1.0.104

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gitzone/tsbundle",
-  "version": "1.0.93",
+  "version": "1.0.104",
   "private": false,
   "description": "a bundler using rollup for painless bundling of web projects",
   "main": "dist_ts/index.js",
@@ -10,46 +10,30 @@
   "license": "MIT",
   "scripts": {
     "test": "npm run build && (tstest test/) && (cd test && node ../cli.js --production)",
-    "build": "(tsbuild --web)"
+    "build": "(tsbuild --web --allowimplicitany)"
   },
   "bin": {
     "tsbundle": "cli.js"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.48",
+    "@gitzone/tsbuild": "^2.1.59",
     "@gitzone/tsrun": "^1.2.31",
-    "@gitzone/tstest": "^1.0.67",
-    "@pushrocks/tapbundle": "^5.0.2",
-    "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.15.0"
+    "@gitzone/tstest": "^1.0.69",
+    "@pushrocks/tapbundle": "^5.0.2"
   },
   "dependencies": {
-    "@babel/core": "^7.17.5",
-    "@babel/plugin-proposal-class-properties": "^7.16.7",
-    "@babel/plugin-proposal-decorators": "^7.17.2",
-    "@babel/plugin-transform-runtime": "^7.17.0",
-    "@babel/preset-env": "^7.16.11",
-    "@babel/runtime": "^7.17.2",
     "@pushrocks/early": "^3.0.6",
     "@pushrocks/smartcli": "^3.0.14",
     "@pushrocks/smartfile": "^9.0.6",
     "@pushrocks/smartlog": "^2.0.44",
     "@pushrocks/smartlog-destination-local": "^8.0.8",
-    "@pushrocks/smartparcel": "^1.0.13",
-    "@pushrocks/smartpath": "^5.0.4",
+    "@pushrocks/smartpath": "^5.0.5",
     "@pushrocks/smartpromise": "^3.1.7",
     "@pushrocks/smartspawn": "^2.0.9",
-    "@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",
+    "esbuild": "0.14.27",
     "html-minifier": "^4.0.0",
-    "rollup": "^2.70.1",
-    "rollup-plugin-babel": "^4.4.0",
-    "rollup-plugin-sourcemaps": "^0.6.3",
-    "rollup-plugin-terser": "^7.0.2",
     "typescript": "4.7.0"
   },
   "files": [

rollup.config.js

@@ -1,57 +0,0 @@
-import resolve from 'rollup-plugin-node-resolve';
-import commonjs from 'rollup-plugin-commonjs';
-import sourceMaps from 'rollup-plugin-sourcemaps';
-import typescript from 'rollup-plugin-typescript2';
-import json from 'rollup-plugin-json';
-import babel from 'rollup-plugin-babel';
-
-const pkg = require('./package.json');
-
-export default {
-  input: `ts_web/index.ts`,
-  output: {
-    name: 'tsbundle',
-    // file: 'dist_web/bundle.js',
-    file: 'dist_web/bundle.js',
-    format: 'iife',
-    sourcemap: true
-  },
-  // Indicate here external modules you don't wanna include in your bundle (i.e.: 'lodash')
-  external: [],
-  watch: {
-    include: 'src/**'
-  },
-  plugins: [
-    // Allow json resolution
-    json(),
-    // Compile TypeScript files
-    typescript({ useTsconfigDeclarationDir: true, tsconfigOverride: {
-      compilerOptions: {
-        declaration: true,
-        emitDecoratorMetadata: true,
-        experimentalDecorators: true,
-        inlineSourceMap: true,
-        noEmitOnError: true,
-        lib: ['es2016', 'es2017', 'dom'],
-        noImplicitAny: false
-      }
-    } }),
-    // 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
-    resolve(),
-    commonjs({
-      namedExports: {
-          'node_modules/@pushrocks/smartstate/dist/index.js': ['Smartstate']
-      }
-    }),
-
-    // Resolve source maps to the original source
-    sourceMaps(),
-    babel({
-      extensions: ['.js', '.jsx', '.ts', '.tsx'],
-      babelrc: false,
-      presets: [["@babel/preset-env", { modules: false }]]
-    })
-  ]
-};

test/test.ts

@@ -1,25 +1,17 @@
 import { expect, tap } from '@pushrocks/tapbundle';
-import * as tsbundle from '../dist_ts/index.js';
+import * as tsbundle from '../ts/index.js';
 
-import * as path from 'path';
-
-tap.test('should bundle test', async () => {
+tap.test('should bundle with esbuild', async () => {
   const tsbundleInstance = new tsbundle.TsBundle();
-  await tsbundleInstance.buildTest(
+  await tsbundleInstance.build(
     process.cwd() + '/test',
     './ts_web/index.ts',
     './dist_manual/test.js',
-    'rollup'
+    {
+      bundler: 'esbuild'
+    }
   );
 });
 
-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();

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@gitzone/tsbundle',
+  version: '1.0.104',
+  description: 'a bundler using rollup for painless bundling of web projects'
+}

ts/index.ts

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

ts/interfaces/index.ts

@@ -0,0 +1,14 @@
+export interface ICliOptions {
+  commonjs?: boolean;
+  skiplibcheck?: boolean;
+  production?: boolean;
+  bundler: 'parcel' | 'esbuild' | 'rollup'
+}
+
+export interface IEnvTransportOptions {
+  cwd: string;
+  from: string;
+  to: string;
+  mode: 'test' | 'production',
+  argv: ICliOptions
+}

ts/mod_esbuild/index.child.ts

@@ -0,0 +1,81 @@
+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
+  }
+
+  /**
+   * creates a bundle for the test enviroment
+   */
+  public async buildTest(
+    fromArg: string,
+    toArg: string,
+    argvArg: any
+  ) {
+    // create a bundle
+    const esbuild = await plugins.esbuild.build({
+      entryPoints: [fromArg],
+      bundle: true,
+      sourcemap: true,
+      format: 'esm',
+      target: 'es2020',
+      outfile: toArg,
+      tsconfig: paths.tsconfigPath
+    });
+  }
+
+  /**
+   * creates a bundle for the production environment
+   */
+  public async buildProduction(
+    fromArg: string,
+    toArg: string,
+    argvArg: any
+  ) {
+    // create a bundle
+    console.log('esbuild specific:');
+    console.log(`from: ${fromArg}`);
+    console.log((`to: ${toArg}`));
+    const esbuild = await plugins.esbuild.build({
+      entryPoints: [fromArg],
+      bundle: true,
+      sourcemap: true,
+      format: 'esm',
+      target: 'es2020',
+      minify: true,
+      outfile: toArg
+    });
+  }
+}
+
+const run = async () => {
+  console.log('running spawned compilation process');
+  const transportOptions: interfaces.IEnvTransportOptions = JSON.parse(process.env.transportOptions);
+  console.log('=======> ESBUILD');
+  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:')
+    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:')
+    tsbundleProcessInstance.buildProduction(
+      plugins.smartpath.transform.makeAbsolute(transportOptions.from, process.cwd()),
+      plugins.smartpath.transform.makeAbsolute(transportOptions.to, process.cwd()),
+      transportOptions.argv
+    );
+  }
+};
+
+run();

