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

package/bin/context.js

@@ -2,10 +2,10 @@
 
 /**
  * @typedef {import('../src/types/package').Package & { path:string }} Pkg
- * @typedef {Pkg & { mono: boolean, manager: 'yarn'|'npm', resolve: (file:string) => string}} Workspace
+ * @typedef {Pkg & { mono: boolean, manager: 'yarn'|'npm', resolve: (file:string) => string, stripRoot: (file:string)=>string}} Workspace
  * @typedef {import('../src/types/context').ManifestContext} ManifestContext
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 
@@ -79,6 +79,7 @@ function $resolveWorkspace(base = process.cwd()) {
     type: pkg.type,
     manager: existsSync(path.resolve(pkg.path, 'yarn.lock')) ? 'yarn' : 'npm',
     resolve: createRequire(`${pkg.path}/node_modules`).resolve.bind(null),
+    stripRoot: (full) => full === pkg.path ? '' : full.replace(`${pkg.path}/`, ''),
     mono: !!pkg.workspaces || (!pkg.travetto?.build?.isolated && !!prevPkg)  // Workspaces or nested projects
   };
 }
@@ -86,18 +87,11 @@ function $resolveWorkspace(base = process.cwd()) {
 /**
  * Get Compiler url
  * @param {Workspace} ws
- * @param {string} toolFolder
  */
-function $getCompilerUrl(ws, toolFolder) {
-  const file = path.resolve(ws.path, toolFolder, 'build.compilerUrl');
+function $getCompilerUrl(ws) {
   // eslint-disable-next-line no-bitwise
-  const port = (Math.abs([...file].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
-  const out = `http://localhost:${port}`;
-  if (!existsSync(file)) {
-    mkdirSync(path.dirname(file), { recursive: true });
-    writeFileSync(file, out, 'utf8');
-  }
-  return out;
+  const port = (Math.abs([...ws.path].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
+  return `http://localhost:${port}`;
 }
 
 /**
@@ -156,14 +150,14 @@ export function getManifestContext(folder) {
     },
     build: {
       compilerFolder: build.compilerFolder ?? COMPILER_FOLDER,
-      compilerUrl: build.compilerUrl ?? $getCompilerUrl(workspace, toolFolder),
-      compilerModuleFolder: path.dirname(workspace.resolve('@travetto/compiler/package.json')).replace(`${workspace.path}/`, ''),
+      compilerUrl: build.compilerUrl ?? $getCompilerUrl(workspace),
+      compilerModuleFolder: workspace.stripRoot(path.dirname(workspace.resolve('@travetto/compiler/package.json'))),
       outputFolder: build.outputFolder ?? OUTPUT_FOLDER,
       toolFolder
     },
     main: {
       name: mod.name ?? 'untitled',
-      folder: mod.path === workspace.path ? '' : mod.path.replace(`${workspace.path}/`, ''),
+      folder: workspace.stripRoot(mod.path),
       version: mod.version,
       description: mod.description
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "4.0.0-rc.1",
+  "version": "4.0.0-rc.3",
   "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/runtime.ts

@@ -126,6 +126,13 @@ export const RuntimeContext = build({
   workspaceRelative(...rel: string[]): string {
     return path.resolve(RuntimeIndex.manifest.workspace.path, ...rel);
   },
+  /**
+   * Strip off the workspace path from a file
+   * @param full A full path
+   */
+  stripWorkspacePath(full: string): string {
+    return full === RuntimeIndex.manifest.workspace.path ? '' : full.replace(`${RuntimeIndex.manifest.workspace.path}/`, '');
+  },
   /**
    * Produce a workspace path for tooling, with '@' being replaced by node_module/name folder
    * @param rel The relative path

package/src/types/package.ts

@@ -44,6 +44,7 @@ export type Package = {
     build?: Partial<ManifestContext['build']> & {
       isolated?: boolean;
       withModules?: Record<string, 'main' | true>;
+      watchIgnores?: string[];
     };
   };
   workspaces?: string[];
@@ -53,23 +54,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 };

package/support/transformer.function-metadata.ts

@@ -7,7 +7,6 @@ import {
 
 const MANIFEST_MOD = '@travetto/manifest';
 const MANIFEST_IDX = `${MANIFEST_MOD}/__index__`;
-const ENTRY_POINT = 'support/entry';
 
 const RUNTIME_IDX_IMPORT = `${MANIFEST_MOD}/src/runtime`;
 const RUNTIME_IDX_CLS = 'RuntimeIndex';
@@ -32,9 +31,7 @@ interface MetadataInfo {
 export class RegisterTransformer {
 
   static #valid({ importName: imp }: TransformerState): boolean {
-    return !imp.startsWith(MANIFEST_MOD) ?
-      !imp.includes(ENTRY_POINT) :
-      !(/[/](src|support)[/]/.test(imp) || imp === MANIFEST_IDX);
+    return !imp.startsWith(MANIFEST_MOD) || !(/[/](src|support)[/]/.test(imp) || imp === MANIFEST_IDX);
   }
 
   /**