@travetto/manifest 7.0.0-rc.0 → 7.0.0-rc.1

package/package.json

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

package/src/context.ts

@@ -8,25 +8,25 @@ import type { ManifestContext } from './types/context.ts';
 type Pkg = Package & { path: string };
 
 // eslint-disable-next-line no-bitwise
-const toPort = (pth: string): number => (Math.abs([...pth].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
-const toPosix = (pth: string): string => pth.replaceAll('\\', '/');
+const toPort = (location: string): number => (Math.abs([...location].reduce((a, b) => (a * 33) ^ b.charCodeAt(0), 5381)) % 29000) + 20000;
+const toPosix = (location: string): string => location.replaceAll('\\', '/');
 const readPackage = (file: string): Pkg => ({ ...JSON.parse(readFileSync(file, 'utf8')), path: toPosix(path.dirname(file)) });
 
 /** Find package */
 function findPackage(base: string, pred: (_p?: Pkg) => boolean): Pkg {
   let folder = `${base}/.`;
-  let prev: string;
+  let previous: string;
   let pkg: Pkg | undefined;
   const packages: Pkg[] = [];
 
   do {
     pkg && packages.push(pkg);
-    prev = folder;
+    previous = folder;
     folder = path.dirname(folder);
     const folderPkg = path.resolve(folder, 'package.json');
     pkg = existsSync(folderPkg) ? readPackage(folderPkg) : pkg;
   } while (
-    prev !== folder && // Not at root
+    previous !== folder && // Not at root
     !pred(pkg) && // Matches criteria
     !existsSync(path.resolve(folder, '.git')) // Not at source root
   );

package/src/delta.ts

@@ -15,7 +15,7 @@ const VALID_SOURCE_FOLDERS = new Set<ManifestModuleFolderType>(['bin', 'src', 't
 const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
 const VALID_OUTPUT_TYPE = new Set<ManifestModuleFileType>([...VALID_SOURCE_TYPE, 'typings']);
 
-const TypedObject: { keys<T = unknown, K extends keyof T = keyof T>(o: T): K[] } & ObjectConstructor = Object;
+const TypedObject: { keys<T = unknown, K extends keyof T = keyof T>(item: T): K[] } & ObjectConstructor = Object;
 
 /**
  * Produce delta for the manifest
@@ -38,47 +38,47 @@ export class ManifestDeltaUtil {
     const root = path.resolve(ctx.workspace.path, ctx.build.outputFolder, left.outputFolder);
     const right = new Set(
       (await ManifestModuleUtil.scanFolder(ctx, root, left.main))
-        .filter(x => {
-          const type = ManifestModuleUtil.getFileType(x);
+        .filter(file => {
+          const type = ManifestModuleUtil.getFileType(file);
           return VALID_SOURCE_TYPE.has(type);
         })
-        .map(x => ManifestModuleUtil.withoutSourceExtension(x.replace(`${root}/`, '')))
+        .map(file => ManifestModuleUtil.withoutSourceExtension(file.replace(`${root}/`, '')))
     );
 
-    for (const el of Object.keys(left.files)) {
-      const output = ManifestModuleUtil.withOutputExtension(`${outputFolder}/${left.outputFolder}/${el}`);
-      const [, , leftTs] = left.files[el];
+    for (const file of Object.keys(left.files)) {
+      const output = ManifestModuleUtil.withOutputExtension(`${outputFolder}/${left.outputFolder}/${file}`);
+      const [, , leftTimestamp] = left.files[file];
       const stat = await fs.stat(output).catch(() => undefined);
-      right.delete(ManifestModuleUtil.withoutSourceExtension(el));
+      right.delete(ManifestModuleUtil.withoutSourceExtension(file));
 
       if (!stat) {
-        add(el, 'added');
+        add(file, 'added');
       } else {
-        const rightTs = this.#getNewest(stat);
-        if (leftTs > rightTs) {
-          add(el, 'changed');
+        const rightTimestamp = this.#getNewest(stat);
+        if (leftTimestamp > rightTimestamp) {
+          add(file, 'changed');
         }
       }
     }
     // Deleted
-    for (const el of right) {
-      add(el, 'removed');
+    for (const file of right) {
+      add(file, 'removed');
     }
     return out;
   }
 
   /**
    * Collapse all files in a module
-   * @param {ManifestModule} m
+   * @param {ManifestModule} mod
    * @returns {}
    */
-  static #flattenModuleFiles(m: ManifestModule): Record<string, ManifestModuleFile> {
+  static #flattenModuleFiles(mod: ManifestModule): Record<string, ManifestModuleFile> {
     const out: Record<string, ManifestModuleFile> = {};
-    for (const key of TypedObject.keys(m.files)) {
+    for (const key of TypedObject.keys(mod.files)) {
       if (!VALID_SOURCE_FOLDERS.has(key)) {
         continue;
       }
-      for (const [name, type, date] of m.files?.[key] ?? []) {
+      for (const [name, type, date] of mod.files?.[key] ?? []) {
         if (VALID_OUTPUT_TYPE.has(type)) {
           out[name] = [name, type, date];
         }
@@ -93,14 +93,14 @@ export class ManifestDeltaUtil {
   static async produceDelta(manifest: ManifestRoot): Promise<DeltaEvent[]> {
     const deltaLeft = Object.fromEntries(
       Object.values(manifest.modules)
-        .map(m => [m.name, { ...m, files: this.#flattenModuleFiles(m) }])
+        .map(mod => [mod.name, { ...mod, files: this.#flattenModuleFiles(mod) }])
     );
 
     const out: DeltaEvent[] = [];
     const outputFolder = path.resolve(manifest.workspace.path, manifest.build.outputFolder);
 
-    for (const lMod of Object.values(deltaLeft)) {
-      out.push(...await this.#deltaModules(manifest, outputFolder, lMod));
+    for (const leftMod of Object.values(deltaLeft)) {
+      out.push(...await this.#deltaModules(manifest, outputFolder, leftMod));
     }
 
     return out;

package/src/dependencies.ts

@@ -1,13 +1,13 @@
 import { PackageUtil } from './package.ts';
 import { path } from './path.ts';
 
-import type { Package, PackageDepType } from './types/package.ts';
+import type { Package, PackageDependencyType } from './types/package.ts';
 import type { ManifestContext } from './types/context.ts';
 import type { PackageModule } from './types/manifest.ts';
 
 type CreateOpts = Partial<Pick<PackageModule, 'main' | 'workspace' | 'prod'>> & { roleRoot?: boolean, parent?: PackageModule };
 
-type Req = {
+type VisitableNode = {
   /** Request package */
   pkg: Package;
   /** Children to visit */
@@ -24,7 +24,8 @@ type Req = {
 export class PackageModuleVisitor {
 
   static async visit(ctx: ManifestContext): Promise<Iterable<PackageModule>> {
-    const visitor = new PackageModuleVisitor(ctx, Object.fromEntries((await PackageUtil.resolveWorkspaces(ctx)).map(x => [x.name, x.path])));
+    const visitor = new PackageModuleVisitor(ctx, Object.fromEntries((await PackageUtil.resolveWorkspaces(ctx))
+      .map(workspace => [workspace.name, workspace.path])));
     return visitor.visit();
   }
 
@@ -42,7 +43,7 @@ export class PackageModuleVisitor {
   /**
    * Build a package module
    */
-  #create(sourcePath: string, { main, workspace, prod = false, roleRoot = false, parent }: CreateOpts = {}): Req {
+  #create(sourcePath: string, { main, workspace, prod = false, roleRoot = false, parent }: CreateOpts = {}): VisitableNode {
     const pkg = PackageUtil.readPackage(sourcePath);
     const value = this.#cache[sourcePath] ??= {
       main,
@@ -55,31 +56,31 @@ export class PackageModuleVisitor {
       outputFolder: `node_modules/${pkg.name}`,
       state: {
         childSet: new Set(), parentSet: new Set(), roleSet: new Set(), roleRoot,
-        travetto: pkg.travetto, prodDeps: new Set(Object.keys(pkg.dependencies ?? {}))
+        travetto: pkg.travetto, prodDependencies: new Set(Object.keys(pkg.dependencies ?? {}))
       }
     };
 
-    const deps: PackageDepType[] = ['dependencies', ...(value.main ? ['devDependencies'] as const : [])];
-    const children = Object.fromEntries(deps.flatMap(x => Object.entries(pkg[x] ?? {})));
+    const dependencies: PackageDependencyType[] = ['dependencies', ...(value.main ? ['devDependencies'] as const : [])];
+    const children = Object.fromEntries(dependencies.flatMap(dependency => Object.entries(pkg[dependency] ?? {})));
     return { pkg, value, children, parent };
   }
 
   /**
    * Get monorepo root includes
    */
-  #getMonoRootIncludes(parent: Req): Req[] {
+  #getMonoRootIncludes(parent: VisitableNode): VisitableNode[] {
     if (!(this.#ctx.workspace.mono && !this.#ctx.main.folder)) { // If not mono root, bail
       return [];
     }
 
     return Object.values(this.#workspaceModules)
-      .map(loc => this.#create(loc, { main: true, workspace: true, roleRoot: true, parent: parent.value }));
+      .map(folder => this.#create(folder, { main: true, workspace: true, roleRoot: true, parent: parent.value }));
   }
 
   /**
    * Determine default includes
    */
-  #getIncludes(parent: Req): Req[] {
+  #getIncludes(parent: VisitableNode): VisitableNode[] {
     if (this.#ctx.workspace.mono && !this.#ctx.main.folder) { // If mono and not at mono root, bail
       return [];
     }
@@ -91,8 +92,8 @@ export class PackageModuleVisitor {
       );
     } else {
       return Object.values(this.#workspaceModules)
-        .filter((loc) => PackageUtil.readPackage(loc).travetto?.workspaceInclude)
-        .map(loc => this.#create(loc, { workspace: true, parent: parent.value }));
+        .filter((folder) => PackageUtil.readPackage(folder).travetto?.workspaceInclude)
+        .map(folder => this.#create(folder, { workspace: true, parent: parent.value }));
     }
   }
 
@@ -100,50 +101,50 @@ export class PackageModuleVisitor {
    * Propagate prod, role information through graph
    */
   async #complete(mods: Iterable<PackageModule>): Promise<PackageModule[]> {
-    const mapping = new Map([...mods].map(el => [el.name, { parent: new Set(el.state.parentSet), el }]));
+    const mapping = new Map([...mods].map(item => [item.name, { parent: new Set(item.state.parentSet), item }]));
 
     // All first-level dependencies should have role filled in (for propagation)
-    for (const dep of [...mods].filter(x => x.state.roleRoot)) {
-      dep.state.roleSet.clear(); // Ensure the roleRoot is empty
-      for (const c of dep.state.childSet) { // Visit children
-        const cDep = mapping.get(c)!.el;
-        if (cDep.state.roleRoot) { continue; }
+    for (const dependency of [...mods].filter(mod => mod.state.roleRoot)) {
+      dependency.state.roleSet.clear(); // Ensure the roleRoot is empty
+      for (const child of dependency.state.childSet) { // Visit children
+        const childDependency = mapping.get(child)!.item;
+        if (childDependency.state.roleRoot) { continue; }
         // Set roles for all top level modules
-        cDep.state.roleSet = new Set(cDep.state.travetto?.roles ?? ['std']);
+        childDependency.state.roleSet = new Set(childDependency.state.travetto?.roles ?? ['std']);
       }
     }
 
     // Visit all nodes
     while (mapping.size > 0) {
-      const toProcess = [...mapping.values()].filter(x => x.parent.size === 0);
+      const toProcess = [...mapping.values()].filter(item => item.parent.size === 0);
       if (!toProcess.length) {
         throw new Error(`We have reached a cycle for ${[...mapping.keys()]}`);
       }
       // Propagate to children
-      for (const { el } of toProcess) {
-        for (const c of el.state.childSet) {
-          const child = mapping.get(c);
+      for (const { item } of toProcess) {
+        for (const childName of item.state.childSet) {
+          const child = mapping.get(childName);
           if (!child) { continue; }
-          child.parent.delete(el.name);
+          child.parent.delete(item.name);
           // Propagate roles from parent to child
-          if (!child.el.state.roleRoot) {
-            for (const role of el.state.roleSet) {
-              child.el.state.roleSet.add(role);
+          if (!child.item.state.roleRoot) {
+            for (const role of item.state.roleSet) {
+              child.item.state.roleSet.add(role);
             }
           }
           // Allow prod to trickle down as needed
-          child.el.prod ||= (el.prod && el.state.prodDeps.has(c));
+          child.item.prod ||= (item.prod && item.state.prodDependencies.has(childName));
         }
       }
       // Remove from mapping
-      for (const { el } of toProcess) {
-        mapping.delete(el.name);
+      for (const { item } of toProcess) {
+        mapping.delete(item.name);
       }
     }
 
     // Mark as standard at the end
-    for (const dep of [...mods].filter(x => x.state.roleRoot)) {
-      dep.state.roleSet = new Set(['std']);
+    for (const dependency of [...mods].filter(mod => mod.state.roleRoot)) {
+      dependency.state.roleSet = new Set(['std']);
     }
 
     return [...mods].toSorted((a, b) => a.name.localeCompare(b.name));
@@ -154,12 +155,12 @@ export class PackageModuleVisitor {
    */
   async visit(): Promise<Iterable<PackageModule>> {
     const seen = new Set<PackageModule>();
-    const mainReq = this.#create(this.#mainSourcePath, { main: true, workspace: true, roleRoot: true, prod: true });
+    const mainRequire = this.#create(this.#mainSourcePath, { main: true, workspace: true, roleRoot: true, prod: true });
 
     const queue = [
-      mainReq,
-      ...this.#getMonoRootIncludes(mainReq),
-      ...this.#getIncludes(mainReq)
+      mainRequire,
+      ...this.#getMonoRootIncludes(mainRequire),
+      ...this.#getIncludes(mainRequire)
     ];
 
     while (queue.length) {
@@ -181,8 +182,8 @@ export class PackageModuleVisitor {
       }
 
       const next = Object.entries(children)
-        .map(([n, v]) => PackageUtil.resolveVersionPath(pkg, v) ?? PackageUtil.resolvePackagePath(n))
-        .map(loc => this.#create(loc, { parent: node }));
+        .map(([name, location]) => PackageUtil.resolveVersionPath(pkg, location) ?? PackageUtil.resolvePackagePath(name))
+        .map(location => this.#create(location, { parent: node }));
 
       queue.push(...next);
     }

package/src/manifest-index.ts

@@ -7,7 +7,7 @@ import { ManifestUtil } from './util.ts';
 import type { ManifestModule, ManifestRoot, ManifestModuleFile, IndexedModule, IndexedFile, FindConfig } from './types/manifest.ts';
 
 const TypedObject: {
-  keys<T = unknown, K extends keyof T = keyof T>(o: T): K[];
+  keys<T = unknown, K extends keyof T = keyof T>(item: T): K[];
   fromEntries<K extends string | symbol, V>(items: ([K, V] | readonly [K, V])[]): Record<K, V>;
   entries<K extends Record<symbol | string, unknown>>(record: K): [keyof K, K[keyof K]][];
 } & ObjectConstructor = Object;
@@ -56,19 +56,19 @@ export class ManifestIndex {
     this.init(`${this.outputRoot}/node_modules/${module}`);
   }
 
-  #moduleFiles(m: ManifestModule, files: ManifestModuleFile[]): IndexedFile[] {
-    return files.map(([f, type, _ts, role = 'std']) => {
+  #moduleFiles(mod: ManifestModule, files: ManifestModuleFile[]): IndexedFile[] {
+    return files.map(([file, type, _ts, role = 'std']) => {
       const isSource = type === 'ts' || type === 'js';
-      const sourceFile = path.resolve(this.#manifest.workspace.path, m.sourceFolder, f);
-      const js = isSource ? ManifestModuleUtil.withOutputExtension(f) : f;
-      const outputFile = this.#resolveOutput(m.outputFolder, js);
-      const modImport = `${m.name}/${f}`;
-      let id = `${m.name}:${f}`;
+      const sourceFile = path.resolve(this.#manifest.workspace.path, mod.sourceFolder, file);
+      const js = isSource ? ManifestModuleUtil.withOutputExtension(file) : file;
+      const outputFile = this.#resolveOutput(mod.outputFolder, js);
+      const modImport = `${mod.name}/${file}`;
+      let id = `${mod.name}:${file}`;
       if (isSource) {
         id = ManifestModuleUtil.withoutSourceExtension(id);
       }
 
-      return { id, type, sourceFile, outputFile, import: modImport, role, relativeFile: f, module: m.name };
+      return { id, type, sourceFile, outputFile, import: modImport, role, relativeFile: file, module: mod.name };
     });
   }
 
@@ -82,13 +82,13 @@ export class ManifestIndex {
     this.#arbitraryLookup = undefined;
 
     this.#modules = Object.values(this.#manifest.modules)
-      .map(m => ({
-        ...m,
-        outputPath: this.#resolveOutput(m.outputFolder),
-        sourcePath: path.resolve(this.#manifest.workspace.path, m.sourceFolder),
+      .map(mod => ({
+        ...mod,
+        outputPath: this.#resolveOutput(mod.outputFolder),
+        sourcePath: path.resolve(this.#manifest.workspace.path, mod.sourceFolder),
         children: new Set(),
         files: TypedObject.fromEntries(
-          TypedObject.entries(m.files).map(([folder, files]) => [folder, this.#moduleFiles(m, files ?? [])])
+          TypedObject.entries(mod.files).map(([folder, files]) => [folder, this.#moduleFiles(mod, files ?? [])])
         )
       }));
 
@@ -103,12 +103,12 @@ export class ManifestIndex {
         }
       }
     }
-    this.#modulesByName = Object.fromEntries(this.#modules.map(x => [x.name, x]));
+    this.#modulesByName = Object.fromEntries(this.#modules.map(mod => [mod.name, mod]));
 
     // Store child information
     for (const mod of this.#modules) {
-      for (const p of mod.parents) {
-        this.#modulesByName[p]?.children.add(mod.name);
+      for (const parent of mod.parents) {
+        this.#modulesByName[parent]?.children.add(mod.name);
       }
     }
   }
@@ -125,7 +125,7 @@ export class ManifestIndex {
    * @returns
    */
   getWorkspaceModules(): IndexedModule[] {
-    return this.#modules.filter(x => x.workspace);
+    return this.#modules.filter(mod => mod.workspace);
   }
 
   /**
@@ -134,9 +134,9 @@ export class ManifestIndex {
    */
   find(config: FindConfig): IndexedFile[] {
     const searchSpace: IndexedFile[] = [];
-    for (const m of this.#modules) {
-      if (config.module?.(m) ?? true) {
-        for (const [folder, files] of TypedObject.entries(m.files)) {
+    for (const mod of this.#modules) {
+      if (config.module?.(mod) ?? true) {
+        for (const [folder, files] of TypedObject.entries(mod.files)) {
           if (config.folder?.(folder) ?? true) {
             for (const file of files) {
               if (
@@ -206,14 +206,14 @@ export class ManifestIndex {
    */
   getModuleList(mode: 'workspace' | 'all', exprList: string = ''): Set<string> {
     const allMods = Object.keys(this.#manifest.modules);
-    const active = new Set<string>(mode === 'workspace' ? this.getWorkspaceModules().map(x => x.name) : allMods);
+    const active = new Set<string>(mode === 'workspace' ? this.getWorkspaceModules().map(item => item.name) : allMods);
 
     for (const expr of exprList.split(/,/g)) {
-      const [, neg, mod] = expr.trim().match(/(-|[+])?([^+\- ]{1,150})$/) ?? [];
+      const [, negative, mod] = expr.trim().match(/(-|[+])?([^+\- ]{1,150})$/) ?? [];
       if (mod) {
         const pattern = new RegExp(`^${mod.replace(/[*]/g, '.*')}$`);
-        for (const m of allMods.filter(x => pattern.test(x))) {
-          active[neg ? 'delete' : 'add'](m);
+        for (const moduleName of allMods.filter(item => pattern.test(item))) {
+          active[negative ? 'delete' : 'add'](moduleName);
         }
       }
     }
@@ -248,7 +248,7 @@ export class ManifestIndex {
     const base = this.#manifest.workspace.path;
     const lookup = this.#arbitraryLookup ??= ManifestUtil.lookupTrie(
       Object.values(this.#manifest.modules),
-      x => x.sourceFolder.split('/'),
+      mod => mod.sourceFolder.split('/'),
       sub =>
         !existsSync(path.resolve(base, ...sub, 'package.json')) &&
         !existsSync(path.resolve(base, ...sub, '.git'))

package/src/module.ts

@@ -18,8 +18,8 @@ const EXT_MAPPING: Record<string, ManifestModuleFileType> = {
 };
 
 const INDEX_FILES = new Set(
-  ['__index__', '__index', 'index', 'jsx-runtime'].flatMap(f =>
-    ['ts', 'tsx', 'js'].map(ext => `${f}.${ext}`)
+  ['__index__', '__index', 'index', 'jsx-runtime'].flatMap(file =>
+    ['ts', 'tsx', 'js'].map(ext => `${file}.${ext}`)
   )
 );
 
@@ -37,16 +37,16 @@ const SUPPORT_FILE_MAP: Record<string, ManifestModuleRole> = {
   build: 'build'
 };
 
-const SUPPORT_FILE_RE = new RegExp(`^support[/](?<name>${Object.keys(SUPPORT_FILE_MAP).join('|')})[./]`);
+const SUPPORT_FILE_REGEX = new RegExp(`^support[/](?<name>${Object.keys(SUPPORT_FILE_MAP).join('|')})[./]`);
 
 export class ManifestModuleUtil {
 
   static TYPINGS_EXT = '.d.ts';
   static OUTPUT_EXT = '.js';
   static SOURCE_DEF_EXT = '.ts';
-  static SOURCE_EXT_RE = /[.][cm]?[tj]sx?$/;
-  static TYPINGS_EXT_RE = /[.]d[.][cm]?ts$/;
-  static TYPINGS_WITH_MAP_EXT_RE = /[.]d[.][cm]?ts([.]map)?$/;
+  static SOURCE_EXT_REGEX = /[.][cm]?[tj]sx?$/;
+  static TYPINGS_EXT_REGEX = /[.]d[.][cm]?ts$/;
+  static TYPINGS_WITH_MAP_EXT_REGEX = /[.]d[.][cm]?ts([.]map)?$/;
 
   static #scanCache: Record<string, string[]> = {};
 
@@ -58,7 +58,7 @@ export class ManifestModuleUtil {
    * Replace a source file's extension with a given value
    */
   static #pathToExtension(sourceFile: string, ext: string): string {
-    return sourceFile.replace(ManifestModuleUtil.SOURCE_EXT_RE, ext);
+    return sourceFile.replace(ManifestModuleUtil.SOURCE_EXT_REGEX, ext);
   }
 
   /**
@@ -146,7 +146,7 @@ export class ManifestModuleUtil {
    * Get file type for a file name
    */
   static getFileRole(moduleFile: string): ManifestModuleRole | undefined {
-    const matched = SUPPORT_FILE_MAP[moduleFile.match(SUPPORT_FILE_RE)?.groups?.name ?? ''];
+    const matched = SUPPORT_FILE_MAP[moduleFile.match(SUPPORT_FILE_REGEX)?.groups?.name ?? ''];
     if (matched) {
       return matched;
     } else if (moduleFile.startsWith('test/')) {
@@ -199,9 +199,9 @@ export class ManifestModuleUtil {
    */
   static async transformFile(moduleFile: string, full: string): Promise<ManifestModuleFile> {
     const updated = this.#getNewest(await fs.stat(full).catch(() => ({ mtimeMs: 0, ctimeMs: 0 })));
-    const res: ManifestModuleFile = [moduleFile, this.getFileType(moduleFile), updated];
+    const moduleFileTuple: ManifestModuleFile = [moduleFile, this.getFileType(moduleFile), updated];
     const role = this.getFileRole(moduleFile);
-    return role ? [...res, role] : res;
+    return role ? [...moduleFileTuple, role] : moduleFileTuple;
   }
 
   /**
@@ -234,8 +234,8 @@ export class ManifestModuleUtil {
    */
   static async produceModules(ctx: ManifestContext): Promise<Record<string, ManifestModule>> {
     const pkgs = await PackageModuleVisitor.visit(ctx);
-    const modules = await Promise.all([...pkgs].map(x => this.describeModule(ctx, x)));
-    return Object.fromEntries(modules.map(m => [m.name, m]));
+    const modules = await Promise.all([...pkgs].map(mod => this.describeModule(ctx, mod)));
+    return Object.fromEntries(modules.map(mod => [mod.name, mod]));
   }
 
   /**

package/src/package.ts

@@ -18,9 +18,9 @@ export class PackageUtil {
   static #cache: Record<string, Package> = {};
   static #workspaces: Record<string, PackageWorkspaceEntry[]> = {};
 
-  static #exec<T>(cwd: string, cmd: string): Promise<T> {
+  static #exec<T>(workingDirectory: string, cmd: string): Promise<T> {
     const env = { PATH: process.env.PATH, NODE_PATH: process.env.NODE_PATH };
-    const text = execSync(cmd, { cwd, encoding: 'utf8', env, stdio: ['pipe', 'pipe'] }).toString().trim();
+    const text = execSync(cmd, { cwd: workingDirectory, encoding: 'utf8', env, stdio: ['pipe', 'pipe'] }).toString().trim();
     return JSON.parse(text);
   }
 
@@ -55,13 +55,13 @@ export class PackageUtil {
         return path.join(resolved.split(name)[0], name);
       } catch { // When import lookup fails
         let folder = root ?? process.cwd();
-        let prev = '';
-        while (folder !== prev) {
+        let previous = '';
+        while (folder !== previous) {
           const pkg = path.resolve(folder, 'node_modules', name, 'package.json');
           if (existsSync(pkg)) {
             return pkg;
           }
-          prev = folder;
+          previous = folder;
           folder = path.dirname(folder);
         }
       }
@@ -106,7 +106,7 @@ export class PackageUtil {
           case 'yarn':
           case 'npm': {
             const workspaces = await this.#exec<{ location: string, name: string }[]>(rootPath, 'npm query .workspace');
-            out = workspaces.map(d => ({ path: path.resolve(ctx.workspace.path, d.location), name: d.name }));
+            out = workspaces.map(mod => ({ path: path.resolve(ctx.workspace.path, mod.location), name: mod.name }));
             break;
           }
         }

package/src/path.ts

@@ -29,7 +29,7 @@ export const path: posix.PlatformPath & {
     isAbsolute: (file) => native.isAbsolute(toPosix(file)),
     normalize: (file) => toPosix(native.normalize(toPosix(file))),
     parse: (file) => native.parse(toPosix(file)),
-    format: (obj) => toPosix(native.format(obj)),
+    format: (value) => toPosix(native.format(value)),
     toNamespacedPath: (file) => toPosix(native.toNamespacedPath(toPosix(file))),
   } : {
     relative: (from, to) => posix.relative(toPosix(from), toPosix(to)),
@@ -38,7 +38,7 @@ export const path: posix.PlatformPath & {
     isAbsolute: file => posix.isAbsolute(toPosix(file)),
     normalize: file => posix.normalize(toPosix(file)),
     parse: file => posix.parse(toPosix(file)),
-    format: obj => posix.format(obj),
+    format: value => posix.format(value),
     toNamespacedPath: file => toPosix(file),
   }
 };

package/src/types/manifest.ts

@@ -70,7 +70,7 @@ export type PackageModule = Omit<ManifestModule, 'files' | 'parents' | 'roles'>
     /** Travetto package info */
     travetto?: Package['travetto'];
     /** Prod dependencies */
-    prodDeps: Set<string>;
+    prodDependencies: Set<string>;
     /** Set of parent package names */
     parentSet: Set<string>;
     /** Set of child package names */

package/src/types/package.ts

@@ -55,6 +55,6 @@ export type Package = {
   publishConfig?: { access?: 'restricted' | 'public' };
 };
 
-export type PackageDepType = 'dependencies' | 'devDependencies' | 'optionalDependencies' | 'peerDependencies';
+export type PackageDependencyType = 'dependencies' | 'devDependencies' | 'optionalDependencies' | 'peerDependencies';
 
 export type PackageWorkspaceEntry = { name: string, path: string };

package/src/util.ts

@@ -36,8 +36,8 @@ export class ManifestUtil {
    * 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)]);
+    const prodModules = Object.values(manifest.modules).filter(mod => mod.prod);
+    const prodModNames = new Set([...prodModules.map(mod => mod.name)]);
     return {
       generated: manifest.generated,
       workspace: manifest.workspace,
@@ -48,8 +48,8 @@ export class ManifestUtil {
       },
       main: manifest.main,
       modules: Object.fromEntries(
-        prodModules.map(m => [m.name, Object.assign(m, {
-          parents: m.parents.filter(x => prodModNames.has(x))
+        prodModules.map(mod => [mod.name, Object.assign(mod, {
+          parents: mod.parents.filter(parent => prodModNames.has(parent))
         })])
       ),
     };
@@ -136,7 +136,7 @@ export class ManifestUtil {
    * Efficient lookup for path-based graphs
    */
   static lookupTrie<T>(
-    inputs: T[], getPath: (v: T) => string[], validateUnknown?: (pth: string[]) => boolean
+    inputs: T[], getPath: (value: T) => string[], validateUnknown?: (pth: string[]) => boolean
   ): (pth: string[]) => T | undefined {
     type TrieNode = { value?: T, subs: Record<string, TrieNode> };
     const root: TrieNode = { subs: {} };