@git.zone/tsbundle 2.11.4 → 2.13.0

package/ts/mod_esbuild/index.child.ts

@@ -2,13 +2,20 @@ 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
   }
 
-  public async getAliases() {
+  public async getAliases(): Promise<Record<string, string>> {
     try {
       const aliasObject: Record<string, string> = {};
       const tsconfigPath = plugins.path.join(paths.cwd, 'tsconfig.json');
@@ -27,56 +34,74 @@ export class TsBundleProcess {
         }
       }
       return aliasObject;
-    } catch (error) {
+    } catch {
       return {};
     }
   }
 
-  /**
-   * creates a bundle for the test enviroment
-   */
-  public async buildTest(fromArg: string, toArg: string, argvArg: any) {
-    // 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(),
-    });
+  private async build(
+    fromArg: string,
+    toArg: string,
+    argvArg: interfaces.ICliOptions,
+    productionArg: boolean,
+  ): Promise<void> {
+    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,
+        ...(argvArg.banner !== undefined ? {
+          banner: { js: argvArg.banner },
+        } : {}),
+        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);
+    }
   }
 
-  /**
-   * creates a bundle for the production environment
-   */
-  public async buildProduction(fromArg: string, toArg: string, argvArg: any) {
-    // create a bundle
+  public async buildTest(
+    fromArg: string,
+    toArg: string,
+    argvArg: interfaces.ICliOptions,
+  ): Promise<void> {
+    await this.build(fromArg, toArg, argvArg, false);
+  }
+
+  public async buildProduction(
+    fromArg: string,
+    toArg: string,
+    argvArg: interfaces.ICliOptions,
+  ): Promise<void> {
     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);
   }
 }
 
@@ -121,15 +146,24 @@ const run = async () => {
       );
     }
     process.exit(0);
-  } catch (error: any) {
+  } catch (error: unknown) {
     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 as {
+          errors?: Array<{
+            location?: { file?: string; line?: number; column?: number };
+            text: string;
+          }>;
+          message?: string;
+        }
+      : 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 || '?';
@@ -137,7 +171,7 @@ const run = async () => {
         console.error(`    ${err.text}\n`);
       }
     } else {
-      console.error(error.message || error);
+      console.error(errorData?.message || error);
     }
 
     console.error('\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m\n');

package/ts/mod_esbuild/plugins.ts

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

package/ts/mod_esbuild/workerplugin.ts

@@ -0,0 +1,328 @@
+/*
+ * 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';
+
+interface IWorkerPluginOptions {
+  constructors?: string[];
+}
+
+interface IWorkerReference {
+  argument: plugins.ts.NewExpression;
+  module: boolean;
+  value: string;
+}
+
+interface IWorkerBuildState {
+  dependencyGraph: Map<string, Set<string>>;
+  emittedWorkers: Map<string, Promise<string>>;
+  parentKey: string;
+  parentOutputDirectory: string;
+}
+
+const rootWorkerKey = 'tsbundle:main';
+
+const hasDependencyPath = (
+  graphArg: Map<string, Set<string>>,
+  fromKeyArg: string,
+  targetKeyArg: string,
+  visitedArg = new Set<string>(),
+): boolean => {
+  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: Map<string, Set<string>>,
+  parentKeyArg: string,
+  childKeyArg: string,
+): void => {
+  if (hasDependencyPath(graphArg, childKeyArg, parentKeyArg)) {
+    throw new Error(`Cyclic module-worker dependency detected: ${parentKeyArg} -> ${childKeyArg}`);
+  }
+  const dependencies = graphArg.get(parentKeyArg) || new Set<string>();
+  dependencies.add(childKeyArg);
+  graphArg.set(parentKeyArg, dependencies);
+};
+
+const getLoader = (filePathArg: string): plugins.Loader => {
+  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: string): plugins.ts.ScriptKind => {
+  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: plugins.ts.Node): boolean => {
+  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: plugins.ts.Expression): string | undefined => {
+  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: plugins.ts.Expression | undefined): boolean => {
+  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'],
+}: IWorkerPluginOptions = {}, stateArg?: IWorkerBuildState): plugins.Plugin => {
+  const state: IWorkerBuildState = stateArg || {
+    dependencyGraph: new Map<string, Set<string>>(),
+    emittedWorkers: new Map<string, Promise<string>>(),
+    parentKey: rootWorkerKey,
+    parentOutputDirectory: '',
+  };
+
+  const plugin: plugins.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<string>();
+        const symbols = new Map<string, string>();
+        const references: IWorkerReference[] = [];
+
+        const collectDeclarations = (node: plugins.ts.Node): void => {
+          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: plugins.ts.Node): void => {
+          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<string>([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;
+};