@git.zone/tsbundle 2.11.4 → 2.12.0

package/dist_ts/mod_esbuild/index.child.d.ts

@@ -1,12 +1,8 @@
+import * as interfaces from '../interfaces/index.js';
 export declare class TsBundleProcess {
     constructor();
     getAliases(): Promise<Record<string, string>>;
-    /**
-     * creates a bundle for the test enviroment
-     */
-    buildTest(fromArg: string, toArg: string, argvArg: any): Promise<void>;
-    /**
-     * creates a bundle for the production environment
-     */
-    buildProduction(fromArg: string, toArg: string, argvArg: any): Promise<void>;
+    private build;
+    buildTest(fromArg: string, toArg: string, argvArg: interfaces.ICliOptions): Promise<void>;
+    buildProduction(fromArg: string, toArg: string, argvArg: interfaces.ICliOptions): Promise<void>;
 }

package/dist_ts/mod_esbuild/index.child.js

@@ -2,6 +2,8 @@ import * as plugins from './plugins.js';
 import * as paths from '../paths.js';
 import * as interfaces from '../interfaces/index.js';
 import { logger } from '../tsbundle.logging.js';
+import { workerPlugin } from './workerplugin.js';
+import { cleanupBuildStage, createBuildStage, getChunkNamespace, publishGeneratedArtifacts, } from '../mod_output/artifactpublisher.js';
 export class TsBundleProcess {
     constructor() {
         // Nothing here
@@ -24,54 +26,56 @@ export class TsBundleProcess {
             }
             return aliasObject;
         }
-        catch (error) {
+        catch {
             return {};
         }
     }
-    /**
-     * creates a bundle for the test enviroment
-     */
+    async build(fromArg, toArg, argvArg, productionArg) {
+        const logicalOutputName = plugins.path.basename(argvArg.chunkOwner || toArg);
+        const chunkNamespace = getChunkNamespace(logicalOutputName);
+        const outputDirectory = plugins.path.dirname(toArg);
+        const stage = createBuildStage(outputDirectory);
+        const stageMainPath = plugins.path.join(stage.stageDirectory, plugins.path.basename(toArg));
+        try {
+            await plugins.esbuild.build({
+                absWorkingDir: process.cwd(),
+                entryPoints: [fromArg],
+                bundle: true,
+                sourcemap: argvArg.sourcemap !== false,
+                format: 'esm',
+                target: 'es2022',
+                minify: productionArg,
+                keepNames: true,
+                entryNames: plugins.path.parse(toArg).name,
+                outdir: stage.stageDirectory,
+                tsconfig: paths.tsconfigPath,
+                splitting: false,
+                treeShaking: false,
+                chunkNames: `chunks/${chunkNamespace}/[name]-[hash]`,
+                alias: await this.getAliases(),
+                plugins: [workerPlugin()],
+            });
+            await publishGeneratedArtifacts({
+                sourceDirectory: stage.stageDirectory,
+                sourceMainPath: stageMainPath,
+                targetPath: toArg,
+                logicalOutputName,
+                chunkNamespace,
+                sourceMapsEnabled: argvArg.sourcemap !== false,
+            });
+        }
+        finally {
+            cleanupBuildStage(stage.stageDirectory, outputDirectory, stage.marker);
+        }
+    }
     async buildTest(fromArg, toArg, argvArg) {
-        // create a bundle
-        const esbuild = await plugins.esbuild.build({
-            entryPoints: [fromArg],
-            bundle: true,
-            sourcemap: argvArg.sourcemap !== false,
-            format: 'esm',
-            target: 'es2022',
-            keepNames: true,
-            entryNames: plugins.path.parse(toArg).name,
-            outdir: plugins.path.parse(toArg).dir,
-            splitting: false,
-            treeShaking: false,
-            tsconfig: paths.tsconfigPath,
-            alias: await this.getAliases(),
-        });
+        await this.build(fromArg, toArg, argvArg, false);
     }
-    /**
-     * creates a bundle for the production environment
-     */
     async buildProduction(fromArg, toArg, argvArg) {
-        // create a bundle
         console.log('esbuild specific:');
         console.log(`from: ${fromArg}`);
         console.log(`to: ${toArg}`);
-        const esbuild = await plugins.esbuild.build({
-            entryPoints: [fromArg],
-            bundle: true,
-            sourcemap: argvArg.sourcemap !== false,
-            format: 'esm',
-            target: 'es2022',
-            minify: true,
-            keepNames: true,
-            entryNames: plugins.path.parse(toArg).name,
-            outdir: plugins.path.parse(toArg).dir,
-            tsconfig: paths.tsconfigPath,
-            splitting: false,
-            treeShaking: false,
-            chunkNames: 'chunks/[name]-[hash]',
-            alias: await this.getAliases(),
-        });
+        await this.build(fromArg, toArg, argvArg, true);
     }
 }
 const run = async () => {
@@ -101,10 +105,13 @@ const run = async () => {
         console.error('\n\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m');
         console.error('\x1b[31m❌ BUILD FAILED\x1b[0m');
         console.error('\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m\n');
-        if (error.errors && Array.isArray(error.errors)) {
+        const errorData = typeof error === 'object' && error !== null
+            ? error
+            : undefined;
+        if (Array.isArray(errorData?.errors)) {
             // esbuild errors - format them nicely
-            console.error(`Found ${error.errors.length} error(s):\n`);
-            for (const err of error.errors) {
+            console.error(`Found ${errorData.errors.length} error(s):\n`);
+            for (const err of errorData.errors) {
                 const file = err.location?.file || 'unknown';
                 const line = err.location?.line || '?';
                 const column = err.location?.column || '?';
@@ -113,11 +120,11 @@ const run = async () => {
             }
         }
         else {
-            console.error(error.message || error);
+            console.error(errorData?.message || error);
         }
         console.error('\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m\n');
         process.exit(1);
     }
 };
 run();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_esbuild/plugins.d.ts

@@ -1,3 +1,6 @@
 export * from '../plugins.js';
-import esbuild from 'esbuild';
-export { esbuild };
+import esbuild, { type BuildOptions, type Loader, type Plugin } from 'esbuild';
+import MagicString from 'magic-string';
+import ts from 'typescript';
+export { esbuild, MagicString, ts };
+export type { BuildOptions, Loader, Plugin };

package/dist_ts/mod_esbuild/plugins.js

@@ -1,4 +1,6 @@
 export * from '../plugins.js';
-import esbuild from 'esbuild';
-export { esbuild };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL21vZF9lc2J1aWxkL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUM7QUFFOUIsT0FBTyxPQUFPLE1BQU0sU0FBUyxDQUFDO0FBRTlCLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQyJ9
+import esbuild, {} from 'esbuild';
+import MagicString from 'magic-string';
+import ts from 'typescript';
+export { esbuild, MagicString, ts };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL21vZF9lc2J1aWxkL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUM7QUFFOUIsT0FBTyxPQUFPLEVBQUUsRUFJZixNQUFNLFNBQVMsQ0FBQztBQUNqQixPQUFPLFdBQVcsTUFBTSxjQUFjLENBQUM7QUFDdkMsT0FBTyxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRTVCLE9BQU8sRUFBRSxPQUFPLEVBQUUsV0FBVyxFQUFFLEVBQUUsRUFBRSxDQUFDIn0=

package/dist_ts/mod_esbuild/workerplugin.d.ts

@@ -0,0 +1,12 @@
+import * as plugins from './plugins.js';
+interface IWorkerPluginOptions {
+    constructors?: string[];
+}
+interface IWorkerBuildState {
+    dependencyGraph: Map<string, Set<string>>;
+    emittedWorkers: Map<string, Promise<string>>;
+    parentKey: string;
+    parentOutputDirectory: string;
+}
+export declare const workerPlugin: ({ constructors, }?: IWorkerPluginOptions, stateArg?: IWorkerBuildState) => plugins.Plugin;
+export {};

package/dist_ts/mod_esbuild/workerplugin.js

@@ -0,0 +1,254 @@
+/*
+ * Derived from @chialab/esbuild-plugin-worker 0.19.2.
+ * Copyright (c) 2021 Chialab. Licensed under the MIT License.
+ * See third-party-notices.md in the published package.
+ */
+import * as plugins from './plugins.js';
+const rootWorkerKey = 'tsbundle:main';
+const hasDependencyPath = (graphArg, fromKeyArg, targetKeyArg, visitedArg = new Set()) => {
+    if (fromKeyArg === targetKeyArg) {
+        return true;
+    }
+    if (visitedArg.has(fromKeyArg)) {
+        return false;
+    }
+    visitedArg.add(fromKeyArg);
+    for (const dependencyKey of graphArg.get(fromKeyArg) || []) {
+        if (hasDependencyPath(graphArg, dependencyKey, targetKeyArg, visitedArg)) {
+            return true;
+        }
+    }
+    return false;
+};
+const addWorkerDependency = (graphArg, parentKeyArg, childKeyArg) => {
+    if (hasDependencyPath(graphArg, childKeyArg, parentKeyArg)) {
+        throw new Error(`Cyclic module-worker dependency detected: ${parentKeyArg} -> ${childKeyArg}`);
+    }
+    const dependencies = graphArg.get(parentKeyArg) || new Set();
+    dependencies.add(childKeyArg);
+    graphArg.set(parentKeyArg, dependencies);
+};
+const getLoader = (filePathArg) => {
+    switch (plugins.path.extname(filePathArg)) {
+        case '.tsx':
+            return 'tsx';
+        case '.jsx':
+            return 'jsx';
+        case '.ts':
+        case '.mts':
+        case '.cts':
+            return 'ts';
+        default:
+            return 'js';
+    }
+};
+const getScriptKind = (filePathArg) => {
+    switch (plugins.path.extname(filePathArg)) {
+        case '.tsx':
+            return plugins.ts.ScriptKind.TSX;
+        case '.jsx':
+            return plugins.ts.ScriptKind.JSX;
+        case '.ts':
+        case '.mts':
+        case '.cts':
+            return plugins.ts.ScriptKind.TS;
+        default:
+            return plugins.ts.ScriptKind.JS;
+    }
+};
+const isImportMetaUrl = (nodeArg) => {
+    return plugins.ts.isPropertyAccessExpression(nodeArg)
+        && nodeArg.name.text === 'url'
+        && plugins.ts.isMetaProperty(nodeArg.expression)
+        && nodeArg.expression.keywordToken === plugins.ts.SyntaxKind.ImportKeyword
+        && nodeArg.expression.name.text === 'meta';
+};
+const getWorkerConstructorName = (nodeArg) => {
+    if (plugins.ts.isIdentifier(nodeArg)) {
+        return nodeArg.text;
+    }
+    if (plugins.ts.isPropertyAccessExpression(nodeArg)
+        && plugins.ts.isIdentifier(nodeArg.expression)
+        && ['window', 'globalThis', 'self', 'global'].includes(nodeArg.expression.text)) {
+        return nodeArg.name.text;
+    }
+    return undefined;
+};
+const isModuleWorker = (optionsArg) => {
+    if (!optionsArg || !plugins.ts.isObjectLiteralExpression(optionsArg)) {
+        return false;
+    }
+    return optionsArg.properties.some((property) => (plugins.ts.isPropertyAssignment(property)
+        && property.name.getText() === 'type'
+        && plugins.ts.isStringLiteral(property.initializer)
+        && property.initializer.text === 'module'));
+};
+export const workerPlugin = ({ constructors = ['Worker', 'SharedWorker'], } = {}, stateArg) => {
+    const state = stateArg || {
+        dependencyGraph: new Map(),
+        emittedWorkers: new Map(),
+        parentKey: rootWorkerKey,
+        parentOutputDirectory: '',
+    };
+    const plugin = {
+        name: 'tsbundle-worker',
+        setup(pluginBuild) {
+            pluginBuild.onLoad({
+                filter: /\.[cm]?[jt]sx?$/,
+                namespace: 'file',
+            }, async (args) => {
+                const code = await plugins.fsPromises.readFile(args.path, 'utf8');
+                if (!constructors.some((constructorName) => code.includes(`new ${constructorName}`))) {
+                    return undefined;
+                }
+                const sourceFile = plugins.ts.createSourceFile(args.path, code, plugins.ts.ScriptTarget.Latest, true, getScriptKind(args.path));
+                const localClasses = new Set();
+                const symbols = new Map();
+                const references = [];
+                const collectDeclarations = (node) => {
+                    if (plugins.ts.isClassDeclaration(node) && node.name) {
+                        localClasses.add(node.name.text);
+                    }
+                    else if (plugins.ts.isVariableDeclaration(node)
+                        && plugins.ts.isIdentifier(node.name)
+                        && node.initializer
+                        && plugins.ts.isStringLiteral(node.initializer)) {
+                        symbols.set(node.name.text, node.initializer.text);
+                    }
+                    plugins.ts.forEachChild(node, collectDeclarations);
+                };
+                collectDeclarations(sourceFile);
+                const collectReferences = (node) => {
+                    if (plugins.ts.isNewExpression(node)) {
+                        const constructorName = getWorkerConstructorName(node.expression);
+                        const argument = node.arguments?.[0];
+                        if (constructorName
+                            && constructors.includes(constructorName)
+                            && !localClasses.has(constructorName)
+                            && argument
+                            && plugins.ts.isNewExpression(argument)
+                            && plugins.ts.isIdentifier(argument.expression)
+                            && argument.expression.text === 'URL'
+                            && argument.arguments?.length === 2
+                            && isImportMetaUrl(argument.arguments[1])) {
+                            const reference = argument.arguments[0];
+                            const value = plugins.ts.isStringLiteral(reference)
+                                ? reference.text
+                                : plugins.ts.isIdentifier(reference)
+                                    ? symbols.get(reference.text)
+                                    : undefined;
+                            if (value) {
+                                references.push({
+                                    argument,
+                                    module: isModuleWorker(node.arguments?.[1]),
+                                    value,
+                                });
+                            }
+                        }
+                    }
+                    plugins.ts.forEachChild(node, collectReferences);
+                };
+                collectReferences(sourceFile);
+                if (references.length === 0) {
+                    return undefined;
+                }
+                const outdir = pluginBuild.initialOptions.outdir;
+                const chunkNames = pluginBuild.initialOptions.chunkNames;
+                if (!outdir || !chunkNames) {
+                    throw new Error('Module workers require esbuild outdir and chunkNames options.');
+                }
+                const workerEntryPattern = chunkNames.replace('[name]', 'worker');
+                const workerOutputDirectoryRaw = plugins.path.dirname(workerEntryPattern);
+                const workerOutputDirectory = workerOutputDirectoryRaw === '.'
+                    ? ''
+                    : workerOutputDirectoryRaw;
+                if (plugins.path.isAbsolute(workerOutputDirectory)
+                    || workerOutputDirectory === '..'
+                    || workerOutputDirectory.startsWith(`..${plugins.path.sep}`)
+                    || /\[[^\]]+\]/.test(workerOutputDirectory)) {
+                    throw new Error(`Module-worker output directory must stay fixed within esbuild outdir: ${chunkNames}`);
+                }
+                const magicString = new plugins.MagicString(code);
+                const watchFiles = new Set([args.path]);
+                for (const reference of references) {
+                    const resolved = await pluginBuild.resolve(reference.value, {
+                        kind: 'dynamic-import',
+                        importer: args.path,
+                        namespace: 'file',
+                        resolveDir: plugins.path.dirname(args.path),
+                    });
+                    if (resolved.external) {
+                        continue;
+                    }
+                    if (!resolved.path) {
+                        throw new Error(`Unable to resolve worker entry '${reference.value}' from ${args.path}.`);
+                    }
+                    watchFiles.add(resolved.path);
+                    const canonicalWorkerPath = await plugins.fsPromises.realpath(resolved.path);
+                    const cacheKey = `${reference.module ? 'module' : 'classic'}:${canonicalWorkerPath}`;
+                    addWorkerDependency(state.dependencyGraph, state.parentKey, cacheKey);
+                    let emittedWorkerPromise = state.emittedWorkers.get(cacheKey);
+                    if (!emittedWorkerPromise) {
+                        emittedWorkerPromise = (async () => {
+                            const initialOptions = pluginBuild.initialOptions;
+                            const workerResult = await plugins.esbuild.build({
+                                ...initialOptions,
+                                entryPoints: [resolved.path],
+                                stdin: undefined,
+                                outfile: undefined,
+                                outdir,
+                                entryNames: workerEntryPattern,
+                                bundle: true,
+                                format: reference.module ? 'esm' : 'iife',
+                                platform: initialOptions.platform || 'browser',
+                                splitting: false,
+                                metafile: true,
+                                write: true,
+                                plugins: [workerPlugin({ constructors }, {
+                                        dependencyGraph: state.dependencyGraph,
+                                        emittedWorkers: state.emittedWorkers,
+                                        parentKey: cacheKey,
+                                        parentOutputDirectory: workerOutputDirectory,
+                                    })],
+                            });
+                            const outputEntry = Object.entries(workerResult.metafile.outputs).find(([, output]) => (!!output.entryPoint && !output.cssBundle));
+                            if (!outputEntry) {
+                                throw new Error(`Worker build produced no JavaScript output for ${resolved.path}.`);
+                            }
+                            const outputPath = plugins.path.isAbsolute(outputEntry[0])
+                                ? outputEntry[0]
+                                : plugins.path.resolve(initialOptions.absWorkingDir || process.cwd(), outputEntry[0]);
+                            const relativeOutputPath = plugins.path.relative(outdir, outputPath);
+                            if (relativeOutputPath === '..'
+                                || relativeOutputPath.startsWith(`..${plugins.path.sep}`)
+                                || plugins.path.isAbsolute(relativeOutputPath)) {
+                                throw new Error(`Worker output escaped esbuild outdir: ${outputPath}`);
+                            }
+                            return relativeOutputPath;
+                        })();
+                        state.emittedWorkers.set(cacheKey, emittedWorkerPromise);
+                    }
+                    const emittedWorker = await emittedWorkerPromise;
+                    const relativeWorkerPath = plugins.path.relative(state.parentOutputDirectory || '.', emittedWorker).split(plugins.path.sep).join('/');
+                    const workerUrl = relativeWorkerPath.startsWith('.')
+                        ? relativeWorkerPath
+                        : `./${relativeWorkerPath}`;
+                    magicString.overwrite(reference.argument.getStart(sourceFile), reference.argument.end, `new URL('${workerUrl}', import.meta.url).href`);
+                }
+                const sourceMap = magicString.generateMap({
+                    source: plugins.path.basename(args.path),
+                    includeContent: true,
+                    hires: true,
+                });
+                return {
+                    contents: `${magicString.toString()}\n//# sourceMappingURL=${sourceMap.toUrl()}`,
+                    loader: getLoader(args.path),
+                    resolveDir: plugins.path.dirname(args.path),
+                    watchFiles: [...watchFiles],
+                };
+            });
+        },
+    };
+    return plugin;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workerplugin.js","sourceRoot":"","sources":["../../ts/mod_esbuild/workerplugin.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_output/artifactpublisher.d.ts

@@ -0,0 +1,43 @@
+export declare const chunkManifestFile = ".tsbundle-artifacts.json";
+export interface IProcessOwnership {
+    leaseManaged?: boolean;
+    processId: number;
+    processIdentity?: string;
+}
+interface IBuildStageMarker extends IProcessOwnership {
+    owner: string;
+    kind: string;
+    createdAt: string;
+    invocationId: string;
+    schemaVersion: 1;
+}
+export interface IAdditionalArtifact {
+    sourcePath: string;
+    targetPath: string;
+}
+interface IPublishGeneratedArtifactsOptions {
+    additionalArtifacts?: IAdditionalArtifact[];
+    chunkNamespace: string;
+    lockTargetPath?: string;
+    logicalOutputName: string;
+    sourceDirectory: string;
+    sourceMainPath: string;
+    sourceMapsEnabled: boolean;
+    targetPath: string;
+}
+export declare const getProcessIdentity: (processIdArg: number) => string | undefined;
+export declare const createProcessOwnership: () => Required<IProcessOwnership>;
+export declare const isProcessOwnershipActive: (ownershipArg: IProcessOwnership, markerPathArg: string, leaseTimeoutMsArg: number) => boolean;
+export declare const startOwnershipHeartbeat: (markerPathArg: string) => (() => void);
+export declare const withArtifactPublicationLock: <T>(targetPathArg: string, callbackArg: () => Promise<T>) => Promise<T>;
+export declare const withArtifactPublicationLocks: <T>(targetPathArg: string, callbackArg: () => Promise<T>, additionalTargetPathsArg?: string[]) => Promise<T>;
+export declare const writeFileAtomically: (targetPathArg: string, contentArg: string | Buffer, modeArg?: number) => void;
+export declare const getChunkNamespace: (logicalOutputNameArg: string) => string;
+export declare const publishGeneratedArtifacts: (optionsArg: IPublishGeneratedArtifactsOptions) => Promise<void>;
+export declare const cleanupStaleBuildStages: (outputDirectoryArg: string) => void;
+export declare const createBuildStage: (outputDirectoryArg: string) => {
+    marker: IBuildStageMarker;
+    stageDirectory: string;
+};
+export declare const cleanupBuildStage: (stageDirectoryArg: string, outputDirectoryArg: string, expectedMarkerArg: IBuildStageMarker) => void;
+export {};