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

package/package.json

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

package/src/dependencies.ts

@@ -23,40 +23,20 @@ type Req = {
  */
 export class PackageModuleVisitor {
 
-  constructor(public ctx: ManifestContext) {
-    this.#mainSourcePath = path.resolve(this.ctx.workspace.path, this.ctx.main.folder);
+  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])));
+    return visitor.visit();
   }
 
   #mainSourcePath: string;
   #cache: Record<string, PackageModule> = {};
-  #workspaceModules: Map<string, string>;
+  #workspaceModules: Record<string, string>;
+  #ctx: ManifestContext;
 
-  /**
-   * Initialize visitor, and provide global dependencies
-   */
-  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])
-    );
-
-    // Treat all workspace modules as main modules
-    if (this.ctx.workspace.mono && !this.ctx.main.folder) {
-      for (const [, loc] of this.#workspaceModules) {
-        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 ?? {})) {
-        globals.push(this.#create(PackageUtil.resolvePackagePath(name),
-          { main: type === 'main', workspace: true, parent: mainReq.value }
-        ));
-      }
-    }
-
-    return globals;
+  constructor(ctx: ManifestContext, workspaceModules: Record<string, string>) {
+    this.#mainSourcePath = path.resolve(ctx.workspace.path, ctx.main.folder);
+    this.#ctx = ctx;
+    this.#workspaceModules = workspaceModules;
   }
 
   /**
@@ -69,9 +49,9 @@ export class PackageModuleVisitor {
       prod,
       name: pkg.name,
       version: pkg.version,
-      workspace: workspace ?? this.#workspaceModules.has(pkg.name),
+      workspace: workspace ?? (pkg.name in this.#workspaceModules),
       internal: pkg.private === true,
-      sourceFolder: sourcePath === this.ctx.workspace.path ? '' : sourcePath.replace(`${this.ctx.workspace.path}/`, ''),
+      sourceFolder: sourcePath === this.#ctx.workspace.path ? '' : sourcePath.replace(`${this.#ctx.workspace.path}/`, ''),
       outputFolder: `node_modules/${pkg.name}`,
       state: {
         childSet: new Set(), parentSet: new Set(), roleSet: new Set(), roleRoot,
@@ -84,6 +64,38 @@ export class PackageModuleVisitor {
     return { pkg, value, children, parent };
   }
 
+  /**
+   * Get monorepo root includes
+   */
+  #getMonoRootIncludes(parent: Req): Req[] {
+    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 }));
+  }
+
+  /**
+   * Determine default includes
+   */
+  #getIncludes(parent: Req): Req[] {
+    if (this.#ctx.workspace.mono && !this.#ctx.main.folder) { // If mono and not at mono root, bail
+      return [];
+    }
+
+    const root = PackageUtil.readPackage(this.#ctx.workspace.path);
+    if (root.travetto?.build?.includes) {
+      return Object.entries(root.travetto.build.includes).map(([name, type]) =>
+        this.#create(PackageUtil.resolvePackagePath(name), { main: type === 'main', workspace: true, parent: parent.value })
+      );
+    } else {
+      return Object.values(this.#workspaceModules)
+        .filter((loc) => PackageUtil.readPackage(loc).travetto?.workspaceInclude)
+        .map(loc => this.#create(loc, { workspace: true, parent: parent.value }));
+    }
+  }
+
   /**
    * Propagate prod, role information through graph
    */
@@ -143,7 +155,13 @@ export class PackageModuleVisitor {
    */
   async visit(): Promise<Iterable<PackageModule>> {
     const seen = new Set<PackageModule>();
-    const queue = [...await this.init()];
+    const mainReq = this.#create(this.#mainSourcePath, { main: true, workspace: true, roleRoot: true, prod: true });
+
+    const queue = [
+      mainReq,
+      ...this.#getMonoRootIncludes(mainReq),
+      ...this.#getIncludes(mainReq)
+    ];
 
     while (queue.length) {
       const { value: node, parent, children, pkg } = queue.shift()!; // Visit initial set first
@@ -152,7 +170,7 @@ export class PackageModuleVisitor {
       }
 
       // Track parentage
-      if (node.name !== this.ctx.main.name && parent) {
+      if (node.name !== this.#ctx.main.name && parent) {
         node.state.parentSet.add(parent.name);
         parent.state.childSet.add(node.name);
       }

package/src/module.ts

@@ -197,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 new PackageModuleVisitor(ctx).visit();
+    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]));
   }

package/src/types/package.ts

@@ -41,9 +41,10 @@ export type Package = {
       outputs?: string[];
     };
     defaultEnv?: string;
+    workspaceInclude?: boolean;
     build?: Partial<ManifestContext['build']> & {
       isolated?: boolean;
-      withModules?: Record<string, 'main' | true>;
+      includes?: Record<string, 'main' | true>;
       watchIgnores?: string[];
     };
   };

package/src/util.ts

@@ -116,9 +116,9 @@ export class ManifestUtil {
   /**
    * Produce the manifest context for a given module module
    */
-  static getModuleContext(ctx: ManifestContext, folder: string): ManifestContext {
+  static getModuleContext(ctx: ManifestContext, folder: string, ensureLatest = false): ManifestContext {
     const modPath = path.resolve(ctx.workspace.path, folder);
-    const pkg = PackageUtil.readPackage(modPath);
+    const pkg = PackageUtil.readPackage(modPath, ensureLatest);
 
     return {
       workspace: ctx.workspace,