@travetto/compiler 7.0.0 → 7.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "type": "module",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
@@ -32,10 +32,10 @@
   "dependencies": {
     "@parcel/watcher": "^2.5.1",
     "@travetto/manifest": "^7.0.0",
-    "@travetto/transformer": "^7.0.0"
+    "@travetto/transformer": "^7.0.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.0.0"
+    "@travetto/cli": "^7.0.1"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/event.ts

@@ -1,7 +1,7 @@
-import type { CompilerEvent, CompilerEventType } from '../support/types.ts';
+import type { CompilerEventPayload, CompilerEventType } from '../support/types.ts';
 
 export class EventUtil {
-  static sendEvent<K extends CompilerEventType, T extends CompilerEvent & { type: K }>(type: K, payload: T['payload']): void {
+  static sendEvent<K extends CompilerEventType, T extends CompilerEventPayload<K>>(type: K, payload: T): void {
     process.connected && process.send!({ type, payload }, undefined, undefined, () => { });
   }
 }

package/src/watch.ts

@@ -9,6 +9,7 @@ import { CompilerUtil } from './util.ts';
 
 import { AsyncQueue } from '../support/queue.ts';
 import { IpcLogger } from '../support/log.ts';
+import { EventUtil } from './event.ts';
 
 const log = new IpcLogger({ level: 'debug' });
 
@@ -56,7 +57,7 @@ export class CompilerWatcher {
     return [...ignores].toSorted().map(ignore => ignore.endsWith('/') ? ignore : `${ignore}/`);
   }
 
-  #toCandidateEvent(action: CompilerWatchEvent['action'], file: string): CompilerWatchEventCandidate {
+  #toCandidateEvent({ action, file }: Pick<CompilerWatchEvent, 'action' | 'file'>): CompilerWatchEventCandidate {
     let entry = this.#state.getBySource(file);
     const mod = entry?.module ?? this.#state.manifestIndex.findModuleForArbitraryFile(file);
     if (mod && action === 'create' && !entry) {
@@ -69,19 +70,25 @@ export class CompilerWatcher {
     return { entry, file: entry?.sourceFile ?? file, action };
   }
 
-  #isValidEvent(event: CompilerWatchEventCandidate): event is CompilerWatchEvent {
-    const relativeFile = event.file.replace(`${this.#root}/`, '');
+  #isValidFile(file: string): boolean {
+    const relativeFile = file.replace(`${this.#root}/`, '');
     if (relativeFile === this.#watchCanary) {
       return false;
     } else if (relativeFile.startsWith('.')) {
       return false;
-    } else if (!event.entry) {
-      log.debug(`Skipping unknown file ${relativeFile}`);
+    }
+    return true;
+  }
+
+  #isValidEvent(event: CompilerWatchEventCandidate): event is CompilerWatchEvent {
+    if (!event.entry) {
+      log.debug(`Skipping unknown file ${event.file}`);
       return false;
     } else if (event.action === 'update' && !this.#state.checkIfSourceChanged(event.entry.sourceFile)) {
+      const relativeFile = event.file.replace(`${this.#root}/`, '');
       log.debug(`Skipping update, as contents unchanged ${relativeFile}`);
       return false;
-    } else if (!CompilerUtil.validFile(ManifestModuleUtil.getFileType(relativeFile))) {
+    } else if (!CompilerUtil.validFile(ManifestModuleUtil.getFileType(event.file))) {
       return false;
     }
     return true;
@@ -168,10 +175,20 @@ export class CompilerWatcher {
           throw new CompilerReset('Package information changed');
         }
 
-        const items = events
-          .map(event => this.#toCandidateEvent(event.type, path.toPosix(event.path)))
+        // One event per file set
+        const filesChanged = events.map(e => ({ file: path.toPosix(e.path), action: e.type })).filter(e => this.#isValidFile(e.file));
+        if (filesChanged.length) {
+          EventUtil.sendEvent('file', { time: Date.now(), files: filesChanged });
+        }
+
+        const items = filesChanged
+          .map(event => this.#toCandidateEvent(event))
           .filter(event => this.#isValidEvent(event));
 
+        if (items.length === 0) {
+          return;
+        }
+
         try {
           await this.#reconcileManifestUpdates(items);
         } catch (manifestError) {

package/support/entry.main.ts

@@ -3,7 +3,7 @@ import fs from 'node:fs/promises';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerMode, CompilerServerInfo } from './types.ts';
+import { isComplilerEventType, type CompilerMode, type CompilerServerInfo } from './types.ts';
 import { Log } from './log.ts';
 import { CompilerSetup } from './setup.ts';
 import { CompilerServer } from './server/server.ts';
@@ -72,9 +72,8 @@ export const main = (ctx: ManifestContext) => {
 
     /** Stream events */
     events: async (type: string, handler: (event: unknown) => unknown): Promise<void> => {
-      if (type === 'change' || type === 'log' || type === 'progress' || type === 'state' || type === 'all') {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        for await (const event of client.fetchEvents(type as 'change')) { await handler(event); }
+      if (isComplilerEventType(type)) {
+        for await (const event of client.fetchEvents(type)) { await handler(event); }
       } else {
         throw new Error(`Unknown event type: ${type}`);
       }

package/support/server/client.ts

@@ -4,7 +4,7 @@ import http, { Agent } from 'node:http';
 
 import { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerEvent, CompilerEventType, CompilerServerInfo, CompilerStateType } from '../types.ts';
+import type { CompilerEventPayload, CompilerEventType, CompilerServerInfo, CompilerStateType } from '../types.ts';
 import type { LogShape } from '../log.ts';
 import { CommonUtil } from '../util.ts';
 import { ProcessHandle } from './process-handle.ts';
@@ -91,12 +91,7 @@ export class CompilerClient {
   }
 
   /** Fetch compiler events */
-  fetchEvents<
-    V extends CompilerEventType,
-    T extends (CompilerEvent & { type: V })['payload']
-  >(type: V, config?: FetchEventsConfig<T>): AsyncIterable<T>;
-  fetchEvents(type: 'all', config?: FetchEventsConfig<CompilerEvent>): AsyncIterable<CompilerEvent>;
-  async * fetchEvents<T = unknown>(type: string, config: FetchEventsConfig<T> = {}): AsyncIterable<T> {
+  async * fetchEvents<V extends CompilerEventType, T extends CompilerEventPayload<V>>(type: V, config: FetchEventsConfig<T> = {}): AsyncIterable<T> {
     let info = await this.info();
     if (!info) {
       return;

package/support/server/server.ts

@@ -4,7 +4,10 @@ import { setMaxListeners } from 'node:events';
 
 import type { ManifestContext } from '@travetto/manifest';
 
-import type { CompilerMode, CompilerProgressEvent, CompilerEvent, CompilerEventType, CompilerServerInfo } from '../types.ts';
+import {
+  type CompilerMode, type CompilerProgressEvent, type CompilerEvent,
+  type CompilerEventType, type CompilerServerInfo, isComplilerEventType
+} from '../types.ts';
 import { Log } from '../log.ts';
 import { CommonUtil } from '../util.ts';
 import { CompilerClient } from './client.ts';
@@ -20,7 +23,7 @@ export class CompilerServer {
   #ctx: ManifestContext;
   #server: http.Server;
   #listenersAll = new Set<http.ServerResponse>();
-  #listeners: Partial<Record<CompilerEventType | 'all', Record<string, http.ServerResponse>>> = {};
+  #listeners: Partial<Record<CompilerEventType, Record<string, http.ServerResponse>>> = {};
   #shutdown = new AbortController();
   info: CompilerServerInfo;
   #client: CompilerClient;
@@ -98,7 +101,7 @@ export class CompilerServer {
     return output;
   }
 
-  #addListener(type: CompilerEventType | 'all', response: http.ServerResponse): void {
+  #addListener(type: CompilerEventType, response: http.ServerResponse): void {
     response.writeHead(200);
     const id = `id_${Date.now()}_${Math.random()}`.replace('.', '1');
     (this.#listeners[type] ??= {})[id] = response;
@@ -109,7 +112,6 @@ export class CompilerServer {
       response.write('\n'); // Send at least one byte on listen
     }
 
-    // Do not wait on it
     response.on('close', () => {
       delete this.#listeners[type]?.[id];
       this.#listenersAll.delete(response);
@@ -168,11 +170,10 @@ export class CompilerServer {
     let close = false;
     switch (action) {
       case 'event': {
-        switch (subAction) {
-          case 'change': case 'log': case 'progress': case 'state': case 'all':
-            return this.#addListener(subAction, response);
-          default: return;
+        if (isComplilerEventType(subAction)) {
+          this.#addListener(subAction, response);
         }
+        return;
       }
       case 'clean': out = await this.#clean(); break;
       case 'stop': out = JSON.stringify({ closing: true }); close = true; break;

package/support/types.ts

@@ -8,14 +8,18 @@ export type CompilerLogLevel = 'info' | 'debug' | 'warn' | 'error';
 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: 'state', payload: CompilerStateEvent } |
+  { type: 'all', payload: unknown };
 
 export type CompilerEventType = CompilerEvent['type'];
+export type CompilerEventPayload<V> = (CompilerEvent & { type: V })['payload'];
 
 export type CompilerServerInfo = {
   path: string;
@@ -27,3 +31,7 @@ export type CompilerServerInfo = {
   url: string;
   env?: Record<string, string>;
 };
+
+const VALID_EVENT_TYPES = new Set<CompilerEventType>(['change', 'log', 'progress', 'state', 'all', 'file']);
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+export const isComplilerEventType = (value: string): value is CompilerEventType => VALID_EVENT_TYPES.has(value as CompilerEventType);

package/support/util.ts

@@ -38,12 +38,12 @@ export class CommonUtil {
       const kill = (): void => controller.abort();
       parent.addEventListener('abort', kill);
 
-      const comp = input(controller.signal);
+      const stream = input(controller.signal);
 
       log.debug('Started event stream');
 
       // Wait for all events, close at the end
-      for await (const event of comp) {
+      for await (const event of stream) {
         yield event;
         if (shouldRestart(event)) {
           log.debug('Restarting stream');