1.0.93

.gitlab-ci.yml

@@ -12,6 +12,9 @@ stages:
   - release
   - metadata
 
+before_script:
+  - npm install -g @shipzone/npmci
+
 # ====================
 # security stage
 # ====================
@@ -19,23 +22,36 @@ mirror:
   stage: security
   script:
     - npmci git mirror
+  only:
+    - tags
   tags:
     - lossless
     - docker
     - notpriv
 
-audit:
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install --production --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=prod --production
+  tags:
+    - docker
+  allow_failure: true
+
+auditDevDependencies:
   image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
     - npmci npm prepare
     - npmci command npm install --ignore-scripts
     - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high
+    - npmci command npm audit --audit-level=high --only=dev
   tags:
-    - lossless
     - docker
-    - notpriv
+  allow_failure: true
 
 # ====================
 # test stage
@@ -50,9 +66,7 @@ testStable:
     - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - priv
 
 testBuild:
   stage: test
@@ -63,9 +77,7 @@ testBuild:
     - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - notpriv
 
 release:
   stage: release
@@ -85,6 +97,8 @@ release:
 codequality:
   stage: metadata
   allow_failure: true
+  only:
+    - tags
   script:
     - npmci command npm install -g tslint typescript
     - npmci npm prepare

.snyk

@@ -1,4 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.13.5
-ignore: {}
-patch: {}

.vscode/launch.json

@@ -2,28 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "current file",
+      "command": "npm test",
-      "type": "node",
+      "name": "Run npm test",
       "request": "launch",
-      "args": [
+      "type": "node-terminal"
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
     }
   ]
 }

.vscode/settings.json

@@ -15,7 +15,7 @@
             "properties": {
               "projectType": {
                 "type": "string",
-                "enum": ["website", "element", "service", "npm"]
+                "enum": ["website", "element", "service", "npm", "wcc"]
               }
             }
           }

cli.child.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+process.env.CLI_CALL = 'true';
+import * as cliTool from './ts/index.js';
+cliTool.runCli();

cli.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 process.env.CLI_CALL = 'true';
-const cliTool = require('./dist_ts/index');
+const cliTool = await import('./dist_ts/index.js');
 cliTool.runCli();

cli.ts.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
 process.env.CLI_CALL = 'true';
-require('@gitzone/tsrun');
+
-const cliTool = require('./ts/index');
+import * as tsrun from '@gitzone/tsrun';
-cliTool.runCli();
+tsrun.runPath('./cli.child.js', import.meta.url);

npmextra.json

@@ -5,7 +5,7 @@
       "githost": "gitlab.com",
       "gitscope": "gitzone",
       "gitrepo": "tsbundle",
-      "shortDescription": "a bundler using rollup for painless bundling of web projects",
+      "description": "a bundler using rollup for painless bundling of web projects",
       "npmPackagename": "@gitzone/tsbundle",
       "license": "MIT",
       "projectDomain": "git.zone"

package.json

