@travetto/manifest 4.0.0-rc.0 → 4.0.0-rc.2

package/src/util.ts

@@ -1,9 +1,11 @@
 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';
 
 /**
@@ -15,29 +17,41 @@ export class ManifestUtil {
    */
   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
-      modules: Object.fromEntries(
-        Object.values(manifest.modules)
-          .filter(x => x.prod)
-          .map(m => [m.name, m])
-      ),
+      generated: manifest.generated,
+      workspace: manifest.workspace,
       build: {
         ...manifest.build,
         // Mark output folder/workspace path as portable
         outputFolder: '$$PRODUCTION$$',
-      }
+      },
+      main: manifest.main,
+      modules: Object.fromEntries(
+        prodModules.map(m => [m.name, Object.assign(m, {
+          parents: m.parents.filter(x => prodModNames.has(x))
+        })])
+      ),
     };
   }
 
@@ -47,7 +61,7 @@ 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);
@@ -58,7 +72,7 @@ export class ManifestUtil {
       manifest.build.outputFolder = path.cwd();
       manifest.workspace.path = path.cwd();
     }
-    return { manifest, file };
+    return manifest;
   }
 
   /**
@@ -89,7 +103,8 @@ export class ManifestUtil {
    */
   static getWorkspaceContext(ctx: ManifestContext): ManifestContext {
     return ctx.workspace.mono ? {
-      ...ctx,
+      workspace: ctx.workspace,
+      build: ctx.build,
       main: {
         name: ctx.workspace.name,
         folder: '',
@@ -106,7 +121,8 @@ export class ManifestUtil {
     const pkg = PackageUtil.readPackage(modPath);
 
     return {
-      ...ctx,
+      workspace: ctx.workspace,
+      build: ctx.build,
       main: {
         name: pkg.name,
         folder,
@@ -115,4 +131,43 @@ export class ManifestUtil {
       }
     };
   }
+
+  /**
+   * 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/src/types.ts

@@ -1,140 +0,0 @@
-export type NodeModuleType = 'module' | 'commonjs';
-export type NodePackageManager = 'yarn' | 'npm';
-
-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 ManifestDepCore = {
-  name: string;
-  main?: boolean;
-  local?: boolean;
-  version: string;
-  prod: boolean;
-  internal?: boolean;
-};
-export type ManifestModuleCore = ManifestDepCore & {
-  sourceFolder: string;
-  outputFolder: string;
-  roles: ManifestModuleRole[];
-  parents: string[];
-};
-
-export type ManifestModule = ManifestModuleCore & {
-  files: Partial<Record<ManifestModuleFolderType, ManifestModuleFile[]>>;
-};
-
-export type ManifestContext = {
-  workspace: {
-    /** Workspace path for module */
-    path: string;
-    /** The module name for the workspace root */
-    name: string;
-    /** Is the workspace a monorepo? */
-    mono?: boolean;
-    /** The module type of the workspace */
-    type: NodeModuleType;
-    /** The package manager of the workspace */
-    manager: NodePackageManager;
-  };
-  build: {
-    /** Compiler folder, relative to workspace */
-    compilerFolder: string;
-    /** Compiler module folder */
-    compilerModuleFolder: string;
-    /** URL for the compiler server */
-    compilerUrl: string;
-    /** Code output folder, relative to workspace */
-    outputFolder: string;
-  };
-  main: {
-    /** Main module for manifest */
-    name: string;
-    /** Folder, relative to workspace for main module */
-    folder: string;
-    /** Description of the main module */
-    description?: string;
-    /** Version of the main module */
-    version: 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?: {
-    displayName?: string;
-    roles?: ManifestModuleRole[];
-    doc?: {
-      output?: string[];
-      root?: string;
-      baseUrl?: string;
-      outputs?: string[];
-    };
-    build?: Partial<ManifestContext['build']> & {
-      isolated?: boolean;
-      withModules?: Record<string, 'main' | true>;
-    };
-  };
-  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> = {
-  rootPath: string;
-  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;
-};