ts/mod_esbuild/plugins.ts

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

ts/mod_html/index.ts

@@ -0,0 +1,44 @@
+import * as plugins from './plugins.js';
+import * as paths from '../paths.js';
+
+export class HtmlHandler {
+  public defaultFromPath: string = plugins.path.join(paths.htmlDir, 'index.html');
+  public defaultToPath: string = plugins.path.join(paths.distServeDir, 'index.html');
+
+  public async checkIfExists() {
+    return plugins.smartfile.fs.fileExists(this.defaultFromPath);
+  }
+
+  // copies the html
+  public async copyHtml(fromArg: string = this.defaultFromPath, toArg: string = this.defaultToPath) {
+    if (await this.checkIfExists()) {
+      console.log(`${fromArg} replaces file at ${toArg}`);
+    }
+    fromArg = plugins.smartpath.transform.toAbsolute(fromArg, paths.cwd) as string;
+    toArg = plugins.smartpath.transform.toAbsolute(toArg, paths.cwd) as string;
+    await plugins.smartfile.fs.copy(fromArg, toArg);
+    console.log(`html copy succeeded!`);
+  }
+
+  // copies and minifies the html
+  public async minifyHtml(fromArg: string = this.defaultFromPath, toArg: string = this.defaultToPath) {
+    if (await this.checkIfExists()) {
+      console.log(`${fromArg} replaces file at ${toArg}`);
+    }
+    fromArg = plugins.smartpath.transform.toAbsolute(fromArg, paths.cwd) as string;
+    toArg = plugins.smartpath.transform.toAbsolute(toArg, paths.cwd) as string;
+    const fileString = plugins.smartfile.fs.toStringSync(fromArg);
+    const minifiedHtml = plugins.htmlMinifier.minify(fileString, {
+      minifyCSS: true,
+      minifyJS: true,
+      sortAttributes: true,
+      sortClassName: true,
+      removeAttributeQuotes: true,
+      collapseWhitespace: true,
+      collapseInlineTagWhitespace: true,
+      removeComments: true,
+    });
+    await plugins.smartfile.memory.toFs(minifiedHtml, toArg);
+    console.log(`html minification succeeded!`);
+  }
+}

ts/mod_html/plugins.ts

@@ -0,0 +1,7 @@
+export * from '../plugins.js';
+
+import * as htmlMinifier from 'html-minifier';
+
+export {
+  htmlMinifier
+}

ts/paths.ts

