@travetto/compiler 4.1.2 → 5.0.0-rc.0

package/bin/common.js

@@ -10,8 +10,13 @@ const TS_EXT = /[.]tsx?$/;
 
 const getAge = (/** @type {{mtimeMs:number, ctimeMs:number}} */ st) => Math.max(st.mtimeMs, st.ctimeMs);
 
+const modPath = (/** @type {Ctx} */ ctx, mod, file) => {
+  const base = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules', mod, file);
+  return `${base}${file.includes('.') ? '' : file.includes('/') ? '.ts' : '/__index__.ts'}`.replace(TS_EXT, '.js');
+};
+
 const getTarget = (/** @type {Ctx} */ ctx, file = '') => ({
-  dest: path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules', '@travetto/compiler', file).replace(TS_EXT, '.js'),
+  dest: modPath(ctx, '@travetto/compiler', file),
   src: path.resolve(ctx.workspace.path, ctx.build.compilerModuleFolder, file),
   async writeIfStale(/** @type {(text:string)=>(string|Promise<string>)}*/ transform) {
     if (!existsSync(this.dest) || getAge(statSync(this.dest)) < getAge(statSync(this.src))) {
@@ -28,8 +33,7 @@ const getTranspiler = async (/** @type {Ctx} */ ctx) => {
   return (content = '') =>
     ts.transpile(content, { target: ts.ScriptTarget.ES2022, module, esModuleInterop: true, allowSyntheticDefaultImports: true })
       .replace(/from '([.][^']+)'/g, (_, i) => `from '${i.replace(/[.]js$/, '')}.js'`)
-      .replace(/from '(@travetto\/(.*?))'/g, (_, i, s) =>
-        `from '${path.resolve(ctx.workspace.path, ctx.build.compilerFolder, `${i}${s.includes('/') ? '.js' : '/__index__.js'}`)}'`);
+      .replace(/from '(@travetto\/[^/']+)([/][^']+)?'/g, (_, mod, file) => `from '${modPath(ctx, mod, file)}'`);
 };
 
 /** @returns {Promise<import('@travetto/compiler/support/entry.trvc')>} */
@@ -44,14 +48,21 @@ export async function getEntry() {
 
   // Setup Tsconfig
   const tsconfig = path.resolve(ctx.workspace.path, 'tsconfig.json');
-  existsSync(tsconfig) || writeFileSync(tsconfig, JSON.stringify({ extends: '@travetto/compiler/tsconfig.trv.json' }), 'utf8');
+  existsSync(tsconfig) || writeFileSync(tsconfig,
+    JSON.stringify({ extends: '@travetto/compiler/tsconfig.trv.json' }), 'utf8');
 
   // Compile support folder
-  await target('package.json').writeIfStale(text => JSON.stringify(Object.assign(JSON.parse(text), { type: ctx.workspace.type }), null, 2));
+  await target('package.json').writeIfStale(text =>
+    JSON.stringify(Object.assign(JSON.parse(text), { type: ctx.workspace.type }), null, 2)
+  );
 
   let transpile;
   for (const file of readdirSync(target('support').src, { recursive: true, encoding: 'utf8' })) {
-    if (TS_EXT.test(file)) { await target(`support/${file}`).writeIfStale(async (text) => (transpile ??= await getTranspiler(ctx))(text)); }
+    if (TS_EXT.test(file)) {
+      await target(`support/${file}`).writeIfStale(async (text) =>
+        (transpile ??= await getTranspiler(ctx))(text)
+      );
+    }
   }
 
   // Load

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "4.1.2",
+  "version": "5.0.0-rc.0",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
@@ -31,12 +31,12 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.4.1",
-    "@travetto/manifest": "^4.1.0",
-    "@travetto/transformer": "^4.1.2",
-    "@types/node": "^20.14.8"
+    "@travetto/manifest": "^5.0.0-rc.0",
+    "@travetto/transformer": "^5.0.0-rc.0",
+    "@types/node": "^20.14.10"
   },
   "peerDependencies": {
-    "@travetto/cli": "^4.1.2"
+    "@travetto/cli": "^5.0.0-rc.0"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/event.ts

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

package/src/util.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { ManifestContext, ManifestModuleFileType, ManifestModuleUtil, ManifestRoot, Package, path } from '@travetto/manifest';
+import { path, ManifestContext, ManifestModuleFileType, ManifestModuleUtil, ManifestRoot, Package } from '@travetto/manifest';
 
 type OutputToSource = (outputFile: string) => ({ sourceFile: string } | undefined);
 

package/src/watch.ts

@@ -19,7 +19,6 @@ type FileShape = {
   action: WatchAction;
 };
 
-
 /**
  * Watch support, based on compiler state and manifest details
  */
@@ -44,7 +43,7 @@ export class CompilerWatcher {
       ignores = ['node_modules/**'];
     }
 
-    // Disable exclusions until parcel watcher fixes itself
+    // TODO: Fix once node/parcel sort this out
     return os.platform() === 'linux' ? [] : [
       ...ignores,
       '.git', '**/.git',

package/support/entry.trvc.ts

@@ -1,6 +1,5 @@
 // @trv-no-transform
 import fs from 'node:fs/promises';
-import path from 'node:path';
 
 import type { ManifestContext } from '@travetto/manifest';
 
@@ -10,6 +9,8 @@ import { CompilerSetup } from './setup';
 import { CompilerServer } from './server/server';
 import { CompilerRunner } from './server/runner';
 import { CompilerClient } from './server/client';
+import { CommonUtil } from './util';
+
 
 // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 export const main = (ctx: ManifestContext) => {
@@ -63,7 +64,7 @@ export const main = (ctx: ManifestContext) => {
       if (await client.clean()) {
         return console.log(`Clean triggered ${ctx.workspace.path}:`, buildFolders);
       } else {
-        await Promise.all(buildFolders.map(f => fs.rm(path.resolve(ctx.workspace.path, f), { force: true, recursive: true })));
+        await Promise.all(buildFolders.map(f => fs.rm(CommonUtil.resolveWorkspace(ctx, f), { force: true, recursive: true })));
         return console.log(`Cleaned ${ctx.workspace.path}:`, buildFolders);
       }
     },
@@ -72,6 +73,8 @@ export const main = (ctx: ManifestContext) => {
     events: async (type: string, handler: (ev: unknown) => unknown): Promise<void> => {
       if (type === 'change' || type === 'log' || type === 'progress' || type === 'state') {
         for await (const ev of client.fetchEvents(type)) { await handler(ev); }
+      } else if (type === 'all') {
+        for await (const ev of client.fetchEvents(type)) { await handler(ev); }
       } else {
         throw new Error(`Unknown event type: ${type}`);
       }
@@ -98,12 +101,11 @@ export const main = (ctx: ManifestContext) => {
       }
 
       return (mod, args) => {
-        const outputRoot = path.resolve(ctx.workspace.path, ctx.build.outputFolder);
-        process.env.TRV_MANIFEST = path.resolve(outputRoot, 'node_modules', ctx.main.name); // Setup for running
+        process.env.TRV_MANIFEST = CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', ctx.main.name); // Setup for running
         if (args) {
           process.argv = [process.argv0, mod, ...args];
         }
-        return import(path.join(outputRoot, 'node_modules', mod)); // Return function to run import on a module
+        return import(CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', mod)); // Return function to run import on a module
       };
     },
 

package/support/server/client.ts

@@ -93,10 +93,13 @@ export class CompilerClient {
   }
 
   /** Fetch compiler events */
-  async * fetchEvents<
+  /** Fetch compiler events */
+  fetchEvents<
     V extends CompilerEventType,
     T extends (CompilerEvent & { type: V })['payload']
-  >(type: V, cfg: FetchEventsConfig<T> = {}): AsyncIterable<T> {
+  >(type: V, cfg?: FetchEventsConfig<T>): AsyncIterable<T>;
+  fetchEvents(type: 'all', cfg?: FetchEventsConfig<CompilerEvent>): AsyncIterable<CompilerEvent>;
+  async * fetchEvents<T = unknown>(type: string, cfg: FetchEventsConfig<T> = {}): AsyncIterable<T> {
     let info = await this.info();
     if (!info) {
       return;

package/support/server/process-handle.ts

@@ -11,7 +11,7 @@ export class ProcessHandle {
   #log: Logger;
 
   constructor(ctx: ManifestContext, name: string) {
-    this.#file = path.resolve(ctx.workspace.path, ctx.build.toolFolder, `${name}.pid`);
+    this.#file = CommonUtil.resolveWorkspace(ctx, ctx.build.toolFolder, `${name}.pid`);
     this.#log = Log.scoped(`process-handle.${name}`);
   }
 
@@ -51,8 +51,12 @@ export class ProcessHandle {
   async ensureKilled(gracePeriod: number = 3000): Promise<boolean> {
     const start = Date.now();
     const pid = await this.getPid();
+    if (!pid) {
+      return false;
+    }
+
     this.#log.debug('Ensuring Killed', pid);
-    while (pid && (Date.now() - start) < gracePeriod) { // Ensure its done
+    while ((Date.now() - start) < gracePeriod) { // Ensure its done
       if (!await this.isRunning()) {
         return true;
       }
@@ -60,9 +64,9 @@ export class ProcessHandle {
     }
     try {
       this.#log.debug('Force Killing', pid);
-      pid && process.kill(pid); // Force kill
+      process.kill(pid); // Force kill
     } catch { }
     this.#log.debug('Did Kill', this.#file, !!pid);
-    return pid !== undefined;
+    return true;
   }
 }

package/support/server/runner.ts

@@ -1,5 +1,4 @@
 import cp from 'node:child_process';
-import path from 'node:path';
 import { rmSync } from 'node:fs';
 
 import type { ManifestContext, DeltaEvent } from '@travetto/manifest';
@@ -35,8 +34,8 @@ export class CompilerRunner {
       log.debug(`Started watch=${watch} changed=${changed.slice(0, 10).map(x => `${x.module}/${x.file}`)}`);
     }
 
-    const main = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules', '@travetto/compiler/support/entry.compiler.js');
-    const deltaFile = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, `manifest-delta-${Date.now()}.json`);
+    const main = CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, 'node_modules', '@travetto/compiler/support/entry.compiler.js');
+    const deltaFile = CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, `manifest-delta-${Date.now()}.json`);
 
     const changedFiles = changed[0]?.file === '*' ? ['*'] : changed.map(ev => ev.sourceFile);
 
@@ -49,7 +48,7 @@ export class CompilerRunner {
       const proc = cp.spawn(process.argv0, [main, deltaFile, `${watch}`], {
         env: {
           ...process.env,
-          TRV_MANIFEST: path.resolve(ctx.workspace.path, 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'],

package/support/server/server.ts

@@ -1,6 +1,5 @@
 import http from 'node:http';
 import fs from 'node:fs/promises';
-import path from 'node:path';
 import { setMaxListeners } from 'node:events';
 
 import type { ManifestContext } from '@travetto/manifest';
@@ -20,7 +19,8 @@ export class CompilerServer {
 
   #ctx: ManifestContext;
   #server: http.Server;
-  #listeners: Record<string, { res: http.ServerResponse, type: CompilerEventType }> = {};
+  #listenersAll = new Set<http.ServerResponse>();
+  #listeners: Partial<Record<CompilerEventType | 'all', Record<string, http.ServerResponse>>> = {};
   #shutdown = new AbortController();
   signal = this.#shutdown.signal;
   info: CompilerServerInfo;
@@ -95,25 +95,43 @@ export class CompilerServer {
     return output;
   }
 
-  async #addListener(type: string, res: http.ServerResponse): Promise<void> {
+  #addListener(type: CompilerEventType | 'all', res: http.ServerResponse): void {
     res.writeHead(200);
     const id = `id_${Date.now()}_${Math.random()}`.replace('.', '1');
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    this.#listeners[id] = { res, type: type as 'change' };
-    if (type === 'state') { // Send on initial connect
-      res.write(JSON.stringify({ state: this.info.state }));
+    (this.#listeners[type] ??= {})[id] = res;
+    this.#listenersAll.add(res);
+    if (type === 'state' || type === 'all') { // Send on initial connect
+      this.#emitEvent({ type: 'state', payload: { state: this.info.state } }, id);
+    } else {
+      res.write('\n'); // Send at least one byte on listen
     }
-    res.write('\n'); // Send at least one byte on listen
 
     // Do not wait on it
-    res.on('close', () => { delete this.#listeners[id]; });
+    res.on('close', () => {
+      delete this.#listeners[type]?.[id];
+      this.#listenersAll.delete(res);
+    });
   }
 
-  #emitEvent(ev: CompilerEvent): void {
-    const msg = `${JSON.stringify(ev.payload)}\n`;
-    for (const el of Object.values(this.#listeners)) {
-      if (!el.res.closed && el.type === ev.type) {
-        el.res.write(msg);
+  #emitEvent(ev: CompilerEvent, to?: string): void {
+    if (this.#listeners.all) {
+      const msg = JSON.stringify(ev);
+      for (const [id, item] of Object.entries(this.#listeners.all)) {
+        if (item.closed || (to && id !== to)) {
+          continue;
+        }
+        item.write(msg);
+        item.write('\n');
+      }
+    }
+    if (this.#listeners[ev.type]) {
+      const msg = JSON.stringify(ev.payload);
+      for (const [id, item] of Object.entries(this.#listeners[ev.type]!)) {
+        if (item.closed || (to && id !== to)) {
+          continue;
+        }
+        item.write(msg);
+        item.write('\n');
       }
     }
   }
@@ -122,15 +140,16 @@ export class CompilerServer {
     log.info('Server disconnect requested');
     this.info.iteration = Date.now();
     await CommonUtil.blockingTimeout(20);
-    for (const el of Object.values(this.#listeners)) {
-      try { el.res.end(); } catch { }
+    for (const el of this.#listenersAll) {
+      try { el.end(); } catch { }
     }
     this.#listeners = {}; // Ensure its empty
+    this.#listenersAll.clear();
   }
 
   async #clean(): Promise<{ clean: boolean }> {
     await Promise.all([this.#ctx.build.compilerFolder, this.#ctx.build.outputFolder]
-      .map(f => fs.rm(path.resolve(this.#ctx.workspace.path, f), { recursive: true, force: true })));
+      .map(f => fs.rm(CommonUtil.resolveWorkspace(this.#ctx, f), { recursive: true, force: true })));
     return { clean: true };
   }
 
@@ -145,7 +164,8 @@ export class CompilerServer {
     let out: unknown;
     let close = false;
     switch (action) {
-      case 'event': return await this.#addListener(subAction, res);
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      case 'event': return this.#addListener(subAction as 'change', res);
       case 'clean': out = await this.#clean(); break;
       case 'stop': out = JSON.stringify({ closing: true }); close = true; break;
       case 'info':

package/support/setup.ts

@@ -1,6 +1,6 @@
-import path from 'node:path';
 import { createRequire } from 'node:module';
 import fs from 'node:fs/promises';
+import path from 'node:path';
 
 import { type DeltaEvent, type ManifestContext, type Package } from '@travetto/manifest';
 
@@ -27,7 +27,7 @@ export class CompilerSetup {
     Pick<typeof import('@travetto/manifest'), 'ManifestDeltaUtil' | 'ManifestUtil'>
   > => {
     const all = ['util', 'delta'].map(f =>
-      import(path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules', `@travetto/manifest/src/${f}.js`))
+      import(CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, 'node_modules', `@travetto/manifest/src/${f}.js`))
     );
     return Promise.all(all).then(props => Object.assign({}, ...props));
   };
@@ -50,11 +50,11 @@ export class CompilerSetup {
   static async #transpileFile(ctx: ManifestContext, inputFile: string, outputFile: string): Promise<void> {
     const type = CommonUtil.getFileType(inputFile);
     if (type === 'js' || type === 'ts') {
-      const compilerOut = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules');
+      const compilerOut = CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, 'node_modules');
 
       const text = (await fs.readFile(inputFile, 'utf8'))
         .replace(/from '([.][^']+)'/g, (_, i) => `from '${i.replace(/[.]js$/, '')}.js'`)
-        .replace(/from '(@travetto\/(.*?))'/g, (_, i, s) => `from '${path.resolve(compilerOut, `${i}${s.includes('/') ? '.js' : '/__index__.js'}`)}'`);
+        .replace(/from '(@travetto\/(.*?))'/g, (_, i, s) => `from '${compilerOut}/${i}${s.includes('/') ? '.js' : '/__index__.js'}'`);
 
       const ts = (await import('typescript')).default;
       const content = ts.transpile(text, {
@@ -92,7 +92,7 @@ export class CompilerSetup {
         if (file.startsWith('.')) {
           continue;
         }
-        const resolvedInput = path.resolve(sub, file);
+        const resolvedInput = path.resolve(sub, file).replaceAll('\\', '/'); // To posix
         const stat = await fs.stat(resolvedInput);
 
         if (stat.isDirectory()) {
@@ -105,14 +105,14 @@ export class CompilerSetup {
       }
     }
 
-    const outputFolder = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, 'node_modules', module);
+    const outputFolder = CommonUtil.resolveWorkspace(ctx, ctx.build.compilerFolder, 'node_modules', module);
     const out: ModFile[] = [];
     for (const input of files) {
       const output = this.#sourceToOutputExt(input.replace(inputFolder, outputFolder));
       const inputTs = await fs.stat(input).then(RECENT_STAT, () => 0);
       if (inputTs) {
         const outputTs = await fs.stat(output).then(RECENT_STAT, () => 0);
-        await fs.mkdir(path.dirname(output), { recursive: true, });
+        await fs.mkdir(path.dirname(output), { recursive: true });
         out.push({ input, output, stale: inputTs > outputTs });
       }
     }
@@ -202,7 +202,7 @@ export class CompilerSetup {
 
     if (changes) {
       await Log.wrap('reset', async log => {
-        await fs.rm(path.resolve(ctx.workspace.path, ctx.build.outputFolder), { recursive: true, force: true });
+        await fs.rm(CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder), { recursive: true, force: true });
         log.info('Clearing output due to compiler changes');
       }, false);
     }

package/support/ts-util.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
-import path from 'node:path';
 
-import { ManifestContext } from '@travetto/manifest';
+import { type ManifestContext } from '@travetto/manifest';
+import { CommonUtil } from './util';
 
 const OPT_CACHE: Record<string, import('typescript').CompilerOptions> = {};
 
@@ -11,10 +11,10 @@ export class TypescriptUtil {
      */
   static async getCompilerOptions(ctx: ManifestContext): Promise<{}> {
     if (!(ctx.workspace.path in OPT_CACHE)) {
-      let tsconfig = path.resolve(ctx.workspace.path, 'tsconfig.json');
+      let tsconfig = CommonUtil.resolveWorkspace(ctx, 'tsconfig.json');
 
       if (!await fs.stat(tsconfig).then(_ => true, _ => false)) {
-        tsconfig = path.resolve(ctx.workspace.path, ctx.build.compilerModuleFolder, 'tsconfig.trv.json');
+        tsconfig = CommonUtil.resolveWorkspace(ctx, ctx.build.compilerModuleFolder, 'tsconfig.trv.json');
       }
 
       const ts = (await import('typescript')).default;
@@ -29,7 +29,7 @@ export class TypescriptUtil {
         resolveJsonModule: true,
         sourceRoot: ctx.workspace.path,
         rootDir: ctx.workspace.path,
-        outDir: path.resolve(ctx.workspace.path),
+        outDir: CommonUtil.resolveWorkspace(ctx),
         module: ctx.workspace.type === 'commonjs' ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext,
       };
     }

package/support/util.ts

@@ -1,10 +1,15 @@
 import fs from 'node:fs/promises';
-import path from 'node:path';
 import { setMaxListeners } from 'node:events';
 import timers from 'node:timers/promises';
+import posix from 'node:path/posix';
+import native from 'node:path';
+
+import { type ManifestContext } from '@travetto/manifest';
 
 import { Log } from './log';
 
+const toPosix = (file: string): string => file.replaceAll('\\', '/');
+
 export class CommonUtil {
   /**
    * Determine file type
@@ -19,7 +24,7 @@ export class CommonUtil {
    * Write text file, and ensure folder exists
    */
   static writeTextFile = (file: string, content: string): Promise<void> =>
-    fs.mkdir(path.dirname(file), { recursive: true }).then(() => fs.writeFile(file, content, 'utf8'));
+    fs.mkdir(native.dirname(file), { recursive: true }).then(() => fs.writeFile(file, content, 'utf8'));
 
   /**
    * Restartable Event Stream
@@ -92,4 +97,12 @@ export class CommonUtil {
   static queueMacroTask(): Promise<void> {
     return timers.setImmediate(undefined);
   }
+
+  /**
+   * Resolve path for workspace, ensuring posix compliant slashes
+   */
+  static resolveWorkspace(ctx: ManifestContext, ...args: string[]): string {
+    const all = [process.cwd(), ctx.workspace.path, ...args].map(toPosix);
+    return process.platform === 'win32' ? toPosix(native.resolve(...all)) : posix.resolve(...all);
+  }
 }

package/tsconfig.trv.json

@@ -4,7 +4,7 @@
     "target": "esnext",
     "moduleResolution": "Bundler",
     "lib": [
-      "es2022"
+      "ES2023"
     ],
     "jsx": "react-jsx",
     "strict": true,