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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "3.0.0-rc.27",
+  "version": "3.0.0-rc.28",
   "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.9",
     "@travetto/transformer": "^3.0.0-rc.19"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.0.0-rc.18"
+    "@travetto/cli": "^3.0.0-rc.19"
   },
   "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
  */
@@ -134,11 +131,10 @@ export class Compiler {
     if (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

@@ -108,7 +108,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 +125,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

@@ -50,7 +50,7 @@ export class LockManager {
       const content = await fs.readFile(file, 'utf8');
       const filePid = parseInt(content, 10);
       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;
       }
@@ -118,25 +118,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 +145,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

@@ -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 });
     }
   }