@travetto/manifest 7.0.2 → 7.0.3

package/README.md

@@ -60,8 +60,6 @@ By default, all paths within the framework are assumed to be in a POSIX style, a
   },
   "build": {
     "compilerUrl": "http://127.0.0.1:26803",
-    "compilerModuleFolder": "module/compiler",
-    "compilerFolder": ".trv/compiler",
     "outputFolder": ".trv/output",
     "toolFolder": ".trv/tool",
     "typesFolder": ".trv/types"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "7.0.2",
+  "version": "7.0.3",
   "type": "module",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
@@ -18,9 +18,7 @@
   },
   "files": [
     "__index__.ts",
-    "bin",
-    "src",
-    "support"
+    "src"
   ],
   "main": "__index__.ts",
   "engines": {

package/src/context.ts

@@ -50,7 +50,7 @@ export function getManifestContext(root: string = process.cwd()): ManifestContex
   const resolve = createRequire(path.resolve(workspace.path, 'node_modules')).resolve.bind(null);
   const wsPrefix = `${workspace.path}/`;
   const moduleName = process.env.TRV_MODULE === workspace.name ? workspace.path : process.env.TRV_MODULE;
-  const modPkg = (!!workspace.workspaces && moduleName) ?
+  const modulePkg = (!!workspace.workspaces && moduleName) ?
     readPackage(resolve(`${moduleName}/package.json`)) :
     findPackage(root, pkg => !!pkg) ?? workspace;
 
@@ -69,17 +69,15 @@ export function getManifestContext(root: string = process.cwd()): ManifestContex
     },
     build: {
       compilerUrl: build.compilerUrl ?? `http://localhost:${toPort(wsPrefix)}`,
-      compilerModuleFolder: toPosix(path.dirname(resolve('@travetto/compiler/package.json'))).replace(wsPrefix, ''),
-      compilerFolder: toPosix(build.compilerFolder ?? '.trv/compiler'),
       outputFolder: toPosix(build.outputFolder ?? '.trv/output'),
       toolFolder: toPosix(build.toolFolder ?? '.trv/tool'),
       typesFolder: toPosix(build.typesFolder ?? '.trv/types')
     },
     main: {
-      name: modPkg.name ?? 'untitled',
-      folder: modPkg.path.replace(wsPrefix, ''),
-      version: modPkg.version,
-      description: modPkg.description
+      name: modulePkg.name ?? 'untitled',
+      folder: modulePkg.path.replace(wsPrefix, ''),
+      version: modulePkg.version,
+      description: modulePkg.description
     }
   };
 }

package/src/delta.ts

@@ -11,7 +11,7 @@ type DeltaEventType = ChangeEventType | 'missing' | 'dirty';
 type DeltaModule = ManifestModuleCore & { files: Record<string, ManifestModuleFile> };
 export type DeltaEvent = { file: string, type: DeltaEventType, module: string, sourceFile: string };
 
-const VALID_SOURCE_FOLDERS = new Set<ManifestModuleFolderType>(['bin', 'src', 'test', 'support', '$index', '$package', 'doc']);
+const VALID_SOURCE_FOLDERS = new Set<ManifestModuleFolderType>(['bin', 'src', 'test', 'support', '$index', '$transformer', '$package', 'doc']);
 const VALID_SOURCE_TYPE = new Set<ManifestModuleFileType>(['js', 'ts', 'package-json']);
 const VALID_OUTPUT_TYPE = new Set<ManifestModuleFileType>([...VALID_SOURCE_TYPE, 'typings']);
 
