1.0.85

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitzone/tsbundle",
-  "version": "1.0.80",
+  "version": "1.0.85",
   "private": false,
   "description": "a bundler using rollup for painless bundling of web projects",
   "main": "dist_ts/index.js",
@@ -8,7 +8,7 @@
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
-    "test": "cd test && node ../cli.ts.js --production",
+    "test": "npm run build && (tstest test/) && (cd test && node ../cli.js --production)",
     "build": "(tsbuild --web)"
   },
   "bin": {
@@ -16,37 +16,39 @@
   },
   "devDependencies": {
     "@gitzone/tsbuild": "^2.1.25",
-    "@gitzone/tsrun": "^1.2.12",
+    "@gitzone/tsrun": "^1.2.17",
-    "@gitzone/tstest": "^1.0.52",
+    "@gitzone/tstest": "^1.0.54",
     "@pushrocks/tapbundle": "^3.2.14",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.15.0"
   },
   "dependencies": {
-    "@babel/core": "^7.11.1",
+    "@babel/core": "^7.14.8",
-    "@babel/plugin-proposal-class-properties": "^7.10.4",
+    "@babel/plugin-proposal-class-properties": "^7.14.5",
-    "@babel/plugin-proposal-decorators": "^7.10.5",
+    "@babel/plugin-proposal-decorators": "^7.14.5",
-    "@babel/plugin-transform-runtime": "^7.11.0",
+    "@babel/plugin-transform-runtime": "^7.14.5",
-    "@babel/preset-env": "^7.11.0",
+    "@babel/preset-env": "^7.14.8",
-    "@babel/runtime": "^7.11.2",
+    "@babel/runtime": "^7.14.8",
     "@pushrocks/early": "^3.0.6",
-    "@pushrocks/smartcli": "^3.0.12",
+    "@pushrocks/smartcli": "^3.0.14",
-    "@pushrocks/smartfile": "^8.0.8",
+    "@pushrocks/smartfile": "^8.0.10",
-    "@pushrocks/smartlog": "^2.0.39",
+    "@pushrocks/smartlog": "^2.0.44",
     "@pushrocks/smartlog-destination-local": "^8.0.8",
     "@pushrocks/smartparcel": "^1.0.9",
-    "@rollup/plugin-commonjs": "^14.0.0",
+    "@pushrocks/smartpromise": "^3.1.6",
+    "@pushrocks/smartspawn": "^2.0.9",
+    "@rollup/plugin-commonjs": "^19.0.1",
     "@rollup/plugin-json": "^4.1.0",
-    "@rollup/plugin-node-resolve": "^8.4.0",
+    "@rollup/plugin-node-resolve": "^13.0.2",
-    "@rollup/plugin-typescript": "^5.0.2",
+    "@rollup/plugin-typescript": "^8.2.3",
-    "@types/html-minifier": "^4.0.0",
+    "@types/html-minifier": "^4.0.1",
-    "@types/node": "^14.0.27",
+    "@types/node": "^16.4.0",
     "html-minifier": "^4.0.0",
-    "rollup": "^2.23.1",
+    "rollup": "^2.53.3",
     "rollup-plugin-babel": "^4.4.0",
-    "rollup-plugin-sourcemaps": "^0.6.2",
+    "rollup-plugin-sourcemaps": "^0.6.3",
-    "rollup-plugin-terser": "^6.1.0",
+    "rollup-plugin-terser": "^7.0.2",
-    "typescript": "^4.2.3"
+    "typescript": "^4.3.5"
   },
   "files": [
     "ts/**/*",

test/test.ts

@@ -1,8 +1,16 @@
 import { expect, tap } from '@pushrocks/tapbundle';
-import * as tsbundle from '../ts/index';
+import * as tsbundle from '../dist_ts/index';
 
-tap.test('first test', async () => {
+import * as path from 'path';
-  await tsbundle.runCli();
+
-});
+tap.test('should bundle test', async () => {
+  const tsbundleInstance = new tsbundle.TsBundle();
+  await tsbundleInstance.buildTest(process.cwd() + '/test', './ts_web/index.ts', './dist_manual/test.js', 'rollup')
+})
+
+tap.test('should bundle production', async () => {
+  const tsbundleInstance = new tsbundle.TsBundle();
+  await tsbundleInstance.buildProduction(process.cwd(), './test/ts_web/index.ts', './test/dist_manual/production.js')
+})
 
 tap.start();

test/ts_web/index.ts

@@ -1,3 +1,18 @@
-const myConst = 'hello';
+const myConst: string = 'hello';
+
+function sealed(constructor: Function) {
+  Object.seal(constructor);
+  Object.seal(constructor.prototype);
+}
+
+@sealed
+class BugReport {
+  type = "report";
+  title: string;
+
+  constructor(t: string) {
+    this.title = t;
+  }
+}
 
 console.log(myConst);

ts/tsbundle.class.tsbundle.ts

@@ -2,137 +2,40 @@ import * as plugins from './tsbundle.plugins';
 import { logger } from './tsbundle.logging';
 
 export class TsBundle {
-  /**
+  public async buildTest(cwdArg: string, fromArg: string, toArg: string, bundlerArg: 'rollup' | 'parcel') {
-   * the basic default options for rollup
+    const done = plugins.smartpromise.defer();
-   */
+    const threadsimple = new plugins.smartspawn.ThreadSimple(plugins.path.join(__dirname, './tsbundle.class.tsbundleprocess.js'), [], {
-  public getBaseOptions(
+      env: {
-    fromArg: string = `ts_web/index.ts`,
+        ...process.env,
-    toArg: string = 'dist_bundle/bundle.js'
+        tsbundleMode: 'test',
-  ) {
+        tsbundleCwd: cwdArg,
-    logger.log('info', `from: ${fromArg}`);
+        tsbundleFrom: fromArg,
-    logger.log('info', `to: ${toArg}`);
+        tsbundleTo: toArg,
-
+        tsbundleBundler: bundlerArg
-    const baseOptions: plugins.rollup.RollupOptions = {
-      input: fromArg,
-      output: {
-        name: 'tsbundle',
-        file: toArg,
-        format: 'iife',
-        sourcemap: true,
-      },
-      // Indicate here external modules you don't wanna include in your bundle (i.e.: 'lodash')
-      external: [],
-      watch: {
-        include: ['src/**'],
-      },
-      plugins: [
-        // Compile TypeScript files
-        plugins.rollupTypescript({
-          include: plugins.path.parse(fromArg).dir
-            ? plugins.path.parse(fromArg).dir + '/**/*.ts'
-            : '**/*.ts',
-          declaration: false,
-          emitDecoratorMetadata: true,
-          experimentalDecorators: true,
-          inlineSourceMap: true,
-          noEmitOnError: true,
-          lib: ['esnext', 'dom', 'es2017.object'],
-          noImplicitAny: false,
-          target: 'es2018',
-          allowSyntheticDefaultImports: true,
-        }),
-        plugins.rollupJson(),
-        // Allow node_modules resolution, so you can use 'external' to control
-        // which external modules to include in the bundle
-        // https://github.com/rollup/rollup-plugin-node-resolve#usage
-        plugins.rollupResolve(),
-        plugins.rollupCommonjs({}),
-
-        // Resolve source maps to the original source
-        plugins.rollupSourceMaps(),
-        /*plugins.rollupBabel({
-          runtimeHelpers: true,
-          extensions: ['.js', '.jsx', '.ts', '.tsx'],
-          babelrc: false,
-          presets: [
-            [
-              '@babel/preset-env',
-              {
-                modules: false,
-                targets: {
-                  chrome: '41'
       }
-              }
-            ]
-          ],
-          plugins: [
-            [
-              '@babel/plugin-transform-runtime',
-              {
-                regenerator: true
-              }
-            ]
-          ]
-        })*/
-      ],
-    };
-    return baseOptions;
-  }
-
-  public getOptionsTest(fromArg: string, toArg: string): plugins.rollup.RollupOptions {
-    return this.getBaseOptions(fromArg, toArg);
-  }
-
-  public getOptionsProduction(fromArg: string, toArg: string): plugins.rollup.RollupOptions {
-    const productionOptions = this.getBaseOptions(fromArg, toArg);
-    productionOptions.plugins.push(
-      plugins.rollupTerser({
-        compress: true,
-        mangle: true
     })
-    );
+    const childProcess = await threadsimple.start();
-    return productionOptions;
+    childProcess.on('exit', (status) => {
-  }
+      done.resolve();
+    })
+    await done.promise;
+  };
   
-  constructor() {
+  public async buildProduction(cwdArg: string, fromArg: string, toArg: string) {
-    // Nothing here
+    const done = plugins.smartpromise.defer();
-  }
+    const threadsimple = new plugins.smartspawn.ThreadSimple(plugins.path.join(__dirname, './tsbundle.class.tsbundleprocess.js'), [], {
-
+      env: {
-  /**
+        ...process.env,
-   * creates a bundle for the test enviroment
+        tsbundleMode: 'production',
-   */
+        tsbundleCwd: cwdArg,
-  public async buildTest(
+        tsbundleFrom: fromArg,
-    fromArg: string,
+        tsbundleTo: toArg
-    toArg: string,
-    bundlerArg: 'rollup' | 'parcel' = 'rollup'
-  ) {
-    // create a bundle
-    switch (bundlerArg) {
-      case 'rollup':
-        logger.log('info', `bundling for TEST!`);
-        const buildOptions = this.getOptionsTest(fromArg, toArg);
-        const bundle = await plugins.rollup.rollup(buildOptions);
-        bundle.generate(buildOptions.output as plugins.rollup.OutputOptions);
-        await bundle.write(buildOptions.output as plugins.rollup.OutputOptions);
-        logger.log('ok', `Successfully bundled files!`);
-        break;
-      case 'parcel':
-        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
-   */
-  public async buildProduction(fromArg: string, toArg: string) {
-    // create a bundle
-    logger.log('info', `bundling for PRODUCTION!`);
-    const buildOptions = this.getOptionsProduction(fromArg, toArg);
-    const bundle = await plugins.rollup.rollup(buildOptions);
-    bundle.generate(buildOptions.output as plugins.rollup.OutputOptions);
-    await bundle.write(buildOptions.output as plugins.rollup.OutputOptions);
-    logger.log('ok', `Successfully bundled files!`);
       }
+    })
+    const childProcess = await threadsimple.start();
+    childProcess.on('exit', (status) => {
+      done.resolve();
+    })
+    await done.promise;
+  };
 }

ts/tsbundle.class.tsbundleprocess.ts

@@ -0,0 +1,157 @@
+import * as plugins from './tsbundle.plugins';
+import { logger } from './tsbundle.logging';
+
+export class TsBundleProcess {
+  /**
+   * the basic default options for rollup
+   */
+  public getBaseOptions(
+    fromArg: string = `ts_web/index.ts`,
+    toArg: string = 'dist_bundle/bundle.js'
+  ) {
+    logger.log('info', `from: ${fromArg}`);
+    logger.log('info', `to: ${toArg}`);
+
+    const baseOptions: plugins.rollup.RollupOptions = {
+      input: fromArg,
+      output: {
+        name: 'tsbundle',
+        file: toArg,
+        format: 'iife',
+        sourcemap: true,
+      },
+      // Indicate here external modules you don't wanna include in your bundle (i.e.: 'lodash')
+      external: [],
+      watch: {
+        include: ['src/**'],
+      },
+      plugins: [
+        // Compile TypeScript files
+        plugins.rollupTypescript({
+          include: plugins.path.parse(fromArg).dir
+            ? plugins.path.parse(fromArg).dir + '/**/*.ts'
+            : '**/*.ts',
+          declaration: false,
+          emitDecoratorMetadata: true,
+          experimentalDecorators: true,
+          inlineSourceMap: true,
+          noEmitOnError: true,
+          lib: ['esnext', 'dom', 'es2017.object'],
+          noImplicitAny: false,
+          target: 'es2018',
+          allowSyntheticDefaultImports: true,
+        }),
+        plugins.rollupJson(),
+        // Allow node_modules resolution, so you can use 'external' to control
+        // which external modules to include in the bundle
+        // https://github.com/rollup/rollup-plugin-node-resolve#usage
+        plugins.rollupResolve(),
+        plugins.rollupCommonjs({}),
+
+        // Resolve source maps to the original source
+        plugins.rollupSourceMaps(),
+        /*plugins.rollupBabel({
+          runtimeHelpers: true,
+          extensions: ['.js', '.jsx', '.ts', '.tsx'],
+          babelrc: false,
+          presets: [
+            [
+              '@babel/preset-env',
+              {
+                modules: false,
+                targets: {
+                  chrome: '41'
+                }
+              }
+            ]
+          ],
+          plugins: [
+            [
+              '@babel/plugin-transform-runtime',
+              {
+                regenerator: true
+              }
+            ]
+          ]
+        })*/
+      ],
+    };
+    return baseOptions;
+  }
+
+  public getOptionsTest(fromArg: string, toArg: string): plugins.rollup.RollupOptions {
+    return this.getBaseOptions(fromArg, toArg);
+  }
+
+  public getOptionsProduction(fromArg: string, toArg: string): plugins.rollup.RollupOptions {
+    const productionOptions = this.getBaseOptions(fromArg, toArg);
+    productionOptions.plugins.push(
+      plugins.rollupTerser({
+        compress: true,
+        mangle: true
+      })
+    );
+    return productionOptions;
+  }
+
+  constructor() {
+    // Nothing here
+  }
+
+  /**
+   * creates a bundle for the test enviroment
+   */
+  public async buildTest(
+    fromArg: string,
+    toArg: string,
+    bundlerArg: 'rollup' | 'parcel' = 'rollup'
+  ) {
+    // create a bundle
+    switch (bundlerArg) {
+      case 'rollup':
+        logger.log('info', `bundling for TEST!`);
+        const buildOptions = this.getOptionsTest(fromArg, toArg);
+        const bundle = await plugins.rollup.rollup(buildOptions);
+        bundle.generate(buildOptions.output as plugins.rollup.OutputOptions);
+        await bundle.write(buildOptions.output as plugins.rollup.OutputOptions);
+        logger.log('ok', `Successfully bundled files!`);
+        process.exit(0);
+      case 'parcel':
+        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
+   */
+  public async buildProduction(fromArg: string, toArg: string) {
+    // create a bundle
+    logger.log('info', `bundling for PRODUCTION!`);
+    const buildOptions = this.getOptionsProduction(fromArg, toArg);
+    const bundle = await plugins.rollup.rollup(buildOptions);
+    bundle.generate(buildOptions.output as plugins.rollup.OutputOptions);
+    await bundle.write(buildOptions.output as plugins.rollup.OutputOptions);
+    logger.log('ok', `Successfully bundled files!`);
+    process.exit(0);
+  }
+}
+
+const run = async () => {
+  console.log('running spawned compilation process');
+  console.log(`cwd: ${process.env.tsbundleCwd}`);
+  console.log(`from: ${process.env.tsbundleFrom}`);
+  console.log(`to: ${process.env.tsbundleTo}`);
+  console.log(`mode: ${process.env.tsbundleMode}`);
+  process.chdir(process.env.tsbundleCwd);
+  console.log(`switched to ${process.cwd()}`)
+  const tsbundleProcessInstance = new TsBundleProcess();
+  if (process.env.tsbundleMode === 'test') {
+    tsbundleProcessInstance.buildTest(process.env.tsbundleFrom, process.env.tsbundleTo, process.env.tsbundleBundler as 'rollup' | 'parcel');
+  } else {
+    tsbundleProcessInstance.buildProduction(process.env.tsbundleFrom, process.env.tsbundleTo);
+  }
+}
+
+run();

ts/tsbundle.cli.ts

@@ -10,12 +10,12 @@ export const runCli = async () => {
     // const htmlHandler = new HtmlHandler();
     switch (true) {
       case argvArg.production || process.env.CI:
-        await tsbundle.buildProduction(argvArg.from, argvArg.to);
+        await tsbundle.buildProduction(process.cwd(), argvArg.from, argvArg.to);
         // await htmlHandler.minifyHtml();
         break;
       case argvArg.test:
       default:
-        await tsbundle.buildTest(argvArg.from, argvArg.to);
+        await tsbundle.buildTest(process.cwd(), argvArg.from, argvArg.to, 'rollup');
         // await htmlHandler.copyHtml();
         return;
     }
@@ -26,12 +26,12 @@ export const runCli = async () => {
     // const htmlHandler = new HtmlHandler();
     switch (true) {
       case argvArg.production || process.env.CI:
-        await tsbundle.buildProduction('./ts_web/index.ts', './dist_bundle/bundle.js');
+        await tsbundle.buildProduction(process.cwd(), './ts_web/index.ts', './dist_bundle/bundle.js');
         // await htmlHandler.minifyHtml();
         break;
       case argvArg.test:
       default:
-        await tsbundle.buildTest('./ts_web/index.ts', './dist_bundle/bundle.js');
+        await tsbundle.buildTest(process.cwd(), './ts_web/index.ts', './dist_bundle/bundle.js', 'rollup');
         // await htmlHandler.copyHtml();
         return;
     }
@@ -42,12 +42,12 @@ export const runCli = async () => {
     // const htmlHandler = new HtmlHandler();
     switch (true) {
       case argvArg.production || process.env.CI:
-        await tsbundle.buildProduction('./ts/index.ts', './dist_bundle/bundle.js');
+        await tsbundle.buildProduction(process.cwd(), './ts/index.ts', './dist_bundle/bundle.js');
         // await htmlHandler.minifyHtml();
         break;
       case argvArg.test:
       default:
-        await tsbundle.buildTest('./ts/index.ts', './dist_bundle/bundle.js');
+        await tsbundle.buildTest(process.cwd(), './ts/index.ts', './dist_bundle/bundle.js', 'rollup');
         // await htmlHandler.copyHtml();
         return;
     }
@@ -58,12 +58,12 @@ export const runCli = async () => {
     const htmlHandler = new HtmlHandler();
     switch (true) {
       case argvArg.production || process.env.CI:
-        await tsbundle.buildProduction('./ts_web/index.ts', './dist_serve/bundle.js');
+        await tsbundle.buildProduction(process.cwd(), './ts_web/index.ts', './dist_serve/bundle.js');
         await htmlHandler.minifyHtml();
         break;
       case argvArg.test:
       default:
-        await tsbundle.buildTest('./ts_web/index.ts', './dist_serve/bundle.js');
+        await tsbundle.buildTest(process.cwd(), './ts_web/index.ts', './dist_serve/bundle.js', 'rollup');
         await htmlHandler.copyHtml();
         return;
     }

ts/tsbundle.plugins.ts

@@ -9,8 +9,10 @@ import * as smartfile from '@pushrocks/smartfile';
 import * as smartlog from '@pushrocks/smartlog';
 import * as smartlogDestinationLocal from '@pushrocks/smartlog-destination-local';
 import * as smartparcel from '@pushrocks/smartparcel';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartspawn from '@pushrocks/smartspawn';
 
-export { smartcli, smartfile, smartlog, smartlogDestinationLocal, smartparcel };
+export { smartcli, smartfile, smartlog, smartlogDestinationLocal, smartparcel, smartpromise, smartspawn };
 
 // third party scope
 import * as rollup from 'rollup';

tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true
+  }
+}