@travetto/compiler 5.0.4 → 5.0.5

package/bin/common.js

@@ -13,11 +13,14 @@ const modPath = (/** @type {Ctx} */ ctx, 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 (!existsSync(this.dest) || getAge(statSync(this.dest)) < getAge(statSync(this.src))) {
+    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');
@@ -38,17 +41,23 @@ 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
 
-  // Load manifest without compiling, just stripping types away
+  // 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');
-  const src = readFileSync(loc, 'utf8')
-    // Remove type information
-    .replace(/\s*[|]\s+undefined/g, '')
-    .replace(/<([^>]|\n)+>/gsm, '')
-    .replace(/[?]?: (string|[A-Z][a-zA-Z]+)/g, '')
-    .replace(/^(import )?type .*$/gm, '');
+
+  // 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
-  const { getManifestContext } = await import(`data:text/javascript;charset=utf-8,${encodeURIComponent(src)}`);
+  const { getManifestContext } = await import(manifestJs);
 
   /** @type {Ctx} */
   const ctx = getManifestContext();
@@ -75,6 +84,7 @@ async function getEntry() {
 
   // Load
   try {
+    /** @type {import('../support/entry.trvc')} */
     const res = await import(target('support/entry.trvc.ts').dest);
     return await res.main(ctx);
   } catch (err) {
@@ -83,4 +93,5 @@ async function getEntry() {
   }
 }
 
+// eslint-disable-next-line no-undef
 module.exports = { getEntry };

package/bin/manifest-context.mjs

@@ -0,0 +1,121 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+const TOOL_FOLDER = '.trv/tool';
+const COMPILER_FOLDER = '.trv/compiler';
+const OUTPUT_FOLDER = '.trv/output';
+const TYPES_FOLDER = '.trv/types';
+const WS_ROOT = {};
+function readPackage(dir) {
+    dir = dir.endsWith('.json') ? path.dirname(dir) : dir;
+    try {
+        const v = readFileSync(path.resolve(dir, 'package.json'), 'utf8');
+        return ({ ...JSON.parse(v), path: path.resolve(dir) });
+    }
+    catch { }
+}
+function findPackage(dir) {
+    let prev;
+    let pkg, curr = path.resolve(dir);
+    while (!pkg && curr !== prev) {
+        pkg = readPackage(curr);
+        [prev, curr] = [curr, path.dirname(curr)];
+    }
+    if (!pkg) {
+        throw new Error('Could not find a package.json');
+    }
+    else {
+        return pkg;
+    }
+}
+function resolveWorkspace(base = process.cwd()) {
+    if (base in WS_ROOT) {
+        return WS_ROOT[base];
+    }
+    let folder = base;
+    let prev;
+    let prevPkg, pkg;
+    while (prev !== folder) {
+        [prev, prevPkg] = [folder, pkg];
+        pkg = readPackage(folder) ?? pkg;
+        if ((pkg && (!!pkg.workspaces || !!pkg.travetto?.build?.isolated)) ||
+            existsSync(path.resolve(folder, '.git'))) {
+            break;
+        }
+        folder = path.dirname(folder);
+    }
+    if (!pkg) {
+        throw new Error('Could not find a package.json');
+    }
+    return WS_ROOT[base] = {
+        ...pkg,
+        name: pkg.name ?? 'untitled',
+        type: pkg.type,
+        manager: existsSync(path.resolve(pkg.path, 'yarn.lock')) ? 'yarn' : 'npm',
+        resolve: createRequire(`${pkg.path}/node_modules`).resolve.bind(null),
+        stripRoot: (full) => full === pkg.path ? '' : full.replace(`${pkg.path}/`, ''),
+        mono: !!pkg.workspaces || (!pkg.travetto?.build?.isolated && !!prevPkg)
+    };
+}
+function getCompilerUrl(ws) {
+    const port = (Math.abs([...ws.path].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
+    return `http://localhost:${port}`;
+}
+function resolveModule(workspace, folder) {
+    let mod;
+    if (!folder && process.env.TRV_MODULE) {
+        mod = process.env.TRV_MODULE;
+        if (/[.][cm]?(t|j)sx?$/.test(mod)) {
+            try {
+                process.env.TRV_MODULE = mod = findPackage(path.dirname(mod)).name;
+            }
+            catch {
+                process.env.TRV_MODULE = mod = '';
+            }
+        }
+    }
+    if (mod) {
+        try {
+            folder = path.dirname(workspace.resolve(`${mod}/package.json`));
+        }
+        catch {
+            const workspacePkg = readPackage(workspace.path);
+            if (workspacePkg?.name === mod) {
+                folder = workspace.path;
+            }
+            else {
+                throw new Error(`Unable to resolve location for ${folder}`);
+            }
+        }
+    }
+    return findPackage(folder ?? '.');
+}
+export function getManifestContext(folder) {
+    const workspace = resolveWorkspace();
+    const mod = resolveModule(workspace, folder);
+    const build = workspace.travetto?.build ?? {};
+    return {
+        workspace: {
+            name: workspace.name,
+            path: workspace.path,
+            mono: workspace.mono,
+            manager: workspace.manager,
+            type: workspace.type ?? 'commonjs',
+            defaultEnv: workspace.travetto?.defaultEnv ?? 'local'
+        },
+        build: {
+            compilerFolder: build.compilerFolder ?? COMPILER_FOLDER,
+            compilerUrl: build.compilerUrl ?? getCompilerUrl(workspace),
+            compilerModuleFolder: workspace.stripRoot(path.dirname(workspace.resolve('@travetto/compiler/package.json'))),
+            outputFolder: build.outputFolder ?? OUTPUT_FOLDER,
+            toolFolder: build.toolFolder ?? TOOL_FOLDER,
+            typesFolder: build.typesFolder ?? TYPES_FOLDER
+        },
+        main: {
+            name: mod.name ?? 'untitled',
+            folder: workspace.stripRoot(mod.path),
+            version: mod.version,
+            description: mod.description
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/compiler",
-  "version": "5.0.4",
+  "version": "5.0.5",
   "description": "The compiler infrastructure for the Travetto framework",
   "keywords": [
     "compiler",
@@ -33,12 +33,12 @@
   },
   "dependencies": {
     "@parcel/watcher": "^2.4.1",
-    "@travetto/manifest": "^5.0.3",
-    "@travetto/transformer": "^5.0.4",
+    "@travetto/manifest": "^5.0.4",
+    "@travetto/transformer": "^5.0.5",
     "@types/node": "^22.5.1"
   },
   "peerDependencies": {
-    "@travetto/cli": "^5.0.4"
+    "@travetto/cli": "^5.0.5"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/state.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 
-import { path, ManifestModuleUtil, type ManifestModule, type ManifestRoot, ManifestIndex } from '@travetto/manifest';
+import { path, ManifestModuleUtil, type ManifestModule, type ManifestRoot, ManifestIndex, ManifestModuleFolderType } from '@travetto/manifest';
 import { TransformerManager } from '@travetto/transformer';
 
 import { TypescriptUtil } from '../support/ts-util';
@@ -9,6 +9,9 @@ import { CompilerUtil } from './util';
 import { CompileEmitError, CompileStateEntry } from './types';
 import { CommonUtil } from '../support/util';
 
+const TYPINGS_FOLDER_KEYS = new Set<ManifestModuleFolderType>(['$index', 'support', 'src']);
+const TYPINGS_EXT_RE = /[.]d[.][cm]?ts([.]map)?$/;
+
 export class CompilerState implements ts.CompilerHost {
 
   static async get(idx: ManifestIndex): Promise<CompilerState> {
@@ -18,6 +21,7 @@ export class CompilerState implements ts.CompilerHost {
   private constructor() { }
 
   #outputPath: string;
+  #typingsPath: string;
   #sourceFiles = new Set<string>();
   #sourceDirectory = new Map<string, string>();
   #sourceToEntry = new Map<string, CompileStateEntry>();
@@ -39,11 +43,25 @@ export class CompilerState implements ts.CompilerHost {
     return ts.sys.readFile(this.#sourceToEntry.get(sourceFile)?.sourceFile ?? sourceFile);
   }
 
+  #writeExternalTypings(location: string, text: string, bom: boolean): void {
+    let core = location.replace('.map', '');
+    if (!this.#outputToEntry.has(core)) {
+      core = core.replace('.d.ts', '.js');
+    }
+    const entry = this.#outputToEntry.get(core);
+    if (entry) {
+      const relative = this.#manifestIndex.getFromSource(entry.sourceFile)?.relativeFile;
+      if (relative && TYPINGS_FOLDER_KEYS.has(ManifestModuleUtil.getFolderKey(relative))) {
+        ts.sys.writeFile(location.replace(this.#outputPath, this.#typingsPath), text, bom);
+      }
+    }
+  }
+
   async init(idx: ManifestIndex): Promise<this> {
     this.#manifestIndex = idx;
     this.#manifest = idx.manifest;
     this.#outputPath = path.resolve(this.#manifest.workspace.path, this.#manifest.build.outputFolder);
-
+    this.#typingsPath = path.resolve(this.#manifest.workspace.path, this.#manifest.build.typesFolder);
 
     this.#compilerOptions = {
       ...await TypescriptUtil.getCompilerOptions(this.#manifest),
@@ -241,7 +259,12 @@ export class CompilerState implements ts.CompilerHost {
     if (outputFile.endsWith('package.json')) {
       text = CompilerUtil.rewritePackageJSON(this.#manifest, text);
     }
-    const location = this.#tscOutputFileToOuptut.get(outputFile)! ?? outputFile;
+    const location = this.#tscOutputFileToOuptut.get(outputFile) ?? outputFile;
+
+    if (TYPINGS_EXT_RE.test(outputFile)) {
+      this.#writeExternalTypings(location, text, bom);
+    }
+
     ts.sys.writeFile(location, text, bom);
   }
 

package/support/entry.trvc.ts

@@ -15,7 +15,7 @@ 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'));
-  const buildFolders = [ctx.build.outputFolder, ctx.build.compilerFolder];
+  const buildFolders = [ctx.build.outputFolder, ctx.build.compilerFolder, ctx.build.typesFolder];
   Log.root = ctx.workspace.path;
   Log.initLevel('error');