@travetto/compiler 8.0.0-alpha.2 → 8.0.0-alpha.21

package/README.md

@@ -17,15 +17,15 @@ 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|watch` - Run the compiler in watch mode
+   *  `start` - Run the compiler in watch mode
    *  `stop` - Stop the compiler if running
    *  `restart` - Restart the compiler in watch mode
    *  `build` - Ensure the project is built and upto date
@@ -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
@@ -48,7 +48,7 @@ $ TRV_BUILD=debug trvc build
 2029-03-14T04:00:02.450Z info  [compiler-exec  ] Launching compiler
 2029-03-14T04:00:02.762Z debug [server         ] Compilation started
 2029-03-14T04:00:02.947Z info  [server         ] State changed: init
-2029-03-14T04:00:03.093Z debug [server         ] Compiler loaded
+2029-03-14T04:00:03.093Z debug [server         ] Compiler loaded: 0 files changed
 2029-03-14T04:00:04.003Z info  [server         ] State changed: compile-start
 2029-03-14T04:00:04.495Z info  [server         ] State changed: compile-end
 2029-03-14T04:00:05.066Z debug [server         ] Compiler process shutdown

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,20 +1,17 @@
-import module from 'node:module';
+// @ts-check
+
 import { readFileSync } from 'node:fs';
+import module from 'node:module';
 import { fileURLToPath } from 'node:url';
 
-import '@travetto/runtime/support/polyfill.js';
-
-process.setSourceMapsEnabled(true); // Ensure source map during compilation/development
-process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --enable-source-maps`; // Ensure it passes to children
-const ogEmitWarning = process.emitWarning;
-Error.stackTraceLimit = 50;
+const ogEmitWarning = process.emitWarning.bind(process);
 
 module.registerHooks({
   load: (url, context, nextLoad) => {
     if (/[.]tsx?$/.test(url)) {
+      const source = readFileSync(fileURLToPath(url), 'utf8');
       try {
-        process.emitWarning = () => { }; // Suppress ts-node experimental warnings
-        const source = readFileSync(fileURLToPath(url), 'utf8');
+        process.emitWarning = () => {};
         return { format: 'module', source: module.stripTypeScriptTypes(source), shortCircuit: true };
       } finally {
         process.emitWarning = ogEmitWarning;

package/bin/trvc-target.js

@@ -1,4 +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

@@ -1,5 +1,7 @@
 #!/usr/bin/env node
 // @ts-check
+import '@travetto/runtime/support/patch.js';
 import './hook.js';
+
 const { invoke } = await import('@travetto/compiler/support/invoke.ts');
-await invoke();
+await invoke(...process.argv.slice(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "8.0.0-alpha.2",
+  "version": "8.0.0-alpha.21",
   "type": "module",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
@@ -31,11 +31,11 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.5.6",
-    "@travetto/manifest": "^8.0.0-alpha.2",
-    "@travetto/transformer": "^8.0.0-alpha.2"
+    "@travetto/manifest": "^8.0.0-alpha.11",
+    "@travetto/transformer": "^8.0.0-alpha.14"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.3"
+    "@travetto/cli": "^8.0.0-alpha.28"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

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,16 +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 { CompilerUtil } from './util.ts';
-import { CompilerState } from './state.ts';
-import { CompilerWatcher } from './watch.ts';
-import { type CompileEmitEvent, type CompileEmitter, 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' });
 
@@ -18,7 +16,6 @@ const log = new IpcLogger({ level: 'debug' });
  * Compilation support
  */
 export class Compiler {
-
   /**
    * Run compiler as a main entry point
    */
@@ -32,8 +29,8 @@ export class Compiler {
 
   #state: CompilerState;
   #watch?: boolean;
-  #controller: AbortController;
-  #signal: AbortSignal;
+  #shutdownController: AbortController;
+  #shutdownSignal: AbortSignal;
   #shuttingDown = false;
   #deltaEvents: DeltaEvent[];
 
@@ -42,15 +39,13 @@ 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', error?: Error): void {
+  #shutdown(mode: 'error' | 'manual' | 'complete' | 'reset', errorMessage?: string): void {
     if (this.#shuttingDown) {
       return;
     }
@@ -64,14 +59,13 @@ export class Compiler {
       }
       case 'error': {
         process.exitCode = 1;
-        if (error) {
-          EventUtil.sendEvent('log', { level: 'error', message: error.toString(), time: Date.now() });
-          log.error('Shutting down due to failure', error.stack);
+        if (errorMessage) {
+          log.error('Shutting down due to failure', errorMessage);
         }
         break;
       }
       case 'reset': {
-        log.info('Reset due to', error?.message);
+        log.info('Reset due to', errorMessage);
         EventUtil.sendEvent('state', { state: 'reset' });
         process.exitCode = 0;
         break;
@@ -80,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
   }
 
@@ -110,35 +104,27 @@ export class Compiler {
     });
   }
 
-  /**
-   * Compile in a single pass, only emitting dirty files
-   */
-  getCompiler(): CompileEmitter {
-    return (sourceFile: string, needsNewProgram?: boolean) => this.#state.compileSourceFile(sourceFile, needsNewProgram);
-  }
-
   /**
    * Emit all files as a stream
    */
-  async * emit(files: string[], emitter: CompileEmitter): AsyncIterable<CompileEmitEvent> {
+  async *emit(files: string[]): AsyncIterable<CompileEmitEvent> {
     let i = 0;
     let lastSent = Date.now();
 
-    await emitter(files[0]); // Prime
-
     for (const file of files) {
       const start = Date.now();
-      const error = await emitter(file);
+      const errors = await this.#state.compileSourceFile(file);
       const duration = Date.now() - start;
       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, error, 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;
       }
     }
@@ -157,49 +143,52 @@ export class Compiler {
 
     EventUtil.sendEvent('state', { state: 'init', extra: { processId: process.pid } });
 
-    const emitter = this.getCompiler();
-    let failure: Error | undefined;
+    const failures = new Map<string, number>();
 
-    log.debug('Compiler loaded');
+    log.debug(`Compiler loaded: ${this.#deltaEvents.length} files changed`);
 
     EventUtil.sendEvent('state', { state: 'compile-start' });
 
     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));
-
-    if (this.#watch || changedFiles.length) {
-      await ManifestUtil.writeManifest(this.#state.manifestIndex.manifest);
-      await this.#state.initializeTypescript();
-    }
+    const changedFiles = isCompilerChanged ? this.#state.getAllFiles() : this.#deltaEvents.map(event => event.sourceFile);
 
     if (changedFiles.length) {
-      for await (const event of this.emit(changedFiles, emitter)) {
-        if (event.error) {
-          const compileError = CompilerUtil.buildTranspileError(event.file, event.error);
-          failure ??= compileError;
-          EventUtil.sendEvent('log', { level: 'error', message: compileError.toString(), time: Date.now() });
+      for await (const event of this.emit(changedFiles)) {
+        if (event.errors?.length) {
+          failures.set(event.file, event.errors.length);
+          for (const error of event.errors) {
+            log.error(`ERROR ${event.file}:${error}`);
+          }
+          // Touch file to ensure recompilation later
+          if (await fs.stat(event.file, { throwIfNoEntry: false })) {
+            await fs.utimes(event.file, new Date(), new Date());
+          }
         }
         metrics.push(event);
       }
-      if (this.#signal.aborted) {
+      if (this.#shutdownSignal.aborted) {
         log.debug('Compilation aborted');
-      } else if (failure) {
-        log.debug('Compilation failed');
-        return this.#shutdown('error', failure);
+      } else if (failures.size) {
+        const sortedFailures = [...failures.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+        log.error(
+          'Compilation failed',
+          ['', sortedFailures.flatMap(([file, count]) => `- ${file}: ${count} errors found`)].flat(3).join('\n')
+        );
       } else {
         log.debug('Compilation succeeded');
       }
 
-      // Rebuild manifests if dirty
+      // Rebuild manifests
       const manifest = await ManifestUtil.buildManifest(this.#state.manifestIndex.manifest);
       await ManifestUtil.writeManifest(manifest);
       await ManifestUtil.writeDependentManifests(manifest);
+
+      if (!this.#watch && failures.size) {
+        return this.#shutdown('error');
+      }
+
       this.#state.manifestIndex.reinitForModule(this.#state.manifest.main.name); // Reload
-    } else if (this.#watch) {
-      // Prime compiler before complete
-      const resolved = this.#state.getArbitraryInputFile();
-      await emitter(resolved, true);
     }
 
     EventUtil.sendEvent('state', { state: 'compile-end' });
@@ -208,16 +197,22 @@ 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);
+
       log.info('Watch is ready');
 
       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 error = await emitter(event.entry.sourceFile, true);
-            if (error) {
-              log.info('Compilation Error', CompilerUtil.buildTranspileError(event.entry.sourceFile, error));
+            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}`);
             }
@@ -242,7 +237,7 @@ export class Compiler {
         EventUtil.sendEvent('state', { state: 'watch-end' });
       } catch (error) {
         if (error instanceof Error) {
-          this.#shutdown(error instanceof CompilerReset ? 'reset' : 'error', error);
+          this.#shutdown(error instanceof CompilerReset ? 'reset' : 'error', error.message);
         }
       }
     }

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 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.isComplilerEventType(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();
   }
-}
+}