@travetto/manifest 5.0.0-rc.1 → 5.0.0-rc.2

package/README.md

@@ -35,7 +35,7 @@ During the compilation process, it is helpful to know how the output content dif
 ## 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 [RuntimeIndex](https://github.com/travetto/travetto/tree/main/module/manifest/src/runtime.ts#L12) 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 associated data by the id.
 
 **Code: Test Class**
 ```typescript
@@ -50,11 +50,11 @@ export class TestClass {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestClass = void 0;
 const tslib_1 = require("tslib");
-const Ⲑ_runtime_1 = tslib_1.__importStar(require("@travetto/manifest/src/runtime.js"));
 const Ⲑ_decorator_1 = tslib_1.__importStar(require("@travetto/registry/src/decorator.js"));
-var ᚕf = "@travetto/manifest/doc/test-class.js";
+const Ⲑ_function_1 = tslib_1.__importStar(require("@travetto/runtime/src/function.js"));
+var ᚕm = ["@travetto/manifest", "doc/test-class"];
 let TestClass = class TestClass {
-    static Ⲑinit = Ⲑ_runtime_1.RuntimeIndex.registerFunction(TestClass, ᚕf, { hash: 197152026, lines: [1, 3] }, { doStuff: { hash: 51337554, lines: [2, 2] } }, false, false);
+    static Ⲑinit = Ⲑ_function_1.register(TestClass, ᚕm, { hash: 197152026, lines: [1, 3] }, { doStuff: { hash: 51337554, lines: [2, 2] } }, false, false);
     async doStuff() { }
 };
 exports.TestClass = TestClass;
@@ -63,21 +63,6 @@ exports.TestClass = TestClass = tslib_1.__decorate([
 ], TestClass);
 ```
 
-**Terminal: Index Lookup at Runtime**
-```bash
-$ trv main ./doc/lookup.ts
-
-{
-  id: '@travetto/manifest:doc/test-class￮TestClass',
-  source: './doc/test-class.ts',
-  hash: 197152026,
-  lines: [ 1, 3 ],
-  methods: { doStuff: { hash: 51337554, lines: [ 2, 2 ] } },
-  abstract: false,
-  synthetic: false
-}
-```
-
 ## Module Indexing
 Once the manifest is created, the application runtime can now read this manifest, which allows for influencing runtime behavior. The most common patterns include:
    *  Loading all source files
@@ -91,8 +76,6 @@ Once the manifest is created, the application runtime can now read this manifest
 ## Path Normalization
 By default, all paths within the framework are assumed to be in a POSIX style, and all input paths are converted to the POSIX style.  This works appropriately within a Unix and a Windows environment.  This module offers up [path](https://github.com/travetto/travetto/tree/main/module/manifest/src/path.ts#L9) as an equivalent to [Node](https://nodejs.org)'s [http](https://nodejs.org/api/path.html) library.  This allows for consistent behavior across all file-interactions.
 
-Imports pointing at $`node:path` and $`path` are rewritten at compile time to point to the implementation provided by the module.  This allows for seamless import/usage patterns with the reliability needed for cross platform support.
-
 ## Anatomy of a Manifest
 
 **Code: Manifest for @travetto/manifest**
@@ -140,7 +123,6 @@ Imports pointing at $`node:path` and $`path` are rewritten at compile time to po
         ],
         "doc": [
           [ "DOC.tsx", "ts", 1868155200000, "doc" ],
-          [ "doc/lookup.ts", "ts", 1868155200000, "doc" ],
           [ "doc/test-class.ts", "ts", 1868155200000, "doc" ]
         ],
         "$index": [
@@ -150,26 +132,19 @@ Imports pointing at $`node:path` and $`path` are rewritten at compile time to po
           [ "package.json", "package-json", 1868155200000 ]
         ],
         "test": [
-          [ "test/path.ts", "ts", 1868155200000, "test" ],
-          [ "test/runtime.ts", "ts", 1868155200000, "test" ]
+          [ "test/path.ts", "ts", 1868155200000, "test" ]
         ],
         "test/fixtures": [
           [ "test/fixtures/simple.ts", "fixture", 1868155200000, "test" ]
         ],
