@travetto/manifest 3.4.0 → 4.0.0-rc.1

package/src/util.ts

@@ -1,7 +1,10 @@
 import { path } from './path';
-import { ManifestContext, ManifestRoot } from './types';
 import { ManifestModuleUtil } from './module';
 import { ManifestFileUtil } from './file';
+import { PackageUtil } from './package';
+
+import type { ManifestContext } from './types/context';
+import type { ManifestRoot } from './types/manifest';
 
 const MANIFEST_FILE = 'manifest.json';
 
@@ -9,41 +12,46 @@ const MANIFEST_FILE = 'manifest.json';
  * Manifest utils
  */
 export class ManifestUtil {
-  /**
-   * Build a manifest context
-   * @param folder
-   */
-  static async buildContext(folder?: string): Promise<ManifestContext> {
-    const { getManifestContext } = await import('../bin/context.js');
-    return getManifestContext(folder);
-  }
-
   /**
    * Produce manifest in memory
    */
   static async buildManifest(ctx: ManifestContext): Promise<ManifestRoot> {
     return {
-      modules: await ManifestModuleUtil.produceModules(ctx),
       generated: Date.now(),
-      ...ctx
+      workspace: ctx.workspace,
+      build: ctx.build,
+      main: ctx.main,
+      modules: await ManifestModuleUtil.produceModules(ctx),
     };
   }
 
+  /**
+   * Produce a manifest location given a current context and a module name
+   */
+  static getManifestLocation(ctx: ManifestContext, module?: string): string {
+    return path.resolve(ctx.workspace.path, ctx.build.outputFolder, 'node_modules', module ?? ctx.workspace.name);
+  }
+
   /**
    * Produce a production manifest from a given manifest
    */
   static createProductionManifest(manifest: ManifestRoot): ManifestRoot {
+    const prodModules = Object.values(manifest.modules).filter(x => x.prod);
+    const prodModNames = new Set([...prodModules.map(x => x.name)]);
     return {
-      ...manifest,
-      // If in prod mode, only include std modules
+      generated: manifest.generated,
+      workspace: manifest.workspace,
+      build: {
+        ...manifest.build,
+        // Mark output folder/workspace path as portable
+        outputFolder: '$$PRODUCTION$$',
+      },
+      main: manifest.main,
       modules: Object.fromEntries(
-        Object.values(manifest.modules)
-          .filter(x => x.prod)
-          .map(m => [m.name, m])
+        prodModules.map(m => [m.name, Object.assign(m, {
+          parents: m.parents.filter(x => prodModNames.has(x))
+        })])
       ),
-      // Mark output folder/workspace path as portable
-      outputFolder: '',
-      workspacePath: '',
     };
   }
 
@@ -53,27 +61,27 @@ export class ManifestUtil {
    * @param file
    * @returns
    */
-  static readManifestSync(file: string): { manifest: ManifestRoot, file: string } {
+  static readManifestSync(file: string): ManifestRoot {
     file = path.resolve(file);
     if (!file.endsWith('.json')) {
       file = path.resolve(file, MANIFEST_FILE);
     }
     const manifest: ManifestRoot = ManifestFileUtil.readAsJsonSync(file);
-    // Support packaged environments, by allowing empty outputFolder
-    if (!manifest.outputFolder) {
-      manifest.outputFolder = path.cwd();
-      manifest.workspacePath = path.cwd();
+    // Support packaged environments, by allowing empty manifest.build.outputFolder
+    if (manifest.build.outputFolder === '$$PRODUCTION$$') {
+      manifest.build.outputFolder = path.cwd();
+      manifest.workspace.path = path.cwd();
     }
-    return { manifest, file };
+    return manifest;
   }
 
   /**
    * Write manifest for a given context, return location
    */
-  static writeManifest(ctx: ManifestContext, manifest: ManifestRoot): Promise<string> {
-    return ManifestFileUtil.bufferedFileWrite(
-      path.resolve(ctx.workspacePath, ctx.outputFolder, 'node_modules', ctx.mainModule, MANIFEST_FILE),
-      JSON.stringify(manifest)
+  static writeManifest(manifest: ManifestRoot): Promise<string> {
+    return this.writeManifestToFile(
+      path.resolve(manifest.workspace.path, manifest.build.outputFolder, 'node_modules', manifest.main.name),
+      manifest
     );
   }
 
@@ -91,11 +99,75 @@ export class ManifestUtil {
   }
 
   /**
-   * Rewrite manifest for a given folder
+   * Produce the manifest context for the workspace module
    */
-  static async rewriteManifest(source: string): Promise<void> {
-    const subCtx = await this.buildContext(source);
-    const subManifest = await this.buildManifest(subCtx);
-    await this.writeManifest(subCtx, subManifest);
+  static getWorkspaceContext(ctx: ManifestContext): ManifestContext {
+    return ctx.workspace.mono ? {
+      workspace: ctx.workspace,
+      build: ctx.build,
+      main: {
+        name: ctx.workspace.name,
+        folder: '',
+        version: '0.0.0',
+      }
+    } : ctx;
+  }
+
+  /**
+   * Produce the manifest context for a given module module
+   */
+  static getModuleContext(ctx: ManifestContext, folder: string): ManifestContext {
+    const modPath = path.resolve(ctx.workspace.path, folder);
+    const pkg = PackageUtil.readPackage(modPath);
+
+    return {
+      workspace: ctx.workspace,
+      build: ctx.build,
+      main: {
+        name: pkg.name,
+        folder,
+        version: pkg.version,
+        description: pkg.description
+      }
+    };
+  }
+
+  /**
+   * Efficient lookup for path-based graphs
+   */
+  static lookupTrie<T>(
+    inputs: T[], getPath: (v: T) => string[], validateUnknown?: (pth: string[]) => boolean
+  ): (pth: string[]) => T | undefined {
+    type TrieNode = { value?: T, subs: Record<string, TrieNode> };
+    const root: TrieNode = { subs: {} };
+    for (const item of inputs) {
+      const pth = getPath(item);
+      let node = root;
+      for (const sub of pth) {
+        if (sub) {
+          node = node.subs[sub] ??= { subs: {} };
+        }
+      }
+      node.value = item;
+    }
+
+    return pth => {
+      let node = root;
+      let value = node.value;
+      let i = 0;
+
+      for (const sub of pth) {
+        i += 1;
+        if (node) {
+          node = node.subs[sub];
+          value = node?.value ?? value;
+        } else if (validateUnknown && !node && !validateUnknown(pth.slice(0, i))) {
+          value = undefined;
+          break;
+        }
+      }
+
+      return value;
+    };
   }
 }

package/support/transformer.function-metadata.ts

@@ -9,16 +9,16 @@ const MANIFEST_MOD = '@travetto/manifest';
 const MANIFEST_IDX = `${MANIFEST_MOD}/__index__`;
 const ENTRY_POINT = 'support/entry';
 
-const ROOT_IDX_IMPORT = `${MANIFEST_MOD}/src/root-index`;
-const ROOT_IDX_CLS = 'RootIndex';
+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 rootIdx = Symbol.for(`${MANIFEST_MOD}:rootIndex`);
+const runtimeIdx = Symbol.for(`${MANIFEST_MOD}:runtimeIndex`);
 
 interface MetadataInfo {
-  [rootIdx]?: Import;
+  [runtimeIdx]?: Import;
   [methods]?: {
     [key: string]: { hash: number };
   };
@@ -72,8 +72,8 @@ export class RegisterTransformer {
       return node;
     }
 
-    state[rootIdx] ??= state.importFile(ROOT_IDX_IMPORT);
-    const ident = state.createAccess(state[rootIdx].ident, ROOT_IDX_CLS);
+    state[runtimeIdx] ??= state.importFile(RUNTIME_IDX_IMPORT);
+    const ident = state.createAccess(state[runtimeIdx].ident, RUNTIME_IDX_CLS);
 
     const name = node.name?.escapedText.toString() ?? '';
 
@@ -117,8 +117,8 @@ export class RegisterTransformer {
 
     if (ts.isFunctionDeclaration(node) && node.name && node.parent && ts.isSourceFile(node.parent)) {
       // If we have a class like function
-      state[rootIdx] ??= state.importFile(ROOT_IDX_IMPORT);
-      const ident = state.createAccess(state[rootIdx].ident, ROOT_IDX_CLS);
+      state[runtimeIdx] ??= state.importFile(RUNTIME_IDX_IMPORT);
+      const ident = state.createAccess(state[runtimeIdx].ident, RUNTIME_IDX_CLS);
       const meta = state.factory.createCallExpression(
         state.createAccess(ident, 'registerFunction'),
         [],

package/src/types.ts

@@ -1,118 +0,0 @@
-export type NodeModuleType = 'module' | 'commonjs';
-
-export type ManifestModuleFileType = 'typings' | 'ts' | 'js' | 'json' | 'package-json' | 'unknown' | 'fixture' | 'md';
-export type ManifestModuleFolderType =
-  '$root' | '$index' | '$package' |
-  'src' | 'bin' | 'support' | 'resources' | 'test' | 'doc' |
-  'test/fixtures' | 'support/fixtures' | 'support/resources' |
-  '$other' | '$transformer';
-
-export type ManifestModuleRole = 'std' | 'test' | 'doc' | 'compile' | 'build';
-
-export type ManifestModuleFile = [string, ManifestModuleFileType, number] | [string, ManifestModuleFileType, number, ManifestModuleRole];
-export type ManifestModuleCore = {
-  name: string;
-  main?: boolean;
-  local?: boolean;
-  version: string;
-  sourceFolder: string;
-  outputFolder: string;
-  prod: boolean;
-  roles: ManifestModuleRole[];
-  parents: string[];
-  internal?: boolean;
-};
-
-export type ManifestModule = ManifestModuleCore & {
-  files: Partial<Record<ManifestModuleFolderType, ManifestModuleFile[]>>;
-};
-
-export type ManifestContext = {
-  mainModule: string;
-  mainFolder: string;
-  workspacePath: string;
-  outputFolder: string;
-  toolFolder: string;
-  compilerFolder: string;
-  monoRepo?: boolean;
-  moduleType: NodeModuleType;
-  packageManager: 'yarn' | 'npm';
-  frameworkVersion: string;
-  description?: string;
-  version: string;
-  compilerUrl: string;
-};
-
-export type ManifestRoot = ManifestContext & {
-  generated: number;
-  modules: Record<string, ManifestModule>;
-};
-
-export type Package = {
-  name: string;
-  type?: NodeModuleType;
-  version: string;
-  description?: string;
-  license?: string;
-  repository?: {
-    url: string;
-    directory?: string;
-  };
-  author?: {
-    email?: string;
-    name?: string;
-  };
-  main: string;
-  homepage?: string;
-  files?: string[];
-  bin?: Record<string, string>;
-  scripts?: Record<string, string>;
-  engines?: Record<string, string>;
-  keywords?: string[];
-
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-  peerDependencies?: Record<string, string>;
-  peerDependenciesMeta?: Record<string, { optional?: boolean }>;
-  optionalDependencies?: Record<string, string>;
-  travetto?: {
-    isolated?: boolean;
-    displayName?: string;
-    roles?: ManifestModuleRole[];
-    globalModules?: string[];
-    mainSource?: string[];
-    docOutput?: string[];
-    docRoot?: string;
-    docBaseUrl?: string;
-    docOutputs?: string[];
-    outputFolder?: string;
-    toolFolder?: string;
-    compilerFolder?: string;
-    compilerUrl?: string;
-  };
-  workspaces?: string[];
-  private?: boolean;
-  publishConfig?: { access?: 'restricted' | 'public' };
-};
-
-type OrProm<T> = T | Promise<T>;
-
-export type PackageVisitReq<T> = { pkg: Package, prod: boolean, sourcePath: string, parent?: T, topLevel?: boolean };
-export type PackageVisitor<T> = {
-  init?(req: PackageVisitReq<T>): OrProm<undefined | void | PackageVisitReq<T>[]>;
-  valid?(req: PackageVisitReq<T>): boolean;
-  create(req: PackageVisitReq<T>): OrProm<T>;
-  visit?(req: PackageVisitReq<T>, item: T): OrProm<void>;
-  complete?(values: Set<T>): OrProm<Set<T> | undefined>;
-};
-
-export type PackageWorkspaceEntry = { name: string, sourcePath: string };
-
-export type FunctionMetadata = {
-  id: string;
-  source: string;
-  hash?: number;
-  methods?: Record<string, { hash: number }>;
-  synthetic?: boolean;
-  abstract?: boolean;
-};