@@ -1,51 +1,56 @@
 {
   "name": "@gitzone/tsbundle",
-  "version": "1.0.64",
+  "version": "1.0.93",
   "private": false,
   "description": "a bundler using rollup for painless bundling of web projects",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "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)",
+    "build": "(tsbuild --web)"
-    "format": "(gitzone format)"
   },
   "bin": {
     "tsbundle": "cli.js"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.22",
+    "@gitzone/tsbuild": "^2.1.48",
-    "@gitzone/tsrun": "^1.2.8",
+    "@gitzone/tsrun": "^1.2.31",
-    "@gitzone/tstest": "^1.0.28",
+    "@gitzone/tstest": "^1.0.67",
-    "@pushrocks/tapbundle": "^3.2.1",
+    "@pushrocks/tapbundle": "^5.0.2",
-    "tslint": "^6.1.0",
+    "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.15.0"
   },
   "dependencies": {
-    "@babel/core": "^7.8.7",
+    "@babel/core": "^7.17.5",
-    "@babel/plugin-proposal-class-properties": "^7.8.3",
+    "@babel/plugin-proposal-class-properties": "^7.16.7",
-    "@babel/plugin-proposal-decorators": "^7.8.3",
+    "@babel/plugin-proposal-decorators": "^7.17.2",
-    "@babel/plugin-transform-runtime": "^7.8.3",
+    "@babel/plugin-transform-runtime": "^7.17.0",
-    "@babel/preset-env": "^7.8.7",
+    "@babel/preset-env": "^7.16.11",
-    "@babel/runtime": "^7.8.7",
+    "@babel/runtime": "^7.17.2",
-    "@pushrocks/early": "^3.0.3",
+    "@pushrocks/early": "^3.0.6",
-    "@pushrocks/smartcli": "^3.0.9",
+    "@pushrocks/smartcli": "^3.0.14",
-    "@pushrocks/smartfile": "^7.0.11",
+    "@pushrocks/smartfile": "^9.0.6",
-    "@pushrocks/smartlog": "^2.0.21",
+    "@pushrocks/smartlog": "^2.0.44",
-    "@pushrocks/smartlog-destination-local": "^8.0.2",
+    "@pushrocks/smartlog-destination-local": "^8.0.8",
-    "@rollup/plugin-commonjs": "^11.0.2",
+    "@pushrocks/smartparcel": "^1.0.13",
-    "@rollup/plugin-node-resolve": "^7.1.1",
+    "@pushrocks/smartpath": "^5.0.4",
-    "@rollup/plugin-typescript": "^4.0.0",
+    "@pushrocks/smartpromise": "^3.1.7",
-    "@types/html-minifier": "^3.5.3",
+    "@pushrocks/smartspawn": "^2.0.9",
-    "@types/node": "^13.9.1",
+    "@rollup/plugin-commonjs": "^21.0.2",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.1.3",
+    "@rollup/plugin-typescript": "^8.3.1",
+    "@types/html-minifier": "^4.0.2",
+    "@types/node": "^17.0.21",
     "html-minifier": "^4.0.0",
-    "rollup": "^2.1.0",
+    "rollup": "^2.70.1",
     "rollup-plugin-babel": "^4.4.0",
-    "rollup-plugin-sourcemaps": "^0.5.0",
+    "rollup-plugin-sourcemaps": "^0.6.3",
-    "rollup-plugin-terser": "^5.3.0",
+    "rollup-plugin-terser": "^7.0.2",
-    "terser": "^4.6.7"
+    "typescript": "4.7.0"
   },
   "files": [
     "ts/**/*",
@@ -58,5 +63,8 @@
     "cli.js",
     "npmextra.json",
     "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
   ]
 }

readme.md

