tsbundle/ts/mod_esbuild/index.child.ts

import * as plugins from './plugins.js';
import * as paths from '../paths.js';
import * as interfaces from '../interfaces/index.js';
import { logger } from '../tsbundle.logging.js';

export class TsBundleProcess {
  constructor() {
    // Nothing here
  }

  public async getAliases() {
    try {
      const aliasObject: Record<string, string> = {};
      const tsconfigPath = plugins.path.join(paths.cwd, 'tsconfig.json');
      const tsconfigContent = await plugins.fs
        .file(tsconfigPath)
        .encoding('utf8')
        .read();
      const localTsConfig = JSON.parse(tsconfigContent as string);
      if (
        localTsConfig.compilerOptions &&
        localTsConfig.compilerOptions.paths
      ) {
        for (const alias of Object.keys(localTsConfig.compilerOptions.paths)) {
          const aliasPath = localTsConfig.compilerOptions.paths[alias][0];
          aliasObject[alias] = aliasPath;
        }
      }
      return aliasObject;
    } catch (error) {
      return {};
    }
  }

  /**
   * creates a bundle for the test enviroment
   */
  public async buildTest(fromArg: string, toArg: string, argvArg: any) {
    // create a bundle
    const esbuild = await plugins.esbuild.build({
      entryPoints: [fromArg],
      bundle: true,
      sourcemap: true,
      format: 'esm',
      target: 'es2022',
      entryNames: plugins.path.parse(toArg).name,
      outdir: plugins.path.parse(toArg).dir,
      splitting: false,
      treeShaking: false,
      tsconfig: paths.tsconfigPath,
      alias: await this.getAliases(),
    });
  }

  /**
   * 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: 'es2022',
      minify: true,
      entryNames: plugins.path.parse(toArg).name,
      outdir: plugins.path.parse(toArg).dir,
      tsconfig: paths.tsconfigPath,
      splitting: false,
      treeShaking: false,
      chunkNames: 'chunks/[name]-[hash]',
      alias: await this.getAliases(),
    });
  }
}

const run = async () => {
  try {
    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:');
      await tsbundleProcessInstance.buildTest(
        plugins.smartpath.transform.makeAbsolute(
          transportOptions.from,
          process.cwd(),
        ),
        plugins.smartpath.transform.makeAbsolute(
          transportOptions.to,
          process.cwd(),
        ),
        transportOptions.argv,
      );
    } else {
      console.log('building for production:');
      await tsbundleProcessInstance.buildProduction(
        plugins.smartpath.transform.makeAbsolute(
          transportOptions.from,
          process.cwd(),
        ),
        plugins.smartpath.transform.makeAbsolute(
          transportOptions.to,
          process.cwd(),
        ),
        transportOptions.argv,
      );
    }
    process.exit(0);
  } catch (error: any) {
    console.error('\n\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m');
    console.error('\x1b[31m❌ BUILD FAILED\x1b[0m');
    console.error('\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m\n');

    if (error.errors && Array.isArray(error.errors)) {
      // esbuild errors - format them nicely
      console.error(`Found ${error.errors.length} error(s):\n`);
      for (const err of error.errors) {
        const file = err.location?.file || 'unknown';
        const line = err.location?.line || '?';
        const column = err.location?.column || '?';
        console.error(`  \x1b[36m${file}\x1b[0m:\x1b[33m${line}\x1b[0m:\x1b[33m${column}\x1b[0m`);
        console.error(`    ${err.text}\n`);
      }
    } else {
      console.error(error.message || error);
    }

    console.error('\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m\n');
    process.exit(1);
  }
};

run();