fix(core): update

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_rollup/htmlhandler.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,69 @@
+import * as plugins from './plugins.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,
+      outfile: toArg
+    });
+  }
+
+  /**
+   * creates a bundle for the production environment
+   */
+  public async buildProduction(
+    fromArg: string,
+    toArg: string,
+    argvArg: any
+  ) {
+    // create a bundle
+    const esbuild = await plugins.esbuild.build({
+      entryPoints: [fromArg],
+      bundle: true,
+      outfile: toArg
+    });
+  }
+}
+
+const run = async () => {
+  console.log('running spawned compilation process');
+  const transportOptions: interfaces.IEnvTransportOptions = JSON.parse(process.env.transportOptions);
+  console.log('bundling with 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.path.join(process.cwd(), transportOptions.from),
+      plugins.path.join(process.cwd(), transportOptions.to),
+      transportOptions.argv
+    );
+  } else {
+    console.log('building for production:')
+    tsbundleProcessInstance.buildProduction(
+      transportOptions.from,
+      transportOptions.to,
+      transportOptions.argv
+    );
+  }
+};
+
+run();

ts/mod_esbuild/plugins.ts

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

ts/mod_parcel/index.child.ts

@@ -0,0 +1,70 @@
+import * as plugins from './plugins.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
+  ) {
+    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
+    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: interfaces.IEnvTransportOptions = 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();

ts/mod_parcel/plugins.ts

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

ts/mod_rollup/htmlhandler.ts

@@ -1,5 +1,5 @@
-import * as plugins from './tsbundle.plugins.js';
-import * as paths from './tsbundle.paths.js';
+import * as plugins from './plugins.js';
+import * as paths from '../paths.js';
 
 export class HtmlHandler {
   public sourceFilePath: string = plugins.path.join(paths.htmlDir, 'index.html');

ts/mod_rollup/index.child.ts

@@ -1,5 +1,6 @@
-import * as plugins from './tsbundle.plugins.js';
-import { logger } from './tsbundle.logging.js';
+import * as plugins from './plugins.js';
+import * as interfaces from '../interfaces/index.js';
+import { logger } from '../tsbundle.logging.js';
 
 export class TsBundleProcess {
   /**
@@ -108,28 +109,16 @@ export class TsBundleProcess {
   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();
-    }
+    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);
   }
 
   /**
@@ -149,25 +138,23 @@ export class TsBundleProcess {
 
 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);
+  const transportOptions: interfaces.IEnvTransportOptions = JSON.parse(process.env.transportOptions);
+  console.log('bundling with rollup:');
+  console.log(transportOptions);
+  process.chdir(transportOptions.cwd);
   console.log(`switched to ${process.cwd()}`);
   const tsbundleProcessInstance = new TsBundleProcess();
-  if (process.env.tsbundleMode === 'test') {
+  if (transportOptions.mode === 'test') {
     tsbundleProcessInstance.buildTest(
-      process.env.tsbundleFrom,
-      process.env.tsbundleTo,
-      process.env.tsbundleBundler as 'rollup' | 'parcel',
-      JSON.parse(process.env.tsbundleArgv)
+      transportOptions.from,
+      transportOptions.to,
+      transportOptions.argv
     );
   } else {
     tsbundleProcessInstance.buildProduction(
-      process.env.tsbundleFrom,
-      process.env.tsbundleTo,
-      JSON.parse(process.env.tsbundleArgv)
+      transportOptions.from,
+      transportOptions.to,
+      transportOptions.argv
     );
   }
 };

ts/mod_rollup/plugins.ts

@@ -0,0 +1,25 @@
+export * from '../plugins.js';
+
+// 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,
+};

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(

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,63 +1,47 @@
-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 ? JSON.stringify(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'
+      }
+      if (argvArg.bundler === 'parcel') {
+        return './mod_parcel/index.child.js'
+      }
+      if (argvArg.bundler === 'rollup') {
+        return './mod_rollup/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: argvArg ? argvArg : {
+        bundler: 'esbuild'
+      } 
+    }
     const threadsimple = new plugins.smartspawn.ThreadSimple(
       plugins.path.join(
         plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
-        './tsbundle.class.tsbundleprocess.js'
+        getBundlerPath()
       ),
       [],
       {
         env: {
           ...process.env,
-          tsbundleMode: 'production',
-          tsbundleCwd: cwdArg,
-          tsbundleFrom: fromArg,
-          tsbundleTo: toArg,
-          tsbundleBundler: bundlerArg,
-          tsbundleArgv: argvArg ? JSON.stringify(argvArg) : '{}',
+          transportOptions: JSON.stringify(transportOptions),
         },
       }
     );

ts/tsbundle.cli.ts

@@ -1,108 +1,44 @@
-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 { 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();
-    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;
-    }
+    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
+    );
   });
 
   tsBundleCli.startParse();

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,
-};