@@ -8,13 +8,20 @@ a bundler using rollup for painless bundling of web projects
 * [docs (typedoc)](https://gitzone.gitlab.io/tsbundle/)
 
 ## Status for master
-[![pipeline status](https://gitlab.com/gitzone/tsbundle/badges/master/pipeline.svg)](https://gitlab.com/gitzone/tsbundle/commits/master)
+
-[![coverage report](https://gitlab.com/gitzone/tsbundle/badges/master/coverage.svg)](https://gitlab.com/gitzone/tsbundle/commits/master)
+Status Category | Status Badge
-[![npm downloads per month](https://img.shields.io/npm/dm/@gitzone/tsbundle.svg)](https://www.npmjs.com/package/@gitzone/tsbundle)
+-- | --
-[![Known Vulnerabilities](https://snyk.io/test/npm/@gitzone/tsbundle/badge.svg)](https://snyk.io/test/npm/@gitzone/tsbundle)
+GitLab Pipelines | [![pipeline status](https://gitlab.com/gitzone/tsbundle/badges/master/pipeline.svg)](https://lossless.cloud)
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/gitzone/tsbundle/badges/master/coverage.svg)](https://lossless.cloud)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@gitzone/tsbundle)](https://lossless.cloud)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/gitzone/tsbundle)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@gitzone/tsbundle)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@gitzone/tsbundle)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@gitzone/tsbundle)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
 
 ## Usage
 
@@ -44,6 +51,7 @@ tsbundle --from="./ts/index.ts" --to="dist/bundle.js"
 ```
 
 ## API
+
 You are using TypeScript, aren't you? Most of the stuff is apparent from the IDE intellisense.
 
 ```typescript
@@ -52,10 +60,10 @@ import { TsBundle } from '@gitozne/tsbundle';
 const myTsBundleInstance = new TsBundle();
 
 const run = async () => {
-  await myTsBundleInstance.buildTest('./from/my.ts', './to/mybundle.js')
+  await myTsBundleInstance.buildTest('./from/my.ts', './to/mybundle.js');
   // OR
-  await myTsBundleInstance.buildProduction('./from/my.ts', './to/mybundle.js')
+  await myTsBundleInstance.buildProduction('./from/my.ts', './to/mybundle.js');
-}
+};
 ```
 
 ## Contribution

test/test.ts

@@ -1,8 +1,25 @@
 import { expect, tap } from '@pushrocks/tapbundle';
-import * as tsbundle from '../ts/index';
+import * as tsbundle from '../dist_ts/index.js';
 
-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/index.ts

@@ -1,13 +1,13 @@
 import * as early from '@pushrocks/early';
 early.start('tsbundle');
 // lets import all plugins beforehand
-import './tsbundle.plugins';
+import './tsbundle.plugins.js';
 
-import { logger } from './tsbundle.logging';
+import { logger } from './tsbundle.logging.js';
-import { runCli } from './tsbundle.cli';
+import { runCli } from './tsbundle.cli.js';
 early.stop();
 
 // lets make this usable programmatically
-export * from './tsbundle.class.tsbundle';
+export * from './tsbundle.class.tsbundle.js';
-export * from './tsbundle.htmlhandler';
+export * from './tsbundle.htmlhandler.js';
 export { runCli };

ts/tsbundle.class.tsbundle.ts

@@ -1,127 +1,64 @@
-import * as plugins from './tsbundle.plugins';
+import * as plugins from './tsbundle.plugins.js';
-import { logger } from './tsbundle.logging';
+import { logger } from './tsbundle.logging.js';
 
 export class TsBundle {
-  /**
+  public async buildTest (
-   * the basic default options for rollup
+    cwdArg: string,
-   */
+    fromArg: string,
-  public getBaseOptions(
+    toArg: string,
-    fromArg: string = `ts_web/index.ts`,
+    bundlerArg: 'rollup' | 'parcel',
-    toArg: string = 'dist_bundle/bundle.js'
+    argvArg: any
   ) {
-    logger.log('info', `from: ${fromArg}`);
+    const done = plugins.smartpromise.defer();
-    logger.log('info', `to: ${toArg}`);
+    const threadsimple = new plugins.smartspawn.ThreadSimple(
-
+      plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), './tsbundle.class.tsbundleprocess.js'),
-    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'
-        }),
-        // 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({
-          namedExports: {
-            'node_modules/@pushrocks/smartstate/dist/index.js': ['Smartstate']
-          }
-        }),
-
-        // 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,
+        env: {
-                targets: {
+          ...process.env,
-                  chrome: '41'
+          tsbundleMode: 'test',
+          tsbundleCwd: cwdArg,
+          tsbundleFrom: fromArg,
+          tsbundleTo: toArg,
+          tsbundleBundler: bundlerArg,
+          tsbundleArgv: argvArg,
+        },
       }
-              }
-            ]
-          ],
-          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,
-        sourcemap: true
-      })
     );
-    return productionOptions;
+    const childProcess = await threadsimple.start();
+    childProcess.on('exit', (status) => {
+      done.resolve();
+    });
+    await done.promise;
   }
 
-  constructor() {
+  public async buildProduction (
-    // Nothing here
+    cwdArg: string,
+    fromArg: string,
+    toArg: string,
+    bundlerArg: 'rollup' | 'parcel',
+    argvArg: any
+  ) {
+    const done = plugins.smartpromise.defer();
+    const threadsimple = new plugins.smartspawn.ThreadSimple(
+      plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), './tsbundle.class.tsbundleprocess.js'),
+      [],
+      {
+        env: {
+          ...process.env,
+          tsbundleMode: 'production',
+          tsbundleCwd: cwdArg,
+          tsbundleFrom: fromArg,
+          tsbundleTo: toArg,
+          tsbundleBundler: bundlerArg,
+          tsbundleArgv: argvArg,
+        },
       }
-
+    );
-  /**
+    const childProcess = await threadsimple.start();
-   * creates a bundle for the test enviroment
+    childProcess.on('exit', (status) => {
-   */
+      done.resolve();
-  public async buildTest(fromArg: string, toArg: string) {
+    });
-    // create a bundle
+    await done.promise;
-    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!`);
-  }
-
-  /**
-   * 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!`);
   }
 }

ts/tsbundle.class.tsbundleprocess.ts

@@ -0,0 +1,157 @@
+import * as plugins from './tsbundle.plugins.js';
+import { logger } from './tsbundle.logging.js';
+
+export class TsBundleProcess {
+  /**
+   * the basic default options for rollup
+   */
+  public getBaseOptions(
+    fromArg: string = `ts_web/index.ts`,
+    toArg: string = 'dist_bundle/bundle.js',
+    argvArg: any
+  ) {
+    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 as any)({
+          include: plugins.path.parse(fromArg).dir
+            ? plugins.path.parse(fromArg).dir + '/**/*.ts'
+            : '**/*.ts',
+          declaration: false,
+          emitDecoratorMetadata: true,
+          experimentalDecorators: true,
+          inlineSourceMap: true,
+          noEmitOnError: true,
+          lib: ['dom'],
+          noImplicitAny: false,
+          target: 'es2020',
+          module: 'es2020',
+          moduleResolution: 'node12',
+          allowSyntheticDefaultImports: true,
+          importsNotUsedAsValues: 'preserve',
+          ...argvArg && argvArg.skiplibcheck ? {
+            skipLibCheck: true
+          } : {},
+          ...argvArg && argvArg.allowimplicitany ? {
+            noImplicitAny: false
+          } : {},
+          ...argvArg && argvArg.commonjs ? {
+            module: 'commonjs',
+            moduleResolution: 'node',
+          } : {},
+        }),
+        (plugins.rollupJson as any)(),
+        // 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 as any)({}),
+
+        // Resolve source maps to the original source
+        plugins.rollupSourceMaps(),
+      ],
+    };
+    return baseOptions;
+  }
+
+  public getOptionsTest(fromArg: string, toArg: string, argvArg: any): plugins.rollup.RollupOptions {
+    return this.getBaseOptions(fromArg, toArg, argvArg);
+  }
+
+  public getOptionsProduction(fromArg: string, toArg: string, argvArg: any): plugins.rollup.RollupOptions {
+    const productionOptions = this.getBaseOptions(fromArg, toArg, argvArg);
+    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',
+    argvArg: any
+  ) {
+    // create a bundle
+    switch (bundlerArg) {
+      case 'rollup':
+        logger.log('info', `bundling for TEST!`);
+        const buildOptions = this.getOptionsTest(fromArg, toArg, argvArg);
+        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, argvArg: any) {
+    // create a bundle
+    logger.log('info', `bundling for PRODUCTION!`);
+    const buildOptions = this.getOptionsProduction(fromArg, toArg, argvArg);
+    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',
+      process.env.tsbundleArgv
+    );
+  } else {
+    tsbundleProcessInstance.buildProduction(process.env.tsbundleFrom, process.env.tsbundleTo, process.env.tsbundleArgv);
+  }
+};
+
+run();

ts/tsbundle.cli.ts

@@ -1,69 +1,105 @@
-import * as plugins from './tsbundle.plugins';
+import * as plugins from './tsbundle.plugins.js';
-import { TsBundle } from './tsbundle.class.tsbundle';
+import { TsBundle } from './tsbundle.class.tsbundle.js';
-import { HtmlHandler } from './tsbundle.htmlhandler';
+import { HtmlHandler } from './tsbundle.htmlhandler.js';
-import { logger } from './tsbundle.logging';
+import { logger } from './tsbundle.logging.js';
 
 export const runCli = async () => {
   const tsBundleCli = new plugins.smartcli.Smartcli();
-  tsBundleCli.standardTask().subscribe(async argvArg => {
+  tsBundleCli.standardTask().subscribe(async (argvArg) => {
     const tsbundle = new TsBundle();
     // 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, 'rollup', argvArg);
         // 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', argvArg);
         // await htmlHandler.copyHtml();
         return;
     }
   });
 
-  tsBundleCli.addCommand('element').subscribe(async argvArg => {
+  tsBundleCli.addCommand('element').subscribe(async (argvArg) => {
     const tsbundle = new TsBundle();
     // 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',
+          'rollup',
+          argvArg
+        );
         // 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',
+          argvArg
+        );
         // await htmlHandler.copyHtml();
         return;
     }
   });
 
-  tsBundleCli.addCommand('npm').subscribe(async argvArg => {
+  tsBundleCli.addCommand('npm').subscribe(async (argvArg) => {
     const tsbundle = new TsBundle();
     // const htmlHandler = new HtmlHandler();
     switch (true) {
       case argvArg.production || process.env.CI:
-        await tsbundle.buildProduction('./ts/index.ts', './dist_ts/bundle.js');
+        await tsbundle.buildProduction(
+          process.cwd(),
+          './ts/index.ts',
+          './dist_bundle/bundle.js',
+          'rollup',
+          argvArg
+        );
         // await htmlHandler.minifyHtml();
         break;
       case argvArg.test:
       default:
-        await tsbundle.buildTest('./ts/index.ts', './dist_ts/bundle.js');
+        await tsbundle.buildTest(
+          process.cwd(),
+          './ts/index.ts',
+          './dist_bundle/bundle.js',
+          'rollup',
+          argvArg
+        );
         // await htmlHandler.copyHtml();
         return;
     }
   });
 
-  tsBundleCli.addCommand('website').subscribe(async argvArg => {
+  tsBundleCli.addCommand('website').subscribe(async (argvArg) => {
     const tsbundle = new TsBundle();
     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',
+          'rollup',
+          argvArg
+        );
         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',
+          argvArg
+        );
         await htmlHandler.copyHtml();
         return;
     }

ts/tsbundle.htmlhandler.ts

@@ -1,5 +1,5 @@
-import * as plugins from './tsbundle.plugins';
+import * as plugins from './tsbundle.plugins.js';
-import * as paths from './tsbundle.paths';
+import * as paths from './tsbundle.paths.js';
 
 export class HtmlHandler {
   public sourceFilePath: string = plugins.path.join(paths.htmlDir, 'index.html');
@@ -31,7 +31,7 @@ export class HtmlHandler {
       removeAttributeQuotes: true,
       collapseWhitespace: true,
       collapseInlineTagWhitespace: true,
-      removeComments: true
+      removeComments: true,
     });
     plugins.smartfile.memory.toFsSync(minifiedHtml, targetPathArg);
   }

ts/tsbundle.logging.ts

@@ -1,4 +1,4 @@
-import * as plugins from './tsbundle.plugins';
+import * as plugins from './tsbundle.plugins.js';
 
 export const logger = new plugins.smartlog.Smartlog({
   logContext: {
@@ -7,9 +7,9 @@ export const logger = new plugins.smartlog.Smartlog({
     containerName: 'Some Containername',
     environment: 'local',
     runtime: 'node',
-    zone: 'gitzone'
+    zone: 'gitzone',
   },
-  minimumLogLevel: 'silly'
+  minimumLogLevel: 'silly',
 });
 
 logger.addLogDestination(new plugins.smartlogDestinationLocal.DestinationLocal());

ts/tsbundle.paths.ts

@@ -1,7 +1,10 @@
-import * as plugins from './tsbundle.plugins';
+import * as plugins from './tsbundle.plugins.js';
 
 export const cwd = process.cwd();
-export const packageDir = plugins.path.join(__dirname, '../');
+export const packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../'
+);
 export const htmlDir = plugins.path.join(cwd, './html');
 export const distServeDir = plugins.path.join(cwd, './dist_serve');
 export const assetsDir = plugins.path.join(packageDir, 'assets');

ts/tsbundle.plugins.ts

@@ -8,13 +8,27 @@ import * as smartcli from '@pushrocks/smartcli';
 import * as smartfile from '@pushrocks/smartfile';
 import * as smartlog from '@pushrocks/smartlog';
 import * as smartlogDestinationLocal from '@pushrocks/smartlog-destination-local';
+import * as smartpath from '@pushrocks/smartpath';
+import * as smartparcel from '@pushrocks/smartparcel';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartspawn from '@pushrocks/smartspawn';
 
-export { smartcli, smartfile, smartlog, smartlogDestinationLocal };
+export {
+  smartcli,
+  smartfile,
+  smartlog,
+  smartlogDestinationLocal,
+  smartpath,
+  smartparcel,
+  smartpromise,
+  smartspawn,
+};
 
 // third party scope
 import * as rollup from 'rollup';
 import rollupBabel from 'rollup-plugin-babel';
 import rollupCommonjs from '@rollup/plugin-commonjs';
+import rollupJson from '@rollup/plugin-json';
 import rollupResolve from '@rollup/plugin-node-resolve';
 import rollupSourceMaps from 'rollup-plugin-sourcemaps';
 import { terser as rollupTerser } from 'rollup-plugin-terser';
@@ -26,9 +40,10 @@ export {
   rollup,
   rollupBabel,
   rollupCommonjs,
+  rollupJson,
   rollupResolve,
   rollupSourceMaps,
   rollupTerser,
   rollupTypescript,
-  htmlMinifier
+  htmlMinifier,
 };

tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "target": "ES2020",
+    "module": "ES2020",
+    "moduleResolution": "node12",
+    "esModuleInterop": true
+  }
+}