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

package/package.json

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

package/src/dependencies.ts

@@ -1,16 +1,27 @@
 import { PackageUtil } from './package';
 import { path } from './path';
 
-import type { Package, PackageDepType, PackageVisitReq, PackageVisitor } from './types/package';
+import type { Package, PackageDepType } from './types/package';
 import type { ManifestContext } from './types/context';
 import type { PackageModule } from './types/manifest';
 
-type CreateOpts = Partial<Pick<PackageModule, 'main' | 'workspace' | 'prod'>> & { roleRoot?: boolean };
+type CreateOpts = Partial<Pick<PackageModule, 'main' | 'workspace' | 'prod'>> & { roleRoot?: boolean, parent?: PackageModule };
+
+type Req = {
+  /** Request package */
+  pkg: Package;
+  /** Children to visit */
+  children: Record<string, string>;
+  /** Value */
+  value: PackageModule;
+  /** Parent */
+  parent?: PackageModule;
+};
 
 /**
  * Used for walking dependencies for collecting modules for the manifest
  */
-export class PackageModuleVisitor implements PackageVisitor<PackageModule> {
+export class PackageModuleVisitor {
 
   constructor(public ctx: ManifestContext) {
     this.#mainSourcePath = path.resolve(this.ctx.workspace.path, this.ctx.main.folder);
@@ -23,9 +34,8 @@ export class PackageModuleVisitor implements PackageVisitor<PackageModule> {
   /**
    * Initialize visitor, and provide global dependencies
    */
-  async init(): Promise<Iterable<PackageVisitReq<PackageModule>>> {
-    const mainPkg = PackageUtil.readPackage(this.#mainSourcePath);
-    const mainReq = this.create(mainPkg, { main: true, workspace: true, roleRoot: true, prod: true });
+  async init(): Promise<Iterable<Req>> {
+    const mainReq = this.#create(this.#mainSourcePath, { main: true, workspace: true, roleRoot: true, prod: true });
     const globals = [mainReq];
     this.#workspaceModules = new Map(
       (await PackageUtil.resolveWorkspaces(this.ctx)).map(x => [x.name, x.path])
@@ -34,33 +44,26 @@ export class PackageModuleVisitor implements PackageVisitor<PackageModule> {
     // Treat all workspace modules as main modules
     if (this.ctx.workspace.mono && !this.ctx.main.folder) {
       for (const [, loc] of this.#workspaceModules) {
-        const depPkg = PackageUtil.readPackage(loc);
-        globals.push(this.create(depPkg, { main: true, workspace: true, roleRoot: true }));
+        globals.push(this.#create(loc, { main: true, workspace: true, roleRoot: true, parent: mainReq.value }));
       }
     } else {
       // If we have 'withModules' at workspace root
       const root = PackageUtil.readPackage(this.ctx.workspace.path);
       for (const [name, type] of Object.entries(root.travetto?.build?.withModules ?? {})) {
-        const depPkg = PackageUtil.readPackage(PackageUtil.resolvePackagePath(name));
-        globals.push(this.create(depPkg, { main: type === 'main', workspace: true }));
+        globals.push(this.#create(PackageUtil.resolvePackagePath(name),
+          { main: type === 'main', workspace: true, parent: mainReq.value }
+        ));
       }
     }
 
-    return globals.map((x, i) => i === 0 ? x : { ...x, parent: mainReq.value });
-  }
-
-  /**
-   * Is valid dependency for searching
-   */
-  valid({ value: node }: PackageVisitReq<PackageModule>): boolean {
-    return node.workspace || !!node.state.travetto; // Workspace or travetto module
+    return globals;
   }
 
   /**
    * Build a package module
    */
-  create(pkg: Package, { main, workspace, prod = false, roleRoot = false }: CreateOpts = {}): PackageVisitReq<PackageModule> {
-    const sourcePath = PackageUtil.getPackagePath(pkg);
+  #create(sourcePath: string, { main, workspace, prod = false, roleRoot = false, parent }: CreateOpts = {}): Req {
+    const pkg = PackageUtil.readPackage(sourcePath);
     const value = this.#cache[sourcePath] ??= {
       main,
       prod,
@@ -78,24 +81,13 @@ export class PackageModuleVisitor implements PackageVisitor<PackageModule> {
 
     const deps: PackageDepType[] = ['dependencies', ...(value.main ? ['devDependencies'] as const : [])];
     const children = Object.fromEntries(deps.flatMap(x => Object.entries(pkg[x] ?? {})));
-    return { pkg, value, children };
-  }
-
-  /**
-   * Visit dependency
-   */
-  visit({ value: mod, parent }: PackageVisitReq<PackageModule>): void {
-    if (mod.name === this.ctx.main.name) { return; } // Skip root
-    if (parent) {
-      mod.state.parentSet.add(parent.name);
-      parent.state.childSet.add(mod.name);
-    }
+    return { pkg, value, children, parent };
   }
 
   /**
    * Propagate prod, role information through graph
    */
-  async complete(mods: Iterable<PackageModule>): Promise<PackageModule[]> {
+  async #complete(mods: Iterable<PackageModule>): Promise<PackageModule[]> {
     const mapping = new Map([...mods].map(el => [el.name, { parent: new Set(el.state.parentSet), el }]));
 
     // All first-level dependencies should have role filled in (for propagation)
@@ -144,4 +136,40 @@ export class PackageModuleVisitor implements PackageVisitor<PackageModule> {
 
     return [...mods].sort((a, b) => a.name.localeCompare(b.name));
   }
+
+
+  /**
+   * Visit packages with ability to track duplicates
+   */
+  async visit(): Promise<Iterable<PackageModule>> {
+    const seen = new Set<PackageModule>();
+    const queue = [...await this.init()];
+
+    while (queue.length) {
+      const { value: node, parent, children, pkg } = queue.shift()!; // Visit initial set first
+      if (!node || (!node.workspace && !node.state.travetto)) {
+        continue;
+      }
+
+      // Track parentage
+      if (node.name !== this.ctx.main.name && parent) {
+        node.state.parentSet.add(parent.name);
+        parent.state.childSet.add(node.name);
+      }
+
+      if (seen.has(node)) {
+        continue;
+      } else {
+        seen.add(node);
+      }
+
+      const next = Object.entries(children)
+        .map(([n, v]) => PackageUtil.resolveVersionPath(pkg, v) ?? PackageUtil.resolvePackagePath(n))
+        .map(loc => this.#create(loc, { parent: node }));
+
+      queue.push(...next);
+    }
+
+    return await this.#complete(seen);
+  }
 }

package/src/module.ts

@@ -1,7 +1,6 @@
 import fs from 'node:fs/promises';
 
 import { path } from './path';
-import { PackageUtil } from './package';
 import { PackageModuleVisitor } from './dependencies';
 
 import type { ManifestModuleFileType, ManifestModuleRole, ManifestModuleFolderType } from './types/common';
@@ -198,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 PackageUtil.visitPackages(new PackageModuleVisitor(ctx));
+    const pkgs = await new PackageModuleVisitor(ctx).visit();
     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

@@ -4,7 +4,7 @@ import { execSync } from 'node:child_process';
 import { path } from './path';
 import { ManifestFileUtil } from './file';
 
-import { PackagePath, type Package, type PackageVisitor, type PackageWorkspaceEntry } from './types/package';
+import { PackagePath, type Package, type PackageWorkspaceEntry } from './types/package';
 import type { ManifestContext } from './types/context';
 import type { NodePackageManager } from './types/common';
 
@@ -81,38 +81,6 @@ export class PackageUtil {
     return pkg[PackagePath];
   }
 
-  /**
-   * Visit packages with ability to track duplicates
-   */
-  static async visitPackages<T>(visitor: PackageVisitor<T>): Promise<Iterable<T>> {
-    const seen = new Set<T>();
-    const queue = [...await visitor.init()];
-
-    while (queue.length) {
-      const node = queue.shift()!; // Visit initial set first
-
-      if (!visitor.valid(node)) {
-        continue;
-      }
-
-      visitor.visit(node);
-
-      if (seen.has(node.value)) {
-        continue;
-      } else {
-        seen.add(node.value);
-      }
-
-      const children = Object.entries(node.children)
-        .map(([n, v]) => this.readPackage(this.resolveVersionPath(node.pkg, v) ?? this.resolvePackagePath(n)))
-        .map(pkg => ({ ...visitor.create(pkg), parent: node.value }));
-
-      queue.push(...children);
-    }
-
-    return await visitor.complete(seen);
-  }
-
   /**
    * Find workspace values from rootPath
    */

package/src/types/package.ts

@@ -53,23 +53,4 @@ export type Package = {
 
 export type PackageDepType = 'dependencies' | 'devDependencies' | 'optionalDependencies' | 'peerDependencies';
 
-export type PackageVisitReq<T> = {
-  /** Request package */
-  pkg: Package;
-  /** Children to visit */
-  children: Record<string, string>;
-  /** Value */
-  value: T;
-  /** Parent */
-  parent?: T;
-};
-
-export type PackageVisitor<T> = {
-  create(pkg: Package): PackageVisitReq<T>;
-  init(): Promise<Iterable<PackageVisitReq<T>>>;
-  valid(req: PackageVisitReq<T>): boolean;
-  visit(req: PackageVisitReq<T>): void;
-  complete(values: Iterable<T>): Promise<Iterable<T>>;
-};
-
 export type PackageWorkspaceEntry = { name: string, path: string };