@git.zone/tsbundle 2.2.8 → 2.4.0

package/ts/00_commitinfo_data.ts

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

package/ts/interfaces/index.ts

@@ -2,7 +2,7 @@ export interface ICliOptions {
   commonjs?: boolean;
   skiplibcheck?: boolean;
   production?: boolean;
-  bundler: 'parcel' | 'esbuild' | 'rollup'
+  bundler: 'esbuild' | 'rolldown' | 'rspack'
 }
 
 export interface IEnvTransportOptions {

package/ts/mod_esbuild/index.child.ts

@@ -61,7 +61,7 @@ export class TsBundleProcess {
       format: 'esm',
       target: 'es2022',
       minify: true,
-      entryNames: 'bundle',
+      entryNames: plugins.path.parse(toArg).name,
       outdir: plugins.path.parse(toArg).dir,
       tsconfig: paths.tsconfigPath,
       splitting: false,

package/ts/mod_rolldown/index.child.ts

@@ -0,0 +1,115 @@
+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';
+
+export class TsBundleProcess {
+  constructor() {
+    // Nothing here
+  }
+
+  public async getAliases() {
+    try {
+      const aliasObject: Record<string, string> = {};
+      const localTsConfig = plugins.smartfile.fs.toObjectSync(
+        plugins.path.join(paths.cwd, 'tsconfig.json')
+      );
+      if (localTsConfig.compilerOptions && localTsConfig.compilerOptions.paths) {
+        for (const alias of Object.keys(localTsConfig.compilerOptions.paths)) {
+          const aliasPath = localTsConfig.compilerOptions.paths[alias][0];
+          aliasObject[alias] = aliasPath;
+        }
+      }
+      return aliasObject;
+    } catch (error) {
+      return {};
+    }
+  }
+
+  /**
+   * 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,
+      },
+    });
+    
+    const outputDir = plugins.path.dirname(toArg);
+    const outputFilename = plugins.path.basename(toArg);
+    
+    await result.write({
+      dir: outputDir,
+      entryFileNames: outputFilename,
+      format: 'es',
+      sourcemap: true,
+      inlineDynamicImports: true,
+    });
+  }
+
+  /**
+   * creates a bundle for the production environment
+   */
+  public async buildProduction(fromArg: string, toArg: string, argvArg: any) {
+    // create a bundle
+    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,
+      },
+      experimental: {
+        enableComposingJsPlugins: true,
+      },
+    });
+    
+    const outputDir = plugins.path.dirname(toArg);
+    const outputFilename = plugins.path.basename(toArg);
+    
+    await result.write({
+      dir: outputDir,
+      entryFileNames: outputFilename,
+      format: 'es',
+      sourcemap: true,
+      minify: true,
+      inlineDynamicImports: true,
+    });
+  }
+}
+
+const run = async () => {
+  console.log('running spawned compilation process');
+  const transportOptions: interfaces.IEnvTransportOptions = JSON.parse(
+    process.env.transportOptions
+  );
+  console.log('=======> ROLLDOWN');
+  console.log(transportOptions);
+  process.chdir(transportOptions.cwd);
+  console.log(`switched to ${process.cwd()}`);
+  const tsbundleProcessInstance = new TsBundleProcess();
+  if (transportOptions.mode === 'test') {
+    console.log('building for test:');
+    await tsbundleProcessInstance.buildTest(
+      plugins.smartpath.transform.makeAbsolute(transportOptions.from, process.cwd()),
+      plugins.smartpath.transform.makeAbsolute(transportOptions.to, process.cwd()),
+      transportOptions.argv
+    );
+  } else {
+    console.log('building for production:');
+    await tsbundleProcessInstance.buildProduction(
+      plugins.smartpath.transform.makeAbsolute(transportOptions.from, process.cwd()),
+      plugins.smartpath.transform.makeAbsolute(transportOptions.to, process.cwd()),
+      transportOptions.argv
+    );
+  }
+};
+
+run();

package/ts/mod_rolldown/plugins.ts

@@ -0,0 +1,5 @@
+export * from '../plugins.js';
+
+import { rolldown } from 'rolldown';
+
+export { rolldown }

