@travetto/compiler 3.0.0-rc.27 → 3.0.0-rc.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "3.0.0-rc.27",
+  "version": "3.0.0-rc.29",
   "description": "Compiler",
   "keywords": [
     "compiler",
@@ -32,11 +32,11 @@
   "dependencies": {
     "@parcel/watcher": "^2.1.0",
     "@travetto/manifest": "^3.0.0-rc.15",
-    "@travetto/terminal": "^3.0.0-rc.8",
+    "@travetto/terminal": "^3.0.0-rc.10",
     "@travetto/transformer": "^3.0.0-rc.19"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.0-rc.18"
+    "@travetto/cli": "^3.0.0-rc.20"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -1,5 +1,4 @@
 import { install } from 'source-map-support';
-import timers from 'timers/promises';
 import ts from 'typescript';
 import fs from 'fs/promises';
 
@@ -12,8 +11,6 @@ import { CompilerWatcher } from './watch';
 import { Log } from './log';
 import { CompileEmitError, CompileEmitEvent, CompileEmitter } from './types';
 
-const PING_THRESHOLD = 1000;
-
 /**
  * Compilation support
  */
@@ -24,21 +21,22 @@ export class Compiler {
    */
   static async main(): Promise<void> {
     const [dirty, watch] = process.argv.slice(2);
-    install();
+    const state = await CompilerState.get(RootIndex);
     const dirtyFiles = (await fs.readFile(dirty, 'utf8')).split(/\n/).filter(x => !!x);
-    return new Compiler().init(dirtyFiles).then(c => c.run(watch === 'true'));
+    await new Compiler(state, dirtyFiles, watch === 'true').run();
+    process.exit(0);
   }
 
   #state: CompilerState;
   #dirtyFiles: string[];
+  #watch?: boolean;
 
-  async init(dirtyFiles: string[]): Promise<this> {
-    this.#state = await CompilerState.get(RootIndex);
+  constructor(state: CompilerState, dirtyFiles: string[], watch?: boolean) {
+    this.#state = state;
     this.#dirtyFiles = dirtyFiles[0] === '*' ?
       this.#state.getAllFiles() :
       dirtyFiles.map(f => this.#state.getBySource(f)!.input);
-
-    return this;
+    this.#watch = watch;
   }
 
   /**
@@ -99,9 +97,14 @@ export class Compiler {
   /**
    * Run the compiler
    */
-  async run(watch?: boolean): Promise<void> {
+  async run(): Promise<void> {
+    await GlobalTerminal.init();
+    install();
+
     Log.debug('Compilation started');
 
+    process.on('disconnect', () => process.exit(0));
+
     const emitter = await this.getCompiler();
     let failed = false;
 
@@ -123,7 +126,7 @@ export class Compiler {
       } else {
         Log.debug('Compilation succeeded');
       }
-    } else if (watch) {
+    } else if (this.#watch) {
       // Prime compiler before complete
       const resolved = this.#state.getArbitraryInputFile();
       await emitter(resolved, true);
@@ -131,16 +134,15 @@ export class Compiler {
 
     process.send?.('build-complete');
 
-    if (watch) {
+    if (this.#watch) {
       Log.info('Watch is ready');
       await this.#watchLocalModules(emitter);
-      for await (const _ of timers.setInterval(PING_THRESHOLD)) {
-        if (!await fs.stat(this.#state.resolveOutputFile('.')).catch(() => false)) { // Output removed
+      const output = this.#state.resolveOutputFile('.');
+      for await (const _ of fs.watch(output)) {
+        if (!await fs.stat(output).catch(() => false)) {
           process.send?.('restart');
-        } else {
-          process.send?.('ping');
         }
       }
     }
   }
-}
+}

package/support/launcher.ts

@@ -21,7 +21,10 @@ async function compile(ctx: ManifestContext, op: 'watch' | 'build' | undefined,
 
   await LogUtil.withLogger('precompile', async () => {
     for (const mod of PRECOMPILE_MODS) {
-      changes += (await TranspileUtil.compileIfStale(ctx, 'precompile', mod, SOURCE_SEED)).length;
+      const count = (await TranspileUtil.compileIfStale(ctx, 'precompile', mod, SOURCE_SEED)).length;
+      if (mod !== '@travetto/terminal') {
+        changes += count;
+      }
     }
   });
 
@@ -108,7 +111,14 @@ async function exportManifest(ctx: ManifestContext, output?: string, env = 'dev'
  * Launch
  */
 export async function launch(ctx: ManifestContext, root: ManifestContext, op?: 'build' | 'watch' | 'manifest', args: (string | undefined)[] = []): Promise<void> {
+  // If quiet enabled, turn off all output by default
+  LogUtil.level = process.env.TRV_BUILD ?? (process.env.TRV_QUIET ? 'none' : (!op ? 'warn' : 'info'));
+
   if (op !== 'manifest' && await LockManager.getCompileAction(root, op) === 'build') {
+
+    // Ready signal
+    process.send?.('ready');
+
     await LockManager.withLocks(root, async (acquire, release) => {
       let action: CompileResult;
       do {
@@ -118,7 +128,10 @@ export async function launch(ctx: ManifestContext, root: ManifestContext, op?: '
         }
         action = await compile(root, op, msg => {
           switch (msg) {
-            case 'build-complete': release('build'); break;
+            case 'build-complete': {
+              release('build');
+              break;
+            }
           }
         });
       } while (action === 'restart');

package/support/lock.ts

@@ -28,7 +28,7 @@ export class LockManager {
    * Get the lock file name
    */
   static #getFileName(ctx: ManifestContext, type: LockType): string {
-    return path.resolve(ctx.workspacePath, ctx.toolFolder, `${type}.pid`);
+    return path.resolve(ctx.workspacePath, ctx.toolFolder, `${type}.lock`);
   }
 
   /**
@@ -47,10 +47,9 @@ export class LockManager {
     const stale = this.#isStale(stat);
     let pid: number | undefined;
     if (stat) {
-      const content = await fs.readFile(file, 'utf8');
-      const filePid = parseInt(content, 10);
+      const { pid: filePid } = JSON.parse(await fs.readFile(file, 'utf8'));
       if (stale) {
-        LogUtil.log('lock', [], 'info', `${type} file is stale: ${stat.mtimeMs} vs ${Date.now()}`);
+        LogUtil.log('lock', [], 'debug', `${type} file is stale: ${stat.mtimeMs} vs ${Date.now()}`);
       } else {
         pid = filePid;
       }
@@ -65,7 +64,7 @@ export class LockManager {
     const file = this.#getFileName(ctx, type);
     mkdirSync(path.dirname(file), { recursive: true });
     LogUtil.log('lock', [], 'debug', `Acquiring ${type}`);
-    writeFileSync(file, `${process.pid}`, 'utf8');
+    writeFileSync(file, JSON.stringify({ pid: process.pid }), 'utf8');
   }
 
   /**
@@ -118,25 +117,24 @@ export class LockManager {
    * Read the watch lock file and determine its result, communicating with the user as necessary
    */
   static async #getWatchAction(ctx: ManifestContext, log: CompilerLogger, lockType: LockType | undefined, buildState: LockDetails): Promise<LockAction> {
-    const level = lockType ? 'info' : 'debug';
     if (lockType === 'watch') {
-      log(level, 'Already running');
+      log('info', 'Already running');
       return 'skip';
     } else {
       if (buildState.pid) {
-        log('info', 'Already running, waiting for build to finish');
+        log('warn', 'Already running, waiting for build to finish');
         switch (await this.#waitForRelease(ctx, 'build')) {
           case 'complete': {
-            log(level, 'Completed build');
+            log('info', 'Completed build');
             return 'skip';
           }
           case 'stale': {
-            log(level, 'Became stale, retrying');
+            log('info', 'Became stale, retrying');
             return 'retry';
           }
         }
       } else {
-        log(level, 'Already running, and has built');
+        log('info', 'Already running, and has built');
         return 'skip';
       }
     }
@@ -146,21 +144,20 @@ export class LockManager {
    * Read the build lock file and determine its result, communicating with the user as necessary
    */
   static async #getBuildAction(ctx: ManifestContext, log: CompilerLogger, lockType: LockType | undefined): Promise<LockAction> {
-    const level = lockType ? 'info' : 'debug';
     if (lockType === 'watch') {
-      log('info', 'Build already running, waiting to begin watch');
+      log('warn', 'Build already running, waiting to begin watch');
       const res = await this.#waitForRelease(ctx, 'build');
-      log(level, `Finished with status of ${res}, retrying`);
+      log('info', `Finished with status of ${res}, retrying`);
       return 'retry';
     } else {
-      log('info', 'Already running, waiting for completion');
+      log('warn', 'Already running, waiting for completion');
       switch (await this.#waitForRelease(ctx, lockType ?? 'build')) {
         case 'complete': {
-          log(level, 'Completed');
+          log('info', 'Completed');
           return 'skip';
         }
         case 'stale': {
-          log(level, 'Became stale, retrying');
+          log('info', 'Became stale, retrying');
           return 'retry';
         }
       }

package/support/log.ts

@@ -2,16 +2,24 @@ export type CompilerLogEvent = [level: 'info' | 'debug' | 'warn', message: strin
 export type CompilerLogger = (...args: CompilerLogEvent) => void;
 export type WithLogger<T> = (log: CompilerLogger) => Promise<T>;
 
-const ENV_LEVEL = process.env.TRV_BUILD ?? 'info';
-const LEVELS = {
-  warn: /^(debug|info|warn)$/.test(ENV_LEVEL),
-  info: /^(debug|info)$/.test(ENV_LEVEL),
-  debug: /^debug$/.test(ENV_LEVEL),
-};
 const SCOPE_MAX = 15;
 
 export class LogUtil {
 
+  static levels: {
+    debug: boolean;
+    info: boolean;
+    warn: boolean;
+  }
+
+  static set level(value: string) {
+    this.levels = {
+      warn: /^(debug|info|warn)$/.test(value),
+      info: /^(debug|info)$/.test(value),
+      debug: /^debug$/.test(value),
+    };
+  }
+
   /**
    * Is object a log event
    */
@@ -22,7 +30,14 @@ export class LogUtil {
    */
   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);
+    if (LogUtil.levels[level]) {
+      const params = [`[${scope.padEnd(SCOPE_MAX, ' ')}]`, ...args, message];
+      if (!/(0|false|off|no)$/i.test(process.env.TRV_LOG_TIME ?? '')) {
+        params.unshift(new Date().toISOString());
+      }
+      // eslint-disable-next-line no-console
+      console[level]!(...params);
+    }
   }
 
   /**

package/support/transpile.ts

@@ -131,8 +131,8 @@ export class TranspileUtil {
   }
 
   /**
- * Recompile folder if stale
- */
+   * Recompile folder if stale
+   */
   static async compileIfStale(ctx: ManifestContext, scope: string, mod: string, seed: string[]): Promise<string[]> {
     const files = await this.getModuleSources(ctx, mod, seed);
     const changes = files.filter(x => x.stale).map(x => x.input);
@@ -166,13 +166,14 @@ export class TranspileUtil {
   static async runCompiler(ctx: ManifestContext, manifest: ManifestRoot, changed: DeltaEvent[], watch: boolean, onMessage: (msg: unknown) => void): Promise<CompileResult> {
     const compiler = path.resolve(ctx.workspacePath, ctx.compilerFolder);
     const main = path.resolve(compiler, 'node_modules', '@travetto/compiler/support/compiler-entry.js');
-    const deltaFile = path.resolve(os.tmpdir(), `manifest-delta.${Date.now()}.${Math.random()}.json`);
+    const deltaFile = path.resolve(os.tmpdir(), `manifest-delta.${process.pid}.${process.ppid}.${Date.now()}.json`);
 
     const changedFiles = changed[0]?.file === '*' ? ['*'] : changed.map(ev =>
       path.resolve(manifest.workspacePath, manifest.modules[ev.module].sourceFolder, ev.file)
     );
 
     let proc: cp.ChildProcess | undefined;
+    let kill: (() => void) | undefined;
 
     try {
       await this.writeTextFile(deltaFile, changedFiles.join('\n'));
@@ -195,9 +196,14 @@ export class TranspileUtil {
             }
           })
           .on('exit', code => (code !== null && code > 0) ? rej(new Error('Failed during compilation')) : res('complete'));
+        kill = (): void => { proc?.kill('SIGKILL'); };
+        process.on('exit', kill);
       }));
     } finally {
       if (proc?.killed === false) { proc.kill('SIGKILL'); }
+      if (kill) {
+        process.removeListener('exit', kill);
+      }
       await fs.rm(deltaFile, { force: true });
     }
   }