create-foxglove-extension/dist/create.js

Create and package Foxglove extensions

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createCommand = createCommand;
const child_process_1 = require("child_process");
const fs_1 = require("fs");
const promises_1 = require("fs/promises");
const mkdirp_1 = require("mkdirp");
const path = __importStar(require("path"));
const sanitize_filename_1 = __importDefault(require("sanitize-filename"));
const tar = __importStar(require("tar"));
const log_1 = require("./log");
const DEPENDENCIES = [
    "@foxglove/eslint-plugin@^2",
    "@foxglove/extension@^2",
    "@types/react@^18",
    "@types/react-dom@^18",
    "create-foxglove-extension@^1",
    "eslint@^9",
    "prettier@^3",
    "react@^18",
    "react-dom@^18",
    "typescript@^5",
];
async function createCommand(options) {
    const name = options.name;
    if (name !== (0, sanitize_filename_1.default)(name)) {
        throw new Error(`Name "${name}" contains invalid characters. Choose a filename-compatible project name`);
    }
    const cwd = options.cwd ?? process.cwd();
    const dirname = options.dirname ?? __dirname;
    let tempDir;
    try {
        const extensionDir = path.join(cwd, name);
        if (await exists(extensionDir)) {
            throw new Error(`Directory "${extensionDir}" already exists`);
        }
        tempDir = await (0, promises_1.mkdtemp)("extract-template-");
        await tar.extract({
            cwd: tempDir,
            file: path.join(dirname, "template.tar.gz"),
        });
        const templateDir = path.join(tempDir, "template");
        const replacements = new Map([["${NAME}", name]]);
        const files = await listFiles(templateDir);
        for (const file of files) {
            const srcFile = path.resolve(templateDir, file);
            const dstFile = path.resolve(extensionDir, file);
            await copyTemplateFile(srcFile, dstFile, replacements);
        }
        await installDependencies(extensionDir, DEPENDENCIES);
        (0, log_1.info)(`Created Foxglove extension "${name}" at ${extensionDir}`);
    }
    finally {
        if (tempDir) {
            await (0, promises_1.rm)(tempDir, { recursive: true, force: true });
        }
    }
}
async function exists(filename) {
    try {
        await (0, promises_1.access)(filename, fs_1.constants.F_OK);
        return true;
    }
    catch {
        return false;
    }
}
async function listFiles(baseDir, curDir) {
    let output = [];
    const curOrBaseDir = curDir ?? baseDir;
    const contents = await (0, promises_1.readdir)(curOrBaseDir, { withFileTypes: true });
    for (const entry of contents) {
        if (entry.isDirectory()) {
            output = output.concat(await listFiles(baseDir, path.join(curOrBaseDir, entry.name)));
        }
        else if (entry.isFile()) {
            output.push(path.relative(baseDir, path.join(curOrBaseDir, entry.name)));
        }
    }
    return output;
}
async function copyTemplateFile(src, dst, replacements) {
    (0, log_1.info)(`creating ${dst}`);
    let contents = await (0, promises_1.readFile)(src, { encoding: "utf8" });
    for (const [search, replacement] of replacements.entries()) {
        const regex = new RegExp(search.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&"), "g");
        contents = contents.replace(regex, replacement);
    }
    await (0, mkdirp_1.mkdirp)(path.dirname(dst));
    await (0, promises_1.writeFile)(dst, contents);
}
async function installDependencies(extensionDir, deps) {
    const command = "npm";
    const args = ["install", "--save-exact", "--save-dev", ...deps];
    (0, log_1.info)(`${command} ${args.join(" ")}`);
    await new Promise((resolve, reject) => {
        const child = (0, child_process_1.spawn)(command, args, {
            shell: true,
            stdio: "inherit",
            cwd: extensionDir,
            env: { ...process.env },
        });
        child.on("close", (code) => {
            if (code !== 0) {
                reject(new Error(`npm exited with code ${code ?? "<null>"}`));
                return;
            }
            resolve();
        });
    });
}