-        "$transformer": [
-          [ "support/transformer.function-metadata.ts", "ts", 1868155200000, "compile" ],
-          [ "support/transformer.rewrite-path-import.ts", "ts", 1868155200000, "compile" ]
-        ],
         "src": [
           [ "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/runtime.ts", "ts", 1868155200000 ],
           [ "src/util.ts", "ts", 1868155200000 ],
           [ "src/types/common.ts", "ts", 1868155200000 ],
           [ "src/types/context.ts", "ts", 1868155200000 ],

package/__index__.ts

@@ -1,9 +1,8 @@
-/// <reference path="./src/global.d.ts" />
+/// <reference path="../runtime/src/global.d.ts" />
 
 export * from './src/module';
 export * from './src/delta';
 export * from './src/manifest-index';
-export * from './src/runtime';
 export * from './src/package';
 export * from './src/util';
 export * from './src/file';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "5.0.0-rc.1",
+  "version": "5.0.0-rc.2",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
     "path",

package/src/manifest-index.ts

@@ -22,13 +22,12 @@ export class ManifestIndex {
   #manifest: ManifestRoot;
   #modules: IndexedModule[];
   #modulesByName: Record<string, IndexedModule> = {};
-  #modulesByFolder: Record<string, IndexedModule> = {};
   #outputRoot: string;
   #outputToEntry = new Map<string, IndexedFile>();
   #sourceToEntry = new Map<string, IndexedFile>();
   #importToEntry = new Map<string, IndexedFile>();
 
-  constructor(manifest: string) {
+  constructor(manifest: string = process.env.TRV_MANIFEST!) {
     this.init(manifest);
   }
 
@@ -50,6 +49,14 @@ export class ManifestIndex {
     this.#index();
   }
 
+  /**
+   * **WARNING**: This is a destructive operation, and should only be called before loading any code
+   * @private
+   */
+  reinitForModule(module: string): void {
+    this.init(`${this.outputRoot}/node_modules/${module}`);
+  }
+
   #moduleFiles(m: ManifestModule, files: ManifestModuleFile[]): IndexedFile[] {
     return files.map(([f, type, ts, role = 'std']) => {
       const isSource = type === 'ts' || type === 'js';
@@ -98,7 +105,6 @@ export class ManifestIndex {
       }
     }
     this.#modulesByName = Object.fromEntries(this.#modules.map(x => [x.name, x]));
-    this.#modulesByFolder = Object.fromEntries(this.#modules.map(x => [x.sourceFolder, x]));
 
     // Store child information
     for (const mod of this.#modules) {
@@ -162,13 +168,6 @@ export class ManifestIndex {
     return this.#modulesByName[name];
   }
 
-  /**
-   * Get module by folder
-   */
-  getModuleByFolder(folder: string): IndexedModule | undefined {
-    return this.#modulesByFolder[folder];
-  }
-
   /**
    * Resolve import
    */
@@ -203,15 +202,6 @@ export class ManifestIndex {
     return name ? this.getModule(name) : undefined;
   }
 
-  /**
-   * Get module from import name
-   * @param importName
-   */
-  getModuleFromImport(importName: string): IndexedModule | undefined {
-    const name = this.getFromImport(importName)?.module;
-    return name ? this.getModule(name) : undefined;
-  }
-
   /**
    * Build module list from an expression list (e.g. `@travetto/rest,-@travetto/log)
    */
@@ -266,4 +256,34 @@ export class ManifestIndex {
     );
     return lookup(file.replace(`${base}/`, '').split('/'));
   }
+
+  /**
+   * Get manifest module by name
+   */
+  getManifestModule(mod: string): ManifestModule {
+    return this.manifest.modules[mod];
+  }
+
+  /**
+   * Get manifest modules
+   */
+  getManifestModules(): ManifestModule[] {
+    return Object.values(this.manifest.modules);
+  }
+
+  /**
+   * Get main module for manifest
+   */
+  get mainModule(): IndexedModule {
+    return this.getModule(this.manifest.main.name)!;
+  }
+
+  /**
+   * Get source file from import location
+   * @param importFile
+   */
+  getSourceFile(importFile: string | [string, string]): string {
+    importFile = Array.isArray(importFile) ? importFile.join('/') : importFile;
+    return this.getFromImport(importFile)?.sourceFile ?? importFile;
+  }
 }

package/src/types/common.ts

@@ -8,13 +8,4 @@ export type ManifestModuleFolderType =
   'test/fixtures' | 'support/fixtures' | 'support/resources' |
   '$other' | '$transformer';
 
-export type ManifestModuleRole = 'std' | 'test' | 'doc' | 'compile' | 'build';
-
-export type FunctionMetadataTag = { hash: number, lines: [number, number] };
-export type FunctionMetadata = FunctionMetadataTag & {
-  id: string;
-  source: string;
-  methods?: Record<string, FunctionMetadataTag>;
-  synthetic?: boolean;
-  abstract?: boolean;
-};
+export type ManifestModuleRole = 'std' | 'test' | 'doc' | 'compile' | 'build';

package/src/global.d.ts

@@ -1,3 +0,0 @@
-declare interface Function {
-  Ⲑid: string;
-}

package/src/runtime.ts

@@ -1,115 +0,0 @@
-import { path } from './path';
-import { ManifestIndex } from './manifest-index';
-import type { FunctionMetadata, FunctionMetadataTag } from './types/common';
-import type { IndexedModule, ManifestModule } from './types/manifest';
-
-const METADATA = Symbol.for('@travetto/manifest:metadata');
-type Metadated = { [METADATA]: FunctionMetadata };
-
-/**
- * Extended manifest index geared for application execution
- */
-class $RuntimeIndex extends ManifestIndex {
-
-  #metadata = new Map<string, FunctionMetadata>();
-
-  /**
-   * **WARNING**: This is a destructive operation, and should only be called before loading any code
-   * @private
-   */
-  reinitForModule(module: string): void {
-    this.init(`${this.outputRoot}/node_modules/${module}`);
-  }
-
-  /**
-   * Get internal id from file name and optionally, class name
-   */
-  getId(filename: string, clsName?: string): string {
-    filename = path.toPosix(filename);
-    const id = this.getEntry(filename)?.id ?? filename;
-    return clsName ? `${id}￮${clsName}` : id;
-  }
-
-  /**
-   * Get main module for manifest
-   */
-  get mainModule(): IndexedModule {
-    return this.getModule(this.manifest.main.name)!;
-  }
-
-  /**
-   * Get source file from import location
-   * @param outputFile
-   */
-  getSourceFile(importFile: string): string {
-    return this.getFromImport(importFile)?.sourceFile ?? importFile;
-  }
-
-  /**
-   * Initialize the meta data for a function/class
-   * @param cls Class
-   * @param `file` Filename
-   * @param `hash` Hash of class contents
-   * @param `line` Line number in source
-   * @param `methods` Methods and their hashes
-   * @param `abstract` Is the class abstract
-   * @param `synthetic` Is this code generated at build time
-   * @private
-   */
-  registerFunction(
-    cls: Function, fileOrImport: string, tag: FunctionMetadataTag,
-    methods?: Record<string, FunctionMetadataTag>, abstract?: boolean, synthetic?: boolean
-  ): boolean {
-    const source = this.getSourceFile(fileOrImport);
-    const id = this.getId(source, cls.name);
-    Object.defineProperty(cls, 'Ⲑid', { value: id });
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    (cls as unknown as Metadated)[METADATA] = { id, source, ...tag, methods, abstract, synthetic };
-    this.#metadata.set(id, { id, source, ...tag, methods, abstract, synthetic });
-    return true;
-  }
-
-  /**
-   * Retrieve function metadata by function, or function id
-   */
-  getFunctionMetadataFromClass(cls: Function | undefined): FunctionMetadata | undefined {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return (cls as unknown as Metadated)?.[METADATA];
-  }
-
-  /**
-   * Retrieve function metadata by function, or function id
-   */
-  getFunctionMetadata(clsId?: string | Function): FunctionMetadata | undefined {
-    const id = clsId === undefined ? '' : typeof clsId === 'string' ? clsId : clsId.Ⲑid;
-    return this.#metadata.get(id);
-  }
-
-  /**
-   * Resolve module path to folder, with support for main module and monorepo support
-   */
-  resolveModulePath(modulePath: string): string {
-    const main = this.manifest.main.name;
-    const workspace = this.manifest.workspace.path;
-    const [base, sub] = modulePath
-      .replace(/^(@@?)(#|$)/g, (_, v, r) => `${v === '@' ? main : workspace}${r}`)
-      .split('#');
-    return path.resolve(this.hasModule(base) ? this.getModule(base)!.sourcePath : base, sub ?? '.');
-  }
-
-  /**
-   * Get manifest module by name
-   */
-  getManifestModule(mod: string): ManifestModule {
-    return this.manifest.modules[mod];
-  }
-
-  /**
-   * Get manifest modules
-   */
-  getManifestModules(): ManifestModule[] {
-    return Object.values(this.manifest.modules);
-  }
-}
-
-export const RuntimeIndex = new $RuntimeIndex(process.env.TRV_MANIFEST!);

package/support/transformer.function-metadata.ts

@@ -1,142 +0,0 @@
-import ts from 'typescript';
-
-import {
-  TransformerState, OnMethod, OnClass, AfterClass,
-  AfterFunction, CoreUtil, SystemUtil, Import
-} from '@travetto/transformer';
-
-import type { FunctionMetadataTag } from '../src/types/common';
-
-const MANIFEST_MOD = '@travetto/manifest';
-const MANIFEST_MOD_SRC = `${MANIFEST_MOD}/src`;
-const MANIFEST_IDX = `${MANIFEST_MOD}/__index__`;
-
-const RUNTIME_IDX_IMPORT = `${MANIFEST_MOD_SRC}/runtime`;
-const RUNTIME_IDX_CLS = 'RuntimeIndex';
-
-const methods = Symbol.for(`${MANIFEST_MOD}:methods`);
-const cls = Symbol.for(`${MANIFEST_MOD}:class`);
-const fn = Symbol.for(`${MANIFEST_MOD}:function`);
-const runtimeIdx = Symbol.for(`${MANIFEST_MOD}:runtimeIndex`);
-
-interface MetadataInfo {
-  [runtimeIdx]?: Import;
-  [methods]?: Record<string, FunctionMetadataTag>;
-  [cls]?: FunctionMetadataTag;
-  [fn]?: number;
-}
-
-/**
- * Providing metadata for classes
- */
-export class RegisterTransformer {
-
-  static #tag(state: TransformerState, node: ts.Node): FunctionMetadataTag {
-    const hash = SystemUtil.naiveHash(node.getText());
-    try {
-      const range = CoreUtil.getRangeOf(state.source, node) ?? [0, 0];
-      return { hash, lines: range };
-    } catch (err) {
-      return { hash, lines: [0, 0] };
-    }
-  }
-
-  static #valid({ importName: imp }: TransformerState): boolean {
-    return !imp.startsWith(MANIFEST_MOD_SRC) && imp !== MANIFEST_IDX;
-  }
-
-  /**
-   * Hash each class
-   */
-  @OnClass()
-  static collectClassMetadata(state: TransformerState & MetadataInfo, node: ts.ClassDeclaration): ts.ClassDeclaration {
-    if (!this.#valid(state)) {
-      return node; // Exclude self
-    }
-    state[cls] = this.#tag(state, node);
-    return node;
-  }
-
-  /**
-   * Hash each method
-   */
-  @OnMethod()
-  static collectMethodMetadata(state: TransformerState & MetadataInfo, node: ts.MethodDeclaration): ts.MethodDeclaration {
-    if (state[cls] && ts.isIdentifier(node.name) && !CoreUtil.isAbstract(node) && ts.isClassDeclaration(node.parent)) {
-      state[methods] ??= {};
-      state[methods]![node.name.escapedText.toString()] = this.#tag(state, node);
-    }
-    return node;
-  }
-
-  /**
-   * After visiting each class, register all the collected metadata
-   */
-  @AfterClass()
-  static registerClassMetadata(state: TransformerState & MetadataInfo, node: ts.ClassDeclaration): ts.ClassDeclaration {
-    if (!state[cls]) {
-      return node;
-    }
-
-    state[runtimeIdx] ??= state.importFile(RUNTIME_IDX_IMPORT);
-    const ident = state.createAccess(state[runtimeIdx].ident, RUNTIME_IDX_CLS);
-
-    const name = node.name?.escapedText.toString() ?? '';
-
-    const meta = state.factory.createCallExpression(
-      state.createAccess(ident, 'registerFunction'),
-      [],
-      [
-        state.createIdentifier(name),
-        state.getFilenameIdentifier(),
-        state.fromLiteral(state[cls]),
-        state.extendObjectLiteral(state[methods] || {}),
-        state.fromLiteral(CoreUtil.isAbstract(node)),
-        state.fromLiteral(name.endsWith(TransformerState.SYNTHETIC_EXT))
-      ]
-    );
-
-    state[methods] = {};
-    delete state[cls];
-
-    return state.factory.updateClassDeclaration(
-      node,
-      node.modifiers,
-      node.name,
-      node.typeParameters,
-      node.heritageClauses,
-      [
-        state.createStaticField('Ⲑinit', meta),
-        ...node.members
-      ]
-    );
-  }
-
-  /**
-   * Give proper functions a file name
-   */
-  @AfterFunction()
-  static registerFunctionMetadata(state: TransformerState & MetadataInfo, node: ts.FunctionDeclaration | ts.FunctionExpression): typeof node {
-    if (!this.#valid(state)) {
-      return node;
-    }
-
-    if (ts.isFunctionDeclaration(node) && node.name && node.parent && ts.isSourceFile(node.parent)) {
-      // If we have a class like function
-      state[runtimeIdx] ??= state.importFile(RUNTIME_IDX_IMPORT);
-      const ident = state.createAccess(state[runtimeIdx].ident, RUNTIME_IDX_CLS);
-      const tag = this.#tag(state, node);
-      const meta = state.factory.createCallExpression(
-        state.createAccess(ident, 'registerFunction'),
-        [],
-        [
-          state.createIdentifier(node.name),
-          state.getFilenameIdentifier(),
-          state.fromLiteral(tag),
-        ]
-      );
-      state.addStatements([state.factory.createExpressionStatement(meta)]);
-    }
-    return node;
-  }
-}

package/support/transformer.rewrite-path-import.ts

@@ -1,39 +0,0 @@
-import ts from 'typescript';
-
-import { TransformerState, OnFile } from '@travetto/transformer';
-
-const PATH_REGEX = /^['"](node:)?path['"]$/;
-const PATH_TARGET = '@travetto/manifest/src/path';
-const SKIP_SRC = /^@travetto\/manifest\/(src|support)/;
-
-/**
- * Rewriting path imports to use manifest's path
- */
-export class PathImportTransformer {
-
-  /**
-   * Hash each class
-   */
-  @OnFile()
-  static rewritePathImport(state: TransformerState, node: ts.SourceFile): ts.SourceFile {
-    if (SKIP_SRC.test(state.importName)) {
-      return node;
-    }
-
-    const stmt = node.statements.find((x): x is ts.ImportDeclaration =>
-      ts.isImportDeclaration(x) && PATH_REGEX.test(x.moduleSpecifier?.getText() ?? ''));
-    if (stmt) {
-      const updated = state.factory.updateImportDeclaration(
-        stmt,
-        stmt.modifiers,
-        stmt.importClause,
-        state.factory.createStringLiteral(PATH_TARGET),
-        stmt.attributes
-      );
-      return state.factory.updateSourceFile(node, node.statements.map(x =>
-        x === stmt ? updated : x
-      ));
-    }
-    return node;
-  }
-}