create-foxglove-extension/dist/build.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.buildCommand = buildCommand;
const fs_1 = require("fs");
const path = __importStar(require("path"));
const webpack_1 = __importDefault(require("webpack"));
const log_1 = require("./log");
const webpackConfigExtension_1 = __importDefault(require("./webpackConfigExtension"));
function objectIsWebpackConfig(obj) {
    return typeof obj === "object" && obj != undefined && "webpack" in obj;
}
async function buildCommand(options = {}) {
    const env = options.mode ?? (process.env.NODE_ENV === "production" ? "production" : "development");
    const extensionPath = path.resolve((options.cwd ?? process.cwd()).replace(/"$/, ""));
    const entryPoint = options.entryPoint ?? "./src/index.ts";
    const configPath = path.join(extensionPath, "config.ts");
    let webpackConfig = (0, webpackConfigExtension_1.default)(extensionPath, entryPoint, env);
    if ((0, fs_1.existsSync)(configPath)) {
        (0, log_1.info)(`Using config file at ${configPath}`);
        const config = await Promise.resolve(`${configPath}`).then(s => __importStar(require(s)));
        if (objectIsWebpackConfig(config)) {
            webpackConfig = config.webpack(webpackConfig);
        }
    }
    const compiler = (0, webpack_1.default)(webpackConfig);
    await new Promise((resolve, reject) => {
        (0, log_1.info)("Building...");
        compiler.run((err, result) => {
            compiler.close(() => {
                if (err) {
                    reject(err);
                    return;
                }
                if (result == undefined) {
                    reject(new Error(`build did not produce any output`));
                    return;
                }
                if (result.hasErrors()) {
                    reject(new Error(`build failed: ${getErrorOutput(result.compilation)}`));
                    return;
                }
                (0, log_1.info)("Build complete");
                resolve();
            });
        });
    });
}
function getErrorOutput(compilation) {
    const warnings = compilation
        .getWarnings()
        .map((warning) => warning.message)
        .join("\n");
    const errors = compilation
        .getErrors()
        .map((error) => error.message)
        .join("\n");
    let output = "";
    if (warnings.length > 0) {
        output += `Warnings:\n${warnings}`;
    }
    if (errors.length > 0) {
        output += `${output.length > 0 ? "\n\n" : ""}Errors:\n${errors}`;
    }
    return output;
}