@vercel/fs-detectors 7.9.2 → 7.9.4

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export { LocalFileSystemDetector } from './detectors/local-file-system-detector'
 export { workspaceManagers } from './workspaces/workspace-managers';
 export { getWorkspaces, GetWorkspaceOptions, Workspace, WorkspaceType, } from './workspaces/get-workspaces';
 export { getWorkspacePackagePaths, GetWorkspacePackagePathsOptions, } from './workspaces/get-workspace-package-paths';
+export { resolveWorkspacePackageTargets, type WorkspacePackageTarget, } from './workspaces/resolve-workspace-package-targets';
 export { monorepoManagers } from './monorepos/monorepo-managers';
 export { isOfficialRuntime, isStaticRuntime } from './is-official-runtime';
 export { packageManagers } from './package-managers/package-managers';

package/dist/index.js

@@ -65,6 +65,7 @@ __export(src_exports, {
   resolveAllConfiguredServices: () => import_resolve.resolveAllConfiguredServices,
   resolveAllConfiguredServicesV2: () => import_resolve_v2.resolveAllConfiguredServicesV2,
   resolveConfiguredServiceV2: () => import_resolve_v2.resolveConfiguredServiceV2,
+  resolveWorkspacePackageTargets: () => import_resolve_workspace_package_targets.resolveWorkspacePackageTargets,
   validateProxy: () => import_detect_builders.validateProxy,
   validateProxyConfig: () => import_detect_builders.validateProxyConfig,
   validateServiceConfigV2: () => import_resolve_v2.validateServiceConfigV2,
@@ -87,6 +88,7 @@ var import_local_file_system_detector = require("./detectors/local-file-system-d
 var import_workspace_managers = require("./workspaces/workspace-managers");
 var import_get_workspaces = require("./workspaces/get-workspaces");
 var import_get_workspace_package_paths = require("./workspaces/get-workspace-package-paths");
+var import_resolve_workspace_package_targets = require("./workspaces/resolve-workspace-package-targets");
 var import_monorepo_managers = require("./monorepos/monorepo-managers");
 var import_is_official_runtime = require("./is-official-runtime");
 var import_package_managers = require("./package-managers/package-managers");
@@ -141,6 +143,7 @@ var import_detect_instrumentation = require("./detect-instrumentation");
   resolveAllConfiguredServices,
   resolveAllConfiguredServicesV2,
   resolveConfiguredServiceV2,
+  resolveWorkspacePackageTargets,
   validateProxy,
   validateProxyConfig,
   validateServiceConfigV2,

package/dist/workspaces/get-workspace-package-paths.d.ts

@@ -3,9 +3,13 @@ import { Workspace } from './get-workspaces';
 interface GetPackagePathOptions {
     fs: DetectorFilesystem;
 }
+export interface GetWorkspacePatternsOptions extends GetPackagePathOptions {
+    type: Workspace['type'];
+}
 export interface GetWorkspacePackagePathsOptions extends GetPackagePathOptions {
     fs: DetectorFilesystem;
     workspace: Workspace;
 }
 export declare function getWorkspacePackagePaths({ fs, workspace, }: GetWorkspacePackagePathsOptions): Promise<string[]>;
+export declare function getWorkspacePatterns({ fs, type, }: GetWorkspacePatternsOptions): Promise<string[]>;
 export {};

package/dist/workspaces/get-workspace-package-paths.js

@@ -28,7 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var get_workspace_package_paths_exports = {};
 __export(get_workspace_package_paths_exports, {
-  getWorkspacePackagePaths: () => getWorkspacePackagePaths
+  getWorkspacePackagePaths: () => getWorkspacePackagePaths,
+  getWorkspacePatterns: () => getWorkspacePatterns
 });
 module.exports = __toCommonJS(get_workspace_package_paths_exports);
 var import_path = __toESM(require("path"));
@@ -44,22 +45,13 @@ async function getWorkspacePackagePaths({
   const { type, rootPath } = workspace;
   const workspaceFs = fs.chdir(rootPath);
   let results = [];
-  switch (type) {
-    case "yarn":
-    case "npm":
-      results = await getPackageJsonWorkspacePackagePaths({ fs: workspaceFs });
-      break;
-    case "pnpm":
-      results = await getPnpmWorkspacePackagePaths({ fs: workspaceFs });
-      break;
-    case "nx":
-      results = await getNxWorkspacePackagePaths({ fs: workspaceFs });
-      break;
-    case "rush":
-      results = await getRushWorkspacePackagePaths({ fs: workspaceFs });
-      break;
-    default:
-      throw new Error(`Unknown workspace implementation: ${type}`);
+  if (type === "nx") {
+    results = await getNxWorkspacePackagePaths({ fs: workspaceFs });
+  } else if (type === "rush") {
+    results = await getRushWorkspacePackagePaths({ fs: workspaceFs });
+  } else {
+    const patterns = await getWorkspacePatterns({ fs: workspaceFs, type });
+    results = await getPackagePaths(patterns, workspaceFs);
   }
   return results.map((packagePath) => {
     return posixPath.join(rootPath, posixPath.dirname(packagePath));
@@ -88,20 +80,27 @@ async function getPackagePaths(packages, fs) {
     )
   )).flat();
 }
-async function getPackageJsonWorkspacePackagePaths({
-  fs
+async function getWorkspacePatterns({
+  fs,
+  type
 }) {
+  const stringPatterns = (value) => Array.isArray(value) ? value.filter(
+    (pattern) => typeof pattern === "string"
+  ) : [];
+  if (type === "pnpm") {
+    const pnpmWorkspaceAsBuffer = await fs.readFile("pnpm-workspace.yaml");
+    const { packages = [] } = import_js_yaml.default.load(
+      pnpmWorkspaceAsBuffer.toString()
+    );
+    return stringPatterns(packages);
+  }
   const packageJsonAsBuffer = await fs.readFile("package.json");
   const { workspaces } = JSON.parse(
     packageJsonAsBuffer.toString()
   );
-  let packages = [];
-  if (Array.isArray(workspaces)) {
-    packages = workspaces;
-  } else {
-    packages = workspaces?.packages ?? [];
-  }
-  return getPackagePaths(packages, fs);
+  return stringPatterns(
+    Array.isArray(workspaces) ? workspaces : workspaces?.packages
+  );
 }
 async function getNxWorkspacePackagePaths({
   fs
@@ -111,15 +110,6 @@ async function getNxWorkspacePackagePaths({
   const packages = Object.values(projects);
   return getPackagePaths(packages, fs);
 }
-async function getPnpmWorkspacePackagePaths({
-  fs
-}) {
-  const pnpmWorkspaceAsBuffer = await fs.readFile("pnpm-workspace.yaml");
-  const { packages = [] } = import_js_yaml.default.load(
-    pnpmWorkspaceAsBuffer.toString()
-  );
-  return getPackagePaths(packages, fs);
-}
 async function getRushWorkspacePackagePaths({
   fs
 }) {
@@ -136,5 +126,6 @@ async function getRushWorkspacePackagePaths({
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  getWorkspacePackagePaths
+  getWorkspacePackagePaths,
+  getWorkspacePatterns
 });

package/dist/workspaces/get-workspaces.d.ts

@@ -4,7 +4,7 @@ export interface GetWorkspaceOptions {
     depth?: number;
     cwd?: string;
 }
-export type WorkspaceType = 'yarn' | 'pnpm' | 'npm' | 'nx' | 'rush';
+export type WorkspaceType = 'yarn' | 'pnpm' | 'npm' | 'bun' | 'nx' | 'rush';
 export type Workspace = {
     type: WorkspaceType;
     rootPath: string;

package/dist/workspaces/resolve-workspace-package-targets.d.ts

@@ -0,0 +1,13 @@
+import { DetectorFilesystem } from '../detectors/filesystem';
+import type { WorkspaceType } from './get-workspaces';
+export interface WorkspacePackageTarget {
+    isRoot?: boolean;
+    name?: string;
+    packageJsonPath: string;
+    relativePath: string;
+}
+export declare function resolveWorkspacePackageTargets({ fs, targetPaths, type, }: {
+    fs: DetectorFilesystem;
+    targetPaths: string[];
+    type: Extract<WorkspaceType, 'npm' | 'pnpm' | 'yarn' | 'bun'>;
+}): Promise<WorkspacePackageTarget[] | null>;

package/dist/workspaces/resolve-workspace-package-targets.js

@@ -0,0 +1,115 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolve_workspace_package_targets_exports = {};
+__export(resolve_workspace_package_targets_exports, {
+  resolveWorkspacePackageTargets: () => resolveWorkspacePackageTargets
+});
+module.exports = __toCommonJS(resolve_workspace_package_targets_exports);
+var import_path = require("path");
+var import_minimatch = __toESM(require("minimatch"));
+var import_get_workspace_package_paths = require("./get-workspace-package-paths");
+function normalize(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\//, "");
+}
+function matchesWorkspace(relativePath, patterns) {
+  const positives = patterns.filter((pattern) => !pattern.startsWith("!")).map(normalize);
+  const negatives = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => normalize(pattern.slice(1)));
+  return positives.some((pattern) => (0, import_minimatch.default)(relativePath, pattern)) && !negatives.some((pattern) => (0, import_minimatch.default)(relativePath, pattern));
+}
+async function readPackage(fs, packageJsonPath) {
+  try {
+    const packageJson = JSON.parse(
+      (await fs.readFile(packageJsonPath)).toString()
+    );
+    return {
+      name: typeof packageJson.name === "string" ? packageJson.name : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function findPackage(fs, targetPath) {
+  if (targetPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(targetPath) || normalize(targetPath) === ".." || normalize(targetPath).startsWith("../")) {
+    return null;
+  }
+  let relativePath = normalize(targetPath);
+  while (relativePath && relativePath !== ".") {
+    const packageJsonPath = import_path.posix.join(relativePath, "package.json");
+    const packageJson = await readPackage(fs, packageJsonPath);
+    if (packageJson) {
+      return {
+        name: packageJson.name,
+        packageJsonPath,
+        relativePath
+      };
+    }
+    const parent = import_path.posix.dirname(relativePath);
+    if (parent === relativePath || parent === ".")
+      return null;
+    relativePath = parent;
+  }
+  return null;
+}
+async function resolveWorkspacePackageTargets({
+  fs,
+  targetPaths,
+  type
+}) {
+  let patterns;
+  try {
+    patterns = await (0, import_get_workspace_package_paths.getWorkspacePatterns)({ fs, type });
+  } catch {
+    return null;
+  }
+  if (patterns.length === 0)
+    return null;
+  const targets = /* @__PURE__ */ new Map();
+  for (const targetPath of targetPaths) {
+    const target = await findPackage(fs, targetPath);
+    if (!target || !matchesWorkspace(target.relativePath, patterns))
+      return null;
+    targets.set(target.packageJsonPath, target);
+  }
+  const rootPackageJson = await readPackage(fs, "package.json");
+  if (rootPackageJson) {
+    targets.set("package.json", {
+      isRoot: true,
+      name: rootPackageJson.name,
+      packageJsonPath: "package.json",
+      relativePath: "."
+    });
+  }
+  return Array.from(targets.values()).sort(
+    (a, b) => a.relativePath.localeCompare(b.relativePath)
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveWorkspacePackageTargets
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "7.9.2",
+  "version": "7.9.4",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,11 +20,11 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "smol-toml": "1.5.2",
-    "@vercel/build-utils": "14.17.0",
+    "@vercel/build-utils": "14.19.0",
     "@vercel/error-utils": "2.2.1",
     "@vercel/frameworks": "3.35.0",
-    "@vercel/python-analysis": "0.14.0",
-    "@vercel/routing-utils": "6.6.0"
+    "@vercel/routing-utils": "6.6.0",
+    "@vercel/python-analysis": "0.14.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",
@@ -33,7 +33,7 @@
     "@types/node": "20.11.0",
     "@types/semver": "7.3.10",
     "vitest": "4.1.10",
-    "@vercel-internals/runtimes": "1.1.10"
+    "@vercel-internals/runtimes": "1.1.12"
   },
   "scripts": {
     "build": "node build.mjs",