@@ -1,4 +1,4 @@
-import * as plugins from './tsbundle.plugins.js';
+import * as plugins from './plugins.js';
 
 export const cwd = process.cwd();
 export const packageDir = plugins.path.join(
@@ -8,3 +8,4 @@ export const packageDir = plugins.path.join(
 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');
+export const tsconfigPath = plugins.path.join(packageDir, './tsconfig.json');

ts/plugins.ts

@@ -0,0 +1,23 @@
+// node native
+import * as path from 'path';
+
+export { path };
+
+// pushrocks scope
+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 smartpromise from '@pushrocks/smartpromise';
+import * as smartspawn from '@pushrocks/smartspawn';
+
+export {
+  smartcli,
+  smartfile,
+  smartlog,
+  smartlogDestinationLocal,
+  smartpath,
+  smartpromise,
+  smartspawn,
+};

ts/tsbundle.class.tsbundle.ts

@@ -1,57 +1,42 @@
-import * as plugins from './tsbundle.plugins.js';
+import * as plugins from './plugins.js';
+import * as interfaces from './interfaces/index.js';
 import { logger } from './tsbundle.logging.js';
 
 export class TsBundle {
-  public async buildTest (
-    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: 'test',
-          tsbundleCwd: cwdArg,
-          tsbundleFrom: fromArg,
-          tsbundleTo: toArg,
-          tsbundleBundler: bundlerArg,
-          tsbundleArgv: argvArg,
-        },
-      }
-    );
-    const childProcess = await threadsimple.start();
-    childProcess.on('exit', (status) => {
-      done.resolve();
-    });
-    await done.promise;
-  }
 
-  public async buildProduction (
+  public async build(
     cwdArg: string,
-    fromArg: string,
-    toArg: string,
-    bundlerArg: 'rollup' | 'parcel',
-    argvArg: any
+    fromArg: string = './ts_web/index.ts',
+    toArg: string = './dist_bundle/bundle.js',
+    argvArg: interfaces.ICliOptions
   ) {
     const done = plugins.smartpromise.defer();
+    const getBundlerPath = () => {
+      if (argvArg.bundler === 'esbuild') {
+        return './mod_esbuild/index.child.js'
+      }
+      return './mod_esbuild/index.child.js'
+    }
+    const transportOptions: interfaces.IEnvTransportOptions = {
+      cwd: cwdArg,
+      from: fromArg,
+      to: toArg,
+      mode: argvArg && argvArg.production ? 'production' : 'test',
+      argv:  {
+        bundler: 'esbuild',
+        ...argvArg
+      } 
+    }
     const threadsimple = new plugins.smartspawn.ThreadSimple(
-      plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), './tsbundle.class.tsbundleprocess.js'),
+      plugins.path.join(
+        plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+        getBundlerPath()
+      ),
       [],
       {
         env: {
           ...process.env,
-          tsbundleMode: 'production',
-          tsbundleCwd: cwdArg,
-          tsbundleFrom: fromArg,
-          tsbundleTo: toArg,
-          tsbundleBundler: bundlerArg,
-          tsbundleArgv: argvArg,
+          transportOptions: JSON.stringify(transportOptions),
         },
       }
     );

ts/tsbundle.class.tsbundleprocess.ts

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

ts/tsbundle.htmlhandler.ts

@@ -1,38 +0,0 @@
-import * as plugins from './tsbundle.plugins.js';
-import * as paths from './tsbundle.paths.js';
-
-export class HtmlHandler {
-  public sourceFilePath: string = plugins.path.join(paths.htmlDir, 'index.html');
-  public targetFilePath: string = plugins.path.join(paths.distServeDir, 'index.html');
-
-  public async checkIfExists() {
-    return plugins.smartfile.fs.fileExists(this.sourceFilePath);
-  }
-
-  // copies the html
-  public async copyHtml(targetPathArg = this.targetFilePath) {
-    if (!(await this.checkIfExists())) {
-      return;
-    }
-    await plugins.smartfile.fs.copy(this.sourceFilePath, targetPathArg);
-  }
-
-  // copies and minifies the html
-  public 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);
-  }
-}

ts/tsbundle.logging.ts

@@ -1,4 +1,4 @@
-import * as plugins from './tsbundle.plugins.js';
+import * as plugins from './plugins.js';
 
 export const logger = new plugins.smartlog.Smartlog({
   logContext: {

ts/tsbundle.plugins.ts

@@ -1,49 +0,0 @@
-// node native
-import * as path from 'path';
-
-export { path };
-
-// pushrocks scope
-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,
-  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';
-import rollupTypescript from '@rollup/plugin-typescript';
-
-import * as htmlMinifier from 'html-minifier';
-
-export {
-  rollup,
-  rollupBabel,
-  rollupCommonjs,
-  rollupJson,
-  rollupResolve,
-  rollupSourceMaps,
-  rollupTerser,
-  rollupTypescript,
-  htmlMinifier,
-};

tsconfig.json

@@ -4,6 +4,8 @@
     "target": "ES2020",
     "module": "ES2020",
     "moduleResolution": "node12",
+    "useDefineForClassFields": false,
+    "preserveValueImports": true,
     "esModuleInterop": true
   }
 }

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}