package/ts/mod_rspack/index.child.ts

@@ -0,0 +1,236 @@
+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';
+
+export class TsBundleProcess {
+  constructor() {
+    // Nothing here
+  }
+
+  public async getAliases() {
+    try {
+      const aliasObject: Record<string, string> = {};
+      const localTsConfig = plugins.smartfile.fs.toObjectSync(
+        plugins.path.join(paths.cwd, 'tsconfig.json')
+      );
+      if (localTsConfig.compilerOptions && localTsConfig.compilerOptions.paths) {
+        for (const alias of Object.keys(localTsConfig.compilerOptions.paths)) {
+          const aliasPath = localTsConfig.compilerOptions.paths[alias][0];
+          // Convert TypeScript path to absolute path for rspack
+          aliasObject[alias.replace('/*', '')] = plugins.path.resolve(paths.cwd, aliasPath.replace('/*', ''));
+        }
+      }
+      return aliasObject;
+    } catch (error) {
+      return {};
+    }
+  }
+
+  /**
+   * creates a bundle for the test enviroment
+   */
+  public async buildTest(fromArg: string, toArg: string, argvArg: any) {
+    const aliases = await this.getAliases();
+    const outputDir = plugins.path.dirname(toArg);
+    const outputFilename = plugins.path.basename(toArg);
+    
+    const config = {
+      mode: 'development' as const,
+      entry: {
+        main: fromArg,
+      },
+      output: {
+        path: outputDir,
+        filename: outputFilename,
+        library: {
+          type: 'module' as const,
+        },
+      },
+      devtool: 'source-map' as const,
+      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',
+                  },
+                },
+              },
+            },
+            type: 'javascript/auto',
+          },
+        ],
+      },
+      experiments: {
+        outputModule: true,
+      },
+    };
+
+    return new Promise((resolve, reject) => {
+      plugins.rspack(config, (err, stats) => {
+        if (err) {
+          console.error(err.stack || err);
+          reject(err);
+          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);
+      });
+    });
+  }
+
+  /**
+   * creates a bundle for the production environment
+   */
+  public async buildProduction(fromArg: string, toArg: string, argvArg: any) {
+    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,
+        library: {
+          type: 'module' as const,
+        },
+      },
+      devtool: 'source-map' as const,
+      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,
+      },
+      experiments: {
+        outputModule: true,
+      },
+    };
+
+    return new Promise((resolve, reject) => {
+      plugins.rspack(config, (err, stats) => {
+        if (err) {
+          console.error(err.stack || err);
+          reject(err);
+          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);
+      });
+    });
+  }
+}
+
+const run = async () => {
+  console.log('running spawned compilation process');
+  const transportOptions: interfaces.IEnvTransportOptions = JSON.parse(
+    process.env.transportOptions
+  );
+  console.log('=======> RSPACK');
+  console.log(transportOptions);
+  process.chdir(transportOptions.cwd);
+  console.log(`switched to ${process.cwd()}`);
+  const tsbundleProcessInstance = new TsBundleProcess();
+  if (transportOptions.mode === 'test') {
+    console.log('building for test:');
+    await tsbundleProcessInstance.buildTest(
+      plugins.smartpath.transform.makeAbsolute(transportOptions.from, process.cwd()),
+      plugins.smartpath.transform.makeAbsolute(transportOptions.to, process.cwd()),
+      transportOptions.argv
+    );
+  } else {
+    console.log('building for production:');
+    await tsbundleProcessInstance.buildProduction(
+      plugins.smartpath.transform.makeAbsolute(transportOptions.from, process.cwd()),
+      plugins.smartpath.transform.makeAbsolute(transportOptions.to, process.cwd()),
+      transportOptions.argv
+    );
+  }
+};
+
+run();

package/ts/mod_rspack/plugins.ts

@@ -0,0 +1,5 @@
+export * from '../plugins.js';
+
+import { rspack } from '@rspack/core';
+
+export { rspack }

package/ts/tsbundle.class.tsbundle.ts

