bun-workspaces 1.8.2 → 1.9.0

package/src/project/implementations/{fileSystemProject.mjs → fileSystemProject/fileSystemProject.mjs}

@@ -1,8 +1,8 @@
 import fs from "fs";
 import path from "path";
-import { loadRootConfig } from "../../config/index.mjs";
-import { getUserEnvVar } from "../../config/userEnvVars/index.mjs";
-import { parse, quote } from "../../internal/bundledDeps/shellQuote.mjs";
+import { loadRootConfig } from "../../../config/index.mjs";
+import { getUserEnvVar } from "../../../config/userEnvVars/index.mjs";
+import { parse, quote } from "../../../internal/bundledDeps/shellQuote.mjs";
 import {
   DEFAULT_TEMP_DIR,
   IS_WINDOWS,
@@ -11,25 +11,55 @@ import {
   isPlainObject,
   validateJSArray,
   validateJSTypes,
-} from "../../internal/core/index.mjs";
-import { logger } from "../../internal/logger/index.mjs";
+} from "../../../internal/core/index.mjs";
+import { logger } from "../../../internal/logger/index.mjs";
 import {
   createScriptRuntimeEnvVars,
   interpolateWorkspaceScriptMetadata,
   runScript,
   runScripts,
-} from "../../runScript/index.mjs";
-import { checkIsRecursiveScript } from "../../runScript/recursion.mjs";
-import { resolveScriptShell } from "../../runScript/scriptShellOption.mjs";
-import { findWorkspaces, sortWorkspaces } from "../../workspaces/index.mjs";
-import { preventDependencyCycles } from "../../workspaces/dependencyGraph/index.mjs";
-import { PROJECT_ERRORS } from "../errors.mjs";
+} from "../../../runScript/index.mjs";
+import { createMultiProcessOutput } from "../../../runScript/output/multiProcessOutput.mjs";
+import { checkIsRecursiveScript } from "../../../runScript/recursion.mjs";
+import { resolveScriptShell } from "../../../runScript/scriptShellOption.mjs";
+import { findWorkspaces, sortWorkspaces } from "../../../workspaces/index.mjs";
+import { preventDependencyCycles } from "../../../workspaces/dependencyGraph/index.mjs";
+import { PROJECT_ERRORS } from "../../errors.mjs";
 import {
   ProjectBase,
   resolveRootWorkspaceSelector,
   resolveWorkspacePath,
-} from "./projectBase.mjs";
+} from "../projectBase.mjs";
+import { determineAffectedWorkspaces } from "./affectedWorkspaces.mjs";
 
+/**
+ * Resolves the script name used to look up script-level inputs in
+ * `runAffectedWorkspaceScript`. Uses the inline-script name when running
+ * an inline command, or the script name otherwise.
+ */ const resolveInputsLookupScriptName = (scriptOptions) => {
+  if (!scriptOptions.inline) return scriptOptions.script;
+  if (typeof scriptOptions.inline === "object") {
+    return scriptOptions.inline.scriptName;
+  }
+  return undefined;
+};
+const createEmptyAffectedRunResult = () => {
+  const now = new Date().toISOString();
+  return {
+    output: createMultiProcessOutput([]),
+    summary: Promise.resolve({
+      totalCount: 0,
+      successCount: 0,
+      failureCount: 0,
+      allSuccess: true,
+      startTimeISO: now,
+      endTimeISO: now,
+      durationMs: 0,
+      scriptResults: [],
+    }),
+    workspaces: [],
+  };
+};
 const quoteArg = (arg, shell) =>
   IS_WINDOWS && shell === "system"
     ? `"${arg.replace(/"/g, '""')}"`
@@ -497,6 +527,133 @@ class _FileSystemProject extends ProjectBase {
       workspaces,
     };
   }