@@ -69,16 +69,16 @@ export class ManifestDeltaUtil {
 
   /**
    * Collapse all files in a module
-   * @param {ManifestModule} mod
+   * @param {ManifestModule} module
    * @returns {}
    */
-  static #flattenModuleFiles(mod: ManifestModule): Record<string, ManifestModuleFile> {
+  static #flattenModuleFiles(module: ManifestModule): Record<string, ManifestModuleFile> {
     const out: Record<string, ManifestModuleFile> = {};
-    for (const key of TypedObject.keys(mod.files)) {
+    for (const key of TypedObject.keys(module.files)) {
       if (!VALID_SOURCE_FOLDERS.has(key)) {
         continue;
       }
-      for (const [name, type, date] of mod.files?.[key] ?? []) {
+      for (const [name, type, date] of module.files?.[key] ?? []) {
         if (VALID_OUTPUT_TYPE.has(type)) {
           out[name] = [name, type, date];
         }
@@ -93,7 +93,7 @@ export class ManifestDeltaUtil {
   static async produceDelta(manifest: ManifestRoot): Promise<DeltaEvent[]> {
     const deltaLeft = Object.fromEntries(
       Object.values(manifest.modules)
-        .map(mod => [mod.name, { ...mod, files: this.#flattenModuleFiles(mod) }])
+        .map(module => [module.name, { ...module, files: this.#flattenModuleFiles(module) }])
     );
 
     const out: DeltaEvent[] = [];

package/src/dependencies.ts

@@ -100,11 +100,11 @@ export class PackageModuleVisitor {
   /**
    * Propagate prod, role information through graph
    */
-  async #complete(mods: Iterable<PackageModule>): Promise<PackageModule[]> {
-    const mapping = new Map([...mods].map(item => [item.name, { parent: new Set(item.state.parentSet), item }]));
+  async #complete(modules: Iterable<PackageModule>): Promise<PackageModule[]> {
+    const mapping = new Map([...modules].map(item => [item.name, { parent: new Set(item.state.parentSet), item }]));
 
     // All first-level dependencies should have role filled in (for propagation)
-    for (const dependency of [...mods].filter(mod => mod.state.roleRoot)) {
+    for (const dependency of [...modules].filter(module => module.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;
@@ -143,11 +143,11 @@ export class PackageModuleVisitor {
     }
 
     // Mark as standard at the end
-    for (const dependency of [...mods].filter(mod => mod.state.roleRoot)) {
-      dependency.state.roleSet = new Set(['std']);
+    for (const dependency of [...modules].filter(module => module.state.roleRoot)) {
+      dependency.state.roleSet = new Set(['std', ...dependency.state.travetto?.roles ?? []]);
     }
 
-    return [...mods].toSorted((a, b) => a.name.localeCompare(b.name));
+    return [...modules].toSorted((a, b) => a.name.localeCompare(b.name));
   }
 
   /**

package/src/manifest-index.ts

@@ -26,7 +26,7 @@ export class ManifestIndex {
   #sourceToEntry = new Map<string, IndexedFile>();
   #importToEntry = new Map<string, IndexedFile>();
 
-  constructor(manifest: string = process.env.TRV_MANIFEST!) {
+  constructor(manifest: string | ManifestRoot = process.env.TRV_MANIFEST!) {
     this.init(manifest || path.resolve(import.meta.dirname, './manifest.json'));
   }
 
@@ -42,8 +42,8 @@ export class ManifestIndex {
     return this.#outputRoot;
   }
 
-  init(manifestInput: string): void {
-    this.#manifest = ManifestUtil.readManifestSync(manifestInput);
+  init(manifestInput: string | ManifestRoot): void {
+    this.#manifest = typeof manifestInput === 'string' ? ManifestUtil.readManifestSync(manifestInput) : manifestInput;
     this.#outputRoot = path.resolve(this.#manifest.workspace.path, this.#manifest.build.outputFolder);
     this.#index();
   }
@@ -56,19 +56,19 @@ export class ManifestIndex {
     this.init(`${this.outputRoot}/node_modules/${module}`);
   }
 
-  #moduleFiles(mod: ManifestModule, files: ManifestModuleFile[]): IndexedFile[] {
+  #moduleFiles(module: 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, mod.sourceFolder, file);
+      const sourceFile = path.resolve(this.#manifest.workspace.path, module.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}`;
+      const outputFile = this.#resolveOutput(module.outputFolder, js);
+      const moduleImport = `${module.name}/${file}`;
+      let id = `${module.name}:${file}`;
       if (isSource) {
         id = ManifestModuleUtil.withoutSourceExtension(id);
       }
 
-      return { id, type, sourceFile, outputFile, import: modImport, role, relativeFile: file, module: mod.name };
+      return { id, type, sourceFile, outputFile, import: moduleImport, role, relativeFile: file, module: module.name };
     });
   }
 
@@ -82,18 +82,18 @@ export class ManifestIndex {
     this.#arbitraryLookup = undefined;
 
     this.#modules = Object.values(this.#manifest.modules)
-      .map(mod => ({
-        ...mod,
-        outputPath: this.#resolveOutput(mod.outputFolder),
-        sourcePath: path.resolve(this.#manifest.workspace.path, mod.sourceFolder),
+      .map(module => ({
+        ...module,
+        outputPath: this.#resolveOutput(module.outputFolder),
+        sourcePath: path.resolve(this.#manifest.workspace.path, module.sourceFolder),
         children: new Set(),
         files: TypedObject.fromEntries(
-          TypedObject.entries(mod.files).map(([folder, files]) => [folder, this.#moduleFiles(mod, files ?? [])])
+          TypedObject.entries(module.files).map(([folder, files]) => [folder, this.#moduleFiles(module, files ?? [])])
         )
       }));
 
-    for (const mod of this.#modules) {
-      for (const files of Object.values(mod.files ?? {})) {
+    for (const module of this.#modules) {
+      for (const files of Object.values(module.files ?? {})) {
         for (const entry of files) {
           this.#outputToEntry.set(entry.outputFile, entry);
           this.#sourceToEntry.set(entry.sourceFile, entry);
@@ -103,12 +103,12 @@ export class ManifestIndex {
         }
       }
     }
-    this.#modulesByName = Object.fromEntries(this.#modules.map(mod => [mod.name, mod]));
+    this.#modulesByName = Object.fromEntries(this.#modules.map(module => [module.name, module]));
 
     // Store child information
-    for (const mod of this.#modules) {
-      for (const parent of mod.parents) {
-        this.#modulesByName[parent]?.children.add(mod.name);
+    for (const module of this.#modules) {
+      for (const parent of module.parents) {
+        this.#modulesByName[parent]?.children.add(module.name);
       }
     }
   }
@@ -125,7 +125,7 @@ export class ManifestIndex {
    * @returns
    */
   getWorkspaceModules(): IndexedModule[] {
-    return this.#modules.filter(mod => mod.workspace);
+    return this.#modules.filter(module => module.workspace);
   }
 
   /**
@@ -134,9 +134,9 @@ export class ManifestIndex {
    */
   find(config: FindConfig): IndexedFile[] {
     const searchSpace: IndexedFile[] = [];
-    for (const mod of this.#modules) {
-      if (config.module?.(mod) ?? true) {
-        for (const [folder, files] of TypedObject.entries(mod.files)) {
+    for (const module of this.#modules) {
+      if (config.module?.(module) ?? true) {
+        for (const [folder, files] of TypedObject.entries(module.files)) {
           if (config.folder?.(folder) ?? true) {
             for (const file of files) {
               if (
@@ -213,14 +213,14 @@ export class ManifestIndex {
    * Build module list from an expression list (e.g. `@travetto/web,-@travetto/log)
    */
   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(item => item.name) : allMods);
+    const allModules = Object.keys(this.#manifest.modules);
+    const active = new Set<string>(mode === 'workspace' ? this.getWorkspaceModules().map(item => item.name) : allModules);
 
     for (const expr of exprList.split(/,/g)) {
-      const [, negative, mod] = expr.trim().match(/(-|[+])?([^+\- ]{1,150})$/) ?? [];
-      if (mod) {
-        const pattern = new RegExp(`^${mod.replace(/[*]/g, '.*')}$`);
-        for (const moduleName of allMods.filter(item => pattern.test(item))) {
+      const [, negative, module] = expr.trim().match(/(-|[+])?([^+\- ]{1,150})$/) ?? [];
+      if (module) {
+        const pattern = new RegExp(`^${module.replace(/[*]/g, '.*')}$`);
+        for (const moduleName of allModules.filter(item => pattern.test(item))) {
           active[negative ? 'delete' : 'add'](moduleName);
         }
       }
@@ -239,10 +239,10 @@ export class ManifestIndex {
       const next = toProcess.shift()!;
       if (!seen.has(next)) {
         seen.add(next);
-        const mod = this.getModule(next)!;
-        toProcess.push(...mod[field]);
+        const module = this.getModule(next)!;
+        toProcess.push(...module[field]);
         if (next !== this.#manifest.main.name) { // Do not include self
-          out.push(mod);
+          out.push(module);
         }
       }
     }
@@ -256,7 +256,7 @@ export class ManifestIndex {
     const base = this.#manifest.workspace.path;
     const lookup = this.#arbitraryLookup ??= ManifestUtil.lookupTrie(
       Object.values(this.#manifest.modules),
-      mod => mod.sourceFolder.split('/'),
+      module => module.sourceFolder.split('/'),
       sub =>
         !existsSync(path.resolve(base, ...sub, 'package.json')) &&
         !existsSync(path.resolve(base, ...sub, '.git'))
@@ -276,8 +276,8 @@ export class ManifestIndex {
   /**
    * Get manifest module by name
    */
-  getManifestModule(mod: string): ManifestModule {
-    return this.manifest.modules[mod];
+  getManifestModule(module: string): ManifestModule {
+    return this.manifest.modules[module];
   }
 
   /**
@@ -302,4 +302,32 @@ export class ManifestIndex {
     importFile = Array.isArray(importFile) ? importFile.join('/') : importFile;
     return this.getFromImport(importFile)?.sourceFile ?? importFile;
   }
+
+  /**
+   * Group by lineage, data can be duplicated
+   */
+  groupByLineage<T extends { action: string }>(items: { item: T, module: string }[]): Map<string, T[]> {
+    const itemsByMod = new Map<string, T[]>();
+    for (const event of items) {
+      const moduleSet = new Set(this.getDependentModules(event.module, 'parents').map(indexedMod => indexedMod.name));
+      moduleSet.add(this.manifest.workspace.name);
+      for (const moduleName of moduleSet) {
+        if (!itemsByMod.has(moduleName)) {
+          itemsByMod.set(moduleName, []);
+        }
+        itemsByMod.get(moduleName)!.push(event.item);
+      }
+    }
+    return itemsByMod;
+  }
+
+  /**
+   * Resolve child manifest relative to current manifest
+   */
+  resolveDependentManifest(moduleName: string): ManifestRoot {
+    const moduleRoot = this.getManifestModule(moduleName)!.sourceFolder;
+    const moduleContext = ManifestUtil.getModuleContext(this.manifest, moduleRoot);
+    const manifestLocation = ManifestUtil.getManifestLocation(moduleContext, moduleName);
+    return ManifestUtil.readManifestSync(manifestLocation);
+  }
 }

package/src/module.ts

@@ -77,7 +77,6 @@ export class ManifestModuleUtil {
     const out: string[] = [];
 
     const exclude = new Set([
-      path.resolve(ctx.workspace.path, ctx.build.compilerFolder),
       path.resolve(ctx.workspace.path, ctx.build.outputFolder),
       path.resolve(ctx.workspace.path, ctx.build.toolFolder),
     ]);
@@ -207,8 +206,8 @@ export class ManifestModuleUtil {
   /**
    * Visit a module and describe files, and metadata
    */
-  static async describeModule(ctx: ManifestContext, mod: PackageModule): Promise<ManifestModule> {
-    const { state, ...rest } = mod;
+  static async describeModule(ctx: ManifestContext, module: PackageModule): Promise<ManifestModule> {
+    const { state, ...rest } = module;
     const sourcePath = path.resolve(ctx.workspace.path, rest.sourceFolder);
 
     const files: ManifestModule['files'] = {};
@@ -234,8 +233,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(mod => this.describeModule(ctx, mod)));
-    return Object.fromEntries(modules.map(mod => [mod.name, mod]));
+    const modules = await Promise.all([...pkgs].map(module => this.describeModule(ctx, module)));
+    return Object.fromEntries(modules.map(module => [module.name, module]));
   }
 
   /**
@@ -257,4 +256,14 @@ export class ManifestModuleUtil {
     }
     return this.#pathToExtension(sourceFile, '');
   }
+
+  /**
+   * Determine if this type is considered source code
+   */
+  static isSourceType(type: ManifestModuleFileType | string): boolean {
+    if (type.includes('.')) {
+      type = this.getFileType(type);
+    }
+    return type === 'ts' || type === 'package-json' || type === 'js' || type === 'typings';
+  }
 }

package/src/package.ts

@@ -107,7 +107,7 @@ export class PackageUtil {
         case 'yarn':
         case 'npm': {
           const workspaces = await this.#exec<{ location: string, name: string }[]>(rootPath, 'npm query .workspace');
-          out = workspaces.map(mod => ({ path: path.resolve(ctx.workspace.path, mod.location), name: mod.name }));
+          out = workspaces.map(module => ({ path: path.resolve(ctx.workspace.path, module.location), name: module.name }));
           break;
         }
       }

package/src/types/context.ts

@@ -14,10 +14,6 @@ export type ManifestContext = {
     defaultEnv: string;
   };
   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 */

package/src/types/manifest.ts

@@ -1,6 +1,6 @@
 import type { ManifestModuleFileType, ManifestModuleFolderType, ManifestModuleRole } from './common.ts';
 import type { ManifestContext } from './context.ts';
-import { Package } from './package.ts';
+import type { Package } from './package.ts';
 
 export type ManifestModuleFile =
   [path: string, type: ManifestModuleFileType, updated: number] |

package/src/util.ts

@@ -5,6 +5,7 @@ import { PackageUtil } from './package.ts';
 
 import type { ManifestContext } from './types/context.ts';
 import type { ManifestRoot } from './types/manifest.ts';
+import type { ChangeEventType } from './types/common.ts';
 
 const MANIFEST_FILE = 'manifest.json';
 
@@ -36,8 +37,8 @@ export class ManifestUtil {
    * Produce a production manifest from a given manifest
    */
   static createProductionManifest(manifest: ManifestRoot): ManifestRoot {
-    const prodModules = Object.values(manifest.modules).filter(mod => mod.prod);
-    const prodModNames = new Set([...prodModules.map(mod => mod.name)]);
+    const prodModules = Object.values(manifest.modules).filter(module => module.prod);
+    const prodModNames = new Set([...prodModules.map(module => module.name)]);
     return {
       generated: manifest.generated,
       workspace: manifest.workspace,
@@ -48,8 +49,8 @@ export class ManifestUtil {
       },
       main: manifest.main,
       modules: Object.fromEntries(
-        prodModules.map(mod => [mod.name, Object.assign(mod, {
-          parents: mod.parents.filter(parent => prodModNames.has(parent))
+        prodModules.map(module => [module.name, Object.assign(module, {
+          parents: module.parents.filter(parent => prodModNames.has(parent))
         })])
       ),
     };
@@ -85,6 +86,20 @@ export class ManifestUtil {
     );
   }
 
+  /**
+   * Write mono repo manifests, return names written
+   */
+  static async writeDependentManifests(manifest: ManifestRoot): Promise<void> {
+    if (manifest.workspace.mono) {
+      const modules = Object.values(manifest.modules).filter(module => module.workspace && module.name !== manifest.workspace.name);
+      for (const module of modules) {
+        const moduleCtx = this.getModuleContext(manifest, module.sourceFolder, true);
+        const moduleManifest = await this.buildManifest(moduleCtx);
+        await this.writeManifest(moduleManifest);
+      }
+    }
+  }
+
   /**
    * Write a manifest to a specific file, if no file extension provided, the file is assumed to be a folder
    */
@@ -117,8 +132,8 @@ export class ManifestUtil {
    * Produce the manifest context for a given module module
    */
   static getModuleContext(ctx: ManifestContext, folder: string, ensureLatest = false): ManifestContext {
-    const modPath = path.resolve(ctx.workspace.path, folder);
-    const pkg = PackageUtil.readPackage(modPath, ensureLatest);
+    const modulePath = path.resolve(ctx.workspace.path, folder);
+    const pkg = PackageUtil.readPackage(modulePath, ensureLatest);
 
     return {
       workspace: ctx.workspace,
@@ -170,4 +185,25 @@ export class ManifestUtil {
       return value;
     };
   }
+
+  /**
+   * Update manifest for a given module and relative file, with a specified action
+   */
+  static updateManifest(manifest: ManifestRoot, moduleName: string, relativeFile: string, action: ChangeEventType): void {
+    if (action === 'update') {
+      return; // Do nothing
+    }
+    const folderKey = ManifestModuleUtil.getFolderKey(relativeFile);
+    const fileType = ManifestModuleUtil.getFileType(relativeFile);
+    const roleType = ManifestModuleUtil.getFileRole(relativeFile)!;
+
+    const manifestModuleFiles = manifest.modules[moduleName].files[folderKey] ??= [];
+    const idx = manifestModuleFiles.findIndex(indexedFile => indexedFile[0] === relativeFile);
+    const wrappedIdx = idx < 0 ? manifestModuleFiles.length : idx;
+
+    switch (action) {
+      case 'create': manifestModuleFiles[wrappedIdx] = [relativeFile, fileType, Date.now(), roleType]; break;
+      case 'delete': idx >= 0 && manifestModuleFiles.splice(idx, 1); break;
+    }
+  }
 }