@travetto/compiler 3.1.0-rc.2 → 3.1.0-rc.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "3.1.0-rc.2",
+  "version": "3.1.0-rc.3",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
@@ -36,7 +36,7 @@
     "@travetto/transformer": "^3.1.0-rc.2"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.1.0-rc.3"
+    "@travetto/cli": "^3.1.0-rc.4"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -72,10 +72,15 @@ export class Compiler {
    */
   async * emit(files: string[], emitter: CompileEmitter): AsyncIterable<CompileEmitEvent> {
     let i = 0;
+    let lastSent = Date.now();
     for (const file of files) {
       const err = await emitter(file);
       const imp = file.replace(/.*node_modules\//, '');
       yield { file: imp, i: i += 1, err, total: files.length };
+      if ((Date.now() - lastSent) > 50) { // Limit to 1 every 50ms
+        lastSent = Date.now();
+        process.send?.({ type: 'status', total: files.length, idx: i });
+      }
     }
     Log.debug(`Compiled ${i} files`);
   }
@@ -89,7 +94,9 @@ export class Compiler {
 
     Log.debug('Compilation started');
 
-    process.on('disconnect', () => process.exit(0));
+    if (process.send) {
+      process.on('disconnect', () => process.exit(0));
+    }
 
     const emitter = await this.getCompiler();
     let failed = false;
@@ -104,6 +111,8 @@ export class Compiler {
       return { idx: i, total, text: `Compiling [%idx/%total] -- ${file}` };
     };
 
+    process.send?.({ type: 'start' });
+
     if (this.#dirtyFiles.length) {
       await GlobalTerminal.trackProgress(this.emit(this.#dirtyFiles, emitter), resolveEmittedFile, { position: 'bottom', minDelay: 50 });
       if (failed) {
@@ -118,7 +127,7 @@ export class Compiler {
       await emitter(resolved, true);
     }
 
-    process.send?.('build-complete');
+    process.send?.({ type: 'complete' });
 
     if (this.#watch) {
       Log.info('Watch is ready');
@@ -135,7 +144,7 @@ export class Compiler {
         }
       }
       if (!process.exitCode) {
-        process.send?.('restart');
+        process.send?.({ type: 'restart' });
       }
     }
   }

package/support/launcher.ts

@@ -3,7 +3,7 @@ import path from 'path';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import { TranspileUtil, CompileResult } from './transpile';
+import { TranspileUtil, CompileResult, BuildEvent } from './transpile';
 import { LockManager } from './lock';
 import { LogUtil } from './log';
 
@@ -16,7 +16,7 @@ const importManifest = (ctx: ManifestContext): Promise<typeof import('@travetto/
 /**
  * Run the compiler
  */
-async function compile(ctx: ManifestContext, op: 'watch' | 'build' | undefined, onMessage: (msg: unknown) => void): Promise<CompileResult> {
+async function compile(ctx: ManifestContext, op: 'watch' | 'build' | undefined, onMessage: (msg: BuildEvent) => void): Promise<CompileResult> {
   let changes = 0;
 
   await LogUtil.withLogger('precompile', async () => {
@@ -117,7 +117,10 @@ export async function launch(ctx: ManifestContext, root: ManifestContext, op?: '
   if (op !== 'manifest' && await LockManager.getCompileAction(root, op) === 'build') {
 
     // Ready signal
-    process.send?.('ready');
+    if (process.send) {
+      process.send('ready');
+      process.on('disconnect', () => process.exit(0));
+    }
 
     await LockManager.withLocks(root, async (acquire, release) => {
       let action: CompileResult;
@@ -127,8 +130,8 @@ export async function launch(ctx: ManifestContext, root: ManifestContext, op?: '
           acquire('build');
         }
         action = await compile(root, op, msg => {
-          switch (msg) {
-            case 'build-complete': {
+          switch (msg.type) {
+            case 'complete': {
               release('build');
               break;
             }
@@ -138,6 +141,11 @@ export async function launch(ctx: ManifestContext, root: ManifestContext, op?: '
     });
   }
 
+  // Disconnect for non-cli operations
+  if (op && process.send) {
+    process.disconnect();
+  }
+
   switch (op) {
     case 'manifest': return exportManifest(ctx, ...args);
     case 'build': return LogUtil.log('build', [], 'info', 'Successfully built');

package/support/lock.ts

@@ -105,7 +105,7 @@ export class LockManager {
       handler();
 
       remove = (): void => {
-        clearInterval(timer);
+        clearTimeout(timer);
         unwatchFile(file, handler);
       };
     });

package/support/transpile.ts

@@ -11,11 +11,15 @@ import { LogUtil } from './log';
 
 type ModFile = { input: string, output: string, stale: boolean };
 export type CompileResult = 'restart' | 'complete' | 'skipped';
+export type BuildEvent = { type: 'restart' | 'start' | 'complete' } | { type: 'status', idx: number, total: number };
 
 const OPT_CACHE: Record<string, import('typescript').CompilerOptions> = {};
 const SRC_REQ = createRequire(path.resolve('node_modules'));
 const RECENT_STAT = (stat: { ctimeMs: number, mtimeMs: number }): number => Math.max(stat.ctimeMs, stat.mtimeMs);
 
+const isBuildEvent = (ev: unknown): ev is BuildEvent =>
+  ev !== undefined && ev !== null && typeof ev === 'object' && 'type' in ev && typeof ev.type === 'string';
+
 /**
  * Transpile utilities for launching
  */
@@ -190,7 +194,7 @@ export class TranspileUtil {
   /**
    * Run compiler
    */
-  static async runCompiler(ctx: ManifestContext, manifest: ManifestRoot, changed: DeltaEvent[], watch: boolean, onMessage: (msg: unknown) => void): Promise<CompileResult> {
+  static async runCompiler(ctx: ManifestContext, manifest: ManifestRoot, changed: DeltaEvent[], watch: boolean, onMessage: (msg: BuildEvent) => 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.${process.pid}.${process.ppid}.${Date.now()}.json`);
@@ -216,10 +220,14 @@ export class TranspileUtil {
           .on('message', msg => {
             if (LogUtil.isLogEvent(msg)) {
               log(...msg);
-            } else if (msg === 'restart') {
-              res(msg);
-            } else {
-              onMessage(msg);
+            } else if (isBuildEvent(msg)) {
+              // Send to parent if exists
+              process.send?.(msg);
+              if (msg.type === 'restart') {
+                res('restart');
+              } else {
+                onMessage(msg);
+              }
             }
           })
           .on('exit', code => (code !== null && code > 0) ? rej(new Error('Failed during compilation')) : res('complete'));
@@ -231,6 +239,8 @@ export class TranspileUtil {
         await timers.setTimeout(150 + 100 * Math.random());
       }
 
+      LogUtil.log('compiler-exec', [], 'info', `Result ${result}, exit code: ${proc?.exitCode}`);
+
       return result;
     } finally {
       if (proc?.killed === false) { proc.kill('SIGKILL'); }