@travetto/manifest 3.4.0 → 4.0.0-rc.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 ArcSine Technologies
+Copyright (c) 2023 ArcSine Technologies
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -30,12 +30,12 @@ During the compilation process, the compiler needs to know every file that is el
 Additionally, once the code has been compiled (or even bundled after that), the executing process needs to know what files are available for loading, and any patterns necessary for knowing which files to load versus which ones to ignore. This allows for dynamic loading of modules/files without knowledge/access to the file system, and in a more performant manner.
 
 ## Manifest Delta
-During the compilation process, it is helpful to know how the output content differs from the manifest, which is produced from the source input. The [ManifestDeltaUtil](https://github.com/travetto/travetto/tree/main/module/manifest/src/delta.ts#L20) provides the functionality for a given manifest, and will produce a stream of changes grouped by module.  This is the primary input into the [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework")'s incremental behavior to know when a file has changed and needs to be recompiled.
+During the compilation process, it is helpful to know how the output content differs from the manifest, which is produced from the source input. The [ManifestDeltaUtil](https://github.com/travetto/travetto/tree/main/module/manifest/src/delta.ts#L21) provides the functionality for a given manifest, and will produce a stream of changes grouped by module.  This is the primary input into the [Compiler](https://github.com/travetto/travetto/tree/main/module/compiler#readme "The compiler infrastructure for the Travetto framework")'s incremental behavior to know when a file has changed and needs to be recompiled.
 
 ## Class and Function Metadata
 For the framework to work properly, metadata needs to be collected about files, classes and functions to uniquely identify them, with support for detecting changes during live reloads.  To achieve this, every `class` is decorated with an additional field of `Ⲑid`.  `Ⲑid` represents a computed id that is tied to the file/class combination. 
 
-`Ⲑid` is used heavily throughout the framework for determining which classes are owned by the framework, and being able to lookup the needed data from the [RootIndex](https://github.com/travetto/travetto/tree/main/module/manifest/src/root-index.ts#L11) using the `getFunctionMetadata` method.
+`Ⲑid` is used heavily throughout the framework for determining which classes are owned by the framework, and being able to lookup the needed data from the [RuntimeIndex](https://github.com/travetto/travetto/tree/main/module/manifest/src/runtime.ts#L14) using the `getFunctionMetadata` method.
 
 **Code: Test Class**
 ```typescript
@@ -50,10 +50,10 @@ export class TestClass {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestClass = void 0;
 const tslib_1 = require("tslib");
-const Ⲑ_root_index_1 = tslib_1.__importStar(require("@travetto/manifest/src/root-index.js"));
+const Ⲑ_runtime_1 = tslib_1.__importStar(require("@travetto/manifest/src/runtime.js"));
 var ᚕf = "@travetto/manifest/doc/test-class.js";
 class TestClass {
-    static Ⲑinit = Ⲑ_root_index_1.RootIndex.registerFunction(TestClass, ᚕf, 197152026, { doStuff: { hash: 51337554 } }, false, false);
+    static Ⲑinit = Ⲑ_runtime_1.RuntimeIndex.registerFunction(TestClass, ᚕf, 197152026, { doStuff: { hash: 51337554 } }, false, false);
     async doStuff() { }
 }
 exports.TestClass = TestClass;
@@ -92,31 +92,39 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
 ```typescript
 {
   "generated": 1868155200000,
-  "workspacePath": "<generated>",
-  "monoRepo": true,
-  "packageManager": "npm",
-  "moduleType": "commonjs",
-  "outputFolder": ".trv/output",
-  "toolFolder": ".trv/tool",
-  "compilerFolder": ".trv/compiler",
-  "compilerUrl": "http://127.0.0.1:26803",
-  "frameworkVersion": "x.x.x",
-  "mainModule": "@travetto/manifest",
-  "mainFolder": "module/manifest",
-  "version": "x.x.x",
-  "description": "Support for project indexing, manifesting, along with file watching",
+  "workspace": {
+    "name": "@travetto/mono-repo",
+    "path": "<generated>",
+    "mono": true,
+    "manager": "npm",
+    "type": "commonjs",
+    "defaultEnv": "local"
+  },
+  "build": {
+    "compilerFolder": ".trv/compiler",
+    "compilerUrl": "http://127.0.0.1:26803",
+    "compilerModuleFolder": "module/compiler",
+    "outputFolder": ".trv/output",
+    "toolFolder": ".trv/tool"
+  },
+  "main": {
+    "name": "@travetto/manifest",
+    "folder": "module/manifest",
+    "version": "x.x.x",
+    "description": "Support for project indexing, manifesting, along with file watching"
+  },
   "modules": {
     "@travetto/manifest": {
       "main": true,
+      "prod": true,
       "name": "@travetto/manifest",
       "version": "x.x.x",
-      "local": true,
+      "workspace": true,
       "internal": false,
       "sourceFolder": "module/manifest",
       "outputFolder": "node_modules/@travetto/manifest",
       "roles": [ "std" ],
       "parents": [],
-      "prod": true,
       "files": {
         "$root": [
           [ "DOC.html", "unknown", 1868155200000 ],
@@ -136,7 +144,7 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
         ],
         "test": [
           [ "test/path.ts", "ts", 1868155200000, "test" ],
-          [ "test/root-index.ts", "ts", 1868155200000, "test" ]
+          [ "test/runtime.ts", "ts", 1868155200000, "test" ]
         ],
         "test/fixtures": [
           [ "test/fixtures/simple.ts", "fixture", 1868155200000, "test" ]
@@ -148,14 +156,17 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
           [ "src/delta.ts", "ts", 1868155200000 ],
           [ "src/dependencies.ts", "ts", 1868155200000 ],
           [ "src/file.ts", "ts", 1868155200000 ],
+          [ "src/global.d.ts", "typings", 1868155200000 ],
           [ "src/manifest-index.ts", "ts", 1868155200000 ],
           [ "src/module.ts", "ts", 1868155200000 ],
           [ "src/package.ts", "ts", 1868155200000 ],
           [ "src/path.ts", "ts", 1868155200000 ],
-          [ "src/root-index.ts", "ts", 1868155200000 ],
-          [ "src/types.ts", "ts", 1868155200000 ],
-          [ "src/typings.d.ts", "typings", 1868155200000 ],
-          [ "src/util.ts", "ts", 1868155200000 ]
+          [ "src/runtime.ts", "ts", 1868155200000 ],
+          [ "src/util.ts", "ts", 1868155200000 ],
+          [ "src/types/common.ts", "ts", 1868155200000 ],
+          [ "src/types/context.ts", "ts", 1868155200000 ],
+          [ "src/types/manifest.ts", "ts", 1868155200000 ],
+          [ "src/types/package.ts", "ts", 1868155200000 ]
         ],
         "bin": [
           [ "bin/context.d.ts", "typings", 1868155200000 ],

package/__index__.ts

@@ -1,11 +1,14 @@
-/// <reference path="./src/typings.d.ts" />
+/// <reference path="./src/global.d.ts" />
 
 export * from './src/path';
 export * from './src/module';
 export * from './src/delta';
 export * from './src/manifest-index';
-export * from './src/root-index';
+export * from './src/runtime';
 export * from './src/package';
 export * from './src/util';
 export * from './src/file';
-export * from './src/types';
+export * from './src/types/context';
+export * from './src/types/package';
+export * from './src/types/manifest';
+export * from './src/types/common';

package/bin/context.d.ts

@@ -4,7 +4,7 @@ declare namespace ManifestBootstrap {
   /**
    * Get Context for building
    */
-  function getManifestContext(folder?: string): Promise<ManifestContext>;
+  function getManifestContext(folder?: string): ManifestContext;
 }
 
 export = ManifestBootstrap;

package/bin/context.js

@@ -1,13 +1,13 @@
 // @ts-check
 
 /**
- * @typedef {import('../src/types').Package & { path:string }} Pkg
+ * @typedef {import('../src/types/package').Package & { path:string }} Pkg
  * @typedef {Pkg & { mono: boolean, manager: 'yarn'|'npm', resolve: (file:string) => string}} Workspace
- * @typedef {import('../src/types').ManifestContext} ManifestContext
+ * @typedef {import('../src/types/context').ManifestContext} ManifestContext
  */
-import fs from 'fs/promises';
-import path from 'path';
-import { createRequire } from 'module';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
 
 /** @type {Record<string, Workspace>} */ const WS_ROOT = {};
 const TOOL_FOLDER = '.trv/tool';
@@ -17,24 +17,26 @@ const OUTPUT_FOLDER = '.trv/output';
 /**
  * Read package.json or return undefined if missing
  * @param {string} dir
- * @returns {Promise<Pkg|undefined>}
+ * @returns {Pkg|undefined}
  */
-async function $readPackage(dir) {
+function $readPackage(dir) {
   dir = dir.endsWith('.json') ? path.dirname(dir) : dir;
-  return await fs.readFile(path.resolve(dir, 'package.json'), 'utf8')
-    .then(v => ({ ...JSON.parse(v), path: path.resolve(dir) }), () => undefined);
+  try {
+    const v = readFileSync(path.resolve(dir, 'package.json'), 'utf8');
+    return ({ ...JSON.parse(v), path: path.resolve(dir) });
+  } catch { }
 }
 
 /**
  * Find package.json for a given folder
  * @param {string} dir
- * @return {Promise<Pkg>}
+ * @return {Pkg}
  */
-async function $findPackage(dir) {
+function $findPackage(dir) {
   let prev;
   let pkg, curr = path.resolve(dir);
   while (!pkg && curr !== prev) {
-    pkg = await $readPackage(curr);
+    pkg = $readPackage(curr);
     [prev, curr] = [curr, path.dirname(curr)];
   }
   if (!pkg) {
@@ -46,9 +48,9 @@ async function $findPackage(dir) {
 
 /**
  * Get workspace root
- * @return {Promise<Workspace>}
+ * @return {Workspace}
  */
-async function $resolveWorkspace(base = process.cwd()) {
+function $resolveWorkspace(base = process.cwd()) {
   if (base in WS_ROOT) { return WS_ROOT[base]; }
   let folder = base;
   let prev;
@@ -57,10 +59,10 @@ async function $resolveWorkspace(base = process.cwd()) {
 
   while (prev !== folder) {
     [prev, prevPkg] = [folder, pkg];
-    pkg = await $readPackage(folder) ?? pkg;
+    pkg = $readPackage(folder) ?? pkg;
     if (
-      (pkg && (!!pkg.workspaces || !!pkg.travetto?.isolated)) || // if we have a monorepo root, or we are isolated
-      await fs.stat(path.resolve(folder, '.git')).catch(() => { }) // we made it to the source repo root
+      (pkg && (!!pkg.workspaces || !!pkg.travetto?.build?.isolated)) || // if we have a monorepo root, or we are isolated
+      existsSync(path.resolve(folder, '.git')) // we made it to the source repo root
     ) {
       break;
     }
@@ -73,29 +75,29 @@ async function $resolveWorkspace(base = process.cwd()) {
 
   return WS_ROOT[base] = {
     ...pkg,
-    manager: await fs.stat(path.resolve(pkg.path, 'yarn.lock')).catch(() => { }) ? 'yarn' : 'npm',
+    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),
-    mono: !!pkg.workspaces || (!pkg.travetto?.isolated && !!prevPkg)  // Workspaces or nested projects
+    mono: !!pkg.workspaces || (!pkg.travetto?.build?.isolated && !!prevPkg)  // Workspaces or nested projects
   };
 }
 
 /**
  * Get Compiler url
  * @param {Workspace} ws
+ * @param {string} toolFolder
  */
-async function $getCompilerUrl(ws) {
-  let out = ws.travetto?.compilerUrl;
-  if (!out) {
-    const file = path.resolve(ws.path, ws.travetto?.toolFolder ?? TOOL_FOLDER, 'compiler.url');
-    // eslint-disable-next-line no-bitwise
-    const port = (Math.abs([...file].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
-    out = `http://localhost:${port}`;
-    try { await fs.stat(file); } catch {
-      await fs.mkdir(path.dirname(file), { recursive: true });
-      await fs.writeFile(file, out, 'utf8');
-    }
+function $getCompilerUrl(ws, toolFolder) {
+  const file = path.resolve(ws.path, toolFolder, 'build.compilerUrl');
+  // eslint-disable-next-line no-bitwise
+  const port = (Math.abs([...file].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
+  const out = `http://localhost:${port}`;
+  if (!existsSync(file)) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, out, 'utf8');
   }
-  return out.replace('localhost', '127.0.0.1');
+  return out;
 }
 
 /**
@@ -103,13 +105,16 @@ async function $getCompilerUrl(ws) {
  * @param {Workspace} workspace
  * @param {string|undefined} folder
  */
-async function $resolveModule(workspace, folder) {
+function $resolveModule(workspace, folder) {
   let mod;
   if (!folder && process.env.TRV_MODULE) {
     mod = process.env.TRV_MODULE;
-    if (/[.](t|j)s$/.test(mod)) { // Rewrite from file to module
-      process.env.TRV_MODULE = mod = await $findPackage(path.dirname(mod))
-        .then(v => v.name, () => '');
+    if (/[.](t|j)sx?$/.test(mod)) { // Rewrite from file to module
+      try {
+        process.env.TRV_MODULE = mod = $findPackage(path.dirname(mod)).name;
+      } catch {
+        process.env.TRV_MODULE = mod = '';
+      }
     }
   }
 
@@ -117,7 +122,7 @@ async function $resolveModule(workspace, folder) {
     try {
       folder = path.dirname(workspace.resolve(`${mod}/package.json`));
     } catch {
-      const workspacePkg = await $readPackage(workspace.path);
+      const workspacePkg = $readPackage(workspace.path);
       if (workspacePkg?.name === mod) {
         folder = workspace.path;
       } else {
@@ -132,30 +137,35 @@ async function $resolveModule(workspace, folder) {
 /**
  * Gets build context
  * @param {string} [folder]
- * @return {Promise<ManifestContext>}
+ * @return {ManifestContext}
  */
-export async function getManifestContext(folder) {
-  const workspace = await $resolveWorkspace(folder);
-
-  const [mod, framework, compilerUrl] = await Promise.all([
-    $resolveModule(workspace, folder),
-    $readPackage(workspace.resolve('@travetto/manifest/package.json')),
-    $getCompilerUrl(workspace),
-  ]);
+export function getManifestContext(folder) {
+  const workspace = $resolveWorkspace(folder);
+  const mod = $resolveModule(workspace, folder);
+  const build = workspace.travetto?.build ?? {};
+  const toolFolder = build.toolFolder ?? TOOL_FOLDER;
 
   return {
-    workspacePath: workspace.path,
-    monoRepo: workspace.mono,
-    packageManager: workspace.manager,
-    moduleType: workspace.type ?? 'commonjs',
-    outputFolder: workspace.travetto?.outputFolder ?? OUTPUT_FOLDER,
-    toolFolder: workspace.travetto?.toolFolder ?? TOOL_FOLDER,
-    compilerFolder: workspace.travetto?.compilerFolder ?? COMPILER_FOLDER,
-    compilerUrl,
-    frameworkVersion: framework?.version ?? '1.0.0',
-    mainModule: mod.name ?? 'untitled',
-    mainFolder: mod.path === workspace.path ? '' : mod.path.replace(`${workspace.path}/`, ''),
-    version: mod.version,
-    description: mod.description
+    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, toolFolder),
+      compilerModuleFolder: path.dirname(workspace.resolve('@travetto/compiler/package.json')).replace(`${workspace.path}/`, ''),
+      outputFolder: build.outputFolder ?? OUTPUT_FOLDER,
+      toolFolder
+    },
+    main: {
+      name: mod.name ?? 'untitled',
+      folder: mod.path === workspace.path ? '' : mod.path.replace(`${workspace.path}/`, ''),
+      version: mod.version,
+      description: mod.description
+    }
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "3.4.0",
+  "version": "4.0.0-rc.1",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
     "path",
@@ -32,7 +32,9 @@
   },
   "travetto": {
     "displayName": "Manifest",
-    "docBaseUrl": "https://github.com/travetto/travetto/tree/main"
+    "doc": {
+      "baseUrl": "https://github.com/travetto/travetto/tree/main"
+    }
   },
   "publishConfig": {
     "access": "public"

package/src/delta.ts

@@ -1,18 +1,19 @@
-import {
-  ManifestContext, ManifestModule, ManifestModuleCore, ManifestModuleFile,
-  ManifestModuleFileType, ManifestModuleFolderType, ManifestRoot
-} from './types';
+import fs from 'node:fs/promises';
 
 import { ManifestModuleUtil } from './module';
-import { ManifestFileUtil } from './file';
 import { path } from './path';
 
+import type { ManifestModule, ManifestModuleCore, ManifestModuleFile, ManifestRoot } from './types/manifest';
+import type { ManifestModuleFileType, ManifestModuleFolderType } from './types/common';
+import type { ManifestContext } from './types/context';
+
 type DeltaEventType = 'added' | 'changed' | 'removed' | 'missing' | 'dirty';
 type DeltaModule = ManifestModuleCore & { files: Record<string, ManifestModuleFile> };
-export type DeltaEvent = { file: string, type: DeltaEventType, module: string };
+export type DeltaEvent = { file: string, type: DeltaEventType, module: string, sourceFile: string };
 
 const VALID_SOURCE_FOLDERS = new Set<ManifestModuleFolderType>(['bin', 'src', 'test', 'support', '$index', '$package', 'doc']);
-const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
+const VALID_OUTPUT_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
+const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>([...VALID_OUTPUT_TYPE, 'typings']);
 
 /**
  * Produce delta for the manifest
@@ -30,14 +31,14 @@ export class ManifestDeltaUtil {
     const out: DeltaEvent[] = [];
 
     const add = (file: string, type: DeltaEvent['type']): unknown =>
-      out.push({ file, module: left.name, type });
+      out.push({ file, module: left.name, type, sourceFile: path.resolve(ctx.workspace.path, left.sourceFolder, file) });
 
-    const root = `${ctx.workspacePath}/${ctx.outputFolder}/${left.outputFolder}`;
+    const root = path.resolve(ctx.workspace.path, ctx.build.outputFolder, left.outputFolder);
     const right = new Set(
       (await ManifestModuleUtil.scanFolder(root, left.main))
         .filter(x => {
           const type = ManifestModuleUtil.getFileType(x);
-          return type === 'ts' || type === 'typings' || type === 'js' || type === 'package-json';
+          return VALID_SOURCE_TYPE.has(type);
         })
         .map(x => ManifestModuleUtil.sourceToBlankExt(x.replace(`${root}/`, '')))
     );
@@ -45,7 +46,7 @@ export class ManifestDeltaUtil {
     for (const el of Object.keys(left.files)) {
       const output = ManifestModuleUtil.sourceToOutputExt(`${outputFolder}/${left.outputFolder}/${el}`);
       const [, , leftTs] = left.files[el];
-      const stat = await ManifestFileUtil.statFile(output);
+      const stat = await fs.stat(output).catch(() => undefined);
       right.delete(ManifestModuleUtil.sourceToBlankExt(el));
 
       if (!stat) {
@@ -77,7 +78,7 @@ export class ManifestDeltaUtil {
         continue;
       }
       for (const [name, type, date] of m.files?.[key] ?? []) {
-        if (VALID_SOURCE_TYPE.has(type)) {
+        if (VALID_OUTPUT_TYPE.has(type)) {
           out[name] = [name, type, date];
         }
       }
@@ -88,14 +89,14 @@ export class ManifestDeltaUtil {
   /**
    * Produce delta between manifest root and the output folder
    */
-  static async produceDelta(ctx: ManifestContext, manifest: ManifestRoot): Promise<DeltaEvent[]> {
+  static async produceDelta(manifest: ManifestRoot): Promise<DeltaEvent[]> {
     const deltaLeft = Object.fromEntries(
       Object.values(manifest.modules)
         .map(m => [m.name, { ...m, files: this.#flattenModuleFiles(m) }])
     );
 
     const out: DeltaEvent[] = [];
-    const outputFolder = path.resolve(ctx.workspacePath, ctx.outputFolder);
+    const outputFolder = path.resolve(manifest.workspace.path, manifest.build.outputFolder);
 
     for (const lMod of Object.values(deltaLeft)) {
       out.push(...await this.#deltaModules(manifest, outputFolder, lMod));