@swmansion/popcorn 0.3.2 → 0.4.0-next.0

package/dist/plugins/esbuild.mjs

@@ -1,54 +1,59 @@
-import { mkdir, copyFile } from 'fs/promises';
-import { dirname, resolve, basename, join } from 'path';
-import { fileURLToPath } from 'url';
+import { mkdir, cp, rm } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { p as popcorn$1, c as copyRuntime } from './shared.mjs';
+import 'node:child_process';
+import 'node:os';
+import 'node:util';
+import 'node:url';
+import 'node:zlib';
 
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-// Plugin is at dist/plugins/esbuild.mjs, dist/ is one level up
-const popcornDistDir = resolve(__dirname$1, "..");
+/**
+ * Copies the worker, VM runtime, and `otp/` assets into the output directory after a successful esbuild build.
+ *
+ * Requires `format: "esm"` and either `outdir` or `outfile`.
+ * If the application bundle is elsewhere, set `PopcornOpts.workerUrl` to the copied `worker.mjs`.
+ *
+ * @see {@link Options} for application packaging and server requirements.
+ */
 function popcorn(options) {
-    const bundles = options.bundlePaths.map((p) => ({
-        name: basename(p),
-        dir: dirname(p),
-    }));
     let outputDir;
     return {
-        name: "popcorn",
+        name: "popcorn-otp",
         setup(build) {
             build.onStart(() => {
                 const opts = build.initialOptions;
-                const isEsm = opts.format === "esm";
-                const outdirFallback = opts.outfile !== undefined ? dirname(opts.outfile) : undefined;
-                const outdir = opts.outdir ?? outdirFallback;
-                if (!isEsm) {
-                    throw new Error("[popcorn] Popcorn works only with esm type builds.");
-                }
-                if (outdir === undefined) {
-                    throw new Error("[popcorn] outdir is not specified, cannot copy files");
-                }
-                outputDir = outdir;
+                const outdir = opts.outdir ??
+                    (opts.outfile === undefined ? undefined : dirname(opts.outfile));
+                assert(opts.format === "esm", "Popcorn OTP works only with esm builds.");
+                assert(outdir !== undefined, "outdir is not specified, cannot copy files");
+                outputDir = resolve(outdir);
             });
-            build.onEnd(async () => {
-                await mkdir(outputDir, { recursive: true });
+            build.onEnd(async (result) => {
+                if (result.errors.length > 0)
+                    return;
+                assert(outputDir !== undefined, "outdir was not resolved");
+                const outDir = outputDir;
+                const prepared = await popcorn$1(options);
                 try {
+                    await mkdir(outDir, { recursive: true });
                     await Promise.all([
-                        // Copy bundles to output directory
-                        ...bundles.map((b) => copy(b.name, { inDir: b.dir, outDir: outputDir })),
-                        // Copy popcorn runtime files to output directory
-                        // These need to be alongside the bundled code for import.meta.url to work
-                        copy("iframe.mjs", { inDir: popcornDistDir, outDir: outputDir }),
-                        copy("AtomVM.mjs", { inDir: popcornDistDir, outDir: outputDir }),
-                        copy("AtomVM.wasm", { inDir: popcornDistDir, outDir: outputDir }),
+                        copyRuntime(outDir, prepared.runtimeVariant),
+                        cp(resolve(prepared.dir, "otp"), resolve(outDir, "otp"), {
+                            recursive: true,
+                        }),
                     ]);
                 }
-                catch (err) {
-                    throw new Error("[popcorn] Failed to copy files", { cause: err });
+                finally {
+                    await rm(prepared.dir, { recursive: true, force: true });
                 }
             });
         },
     };
 }
-async function copy(name, { inDir, outDir }) {
-    return copyFile(join(inDir, name), join(outDir, name));
+function assert(ok, message) {
+    if (!ok) {
+        throw new Error(`[popcorn-otp] ${message}`);
+    }
 }
 
 export { popcorn };

package/dist/plugins/rollup.d.ts

@@ -1,3 +1,11 @@
 import type { Plugin } from "rollup";
-import { type PopcornPluginOptions } from "./shared";
-export declare function popcorn(options: PopcornPluginOptions): Plugin<unknown>;
+import { type Options } from "./shared";
+/**
+ * Copies the worker, VM runtime, and `otp/` assets into the output directory after Rollup writes the bundle.
+ *
+ * Requires `output.format: "es"` and either `output.dir` or `output.file`.
+ * If the application bundle is elsewhere, set `PopcornOpts.workerUrl` to the copied `worker.mjs`.
+ *
+ * @see {@link Options} for application packaging and server requirements.
+ */
+export declare function popcorn(options: Options): Plugin;

package/dist/plugins/rollup.mjs

@@ -1,35 +1,56 @@
-import { readFile } from 'fs/promises';
-import { dirname, resolve, basename } from 'path';
-import { fileURLToPath } from 'url';
+import { mkdir, cp, rm } from 'node:fs/promises';
+import { resolve, dirname } from 'node:path';
+import { p as popcorn$1, c as copyRuntime } from './shared.mjs';
+import 'node:child_process';
+import 'node:os';
+import 'node:util';
+import 'node:url';
+import 'node:zlib';
 
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-// Plugin is at dist/plugins/rollup.mjs, dist/ is one level up
-const popcornDistDir = resolve(__dirname$1, "..");
+/**
+ * Copies the worker, VM runtime, and `otp/` assets into the output directory after Rollup writes the bundle.
+ *
+ * Requires `output.format: "es"` and either `output.dir` or `output.file`.
+ * If the application bundle is elsewhere, set `PopcornOpts.workerUrl` to the copied `worker.mjs`.
+ *
+ * @see {@link Options} for application packaging and server requirements.
+ */
 function popcorn(options) {
-    const bundles = options.bundlePaths.map((p) => ({
-        path: p,
-        name: basename(p),
-    }));
+    let outputDir;
     return {
-        name: "popcorn",
-        async generateBundle() {
-            // Emit bundles
-            for (const bundle of bundles) {
-                this.emitFile({
-                    type: "asset",
-                    fileName: resolve(popcornDistDir, bundle.name),
-                    source: await readFile(bundle.path),
-                });
+        name: "popcorn-otp",
+        renderStart(outputOptions) {
+            assert(outputOptions.format === "es", "Popcorn OTP works only with esm builds.");
+            let dir = outputOptions.dir;
+            if (dir === undefined && outputOptions.file !== undefined) {
+                dir = dirname(outputOptions.file);
             }
-            // Emit popcorn runtime files to output directory
-            // These need to be alongside the bundled code for import.meta.url to work
-            for (const name of ["iframe.mjs", "AtomVM.mjs", "AtomVM.wasm"]) {
-                const sourcePath = resolve(popcornDistDir, name);
-                const source = await readFile(sourcePath);
-                this.emitFile({ type: "asset", fileName: name, source });
+            assert(dir !== undefined, "output dir is not specified, cannot copy files");
+            outputDir = resolve(dir);
+        },
+        async writeBundle() {
+            assert(outputDir !== undefined, "output dir was not resolved");
+            const outDir = outputDir;
+            const prepared = await popcorn$1(options);
+            try {
+                await mkdir(outDir, { recursive: true });
+                await Promise.all([
+                    copyRuntime(outDir, prepared.runtimeVariant),
+                    cp(resolve(prepared.dir, "otp"), resolve(outDir, "otp"), {
+                        recursive: true,
+                    }),
+                ]);
+            }
+            finally {
+                await rm(prepared.dir, { recursive: true, force: true });
             }
         },
     };
 }
+function assert(ok, message) {
+    if (!ok) {
+        throw new Error(`[popcorn-otp] ${message}`);
+    }
+}
 
 export { popcorn };

package/dist/plugins/shared.d.ts

@@ -1,7 +1,57 @@
-export declare const DIST_DIR = "node_modules/@swmansion/popcorn/dist";
-export type PopcornPluginOptions = {
+/**
+ * Shared options for the Vite, Rollup, and esbuild plugins.
+ *
+ * Compile the project before the plugin runs.
+ * The plugins use the local `mix` executable to package applications and dependencies.
+ *
+ * On the production server, set `Cross-Origin-Opener-Policy: same-origin` and `Cross-Origin-Embedder-Policy: require-corp`.
+ * Serve compressed variants with the matching `Content-Encoding` header.
+ */
+type RuntimeVariant = "core" | "crypto";
+export type Options = {
     /**
-     * Paths to .avm bundle files.
+     * Runtime variant override.
+     *
+     * By default, the plugin selects `crypto` when an application requires it and `core` otherwise.
      */
-    bundlePaths: string[];
+    runtimeVariant?: RuntimeVariant;
+    /**
+     * Mix project directory.
+     *
+     * Reads compiled apps from `_build/$MIX_ENV/lib`, with `MIX_ENV` defaulting to `dev`.
+     */
+    rootDir: string;
+    /**
+     * OTP application to start after VM boot.
+     *
+     * Use `null` to boot without an entrypoint application.
+     */
+    app: string | null;
+    /**
+     * Additional applications to package with their dependencies.
+     *
+     * Does not start them automatically. Defaults to `[]`.
+     */
+    extraApps?: string[];
+    /**
+     * Adds Brotli tarball variants beside the gzip and uncompressed files.
+     *
+     * Defaults to `false`.
+     */
+    brotli?: boolean;
+    /**
+     * Removes nonessential BEAM chunks.
+     *
+     * Experimental. Defaults to `true`.
+     */
+    strip?: boolean;
+};
+export type Prepared = {
+    dir: string;
+    runtimeVariant: RuntimeVariant;
+    notes: unknown[];
 };
+export declare function popcorn(opts: Options): Promise<Prepared>;
+export declare function runtimeDirectory(variant: RuntimeVariant): string;
+export declare function copyRuntime(targetDir: string, variant: RuntimeVariant): Promise<void>;
+export {};

package/dist/plugins/shared.mjs

@@ -0,0 +1,207 @@
+import { execFile } from 'node:child_process';
+import { mkdtemp, rm, mkdir, writeFile, copyFile, readFile } from 'node:fs/promises';
+import { resolve, dirname, normalize, basename } from 'node:path';
+import { tmpdir } from 'node:os';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import { brotliCompress, gzip, constants } from 'node:zlib';
+
+const execFileAsync = promisify(execFile);
+const brotliCompressAsync = promisify(brotliCompress);
+const gzipAsync = promisify(gzip);
+async function popcorn(opts) {
+    const useBrotli = opts.brotli ?? false;
+    const strip = opts.strip ?? true;
+    const assetVariants = [
+        "uncompressed",
+        "gzip",
+        useBrotli && "brotli",
+    ];
+    const preparedDir = await mkdtemp(p `${tmpdir()}/popcorn-otp-`);
+    try {
+        const report = await withTmp(async (packedDir) => {
+            const report = await packTarballs({
+                rootDir: resolve(opts.rootDir),
+                outDir: packedDir,
+                runtimeVariant: opts.runtimeVariant,
+                app: opts.app,
+                extraApps: opts.extraApps ?? [],
+                strip,
+            });
+            if (!report.ok) {
+                throw new Error(`[popcorn-otp] ${formatPackError(report.error)}`);
+            }
+            await Promise.all([
+                copy(report.manifestPath, p `${preparedDir}/otp/manifest.json`),
+                copy(report.bootPath, p `${preparedDir}/otp/bin/vm.boot`),
+                copy(report.tarPaths, p `${preparedDir}/otp/lib`, {
+                    variants: assetVariants,
+                }),
+            ]);
+            return report;
+        });
+        return {
+            dir: preparedDir,
+            runtimeVariant: report.runtimeVariant,
+            notes: report.notes ?? [],
+        };
+    }
+    catch (error) {
+        await rm(preparedDir, { recursive: true, force: true });
+        throw error;
+    }
+}
+function runtimeDirectory(variant) {
+    if (variant !== "core" && variant !== "crypto") {
+        throw new Error(`[popcorn-otp] Unknown runtime variant: ${variant}`);
+    }
+    return p `${dirname(fileURLToPath(import.meta.url))}/../runtimes/${variant}`;
+}
+async function copyRuntime(targetDir, variant) {
+    const distDir = p `${dirname(fileURLToPath(import.meta.url))}/..`;
+    const runtimeDir = runtimeDirectory(variant);
+    await Promise.all(["worker.mjs", "beam.mjs", "beam.emu.mjs", "beam.wasm"].map((file) => copy(p `${file === "worker.mjs" ? distDir : runtimeDir}/${file}`, p `${targetDir}/${file}`)));
+}
+async function packTarballs(opts) {
+    const { rootDir, outDir, runtimeVariant, app, extraApps, strip } = opts;
+    const toolDir = p `${dirname(fileURLToPath(import.meta.url))}/beam_tools`;
+    const packerArgs = [
+        "run",
+        "--no-start",
+        "-e",
+        "Popcorn.BeamTools.CLI.main(System.argv())",
+        "--",
+        "--root-dir",
+        rootDir,
+        "--out-dir",
+        outDir,
+        "--runtimes-dir",
+        p `${toolDir}/../../runtimes`,
+    ];
+    if (runtimeVariant !== undefined) {
+        packerArgs.push("--runtime-variant", runtimeVariant);
+    }
+    if (app !== null) {
+        packerArgs.push("--entrypoint-app", app);
+    }
+    for (const extraApp of extraApps) {
+        packerArgs.push("--extra-app", extraApp);
+    }
+    if (strip) {
+        packerArgs.push("--strip");
+    }
+    const env = {
+        ...process.env,
+        MIX_BUILD_PATH: p `${outDir}/beam_tools_build`,
+        MIX_QUIET: "1",
+    };
+    const { stdout } = await execFileAsync("mix", packerArgs, {
+        cwd: toolDir,
+        env,
+    });
+    return JSON.parse(stdout);
+}
+function hasCode(error, code) {
+    return (typeof error === "object" &&
+        error !== null &&
+        error.code === code);
+}
+function isMissingDepError(error) {
+    return hasCode(error, "missing_dep");
+}
+function isUnsupportedAppsError(error) {
+    return hasCode(error, "unsupported_apps");
+}
+function isMissingExtraAppsError(error) {
+    return hasCode(error, "missing_extra_apps");
+}
+function toolchainOf(error) {
+    if (typeof error !== "object" || error === null) {
+        return undefined;
+    }
+    return error.toolchain;
+}
+function errorLines(error) {
+    if (isMissingDepError(error)) {
+        return [
+            `${error.app} depends on ${error.dep}, which isn't available.`,
+            `BEAM applications come from your project build and your active`,
+            `Erlang/Elixir installation; nothing is bundled with the package.`,
+            `Apps built by your project: ${error.available_apps.join(", ")}.`,
+        ];
+    }
+    if (isUnsupportedAppsError(error)) {
+        const apps = error.apps
+            .map(({ app, capability }) => `${app} (needs ${capability})`)
+            .join(", ");
+        return [
+            `These applications need native support the Wasm runtime wasn't built`,
+            `with: ${apps}.`,
+            `Drop them from your dependencies, or use a runtime built with it.`,
+        ];
+    }
+    if (isMissingExtraAppsError(error)) {
+        return [
+            `Extra apps not found: ${error.apps.join(", ")}.`,
+            `They have to come from your project build or your Erlang/Elixir install.`,
+        ];
+    }
+    return [`packaging failed: ${JSON.stringify(error)}`];
+}
+function formatPackError(error) {
+    const lines = errorLines(error);
+    const toolchain = toolchainOf(error);
+    if (toolchain !== undefined) {
+        lines.push(`Using ${toolchain.executable} (Erlang/OTP ${toolchain.otp}, Elixir ${toolchain.elixir}).`);
+    }
+    return lines.join("\n  ");
+}
+async function copy(source, target, { variants = ["uncompressed"] } = {}) {
+    const sources = typeof source === "string" ? [source] : source;
+    const targetIsDir = typeof source !== "string";
+    await Promise.all(sources.map(async (sourcePath) => {
+        const targetPath = targetIsDir
+            ? p `${target}/${basename(sourcePath)}`
+            : target;
+        await mkdir(dirname(targetPath), { recursive: true });
+        let content;
+        const read = () => (content ??= readFile(sourcePath));
+        await Promise.all(variants
+            .filter((variant) => Boolean(variant))
+            .map(async (variant) => {
+            switch (variant) {
+                case "uncompressed":
+                    await copyFile(sourcePath, targetPath);
+                    break;
+                case "gzip": {
+                    const input = await read();
+                    const buffer = await gzipAsync(input, { level: 9 });
+                    await writeFile(`${targetPath}.gz`, buffer);
+                    break;
+                }
+                case "brotli": {
+                    const Q = constants.BROTLI_PARAM_QUALITY;
+                    const opts = { params: { [Q]: 11 } };
+                    const input = await read();
+                    const buffer = await brotliCompressAsync(input, opts);
+                    await writeFile(`${targetPath}.br`, buffer);
+                    break;
+                }
+            }
+        }));
+    }));
+}
+function p(strings, ...values) {
+    return normalize(String.raw(strings, ...values));
+}
+async function withTmp(f) {
+    const dir = await mkdtemp(p `${tmpdir()}/popcorn-otp-`);
+    try {
+        return await f(dir);
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+
+export { copyRuntime as c, popcorn as p, runtimeDirectory as r };

package/dist/plugins/vite.d.ts

@@ -1,3 +1,18 @@
-import { type PopcornPluginOptions } from "./shared";
 import type { Plugin } from "vite";
-export declare function popcorn(options: PopcornPluginOptions): Plugin;
+import { type Options } from "./shared";
+/**
+ * Serves application assets during developmens.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from "vite";
+ * import { popcorn } from "@swmansion/popcorn/vite";
+ *
+ * export default defineConfig({
+ *   plugins: [popcorn({ rootDir: "../my_app", app: "my_app" })],
+ * });
+ * ```
+ *
+ * @see {@link Options} for production server requirements.
+ */
+export declare function popcorn(options: Options): Plugin;