@travetto/compiler 8.0.0-alpha.8 → 8.0.0

package/README.md

@@ -17,12 +17,12 @@ This module expands upon the [Typescript](https://typescriptlang.org) compiler,
    *  Integration with the [Transformation](https://github.com/travetto/travetto/tree/main/module/transformer#readme "Functionality for AST transformations, with transformer registration, and general utils") module, allowing for rich, type-aware transformations
    *  Automatic conversion to either [Ecmascript Module](https://nodejs.org/api/esm.html) or [CommonJS](https://nodejs.org/api/modules.html) based on the [Package JSON](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) `type` value
    *  Removal of type only imports which can break [Ecmascript Module](https://nodejs.org/api/esm.html)-style output
-   *  Automatic addition of `.js` extension to imports to also support  [Ecmascript Module](https://nodejs.org/api/esm.html)-style output
+   *  Automatic addition of `.js` extension to imports to also support [Ecmascript Module](https://nodejs.org/api/esm.html)-style output
 
 Beyond the [Typescript](https://typescriptlang.org) compiler functionality, the module provides the primary entry point into the development process.
 
 ## CLI
-The compiler cli, [trvc](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trvc.js) is the entry point for compilation-related operations. It has the ability to check for active builds, and ongoing watch operations to ensure only one process is building at a time.  Within the framework, regardless of mono-repo or not, the compilation always targets the entire project.  With the efficient caching behavior, this leads to generally a minimal overhead but allows for centralization of all operations. 
+The compiler cli, [trvc](https://github.com/travetto/travetto/tree/main/module/compiler/bin/trvc.js) is the entry point for compilation-related operations. It has the ability to check for active builds, and ongoing watch operations to ensure only one process is building at a time. Within the framework, regardless of mono-repo or not, the compilation always targets the entire project. With the efficient caching behavior, this leads to generally a minimal overhead but allows for centralization of all operations. 
 
 The compiler cli supports the following operations:
    *  `start` - Run the compiler in watch mode
@@ -36,7 +36,7 @@ The compiler cli supports the following operations:
    *  `manifest [output]` - Generate the project manifest
    *  `manifest:production [output]` - Generate the production project manifest
 
-In addition to the normal output, the compiler supports an environment variable `TRV_BUILD` that supports the following values: `debug`, `info`, `warn` or `none`.  This provides different level of logging during the build process which is helpful to diagnose any odd behaviors.  When invoking an unknown command (e.g. `<other>` from above), the default level is `warn`.  Otherwise the default logging level is `info`.
+In addition to the normal output, the compiler supports an environment variable `TRV_BUILD` that supports the following values: `debug`, `info`, `warn` or `none`. This provides different level of logging during the build process which is helpful to diagnose any odd behaviors. When invoking an unknown command (e.g. `<other>` from above), the default level is `warn`. Otherwise the default logging level is `info`.
 
 **Terminal: Sample trv output with debug logging**
 ```bash

package/__index__.ts

@@ -2,11 +2,11 @@ export * from './src/common.ts';
 export * from './src/compiler.ts';
 export * from './src/event.ts';
 export * from './src/log.ts';
+export * from './src/server/client.ts';
+export * from './src/server/manager.ts';
+export * from './src/server/process-handle.ts';
+export * from './src/server/server.ts';
 export * from './src/state.ts';
 export * from './src/types.ts';
 export * from './src/util.ts';
 export * from './src/watch.ts';
-export * from './src/server/client.ts';
-export * from './src/server/server.ts';
-export * from './src/server/manager.ts';
-export * from './src/server/process-handle.ts';

package/bin/hook.js

@@ -1,17 +1,23 @@
 // @ts-check
-import module from 'node:module';
+
 import { readFileSync } from 'node:fs';
+import module from 'node:module';
 import { fileURLToPath } from 'node:url';
 
-globalThis.devProcessWarningExclusions?.push((message) => message.startsWith('stripTypeScriptTypes'));
+const ogEmitWarning = process.emitWarning.bind(process);
 
 module.registerHooks({
   load: (url, context, nextLoad) => {
     if (/[.]tsx?$/.test(url)) {
       const source = readFileSync(fileURLToPath(url), 'utf8');
-      return { format: 'module', source: module.stripTypeScriptTypes(source), shortCircuit: true };
+      try {
+        process.emitWarning = () => {};
+        return { format: 'module', source: module.stripTypeScriptTypes(source), shortCircuit: true };
+      } finally {
+        process.emitWarning = ogEmitWarning;
+      }
     } else {
       return nextLoad(url, context);
     }
   }
-});
+});

package/bin/trvc-target.js

@@ -1,5 +1,6 @@
 // @ts-check
 import '@travetto/runtime/support/patch.js';
 import './hook.js';
+
 const { Compiler } = await import('../src/compiler.ts');
-await Compiler.main();
+await Compiler.main();

package/bin/trvc.js

@@ -2,5 +2,6 @@
 // @ts-check
 import '@travetto/runtime/support/patch.js';
 import './hook.js';
+
 const { invoke } = await import('@travetto/compiler/support/invoke.ts');
-await invoke(...process.argv.slice(2));
+await invoke(...process.argv.slice(2));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/compiler",
-  "version": "8.0.0-alpha.8",
-  "type": "module",
+  "version": "8.0.0",
+  "private": false,
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
@@ -11,8 +11,15 @@
   "homepage": "https://travetto.io",
   "license": "MIT",
   "author": {
-    "email": "travetto.framework@gmail.com",
-    "name": "Travetto Framework"
+    "name": "Travetto Framework",
+    "email": "travetto.framework@gmail.com"
+  },
+  "repository": {
+    "url": "git+https://github.com/travetto/travetto.git",
+    "directory": "module/compiler"
+  },
+  "bin": {
+    "trvc": "bin/trvc.js"
   },
   "files": [
     "__index__.ts",
@@ -21,21 +28,18 @@
     "support",
     "tsconfig.trv.json"
   ],
+  "type": "module",
   "main": "__index__.ts",
-  "bin": {
-    "trvc": "bin/trvc.js"
-  },
-  "repository": {
-    "url": "git+https://github.com/travetto/travetto.git",
-    "directory": "module/compiler"
+  "publishConfig": {
+    "access": "public"
   },
   "dependencies": {
-    "@parcel/watcher": "^2.5.6",
-    "@travetto/manifest": "^8.0.0-alpha.4",
-    "@travetto/transformer": "^8.0.0-alpha.4"
+    "@parcel/watcher": "^2.6.0",
+    "@travetto/manifest": "^8.0.0",
+    "@travetto/transformer": "^8.0.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.11"
+    "@travetto/cli": "^8.0.0"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {
@@ -47,9 +51,5 @@
     "roles": [
       "compile"
     ]
-  },
-  "private": false,
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/common.ts

@@ -6,11 +6,14 @@ import { type ManifestContext, path } from '@travetto/manifest';
 import { Log } from './log.ts';
 
 export class CommonUtil {
-
   /**
    * Restartable Event Stream
    */
-  static async * restartableEvents<T>(input: (signal: AbortSignal) => AsyncIterable<T>, parent: AbortSignal, shouldRestart: (item: T) => boolean): AsyncIterable<T> {
+  static async *restartableEvents<T>(
+    input: (signal: AbortSignal) => AsyncIterable<T>,
+    parent: AbortSignal,
+    shouldRestart: (item: T) => boolean
+  ): AsyncIterable<T> {
     const log = Log.scoped('event-stream');
     outer: while (!parent.aborted) {
       const controller = new AbortController();
@@ -37,7 +40,8 @@ export class CommonUtil {
       log.debug('Finished event stream');
 
       // Natural exit, we done
-      if (!controller.signal.aborted) { // Shutdown source if still running
+      if (!controller.signal.aborted) {
+        // Shutdown source if still running
         controller.abort();
       }
       return;
@@ -48,14 +52,14 @@ export class CommonUtil {
    * Non-blocking timeout
    */
   static nonBlockingTimeout(time: number): Promise<void> {
-    return timers.setTimeout(time, undefined, { ref: false }).catch(() => { });
+    return timers.setTimeout(time, undefined, { ref: false }).catch(() => {});
   }
 
   /**
    * Blocking timeout
    */
   static blockingTimeout(time: number): Promise<void> {
-    return timers.setTimeout(time, undefined, { ref: true }).catch(() => { });
+    return timers.setTimeout(time, undefined, { ref: true }).catch(() => {});
   }
 
   /**
@@ -76,8 +80,10 @@ export class CommonUtil {
    * Write to stdout with backpressure handling
    */
   static async writeStdout(level: number, data: unknown): Promise<void> {
-    if (data === undefined) { return; }
+    if (data === undefined) {
+      return;
+    }
     process.stdout.write(`${JSON.stringify(data, undefined, level)}\n`) ||
-      await new Promise(resolve => process.stdout.once('drain', resolve));
-  };
-}
+      (await new Promise(resolve => process.stdout.once('drain', resolve)));
+  }
+}

package/src/compiler.ts

@@ -1,15 +1,14 @@
-import fs from 'node:fs/promises';
 import { setMaxListeners } from 'node:events';
+import fs from 'node:fs/promises';
 
-import { getManifestContext, ManifestDeltaUtil, ManifestIndex, ManifestUtil, type DeltaEvent } from '@travetto/manifest';
+import { type DeltaEvent, getManifestContext, ManifestDeltaUtil, ManifestIndex, ManifestUtil } from '@travetto/manifest';
 
-import { CompilerState } from './state.ts';
-import { CompilerWatcher } from './watch.ts';
-import { type CompileEmitEvent, CompilerReset } from './types.ts';
+import { CommonUtil } from './common.ts';
 import { EventUtil } from './event.ts';
-
 import { IpcLogger } from './log.ts';
-import { CommonUtil } from './common.ts';
+import { CompilerState } from './state.ts';
+import { type CompileEmitEvent, CompilerReset } from './types.ts';
+import { CompilerWatcher } from './watch.ts';
 
 const log = new IpcLogger({ level: 'debug' });
 
@@ -17,7 +16,6 @@ const log = new IpcLogger({ level: 'debug' });
  * Compilation support
  */
 export class Compiler {
-
   /**
    * Run compiler as a main entry point
    */
@@ -31,8 +29,8 @@ export class Compiler {
 
   #state: CompilerState;
   #watch?: boolean;
-  #controller: AbortController;
-  #signal: AbortSignal;
+  #shutdownController: AbortController;
+  #shutdownSignal: AbortSignal;
   #shuttingDown = false;
   #deltaEvents: DeltaEvent[];
 
@@ -41,12 +39,10 @@ export class Compiler {
     this.#watch = watch;
     this.#deltaEvents = deltaEvents;
 
-    this.#controller = new AbortController();
-    this.#signal = this.#controller.signal;
-    setMaxListeners(1000, this.#signal);
-    process
-      .once('disconnect', () => this.#shutdown('manual'))
-      .on('message', event => (event === 'shutdown') && this.#shutdown('manual'));
+    this.#shutdownController = new AbortController();
+    this.#shutdownSignal = this.#shutdownController.signal;
+    setMaxListeners(1000, this.#shutdownSignal);
+    process.once('disconnect', () => this.#shutdown('manual')).on('message', event => event === 'shutdown' && this.#shutdown('manual'));
   }
 
   #shutdown(mode: 'error' | 'manual' | 'complete' | 'reset', errorMessage?: string): void {
@@ -78,7 +74,7 @@ export class Compiler {
     // No longer listen to disconnect
     process.removeAllListeners('disconnect');
     process.removeAllListeners('message');
-    this.#controller.abort();
+    this.#shutdownController.abort();
     CommonUtil.nonBlockingTimeout(1000).then(() => process.exit()); // Allow upto 1s to shutdown gracefully
   }
 
@@ -111,7 +107,7 @@ export class Compiler {
   /**
    * Emit all files as a stream
    */
-  async * emit(files: string[]): AsyncIterable<CompileEmitEvent> {
+  async *emit(files: string[]): AsyncIterable<CompileEmitEvent> {
     let i = 0;
     let lastSent = Date.now();
 
@@ -122,12 +118,13 @@ export class Compiler {
       const nodeModSeparator = 'node_modules/';
       const nodeModIdx = file.lastIndexOf(nodeModSeparator);
       const imp = nodeModIdx >= 0 ? file.substring(nodeModIdx + nodeModSeparator.length) : file;
-      yield { file: imp, i: i += 1, errors, total: files.length, duration };
-      if ((Date.now() - lastSent) > 50) { // Limit to 1 every 50ms
+      yield { file: imp, i: (i += 1), errors, total: files.length, duration };
+      if (Date.now() - lastSent > 50) {
+        // Limit to 1 every 50ms
         lastSent = Date.now();
         EventUtil.sendEvent('progress', { total: files.length, idx: i, message: imp, operation: 'compile' });
       }
-      if (this.#signal.aborted) {
+      if (this.#shutdownSignal.aborted) {
         break;
       }
     }
@@ -154,7 +151,7 @@ export class Compiler {
 
     const metrics: CompileEmitEvent[] = [];
     const isCompilerChanged = this.#deltaEvents.some(event => this.#state.isCompilerFile(event.sourceFile));
-    const changedFiles = (isCompilerChanged ? this.#state.getAllFiles() : this.#deltaEvents.map(event => event.sourceFile));
+    const changedFiles = isCompilerChanged ? this.#state.getAllFiles() : this.#deltaEvents.map(event => event.sourceFile);
 
     if (changedFiles.length) {
       for await (const event of this.emit(changedFiles)) {
@@ -170,13 +167,13 @@ export class Compiler {
         }
         metrics.push(event);
       }
-      if (this.#signal.aborted) {
+      if (this.#shutdownSignal.aborted) {
         log.debug('Compilation aborted');
       } else if (failures.size) {
         const sortedFailures = [...failures.entries()].sort((a, b) => a[0].localeCompare(b[0]));
-        log.debug('Compilation failed',
-          ['', sortedFailures.flatMap(([file, count]) => `- ${file}: ${count} errors found`)]
-            .flat(3).join('\n')
+        log.error(
+          'Compilation failed',
+          ['', sortedFailures.flatMap(([file, count]) => `- ${file}: ${count} errors found`)].flat(3).join('\n')
         );
       } else {
         log.debug('Compilation succeeded');
@@ -187,7 +184,7 @@ export class Compiler {
       await ManifestUtil.writeManifest(manifest);
       await ManifestUtil.writeDependentManifests(manifest);
 
-      if (failures.size) {
+      if (!this.#watch && failures.size) {
         return this.#shutdown('error');
       }
 
@@ -200,7 +197,7 @@ export class Compiler {
       this.logStatistics(metrics);
     }
 
-    if (this.#watch && !this.#signal.aborted) {
+    if (this.#watch && !this.#shutdownSignal.aborted) {
       const resolved = this.#state.getArbitraryInputFile();
       await this.#state.compileSourceFile(resolved);
 
@@ -208,11 +205,14 @@ export class Compiler {
 
       EventUtil.sendEvent('state', { state: 'watch-start' });
       try {
-        for await (const event of new CompilerWatcher(this.#state, this.#signal)) {
+        for await (const event of new CompilerWatcher(this.#state, this.#shutdownSignal)) {
           if (event.action !== 'delete') {
             const errors = await this.#state.compileSourceFile(event.entry.sourceFile, true);
             if (errors?.length) {
               log.error('Compilation failed', `${event.entry.sourceFile}: ${errors.length} errors found`);
+              for (const error of errors) {
+                log.error(`ERROR ${event.file}:${error}`);
+              }
             } else {
               log.info(`Compiled ${event.entry.sourceFile} on ${event.action}`);
             }
@@ -246,4 +246,4 @@ export class Compiler {
 
     this.#shutdown('complete');
   }
-}
+}

package/src/event.ts

@@ -3,14 +3,16 @@ import type { CompilerEvent, CompilerEventPayload, CompilerEventType } from './t
 const VALID_EVENT_TYPES = new Set<CompilerEventType>(['change', 'log', 'progress', 'state', 'all', 'file']);
 
 export class EventUtil {
-
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  static isComplilerEventType = (value: string): value is CompilerEventType => VALID_EVENT_TYPES.has(value as CompilerEventType);
+  static isCompilerEventType = (value: string): value is CompilerEventType => VALID_EVENT_TYPES.has(value as CompilerEventType);
 
   static isCompilerEvent = (value: unknown): value is CompilerEvent =>
-    typeof value === 'object' && value !== null && 'type' in value && typeof value.type === 'string' && EventUtil.isComplilerEventType(value.type);
+    typeof value === 'object' &&
+    value !== null &&
+    'type' in value &&
+    typeof value.type === 'string' &&
+    EventUtil.isCompilerEventType(value.type);
 
   static sendEvent<K extends CompilerEventType, T extends CompilerEventPayload<K>>(type: K, payload: T): void {
-    process.connected && process.send!({ type, payload }, undefined, undefined, () => { });
+    process.connected && process.send!({ type, payload }, undefined, undefined, () => {});
   }
-}
+}

package/src/log.ts

@@ -15,7 +15,6 @@ export type LogShape = Record<'info' | 'debug' | 'warn' | 'error', (message: str
 const ESC = '\x1b[';
 
 export class Logger implements LogConfig, LogShape {
-
   static #linePartial: boolean | undefined;
 
   /** Rewrite text line, tracking cleanup as necessary */
@@ -23,7 +22,8 @@ export class Logger implements LogConfig, LogShape {
     if ((!text && !this.#linePartial) || !process.stdout.isTTY) {
       return;
     }
-    if (this.#linePartial === undefined) { // First time
+    if (this.#linePartial === undefined) {
+      // First time
       process.stdout.write(`${ESC}?25l`); // Hide cursor
       process.on('exit', () => this.reset());
     }
@@ -35,7 +35,9 @@ export class Logger implements LogConfig, LogShape {
     }
   }
 
-  static reset(): void { process.stdout.write(`${ESC}!p${ESC}?25h`); }
+  static reset(): void {
+    process.stdout.write(`${ESC}!p${ESC}?25h`);
+  }
 
   level?: CompilerLogLevel | 'none';
   root: string = process.cwd();
@@ -47,28 +49,38 @@ export class Logger implements LogConfig, LogShape {
   }
 
   valid(event: CompilerLogEvent): boolean {
-    return LEVEL_TO_PRIORITY[this.level ?? this.parent?.level!] <= LEVEL_TO_PRIORITY[event.level];
+    return LEVEL_TO_PRIORITY[this.level ?? this.parent?.level ?? 'none'] <= LEVEL_TO_PRIORITY[event.level];
   }
 
   /** Log event with filtering by level */
   render(event: CompilerLogEvent): void {
-    if (!this.valid(event)) { return; }
-    const params = [event.message, ...event.args ?? []]
-      .map(arg => typeof arg === 'string' ? arg.replaceAll(this.root ?? this.parent?.root!, '.') : arg);
+    if (!this.valid(event)) {
+      return;
+    }
+    const params = [event.message, ...(event.args ?? [])].map(arg =>
+      typeof arg === 'string' ? arg.replaceAll(this.root ?? this.parent?.root, '.') : arg
+    );
 
     if (event.scope ?? this.scope) {
       params.unshift(`[${(event.scope ?? this.scope!).padEnd(SCOPE_MAX, ' ')}]`);
     }
     params.unshift(new Date().toISOString(), `${event.level.padEnd(5)}`);
     Logger.rewriteLine(''); // Clear out progress line, if active
-    // eslint-disable-next-line no-console
     console[event.level]!(...params);
   }
 
-  info(message: string, ...args: unknown[]): void { return this.render({ level: 'info', message, args }); }
-  debug(message: string, ...args: unknown[]): void { return this.render({ level: 'debug', message, args }); }
-  warn(message: string, ...args: unknown[]): void { return this.render({ level: 'warn', message, args }); }
-  error(message: string, ...args: unknown[]): void { return this.render({ level: 'error', message, args }); }
+  info(message: string, ...args: unknown[]): void {
+    this.render({ level: 'info', message, args });
+  }
+  debug(message: string, ...args: unknown[]): void {
+    this.render({ level: 'debug', message, args });
+  }
+  warn(message: string, ...args: unknown[]): void {
+    this.render({ level: 'warn', message, args });
+  }
+  error(message: string, ...args: unknown[]): void {
+    this.render({ level: 'error', message, args });
+  }
 }
 
 class $RootLogger extends Logger {
@@ -86,9 +98,17 @@ class $RootLogger extends Logger {
   initLevel(defaultLevel: CompilerLogLevel | 'none'): void {
     const value = process.env.TRV_QUIET !== 'true' ? process.env.TRV_BUILD : 'none';
     switch (value) {
-      case 'debug': case 'warn': case 'error': case 'info': this.level = value; break;
-      case undefined: this.level = defaultLevel; break;
-      case 'none': default: this.level = 'none';
+      case 'debug':
+      case 'warn':
+      case 'error':
+      case 'info':
+        this.level = value;
+        break;
+      case undefined:
+        this.level = defaultLevel;
+        break;
+      default:
+        this.level = 'none';
     }
   }
 
@@ -100,21 +120,34 @@ class $RootLogger extends Logger {
   /** Scope and provide a callback pattern for access to a logger */
   wrap<T = unknown>(scope: string, operation: (log: Logger) => Promise<T>, basic = true): Promise<T> {
     const logger = this.scoped(scope);
-    return basic ? (logger.debug('Started'), operation(logger).finally(() => logger.debug('Completed'))) : operation(logger);
+    if (basic) {
+      logger.debug('Started');
+      return operation(logger).finally(() => logger.debug('Completed'));
+    } else {
+      return operation(logger);
+    }
   }
 
   /** Write progress event, if active */
   onProgressEvent(event: CompilerProgressEvent): void | Promise<void> {
-    if (!(this.logProgress)) { return; }
-    const progress = Math.trunc(event.idx * 100 / event.total);
-    const text = event.complete ? '' : `Compiling [${'#'.repeat(Math.trunc(progress / 10)).padEnd(10, ' ')}] [${event.idx}/${event.total}] ${event.message}`;
+    if (!this.logProgress) {
+      return;
+    }
+    const progress = Math.trunc((event.idx * 100) / event.total);
+    const text = event.complete
+      ? ''
+      : `Compiling [${'#'.repeat(Math.trunc(progress / 10)).padEnd(10, ' ')}] [${event.idx}/${event.total}] ${event.message}`;
     return Logger.rewriteLine(text);
   }
 
   /** Write all progress events if active */
   async consumeProgressEvents(input: () => AsyncIterable<CompilerProgressEvent>): Promise<void> {
-    if (!(this.logProgress)) { return; }
-    for await (const event of input()) { this.onProgressEvent(event); }
+    if (!this.logProgress) {
+      return;
+    }
+    for await (const event of input()) {
+      this.onProgressEvent(event);
+    }
     Logger.reset();
   }
 }
@@ -123,7 +156,9 @@ export const Log = new $RootLogger();
 
 export class IpcLogger extends Logger {
   render(event: CompilerLogEvent): void {
-    if (!this.valid(event)) { return; }
+    if (!this.valid(event)) {
+      return;
+    }
     if (process.connected && process.send) {
       process.send({ type: 'log', payload: event });
     }

package/src/queue.ts

@@ -10,7 +10,9 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
     }
   }
 
-  [Symbol.asyncIterator](): AsyncIterator<X> { return this; }
+  [Symbol.asyncIterator](): AsyncIterator<X> {
+    return this;
+  }
 
   async next(): Promise<IteratorResult<X>> {
     while (!this.#done && !this.#queue.length) {
@@ -35,4 +37,4 @@ export class AsyncQueue<X> implements AsyncIterator<X>, AsyncIterable<X> {
     this.#done = true;
     this.#ready.resolve();
   }
-}
+}