@travetto/manifest 7.1.1 → 7.1.3

package/README.md

@@ -134,7 +134,7 @@ The context contains:
    *  The location where all compiled code will be stored.  Defaults to: `.trv_output`. (*Can be overridden in your [Package JSON](https://docs.npmjs.com/cli/v9/configuring-npm/package-json) in 'travetto.outputFolder'*)
    *  The location where the intermediate compiler will be created. Defaults to: `.trv_compiler`
    *  The location where tooling will be able to write to. Defaults to: `.trv_output`
-   *  Which package manager is in use [Npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) or [Yarn](https://yarnpg.com)
+   *  Which package manager is in use [Npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)/[Yarn](https://yarnpkg.com)
    *  The main module version
    *  The main module description
    *  The framework version (based on @travetto/manifest)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/manifest",
-  "version": "7.1.1",
+  "version": "7.1.3",
   "type": "module",
   "description": "Support for project indexing, manifesting, along with file watching",
   "keywords": [

package/src/context.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { createRequire } from 'node:module';
 
-import type { Package } from './types/package.ts';
+import { type Package, PACKAGE_MANAGERS } from './types/package.ts';
 import type { ManifestContext } from './types/context.ts';
 
 type Pkg = Package & { path: string };
@@ -41,11 +41,17 @@ function findPackage(base: string, pred: (_p?: Pkg) => boolean): Pkg {
   return pkg;
 }
 
+const WORKSPACE_FILES = PACKAGE_MANAGERS.map(x => x.workspaceFile!).filter(Boolean);
+
 /**
  * Gets build context
  */
 export function getManifestContext(root: string = process.cwd()): ManifestContext {
-  const workspace = findPackage(root, pkg => !!pkg?.workspaces || !!pkg?.travetto?.build?.isolated);
+  const workspace = findPackage(root, pkg =>
+    !!pkg?.workspaces ||
+    !!pkg?.travetto?.build?.isolated ||
+    (!!pkg && WORKSPACE_FILES.some(file => existsSync(path.resolve(pkg.path, file))))
+  );
   if (workspace.type !== 'module') {
     throw new Error('Only ESM modules are supported, package.json must be of type module');
   }
@@ -63,7 +69,7 @@ export function getManifestContext(root: string = process.cwd()): ManifestContex
       name: workspace.name ?? 'untitled',
       path: workspace.path,
       mono: !!workspace.workspaces,
-      manager: existsSync(path.resolve(workspace.path, 'yarn.lock')) ? 'yarn' : 'npm'
+      manager: PACKAGE_MANAGERS.find(item => existsSync(path.resolve(workspace.path, item.lock)))?.type ?? 'npm'
     },
     build: {
       compilerUrl: build.compilerUrl ?? `http://localhost:${toPort(wsPrefix)}`,

package/src/manifest-index.ts

@@ -330,4 +330,9 @@ export class ManifestIndex {
     const manifestLocation = ManifestUtil.getManifestLocation(moduleContext, moduleName);
     return ManifestUtil.readManifestSync(manifestLocation);
   }
+
+  /** Resolve a package command tied to workspace */
+  resolvePackageCommand(cmd: string): string {
+    return path.resolve(this.manifest.workspace.path, 'node_modules', '.bin', cmd);
+  }
 }

package/src/package.ts

@@ -7,7 +7,6 @@ import { ManifestFileUtil } from './file.ts';
 
 import { PackagePathSymbol, type Package, type PackageWorkspaceEntry } from './types/package.ts';
 import type { ManifestContext } from './types/context.ts';
-import type { NodePackageManager } from './types/common.ts';
 
 /**
  * Utilities for querying, traversing and reading package.json files.
@@ -18,12 +17,6 @@ export class PackageUtil {
   static #cache: Record<string, Package> = {};
   static #workspaces: Record<string, PackageWorkspaceEntry[]> = {};
 
-  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: workingDirectory, encoding: 'utf8', env, stdio: ['pipe', 'pipe'] }).toString().trim();
-    return JSON.parse(text);
-  }
-
   /**
    * Resolve import given a manifest context
    */
@@ -80,7 +73,7 @@ export class PackageUtil {
       modulePath.endsWith('.json') ? modulePath : path.resolve(modulePath, 'package.json'),
     );
 
-    nodePackage.name ??= 'untitled'; // If a package.json (root-only) is missing a name, allows for npx execution
+    nodePackage.name ??= 'untitled'; // If a package.json (root-only) is missing a name, allows for execution
 
     nodePackage[PackagePathSymbol] = modulePath;
     return nodePackage;
@@ -102,29 +95,19 @@ export class PackageUtil {
     try {
       return this.#workspaces[rootPath] ??= ManifestFileUtil.readAsJsonSync<PackageWorkspaceEntry[]>(cache);
     } catch {
-      let out: PackageWorkspaceEntry[];
+      let args: string[];
       switch (ctx.workspace.manager) {
         case 'yarn':
-        case 'npm': {
-          const workspaces = await this.#exec<{ location: string, name: string }[]>(rootPath, 'npm query .workspace');
-          out = workspaces.map(module => ({ path: path.resolve(ctx.workspace.path, module.location), name: module.name }));
-          break;
-        }
+        case 'npm': args = ['query', '.workspace']; break;
+        case 'pnpm': args = ['ls', '-r', '--depth', '-1', '--json']; break;
       }
-      await ManifestFileUtil.bufferedFileWrite(cache, JSON.stringify(out));
-      return out;
-    }
-  }
 
-  /**
-   * Get an install command for a given npm module
-   */
-  static getInstallCommand(ctx: { workspace: { manager: NodePackageManager } }, pkg: string, production = false): string {
-    let install: string;
-    switch (ctx.workspace.manager) {
-      case 'npm': install = `npm i ${production ? '' : '--save-dev '}${pkg}`; break;
-      case 'yarn': install = `yarn add ${production ? '' : '--dev '}${pkg}`; break;
+      const env = { PATH: process.env.PATH, NODE_PATH: process.env.NODE_PATH };
+      const text = execSync(`${ctx.workspace.manager} ${args.join(' ')}`, { cwd: rootPath, encoding: 'utf8', env, stdio: ['pipe', 'pipe'] });
+      const out: PackageWorkspaceEntry[] = JSON.parse(text.trim());
+      const filtered = out.map(item => ({ name: item.name, path: item.path }));
+      await ManifestFileUtil.bufferedFileWrite(cache, JSON.stringify(filtered));
+      return filtered;
     }
-    return install;
   }
 }

package/src/types/common.ts

@@ -1,5 +1,3 @@
-export type NodePackageManager = 'yarn' | 'npm';
-
 export type ManifestModuleFileType = 'typings' | 'ts' | 'js' | 'json' | 'package-json' | 'unknown' | 'fixture' | 'md';
 export type ManifestModuleFolderType =
   '$root' | '$index' | '$package' |

package/src/types/context.ts

@@ -1,4 +1,4 @@
-import type { NodePackageManager } from './common.ts';
+import type { NodePackageManager } from './package.ts';
 
 export type ManifestContext = {
   workspace: {

package/src/types/package.ts

@@ -3,6 +3,16 @@ import type { ManifestContext } from './context.ts';
 
 export const PackagePathSymbol = Symbol.for('@travetto/manifest:package-path');
 
+const ALL_PACKAGE_MANAGERS = [
+  { lock: 'package-lock.json', type: 'npm', title: 'Npm', workspaceFile: undefined, active: true },
+  { lock: 'yarn.lock', type: 'yarn', title: 'Yarn', workspaceFile: undefined, active: true },
+  { lock: 'pnpm-lock.yaml', type: 'pnpm', workspaceFile: 'pnpm-workspace.yaml', title: 'Pnpm', active: false }
+] as const;
+
+export type NodePackageManager = (typeof ALL_PACKAGE_MANAGERS)[number]['type'];
+
+export const PACKAGE_MANAGERS = ALL_PACKAGE_MANAGERS.filter(manager => manager.active);
+
 export type Package = {
   [PackagePathSymbol]?: string;
   name: string;