@travetto/compiler 4.0.8 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "4.0.8",
+  "version": "4.1.0",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
@@ -31,12 +31,12 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.4.1",
-    "@travetto/manifest": "^4.0.2",
-    "@travetto/transformer": "^4.0.3",
-    "@types/node": "^20.11.25"
+    "@travetto/manifest": "^4.1.0",
+    "@travetto/transformer": "^4.1.0",
+    "@types/node": "^20.12.12"
   },
   "peerDependencies": {
-    "@travetto/cli": "^4.0.6"
+    "@travetto/cli": "^4.1.0"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -67,6 +67,7 @@ export class Compiler {
       case 'error': {
         process.exitCode = 1;
         if (err) {
+          EventUtil.sendEvent('log', { level: 'error', message: err.toString(), time: Date.now() });
           log.error('Shutting down due to failure', err.message);
         }
         break;
@@ -127,7 +128,7 @@ export class Compiler {
     EventUtil.sendEvent('state', { state: 'init', extra: { pid: process.pid } });
 
     const emitter = await this.getCompiler();
-    let failed = false;
+    let failure: Error | undefined;
 
     log.debug('Compiler loaded');
 
@@ -136,17 +137,16 @@ export class Compiler {
     if (this.#dirtyFiles.length) {
       for await (const ev of this.emit(this.#dirtyFiles, emitter)) {
         if (ev.err) {
-          failed = true;
           const compileError = CompilerUtil.buildTranspileError(ev.file, ev.err);
+          failure ??= compileError;
           EventUtil.sendEvent('log', { level: 'error', message: compileError.toString(), time: Date.now() });
         }
       }
       if (this.#signal.aborted) {
         log.debug('Compilation aborted');
-      } else if (failed) {
+      } else if (failure) {
         log.debug('Compilation failed');
-        process.exitCode = 1;
-        return;
+        return this.#shutdown('error', failure);
       } else {
         log.debug('Compilation succeeded');
       }

package/src/state.ts

@@ -1,5 +1,4 @@
 import ts from 'typescript';
-import timers from 'node:timers/promises';
 
 import { path, ManifestModuleUtil, ManifestModule, ManifestRoot, ManifestIndex } from '@travetto/manifest';
 import { TransformerManager } from '@travetto/transformer';
@@ -8,6 +7,7 @@ import { TypescriptUtil } from '../support/ts-util';
 
 import { CompilerUtil } from './util';
 import { CompileEmitError, CompileStateEntry } from './types';
+import { CommonUtil } from '../support/util';
 
 function folderMapper(root: string, prefix: string): { dir: string, translate: (val: string) => string } {
   let matched: string = '~~';
@@ -63,14 +63,15 @@ export class CompilerState implements ts.CompilerHost {
 
     // Register all inputs
     for (const x of this.#modules) {
+      const base = x?.files ?? {};
       const files = [
-        ...x.files.bin ?? [],
-        ...x.files.src ?? [],
-        ...x.files.support ?? [],
-        ...x.files.doc ?? [],
-        ...x.files.test ?? [],
-        ...x.files.$index ?? [],
-        ...x.files.$package ?? []
+        ...base.bin ?? [],
+        ...base.src ?? [],
+        ...base.support ?? [],
+        ...base.doc ?? [],
+        ...base.test ?? [],
+        ...base.$index ?? [],
+        ...base.$package ?? []
       ];
       for (const [file, type] of files) {
         if (CompilerUtil.validFile(type) || type === 'typings') {
@@ -103,14 +104,18 @@ export class CompilerState implements ts.CompilerHost {
   }
 
   getArbitraryInputFile(): string {
-    return this.getBySource(this.#manifestIndex.getModule('@travetto/manifest')!.files.src[0].sourceFile)!.inputFile;
+    const randomSource = this.#manifestIndex.getWorkspaceModules()
+      .filter(x => x.files.src?.length)[0]
+      .files.src[0].sourceFile;
+
+    return this.getBySource(randomSource)!.inputFile;
   }
 
   async createProgram(force = false): Promise<ts.Program> {
     if (force || !this.#program) {
       this.#program = ts.createProgram({ rootNames: this.getAllFiles(), host: this, options: this.#compilerOptions, oldProgram: this.#program });
       this.#transformerManager.init(this.#program.getTypeChecker());
-      await timers.setImmediate();
+      await CommonUtil.queueMacroTask();
     }
     return this.#program;
   }
@@ -179,7 +184,7 @@ export class CompilerState implements ts.CompilerHost {
     if (!contents || (contents.length === 0 && prevHash)) {
       return false; // Ignore empty file
     }
-    const currentHash = CompilerUtil.naiveHash(contents);
+    const currentHash = CommonUtil.naiveHash(contents);
     const changed = prevHash !== currentHash;
     if (changed) {
       this.#sourceHashes.set(inputFile, currentHash);

package/src/util.ts

@@ -105,7 +105,6 @@ export class CompilerUtil {
     }
 
     const errors: string[] = diagnostics.slice(0, 5).map(diag => {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const message = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
       if (diag.file) {
         const { line, character } = diag.file.getLineAndCharacterOfPosition(diag.start!);
@@ -120,18 +119,4 @@ export class CompilerUtil {
     }
     return new Error(`Transpiling ${filename.replace(nativeCwd, '.')} failed: \n${errors.join('\n')}`);
   }
-
-  /**
-   * Naive hashing
-   */
-  static naiveHash(text: string): number {
-    let hash = 5381;
-
-    for (let i = 0; i < text.length; i++) {
-      // eslint-disable-next-line no-bitwise
-      hash = (hash * 33) ^ text.charCodeAt(i);
-    }
-
-    return Math.abs(hash);
-  }
 }

package/src/watch.ts

@@ -1,4 +1,4 @@
-import { ManifestContext, ManifestModuleUtil, ManifestUtil, PackageUtil, RuntimeIndex, path } from '@travetto/manifest';
+import { ManifestModuleFileType, ManifestModuleFolderType, ManifestModuleUtil, ManifestUtil, PackageUtil, RuntimeIndex, path } from '@travetto/manifest';
 
 import type { CompileStateEntry } from './types';
 import { CompilerState } from './state';
@@ -9,6 +9,14 @@ import { AsyncQueue } from '../support/queue';
 type WatchAction = 'create' | 'update' | 'delete';
 type WatchEvent = { action: WatchAction, file: string };
 type CompilerWatchEvent = WatchEvent & { entry: CompileStateEntry };
+type FileShape = {
+  mod: string;
+  folderKey: ManifestModuleFolderType;
+  fileType: ManifestModuleFileType;
+  moduleFile: string;
+  action: WatchAction;
+};
+
 
 /**
  * Watch support, based on compiler state and manifest details
@@ -22,6 +30,10 @@ export class CompilerWatcher {
     this.#signal = signal;
   }
 
+  #reset(ev: WatchEvent): never {
+    throw new Error('RESET', { cause: `${ev.action}:${ev.file}` });
+  }
+
   #getIgnores(): string[] {
     // TODO: Read .gitignore?
     let ignores = PackageUtil.readPackage(this.#state.manifest.workspace.path)?.travetto?.build?.watchIgnores;
@@ -40,8 +52,8 @@ export class CompilerWatcher {
   }
 
   /** Watch files */
-  async * #watchFolder(rootPath: string): AsyncIterable<WatchEvent> {
-    const q = new AsyncQueue<WatchEvent>(this.#signal);
+  async * #watchFolder(rootPath: string): AsyncIterable<WatchEvent[]> {
+    const q = new AsyncQueue<WatchEvent[]>(this.#signal);
     const lib = await import('@parcel/watcher');
     const ignore = this.#getIgnores();
 
@@ -51,9 +63,7 @@ export class CompilerWatcher {
         q.throw(err instanceof Error ? err : new Error((err as Error).message));
         return;
       }
-      for (const ev of events) {
-        q.add({ action: ev.type, file: path.toPosix(ev.path) });
-      }
+      q.add(events.map(ev => ({ action: ev.type, file: path.toPosix(ev.path) })));
     }, { ignore });
 
     if (this.#signal.aborted) { // If already aborted, can happen async
@@ -66,30 +76,53 @@ export class CompilerWatcher {
     yield* q;
   }
 
-  async #rebuildManifestsIfNeeded(event: CompilerWatchEvent, moduleFile: string): Promise<void> {
-    if (!event.entry.outputFile || event.action === 'update') {
+  async #rebuildManifestsIfNeeded(events: CompilerWatchEvent[]): Promise<void> {
+    events = events.filter(x => x.entry.outputFile && x.action !== 'update');
+
+    if (!events.length) {
       return;
     }
 
-    const toUpdate: ManifestContext[] = RuntimeIndex.getDependentModules(event.entry.module.name, 'parents')
-      .map(el => ManifestUtil.getModuleContext(this.#state.manifest, el.sourceFolder));
-
-    toUpdate.push(this.#state.manifest);
-
-    const mod = event.entry.module;
-    const folderKey = ManifestModuleUtil.getFolderKey(moduleFile);
-    const fileType = ManifestModuleUtil.getFileType(moduleFile);
+    const mods = [...new Set(events.map(v => v.entry.module.name))];
+
+    const moduleToFiles = new Map(mods.map(m => [m, {
+      context: ManifestUtil.getModuleContext(this.#state.manifest, RuntimeIndex.getManifestModule(m)!.sourceFolder),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      files: [] as FileShape[]
+    }] as const));
+
+    const parents = new Map<string, string[]>(
+      mods.map(m => [m, RuntimeIndex.getDependentModules(m, 'parents').map(x => x.name)])
+    );
+
+    const allFiles = events.map(ev => {
+      const modRoot = ev.entry.module.sourceFolder || this.#state.manifest.workspace.path;
+      const moduleFile = ev.file.includes(modRoot) ? ev.file.split(`${modRoot}/`)[1] : ev.file;
+      const folderKey = ManifestModuleUtil.getFolderKey(moduleFile);
+      const fileType = ManifestModuleUtil.getFileType(moduleFile);
+      return { mod: ev.entry.module.name, action: ev.action, moduleFile, folderKey, fileType };
+    });
+
+    for (const file of allFiles) {
+      for (const parent of parents.get(file.mod)!) {
+        const mod = moduleToFiles.get(parent);
+        if (!mod || !mod.files) {
+          this.#reset({ action: file.action, file: file.moduleFile });
+        }
+        mod.files.push(file);
+      }
+    }
 
-    for (const ctx of toUpdate) {
-      const newManifest = await ManifestUtil.buildManifest(ctx);
-      if (mod.name in newManifest.modules) {
-        const modFiles = newManifest.modules[mod.name].files[folderKey] ??= [];
+    for (const { context, files } of moduleToFiles.values()) {
+      const newManifest = await ManifestUtil.buildManifest(context);
+      for (const { action, mod, fileType, moduleFile, folderKey } of files) {
+        const modFiles = newManifest.modules[mod].files[folderKey] ??= [];
         const idx = modFiles.findIndex(x => x[0] === moduleFile);
 
-        if (event.action === 'create' && idx < 0) {
+        if (action === 'create' && idx < 0) {
           modFiles.push([moduleFile, fileType, Date.now()]);
         } else if (idx >= 0) {
-          if (event.action === 'delete') {
+          if (action === 'delete') {
             modFiles.splice(idx, 1);
           } else {
             modFiles[idx] = [moduleFile, fileType, Date.now()];
@@ -120,45 +153,51 @@ export class CompilerWatcher {
     const OUTPUT_PATH = path.resolve(manifest.workspace.path, manifest.build.outputFolder);
     const COMPILER_PATH = path.resolve(manifest.workspace.path, manifest.build.compilerFolder);
 
-    for await (const ev of this.#watchFolder(this.#state.manifest.workspace.path)) {
-      const { action, file: sourceFile } = ev;
+    for await (const events of this.#watchFolder(this.#state.manifest.workspace.path)) {
 
-      if (
-        sourceFile === ROOT_LOCK ||
-        sourceFile === ROOT_PKG ||
-        (action === 'delete' && (sourceFile === OUTPUT_PATH || sourceFile === COMPILER_PATH))
-      ) {
-        throw new Error('RESET', { cause: `${action}:${sourceFile}` });
-      }
+      const outEvents: CompilerWatchEvent[] = [];
 
-      const fileType = ManifestModuleUtil.getFileType(sourceFile);
-      if (!CompilerUtil.validFile(fileType)) {
-        continue;
-      }
+      for (const ev of events) {
+        const { action, file: sourceFile } = ev;
+
+        if (
+          sourceFile === ROOT_LOCK ||
+          sourceFile === ROOT_PKG ||
+          (action === 'delete' && (sourceFile === OUTPUT_PATH || sourceFile === COMPILER_PATH))
+        ) {
+          this.#reset(ev);
+        }
+
+        const fileType = ManifestModuleUtil.getFileType(sourceFile);
+        if (!CompilerUtil.validFile(fileType)) {
+          continue;
+        }
 
-      let entry = this.#state.getBySource(sourceFile);
+        let entry = this.#state.getBySource(sourceFile);
 
-      const mod = entry?.module ?? this.#state.manifestIndex.findModuleForArbitraryFile(sourceFile);
-      if (!mod) { // Unknown module
-        continue;
-      }
+        const mod = entry?.module ?? this.#state.manifestIndex.findModuleForArbitraryFile(sourceFile);
+        if (!mod) { // Unknown module
+          continue;
+        }
+
+        const modRoot = mod.sourceFolder || this.#state.manifest.workspace.path;
+        const moduleFile = sourceFile.includes(modRoot) ? sourceFile.split(`${modRoot}/`)[1] : sourceFile;
+
+        if (action === 'create') {
+          entry = this.#state.registerInput(mod, moduleFile);
+        } else if (!entry) {
+          continue;
+        } else if (action === 'update' && !this.#state.checkIfSourceChanged(entry.inputFile)) {
+          continue;
+        } else if (action === 'delete') {
+          this.#state.removeInput(entry.inputFile);
+        }
 
-      const modRoot = mod.sourceFolder || this.#state.manifest.workspace.path;
-      const moduleFile = sourceFile.includes(modRoot) ? sourceFile.split(`${modRoot}/`)[1] : sourceFile;
-
-      if (action === 'create') {
-        entry = this.#state.registerInput(mod, moduleFile);
-      } else if (!entry) {
-        continue;
-      } else if (action === 'update' && !this.#state.checkIfSourceChanged(entry.inputFile)) {
-        continue;
-      } else if (action === 'delete') {
-        this.#state.removeInput(entry.inputFile);
+        outEvents.push({ action, file: entry.sourceFile, entry });
       }
 
-      const result: CompilerWatchEvent = { action, file: entry.sourceFile, entry };
-      await this.#rebuildManifestsIfNeeded(result, moduleFile);
-      yield result;
+      await this.#rebuildManifestsIfNeeded(outEvents);
+      yield* outEvents;
     }
   }
 }

package/support/server/server.ts

@@ -207,7 +207,7 @@ export class CompilerServer {
         CommonUtil.nonBlockingTimeout(2000).then(reject); // Wait 2s max
         this.#server.close(resolve);
         this.#emitEvent({ type: 'state', payload: { state: 'closed' } });
-        setImmediate(() => {
+        CommonUtil.queueMacroTask().then(() => {
           this.#server.closeAllConnections();
           this.#shutdown.abort();
         });

package/support/util.ts

@@ -58,6 +58,20 @@ export class CommonUtil {
     }
   }
 
+  /**
+   * Naive hashing
+   */
+  static naiveHash(text: string): number {
+    let hash = 5381;
+
+    for (let i = 0; i < text.length; i++) {
+      // eslint-disable-next-line no-bitwise
+      hash = (hash * 33) ^ text.charCodeAt(i);
+    }
+
+    return Math.abs(hash);
+  }
+
   /**
    * Non-blocking timeout
    */