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

package/README.md

@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "8.0.0-alpha.2",
+  "version": "8.0.0-alpha.3",
   "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.3",
+    "@travetto/transformer": "^8.0.0-alpha.3"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.3"
+    "@travetto/cli": "^8.0.0-alpha.4"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -3,10 +3,9 @@ import { setMaxListeners } from 'node:events';
 
 import { getManifestContext, ManifestDeltaUtil, ManifestIndex, ManifestUtil, type DeltaEvent } 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 { type CompileEmitEvent, CompilerReset } from './types.ts';
 import { EventUtil } from './event.ts';
 
 import { IpcLogger } from './log.ts';
@@ -50,7 +49,7 @@ export class Compiler {
       .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 +63,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;
@@ -110,30 +108,21 @@ 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 };
+      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' });
@@ -157,10 +146,9 @@ 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' });
 
@@ -168,38 +156,40 @@ export class Compiler {
     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();
-    }
-
     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
+          await fs.utimes(event.file, new Date(), new Date());
         }
         metrics.push(event);
       }
       if (this.#signal.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.debug('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 (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' });
@@ -209,15 +199,18 @@ export class Compiler {
     }
 
     if (this.#watch && !this.#signal.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)) {
           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`);
             } else {
               log.info(`Compiled ${event.entry.sourceFile} on ${event.action}`);
             }
@@ -242,7 +235,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);
         }
       }
     }
@@ -251,4 +244,4 @@ export class Compiler {
 
     this.#shutdown('complete');
   }
-}
+}

package/src/server/manager.ts

@@ -48,8 +48,9 @@ export class CompilerManager {
 
     yield* queue;
 
-    if (subProcess.exitCode !== 0) {
+    if (subProcess.exitCode !== 0 && subProcess.exitCode) {
       log.error(`Terminated during compilation, code=${subProcess.exitCode}, killed=${subProcess.killed}`);
+      process.exitCode = subProcess.exitCode;
     }
     process.off('SIGINT', kill);
 

package/src/state.ts

@@ -4,11 +4,10 @@ import { path, ManifestModuleUtil, type ManifestModule, type ManifestRoot, type
 import type { TransformerManager } from '@travetto/transformer';
 
 import { CompilerUtil } from './util.ts';
-import type { CompileEmitError, CompileStateEntry } from './types.ts';
+import type { CompileStateEntry } from './types.ts';
 import { CommonUtil } from './common.ts';
 import { tsProxy as ts, tsProxyInit } from './ts-proxy.ts';
 
-
 const TYPINGS_FOLDER_KEYS = new Set<ManifestModuleFolderType>(['$index', 'support', 'src', '$package']);
 
 export class CompilerState implements CompilerHost {
@@ -72,9 +71,7 @@ export class CompilerState implements CompilerHost {
     return {
       ...options,
       noEmit: false,
-      emitDeclarationOnly: false,
       allowJs: true,
-      resolveJsonModule: true,
       sourceRoot: this.#manifest.workspace.path,
       rootDir: this.#manifest.workspace.path,
       moduleResolution: ts.ModuleResolutionKind.Bundler,
@@ -140,8 +137,9 @@ export class CompilerState implements CompilerHost {
     return this.getBySource(randomSource)!.sourceFile;
   }
 
-  async createProgram(force = false): Promise<Program> {
+  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.#transformerManager.init(this.#program.getTypeChecker());
       await CommonUtil.queueMacroTask();
@@ -149,36 +147,46 @@ export class CompilerState implements CompilerHost {
     return this.#program;
   }
 
-  async compileSourceFile(sourceFile: string, needsNewProgram = false): Promise<CompileEmitError | undefined> {
+  async compileSourceFile(sourceFile: string, needsNewProgram = false): Promise<string[] | undefined> {
     const output = this.#sourceToEntry.get(sourceFile)?.outputFile;
     if (!output) {
       return;
     }
 
-    const program = await this.createProgram(needsNewProgram);
-    try {
-      switch (ManifestModuleUtil.getFileType(sourceFile)) {
-        case 'typings':
-        case 'package-json':
-          this.writeFile(output, this.readFile(sourceFile)!, false), undefined;
-          break;
-        case 'js':
-          this.writeFile(output, ts.transpile(this.readFile(sourceFile)!, this.#compilerOptions), false);
-          break;
-        case 'ts': {
-          const result = program.emit(
-            program.getSourceFile(sourceFile)!,
-            (...args) => this.writeFile(args[0], args[1], args[2]), undefined, false,
-            this.#transformerManager.get()
-          );
-          return result?.diagnostics?.length ? result.diagnostics : undefined;
-        }
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        return error;
-      } else {
-        throw error;
+    const program = await this.getProgram(needsNewProgram);
+    switch (ManifestModuleUtil.getFileType(sourceFile)) {
+      case 'typings':
+      case 'package-json':
+        this.writeFile(output, this.readFile(sourceFile)!, false), undefined;
+        break;
+      case 'js':
+        this.writeFile(output, ts.transpile(this.readFile(sourceFile)!, this.#compilerOptions), false);
+        break;
+      case 'ts': {
+        const tsSourceFile = program.getSourceFile(sourceFile)!;
+        program.emit(
+          tsSourceFile,
+          (...args) => this.writeFile(args[0], args[1], args[2]), undefined, false,
+          this.#transformerManager.get()
+        );
+        return [
+          ...program.getSemanticDiagnostics(tsSourceFile),
+          ...program.getSyntacticDiagnostics(tsSourceFile),
+          ...program.getDeclarationDiagnostics(tsSourceFile),
+        ]
+          .filter(d => d.category === ts.DiagnosticCategory.Error)
+          .map(diag => {
+            let message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
+            if (message.includes('rootDir') || message.includes('EnvDataCombinedType')) {
+              return '';
+            }
+            if (diag.file) {
+              const { line, character } = diag.file.getLineAndCharacterOfPosition(diag.start!);
+              message = `${line + 1}:${character + 1} -- ${message}`;
+            }
+            return message;
+          })
+          .filter(Boolean);
       }
     }
   }

package/src/ts-proxy.ts

@@ -2,7 +2,8 @@
 import type ts from 'typescript';
 
 let state: typeof ts | undefined;
-export const tsProxyInit = (): Promise<unknown> => import('typescript').then(module => { state = module.default; });
+let promise: Promise<unknown> | undefined;
+export const tsProxyInit = (): Promise<unknown> => promise ??= import('typescript').then(module => { state = module.default; });
 
 export const tsProxy = new Proxy({}!, {
   get(_, prop: string): unknown {

package/src/types.ts

@@ -1,13 +1,9 @@
-import type ts from 'typescript';
-
 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 CompileEmitError = Error | readonly ts.Diagnostic[];
-export type CompileEmitter = (file: string, newProgram?: boolean) => Promise<CompileEmitError | undefined>;
-export type CompileEmitEvent = { file: string, i: number, total: number, error?: CompileEmitError, duration: number };
+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 };
 

package/src/util.ts

@@ -1,10 +1,5 @@
 import { ManifestModuleUtil, type ManifestRoot, type Package } from '@travetto/manifest';
 
-import type { CompileEmitError } from './types.ts';
-import { tsProxy as ts } from './ts-proxy.ts';
-
-const nativeCwd = process.cwd();
-
 /**
  * Standard utilities for compiler
  */
@@ -38,32 +33,6 @@ export class CompilerUtil {
     return JSON.stringify(pkg, null, 2);
   }
 
-  /**
-   * Build transpilation error
-   * @param filename The name of the file
-   * @param diagnostics The diagnostic errors
-   */
-  static buildTranspileError(filename: string, diagnostics: CompileEmitError): Error {
-    if (diagnostics instanceof Error) {
-      return diagnostics;
-    }
-
-    const errors: string[] = diagnostics.slice(0, 5).map(diag => {
-      const message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
-      if (diag.file) {
-        const { line, character } = diag.file.getLineAndCharacterOfPosition(diag.start!);
-        return ` @ ${diag.file.fileName.replace(nativeCwd, '.')}(${line + 1}, ${character + 1}): ${message}`;
-      } else {
-        return ` ${message}`;
-      }
-    });
-
-    if (diagnostics.length > 5) {
-      errors.push(`${diagnostics.length - 5} more ...`);
-    }
-    return new Error(`Transpiling ${filename.replace(nativeCwd, '.')} failed: \n${errors.join('\n')}`);
-  }
-
   /**
    * Naive hashing
    */

package/src/watch.ts

@@ -195,7 +195,7 @@ export class CompilerWatcher {
         return;
       }
       const full = path.resolve(toolRootFolder, file);
-      const stat = await fs.stat(full).catch(() => null);
+      const stat = await fs.stat(full, { throwIfNoEntry: false });
       if (toolFolders.has(full) && !stat) {
         this.#queue.throw(new CompilerReset(`Tooling folder removal ${full}`));
       }
@@ -229,7 +229,7 @@ export class CompilerWatcher {
 
   async #listenGitChanges(): Promise<void> {
     const gitFolder = path.resolve(this.#root, '.git');
-    if (!await fs.stat(gitFolder).catch(() => false)) { return; }
+    if (!await fs.stat(gitFolder, { throwIfNoEntry: false })) { return; }
     log.debug('Starting git canary');
     const listener = watch(gitFolder, { encoding: 'utf8' }, async (event, file) => {
       if (!file) {

package/tsconfig.trv.json

@@ -7,17 +7,22 @@
     "lib": [
       "ESNext",
     ],
+    "types": [
+      "node"
+    ],
     "jsx": "react-jsx",
     "stableTypeOrdering": true,
     "strict": true,
     "declaration": true,
     "declarationMap": true,
+    "emitDeclarationOnly": false,
     "noUncheckedSideEffectImports": true,
     "libReplacement": false,
     "strictPropertyInitialization": false,
     "erasableSyntaxOnly": true,
     "experimentalDecorators": true,
     "noEmitOnError": false,
+    "allowJs": true,
     "noErrorTruncation": true,
     "resolveJsonModule": true,
     "sourceMap": true,