@hyperfrontend/builder 0.1.0

package/bundle/rollup/worker/index.cjs.js

@@ -0,0 +1,290 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const node_path = require('node:path');
+const commonjs = require('../../../_dependencies/@rollup/plugin-commonjs/index.cjs.js');
+const json = require('../../../_dependencies/@rollup/plugin-json/index.cjs.js');
+const nodeResolve = require('../../../_dependencies/@rollup/plugin-node-resolve/index.cjs.js');
+const terser = require('../../../_dependencies/@rollup/plugin-terser/index.cjs.js');
+const typescript = require('../../../_dependencies/@rollup/plugin-typescript/index.cjs.js');
+const index_cjs_js = require('../../../_dependencies/rollup/index.cjs.js');
+const node_module = require('node:module');
+const { join } = require('../../../_shared/bundle/fs/posix-path/index.cjs.js');
+const { createExternalizeBundledDepsPlugin } = require('../../../_shared/bundle/dependencies/externalize-plugin/index.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+const commonjs__default = /*#__PURE__*/_interopDefaultCompat(commonjs);
+const json__default = /*#__PURE__*/_interopDefaultCompat(json);
+const nodeResolve__default = /*#__PURE__*/_interopDefaultCompat(nodeResolve);
+const terser__default = /*#__PURE__*/_interopDefaultCompat(terser);
+const typescript__default = /*#__PURE__*/_interopDefaultCompat(typescript);
+
+const BYTES_PER_MB = 1024 * 1024;
+const importMatchesWorkspaceRoute = (id, routes) => {
+    /* istanbul ignore if -- @preserve defensive: rollup always populates `exporter` on UNRESOLVED_IMPORT warnings */
+    if (id === undefined)
+        return false;
+    for (const route of routes) {
+        if (id === route.packageName || id.startsWith(`${route.packageName}/`))
+            return true;
+    }
+    return false;
+};
+const onWarnEntry = (warning, defaultHandler, workspaceRoutes) => {
+    // why: under bundleAllDeps the externalize plugin is the sole owner of workspace-dep resolution; an unresolved import of a routed package means it slipped past routing and would ship as a bare external specifier — fail loud rather than emit a broken artifact.
+    if (warning.code === 'UNRESOLVED_IMPORT' && importMatchesWorkspaceRoute(warning.exporter, workspaceRoutes)) {
+        throw new Error(`bundle: workspace import "${warning.exporter}" was not routed into _dependencies/ and would leak as an external import. Confirm it is declared in package.json#dependencies and mapped in tsconfig paths; subpath-only packages require a 'sub-path' workspaceDepPolicy entry.`);
+    }
+    if (warning.plugin === 'typescript' && warning.message?.includes('TS2307'))
+        return;
+    if (warning.code === 'EMPTY_BUNDLE')
+        return;
+    defaultHandler(warning);
+};
+const onWarnBundle = (warning, defaultHandler) => {
+    if (warning.plugin === 'typescript' && warning.message?.includes('TS2307'))
+        return;
+    if (warning.code === 'EMPTY_BUNDLE')
+        return;
+    if (warning.code === 'UNRESOLVED_IMPORT')
+        return;
+    defaultHandler(warning);
+};
+const buildExternalPredicate = (externals) => {
+    const set = new Set(externals);
+    return (id) => set.has(id);
+};
+const buildEntryPlugins = (job, format) => {
+    const plugins = [];
+    const hasWorkspaceRoutes = job.workspaceRoutes.length > 0;
+    if (job.bundledDepsPlugin) {
+        plugins.push(createExternalizeBundledDepsPlugin({
+            deps: job.bundledDepsPlugin.deps,
+            entryOutDir: job.outputDir,
+            format,
+            depsRoot: job.bundledDepsPlugin.depsRoot,
+            workspaceRoutes: job.workspaceRoutes,
+        }));
+    }
+    // why: when workspaceRoutes is populated, the externalize plugin owns @hyperfrontend/* resolution; the typescript plugin's baseUrl path-mapping must not preempt it. Falling through to the paths:{} branch lets externalize win.
+    const useBaseUrlMapping = job.bundleWorkspaceDeps && !hasWorkspaceRoutes;
+    plugins.push(json__default.default(), nodeResolve__default.default({ extensions: ['.ts', '.js'] }), commonjs__default.default(), useBaseUrlMapping ? typescript__default.default({
+        tsconfig: job.tsConfigPath,
+        declaration: false,
+        declarationMap: false,
+        sourceMap: job.sourcemap,
+        compilerOptions: {
+            baseUrl: job.workspaceRoot,
+            outDir: job.outputDir,
+        },
+    }) : typescript__default.default({
+        tsconfig: job.tsConfigPath,
+        declaration: false,
+        declarationMap: false,
+        rootDir: `${job.projectRoot}/src`,
+        outDir: job.outputDir,
+        sourceMap: job.sourcemap,
+        compilerOptions: { paths: {} },
+    }));
+    return plugins;
+};
+const buildBundlePlugins = (job) => [
+    json__default.default(),
+    nodeResolve__default.default({ extensions: ['.ts', '.js'], browser: true, preferBuiltins: false }),
+    commonjs__default.default(),
+    typescript__default.default({
+        tsconfig: job.tsConfigPath,
+        declaration: false,
+        declarationMap: false,
+        sourceMap: true,
+        compilerOptions: {
+            baseUrl: job.workspaceRoot,
+            outDir: job.outputDir,
+        },
+    }),
+];
+const buildEntryOutput = (job, format) => {
+    if (job.bin) {
+        return {
+            file: job.bin.outputFile,
+            format,
+            sourcemap: job.sourcemap,
+            banner: job.bin.banner,
+            footer: job.bin.footer,
+            exports: job.bin.exports,
+            inlineDynamicImports: job.bin.inlineDynamicImports,
+            generatedCode: { constBindings: true },
+            ...(format === 'cjs' && { interop: 'compat' }),
+        };
+    }
+    const filename = format === 'esm' ? 'index.esm.js' : 'index.cjs.js';
+    return {
+        file: node_path.join(job.outputDir, filename),
+        format,
+        sourcemap: job.sourcemap,
+        generatedCode: { constBindings: true },
+        ...(format === 'cjs' && { interop: 'compat' }),
+    };
+};
+const buildEsmJob = (job) => ({
+    config: {
+        input: job.inputFile,
+        external: buildExternalPredicate(job.external),
+        onwarn: (warning, defaultHandler) => onWarnEntry(warning, defaultHandler, job.workspaceRoutes),
+        plugins: buildEntryPlugins(job, 'esm'),
+    },
+    outputs: [buildEntryOutput(job, 'esm')],
+});
+const buildCjsJob = (job) => ({
+    config: {
+        input: job.inputFile,
+        external: buildExternalPredicate(job.external),
+        onwarn: (warning, defaultHandler) => onWarnEntry(warning, defaultHandler, job.workspaceRoutes),
+        plugins: buildEntryPlugins(job, 'cjs'),
+    },
+    outputs: [buildEntryOutput(job, 'cjs')],
+});
+const buildIifeJob = (job) => {
+    const bundle = job.bundle;
+    const outputs = [
+        {
+            file: node_path.join(job.outputDir, 'index.iife.js'),
+            format: 'iife',
+            name: bundle.globalName,
+            sourcemap: job.sourcemap,
+            globals: bundle.globals,
+        },
+    ];
+    if (bundle.minify) {
+        outputs.push({
+            file: node_path.join(job.outputDir, 'index.iife.min.js'),
+            format: 'iife',
+            name: bundle.globalName,
+            sourcemap: job.sourcemap,
+            globals: bundle.globals,
+            plugins: [terser__default.default()],
+        });
+    }
+    return {
+        config: {
+            input: job.inputFile,
+            external: buildExternalPredicate(job.external),
+            onwarn: onWarnBundle,
+            plugins: buildBundlePlugins(job),
+        },
+        outputs,
+    };
+};
+const buildUmdJob = (job) => {
+    const bundle = job.bundle;
+    const base = {
+        format: 'umd',
+        name: bundle.globalName,
+        sourcemap: job.sourcemap,
+        globals: bundle.globals,
+    };
+    if (bundle.amdId)
+        base.amd = { id: bundle.amdId };
+    const outputs = [{ ...base, file: node_path.join(job.outputDir, 'index.umd.js') }];
+    if (bundle.minify) {
+        outputs.push({ ...base, file: node_path.join(job.outputDir, 'index.umd.min.js'), plugins: [terser__default.default()] });
+    }
+    return {
+        config: {
+            input: job.inputFile,
+            external: buildExternalPredicate(job.external),
+            onwarn: onWarnBundle,
+            plugins: buildBundlePlugins(job),
+        },
+        outputs,
+    };
+};
+const buildJob = (job) => {
+    if (job.format === 'esm')
+        return buildEsmJob(job);
+    if (job.format === 'cjs')
+        return buildCjsJob(job);
+    if (job.format === 'iife')
+        return buildIifeJob(job);
+    return buildUmdJob(job);
+};
+const ensureDir = (path) => {
+    node_fs.mkdirSync(path, { recursive: true });
+};
+const safeStatSize = (filePath) => {
+    /* istanbul ignore next -- @preserve defensive: rollup always produces the declared output file */
+    try {
+        return node_fs.statSync(filePath).size;
+    }
+    catch {
+        return 0;
+    }
+};
+/**
+ * Runs a single rollup invocation as described by `job` and writes the
+ * resulting report to `job.reportPath`.
+ *
+ * Use this to drive the worker logic in-process; use {@link dispatchRollupWorker}
+ * to run the same job in a forked Node process.
+ *
+ * @param job - Descriptor describing the rollup invocation.
+ * @returns The on-disk report data the worker would have persisted.
+ *
+ * @example Driving the worker logic in-process for a fixture
+ * ```typescript
+ * const report = await runRollupWorkerJob({ format: 'esm', inputFile: '/abs/in.ts', ... })
+ * ```
+ */
+const runRollupWorkerJob = async (job) => {
+    const startedAt = Date.now();
+    ensureDir(job.outputDir);
+    ensureDir(node_path.dirname(job.reportPath));
+    const { config, outputs } = buildJob(job);
+    const bundle = await index_cjs_js.rollup(config);
+    let totalSize = 0;
+    try {
+        for (const output of outputs) {
+            await bundle.write(output);
+            totalSize += safeStatSize(output.file);
+        }
+    }
+    finally {
+        await bundle.close();
+    }
+    if (job.bin) {
+        node_fs.chmodSync(job.bin.outputFile, job.bin.chmod);
+    }
+    const memory = process.memoryUsage();
+    const report = {
+        outputSize: totalSize,
+        endHeapMB: memory.heapUsed / BYTES_PER_MB,
+        endRssMB: memory.rss / BYTES_PER_MB,
+        durationMs: Date.now() - startedAt,
+    };
+    node_fs.writeFileSync(job.reportPath, JSON.stringify(report));
+    return report;
+};
+
+const isMainModule = () => {
+    if (typeof require !== 'undefined' && typeof module !== 'undefined' && require.main === module) {
+        return true;
+    }
+    const argv1 = process.argv[1] ?? '';
+    return argv1.endsWith('index.cjs.js') || argv1.endsWith('index.esm.js') || argv1.endsWith('index.ts') || argv1.endsWith('index.js');
+};
+if (isMainModule()) {
+    const raw = process.argv[2];
+    if (!raw) {
+        process.stderr.write('rollup worker: missing job spec on argv\n');
+        process.exit(2);
+    }
+    const job = JSON.parse(raw);
+    runRollupWorkerJob(job).then(() => process.exit(0), (error) => {
+        const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        process.stderr.write(`rollup worker for ${job.format}/${job.inputFile} failed: ${message}\n`);
+        process.exit(1);
+    });
+}
+
+exports.runRollupWorkerJob = runRollupWorkerJob;

package/bundle/rollup/worker/index.d.ts

@@ -0,0 +1,131 @@
+import { WorkspaceBundledDepRoute } from '../../dependencies';
+
+/**
+ * Output format the rollup worker produces.
+ */
+type RollupWorkerFormat = 'esm' | 'cjs' | 'iife' | 'umd';
+/**
+ * Externalize-bundled-deps plugin payload carried by ESM / CJS descriptors when
+ * a format opts into `bundleAllDeps`.
+ */
+interface RollupWorkerBundledDepsPlugin {
+    /** Bundled-dep package names whose imports should be rewritten to `_dependencies/<dep>/`. */
+    deps: string[];
+    /** Absolute path to the `_dependencies/` root the plugin maps imports into. */
+    depsRoot: string;
+}
+/**
+ * Bundle-output configuration carried by IIFE / UMD descriptors.
+ *
+ * Captures the format-specific output knobs the worker needs to reconstruct
+ * `OutputOptions` for a self-contained browser bundle.
+ */
+interface RollupWorkerBundleOutput {
+    /** Global variable name exposed by the bundle. */
+    globalName: string;
+    /** Emit a minified twin alongside the unminified bundle. */
+    minify: boolean;
+    /** Global names mapped onto the external dependencies. */
+    globals?: Record<string, string>;
+    /** UMD-only AMD module identifier. */
+    amdId?: string;
+}
+/**
+ * Bin-output configuration carried by ESM / CJS descriptors when the entry is a
+ * `package.json#bin` executable script.
+ *
+ * When set, the worker writes the bundle to {@link outputFile} (instead of the
+ * format's default `index.<fmt>.js` filename), prepends the {@link banner} and
+ * appends the {@link footer}, and applies {@link chmod} to the produced file so
+ * the npm bin symlink is invokable.
+ */
+interface RollupWorkerBin {
+    /** Absolute path the worker writes the bin output to. */
+    outputFile: string;
+    /** Banner string prepended to the output (typically the `#!/usr/bin/env node` shebang). */
+    banner: string;
+    /** Footer string appended to the output (the bootstrap that wires the runner to `process.argv`). */
+    footer: string;
+    /** Rollup `output.exports` mode passed through to `bundle.write`. */
+    exports: 'named' | 'default' | 'auto' | 'none';
+    /** When `true`, dynamic imports are inlined so the bin remains a single self-contained file. */
+    inlineDynamicImports: boolean;
+    /** File mode applied via `chmodSync` after the output is written (e.g. `0o755`). */
+    chmod: number;
+}
+/**
+ * Serializable rollup-build descriptor: the contract between the parent
+ * orchestrator and a forked worker. Every field must round-trip through
+ * `JSON.stringify` / `JSON.parse` — no functions, no class instances.
+ *
+ * The worker reconstructs `RollupOptions` from the descriptor using the same
+ * plugin factories the parent would have used in-process.
+ */
+interface RollupBuildDescriptor {
+    /** Output format. */
+    format: RollupWorkerFormat;
+    /** Absolute path to the source TS/JS entry. */
+    inputFile: string;
+    /** Absolute directory the worker writes its output(s) under. */
+    outputDir: string;
+    /** Pre-resolved external package list. */
+    external: string[];
+    /** Sourcemap toggle threaded into the rollup output. */
+    sourcemap: boolean;
+    /** When set: install the externalize-bundled-deps plugin (esm/cjs only). */
+    bundledDepsPlugin: RollupWorkerBundledDepsPlugin | null;
+    /**
+     * Workspace bundled-dep routes consumed by the externalize plugin. When non-empty,
+     * imports of these workspace packages (and matching sub-paths) are rerouted to
+     * the corresponding `_dependencies/<packageName>(/<sub>)?/index.<ext>` chunk.
+     * Empty array for descriptors that do not opt into workspace-dep hoisting.
+     */
+    workspaceRoutes: WorkspaceBundledDepRoute[];
+    /** Absolute tsconfig path threaded into the typescript plugin. */
+    tsConfigPath: string;
+    /** Absolute project root threaded into the typescript plugin. */
+    projectRoot: string;
+    /** Absolute workspace root threaded into the typescript plugin. */
+    workspaceRoot: string;
+    /** When `true`, workspace deps are inlined; otherwise treated as external. */
+    bundleWorkspaceDeps: boolean;
+    /** Bundle-output config carried by IIFE / UMD descriptors. `null` for esm/cjs. */
+    bundle: RollupWorkerBundleOutput | null;
+    /** Bin-output config carried by ESM / CJS descriptors that emit an executable bin. `null` for non-bin entries. */
+    bin: RollupWorkerBin | null;
+    /** Absolute path the worker writes its JSON report to. */
+    reportPath: string;
+}
+/**
+ * Memory + size summary written to `reportPath` when the worker exits cleanly.
+ */
+interface RollupWorkerReport {
+    /** Total on-disk size of every emitted output, in bytes. */
+    outputSize: number;
+    /** `process.memoryUsage().heapUsed` in MB at end of bundle. */
+    endHeapMB: number;
+    /** `process.memoryUsage().rss` in MB at end of bundle. */
+    endRssMB: number;
+    /** Worker wall-clock duration in ms. */
+    durationMs: number;
+}
+
+/**
+ * Runs a single rollup invocation as described by `job` and writes the
+ * resulting report to `job.reportPath`.
+ *
+ * Use this to drive the worker logic in-process; use {@link dispatchRollupWorker}
+ * to run the same job in a forked Node process.
+ *
+ * @param job - Descriptor describing the rollup invocation.
+ * @returns The on-disk report data the worker would have persisted.
+ *
+ * @example Driving the worker logic in-process for a fixture
+ * ```typescript
+ * const report = await runRollupWorkerJob({ format: 'esm', inputFile: '/abs/in.ts', ... })
+ * ```
+ */
+declare const runRollupWorkerJob: (job: RollupBuildDescriptor) => Promise<RollupWorkerReport>;
+
+export { runRollupWorkerJob };
+export type { RollupBuildDescriptor, RollupWorkerBundleOutput, RollupWorkerFormat, RollupWorkerReport };

package/bundle/rollup/worker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/rollup/worker/index.ts"],"names":[],"mappings":"AAWA,YAAY,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACtH,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA"}