@travetto/manifest 4.0.0-rc.5 → 4.0.0-rc.7

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.5",
+  "version": "4.0.0-rc.7",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
     "path",

package/src/delta.ts

@@ -35,7 +35,7 @@ export class ManifestDeltaUtil {
 
     const root = path.resolve(ctx.workspace.path, ctx.build.outputFolder, left.outputFolder);
     const right = new Set(
-      (await ManifestModuleUtil.scanFolder(root, left.main))
+      (await ManifestModuleUtil.scanFolder(ctx, root, left.main))
         .filter(x => {
           const type = ManifestModuleUtil.getFileType(x);
           return VALID_SOURCE_TYPE.has(type);

package/src/module.ts

@@ -44,7 +44,7 @@ export class ManifestModuleUtil {
   /**
    * Simple file scanning
    */
-  static async scanFolder(folder: string, full = false): Promise<string[]> {
+  static async scanFolder(ctx: ManifestContext, folder: string, full = false): Promise<string[]> {
     const key = `${folder}|${full}`;
     if (key in this.#scanCache) {
       return this.#scanCache[key];
@@ -56,6 +56,12 @@ export class ManifestModuleUtil {
 
     const out: string[] = [];
 
+    const exclude = new Set([
+      path.resolve(ctx.workspace.path, ctx.build.compilerFolder),
+      path.resolve(ctx.workspace.path, ctx.build.outputFolder),
+      path.resolve(ctx.workspace.path, ctx.build.toolFolder),
+    ]);
+
     const stack: [string, number][] = [[folder, 0]];
     while (stack.length) {
       const popped = stack.pop();
@@ -69,6 +75,9 @@ export class ManifestModuleUtil {
       if (top !== folder && await fs.stat(`${top}/package.json`).catch(() => false)) {
         continue;
       }
+      if (exclude.has(top)) {
+        continue;
+      }
 
       for (const sub of await fs.readdir(top)) {
         const valid = !sub.startsWith('.') && (depth > 0 || full);
@@ -177,7 +186,7 @@ export class ManifestModuleUtil {
 
     const files: ManifestModule['files'] = {};
 
-    for (const file of await this.scanFolder(sourcePath, rest.main)) {
+    for (const file of await this.scanFolder(ctx, sourcePath, rest.main)) {
       // Group by top folder
       const moduleFile = file.replace(`${sourcePath}/`, '');
       const entry = await this.transformFile(moduleFile, file);

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/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)]);