@travetto/compiler 3.0.0-rc.12 → 3.0.0-rc.13

package/bin/trv.js

@@ -11,7 +11,7 @@ const VALID_OPS = { watch: 'watch', build: 'build', clean: 'clean', manifest: 'm
 
 /**
  * @param {import('@travetto/manifest').ManifestContext} ctx
- * @return {Promise<import('@travetto/compiler/support/launcher')>}
+ * @return {Promise<import('@travetto/compiler/support/launcher').launch>}
  */
 const $getLauncher = async (ctx) => {
   const compPkg = createRequire(path.resolve('node_modules')).resolve('@travetto/compiler/package.json');
@@ -48,49 +48,20 @@ const $getLauncher = async (ctx) => {
     files.push(target);
   }
 
-  try { return await require(files[0]); }
-  catch { return import(files[0]); }
+  try { return require(files[0]).launch; }
+  catch { return import(files[0]).then(x => x.launch); }
 };
 
-/**
- * Parse arguments
- * @param {string[]} args
- * @returns {{ op?: keyof typeof VALID_OPS, clean?: boolean, outputPath?: string, env?: string }}
- */
-function parseArgs(args) {
-  const op = VALID_OPS[args.find(x => !x.startsWith('-')) ?? ''];
-  return {
-    op,
-    clean: args.includes('--clean') || args.includes('-c'),
-    ...(op === 'manifest' ? { outputPath: args[1], env: args[2] } : {})
-  };
-}
-
-const exec = async () => {
+(async () => {
   const ctx = await getManifestContext();
-  const { op, outputPath, env, ...flags } = parseArgs(process.argv.slice(2));
+  const [op, args] = [VALID_OPS[process.argv[2]], process.argv.slice(3)];
 
-  // Clean if needed
-  if (op === 'clean' || (op && flags.clean)) {
+  if (op === 'clean') {
     for (const f of [ctx.outputFolder, ctx.compilerFolder]) {
       await fs.rm(path.resolve(ctx.workspacePath, f), { force: true, recursive: true });
     }
-  }
-
-  if (op === 'clean') { // Clean needs to not attempt to compile/load launcher
     return console.log(`Cleaned ${ctx.workspacePath}: [${ctx.outputFolder}, ${ctx.compilerFolder}]`);
   }
 
-  const { compile, launchMain, exportManifest } = await $getLauncher(ctx);
-
-  switch (op) {
-    case 'manifest': return exportManifest(ctx, outputPath ?? '', env);
-    case 'watch':
-    case 'build': return compile(ctx, op);
-    default:
-      await compile(ctx, op);
-      return launchMain(ctx);
-  }
-};
-
-exec();
+  return (await $getLauncher(ctx))(ctx, op, args);
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "3.0.0-rc.12",
+  "version": "3.0.0-rc.13",
   "description": "Compiler",
   "keywords": [
     "compiler",
@@ -31,12 +31,12 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.1.0",
-    "@travetto/manifest": "^3.0.0-rc.7",
+    "@travetto/manifest": "^3.0.0-rc.8",
     "@travetto/terminal": "^3.0.0-rc.6",
-    "@travetto/transformer": "^3.0.0-rc.10"
+    "@travetto/transformer": "^3.0.0-rc.11"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.0-rc.9"
+    "@travetto/cli": "^3.0.0-rc.10"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/state.ts

@@ -189,7 +189,7 @@ export class CompilerState {
         data?: ts.WriteFileCallbackData
       ): void => {
         if (outputFile.endsWith('package.json')) {
-          text = CompilerUtil.rewritePackageJSON(this.#manifest, text, options);
+          text = CompilerUtil.rewritePackageJSON(this.#manifest, text);
         } else if (!options.inlineSourceMap && options.sourceMap && outputFile.endsWith('.map')) {
           text = CompilerUtil.rewriteSourceMap(this.#manifest.workspacePath, text, f => this.#sourceInputOutput.get(this.#inputToSource.get(f)!));
         } else if (options.inlineSourceMap && CompilerUtil.isSourceMapUrlPosData(data)) {

package/src/util.ts

@@ -79,7 +79,7 @@ export class CompilerUtil {
    * @param text
    * @returns
    */
-  static rewritePackageJSON(manifest: ManifestRoot, text: string, opts: ts.CompilerOptions): string {
+  static rewritePackageJSON(manifest: ManifestRoot, text: string): string {
     const pkg: Package = JSON.parse(text);
     if (pkg.files) {
       pkg.files = pkg.files.map(x => this.inputToOutput(x));
@@ -87,7 +87,7 @@ export class CompilerUtil {
     if (pkg.main) {
       pkg.main = this.inputToOutput(pkg.main);
     }
-    pkg.type = opts.module !== ts.ModuleKind.CommonJS ? 'module' : 'commonjs';
+    pkg.type = manifest.moduleType;
     for (const key of ['devDependencies', 'dependencies', 'peerDependencies'] as const) {
       if (key in pkg) {
         for (const dep of Object.keys(pkg[key] ?? {})) {

package/support/launcher.ts

@@ -1,6 +1,5 @@
 import fs from 'fs/promises';
 import path from 'path';
-import { Module } from 'module';
 
 import type { ManifestContext } from '@travetto/manifest';
 import { TranspileUtil } from './transpile';
@@ -20,7 +19,7 @@ async function compileIfStale(ctx: ManifestContext, scope: string, mod: string,
   const out: string[] = [];
 
   try {
-    await TranspileUtil.withLogger(scope, { args: [mod], basic: false }, async log => {
+    await TranspileUtil.withLogger(scope, async log => {
       if (files.some(f => f.stale)) {
         log('debug', 'Starting');
         for (const file of files.filter(x => x.stale)) {
@@ -34,7 +33,7 @@ async function compileIfStale(ctx: ManifestContext, scope: string, mod: string,
       } else {
         log('debug', 'Skipped');
       }
-    });
+    }, false, [mod]);
   } catch (err) {
     console.error(err);
   }
@@ -44,7 +43,7 @@ async function compileIfStale(ctx: ManifestContext, scope: string, mod: string,
 /**
  * Run the compiler
  */
-export async function compile(ctx: ManifestContext, op?: 'watch' | 'build'): Promise<void> {
+async function compile(ctx: ManifestContext, op?: 'watch' | 'build'): Promise<void> {
   let changes = 0;
 
   await TranspileUtil.withLogger('precompile', async () => {
@@ -73,8 +72,10 @@ export async function compile(ctx: ManifestContext, op?: 'watch' | 'build'): Pro
   });
 
   if (changes) {
-    await fs.rm(path.resolve(ctx.workspacePath, ctx.outputFolder), { recursive: true, force: true });
-    TranspileUtil.log('reset', [], 'info', 'Clearing output due to compiler changes');
+    await TranspileUtil.withLogger('reset', async log => {
+      await fs.rm(path.resolve(ctx.workspacePath, ctx.outputFolder), { recursive: true, force: true });
+      log('info', 'Clearing output due to compiler changes');
+    }, false);
   }
 
   // Write manifest
@@ -95,7 +96,7 @@ export async function compile(ctx: ManifestContext, op?: 'watch' | 'build'): Pro
     }
   });
 
-  await TranspileUtil.withLogger('compile', { args: [], basic: false }, async log => {
+  await TranspileUtil.withLogger('compile', async log => {
     const changed = delta.filter(x => x.type === 'added' || x.type === 'changed');
     log('debug', `Started action=${op} changed=${changed.map(x => `${x.module}/${x.file}`)}`);
     if (changed.length || op === 'watch') {
@@ -104,17 +105,13 @@ export async function compile(ctx: ManifestContext, op?: 'watch' | 'build'): Pro
     } else {
       log('debug', 'Skipped');
     }
-  });
-
-  if (op === 'build') {
-    TranspileUtil.log('build', [], 'info', 'Successfully built');
-  }
+  }, false);
 }
 
 /**
  * Export manifests
  */
-export async function exportManifest(ctx: ManifestContext, output?: string, env = 'dev'): Promise<string | undefined> {
+async function exportManifest(ctx: ManifestContext, output?: string, env = 'dev'): Promise<void> {
   const { ManifestUtil } = await importManifest(ctx);
   const manifest = await ManifestUtil.buildManifest(ctx);
 
@@ -136,25 +133,27 @@ export async function exportManifest(ctx: ManifestContext, output?: string, env
 
     await TranspileUtil.writeTextFile(output, JSON.stringify(manifest));
     TranspileUtil.log('manifest', [], 'info', `Wrote manifest ${output}`);
-    return output;
   } else {
     console.log(JSON.stringify(manifest, null, 2));
-    return;
   }
 }
 
-export async function launchMain(ctx: ManifestContext): Promise<void> {
-  // Rewriting node_path
-  const nodeOut = path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules');
-  const og = process.env.NODE_PATH;
-  process.env.NODE_PATH = [nodeOut, og].join(path.delimiter);
-  // @ts-expect-error
-  Module._initPaths();
-  process.env.NODE_PATH = og; // Restore
-
-  process.env.TRV_MANIFEST = path.resolve(nodeOut, ctx.mainModule);
-
-  // TODO: Externalize somehow?
-  const cliMain = path.join(nodeOut, '@travetto/cli/support/cli.js');
-  return await import(cliMain);
+/**
+ * Launch
+ */
+export async function launch(ctx: ManifestContext, op?: 'build' | 'watch' | 'manifest', args: (string | undefined)[] = []): Promise<void> {
+  if (op !== 'manifest') {
+    await compile(ctx, op);
+  }
+  switch (op) {
+    case 'manifest': return exportManifest(ctx, ...args);
+    case 'build': return TranspileUtil.log('build', [], 'info', 'Successfully built');
+    case undefined: {
+      // TODO: Externalize somehow?
+      const outputPath = path.resolve(ctx.workspacePath, ctx.outputFolder);
+      process.env.TRV_MANIFEST = path.resolve(outputPath, 'node_modules', ctx.mainModule);
+      const cliMain = path.join(outputPath, 'node_modules', '@travetto/cli/support/cli.js');
+      return import(cliMain);
+    }
+  }
 }

package/support/transpile.ts

@@ -6,25 +6,24 @@ import { createRequire } from 'module';
 
 import { DeltaEvent, ManifestContext, ManifestRoot, Package } from '@travetto/manifest';
 
-type ModFile = { input: string, output: string, stale: boolean };
-
-const SRC_REQ = createRequire(path.resolve('node_modules'));
-const recentStat = (stat: { ctimeMs: number, mtimeMs: number }): number => Math.max(stat.ctimeMs, stat.mtimeMs);
-
 export type CompilerLogEvent = [level: 'info' | 'debug' | 'warn', message: string];
+type ModFile = { input: string, output: string, stale: boolean };
 type WithLogger<T> = (log: (...ev: CompilerLogEvent) => void) => Promise<T>;
-type LogConfig = { args?: string[], basic?: boolean };
-const isCompilerLogEvent = (o: unknown): o is CompilerLogEvent => o !== null && o !== undefined && Array.isArray(o);
 
+const OPT_CACHE: Record<string, import('typescript').CompilerOptions> = {};
+const SRC_REQ = createRequire(path.resolve('node_modules'));
 const LEVELS = { warn: true, debug: /^debug$/.test(process.env.TRV_BUILD ?? ''), info: !/^warn$/.test(process.env.TRV_BUILD ?? '') };
 const SCOPE_MAX = 15;
+const RECENT_STAT = (stat: { ctimeMs: number, mtimeMs: number }): number => Math.max(stat.ctimeMs, stat.mtimeMs);
+const IS_LOG_EV = (o: unknown): o is CompilerLogEvent => o !== null && o !== undefined && Array.isArray(o);
 
 /**
  * Transpile utilities for launching
  */
 export class TranspileUtil {
-  static #optCache: Record<string, {}> = {};
-
+  /**
+   * Log message with filtering by level
+   */
   static log(scope: string, args: string[], ...[level, msg]: CompilerLogEvent): void {
     const message = msg.replaceAll(process.cwd(), '.');
     LEVELS[level] && console.debug(new Date().toISOString(), `[${scope.padEnd(SCOPE_MAX, ' ')}]`, ...args, message);
@@ -33,14 +32,10 @@ export class TranspileUtil {
   /**
    * With logger
    */
-  static withLogger<T>(scope: string, op: WithLogger<T>): Promise<T>;
-  static withLogger<T>(scope: string, opts: LogConfig, op: WithLogger<T>): Promise<T>;
-  static withLogger<T>(scope: string, opts: LogConfig | WithLogger<T>, op?: WithLogger<T>): Promise<T> {
-    const cfg = { basic: true, ...typeof opts === 'function' ? {} : opts };
-    const go = typeof opts === 'function' ? opts : op!;
-    const log = this.log.bind(null, scope, cfg.args ?? []);
-    cfg.basic && log('debug', 'Started');
-    return go(log).finally(() => cfg.basic && log('debug', 'Completed'));
+  static withLogger<T>(scope: string, op: WithLogger<T>, basic = true, args: string[] = []): Promise<T> {
+    const log = this.log.bind(null, scope, args);
+    basic && log('debug', 'Started');
+    return op(log).finally(() => basic && log('debug', 'Completed'));
   }
 
   /**
@@ -53,7 +48,7 @@ export class TranspileUtil {
    * Returns the compiler options
    */
   static async getCompilerOptions(ctx: ManifestContext): Promise<{}> {
-    if (!(ctx.workspacePath in this.#optCache)) {
+    if (!(ctx.workspacePath in OPT_CACHE)) {
       let tsconfig = path.resolve(ctx.workspacePath, 'tsconfig.json');
 
       if (!await fs.stat(tsconfig).then(_ => true, _ => false)) {
@@ -66,19 +61,17 @@ export class TranspileUtil {
         ts.readJsonConfigFile(tsconfig, ts.sys.readFile), ts.sys, ctx.workspacePath
       );
 
-      options.allowJs = true;
-      options.resolveJsonModule = true;
-      options.sourceRoot = ctx.workspacePath;
-      options.rootDir = ctx.workspacePath;
-      options.outDir = path.resolve(ctx.workspacePath);
-
-      try {
-        options.module = ctx.moduleType === 'commonjs' ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext;
-      } catch { }
-
-      this.#optCache[ctx.workspacePath] = options;
+      OPT_CACHE[ctx.workspacePath] = {
+        ...options,
+        allowJs: true,
+        resolveJsonModule: true,
+        sourceRoot: ctx.workspacePath,
+        rootDir: ctx.workspacePath,
+        outDir: path.resolve(ctx.workspacePath),
+        module: ctx.moduleType === 'commonjs' ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext,
+      };
     }
-    return this.#optCache[ctx.workspacePath];
+    return OPT_CACHE[ctx.workspacePath];
   }
 
   /**
@@ -143,9 +136,9 @@ export class TranspileUtil {
     const out: ModFile[] = [];
     for (const input of files) {
       const output = input.replace(inputFolder, outputFolder).replace(/[.]ts$/, '.js');
-      const inputTs = await fs.stat(input).then(recentStat, () => 0);
+      const inputTs = await fs.stat(input).then(RECENT_STAT, () => 0);
       if (inputTs) {
-        const outputTs = await fs.stat(output).then(recentStat, () => 0);
+        const outputTs = await fs.stat(output).then(RECENT_STAT, () => 0);
         await fs.mkdir(path.dirname(output), { recursive: true, });
         out.push({ input, output, stale: inputTs > outputTs });
       }
@@ -168,18 +161,16 @@ export class TranspileUtil {
 
     await this.writeTextFile(deltaFile, changedFiles.join('\n'));
 
-    await this.withLogger('compiler-exec', async log => {
-      await new Promise((res, rej) =>
-        cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
-          env: {
-            ...process.env,
-            TRV_MANIFEST: path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule),
-          },
-          stdio: [0, 1, 2, 'ipc'],
-        })
-          .on('message', msg => isCompilerLogEvent(msg) && log(...msg))
-          .on('exit', code => (code !== null && code > 0) ? rej() : res(null))
-      );
-    });
+    await this.withLogger('compiler-exec', log => new Promise((res, rej) =>
+      cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
+        env: {
+          ...process.env,
+          TRV_MANIFEST: path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule),
+        },
+        stdio: [0, 1, 2, 'ipc'],
+      })
+        .on('message', msg => IS_LOG_EV(msg) && log(...msg))
+        .on('exit', code => (code !== null && code > 0) ? rej() : res(null))
+    )).finally(() => fs.unlink(deltaFile));
   }
 }