@travetto/compiler 8.0.0-alpha.20 → 8.0.0-alpha.22

package/src/server/manager.ts

@@ -2,11 +2,11 @@ import { spawn } from 'node:child_process';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerEvent, CompilerLogLevel } from '../types.ts';
-import { AsyncQueue } from '../queue.ts';
-import { Log } from '../log.ts';
 import { CommonUtil } from '../common.ts';
 import { EventUtil } from '../event.ts';
+import { Log } from '../log.ts';
+import { AsyncQueue } from '../queue.ts';
+import type { CompilerEvent, CompilerLogLevel } from '../types.ts';
 import type { CompilerClient } from './client.ts';
 import { CompilerServer } from './server.ts';
 
@@ -17,7 +17,7 @@ const log = Log.scoped('compiler-exec');
  */
 export class CompilerManager {
   /** Run compile process */
-  static async * #runTarget(ctx: ManifestContext, watching: boolean, signal: AbortSignal): AsyncIterable<CompilerEvent> {
+  static async *#runTarget(ctx: ManifestContext, watching: boolean, signal: AbortSignal): AsyncIterable<CompilerEvent> {
     if (signal.aborted) {
       log.debug('Skipping, shutting down');
       return;
@@ -30,17 +30,17 @@ export class CompilerManager {
       env: {
         ...process.env,
         TRV_COMPILER_WATCH: String(watching),
-        TRV_MANIFEST: CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', ctx.workspace.name),
+        TRV_MANIFEST: CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', ctx.workspace.name)
       },
       detached: true,
-      stdio: ['pipe', 1, 2, 'ipc'],
+      stdio: ['pipe', 1, 2, 'ipc']
     })
       .on('message', message => EventUtil.isCompilerEvent(message) && queue.add(message))
       .on('exit', () => queue.close());
 
     const kill = (): unknown => {
       log.debug('Shutting down process');
-      return (subProcess.connected ? subProcess.send('shutdown', () => subProcess.kill()) : subProcess.kill());
+      return subProcess.connected ? subProcess.send('shutdown', () => subProcess.kill()) : subProcess.kill();
     };
 
     process.once('SIGINT', kill);
@@ -58,11 +58,15 @@ export class CompilerManager {
   }
 
   /** Main entry point for compilation */
-  static async compile(ctx: ManifestContext, client: CompilerClient, config: { watch?: boolean, logLevel?: CompilerLogLevel, forceRestart?: boolean }): Promise<void> {
+  static async compile(
+    ctx: ManifestContext,
+    client: CompilerClient,
+    config: { watch?: boolean; logLevel?: CompilerLogLevel; forceRestart?: boolean }
+  ): Promise<void> {
     Log.initLevel(config.logLevel ?? 'info');
     const watch = !!config.watch;
 
-    if (config.forceRestart && await client.stop()) {
+    if (config.forceRestart && (await client.stop())) {
       log.info('Stopped existing server');
     }
 
@@ -84,8 +88,9 @@ export class CompilerManager {
 
   /** Compile only if necessary */
   static async compileIfNecessary(ctx: ManifestContext, client: CompilerClient): Promise<void> {
-    if (!(await client.isWatching())) { // Short circuit if we can
+    if (!(await client.isWatching())) {
+      // Short circuit if we can
       await this.compile(ctx, client, { watch: false, logLevel: 'error' });
     }
   }
-}
+}

package/src/server/process-handle.ts

@@ -3,11 +3,10 @@ import path from 'node:path';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import { Log, type Logger } from '../log.ts';
 import { CommonUtil } from '../common.ts';
+import { Log, type Logger } from '../log.ts';
 
 export class ProcessHandle {
-
   #file: string;
   #log: Logger;
 
@@ -22,13 +21,17 @@ export class ProcessHandle {
   }
 
   getProcessId(): Promise<number | undefined> {
-    return fs.readFile(this.#file, 'utf8')
-      .then(processId => +processId > 0 ? +processId : undefined, () => undefined);
+    return fs.readFile(this.#file, 'utf8').then(
+      processId => (+processId > 0 ? +processId : undefined),
+      () => undefined
+    );
   }
 
   async isRunning(): Promise<boolean> {
     const processId = await this.getProcessId();
-    if (!processId) { return false; }
+    if (!processId) {
+      return false;
+    }
     try {
       process.kill(processId, 0); // See if process is still running
       this.#log.debug('Is running', processId);
@@ -41,11 +44,11 @@ export class ProcessHandle {
 
   async kill(): Promise<boolean> {
     const processId = await this.getProcessId();
-    if (processId && await this.isRunning()) {
+    if (processId && (await this.isRunning())) {
       try {
         this.#log.debug('Killing', processId);
         return process.kill(processId);
-      } catch { }
+      } catch {}
     }
     return false;
   }
@@ -58,8 +61,9 @@ export class ProcessHandle {
     }
 
     this.#log.debug('Ensuring Killed', processId);
-    while ((Date.now() - start) < gracePeriod) { // Ensure its done
-      if (!await this.isRunning()) {
+    while (Date.now() - start < gracePeriod) {
+      // Ensure its done
+      if (!(await this.isRunning())) {
         return true;
       }
       await CommonUtil.blockingTimeout(100);
@@ -67,7 +71,7 @@ export class ProcessHandle {
     try {
       this.#log.debug('Force Killing', processId);
       process.kill(processId); // Force kill
-    } catch { }
+    } catch {}
     this.#log.debug('Did Kill', this.#file, !!processId);
     return true;
   }

package/src/server/server.ts

@@ -1,15 +1,15 @@
-import http from 'node:http';
-import fs from 'node:fs/promises';
 import { setMaxListeners } from 'node:events';
+import fs from 'node:fs/promises';
+import http from 'node:http';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerProgressEvent, CompilerEvent, CompilerEventType, CompilerServerInfo } from '../types.ts';
-import { Log } from '../log.ts';
 import { CommonUtil } from '../common.ts';
+import { EventUtil } from '../event.ts';
+import { Log } from '../log.ts';
+import type { CompilerEvent, CompilerEventType, CompilerProgressEvent, CompilerServerInfo } from '../types.ts';
 import { CompilerClient } from './client.ts';
 import { ProcessHandle } from './process-handle.ts';
-import { EventUtil } from '../event.ts';
 
 const log = Log.scoped('server');
 
@@ -17,7 +17,6 @@ const log = Log.scoped('server');
  * Compiler Server Class
  */
 export class CompilerServer {
-
   #ctx: ManifestContext;
   #server: http.Server;
   #listenersAll = new Set<http.ServerResponse>();
@@ -46,11 +45,14 @@ export class CompilerServer {
       url: this.#url
     };
 
-    this.#server = http.createServer({
-      keepAlive: true,
-      requestTimeout: 1000 * 60 * 60,
-      keepAliveTimeout: 1000 * 60 * 60,
-    }, (request, response) => this.#onRequest(request, response));
+    this.#server = http.createServer(
+      {
+        keepAlive: true,
+        requestTimeout: 1000 * 60 * 60,
+        keepAliveTimeout: 1000 * 60 * 60
+      },
+      (request, response) => this.#onRequest(request, response)
+    );
 
     setMaxListeners(1000, this.signal);
   }
@@ -74,7 +76,7 @@ export class CompilerServer {
         .on('error', async error => {
           if ('code' in error && error.code === 'EADDRINUSE') {
             const info = await this.#client.info();
-            resolve((info && !info.watching && this.watching) ? 'retry' : 'running');
+            resolve(info && !info.watching && this.watching ? 'retry' : 'running');
           } else {
             log.warn('Failed in running server', error);
             reject(error);
@@ -106,7 +108,8 @@ export class CompilerServer {
     const id = `id_${Date.now()}_${Math.random()}`.replace('.', '1');
     (this.#listeners[type] ??= {})[id] = response;
     this.#listenersAll.add(response);
-    if (type === 'state' || type === 'all') { // Send on initial connect
+    if (type === 'state' || type === 'all') {
+      // Send on initial connect
       this.#emitEvent({ type: 'state', payload: { state: this.info.state } }, id);
     } else {
       response.write('\n'); // Send at least one byte on listen
@@ -146,15 +149,20 @@ export class CompilerServer {
     this.info.iteration = Date.now();
     await CommonUtil.blockingTimeout(20);
     for (const listener of this.#listenersAll) {
-      try { listener.end(); } catch { }
+      try {
+        listener.end();
+      } catch {}
     }
     this.#listeners = {}; // Ensure its empty
     this.#listenersAll.clear();
   }
 
   async #clean(): Promise<{ clean: boolean }> {
-    await Promise.all([this.#ctx.build.outputFolder, this.#ctx.build.typesFolder]
-      .map(folder => fs.rm(CommonUtil.resolveWorkspace(this.#ctx, folder), { recursive: true, force: true })));
+    await Promise.all(
+      [this.#ctx.build.outputFolder, this.#ctx.build.typesFolder].map(folder =>
+        fs.rm(CommonUtil.resolveWorkspace(this.#ctx, folder), { recursive: true, force: true })
+      )
+    );
     return { clean: true };
   }
 
@@ -175,10 +183,16 @@ export class CompilerServer {
         }
         return;
       }
-      case 'clean': out = await this.#clean(); break;
-      case 'stop': out = JSON.stringify({ closing: true }); close = true; break;
-      case 'info':
-      default: out = this.info ?? {}; break;
+      case 'clean':
+        out = await this.#clean();
+        break;
+      case 'stop':
+        out = JSON.stringify({ closing: true });
+        close = true;
+        break;
+      default:
+        out = this.info ?? {};
+        break;
     }
     response.end(JSON.stringify(out));
     if (close) {
@@ -199,7 +213,12 @@ export class CompilerServer {
 
       if (event.type === 'state') {
         this.info.state = event.payload.state;
-        if (event.payload.state === 'init' && event.payload.extra && 'processId' in event.payload.extra && typeof event.payload.extra.processId === 'number') {
+        if (
+          event.payload.state === 'init' &&
+          event.payload.extra &&
+          'processId' in event.payload.extra &&
+          typeof event.payload.extra.processId === 'number'
+        ) {
           if (this.info.watching && !this.info.compilerProcessId) {
             // Ensure we are killing in watch mode on first set
             await this.#handle.compiler.kill();
@@ -247,7 +266,8 @@ export class CompilerServer {
           this.#shutdown.abort();
         });
       });
-    } catch { // Timeout or other error
+    } catch {
+      // Timeout or other error
       // Force shutdown
       this.#server.closeAllConnections();
       await this.#handle.compiler.kill();
@@ -260,7 +280,7 @@ export class CompilerServer {
    * Start the server listening
    */
   async listen(): Promise<CompilerServer | undefined> {
-    const running = await this.#tryListen() === 'ok';
+    const running = (await this.#tryListen()) === 'ok';
     log.info(running ? 'Starting server' : 'Server already running under a different process', this.#url);
     return running ? this : undefined;
   }

package/src/state.ts

@@ -1,25 +1,29 @@
 import fs from 'node:fs';
-import type { CompilerHost, SourceFile, CompilerOptions, Program, ScriptTarget } from 'typescript';
 
-import { path, ManifestModuleUtil, type ManifestModule, type ManifestRoot, type ManifestIndex, type ManifestModuleFolderType } from '@travetto/manifest';
+import type { CompilerHost, CompilerOptions, Program, ScriptTarget, SourceFile } from 'typescript';
+
+import {
+  type ManifestIndex,
+  type ManifestModule,
+  type ManifestModuleFolderType,
+  ManifestModuleUtil,
+  type ManifestRoot,
+  path
+} from '@travetto/manifest';
 import type { TransformerManager } from '@travetto/transformer';
 
-import { CompilerUtil } from './util.ts';
-import type { CompileStateEntry } from './types.ts';
 import { CommonUtil } from './common.ts';
 import { tsProxy as ts, tsProxyInit } from './ts-proxy.ts';
+import type { CompileStateEntry } from './types.ts';
+import { CompilerUtil } from './util.ts';
 
 const TYPINGS_FOLDER_KEYS = new Set<ManifestModuleFolderType>(['$index', 'support', 'src', '$package']);
 
 export class CompilerState implements CompilerHost {
-
   static async get(idx: ManifestIndex): Promise<CompilerState> {
     return new CompilerState().init(idx);
   }
 
-  /** @private */
-  constructor() { }
-
   #outputPath: string;
   #typingsPath: string;
   #sourceFiles = new Set<string>();
@@ -44,7 +48,9 @@ export class CompilerState implements CompilerHost {
     try {
       return ts.sys.readFile(location, 'utf8');
     } catch {
-      try { return fs.readFileSync(location, 'utf8'); } catch { }
+      try {
+        return fs.readFileSync(location, 'utf8');
+      } catch {}
     }
     return undefined;
   }
@@ -61,13 +67,17 @@ export class CompilerState implements CompilerHost {
   #fileExists(location: string): boolean {
     try {
       return ts.sys.fileExists(location);
-    } catch { return fs.existsSync(location); }
+    } catch {
+      return fs.existsSync(location);
+    }
   }
 
   #directoryExists(location: string): boolean {
     try {
       return ts.sys.directoryExists(location);
-    } catch { return fs.existsSync(location); }
+    } catch {
+      return fs.existsSync(location);
+    }
   }
 
   #writeExternalTypings(location: string, text: string, bom?: boolean): void {
@@ -120,14 +130,14 @@ export class CompilerState implements CompilerHost {
     for (const module of this.#modules) {
       const base = module?.files ?? {};
       const files = [
-        ...base.bin ?? [],
-        ...base.src ?? [],
-        ...base.support ?? [],
-        ...base.doc ?? [],
-        ...base.test ?? [],
-        ...base.$transformer ?? [],
-        ...base.$index ?? [],
-        ...base.$package ?? []
+        ...(base.bin ?? []),
+        ...(base.src ?? []),
+        ...(base.support ?? []),
+        ...(base.doc ?? []),
+        ...(base.test ?? []),
+        ...(base.$transformer ?? []),
+        ...(base.$index ?? []),
+        ...(base.$package ?? [])
       ];
       for (const [file, type] of files) {
         if (ManifestModuleUtil.isSourceType(type)) {
@@ -158,9 +168,7 @@ export class CompilerState implements CompilerHost {
   }
 
   getArbitraryInputFile(): string {
-    const randomSource = this.#manifestIndex.getWorkspaceModules()
-      .filter(module => module.files.src?.length)[0]
-      .files.src[0].sourceFile;
+    const randomSource = this.#manifestIndex.getWorkspaceModules().filter(module => module.files.src?.length)[0].files.src[0].sourceFile;
 
     return this.getBySource(randomSource)!.sourceFile;
   }
@@ -168,7 +176,12 @@ export class CompilerState implements CompilerHost {
   async getProgram(force = false): Promise<Program> {
     if (force || !this.#program) {
       await this.initializeTypescript();
-      this.#program = ts.createProgram({ rootNames: this.getAllFiles(), host: this, options: this.#compilerOptions, oldProgram: this.#program });
+      this.#program = ts.createProgram({
+        rootNames: this.getAllFiles(),
+        host: this,
+        options: this.#compilerOptions,
+        oldProgram: this.#program
+      });
       this.#transformerManager.init(this.#program.getTypeChecker());
       await CommonUtil.queueMacroTask();
     }
@@ -191,30 +204,34 @@ export class CompilerState implements CompilerHost {
         break;
       }
       case 'js':
-      case 'typings': this.writeFile(output, this.readFile(sourceFile)!); break;
+      case 'typings':
+        this.writeFile(output, this.readFile(sourceFile)!);
+        break;
       case 'ts': {
         const program = await this.getProgram(needsNewProgram);
         const tsSourceFile = program.getSourceFile(sourceFile)!;
         program.emit(
           tsSourceFile,
-          (...args) => this.writeFile(args[0], args[1], args[2]), undefined, false,
+          (...args) => this.writeFile(args[0], args[1], args[2]),
+          undefined,
+          false,
           this.#transformerManager.get()
         );
         return [
           ...program.getSemanticDiagnostics(tsSourceFile),
           ...program.getSyntacticDiagnostics(tsSourceFile),
-          ...program.getDeclarationDiagnostics(tsSourceFile),
+          ...program.getDeclarationDiagnostics(tsSourceFile)
         ]
           .filter(d => d.category === ts.DiagnosticCategory.Error)
           .map(diag => {
             let message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
             if (
-              message.includes("is not under 'rootDir'")
-              || message.includes("does not exist on type 'EnvDataCombinedType'")
-              || message.startsWith('Could not find a declaration file for module')
-              || message.startsWith("Cannot find module '@travetto")
-              || message.startsWith("This JSX tag requires the module path '@travetto")
-              || message.startsWith("JSX element implicitly has type 'any'")
+              message.includes("is not under 'rootDir'") ||
+              message.includes("does not exist on type 'EnvDataCombinedType'") ||
+              message.startsWith('Could not find a declaration file for module') ||
+              message.startsWith("Cannot find module '@travetto") ||
+              message.startsWith("This JSX tag requires the module path '@travetto") ||
+              message.startsWith("JSX element implicitly has type 'any'")
             ) {
               return '';
             }
@@ -235,7 +252,11 @@ export class CompilerState implements CompilerHost {
 
   isCompilerFile(file: string): boolean {
     const entry = this.getBySource(file);
-    return (entry?.moduleFile && ManifestModuleUtil.getFileRole(entry.moduleFile) === 'compile') || entry?.module.roles.includes('compile') || false;
+    return (
+      (entry?.moduleFile && ManifestModuleUtil.getFileRole(entry.moduleFile) === 'compile') ||
+      entry?.module.roles.includes('compile') ||
+      false
+    );
   }
 
   registerInput(module: ManifestModule, moduleFile: string): CompileStateEntry {
@@ -309,12 +330,24 @@ export class CompilerState implements CompilerHost {
   }
 
   /* Start Compiler Host */
-  getCanonicalFileName(file: string): string { return file; }
-  getCurrentDirectory(): string { return this.#manifest.workspace.path; }
-  getDefaultLibFileName(options: CompilerOptions): string { return ts.getDefaultLibFileName(options); }
-  getNewLine(): string { return ts.sys.newLine; }
-  useCaseSensitiveFileNames(): boolean { return ts.sys.useCaseSensitiveFileNames; }
-  getDefaultLibLocation(): string { return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions)); }
+  getCanonicalFileName(file: string): string {
+    return file;
+  }
+  getCurrentDirectory(): string {
+    return this.#manifest.workspace.path;
+  }
+  getDefaultLibFileName(options: CompilerOptions): string {
+    return ts.getDefaultLibFileName(options);
+  }
+  getNewLine(): string {
+    return ts.sys.newLine;
+  }
+  useCaseSensitiveFileNames(): boolean {
+    return ts.sys.useCaseSensitiveFileNames;
+  }
+  getDefaultLibLocation(): string {
+    return path.dirname(ts.getDefaultLibFilePath(this.#compilerOptions));
+  }
 
   fileExists(sourceFile: string): boolean {
     return this.#sourceToEntry.has(sourceFile) || this.#fileExists(sourceFile);
@@ -334,7 +367,7 @@ export class CompilerState implements CompilerHost {
       this.#writeExternalTypings(location, text, bom);
     }
 
-    return this.#writeFile(location, text, bom);
+    this.#writeFile(location, text, bom);
   }
 
   readFile(sourceFile: string): string | undefined {
@@ -349,4 +382,4 @@ export class CompilerState implements CompilerHost {
       return ts.createSourceFile(sourceFile, content ?? '', language);
     });
   }
-}
+}

package/src/ts-proxy.ts

@@ -1,12 +1,14 @@
-/* eslint-disable @typescript-eslint/consistent-type-assertions */
 import type ts from 'typescript';
 
 let state: typeof ts | undefined;
 let promise: Promise<unknown> | undefined;
-export const tsProxyInit = (): Promise<unknown> => promise ??= import('typescript').then(module => { state = module.default; });
+export const tsProxyInit = (): Promise<unknown> =>
+  (promise ??= import('typescript').then(module => {
+    state = module.default;
+  }));
 
 export const tsProxy = new Proxy({}!, {
   get(_, prop: string): unknown {
     return state![prop as keyof typeof ts];
   }
-}) as typeof ts;
+}) as typeof ts;

package/src/types.ts

@@ -3,23 +3,30 @@ import type { ChangeEventType, ManifestModule } from '@travetto/manifest';
 export type CompilerStateType = 'startup' | 'init' | 'compile-start' | 'compile-end' | 'watch-start' | 'watch-end' | 'reset' | 'closed';
 export type CompilerLogLevel = 'info' | 'debug' | 'warn' | 'error';
 
-export type CompileEmitEvent = { file: string, i: number, total: number, errors?: string[], duration: number };
-export type CompileStateEntry = { sourceFile: string, tscOutputFile: string, outputFile?: string, module: ManifestModule, import: string, moduleFile: string };
-export type CompilerWatchEvent = { action: ChangeEventType, file: string, entry: CompileStateEntry, moduleFile: string };
+export type CompileEmitEvent = { file: string; i: number; total: number; errors?: string[]; duration: number };
+export type CompileStateEntry = {
+  sourceFile: string;
+  tscOutputFile: string;
+  outputFile?: string;
+  module: ManifestModule;
+  import: string;
+  moduleFile: string;
+};
+export type CompilerWatchEvent = { action: ChangeEventType; file: string; entry: CompileStateEntry; moduleFile: string };
 
-export type CompilerChangeEvent = { file: string, action: ChangeEventType, output: string, module: string, import: string, time: number };
-export type CompilerLogEvent = { level: CompilerLogLevel, message: string, time?: number, args?: unknown[], scope?: string };
-export type CompilerProgressEvent = { idx: number, total: number, message: string, operation: 'compile', complete?: boolean };
-export type CompilerStateEvent = { state: CompilerStateType, extra?: Record<string, unknown> };
-export type FileChangeEvent = { files: { file: string, action: ChangeEventType }[], time: number };
+export type CompilerChangeEvent = { file: string; action: ChangeEventType; output: string; module: string; import: string; time: number };
+export type CompilerLogEvent = { level: CompilerLogLevel; message: string; time?: number; args?: unknown[]; scope?: string };
+export type CompilerProgressEvent = { idx: number; total: number; message: string; operation: 'compile'; complete?: boolean };
+export type CompilerStateEvent = { state: CompilerStateType; extra?: Record<string, unknown> };
+export type FileChangeEvent = { files: { file: string; action: ChangeEventType }[]; time: number };
 
 export type CompilerEvent =
-  { type: 'file', payload: FileChangeEvent } |
-  { type: 'change', payload: CompilerChangeEvent } |
-  { type: 'log', payload: CompilerLogEvent } |
-  { type: 'progress', payload: CompilerProgressEvent } |
-  { type: 'state', payload: CompilerStateEvent } |
-  { type: 'all', payload: unknown };
+  | { type: 'file'; payload: FileChangeEvent }
+  | { type: 'change'; payload: CompilerChangeEvent }
+  | { type: 'log'; payload: CompilerLogEvent }
+  | { type: 'progress'; payload: CompilerProgressEvent }
+  | { type: 'state'; payload: CompilerStateEvent }
+  | { type: 'all'; payload: unknown };
 
 export type CompilerEventType = CompilerEvent['type'];
 export type CompilerEventPayload<V> = (CompilerEvent & { type: V })['payload'];
@@ -35,4 +42,4 @@ export type CompilerServerInfo = {
   env?: Record<string, string>;
 };
 
-export class CompilerReset extends Error { }
+export class CompilerReset extends Error {}

package/src/util.ts

@@ -4,7 +4,6 @@ import { ManifestModuleUtil, type ManifestRoot, type Package } from '@travetto/m
  * Standard utilities for compiler
  */
 export class CompilerUtil {
-
   /**
    * Rewrites the package.json to target output file names, and pins versions
    * @param manifest
@@ -39,11 +38,10 @@ export class CompilerUtil {
   static naiveHash(text: string): number {
     let hash = 5381;
 
-    for (let i = 0; i < text.length; i++) {
-      // eslint-disable-next-line no-bitwise
+    for (let i = 0; i < text.length; i += 1) {
       hash = (hash * 33) ^ text.charCodeAt(i);
     }
 
     return Math.abs(hash);
   }
-}
+}