v2.8.0

changelog.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2026-01-12 - 2.8.0 - feat(tsbundle)
+add configurable maxLineLength for base64ts output and improve build/error handling in child builds
+
+- Add optional maxLineLength?: number to IBundleConfig to control max characters per line for base64ts output (0 or undefined = unlimited).
+- Support splitting base64 strings when maxLineLength is specified; generateTypeScript(maxLineLength?) and writeToFile(outputPath, maxLineLength?) updated to accept and apply this setting.
+- Pass bundleConfig.maxLineLength through in mod_custom so base64ts output respects bundle configuration.
+- Wrap TsBundle.build in mod_custom with try/catch to log failures and skip output handling when build fails.
+- tsbundle.class now rejects the bundle promise when the child process exits with a non-zero status.
+- mod_esbuild child process now awaits builds, exits with appropriate success/failure codes, and formats esbuild errors for clearer console output.
+
 ## 2026-01-12 - 2.7.4 - fix(deps)
 bump @push.rocks/smartcli dependency to ^4.0.20
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tsbundle",
-  "version": "2.7.4",
+  "version": "2.8.0",
   "private": false,
   "description": "a multi-bundler tool supporting esbuild, rolldown, and rspack for painless bundling of web projects",
   "main": "dist_ts/index.js",

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tsbundle',
-  version: '2.7.4',
+  version: '2.8.0',
   description: 'a multi-bundler tool supporting esbuild, rolldown, and rspack for painless bundling of web projects'
 }

ts/interfaces/index.ts

@@ -24,6 +24,7 @@ export interface IBundleConfig {
   bundler?: TBundler;
   production?: boolean;
   includeFiles?: string[];
+  maxLineLength?: number; // For base64ts output: max chars per line. 0 or undefined = unlimited (default)
 }
 
 export interface ITsbundleConfig {

ts/mod_custom/index.ts

@@ -61,6 +61,7 @@ export class CustomBundleHandler {
 
     // Build the bundle to temp location
     const tsbundle = new TsBundle();
+    try {
       await tsbundle.build(
         this.cwd,
         bundleConfig.from,
@@ -70,6 +71,11 @@ export class CustomBundleHandler {
           production: bundleConfig.production || false,
         }
       );
+    } catch (error: any) {
+      console.error(`\n\x1b[31m❌ Bundle failed: ${bundleConfig.from} -> ${bundleConfig.to}\x1b[0m`);
+      // Don't re-print error details - they were already shown by the child process
+      return; // Skip output handling since build failed
+    }
 
     if (outputMode === 'base64ts') {
       await this.handleBase64TsOutput(bundleConfig, tempBundlePath);
@@ -105,7 +111,7 @@ export class CustomBundleHandler {
     }
 
     // Write the TypeScript output
-    await base64Output.writeToFile(bundleConfig.to);
+    await base64Output.writeToFile(bundleConfig.to, bundleConfig.maxLineLength);
   }
 
   /**

ts/mod_esbuild/index.child.ts

@@ -79,6 +79,7 @@ export class TsBundleProcess {
 }
 
 const run = async () => {
+  try {
     console.log('running spawned compilation process');
     const transportOptions: interfaces.IEnvTransportOptions = JSON.parse(
       process.env.transportOptions,
@@ -90,7 +91,7 @@ const run = async () => {
     const tsbundleProcessInstance = new TsBundleProcess();
     if (transportOptions.mode === 'test') {
       console.log('building for test:');
-    tsbundleProcessInstance.buildTest(
+      await tsbundleProcessInstance.buildTest(
         plugins.smartpath.transform.makeAbsolute(
           transportOptions.from,
           process.cwd(),
@@ -103,7 +104,7 @@ const run = async () => {
       );
     } else {
       console.log('building for production:');
-    tsbundleProcessInstance.buildProduction(
+      await tsbundleProcessInstance.buildProduction(
         plugins.smartpath.transform.makeAbsolute(
           transportOptions.from,
           process.cwd(),
@@ -115,6 +116,29 @@ const run = async () => {
         transportOptions.argv,
       );
     }
+    process.exit(0);
+  } catch (error: any) {
+    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)) {
+      // esbuild errors - format them nicely
+      console.error(`Found ${error.errors.length} error(s):\n`);
+      for (const err of error.errors) {
+        const file = err.location?.file || 'unknown';
+        const line = err.location?.line || '?';
+        const column = err.location?.column || '?';
+        console.error(`  \x1b[36m${file}\x1b[0m:\x1b[33m${line}\x1b[0m:\x1b[33m${column}\x1b[0m`);
+        console.error(`    ${err.text}\n`);
+      }
+    } else {
+      console.error(error.message || error);
+    }
+
+    console.error('\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m\n');
+    process.exit(1);
+  }
 };
 
 run();

ts/mod_output/index.ts

@@ -77,18 +77,26 @@ export class Base64TsOutput {
 
   /**
    * Generate TypeScript file content
+   * @param maxLineLength - Max chars per line for base64 strings. 0 or undefined = unlimited (default)
    */
-  public generateTypeScript(): string {
-    const MAX_LINE_LENGTH = 200;
+  public generateTypeScript(maxLineLength?: number): string {
+    // Default behavior: no line splitting (unlimited)
+    if (!maxLineLength || maxLineLength <= 0) {
+      const filesJson = JSON.stringify(this.files, null, 2);
+      return `// Auto-generated by tsbundle - do not edit
+export const files: { path: string; contentBase64: string }[] = ${filesJson};
+`;
+    }
 
+    // Split base64 strings into chunks when maxLineLength is specified
     const formatBase64 = (base64: string): string => {
-      if (base64.length <= MAX_LINE_LENGTH) {
+      if (base64.length <= maxLineLength) {
         return `"${base64}"`;
       }
 
       const chunks: string[] = [];
-      for (let i = 0; i < base64.length; i += MAX_LINE_LENGTH) {
-        chunks.push(base64.slice(i, i + MAX_LINE_LENGTH));
+      for (let i = 0; i < base64.length; i += maxLineLength) {
+        chunks.push(base64.slice(i, i + maxLineLength));
       }
 
       return `"" +\n      "${chunks.join('" +\n      "')}"`;
@@ -110,12 +118,14 @@ ${filesFormatted}
 
   /**
    * Write the TypeScript file to disk
+   * @param outputPath - Output file path
+   * @param maxLineLength - Max chars per line for base64 strings. 0 or undefined = unlimited (default)
    */
-  public async writeToFile(outputPath: string): Promise<void> {
+  public async writeToFile(outputPath: string, maxLineLength?: number): Promise<void> {
     const absolutePath = plugins.smartpath.transform.toAbsolute(outputPath, this.cwd) as string;
     const outputDir = plugins.path.dirname(absolutePath);
     await plugins.fs.directory(outputDir).create();
-    const content = this.generateTypeScript();
+    const content = this.generateTypeScript(maxLineLength);
     await plugins.fs.file(absolutePath).encoding('utf8').write(content);
     console.log(`Generated base64ts output: ${outputPath}`);
   }

ts/tsbundle.class.tsbundle.ts

@@ -45,7 +45,11 @@ 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();
+      }
     });
     await done.promise;
   }