@travetto/manifest 4.0.0-rc.4 → 4.0.0-rc.6

package/README.md

@@ -53,7 +53,7 @@ const tslib_1 = require("tslib");
 const Ⲑ_runtime_1 = tslib_1.__importStar(require("@travetto/manifest/src/runtime.js"));
 var ᚕf = "@travetto/manifest/doc/test-class.js";
 class TestClass {
-    static Ⲑinit = Ⲑ_runtime_1.RuntimeIndex.registerFunction(TestClass, ᚕf, 197152026, { doStuff: { hash: 51337554 } }, false, false);
+    static Ⲑinit = Ⲑ_runtime_1.RuntimeIndex.registerFunction(TestClass, ᚕf, { hash: 197152026, lines: [1, 3] }, { doStuff: { hash: 51337554, lines: [2, 2] } }, false, false);
     async doStuff() { }
 }
 exports.TestClass = TestClass;
@@ -67,7 +67,8 @@ $ trv main ./doc/lookup.ts
   id: '@travetto/manifest:doc/test-class￮TestClass',
   source: './doc/test-class.ts',
   hash: 197152026,
-  methods: { doStuff: { hash: 51337554 } },
+  lines: [ 1, 3 ],
+  methods: { doStuff: { hash: 51337554, lines: [Array] } },
   abstract: false,
   synthetic: false
 }

package/package.json

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

package/src/dependencies.ts

