fx_cast/ext/bin/build.js

"use strict";

const esbuild = require("esbuild");
const fs = require("fs-extra");
const path = require("path");
const minimist = require("minimist");
const webExt = require("web-ext");

const BRIDGE_NAME = "fx_cast_bridge";
const BRIDGE_VERSION = "0.1.0";

const MIRRORING_APP_ID = "19A6F4AE";

const argv = minimist(process.argv.slice(2), {
    boolean: ["package", "watch"],
    string: ["mirroringAppId", "mode"],
    default: {
        package: false,
        watch: false,
        mirroringAppId: MIRRORING_APP_ID,
        mode: "development"
    }
});

if (argv.package && argv.watch) {
    console.error("Cannot package whilst watching files.");
    process.exit(1);
}

// If packaging, use production mode
if (argv.package) {
    argv.mode = "production";
}

// Paths
const rootPath = path.resolve(__dirname, "../");
const srcPath = path.join(rootPath, "src");

const distPath = path.join(rootPath, "../dist/ext/");
const unpackedPath = path.join(distPath, "unpacked");

const outPath = argv.package ? unpackedPath : distPath;

/** @type esbuild.Plugin */
const preactCompatPlugin = {
    /**
     * Handle react/react-dom preact compat modules.
     */
    name: "preact-compat",
    setup(build) {
        const preactPath = path.resolve(
            __dirname,
            "../node_modules/preact/compat/dist/compat.module.js"
        );

        build.onResolve({ filter: /^(react|react-dom)$/ }, args => ({
            path: preactPath
        }));
    }
};

/** @type esbuild.BuildOptions */
const buildOpts = {
    bundle: true,
    target: "firefox64",
    logLevel: "info",
    sourcemap: "inline",

    outdir: outPath,
    outbase: srcPath,

    entryPoints: [
        // Main
        `${srcPath}/background/background.ts`,
        // Media sender
        `${srcPath}/senders/media/index.ts`,
        `${srcPath}/senders/media/overlay/overlayContent.ts`,
        `${srcPath}/senders/media/overlay/overlayContentLoader.ts`,
        // Mirroring sender
        `${srcPath}/senders/mirroring.ts`,
        // Shim
        `${srcPath}/shim/index.ts`,
        `${srcPath}/shim/content.ts`,
        `${srcPath}/shim/contentBridge.ts`,
        // UI
        `${srcPath}/ui/popup/index.tsx`,
        `${srcPath}/ui/options/index.tsx`
    ],
    define: {
        BRIDGE_NAME: `"${BRIDGE_NAME}"`,
        BRIDGE_VERSION: `"${BRIDGE_VERSION}"`,
        MIRRORING_APP_ID: `"${argv.mirroringAppId}"`
    },
    plugins: [preactCompatPlugin]
};

// Set production options
if (argv.mode === "production") {
    buildOpts.minify = true;
    buildOpts.sourcemap = false;
}

/**
 * Handle build results.
 *
 * @param {esbuild.BuildResult} result
 */
function onBuildResult(result) {
    if (result.errors.length) {
        console.error("Build error!");
        return;
    }

    const manifest = JSON.parse(
        fs.readFileSync(`${srcPath}/manifest.json`, { encoding: "utf-8" })
    );

    manifest.content_security_policy =
        argv.mode === "production"
            ? "script-src 'self'; object-src 'self'"
            : "script-src 'self' 'unsafe-eval'; object-src 'self'";

    fs.writeFileSync(`${outPath}/manifest.json`, JSON.stringify(manifest));

    copy(srcPath, outPath, /^(manifest\.json|.*\.(ts|tsx|js|jsx))$/);
}

/**
 * Recursively copy directory contents.
 *
 * @param {string} src Source path
 * @param {string} dest Destination path
 * @param {RegExp} excludeRegex Match for file exclusion
 */
function copy(src, dest, excludeRegex) {
    if (!fs.existsSync(src)) return;

    const stats = fs.statSync(src);
    if (!stats.isDirectory()) {
        const dirName = path.dirname(dest);
        if (!fs.existsSync(dirName)) {
            fs.mkdirSync(dirName, { recursive: true });
        }
        fs.copyFileSync(src, dest);
        return;
    }

    for (const file of fs.readdirSync(src)) {
        if (excludeRegex.test(file)) continue;
        copy(path.join(src, file), path.join(dest, file), excludeRegex);
    }
}

// Clean
fs.removeSync(distPath);

if (argv.watch) {
    esbuild
        .build({
            ...buildOpts,
            watch: {
                onRebuild(_err, result) {
                    return onBuildResult(result);
                }
            }
        })
        .then(onBuildResult);
} else {
    esbuild.build(buildOpts).then(result => {
        onBuildResult(result);

        if (argv.package) {
            webExt.cmd
                .build(
                    {
                        /**
                         * Webpack output at sourceDir is built into an extension
                         * archive at artifactsDir.
                         */
                        sourceDir: unpackedPath,
                        artifactsDir: distPath,
                        overwriteDest: true
                    },
                    {
                        // Prevent auto-exit
                        shouldExitProgram: false
                    }
                )
                .then(result => {
                    const outputName = path.basename(result.extensionPath);

                    // Rename output extension to XPI
                    fs.moveSync(
                        path.join(distPath, outputName),
                        path.join(distPath, outputName.replace("zip", "xpi"))
                    );

                    // Only need the built extension archive
                    fs.remove(unpackedPath);
                });
        }
    });
}