+  /**
+   * Determine the affected workspaces based on the given options.
+   *
+   * Returns a summary of all workspaces, whether they are affected or not,
+   * and the reasons why they are affected.
+   */ async determineAffectedWorkspaces(options) {
+    validateJSTypes(
+      {
+        "diffSource option": {
+          value: options.diffSource,
+          typeofName: "string",
+        },
+        "ignoreWorkspaceDependencies option": {
+          value: options.ignoreWorkspaceDependencies,
+          typeofName: "boolean",
+          optional: true,
+        },
+        "ignoreExternalDependencies option": {
+          value: options.ignoreExternalDependencies,
+          typeofName: "boolean",
+          optional: true,
+        },
+        "script option": {
+          value: options.script,
+          typeofName: "string",
+          optional: true,
+        },
+      },
+      {
+        throw: true,
+      },
+    );
+    if (options.diffSource !== "git" && options.diffSource !== "fileList") {
+      throw new InvalidJSTypeError(
+        `Type error: diffSource option expects "git" | "fileList", received ${JSON.stringify(options.diffSource)}`,
+      );
+    }
+    if (options.diffSource === "git") {
+      validateJSTypes(
+        {
+          "diffOptions option": {
+            value: options.diffOptions,
+            typeofName: "object",
+            optional: true,
+          },
+        },
+        {
+          throw: true,
+        },
+      );
+      if (options.diffOptions !== undefined) {
+        validateJSTypes(
+          {
+            "diffOptions.baseRef option": {
+              value: options.diffOptions.baseRef,
+              typeofName: "string",
+              optional: true,
+            },
+            "diffOptions.headRef option": {
+              value: options.diffOptions.headRef,
+              typeofName: "string",
+              optional: true,
+            },
+            "diffOptions.ignoreUntracked option": {
+              value: options.diffOptions.ignoreUntracked,
+              typeofName: "boolean",
+              optional: true,
+            },
+            "diffOptions.ignoreStaged option": {
+              value: options.diffOptions.ignoreStaged,
+              typeofName: "boolean",
+              optional: true,
+            },
+            "diffOptions.ignoreUnstaged option": {
+              value: options.diffOptions.ignoreUnstaged,
+              typeofName: "boolean",
+              optional: true,
+            },
+            "diffOptions.ignoreUncommitted option": {
+              value: options.diffOptions.ignoreUncommitted,
+              typeofName: "boolean",
+              optional: true,
+            },
+          },
+          {
+            throw: true,
+          },
+        );
+      }
+    } else {
+      validateJSTypes(
+        {
+          "changedFiles option": {
+            value: options.changedFiles,
+            array: true,
+            itemOptions: {
+              typeofName: "string",
+            },
+          },
+        },
+        {
+          throw: true,
+        },
+      );
+    }
+    return determineAffectedWorkspaces(this, options);
+  }
+  /**
+   * Run the script across the affected workspaces.
+   *
+   * Similar to {@link runScriptAcrossWorkspaces}, but only runs the script across the affected workspaces.
+   */ async runAffectedWorkspaceScript({ affectedOptions, scriptOptions }) {
+    const { workspaceResults } = await this.determineAffectedWorkspaces({
+      ...affectedOptions,
+      script: resolveInputsLookupScriptName(scriptOptions),
+    });
+    const affectedNames = workspaceResults
+      .filter(({ isAffected }) => isAffected)
+      .map(({ workspace }) => workspace.name);
+    if (affectedNames.length === 0) {
+      return createEmptyAffectedRunResult();
+    }
+    return this.runScriptAcrossWorkspaces({
+      ...scriptOptions,
+      workspacePatterns: affectedNames,
+    });
+  }
   static #initialized = false;
 }
 /**

package/src/project/implementations/fileSystemProject/index.mjs

@@ -0,0 +1,4 @@
+export * from "./fileSystemProject.mjs";
+export * from "./affectedWorkspaces.mjs";
+
+export {};

package/src/project/implementations/memoryProject.mjs

@@ -112,6 +112,7 @@ class _MemoryProject extends ProjectBase {
       tags: [],
       dependencies: [],
       dependents: [],
+      externalDependencies: [],
     };
     validateWorkspace(this.rootWorkspace);
     for (const workspace of this.workspaces) {

package/src/project/index.mjs

@@ -1,6 +1,6 @@
 export * from "./errors.mjs";
 export * from "./implementations/projectBase.mjs";
-export * from "./implementations/fileSystemProject.mjs";
+export * from "./implementations/fileSystemProject/index.mjs";
 export * from "./implementations/memoryProject.mjs";
 
 export {};

package/src/rslib-runtime.mjs

@@ -21,42 +21,11 @@ function __webpack_require__(moduleId) {
 // expose the modules object (__webpack_modules__)
 __webpack_require__.m = __webpack_modules__;
 
-// webpack/runtime/compat_get_default_export
-(() => {
-  // getDefaultExport function for compatibility with non-ESM modules
-  __webpack_require__.n = (module) => {
-    var getter =
-      module && module.__esModule ? () => module["default"] : () => module;
-    __webpack_require__.d(getter, { a: getter });
-    return getter;
-  };
-})();
-// webpack/runtime/define_property_getters
-(() => {
-  __webpack_require__.d = (exports, definition) => {
-    for (var key in definition) {
-      if (
-        __webpack_require__.o(definition, key) &&
-        !__webpack_require__.o(exports, key)
-      ) {
-        Object.defineProperty(exports, key, {
-          enumerable: true,
-          get: definition[key],
-        });
-      }
-    }
-  };
-})();
 // webpack/runtime/esm_register_module
 (() => {
   __webpack_require__.add = function registerModules(modules) {
     Object.assign(__webpack_require__.m, modules);
   };
 })();
-// webpack/runtime/has_own_property
-(() => {
-  __webpack_require__.o = (obj, prop) =>
-    Object.prototype.hasOwnProperty.call(obj, prop);
-})();
 
 export { __webpack_require__ };

package/src/workspaces/applyWorkspacePatternConfigs.mjs

@@ -4,11 +4,20 @@ import {
 } from "../config/index.mjs";
 import { matchWorkspacesByPatterns } from "./workspacePattern.mjs";
 
-const resolvedToWorkspaceConfig = ({ aliases, tags, scripts, rules }) => ({
+const resolvedToWorkspaceConfig = ({
+  aliases,
+  tags,
+  scripts,
+  rules,
+  defaultInputs,
+}) => ({
   alias: aliases,
   tags,
   scripts,
   rules,
+  ...(defaultInputs && {
+    defaultInputs,
+  }),
 });
 const makeContext = (workspace) => ({
   name: workspace.name,

package/src/workspaces/dependencyGraph/resolveDependencies.mjs

@@ -1,5 +1,11 @@
 import { resolveCatalogDependencyVersion } from "../packageJson.mjs";
 
+const parseCatalogRef = (rawVersion) => {
+  if (!rawVersion.startsWith("catalog:")) return undefined;
+  return {
+    name: rawVersion.slice("catalog:".length),
+  };
+};
 const resolveWorkspaceDependencies = (
   workspaceMap,
   includeRootWorkspace,
@@ -10,34 +16,78 @@ const resolveWorkspaceDependencies = (
   );
   const workspacesWithDependencies = workspacePackages.map(
     ({ workspace, packageJson }) => {
-      for (const dependencyMap of [
-        packageJson.dependencies,
-        packageJson.devDependencies,
-        packageJson.peerDependencies,
-        packageJson.optionalDependencies,
-      ]) {
-        for (const [dependencyName, dependencyVersion] of Object.entries(
-          dependencyMap,
-        )) {
+      const externalAccumulator = new Map();
+      const dependencyMaps = [
+        {
+          map: packageJson.dependencies,
+          source: "dependencies",
+        },
+        {
+          map: packageJson.devDependencies,
+          source: "devDependencies",
+        },
+        {
+          map: packageJson.peerDependencies,
+          source: "peerDependencies",
+        },
+        {
+          map: packageJson.optionalDependencies,
+          source: "optionalDependencies",
+        },
+      ];
+      for (const { map, source } of dependencyMaps) {
+        for (const [dependencyName, dependencyVersion] of Object.entries(map)) {
+          const catalog = parseCatalogRef(dependencyVersion);
           const resolvedVersion =
-            catalogs && dependencyVersion.startsWith("catalog:")
+            catalogs && catalog
               ? (resolveCatalogDependencyVersion(
                   dependencyName,
                   dependencyVersion,
                   catalogs,
                 ) ?? dependencyVersion)
               : dependencyVersion;
-          if (
-            resolvedVersion.startsWith("workspace:") &&
-            workspaceMap[dependencyName]
-          ) {
-            workspace.dependencies.push(dependencyName);
-            workspaceMap[dependencyName].workspace.dependents.push(
-              workspace.name,
-            );
+          if (resolvedVersion.startsWith("workspace:")) {
+            if (workspaceMap[dependencyName]) {
+              workspace.dependencies.push(dependencyName);
+              workspaceMap[dependencyName].workspace.dependents.push(
+                workspace.name,
+              );
+            }
+            continue;
+          }
+          // External dep — record. Source precedence: a non-`devDependencies`
+          // source overrides `devDependencies`; otherwise the first source
+          // seen wins. Version/catalog reflect the last entry seen for the name.
+          const existing = externalAccumulator.get(dependencyName);
+          if (!existing) {
+            externalAccumulator.set(dependencyName, {
+              source,
+              version: resolvedVersion,
+              catalog,
+            });
+          } else {
+            existing.version = resolvedVersion;
+            existing.catalog = catalog;
+            if (
+              existing.source === "devDependencies" &&
+              source !== "devDependencies"
+            ) {
+              existing.source = source;
+            }
           }
         }
       }
+      workspace.externalDependencies = [...externalAccumulator.entries()]
+        .map(([name, { source, version, catalog }]) => {
+          const entry = {
+            name,
+            version,
+            source,
+          };
+          if (catalog) entry.catalog = catalog;
+          return entry;
+        })
+        .sort((a, b) => a.name.localeCompare(b.name));
       return workspace;
     },
   );

package/src/workspaces/findWorkspaces.mjs

@@ -144,6 +144,7 @@ const findWorkspaces = ({
         tags: workspaceConfig?.tags ?? [],
         dependencies: [],
         dependents: [],
+        externalDependencies: [],
       };
       if (workspace.isRoot) {
         logger.debug(`Found root workspace: ${workspace.name}`);

package/src/workspaces/workspace.mjs

@@ -1,3 +1,9 @@
-/** Metadata about a nested package within a Bun monorepo */
+/** Catalog reference info attached to an `ExternalDependency` that uses a `catalog:` ref */ /** The four `package.json` dependency maps a dep can be declared in */ const EXTERNAL_DEPENDENCY_SOURCES =
+  [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+  ];
 
-export {};
+export { EXTERNAL_DEPENDENCY_SOURCES };