@@ -23,23 +23,56 @@ type Req = {
  */
 export class PackageModuleVisitor {
 
-  constructor(public ctx: ManifestContext) {
-    this.#mainSourcePath = path.resolve(this.ctx.workspace.path, this.ctx.main.folder);
+  static async visit(ctx: ManifestContext): Promise<Iterable<PackageModule>> {
+    const visitor = new PackageModuleVisitor(ctx, Object.fromEntries((await PackageUtil.resolveWorkspaces(ctx)).map(x => [x.name, x.path])));
+    return visitor.visit();
   }
 
   #mainSourcePath: string;
   #cache: Record<string, PackageModule> = {};
-  #workspaceModules: Map<string, string>;
+  #workspaceModules: Record<string, string>;
+  #ctx: ManifestContext;
+
+  constructor(ctx: ManifestContext, workspaceModules: Record<string, string>) {
+    this.#mainSourcePath = path.resolve(ctx.workspace.path, ctx.main.folder);
+    this.#ctx = ctx;
+    this.#workspaceModules = workspaceModules;
+  }
+
+  /**
+   * Build a package module
+   */
+  #create(sourcePath: string, { main, workspace, prod = false, roleRoot = false, parent }: CreateOpts = {}): Req {
+    const pkg = PackageUtil.readPackage(sourcePath);
+    const value = this.#cache[sourcePath] ??= {
+      main,
+      prod,
+      name: pkg.name,
+      version: pkg.version,
+      workspace: workspace ?? (pkg.name in this.#workspaceModules),
+      internal: pkg.private === true,
+      sourceFolder: sourcePath === this.#ctx.workspace.path ? '' : sourcePath.replace(`${this.#ctx.workspace.path}/`, ''),
+      outputFolder: `node_modules/${pkg.name}`,
+      state: {
+        childSet: new Set(), parentSet: new Set(), roleSet: new Set(), roleRoot,
+        travetto: pkg.travetto, prodDeps: new Set(Object.keys(pkg.dependencies ?? {}))
+      }
+    };
+
+    const deps: PackageDepType[] = ['dependencies', ...(value.main ? ['devDependencies'] as const : [])];
+    const children = Object.fromEntries(deps.flatMap(x => Object.entries(pkg[x] ?? {})));
+    return { pkg, value, children, parent };
+  }
 
   /**
    * Get monorepo root includes
    */
   #getMonoRootIncludes(parent: Req): Req[] {
-    if (!(this.ctx.workspace.mono && !this.ctx.main.folder)) { // If not mono root, bail
+    if (!(this.#ctx.workspace.mono && !this.#ctx.main.folder)) { // If not mono root, bail
       return [];
     }
 
-    return [...this.#workspaceModules.values()]
+    return Object.values(this.#workspaceModules)
       .map(loc => this.#create(loc, { main: true, workspace: true, roleRoot: true, parent: parent.value }));
   }
 
@@ -47,63 +80,22 @@ export class PackageModuleVisitor {
    * Determine default includes
    */
   #getIncludes(parent: Req): Req[] {
-    if (this.ctx.workspace.mono && !this.ctx.main.folder) { // If mono and not at mono root, bail
+    if (this.#ctx.workspace.mono && !this.#ctx.main.folder) { // If mono and not at mono root, bail
       return [];
     }
 
-    const root = PackageUtil.readPackage(this.ctx.workspace.path);
+    const root = PackageUtil.readPackage(this.#ctx.workspace.path);
     if (root.travetto?.build?.includes) {
       return Object.entries(root.travetto.build.includes).map(([name, type]) =>
         this.#create(PackageUtil.resolvePackagePath(name), { main: type === 'main', workspace: true, parent: parent.value })
       );
     } else {
-      return [...this.#workspaceModules.values()]
+      return Object.values(this.#workspaceModules)
         .filter((loc) => PackageUtil.readPackage(loc).travetto?.workspaceInclude)
         .map(loc => this.#create(loc, { workspace: true, parent: parent.value }));
     }
   }
 
-  /**
-   * Initialize visitor, and provide global dependencies
-   */
-  async init(): Promise<Iterable<Req>> {
-    const mainReq = this.#create(this.#mainSourcePath, { main: true, workspace: true, roleRoot: true, prod: true });
-    this.#workspaceModules = new Map(
-      (await PackageUtil.resolveWorkspaces(this.ctx)).map(x => [x.name, x.path])
-    );
-
-    return [
-      mainReq,
-      ...this.#getMonoRootIncludes(mainReq),
-      ...this.#getIncludes(mainReq)
-    ];
-  }
-
-  /**
-   * Build a package module
-   */
-  #create(sourcePath: string, { main, workspace, prod = false, roleRoot = false, parent }: CreateOpts = {}): Req {
-    const pkg = PackageUtil.readPackage(sourcePath);
-    const value = this.#cache[sourcePath] ??= {
-      main,
-      prod,
-      name: pkg.name,
-      version: pkg.version,
-      workspace: workspace ?? this.#workspaceModules.has(pkg.name),
-      internal: pkg.private === true,
-      sourceFolder: sourcePath === this.ctx.workspace.path ? '' : sourcePath.replace(`${this.ctx.workspace.path}/`, ''),
-      outputFolder: `node_modules/${pkg.name}`,
-      state: {
-        childSet: new Set(), parentSet: new Set(), roleSet: new Set(), roleRoot,
-        travetto: pkg.travetto, prodDeps: new Set(Object.keys(pkg.dependencies ?? {}))
-      }
-    };
-
-    const deps: PackageDepType[] = ['dependencies', ...(value.main ? ['devDependencies'] as const : [])];
-    const children = Object.fromEntries(deps.flatMap(x => Object.entries(pkg[x] ?? {})));
-    return { pkg, value, children, parent };
-  }
-
   /**
    * Propagate prod, role information through graph
    */
@@ -163,7 +155,13 @@ export class PackageModuleVisitor {
    */
   async visit(): Promise<Iterable<PackageModule>> {
     const seen = new Set<PackageModule>();
-    const queue = [...await this.init()];
+    const mainReq = this.#create(this.#mainSourcePath, { main: true, workspace: true, roleRoot: true, prod: true });
+
+    const queue = [
+      mainReq,
+      ...this.#getMonoRootIncludes(mainReq),
+      ...this.#getIncludes(mainReq)
+    ];
 
     while (queue.length) {
       const { value: node, parent, children, pkg } = queue.shift()!; // Visit initial set first
@@ -172,7 +170,7 @@ export class PackageModuleVisitor {
       }
 
       // Track parentage
-      if (node.name !== this.ctx.main.name && parent) {
+      if (node.name !== this.#ctx.main.name && parent) {
         node.state.parentSet.add(parent.name);
         parent.state.childSet.add(node.name);
       }

package/src/module.ts

@@ -197,7 +197,7 @@ export class ManifestModuleUtil {
    * Produce all modules for a given manifest folder, adding in some given modules when developing framework
    */
   static async produceModules(ctx: ManifestContext): Promise<Record<string, ManifestModule>> {
-    const pkgs = await new PackageModuleVisitor(ctx).visit();
+    const pkgs = await PackageModuleVisitor.visit(ctx);
     const modules = await Promise.all([...pkgs].map(x => this.describeModule(ctx, x)));
     return Object.fromEntries(modules.map(m => [m.name, m]));
   }

package/src/package.ts

@@ -78,7 +78,7 @@ export class PackageUtil {
    * Get the package path
    */
   static getPackagePath(pkg: Package): string {
-    return pkg[PackagePath];
+    return pkg[PackagePath]!;
   }
 
   /**

package/src/runtime.ts

@@ -1,7 +1,7 @@
 import { path } from './path';
 import { ManifestIndex } from './manifest-index';
 
-import type { FunctionMetadata } from './types/common';
+import type { FunctionMetadata, FunctionMetadataTag } from './types/common';
 import type { IndexedModule, ManifestModule } from './types/manifest';
 import type { ManifestContext } from './types/context';
 
@@ -52,16 +52,21 @@ class $RuntimeIndex extends ManifestIndex {
    * @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
    */
-  registerFunction(cls: Function, fileOrImport: string, hash: number, methods?: Record<string, { hash: number }>, abstract?: boolean, synthetic?: boolean): boolean {
+  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, hash, methods, abstract, synthetic };
-    this.#metadata.set(id, { id, source, hash, methods, abstract, synthetic });
+    (cls as unknown as Metadated)[METADATA] = { id, source, ...tag, methods, abstract, synthetic };
+    this.#metadata.set(id, { id, source, ...tag, methods, abstract, synthetic });
     return true;
   }
 

package/src/types/common.ts

@@ -10,11 +10,11 @@ export type ManifestModuleFolderType =
 
 export type ManifestModuleRole = 'std' | 'test' | 'doc' | 'compile' | 'build';
 
-export type FunctionMetadata = {
+export type FunctionMetadataTag = { hash: number, lines: [number, number] };
+export type FunctionMetadata = FunctionMetadataTag & {
   id: string;
   source: string;
-  hash?: number;
-  methods?: Record<string, { hash: number }>;
+  methods?: Record<string, FunctionMetadataTag>;
   synthetic?: boolean;
   abstract?: boolean;
 };

package/src/types/package.ts

@@ -4,7 +4,7 @@ import type { ManifestContext } from './context';
 export const PackagePath = Symbol.for('@travetto/manifest:package-path');
 
 export type Package = {
-  [PackagePath]: string;
+  [PackagePath]?: string;
   name: string;
   type?: NodeModuleType;
   version: string;

package/src/util.ts

@@ -116,9 +116,9 @@ export class ManifestUtil {
   /**
    * Produce the manifest context for a given module module
    */
-  static getModuleContext(ctx: ManifestContext, folder: string): ManifestContext {
+  static getModuleContext(ctx: ManifestContext, folder: string, ensureLatest = false): ManifestContext {
     const modPath = path.resolve(ctx.workspace.path, folder);
-    const pkg = PackageUtil.readPackage(modPath);
+    const pkg = PackageUtil.readPackage(modPath, ensureLatest);
 
     return {
       workspace: ctx.workspace,

package/support/transformer.function-metadata.ts

@@ -5,6 +5,8 @@ import {
   AfterFunction, CoreUtil, SystemUtil, Import
 } from '@travetto/transformer';
 
+import type { FunctionMetadataTag } from '../src/types/common';
+
 const MANIFEST_MOD = '@travetto/manifest';
 const MANIFEST_IDX = `${MANIFEST_MOD}/__index__`;
 
@@ -18,10 +20,8 @@ const runtimeIdx = Symbol.for(`${MANIFEST_MOD}:runtimeIndex`);
 
 interface MetadataInfo {
   [runtimeIdx]?: Import;
-  [methods]?: {
-    [key: string]: { hash: number };
-  };
-  [cls]?: number;
+  [methods]?: Record<string, FunctionMetadataTag>;
+  [cls]?: FunctionMetadataTag;
   [fn]?: number;
 }
 
@@ -30,6 +30,16 @@ interface MetadataInfo {
  */
 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|support)[/]/.test(imp) || imp === MANIFEST_IDX);
   }
@@ -42,7 +52,7 @@ export class RegisterTransformer {
     if (!this.#valid(state)) {
       return node; // Exclude self
     }
-    state[cls] = SystemUtil.naiveHash(node.getText());
+    state[cls] = this.#tag(state, node);
     return node;
   }
 
@@ -52,10 +62,8 @@ export class RegisterTransformer {
   @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)) {
-      const hash = SystemUtil.naiveHash(node.getText());
-      const conf = { hash };
       state[methods] ??= {};
-      state[methods]![node.name.escapedText.toString()] = conf;
+      state[methods]![node.name.escapedText.toString()] = this.#tag(state, node);
     }
     return node;
   }
@@ -80,7 +88,7 @@ export class RegisterTransformer {
       [
         state.createIdentifier(name),
         state.getFilenameIdentifier(),
-        state.fromLiteral(state[cls]!),
+        state.fromLiteral(state[cls]),
         state.extendObjectLiteral(state[methods] || {}),
         state.fromLiteral(CoreUtil.isAbstract(node)),
         state.fromLiteral(name.endsWith(TransformerState.SYNTHETIC_EXT))
@@ -116,13 +124,14 @@ export class RegisterTransformer {
       // 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(SystemUtil.naiveHash(node.getText())),
+          state.fromLiteral(tag),
         ]
       );
       state.addStatements([state.factory.createExpressionStatement(meta)]);