@@ -12,10 +12,15 @@ export class TsBundle {
   ) {
     const done = plugins.smartpromise.defer();
     const getBundlerPath = () => {
-      if (argvArg.bundler === 'esbuild') {
-        return './mod_esbuild/index.child.js'
+      switch (argvArg.bundler) {
+        case 'rolldown':
+          return './mod_rolldown/index.child.js';
+        case 'rspack':
+          return './mod_rspack/index.child.js';
+        case 'esbuild':
+        default:
+          return './mod_esbuild/index.child.js';
       }
-      return './mod_esbuild/index.child.js'
     }
     const transportOptions: interfaces.IEnvTransportOptions = {
       cwd: cwdArg,
@@ -23,7 +28,6 @@ export class TsBundle {
       to: toArg,
       mode: argvArg && argvArg.production ? 'production' : 'test',
       argv:  {
-        bundler: 'esbuild',
         ...argvArg
       } 
     }

package/dist_ts/mod_parcel/index.child.js

@@ -1,42 +0,0 @@
-import * as plugins from './plugins.js';
-import '../interfaces/index.js';
-import '../tsbundle.logging.js';
-export class TsBundleProcess {
-    constructor() {
-        // Nothing here
-    }
-    /**
-     * creates a bundle for the test enviroment
-     */
-    async buildTest(fromArg, toArg, argvArg) {
-        const parsedPath = plugins.path.parse(toArg);
-        const parcelInstance = new plugins.smartparcel.Parcel(fromArg, parsedPath.dir, parsedPath.base);
-        await parcelInstance.build();
-    }
-    /**
-     * creates a bundle for the production environment
-     */
-    async buildProduction(fromArg, toArg, argvArg) {
-        // create a bundle
-        const parsedPath = plugins.path.parse(toArg);
-        const parcelInstance = new plugins.smartparcel.Parcel(fromArg, parsedPath.dir, parsedPath.base);
-        await parcelInstance.build();
-    }
-}
-const run = async () => {
-    console.log('running spawned compilation process');
-    const transportOptions = JSON.parse(process.env.transportOptions);
-    console.log('bundling with parcel:');
-    console.log(transportOptions);
-    process.chdir(transportOptions.cwd);
-    console.log(`switched to ${process.cwd()}`);
-    const tsbundleProcessInstance = new TsBundleProcess();
-    if (transportOptions.mode === 'test') {
-        tsbundleProcessInstance.buildTest(transportOptions.from, transportOptions.to, transportOptions.argv);
-    }
-    else {
-        tsbundleProcessInstance.buildProduction(transportOptions.from, transportOptions.to, transportOptions.argv);
-    }
-};
-run();
-//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_parcel/plugins.d.ts

@@ -1,3 +0,0 @@
-export * from '../plugins.js';
-import * as smartparcel from '@pushrocks/smartparcel';
-export { smartparcel };

package/dist_ts/mod_parcel/plugins.js

@@ -1,4 +0,0 @@
-export * from '../plugins.js';
-import * as smartparcel from '@pushrocks/smartparcel';
-export { smartparcel };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL21vZF9wYXJjZWwvcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQTtBQUU3QixPQUFPLEtBQUssV0FBVyxNQUFNLHdCQUF3QixDQUFDO0FBRXRELE9BQU8sRUFDTCxXQUFXLEVBQ1osQ0FBQSJ9

package/dist_ts/mod_rollup/htmlhandler.d.ts

@@ -1,7 +0,0 @@
-export declare class HtmlHandler {
-    sourceFilePath: string;
-    targetFilePath: string;
-    checkIfExists(): Promise<boolean>;
-    copyHtml(targetPathArg?: string): Promise<void>;
-    minifyHtml(targetPathArg?: string): Promise<void>;
-}

package/dist_ts/mod_rollup/htmlhandler.js

@@ -1,37 +0,0 @@
-import * as plugins from './plugins.js';
-import * as paths from '../paths.js';
-export class HtmlHandler {
-    constructor() {
-        this.sourceFilePath = plugins.path.join(paths.htmlDir, 'index.html');
-        this.targetFilePath = plugins.path.join(paths.distServeDir, 'index.html');
-    }
-    async checkIfExists() {
-        return plugins.smartfile.fs.fileExists(this.sourceFilePath);
-    }
-    // copies the html
-    async copyHtml(targetPathArg = this.targetFilePath) {
-        if (!(await this.checkIfExists())) {
-            return;
-        }
-        await plugins.smartfile.fs.copy(this.sourceFilePath, targetPathArg);
-    }
-    // copies and minifies the html
-    async minifyHtml(targetPathArg = this.targetFilePath) {
-        if (!(await this.checkIfExists())) {
-            return;
-        }
-        const fileString = plugins.smartfile.fs.toStringSync(this.sourceFilePath);
-        const minifiedHtml = plugins.htmlMinifier.minify(fileString, {
-            minifyCSS: true,
-            minifyJS: true,
-            sortAttributes: true,
-            sortClassName: true,
-            removeAttributeQuotes: true,
-            collapseWhitespace: true,
-            collapseInlineTagWhitespace: true,
-            removeComments: true,
-        });
-        plugins.smartfile.memory.toFsSync(minifiedHtml, targetPathArg);
-    }
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHRtbGhhbmRsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9tb2Rfcm9sbHVwL2h0bWxoYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxLQUFLLE1BQU0sYUFBYSxDQUFDO0FBRXJDLE1BQU0sT0FBTyxXQUFXO0lBQXhCO1FBQ1MsbUJBQWMsR0FBVyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLFlBQVksQ0FBQyxDQUFDO1FBQ3hFLG1CQUFjLEdBQVcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLFlBQVksRUFBRSxZQUFZLENBQUMsQ0FBQztJQWdDdEYsQ0FBQztJQTlCUSxLQUFLLENBQUMsYUFBYTtRQUN4QixPQUFPLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDOUQsQ0FBQztJQUVELGtCQUFrQjtJQUNYLEtBQUssQ0FBQyxRQUFRLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQyxjQUFjO1FBQ3ZELElBQUksQ0FBQyxDQUFDLE1BQU0sSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDLEVBQUU7WUFDakMsT0FBTztTQUNSO1FBQ0QsTUFBTSxPQUFPLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLGNBQWMsRUFBRSxhQUFhLENBQUMsQ0FBQztJQUN0RSxDQUFDO0lBRUQsK0JBQStCO0lBQ3hCLEtBQUssQ0FBQyxVQUFVLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQyxjQUFjO1FBQ3pELElBQUksQ0FBQyxDQUFDLE1BQU0sSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDLEVBQUU7WUFDakMsT0FBTztTQUNSO1FBQ0QsTUFBTSxVQUFVLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztRQUMxRSxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDLE1BQU0sQ0FBQyxVQUFVLEVBQUU7WUFDM0QsU0FBUyxFQUFFLElBQUk7WUFDZixRQUFRLEVBQUUsSUFBSTtZQUNkLGNBQWMsRUFBRSxJQUFJO1lBQ3BCLGFBQWEsRUFBRSxJQUFJO1lBQ25CLHFCQUFxQixFQUFFLElBQUk7WUFDM0Isa0JBQWtCLEVBQUUsSUFBSTtZQUN4QiwyQkFBMkIsRUFBRSxJQUFJO1lBQ2pDLGNBQWMsRUFBRSxJQUFJO1NBQ3JCLENBQUMsQ0FBQztRQUNILE9BQU8sQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxZQUFZLEVBQUUsYUFBYSxDQUFDLENBQUM7SUFDakUsQ0FBQztDQUNGIn0=

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

@@ -1,18 +0,0 @@
-import * as plugins from './plugins.js';
-export declare class TsBundleProcess {
-    /**
-     * the basic default options for rollup
-     */
-    getBaseOptions(fromArg: string, toArg: string, argvArg: any): plugins.rollup.RollupOptions;
-    getOptionsTest(fromArg: string, toArg: string, argvArg: any): plugins.rollup.RollupOptions;
-    getOptionsProduction(fromArg: string, toArg: string, argvArg: any): plugins.rollup.RollupOptions;
-    constructor();
-    /**
-     * 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>;
-}