@travetto/compiler 5.0.15 → 5.0.17

package/bin/entry.common.js

@@ -0,0 +1,81 @@
+// @ts-check
+/* eslint-disable no-undef */
+const { stat, readFile, writeFile, mkdir, rm, readdir } = require('node:fs/promises');
+const path = require('node:path');
+
+const COMP_MOD = '@travetto/compiler';
+
+async function writeIfStale(src = '', dest = '', transform = async (x = '') => x) {
+  const [srcStat, destStat] = await Promise.all([src, dest].map(x => stat(`${x}`).then(z => z.mtimeMs, () => 0)));
+
+  if (!destStat || destStat < srcStat) {
+    const text = src ? await readFile(src, 'utf8') : '';
+    await mkdir(path.dirname(dest), { recursive: true });
+    await writeFile(dest, await transform(text), 'utf8');
+  }
+}
+
+async function transpile(content = '', esm = true, full = true) {
+  const ts = (await import('typescript')).default;
+  return ts.transpile(content, {
+    target: ts.ScriptTarget.ES2022,
+    module: esm ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS,
+    ...(full ? { esModuleInterop: true, allowSyntheticDefaultImports: true } : {})
+  });
+}
+
+async function getContext() {
+  const ctxSrc = require.resolve('@travetto/manifest/src/context.ts');
+  const ctxDest = path.resolve(__dirname, 'gen.context.mjs');
+  await writeIfStale(ctxSrc, ctxDest, content => transpile(content, true, false));
+  const ctx = await import(ctxDest).then((/** @type {import('@travetto/manifest/src/context')} */ v) => v.getManifestContext());
+
+  const srcPath = path.resolve.bind(path, ctx.workspace.path, ctx.build.compilerModuleFolder);
+  const destPath = (file = '', mod = COMP_MOD) => {
+    const base = path.resolve(ctx.workspace.path, ctx.build.compilerFolder, mod, file);
+    return `${base}${file.includes('.') ? '' : file.includes('/') ? '.ts' : '/__index__.ts'}`.replace('.ts', '.js');
+  };
+
+  return {
+    packageType: ctx.workspace.type,
+    srcPath,
+    destPath,
+    tsconfig: path.resolve(ctx.workspace.path, 'tsconfig.json'),
+    cleanImports: (t = '') => t
+      .replace(/from '([.][^']+)'/g, (_, i) => `from '${i.replace(/[.]js$/, '')}.js'`)
+      .replace(/from '(@travetto\/[^/']+)([/][^']+)?'/g, (_, mod, modFile) => `from '${destPath(modFile, mod)}'`),
+    loadMain: () => import(destPath('support/entry.main.ts'))
+      .then((/** @type {import('../support/entry.main')} */ v) => v.main(ctx)),
+    supportFiles: () => readdir(srcPath('support'), { recursive: true, encoding: 'utf8' })
+      .then(v => v.filter(f => f.endsWith('.ts')).map(j => `support/${j}`))
+  };
+}
+
+/** @template T */
+async function load(/** @type {(ops: import('../support/entry.main').Operations) => T} */ cb) {
+  const ctx = await getContext();
+
+  try {
+    await writeIfStale('', ctx.tsconfig,
+      async () => JSON.stringify({ extends: `${COMP_MOD}/tsconfig.trv.json` }, null, 2));
+
+    await writeIfStale(ctx.srcPath('package.json'), ctx.destPath('package.json'),
+      async text => JSON.stringify({ ...JSON.parse(text || '{}'), type: ctx.packageType }, null, 2));
+
+    await Promise.all((await ctx.supportFiles()).map(f =>
+      writeIfStale(ctx.srcPath(f), ctx.destPath(f),
+        t => transpile(t, ctx.packageType === 'module').then(ctx.cleanImports))));
+
+    process.setSourceMapsEnabled(true); // Ensure source map during compilation/development
+    process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --enable-source-maps`; // Ensure it passes to children
+    const res = await ctx.loadMain();
+    // @ts-ignore
+    try { module.enableCompileCache(); } catch { }
+    return cb(res);
+  } catch (err) {
+    await rm(ctx.srcPath('.'), { recursive: true, force: true });
+    throw err;
+  }
+}
+
+module.exports = { load };

package/bin/{manifest-context.mjs → gen.context.mjs}

@@ -1,9 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
+// eslint-disable-next-line no-bitwise
 const toPort = (pth) => (Math.abs([...pth].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
 const toPosix = (pth) => pth.replaceAll('\\', '/');
 const readPackage = (file) => ({ ...JSON.parse(readFileSync(file, 'utf8')), path: toPosix(path.dirname(file)) });
+/** Find package */
 function findPackage(base, pred) {
     let folder = `${base}/.`;
     let prev;
@@ -13,14 +15,18 @@ function findPackage(base, pred) {
         folder = path.dirname(folder);
         const folderPkg = path.resolve(folder, 'package.json');
         pkg = existsSync(folderPkg) ? readPackage(folderPkg) : pkg;
-    } while (prev !== folder &&
-        !pred(pkg) &&
-        !existsSync(path.resolve(folder, '.git')));
+    } while (prev !== folder && // Not at root
+        !pred(pkg) && // Matches criteria
+        !existsSync(path.resolve(folder, '.git')) // Not at source root
+    );
     if (!pkg) {
         throw new Error('Could not find a package.json');
     }
     return pkg;
 }
+/**
+ * Gets build context
+ */
 export function getManifestContext(root = process.cwd()) {
     const workspace = findPackage(root, pkg => !!pkg?.workspaces || !!pkg?.travetto?.build?.isolated);
     const build = workspace.travetto?.build ?? {};

package/bin/trvc.js

@@ -1,45 +1,39 @@
 #!/usr/bin/env node
+const help = `
+npx trvc [command]
 
-// @ts-check
-const { getEntry } = require('./common.js');
+Available Commands:
+ * start|watch                - Run the compiler in watch mode
+ * stop                       - Stop the compiler if running
+ * restart                    - Restart the compiler in watch mode
+ * build                      - Ensure the project is built and upto date
+ * clean                      - Clean out the output and compiler caches
+ * info                       - Retrieve the compiler information, if running
+ * event <log|progress|state> - Watch events in realtime as newline delimited JSON
+ * exec <file> [...args]      - Allow for compiling and executing an entrypoint file
+ * manifest --prod [output]   - Generate the project manifest
+`;
 
-const help = () => [
-  'npx trvc [command]',
-  '',
-  'Available Commands:',
-  ' * start|watch                - Run the compiler in watch mode',
-  ' * stop                       - Stop the compiler if running',
-  ' * restart                    - Restart the compiler in watch mode',
-  ' * build                      - Ensure the project is built and upto date',
-  ' * clean                      - Clean out the output and compiler caches',
-  ' * info                       - Retrieve the compiler information, if running',
-  ' * event <log|progress|state> - Watch events in realtime as newline delimited JSON',
-  ' * exec <file> [...args]      - Allow for compiling and executing an entrypoint file',
-  ' * manifest --prod [output]   - Generate the project manifest',
-].join('\n');
+const toJson = (/** @type {number} */ depth) => v => process.stdout.write(`${JSON.stringify(v, undefined, depth)}\n`) ||
+  new Promise(r => process.stdout.once('drain', r));
 
-getEntry().then(async (ops) => {
+require('./entry.common.js').load(ops => {
   const [op, ...all] = process.argv.slice(2);
   const args = all.filter(x => !x.startsWith('-'));
-  const flags = all.filter(x => x.startsWith('-'));
 
   switch (op) {
     case undefined:
-    case 'help': return console.log(`\n${help()}\n`);
-    case 'restart': return ops.restart();
-    case 'stop': return ops.stop();
-    case 'info': return ops.info().then(v => console.log(JSON.stringify(v, null, 2)));
-    case 'event': return ops.events(args[0], v => {
-      if (!process.stdout.write(`${JSON.stringify(v)}\n`)) {
-        return new Promise(r => process.stdout.once('drain', r));
-      }
-    });
+    case 'help': return console.log(help);
+    case 'info': return ops.info().then(toJson(2));
+    case 'event': return ops.events(args[0], toJson(0));
+    case 'manifest': return ops.manifest(args[0], all.some(x => x === '--prod'));
+    case 'exec': return ops.exec(args[0], all.slice(1));
+    case 'build': return ops.build();
     case 'clean': return ops.clean();
-    case 'manifest': return ops.manifest(args[0], flags.some(x => x === '--prod'));
-    case 'exec': return ops.getLoader().then(v => v(args[0], all.slice(1)));
     case 'start':
     case 'watch': return ops.watch();
-    case 'build': return ops.build();
-    default: console.error(`Unknown trvc operation: ${op}\n`); return console.error(help());
+    case 'stop': return ops.stop();
+    case 'restart': return ops.restart();
+    default: console.error(`\nUnknown trvc operation: ${op}\n${help}`);
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "5.0.15",
+  "version": "5.0.17",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
@@ -28,17 +28,13 @@
     "url": "https://github.com/travetto/travetto.git",
     "directory": "module/compiler"
   },
-  "engines": {
-    "node": ">=22.0.0"
-  },
   "dependencies": {
-    "@parcel/watcher": "^2.4.1",
-    "@travetto/manifest": "^5.0.8",
-    "@travetto/transformer": "^5.0.9",
-    "@types/node": "^22.7.7"
+    "@parcel/watcher": "^2.5.0",
+    "@travetto/manifest": "^5.0.10",
+    "@travetto/transformer": "^5.0.11"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.12"
+    "@travetto/cli": "^5.0.17"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -103,7 +103,7 @@ export class Compiler {
 
     for (const file of files) {
       const err = await emitter(file);
-      const imp = file.replace(/.*node_modules\//, '');
+      const imp = file.includes('node_modules/') ? file.split('node_modules/')[1] : file;
       yield { file: imp, i: i += 1, err, total: files.length };
       if ((Date.now() - lastSent) > 50) { // Limit to 1 every 50ms
         lastSent = Date.now();

package/support/{entry.trvc.ts → entry.main.ts}

@@ -11,7 +11,6 @@ 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) => {
   const client = new CompilerClient(ctx, Log.scoped('client'));
@@ -91,21 +90,19 @@ export const main = (ctx: ManifestContext) => {
       await compile('watch');
     },
 
-    /** Build and return a loader */
-    async getLoader(): Promise<(mod: string, args?: string[]) => Promise<unknown>> {
+    /** Set arguments and import module */
+    async exec(mod: string, args?: string[]): Promise<unknown> {
       Log.initLevel('none');
       if (!(await client.isWatching())) { // Short circuit if we can
         Log.initLevel('error');
         await compile('build');
       }
 
-      return (mod, args) => {
-        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(CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', mod)); // Return function to run import on a module
-      };
+      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(CommonUtil.resolveWorkspace(ctx, ctx.build.outputFolder, 'node_modules', mod)); // Return function to run import on a module
     },
 
     /** Manifest entry point */
@@ -115,4 +112,6 @@ export const main = (ctx: ManifestContext) => {
     }
   };
   return ops;
-};
+};
+
+export type Operations = ReturnType<typeof main>;

package/bin/common.js

@@ -1,101 +0,0 @@
-// @ts-check
-const { statSync, readFileSync, writeFileSync, mkdirSync, readdirSync, existsSync, rmSync } = require('node:fs');
-const path = require('node:path');
-
-/** @typedef {import('@travetto/manifest').ManifestContext} Ctx */
-
-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 needsWriting = (/** @type {string} */ src, /** @type {string} */ dest) =>
-  !existsSync(dest) || getAge(statSync(dest)) < getAge(statSync(src));
-
-const getTarget = (/** @type {Ctx} */ ctx, file = '') => ({
-  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 (needsWriting(this.src, this.dest)) {
-      const text = readFileSync(this.src, 'utf8');
-      mkdirSync(path.dirname(this.dest), { recursive: true });
-      writeFileSync(this.dest, await transform(text), 'utf8');
-    }
-  }
-});
-
-const getTranspiler = async (/** @type {Ctx} */ ctx) => {
-  const ts = (await import('typescript')).default;
-  const module = ctx.workspace.type === 'module' ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
-  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, (_, mod, file) => `from '${modPath(ctx, mod, file)}'`);
-};
-
-async function getEntry() {
-  process.setSourceMapsEnabled(true); // Ensure source map during compilation/development
-  process.env.NODE_OPTIONS = `${process.env.NODE_OPTIONS ?? ''} --enable-source-maps`; // Ensure it passes to children
-
-  // eslint-disable-next-line no-undef
-  const manifestJs = path.resolve(__dirname, 'manifest-context.mjs');
-  const loc = require.resolve('@travetto/manifest').replace(/__index__.*/, 'src/context.ts');
-
-  // Compile if needed
-  if (needsWriting(loc, manifestJs)) {
-    const ts = (await import('typescript')).default;
-    const text = ts.transpile(readFileSync(loc, 'utf8'), {
-      target: ts.ScriptTarget.ES2022,
-      module: ts.ModuleKind.ESNext,
-      removeComments: true
-    }, manifestJs);
-    writeFileSync(manifestJs, text, 'utf8');
-  }
-
-  // Load module on demand
-  /** @type {import('@travetto/manifest/src/context')} */
-  const { getManifestContext } = await import(manifestJs);
-
-  /** @type {Ctx} */
-  const ctx = getManifestContext();
-  const target = getTarget.bind(null, ctx);
-
-  // Setup Tsconfig
-  const tsconfig = path.resolve(ctx.workspace.path, 'tsconfig.json');
-  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)
-  );
-
-  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)
-      );
-    }
-  }
-
-  // Load
-  try {
-    // @ts-ignore
-    try { await import('node:module').then(v => v.enableCompileCache()); } catch { }
-
-    /** @type {import('../support/entry.trvc')} */
-    const res = await import(target('support/entry.trvc.ts').dest);
-    return await res.main(ctx);
-  } catch (err) {
-    rmSync(target('.').dest, { recursive: true, force: true });
-    throw err;
-  }
-}
-
-// eslint-disable-next-line no-undef
-module.exports = { getEntry };