@git.zone/tsbundle 2.11.4 → 2.12.0

package/ts/mod_output/index.ts

@@ -1,9 +1,11 @@
 import * as plugins from './plugins.js';
 import * as paths from '../paths.js';
 import * as interfaces from '../interfaces/index.js';
+import { writeFileAtomically } from './artifactpublisher.js';
 
 export class Base64TsOutput {
   private files: interfaces.IBase64File[] = [];
+  private filePaths = new Set<string>();
   private cwd: string;
 
   constructor(cwd: string = paths.cwd) {
@@ -14,10 +16,15 @@ export class Base64TsOutput {
    * Add a file with its content to the output
    */
   public addFile(filePath: string, content: Buffer | string): void {
+    const normalizedPath = plugins.path.posix.normalize(filePath.replace(/\\/g, '/'));
+    if (this.filePaths.has(normalizedPath)) {
+      throw new Error(`Duplicate base64ts output path: ${normalizedPath}`);
+    }
     const contentBuffer = typeof content === 'string' ? Buffer.from(content, 'utf-8') : content;
     const contentBase64 = contentBuffer.toString('base64');
+    this.filePaths.add(normalizedPath);
     this.files.push({
-      path: filePath,
+      path: normalizedPath,
       contentBase64,
     });
   }
@@ -144,7 +151,7 @@ ${filesFormatted}
     const outputDir = plugins.path.dirname(absolutePath);
     await plugins.fs.directory(outputDir).create();
     const content = this.generateTypeScript(maxLineLength);
-    await plugins.fs.file(absolutePath).encoding('utf8').write(content);
+    await writeFileAtomically(absolutePath, content);
     console.log(`Generated base64ts output: ${outputPath}`);
   }
 
@@ -160,5 +167,6 @@ ${filesFormatted}
    */
   public clear(): void {
     this.files = [];
+    this.filePaths.clear();
   }
 }

package/ts/mod_rolldown/index.child.ts

@@ -2,6 +2,12 @@ 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 {
+  cleanupBuildStage,
+  createBuildStage,
+  getChunkNamespace,
+  publishGeneratedArtifacts,
+} from '../mod_output/artifactpublisher.js';
 
 export class TsBundleProcess {
   constructor() {
@@ -32,59 +38,76 @@ export class TsBundleProcess {
     }
   }
 
-  /**
-   * creates a bundle for the test enviroment
-   */
-  public async buildTest(fromArg: string, toArg: string, argvArg: any) {
-    // create a bundle
-    const result = await plugins.rolldown({
-      input: fromArg,
-      resolve: {
-        alias: await this.getAliases(),
-        tsconfigFilename: paths.tsconfigPath,
-      },
-    });
-
+  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 outputDir = plugins.path.dirname(toArg);
     const outputFilename = plugins.path.basename(toArg);
+    const stage = createBuildStage(outputDir);
+    const stageMainPath = plugins.path.join(stage.stageDirectory, outputFilename);
+    try {
+      const result = await plugins.rolldown({
+        input: fromArg,
+        resolve: {
+          alias: await this.getAliases(),
+          tsconfigFilename: paths.tsconfigPath,
+        },
+      });
+      try {
+        await result.write({
+          dir: stage.stageDirectory,
+          entryFileNames: outputFilename,
+          chunkFileNames: `chunks/${chunkNamespace}/[name]-[hash].js`,
+          assetFileNames: `chunks/${chunkNamespace}/[name]-[hash][extname]`,
+          format: 'es',
+          sourcemap: argvArg.sourcemap !== false,
+          minify: productionArg,
+          codeSplitting: false,
+        });
+      } finally {
+        await result.close();
+      }
+      await publishGeneratedArtifacts({
+        sourceDirectory: stage.stageDirectory,
+        sourceMainPath: stageMainPath,
+        targetPath: toArg,
+        logicalOutputName,
+        chunkNamespace,
+        sourceMapsEnabled: argvArg.sourcemap !== false,
+      });
+    } finally {
+      cleanupBuildStage(stage.stageDirectory, outputDir, stage.marker);
+    }
+  }
 
-    await result.write({
-      dir: outputDir,
-      entryFileNames: outputFilename,
-      format: 'es',
-      sourcemap: argvArg.sourcemap !== false,
-      codeSplitting: false,
-    });
+  /**
+   * creates a bundle for the test enviroment
+   */
+  public async buildTest(
+    fromArg: string,
+    toArg: string,
+    argvArg: interfaces.ICliOptions,
+  ): Promise<void> {
+    await this.build(fromArg, toArg, argvArg, false);
   }
 
   /**
    * creates a bundle for the production environment
    */
-  public async buildProduction(fromArg: string, toArg: string, argvArg: any) {
-    // create a bundle
+  public async buildProduction(
+    fromArg: string,
+    toArg: string,
+    argvArg: interfaces.ICliOptions,
+  ): Promise<void> {
     console.log('rolldown specific:');
     console.log(`from: ${fromArg}`);
     console.log(`to: ${toArg}`);
-
-    const result = await plugins.rolldown({
-      input: fromArg,
-      resolve: {
-        alias: await this.getAliases(),
-        tsconfigFilename: paths.tsconfigPath,
-      },
-    });
-
-    const outputDir = plugins.path.dirname(toArg);
-    const outputFilename = plugins.path.basename(toArg);
-
-    await result.write({
-      dir: outputDir,
-      entryFileNames: outputFilename,
-      format: 'es',
-      sourcemap: argvArg.sourcemap !== false,
-      minify: true,
-      codeSplitting: false,
-    });
+    await this.build(fromArg, toArg, argvArg, true);
   }
 }
 

package/ts/mod_rspack/index.child.ts

@@ -2,6 +2,12 @@ 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 {
+  cleanupBuildStage,
+  createBuildStage,
+  getChunkNamespace,
+  publishGeneratedArtifacts,
+} from '../mod_output/artifactpublisher.js';
 
 export class TsBundleProcess {
   constructor() {
@@ -36,22 +42,33 @@ export class TsBundleProcess {
     }
   }
 
-  /**
-   * creates a bundle for the test enviroment
-   */
-  public async buildTest(fromArg: string, toArg: string, argvArg: any) {
+  private async build(
+    fromArg: string,
+    toArg: string,
+    argvArg: interfaces.ICliOptions,
+    productionArg: boolean,
+  ): Promise<void> {
     const aliases = await this.getAliases();
+    const logicalOutputName = plugins.path.basename(argvArg.chunkOwner || toArg);
+    const chunkNamespace = getChunkNamespace(logicalOutputName);
     const outputDir = plugins.path.dirname(toArg);
     const outputFilename = plugins.path.basename(toArg);
+    const stage = createBuildStage(outputDir);
+    const stageMainPath = plugins.path.join(stage.stageDirectory, outputFilename);
 
     const config = {
-      mode: 'development' as const,
+      mode: productionArg ? 'production' as const : 'development' as const,
       entry: {
         main: fromArg,
       },
       output: {
-        path: outputDir,
+        path: stage.stageDirectory,
         filename: outputFilename,
+        chunkFilename: `chunks/${chunkNamespace}/[name]-[contenthash].js`,
+        assetModuleFilename: `chunks/${chunkNamespace}/[name]-[contenthash][ext]`,
+        cssFilename: `chunks/${chunkNamespace}/[name]-[contenthash].css`,
+        cssChunkFilename: `chunks/${chunkNamespace}/[name]-[contenthash].css`,
+        webassemblyModuleFilename: `chunks/${chunkNamespace}/[hash].module.wasm`,
         module: true,
         library: {
           type: 'module' as const,
@@ -80,6 +97,12 @@ export class TsBundleProcess {
                   transform: {
                     decoratorVersion: '2022-03',
                   },
+                  ...(productionArg ? {
+                    minify: {
+                      compress: true,
+                      mangle: true,
+                    },
+                  } : {}),
                 },
               },
             },
@@ -87,139 +110,84 @@ export class TsBundleProcess {
           },
         ],
       },
+      ...(productionArg ? {
+        optimization: {
+          minimize: true,
+          concatenateModules: true,
+          usedExports: true,
+          sideEffects: true,
+        },
+      } : {}),
     };
 
-    return new Promise((resolve, reject) => {
-      plugins.rspack(config, (err, stats) => {
-        if (err) {
-          console.error(err.stack || err);
-          reject(err);
-          return;
-        }
-        if (!stats) {
-          reject(new Error('Rspack did not return stats'));
-          return;
-        }
-
-        if (stats.hasErrors()) {
-          console.error(stats.toString());
-          reject(new Error('Build failed with errors'));
-          return;
-        }
-
-        console.log(
-          stats.toString({
-            colors: true,
-            modules: false,
-            children: false,
-            chunks: false,
-            chunkModules: false,
-          }),
-        );
+    try {
+      await new Promise<void>((resolve, reject) => {
+        plugins.rspack(config, (err, stats) => {
+          if (err) {
+            console.error(err.stack || err);
+            reject(err);
+            return;
+          }
+          if (!stats) {
+            reject(new Error('Rspack did not return stats'));
+            return;
+          }
+
+          if (stats.hasErrors()) {
+            console.error(stats.toString());
+            reject(new Error('Build failed with errors'));
+            return;
+          }
+
+          console.log(
+            stats.toString({
+              colors: true,
+              modules: false,
+              children: false,
+              chunks: false,
+              chunkModules: false,
+            }),
+          );
 
-        resolve(undefined);
+          resolve();
+        });
+      });
+      await publishGeneratedArtifacts({
+        sourceDirectory: stage.stageDirectory,
+        sourceMainPath: stageMainPath,
+        targetPath: toArg,
+        logicalOutputName,
+        chunkNamespace,
+        sourceMapsEnabled: argvArg.sourcemap !== false,
       });
-    });
+    } finally {
+      cleanupBuildStage(stage.stageDirectory, outputDir, stage.marker);
+    }
+  }
+
+  /**
+   * creates a bundle for the test enviroment
+   */
+  public async buildTest(
+    fromArg: string,
+    toArg: string,
+    argvArg: interfaces.ICliOptions,
+  ): Promise<void> {
+    await this.build(fromArg, toArg, argvArg, false);
   }
 
   /**
    * creates a bundle for the production environment
    */
-  public async buildProduction(fromArg: string, toArg: string, argvArg: any) {
+  public async buildProduction(
+    fromArg: string,
+    toArg: string,
+    argvArg: interfaces.ICliOptions,
+  ): Promise<void> {
     console.log('rspack specific:');
     console.log(`from: ${fromArg}`);
     console.log(`to: ${toArg}`);
-
-    const aliases = await this.getAliases();
-    const outputDir = plugins.path.dirname(toArg);
-    const outputFilename = plugins.path.basename(toArg);
-
-    const config = {
-      mode: 'production' as const,
-      entry: {
-        main: fromArg,
-      },
-      output: {
-        path: outputDir,
-        filename: outputFilename,
-        module: true,
-        library: {
-          type: 'module' as const,
-        },
-      },
-      devtool: (argvArg.sourcemap === false ? false : 'source-map') as false | 'source-map',
-      resolve: {
-        alias: aliases,
-        extensions: ['.ts', '.tsx', '.js', '.jsx'],
-      },
-      module: {
-        rules: [
-          {
-            test: /\.tsx?$/,
-            exclude: /node_modules/,
-            use: {
-              loader: 'builtin:swc-loader',
-              options: {
-                jsc: {
-                  parser: {
-                    syntax: 'typescript',
-                    tsx: true,
-                    decorators: true,
-                  },
-                  target: 'es2022',
-                  transform: {
-                    decoratorVersion: '2022-03',
-                  },
-                  minify: {
-                    compress: true,
-                    mangle: true,
-                  },
-                },
-              },
-            },
-            type: 'javascript/auto',
-          },
-        ],
-      },
-      optimization: {
-        minimize: true,
-        concatenateModules: true,
-        usedExports: true,
-        sideEffects: true,
-      },
-    };
-
-    return new Promise((resolve, reject) => {
-      plugins.rspack(config, (err, stats) => {
-        if (err) {
-          console.error(err.stack || err);
-          reject(err);
-          return;
-        }
-        if (!stats) {
-          reject(new Error('Rspack did not return stats'));
-          return;
-        }
-
-        if (stats.hasErrors()) {
-          console.error(stats.toString());
-          reject(new Error('Build failed with errors'));
-          return;
-        }
-
-        console.log(
-          stats.toString({
-            colors: true,
-            modules: false,
-            children: false,
-            chunks: false,
-            chunkModules: false,
-          }),
-        );
-
-        resolve(undefined);
-      });
-    });
+    await this.build(fromArg, toArg, argvArg, true);
   }
 }
 

package/ts/plugins.ts

@@ -1,10 +1,12 @@
 // node native
 import * as path from 'path';
+import * as crypto from 'node:crypto';
 import * as fsSync from 'node:fs';
 import * as fsPromises from 'node:fs/promises';
 import * as os from 'node:os';
+import { setTimeout as delay } from 'node:timers/promises';
 
-export { fsPromises, fsSync, os, path };
+export { crypto, delay, fsPromises, fsSync, os, path };
 
 // pushrocks scope
 import * as smartconfig from '@push.rocks/smartconfig';

package/ts/tsbundle.class.tsbundle.ts

@@ -9,7 +9,6 @@ export class TsBundle {
     toArg: string = './dist_bundle/bundle.js',
     argvArg: interfaces.ICliOptions,
   ) {
-    const done = plugins.smartpromise.defer();
     const getBundlerPath = () => {
       switch (argvArg.bundler) {
         case 'rolldown':
@@ -49,20 +48,109 @@ export class TsBundle {
         },
       },
     );
-    const childProcess = await threadsimple.start();
-    childProcess.on('exit', (status) => {
-      if (status !== 0) {
-        done.reject(new Error(`Bundle build failed with exit code ${status}`));
-      } else {
-        done.resolve();
+    const startPromise = threadsimple.start();
+    const childProcess = threadsimple.threadChildProcess;
+    if (!childProcess) {
+      await startPromise;
+      throw new Error('ThreadSimple.start() did not expose its child process synchronously');
+    }
+    await new Promise<void>((resolve, reject) => {
+      let settled = false;
+      let startSettled = false;
+      let terminal = false;
+      let firstError: Error | undefined;
+      let terminationRequested = false;
+      let forceKillTimer: ReturnType<typeof setTimeout> | undefined;
+      const cleanupListeners = (): void => {
+        childProcess.removeListener('error', handleError);
+        childProcess.removeListener('exit', handleExit);
+        childProcess.removeListener('close', handleClose);
+      };
+      const clearForceKillTimer = (): void => {
+        if (forceKillTimer) {
+          clearTimeout(forceKillTimer);
+          forceKillTimer = undefined;
+        }
+      };
+      const settleIfComplete = (): void => {
+        if (settled || !startSettled || !terminal) {
+          return;
+        }
+        settled = true;
+        clearForceKillTimer();
+        cleanupListeners();
+        if (firstError) {
+          reject(firstError);
+        } else {
+          resolve();
+        }
+      };
+      const isChildLive = (): boolean => (
+        childProcess.exitCode === null && childProcess.signalCode === null
+      );
+      const requestTermination = (): void => {
+        if (terminationRequested || !childProcess.pid || !isChildLive()) {
+          return;
+        }
+        terminationRequested = true;
+        forceKillTimer = setTimeout(() => {
+          if (isChildLive()) {
+            try {
+              childProcess.kill('SIGKILL');
+            } catch {
+              // The first child-process failure remains the actionable error.
+            }
+          }
+        }, 5_000);
+        try {
+          childProcess.kill('SIGTERM');
+        } catch {
+          // The first child-process failure remains the actionable error.
+        }
+      };
+      const handleError = (errorArg: Error): void => {
+        firstError ??= errorArg;
+        requestTermination();
+      };
+      const handleTerminal = (
+        statusArg: number | null,
+        signalArg: NodeJS.Signals | null,
+      ): void => {
+        if (terminal) {
+          return;
+        }
+        terminal = true;
+        clearForceKillTimer();
+        if (!firstError && statusArg !== 0) {
+          const exitDetail = statusArg === null ? `signal ${signalArg}` : `exit code ${statusArg}`;
+          firstError = new Error(`Bundle build failed with ${exitDetail}`);
+        }
+        settleIfComplete();
+      };
+      const handleExit = (statusArg: number | null, signalArg: NodeJS.Signals | null): void => {
+        handleTerminal(statusArg, signalArg);
+      };
+      const handleClose = (statusArg: number | null, signalArg: NodeJS.Signals | null): void => {
+        handleTerminal(statusArg, signalArg);
+      };
+      childProcess.on('error', handleError);
+      childProcess.once('exit', handleExit);
+      childProcess.once('close', handleClose);
+      void startPromise.then(
+        () => {
+          startSettled = true;
+          settleIfComplete();
+        },
+        (errorArg: unknown) => {
+          startSettled = true;
+          firstError ??= errorArg instanceof Error ? errorArg : new Error(String(errorArg));
+          requestTermination();
+          settleIfComplete();
+        },
+      );
+      if (childProcess.exitCode !== null || childProcess.signalCode !== null) {
+        handleTerminal(childProcess.exitCode, childProcess.signalCode);
       }
     });
-    await done.promise;
-    if (argvArg.sourcemap === false) {
-      const outputPath = plugins.path.isAbsolute(toArg)
-        ? toArg
-        : plugins.path.resolve(cwdArg, toArg);
-      await plugins.fsPromises.rm(`${outputPath}.map`, { force: true });
-    }
   }
 }