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

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.2",
+  "version": "4.0.0-rc.4",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [
     "path",

package/src/dependencies.ts

@@ -31,32 +31,52 @@ export class PackageModuleVisitor {
   #cache: Record<string, PackageModule> = {};
   #workspaceModules: Map<string, string>;
 
+  /**
+   * Get monorepo root includes
+   */
+  #getMonoRootIncludes(parent: Req): Req[] {
+    if (!(this.ctx.workspace.mono && !this.ctx.main.folder)) { // If not mono root, bail
+      return [];
+    }
+
+    return [...this.#workspaceModules.values()]
+      .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 [...this.#workspaceModules.values()]
+        .filter((loc) => PackageUtil.readPackage(loc).travetto?.workspaceInclude)
+        .map(loc => this.#create(loc, { workspace: true, parent: parent.value }));
+    }
+  }
+
   /**
    * 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;
+    return [
+      mainReq,
+      ...this.#getMonoRootIncludes(mainReq),
+      ...this.#getIncludes(mainReq)
+    ];
   }
 
   /**

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

@@ -41,9 +41,11 @@ 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[];
     };
   };
   workspaces?: 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);
   }
 
   /**