bun-workspaces 1.0.0-alpha.8 → 1.0.0

package/src/workspaces/findWorkspaces.mjs

@@ -1,66 +1,217 @@
 import fs from "fs";
 import path from "path";
-import { logger } from "../internal/logger.mjs";
-import { ERRORS } from "./errors.mjs";
-import { resolvePackageJsonContent, resolvePackageJsonPath, scanWorkspaceGlob } from "./packageJson.mjs";
-const validatePattern = (pattern)=>{
-    if (pattern.startsWith("!")) {
-        logger.warn(`Negation patterns are not supported by Bun workspaces: ${JSON.stringify(pattern)}`);
-        return false;
-    }
-    return true;
+import bun from "bun";
+import {
+  createDefaultWorkspaceConfig,
+  loadWorkspaceConfig,
+} from "../config/index.mjs";
+import { BUN_LOCK_ERRORS, readBunLockfile } from "../internal/bun/index.mjs";
+import { BunWorkspacesError } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/logger.mjs";
+import { resolveWorkspaceDependencies } from "./dependencyGraph/resolveDependencies.mjs";
+import { WORKSPACE_ERRORS } from "./errors.mjs";
+import {
+  resolvePackageJsonContent,
+  resolvePackageJsonPath,
+} from "./packageJson.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "bun"
+// CONCATENATED MODULE: external "../config/index.mjs"
+// CONCATENATED MODULE: external "../internal/bun/index.mjs"
+// CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../internal/logger/logger.mjs"
+// CONCATENATED MODULE: external "./dependencyGraph/resolveDependencies.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: external "./packageJson.mjs"
+// CONCATENATED MODULE: ./src/workspaces/findWorkspaces.ts
+
+const sortWorkspaces = (workspaces) =>
+  [...workspaces]
+    .sort((a, b) =>
+      a.isRoot
+        ? -1
+        : a.path.localeCompare(b.path) || a.name.localeCompare(b.name),
+    )
+    .reduce((acc, workspace, i, arr) => {
+      const previousWorkspace = arr[i - 1];
+      if (previousWorkspace && previousWorkspace.path === workspace.path) {
+        return acc;
+      }
+      return [...acc, workspace];
+    }, []);
+const getRootPackageJsonWorkspaceData = ({ rootDirectory }) => {
+  const packageJsonPath = path.join(rootDirectory, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    throw new WORKSPACE_ERRORS.PackageNotFound(
+      `No package.json found for project root at ${packageJsonPath}`,
+    );
+  }
+  const { workspaces, catalog, catalogs } = resolvePackageJsonContent(
+    packageJsonPath,
+    rootDirectory,
+    ["workspaces"],
+  );
+  return {
+    workspaceGlobs: workspaces ?? [],
+    catalog,
+    catalogs,
+  };
 };
-const validateWorkspace = (workspace, workspaces)=>{
-    if (workspaces.find((ws)=>ws.path === workspace.path)) return false;
-    if (workspaces.find((ws)=>ws.name === workspace.name)) throw new ERRORS.DuplicateWorkspaceName(`Duplicate workspace name found: ${JSON.stringify(workspace.name)}`);
-    return true;
+const validateWorkspace = (workspace, workspaces) => {
+  if (workspaces.find((ws) => ws.path === workspace.path)) {
+    return false;
+  }
+  if (workspaces.find((ws) => ws.name === workspace.name)) {
+    throw new WORKSPACE_ERRORS.DuplicateWorkspaceName(
+      `Duplicate workspace name found: ${JSON.stringify(workspace.name)}`,
+    );
+  }
+  return true;
 };
-const findWorkspaces = ({ rootDir, workspaceGlobs, workspaceAliases })=>{
-    rootDir = path.resolve(rootDir);
-    const workspaces = [];
-    for (const pattern of workspaceGlobs)if (validatePattern(pattern)) for (const item of scanWorkspaceGlob(pattern, rootDir)){
-        const packageJsonPath = resolvePackageJsonPath(item);
-        if (packageJsonPath) {
-            const packageJsonContent = resolvePackageJsonContent(packageJsonPath, rootDir, [
-                "name",
-                "scripts"
-            ]);
-            const workspace = {
-                name: packageJsonContent.name ?? "",
-                matchPattern: pattern,
-                path: path.relative(rootDir, path.dirname(packageJsonPath)),
-                packageJson: packageJsonContent,
-                aliases: Object.entries(workspaceAliases ?? {}).filter(([_, value])=>value === packageJsonContent.name).map(([key])=>key)
-            };
-            if (validateWorkspace(workspace, workspaces)) workspaces.push(workspace);
+const findWorkspaces = ({
+  rootDirectory,
+  workspaceGlobs: _workspaceGlobs,
+  includeRootWorkspace = false,
+}) => {
+  rootDirectory = path.resolve(rootDirectory);
+  logger.debug(`Finding workspaces in ${rootDirectory}`);
+  let workspaces = [];
+  const workspaceMap = {};
+  logger.debug(`Reading bun.lock`);
+  const bunLock = readBunLockfile(rootDirectory);
+  if (bunLock instanceof BunWorkspacesError) {
+    if (bunLock instanceof BUN_LOCK_ERRORS.BunLockNotFound) {
+      bunLock.message =
+        `No bun.lock found at ${rootDirectory}. Check that this is the directory of your project and that you've ran 'bun install'.` +
+        " If you have ran 'bun install', you may simply have no workspaces or dependencies in your project.";
+    }
+    throw bunLock;
+  }
+  const { workspaceGlobs, catalog, catalogs } = _workspaceGlobs
+    ? {
+        workspaceGlobs: _workspaceGlobs,
+        catalog: {},
+        catalogs: {},
+      }
+    : getRootPackageJsonWorkspaceData({
+        rootDirectory,
+      });
+  const bunCatalogs = {
+    defaultCatalog: catalog,
+    namedCatalogs: catalogs,
+  };
+  let rootWorkspace;
+  const workspaceAliases = {};
+  for (const workspacePath of Object.keys(bunLock.workspaces).map((p) =>
+    path.join(rootDirectory, p),
+  )) {
+    const packageJsonPath = resolvePackageJsonPath(workspacePath);
+    if (packageJsonPath) {
+      const packageJsonContent = resolvePackageJsonContent(
+        packageJsonPath,
+        rootDirectory,
+        ["name", "scripts"],
+      );
+      const workspaceConfig = loadWorkspaceConfig(
+        path.dirname(packageJsonPath),
+      );
+      if (workspaceConfig) {
+        for (const alias of workspaceConfig.aliases) {
+          workspaceAliases[alias] = packageJsonContent.name;
+        }
+      }
+      const relativePath = path.relative(
+        rootDirectory,
+        path.dirname(packageJsonPath),
+      );
+      const matchPattern =
+        workspaceGlobs.find((glob) => new bun.Glob(glob).match(relativePath)) ??
+        "";
+      const isRootWorkspace = workspacePath === rootDirectory;
+      if (!matchPattern && !isRootWorkspace) {
+        logger.debug(`No match pattern found for ${relativePath}`);
+      }
+      const workspace = {
+        name: packageJsonContent.name ?? "",
+        isRoot: isRootWorkspace,
+        matchPattern: workspacePath === rootDirectory ? "" : matchPattern,
+        path: path.relative(rootDirectory, path.dirname(packageJsonPath)),
+        scripts: Object.keys(packageJsonContent.scripts ?? {}).sort(),
+        aliases: [
+          ...new Set(
+            Object.entries(workspaceAliases ?? {})
+              .filter(([_, value]) => value === packageJsonContent.name)
+              .map(([key]) => key)
+              .concat(workspaceConfig?.aliases ?? []),
+          ),
+        ],
+        dependencies: [],
+        dependents: [],
+      };
+      if (workspace.isRoot) {
+        logger.debug(`Found root workspace: ${workspace.name}`);
+        rootWorkspace = workspace;
+      }
+      if (validateWorkspace(workspace, workspaces)) {
+        if (!workspace.isRoot || includeRootWorkspace) {
+          workspaces.push(workspace);
         }
+        workspaceMap[workspace.name] = {
+          workspace,
+          config: workspaceConfig ?? createDefaultWorkspaceConfig(),
+          packageJson: packageJsonContent,
+        };
+      }
     }
-    workspaces.sort((a, b)=>a.name.localeCompare(b.name) || a.path.localeCompare(b.path));
-    return {
-        workspaces
-    };
+  }
+  if (!rootWorkspace) {
+    throw new WORKSPACE_ERRORS.RootWorkspaceNotFound("No root workspace found");
+  }
+  workspaces = sortWorkspaces(
+    resolveWorkspaceDependencies(
+      workspaceMap,
+      includeRootWorkspace,
+      bunCatalogs,
+    ),
+  );
+  validateWorkspaceAliases(workspaces, workspaceAliases, rootWorkspace.name);
+  logger.debug(
+    `Found ${workspaces.length} workspaces: ${workspaces.map((ws) => ws.name).join(", ")}`,
+  );
+  return {
+    workspaces,
+    workspaceMap,
+    rootWorkspace,
+  };
 };
-const validateWorkspaceAliases = (workspaces, workspaceAliases)=>{
-    for (const [alias, name] of Object.entries(workspaceAliases ?? {})){
-        if (workspaces.find((ws)=>ws.name === alias)) throw new ERRORS.AliasConflict(`Alias ${JSON.stringify(alias)} conflicts with workspace name ${JSON.stringify(name)}`);
-        if (!workspaces.find((ws)=>ws.name === name)) throw new ERRORS.AliasedWorkspaceNotFound(`Workspace ${JSON.stringify(name)} was aliased by ${JSON.stringify(alias)} but was not found`);
+const validateWorkspaceAliases = (
+  workspaces,
+  workspaceAliases,
+  rootWorkspaceName,
+) => {
+  for (const [alias, name] of Object.entries(workspaceAliases ?? {})) {
+    if (workspaces.find((ws) => ws.name === alias)) {
+      throw new WORKSPACE_ERRORS.AliasConflict(
+        `Alias ${JSON.stringify(alias)} conflicts with workspace name ${JSON.stringify(name)}`,
+      );
     }
+    const workspaceWithDuplicateAlias = workspaces.find(
+      (ws) => ws.name !== name && ws.aliases.includes(alias),
+    );
+    if (workspaceWithDuplicateAlias) {
+      throw new WORKSPACE_ERRORS.AliasConflict(
+        `Workspaces ${JSON.stringify(name)} and ${JSON.stringify(workspaceWithDuplicateAlias.name)} have the same alias ${JSON.stringify(alias)}`,
+      );
+    }
+    if (
+      !workspaces.find((ws) => ws.name === name) &&
+      name !== rootWorkspaceName
+    ) {
+      throw new WORKSPACE_ERRORS.AliasedWorkspaceNotFound(
+        `Workspace ${JSON.stringify(name)} was aliased by ${JSON.stringify(alias)} but was not found`,
+      );
+    }
+  }
 };
-const findWorkspacesFromPackage = ({ rootDir, workspaceAliases })=>{
-    const packageJsonPath = path.join(rootDir, "package.json");
-    if (!fs.existsSync(packageJsonPath)) throw new ERRORS.PackageNotFound(`No package.json found at ${packageJsonPath}`);
-    const packageJson = resolvePackageJsonContent(packageJsonPath, rootDir, [
-        "workspaces"
-    ]);
-    const result = findWorkspaces({
-        rootDir,
-        workspaceGlobs: packageJson.workspaces ?? [],
-        workspaceAliases
-    });
-    validateWorkspaceAliases(result.workspaces, workspaceAliases);
-    return {
-        ...result,
-        name: packageJson.name ?? ""
-    };
-};
-export { findWorkspaces, findWorkspacesFromPackage, validateWorkspaceAliases };
+
+export { findWorkspaces, sortWorkspaces, validateWorkspaceAliases };

package/src/workspaces/index.d.ts

@@ -1,3 +1,4 @@
-export { findWorkspaces, findWorkspacesFromPackage, type FindWorkspacesOptions, } from "./findWorkspaces";
-export { type Workspace } from "./workspace";
-export type { ResolvedPackageJsonContent } from "./packageJson";
+export * from "./findWorkspaces";
+export * from "./packageJson";
+export * from "./errors";
+export type * from "./workspace";

package/src/workspaces/index.mjs

@@ -1,2 +1,3 @@
-import { findWorkspaces, findWorkspacesFromPackage } from "./findWorkspaces.mjs";
-export { findWorkspaces, findWorkspacesFromPackage };
+export * from "./findWorkspaces.mjs";
+export * from "./packageJson.mjs";
+export * from "./errors.mjs"; // CONCATENATED MODULE: ./src/workspaces/index.ts

package/src/workspaces/packageJson.d.ts

@@ -1,8 +1,31 @@
 export declare const resolvePackageJsonPath: (directoryItem: string) => string;
+export type BunCatalog = Record<string, string>;
+export type BunCatalogSet = {
+  defaultCatalog: BunCatalog;
+  namedCatalogs: Record<string, BunCatalog>;
+};
 export type ResolvedPackageJsonContent = {
-    name: string;
-    workspaces: string[];
-    scripts: Record<string, string>;
+  name: string;
+  workspaces: string[];
+  catalog: BunCatalog;
+  catalogs: Record<string, BunCatalog>;
+  scripts: Record<string, string>;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
+  optionalDependencies: Record<string, string>;
 } & Record<string, unknown>;
-export declare const scanWorkspaceGlob: (pattern: string, rootDir: string) => Generator<string, void, void>;
-export declare const resolvePackageJsonContent: (packageJsonPath: string, rootDir: string, validations: ("workspaces" | "name" | "scripts")[]) => ResolvedPackageJsonContent;
+/**
+ * Resolve a `catalog:` or `catalog:name` version reference for a given package name.
+ * Returns the resolved version string, or null if the catalog or package is not found.
+ */
+export declare const resolveCatalogDependencyVersion: (
+  packageName: string,
+  catalogRef: string,
+  catalogs: BunCatalogSet,
+) => string | null;
+export declare const resolvePackageJsonContent: (
+  packageJsonPath: string,
+  rootDirectory: string,
+  validations: ("workspaces" | "name" | "scripts")[],
+) => ResolvedPackageJsonContent;

package/src/workspaces/packageJson.mjs

@@ -1,65 +1,188 @@
 import fs from "fs";
 import path from "path";
-import { Glob } from "glob";
-import { logger } from "../internal/logger.mjs";
-import { ERRORS } from "./errors.mjs";
-const resolvePackageJsonPath = (directoryItem)=>{
-    if ("package.json" === path.basename(directoryItem)) return directoryItem;
-    if (fs.existsSync(path.join(directoryItem, "package.json"))) return path.join(directoryItem, "package.json");
-    return "";
+import { isJSONObject } from "../internal/core/index.mjs";
+import { logger } from "../internal/logger/index.mjs";
+import { WORKSPACE_ERRORS } from "./errors.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: ./src/workspaces/packageJson.ts
+
+const resolvePackageJsonPath = (directoryItem) => {
+  if (path.basename(directoryItem) === "package.json") {
+    return directoryItem;
+  }
+  if (fs.existsSync(path.join(directoryItem, "package.json"))) {
+    return path.join(directoryItem, "package.json");
+  }
+  return "";
 };
-const scanWorkspaceGlob = (pattern, rootDir)=>new Glob(pattern, {
-        absolute: true,
-        cwd: rootDir
-    }).iterateSync();
-const validateJsonRoot = (json)=>{
-    if (!json || "object" != typeof json || Array.isArray(json)) throw new ERRORS.InvalidPackageJson(`Expected package.json to be an object, got ${typeof json}`);
+const validateJsonRoot = (json) => {
+  if (!json || typeof json !== "object" || Array.isArray(json)) {
+    throw new WORKSPACE_ERRORS.InvalidPackageJson(
+      `Expected package.json to be an object, got ${typeof json}`,
+    );
+  }
 };
-const validateName = (json)=>{
-    if ("string" != typeof json.name) throw new ERRORS.NoWorkspaceName(`Expected package.json to have a string "name" field${void 0 !== json.name ? ` (Received ${json.name})` : ""}`);
-    if (!json.name.trim()) throw new ERRORS.NoWorkspaceName('Expected package.json to have a non-empty "name" field');
-    if (json.name.includes("*")) throw new ERRORS.InvalidWorkspaceName(`Package name cannot contain the character '*' (workspace: "${json.name}")`);
-    return json.name;
+const validateName = (json) => {
+  if (typeof json.name !== "string") {
+    throw new WORKSPACE_ERRORS.NoWorkspaceName(
+      `Expected package.json to have a string "name" field${json.name !== undefined ? ` (Received ${json.name})` : ""}`,
+    );
+  }
+  if (!json.name.trim()) {
+    throw new WORKSPACE_ERRORS.NoWorkspaceName(
+      `Expected package.json to have a non-empty "name" field`,
+    );
+  }
+  if (json.name.includes("*")) {
+    throw new WORKSPACE_ERRORS.InvalidWorkspaceName(
+      `Package name cannot contain the character '*' (workspace: "${json.name}")`,
+    );
+  }
+  return json.name;
 };
-const validateWorkspacePattern = (workspacePattern, rootDir)=>{
-    if ("string" != typeof workspacePattern) throw new ERRORS.InvalidWorkspacePattern(`Expected workspace pattern to be a string, got ${typeof workspacePattern}`);
-    if (!workspacePattern.trim()) return false;
-    const absolutePattern = path.resolve(rootDir, workspacePattern);
-    if (!absolutePattern.startsWith(rootDir)) throw new ERRORS.InvalidWorkspacePattern(`Cannot resolve workspace pattern outside of root directory ${rootDir}: ${absolutePattern}`);
-    return true;
+const validateWorkspacePattern = (workspacePattern, rootDirectory) => {
+  if (typeof workspacePattern !== "string") {
+    throw new WORKSPACE_ERRORS.InvalidWorkspacePattern(
+      `Expected workspace pattern to be a string, got ${typeof workspacePattern}`,
+    );
+  }
+  if (!workspacePattern.trim()) {
+    return false;
+  }
+  const absolutePattern = path.resolve(rootDirectory, workspacePattern);
+  if (!absolutePattern.startsWith(rootDirectory)) {
+    throw new WORKSPACE_ERRORS.InvalidWorkspacePattern(
+      `Cannot resolve workspace pattern outside of root directory ${rootDirectory}: ${absolutePattern}`,
+    );
+  }
+  return true;
 };
-const validateWorkspacePatterns = (json, rootDir)=>{
-    const workspaces = [];
-    if (json.workspaces) {
-        if (!Array.isArray(json.workspaces)) throw new ERRORS.InvalidWorkspaces('Expected package.json to have an array "workspaces" field');
-        for (const workspacePattern of json.workspaces)if (validateWorkspacePattern(workspacePattern, rootDir)) workspaces.push(workspacePattern);
-    }
-    return workspaces;
+const parseCatalogMap = (raw) => {
+  if (!isJSONObject(raw)) return {};
+  return Object.fromEntries(
+    Object.entries(raw).filter(([, value]) => typeof value === "string"),
+  );
 };
-const validateScripts = (json)=>{
-    if (json.scripts && ("object" != typeof json.scripts || Array.isArray(json.scripts))) throw new ERRORS.InvalidScripts('Expected package.json to have an object "scripts" field');
-    if (json.scripts) {
-        for (const value of Object.values(json.scripts))if ("string" != typeof value) throw new ERRORS.InvalidScripts(`Expected workspace "${json.name}" script "${json.scripts}" to be a string, got ${typeof value}`);
+const validateWorkspacePatterns = (json, rootDirectory) => {
+  const workspaces = [];
+  let catalog = {};
+  const catalogs = {};
+  if (json.workspaces) {
+    let source = "array";
+    let rawWorkspaces = [];
+    if (isJSONObject(json.workspaces)) {
+      source = "catalogObject";
+      rawWorkspaces = json.workspaces?.packages;
+      catalog = parseCatalogMap(json.workspaces.catalog);
+      if (isJSONObject(json.workspaces.catalogs)) {
+        for (const [name, value] of Object.entries(json.workspaces.catalogs)) {
+          catalogs[name] = parseCatalogMap(value);
+        }
+      }
+    } else {
+      source = "array";
+      rawWorkspaces = json.workspaces;
+    }
+    if (!Array.isArray(rawWorkspaces)) {
+      throw new WORKSPACE_ERRORS.InvalidWorkspaces(
+        `Expected package.json "workspaces${source === "catalogObject" ? ".packages" : ""}" to be an array`,
+      );
+    }
+    for (const workspacePattern of rawWorkspaces) {
+      if (validateWorkspacePattern(workspacePattern, rootDirectory)) {
+        workspaces.push(workspacePattern);
+      }
     }
-    return {
-        ...json.scripts
-    };
+  }
+  return {
+    workspaces,
+    catalog,
+    catalogs,
+  };
 };
-const resolvePackageJsonContent = (packageJsonPath, rootDir, validations)=>{
-    rootDir = path.resolve(rootDir);
-    let json = {};
-    try {
-        json = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-    } catch (error) {
-        logger.error(error);
-        throw new ERRORS.InvalidPackageJson(`Failed to read and parse package.json at ${packageJsonPath}: ${error.message}`);
+const validateScripts = (json) => {
+  if (
+    json.scripts &&
+    (typeof json.scripts !== "object" || Array.isArray(json.scripts))
+  ) {
+    throw new WORKSPACE_ERRORS.InvalidScripts(
+      `Expected package.json to have an object "scripts" field`,
+    );
+  }
+  if (json.scripts) {
+    for (const value of Object.values(json.scripts)) {
+      if (typeof value !== "string") {
+        throw new WORKSPACE_ERRORS.InvalidScripts(
+          `Expected workspace "${json.name}" script "${json.scripts}" to be a string, got ${typeof value}`,
+        );
+      }
     }
-    validateJsonRoot(json);
-    return {
-        ...json,
-        name: validations.includes("name") ? validateName(json) : json.name ?? "",
-        workspaces: validations.includes("workspaces") ? validateWorkspacePatterns(json, rootDir) : json?.workspaces ?? [],
-        scripts: validations.includes("scripts") ? validateScripts(json) : json.scripts ?? {}
-    };
+  }
+  return {
+    ...json.scripts,
+  };
+};
+/**
+ * Resolve a `catalog:` or `catalog:name` version reference for a given package name.
+ * Returns the resolved version string, or null if the catalog or package is not found.
+ */ const resolveCatalogDependencyVersion = (
+  packageName,
+  catalogRef,
+  catalogs,
+) => {
+  if (!catalogRef.startsWith("catalog:")) return null;
+  const catalogName = catalogRef.slice("catalog:".length);
+  if (!catalogName) {
+    return catalogs.defaultCatalog[packageName] ?? null;
+  }
+  return catalogs.namedCatalogs[catalogName]?.[packageName] ?? null;
+};
+const resolvePackageJsonContent = (
+  packageJsonPath,
+  rootDirectory,
+  validations,
+) => {
+  rootDirectory = path.resolve(rootDirectory);
+  let json = {};
+  try {
+    json = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  } catch (error) {
+    logger.error(error);
+    throw new WORKSPACE_ERRORS.InvalidPackageJson(
+      `Failed to read and parse package.json at ${packageJsonPath}: ${error.message}`,
+    );
+  }
+  validateJsonRoot(json);
+  const { workspaces, catalog, catalogs } = validations.includes("workspaces")
+    ? validateWorkspacePatterns(json, rootDirectory)
+    : {
+        workspaces: json?.workspaces ?? [],
+        catalog: {},
+        catalogs: {},
+      };
+  return {
+    ...json,
+    // Dependency data types are validated by bun install
+    // TODO investigate whether we need to validate any of these fields in the first place
+    dependencies: json.dependencies ?? {},
+    devDependencies: json.devDependencies ?? {},
+    peerDependencies: json.peerDependencies ?? {},
+    optionalDependencies: json.optionalDependencies ?? {},
+    name: validations.includes("name") ? validateName(json) : (json.name ?? ""),
+    workspaces,
+    catalog,
+    catalogs,
+    scripts: validations.includes("scripts")
+      ? validateScripts(json)
+      : (json.scripts ?? {}),
+  };
+};
+
+export {
+  resolveCatalogDependencyVersion,
+  resolvePackageJsonContent,
+  resolvePackageJsonPath,
 };
-export { resolvePackageJsonContent, resolvePackageJsonPath, scanWorkspaceGlob };

package/src/workspaces/workspace.d.ts

@@ -1,13 +1,19 @@
-import type { ResolvedPackageJsonContent } from "./packageJson";
-export interface Workspace {
-    /** The name of the workspace from its `package.json` */
-    name: string;
-    /** The relative path to the workspace from the root `package.json` */
-    path: string;
-    /** The pattern from `"workspaces"` in the root `package.json`that this workspace was matched from*/
-    matchPattern: string;
-    /** The contents of the workspace's package.json, with `"workspaces"` and `"scripts"` resolved */
-    packageJson: ResolvedPackageJsonContent;
-    /** Aliases assigned to the workspace via the `"workspaceAliases"` field in the config */
-    aliases: string[];
-}
+/** Metadata about a nested package within a Bun monorepo */
+export type Workspace = {
+  /** The name of the workspace from its `package.json` */
+  name: string;
+  /** Whether the workspace is the root workspace */
+  isRoot: boolean;
+  /** The relative path to the workspace from the root `package.json` */
+  path: string;
+  /** The pattern from `"workspaces"` in the root `package.json`that this workspace was matched from*/
+  matchPattern: string;
+  /** The scripts available in package.json */
+  scripts: string[];
+  /** Aliases assigned to the workspace via the `"workspaceAliases"` field in the config */
+  aliases: string[];
+  /** Names of workspaces that this workspace depends on */
+  dependencies: string[];
+  /** Names of workspaces that depend on this workspace */
+  dependents: string[];
+};

package/src/workspaces/workspace.mjs

@@ -0,0 +1,2 @@
+// CONCATENATED MODULE: ./src/workspaces/workspace.ts
+/** Metadata about a nested package within a Bun monorepo */

package/src/workspaces/workspacePattern.d.ts

@@ -0,0 +1,21 @@
+import type { Workspace } from "./workspace";
+declare const TARGETS: readonly ["path", "alias", "name"];
+export declare const WORKSPACE_PATTERN_ERRORS: import("../internal/core").DefinedErrors<"InvalidWorkspacePattern">;
+export type WorkspacePatternTarget = (typeof TARGETS)[number];
+export type WorkspacePattern = {
+  target: WorkspacePatternTarget | "default";
+  value: string;
+  isNegated: boolean;
+};
+export declare const WORKSPACE_PATTERN_SEPARATOR = ":";
+export declare const parseWorkspacePattern: (
+  pattern: string,
+) => WorkspacePattern;
+export declare const stringifyWorkspacePattern: (
+  pattern: WorkspacePattern,
+) => string;
+export declare const matchWorkspacesByPatterns: (
+  patterns: string[],
+  workspaces: Workspace[],
+) => Workspace[];
+export {};