workspace-tools 0.40.4 → 0.41.1

package/lib/workspaces/getCatalogs.js.map

@@ -1 +1 @@
-{"version":3,"file":"getCatalogs.js","sourceRoot":"","sources":["../../src/workspaces/getCatalogs.ts"],"names":[],"mappings":";;;AACA,uDAA0D;AAE1D;;;;;;GAMG;AACH,SAAgB,WAAW,CAAC,GAAW;IACrC,MAAM,KAAK,GAAG,IAAA,uCAAqB,EAAC,GAAG,CAAC,CAAC;IACzC,OAAO,KAAK,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC,CAAC;AACnC,CAAC;AAHD,kCAGC"}
+{"version":3,"sources":["../../src/workspaces/getCatalogs.ts"],"sourcesContent":["import type { Catalogs } from \"../types/Catalogs.js\";\nimport type { WorkspaceManager } from \"../types/WorkspaceManager.js\";\nimport { getWorkspaceUtilities } from \"./implementations\";\nimport { wrapWorkspaceUtility } from \"./wrapWorkspaceUtility.js\";\n\n/**\n * Get version catalogs, if supported by the manager (only pnpm and yarn v4 as of writing).\n * Returns undefined if no catalogs are present or the manager doesn't support them.\n * @see https://pnpm.io/catalogs\n * @see https://yarnpkg.com/features/catalogs\n *\n * @param cwd - Current working directory. It will search up from here to find the root, with caching.\n * @param managerOverride Workspace/monorepo manager to use instead of auto-detecting\n *\n * @returns Catalogs if defined, or undefined if not available\n * (logs verbose warnings instead of throwing on error)\n */\nexport function getCatalogs(cwd: string, managerOverride?: WorkspaceManager): Catalogs | undefined {\n  return wrapWorkspaceUtility({\n    cwd,\n    managerOverride,\n    description: \"catalogs\",\n    impl: ({ manager, root }) => {\n      // There is no default implementation for catalogs, since not all managers support it\n      return getWorkspaceUtilities(manager).getCatalogs?.({ root });\n    },\n  });\n}\n"],"names":["getCatalogs","cwd","managerOverride","wrapWorkspaceUtility","description","impl","manager","root","getWorkspaceUtilities"],"mappings":";;;;+BAiBgBA;;;eAAAA;;;iCAfsB;sCACD;AAc9B,SAASA,YAAYC,GAAW,EAAEC,eAAkC;IACzE,OAAOC,IAAAA,0CAAoB,EAAC;QAC1BF;QACAC;QACAE,aAAa;QACbC,MAAM,CAAC,EAAEC,OAAO,EAAEC,IAAI,EAAE;YACtB,qFAAqF;YACrF,OAAOC,IAAAA,sCAAqB,EAACF,SAASN,WAAW,GAAG;gBAAEO;YAAK;QAC7D;IACF;AACF"}

package/lib/workspaces/getChangedPackages.d.ts

@@ -1,4 +1,4 @@
-import { GitCommonOptions, type GetChangesBetweenRefsOptions } from "../git/types";
+import { type GitCommonOptions, type GetChangesBetweenRefsOptions } from "../git/types.js";
 type GetChangedPackagesOptions = GitCommonOptions & {
     /** The `merge-base` branch (must have been fetched locally) */
     target?: string;

package/lib/workspaces/getChangedPackages.js

@@ -1,52 +1,69 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getChangedPackages = exports.getChangedPackagesBetweenRefs = void 0;
-const git_1 = require("../git");
-const getPackagesByFiles_1 = require("./getPackagesByFiles");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get getChangedPackages () {
+        return getChangedPackages;
+    },
+    get getChangedPackagesBetweenRefs () {
+        return getChangedPackagesBetweenRefs;
+    }
+});
+const _git = require("../git");
+const _getPackagesByFiles = require("./getPackagesByFiles.js");
 function getChangedPackagesBetweenRefs(paramsOrCwd, _fromRef, _toRef, _ignoreGlobs, _returnAllPackagesOnNoMatch) {
-    const params = typeof paramsOrCwd === "string"
-        ? {
-            cwd: paramsOrCwd,
-            fromRef: _fromRef,
-            toRef: _toRef,
-            ignoreGlobs: _ignoreGlobs,
-            returnAllPackagesOnNoMatch: _returnAllPackagesOnNoMatch,
-        }
-        : paramsOrCwd;
+    var _gitOptions;
+    const params = typeof paramsOrCwd === "string" ? {
+        cwd: paramsOrCwd,
+        fromRef: _fromRef,
+        toRef: _toRef,
+        ignoreGlobs: _ignoreGlobs,
+        returnAllPackagesOnNoMatch: _returnAllPackagesOnNoMatch
+    } : paramsOrCwd;
     const { fromRef, toRef, ignoreGlobs, returnAllPackagesOnNoMatch = true, ...gitOptions } = params;
-    gitOptions.throwOnError ?? (gitOptions.throwOnError = true);
+    (_gitOptions = gitOptions).throwOnError ?? (_gitOptions.throwOnError = true);
     const changes = [
         ...new Set([
-            ...(0, git_1.getUntrackedChanges)(gitOptions),
-            ...(0, git_1.getUnstagedChanges)(gitOptions),
-            ...(0, git_1.getChangesBetweenRefs)({ fromRef, toRef, ...gitOptions }),
-            ...(0, git_1.getStagedChanges)(gitOptions),
-        ]),
+            ...(0, _git.getUntrackedChanges)(gitOptions),
+            ...(0, _git.getUnstagedChanges)(gitOptions),
+            ...(0, _git.getChangesBetweenRefs)({
+                fromRef,
+                toRef,
+                ...gitOptions
+            }),
+            ...(0, _git.getStagedChanges)(gitOptions)
+        ])
     ];
-    return (0, getPackagesByFiles_1.getPackagesByFiles)({
+    return (0, _getPackagesByFiles.getPackagesByFiles)({
         root: gitOptions.cwd,
         files: changes,
         ignoreGlobs,
-        returnAllPackagesOnNoMatch,
+        returnAllPackagesOnNoMatch
     });
 }
-exports.getChangedPackagesBetweenRefs = getChangedPackagesBetweenRefs;
 function getChangedPackages(cwdOrOptions, target, ignoreGlobs, returnAllPackagesOnNoMatch) {
+    var _gitOptions;
     let gitOptions;
     if (typeof cwdOrOptions === "string") {
-        gitOptions = { cwd: cwdOrOptions };
-    }
-    else {
+        gitOptions = {
+            cwd: cwdOrOptions
+        };
+    } else {
         ({ target, ignoreGlobs, returnAllPackagesOnNoMatch, ...gitOptions } = cwdOrOptions);
     }
-    gitOptions.throwOnError ?? (gitOptions.throwOnError = true);
-    const targetBranch = target || (0, git_1.getDefaultRemoteBranch)(gitOptions);
+    (_gitOptions = gitOptions).throwOnError ?? (_gitOptions.throwOnError = true);
+    const targetBranch = target || (0, _git.getDefaultRemoteBranch)(gitOptions);
     return getChangedPackagesBetweenRefs({
         fromRef: targetBranch,
         ...gitOptions,
         ignoreGlobs,
-        returnAllPackagesOnNoMatch,
+        returnAllPackagesOnNoMatch
     });
 }
-exports.getChangedPackages = getChangedPackages;
-//# sourceMappingURL=getChangedPackages.js.map

package/lib/workspaces/getChangedPackages.js.map

@@ -1 +1 @@
-{"version":3,"file":"getChangedPackages.js","sourceRoot":"","sources":["../../src/workspaces/getChangedPackages.ts"],"names":[],"mappings":";;;AAAA,gCAMgB;AAEhB,6DAA0D;AAiD1D,SAAgB,6BAA6B,CAC3C,WAA0D,EAC1D,QAAiB,EACjB,MAAe,EACf,YAAuB,EACvB,2BAAqC;IAErC,MAAM,MAAM,GACV,OAAO,WAAW,KAAK,QAAQ;QAC7B,CAAC,CAAC;YACE,GAAG,EAAE,WAAW;YAChB,OAAO,EAAE,QAAS;YAClB,KAAK,EAAE,MAAM;YACb,WAAW,EAAE,YAAY;YACzB,0BAA0B,EAAE,2BAA2B;SACxD;QACH,CAAC,CAAC,WAAW,CAAC;IAClB,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,0BAA0B,GAAG,IAAI,EAAE,GAAG,UAAU,EAAE,GAAG,MAAM,CAAC;IACjG,UAAU,CAAC,YAAY,KAAvB,UAAU,CAAC,YAAY,GAAK,IAAI,EAAC;IAEjC,MAAM,OAAO,GAAG;QACd,GAAG,IAAI,GAAG,CAAC;YACT,GAAG,IAAA,yBAAmB,EAAC,UAAU,CAAC;YAClC,GAAG,IAAA,wBAAkB,EAAC,UAAU,CAAC;YACjC,GAAG,IAAA,2BAAqB,EAAC,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,UAAU,EAAE,CAAC;YAC3D,GAAG,IAAA,sBAAgB,EAAC,UAAU,CAAC;SAChC,CAAC;KACH,CAAC;IAEF,OAAO,IAAA,uCAAkB,EAAC;QACxB,IAAI,EAAE,UAAU,CAAC,GAAG;QACpB,KAAK,EAAE,OAAO;QACd,WAAW;QACX,0BAA0B;KAC3B,CAAC,CAAC;AACL,CAAC;AAnCD,sEAmCC;AAoCD,SAAgB,kBAAkB,CAChC,YAAgD,EAChD,MAAe,EACf,WAAsB,EACtB,0BAAoC;IAEpC,IAAI,UAA4B,CAAC;IACjC,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE;QACpC,UAAU,GAAG,EAAE,GAAG,EAAE,YAAY,EAAE,CAAC;KACpC;SAAM;QACL,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,0BAA0B,EAAE,GAAG,UAAU,EAAE,GAAG,YAAY,CAAC,CAAC;KACrF;IACD,UAAU,CAAC,YAAY,KAAvB,UAAU,CAAC,YAAY,GAAK,IAAI,EAAC;IAEjC,MAAM,YAAY,GAAG,MAAM,IAAI,IAAA,4BAAsB,EAAC,UAAU,CAAC,CAAC;IAElE,OAAO,6BAA6B,CAAC;QACnC,OAAO,EAAE,YAAY;QACrB,GAAG,UAAU;QACb,WAAW;QACX,0BAA0B;KAC3B,CAAC,CAAC;AACL,CAAC;AAtBD,gDAsBC"}
+{"version":3,"sources":["../../src/workspaces/getChangedPackages.ts"],"sourcesContent":["import {\n  getChangesBetweenRefs,\n  getDefaultRemoteBranch,\n  getStagedChanges,\n  getUnstagedChanges,\n  getUntrackedChanges,\n} from \"../git\";\nimport { type GitCommonOptions, type GetChangesBetweenRefsOptions } from \"../git/types.js\";\nimport { getPackagesByFiles } from \"./getPackagesByFiles.js\";\n\ntype GetChangedPackagesOptions = GitCommonOptions & {\n  /** The `merge-base` branch (must have been fetched locally) */\n  target?: string;\n  /** Glob patterns to ignore */\n  ignoreGlobs?: string[];\n  /** If true (the default), return all packages if no matches are found for any file. */\n  returnAllPackagesOnNoMatch?: boolean;\n};\n\ntype GetChangedPackagesBetweenRefsOptions = Omit<GetChangedPackagesOptions, \"target\"> &\n  Pick<GetChangesBetweenRefsOptions, \"fromRef\" | \"toRef\">;\n\n/**\n * Finds all packages that had been changed between two refs in the repo under cwd,\n * by executing `git diff $fromRef...$toRef`.\n *\n * **NOTE: The new object params version will throw if any of the git operations error.**\n * Disabling this behavior is not recommended due to the potential for hiding other issues,\n * but can be done by setting `throwOnError: false` in the options.\n *\n * Note that by default, if a repo-wide file such as the root package.json has changed,\n * all packages are assumed to have changed. (This is highly lage-specific behavior.)\n * Disable by setting `returnAllPackagesOnNoMatch` to `false`.\n *\n * Explanation of the three dots:\n *\n * ```txt\n * git diff [--options] <commit>...<commit> [--] [<path>...]\n *\n *   This form is to view the changes on the branch containing and up to\n *   the second <commit>, starting at a common ancestor of both\n *   <commit>. \"git diff A...B\" is equivalent to \"git diff\n *   $(git-merge-base A B) B\". You can omit any one of <commit>, which\n *   has the same effect as using HEAD instead.\n * ```\n *\n * @returns list of package names that have changed\n */\nexport function getChangedPackagesBetweenRefs(params: GetChangedPackagesBetweenRefsOptions): string[];\n/** @deprecated Use object params version */\nexport function getChangedPackagesBetweenRefs(\n  cwd: string,\n  fromRef: string,\n  toRef?: string,\n  ignoreGlobs?: string[],\n  returnAllPackagesOnNoMatch?: boolean\n): string[];\nexport function getChangedPackagesBetweenRefs(\n  paramsOrCwd: GetChangedPackagesBetweenRefsOptions | string,\n  _fromRef?: string,\n  _toRef?: string,\n  _ignoreGlobs?: string[],\n  _returnAllPackagesOnNoMatch?: boolean\n): string[] {\n  const params: GetChangedPackagesBetweenRefsOptions =\n    typeof paramsOrCwd === \"string\"\n      ? {\n          cwd: paramsOrCwd,\n          fromRef: _fromRef!,\n          toRef: _toRef,\n          ignoreGlobs: _ignoreGlobs,\n          returnAllPackagesOnNoMatch: _returnAllPackagesOnNoMatch,\n        }\n      : paramsOrCwd;\n  const { fromRef, toRef, ignoreGlobs, returnAllPackagesOnNoMatch = true, ...gitOptions } = params;\n  gitOptions.throwOnError ??= true;\n\n  const changes = [\n    ...new Set([\n      ...getUntrackedChanges(gitOptions),\n      ...getUnstagedChanges(gitOptions),\n      ...getChangesBetweenRefs({ fromRef, toRef, ...gitOptions }),\n      ...getStagedChanges(gitOptions),\n    ]),\n  ];\n\n  return getPackagesByFiles({\n    root: gitOptions.cwd,\n    files: changes,\n    ignoreGlobs,\n    returnAllPackagesOnNoMatch,\n  });\n}\n\n/**\n * Finds all packages that had been changed in the repo under cwd, by executing\n * `git diff $target...`.\n *\n * **NOTE: The new object params version will throw if any of the git operations error.**\n * Disabling this behavior is not recommended due to the potential for hiding other issues,\n * but can be done by setting `throwOnError: false` in the options.\n *\n * Note that by default, if a repo-wide file such as the root package.json has changed,\n * all packages are assumed to have changed. (This is highly lage-specific behavior.)\n * Disable by setting `returnAllPackagesOnNoMatch` to `false`.\n *\n * Explanation of the three dots:\n *\n * ```txt\n * git diff [--options] <commit>...<commit> [--] [<path>...]\n *\n *   This form is to view the changes on the branch containing and up to\n *   the second <commit>, starting at a common ancestor of both\n *   <commit>. \"git diff A...B\" is equivalent to \"git diff\n *   $(git-merge-base A B) B\". You can omit any one of <commit>, which\n *   has the same effect as using HEAD instead.\n * ```\n *\n * @returns list of package names that have changed\n */\nexport function getChangedPackages(params: GetChangedPackagesOptions): string[];\n/** @deprecated Use object params version */\nexport function getChangedPackages(\n  cwd: string,\n  target?: string,\n  ignoreGlobs?: string[],\n  returnAllPackagesOnNoMatch?: boolean\n): string[];\nexport function getChangedPackages(\n  cwdOrOptions: string | GetChangedPackagesOptions,\n  target?: string,\n  ignoreGlobs?: string[],\n  returnAllPackagesOnNoMatch?: boolean\n): string[] {\n  let gitOptions: GitCommonOptions;\n  if (typeof cwdOrOptions === \"string\") {\n    gitOptions = { cwd: cwdOrOptions };\n  } else {\n    ({ target, ignoreGlobs, returnAllPackagesOnNoMatch, ...gitOptions } = cwdOrOptions);\n  }\n  gitOptions.throwOnError ??= true;\n\n  const targetBranch = target || getDefaultRemoteBranch(gitOptions);\n\n  return getChangedPackagesBetweenRefs({\n    fromRef: targetBranch,\n    ...gitOptions,\n    ignoreGlobs,\n    returnAllPackagesOnNoMatch,\n  });\n}\n"],"names":["getChangedPackages","getChangedPackagesBetweenRefs","paramsOrCwd","_fromRef","_toRef","_ignoreGlobs","_returnAllPackagesOnNoMatch","gitOptions","params","cwd","fromRef","toRef","ignoreGlobs","returnAllPackagesOnNoMatch","throwOnError","changes","Set","getUntrackedChanges","getUnstagedChanges","getChangesBetweenRefs","getStagedChanges","getPackagesByFiles","root","files","cwdOrOptions","target","targetBranch","getDefaultRemoteBranch"],"mappings":";;;;;;;;;;;QAgIgBA;eAAAA;;QAvEAC;eAAAA;;;qBAnDT;oCAE4B;AAiD5B,SAASA,8BACdC,WAA0D,EAC1DC,QAAiB,EACjBC,MAAe,EACfC,YAAuB,EACvBC,2BAAqC;QAarCC;IAXA,MAAMC,SACJ,OAAON,gBAAgB,WACnB;QACEO,KAAKP;QACLQ,SAASP;QACTQ,OAAOP;QACPQ,aAAaP;QACbQ,4BAA4BP;IAC9B,IACAJ;IACN,MAAM,EAAEQ,OAAO,EAAEC,KAAK,EAAEC,WAAW,EAAEC,6BAA6B,IAAI,EAAE,GAAGN,YAAY,GAAGC;IAC1FD,CAAAA,cAAAA,YAAWO,YAAY,KAAvBP,YAAWO,YAAY,GAAK;IAE5B,MAAMC,UAAU;WACX,IAAIC,IAAI;eACNC,IAAAA,wBAAmB,EAACV;eACpBW,IAAAA,uBAAkB,EAACX;eACnBY,IAAAA,0BAAqB,EAAC;gBAAET;gBAASC;gBAAO,GAAGJ,UAAU;YAAC;eACtDa,IAAAA,qBAAgB,EAACb;SACrB;KACF;IAED,OAAOc,IAAAA,sCAAkB,EAAC;QACxBC,MAAMf,WAAWE,GAAG;QACpBc,OAAOR;QACPH;QACAC;IACF;AACF;AAoCO,SAASb,mBACdwB,YAAgD,EAChDC,MAAe,EACfb,WAAsB,EACtBC,0BAAoC;QAQpCN;IANA,IAAIA;IACJ,IAAI,OAAOiB,iBAAiB,UAAU;QACpCjB,aAAa;YAAEE,KAAKe;QAAa;IACnC,OAAO;QACJ,CAAA,EAAEC,MAAM,EAAEb,WAAW,EAAEC,0BAA0B,EAAE,GAAGN,YAAY,GAAGiB,YAAW;IACnF;IACAjB,CAAAA,cAAAA,YAAWO,YAAY,KAAvBP,YAAWO,YAAY,GAAK;IAE5B,MAAMY,eAAeD,UAAUE,IAAAA,2BAAsB,EAACpB;IAEtD,OAAON,8BAA8B;QACnCS,SAASgB;QACT,GAAGnB,UAAU;QACbK;QACAC;IACF;AACF"}

package/lib/workspaces/getPackagesByFiles.js

@@ -1,38 +1,43 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPackagesByFiles = void 0;
-const micromatch_1 = __importDefault(require("micromatch"));
-const path_1 = __importDefault(require("path"));
-const getWorkspaces_1 = require("./getWorkspaces");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getPackagesByFiles", {
+    enumerable: true,
+    get: function() {
+        return getPackagesByFiles;
+    }
+});
+const _micromatch = /*#__PURE__*/ _interop_require_default(require("micromatch"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _getWorkspaceInfos = require("./getWorkspaceInfos.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function getPackagesByFiles(cwdOrOptions, files, ignoreGlobs, returnAllPackagesOnNoMatch) {
     let root;
     if (typeof cwdOrOptions === "string") {
         root = cwdOrOptions;
         files = files;
-    }
-    else {
+    } else {
         ({ root, files, ignoreGlobs, returnAllPackagesOnNoMatch } = cwdOrOptions);
     }
-    const workspaces = (0, getWorkspaces_1.getWorkspaces)(root);
-    const ignoreSet = new Set(ignoreGlobs?.length ? (0, micromatch_1.default)(files, ignoreGlobs) : []);
-    const filteredFiles = files.filter((change) => !ignoreSet.has(change));
+    const workspaces = (0, _getWorkspaceInfos.getWorkspaceInfos)(root) || [];
+    const ignoreSet = new Set(ignoreGlobs?.length ? (0, _micromatch.default)(files, ignoreGlobs) : []);
+    const filteredFiles = files.filter((change)=>!ignoreSet.has(change));
     const packages = new Set();
-    for (const file of filteredFiles) {
-        const candidates = workspaces.filter((pkg) => file.startsWith(path_1.default.relative(root, pkg.path).replace(/\\/g, "/")));
+    for (const file of filteredFiles){
+        const candidates = workspaces.filter((pkg)=>file.startsWith(_path.default.relative(root, pkg.path).replace(/\\/g, "/")));
         if (candidates.length) {
-            const found = candidates.reduce((found, item) => {
-                return found.path.length > item.path.length ? found : item;
-            }, candidates[0]);
+            const found = candidates.reduce((fnd, item)=>fnd.path.length > item.path.length ? fnd : item, candidates[0]);
             packages.add(found.name);
-        }
-        else if (returnAllPackagesOnNoMatch) {
-            return workspaces.map((pkg) => pkg.name);
+        } else if (returnAllPackagesOnNoMatch) {
+            return workspaces.map((pkg)=>pkg.name);
         }
     }
-    return [...packages];
+    return [
+        ...packages
+    ];
 }
-exports.getPackagesByFiles = getPackagesByFiles;
-//# sourceMappingURL=getPackagesByFiles.js.map

package/lib/workspaces/getPackagesByFiles.js.map

@@ -1 +1 @@
-{"version":3,"file":"getPackagesByFiles.js","sourceRoot":"","sources":["../../src/workspaces/getPackagesByFiles.ts"],"names":[],"mappings":";;;;;;AAAA,4DAAoC;AACpC,gDAAwB;AACxB,mDAAgD;AA0BhD,SAAgB,kBAAkB,CAChC,YAAgD,EAChD,KAAgB,EAChB,WAAsB,EACtB,0BAAoC;IAEpC,IAAI,IAAY,CAAC;IACjB,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE;QACpC,IAAI,GAAG,YAAY,CAAC;QACpB,KAAK,GAAG,KAAM,CAAC;KAChB;SAAM;QACL,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,0BAA0B,EAAE,GAAG,YAAY,CAAC,CAAC;KAC3E;IAED,MAAM,UAAU,GAAG,IAAA,6BAAa,EAAC,IAAI,CAAC,CAAC;IACvC,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAC,IAAA,oBAAU,EAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAErF,MAAM,aAAa,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvE,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;IAEnC,KAAK,MAAM,IAAI,IAAI,aAAa,EAAE;QAChC,MAAM,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,cAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;QAElH,IAAI,UAAU,CAAC,MAAM,EAAE;YACrB,MAAM,KAAK,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE;gBAC9C,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;YAC7D,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YAClB,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;SAC1B;aAAM,IAAI,0BAA0B,EAAE;YACrC,OAAO,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;SAC1C;KACF;IAED,OAAO,CAAC,GAAG,QAAQ,CAAC,CAAC;AACvB,CAAC;AAnCD,gDAmCC"}
+{"version":3,"sources":["../../src/workspaces/getPackagesByFiles.ts"],"sourcesContent":["import micromatch from \"micromatch\";\nimport path from \"path\";\nimport { getWorkspaceInfos } from \"./getWorkspaceInfos.js\";\n\ninterface GetPackagesByFilesOptions {\n  /** Monorepo root directory */\n  root: string;\n  /** Files to search for */\n  files: string[];\n  /** Glob patterns to ignore */\n  ignoreGlobs?: string[];\n  /** If true, will return all packages if no matches are found for any file */\n  returnAllPackagesOnNoMatch?: boolean;\n}\n\n/**\n * Given a list of files, finds all packages names that contain those files\n *\n * @returns Package names that have changed\n */\nexport function getPackagesByFiles(options: GetPackagesByFilesOptions): string[];\n/** @deprecated Use object parameter signature instead */\nexport function getPackagesByFiles(\n  root: string,\n  files: string[],\n  ignoreGlobs?: string[],\n  returnAllPackagesOnNoMatch?: boolean\n): string[];\nexport function getPackagesByFiles(\n  cwdOrOptions: string | GetPackagesByFilesOptions,\n  files?: string[],\n  ignoreGlobs?: string[],\n  returnAllPackagesOnNoMatch?: boolean\n): string[] {\n  let root: string;\n  if (typeof cwdOrOptions === \"string\") {\n    root = cwdOrOptions;\n    files = files!;\n  } else {\n    ({ root, files, ignoreGlobs, returnAllPackagesOnNoMatch } = cwdOrOptions);\n  }\n\n  const workspaces = getWorkspaceInfos(root) || [];\n  const ignoreSet = new Set(ignoreGlobs?.length ? micromatch(files, ignoreGlobs) : []);\n\n  const filteredFiles = files.filter((change) => !ignoreSet.has(change));\n\n  const packages = new Set<string>();\n\n  for (const file of filteredFiles) {\n    const candidates = workspaces.filter((pkg) => file.startsWith(path.relative(root, pkg.path).replace(/\\\\/g, \"/\")));\n\n    if (candidates.length) {\n      const found = candidates.reduce((fnd, item) => (fnd.path.length > item.path.length ? fnd : item), candidates[0]);\n      packages.add(found.name);\n    } else if (returnAllPackagesOnNoMatch) {\n      return workspaces.map((pkg) => pkg.name);\n    }\n  }\n\n  return [...packages];\n}\n"],"names":["getPackagesByFiles","cwdOrOptions","files","ignoreGlobs","returnAllPackagesOnNoMatch","root","workspaces","getWorkspaceInfos","ignoreSet","Set","length","micromatch","filteredFiles","filter","change","has","packages","file","candidates","pkg","startsWith","path","relative","replace","found","reduce","fnd","item","add","name","map"],"mappings":";;;;+BA4BgBA;;;eAAAA;;;mEA5BO;6DACN;mCACiB;;;;;;AA0B3B,SAASA,mBACdC,YAAgD,EAChDC,KAAgB,EAChBC,WAAsB,EACtBC,0BAAoC;IAEpC,IAAIC;IACJ,IAAI,OAAOJ,iBAAiB,UAAU;QACpCI,OAAOJ;QACPC,QAAQA;IACV,OAAO;QACJ,CAAA,EAAEG,IAAI,EAAEH,KAAK,EAAEC,WAAW,EAAEC,0BAA0B,EAAE,GAAGH,YAAW;IACzE;IAEA,MAAMK,aAAaC,IAAAA,oCAAiB,EAACF,SAAS,EAAE;IAChD,MAAMG,YAAY,IAAIC,IAAIN,aAAaO,SAASC,IAAAA,mBAAU,EAACT,OAAOC,eAAe,EAAE;IAEnF,MAAMS,gBAAgBV,MAAMW,MAAM,CAAC,CAACC,SAAW,CAACN,UAAUO,GAAG,CAACD;IAE9D,MAAME,WAAW,IAAIP;IAErB,KAAK,MAAMQ,QAAQL,cAAe;QAChC,MAAMM,aAAaZ,WAAWO,MAAM,CAAC,CAACM,MAAQF,KAAKG,UAAU,CAACC,aAAI,CAACC,QAAQ,CAACjB,MAAMc,IAAIE,IAAI,EAAEE,OAAO,CAAC,OAAO;QAE3G,IAAIL,WAAWR,MAAM,EAAE;YACrB,MAAMc,QAAQN,WAAWO,MAAM,CAAC,CAACC,KAAKC,OAAUD,IAAIL,IAAI,CAACX,MAAM,GAAGiB,KAAKN,IAAI,CAACX,MAAM,GAAGgB,MAAMC,MAAOT,UAAU,CAAC,EAAE;YAC/GF,SAASY,GAAG,CAACJ,MAAMK,IAAI;QACzB,OAAO,IAAIzB,4BAA4B;YACrC,OAAOE,WAAWwB,GAAG,CAAC,CAACX,MAAQA,IAAIU,IAAI;QACzC;IACF;IAEA,OAAO;WAAIb;KAAS;AACtB"}

package/lib/workspaces/getWorkspaceInfos.d.ts

@@ -0,0 +1,36 @@
+import type { WorkspaceInfos } from "../types/WorkspaceInfo.js";
+import type { WorkspaceManager } from "../types/WorkspaceManager.js";
+/**
+ * Get an array with names, paths, and package.json contents for each package ("workspace" in
+ * npm/yarn/pnpm terms) within a monorepo. The list of included packages is based on the
+ * workspace/monorepo manager's config file.
+ *
+ * Notes:
+ * - The workspace manager, root, and list of package paths for `cwd` are cached internally,
+ *   but the package contents are not.
+ * - To get an object with package names as keys, use `getPackageInfos` instead.
+ *
+ * @param managerOverride Workspace/monorepo manager to use instead of auto-detecting
+ *
+ * @returns Array of workspace package infos, or undefined if not found (not a monorepo)
+ * or there's any issue. (Logs verbose warnings instead of throwing on error.)
+ */
+export declare function getWorkspaceInfos(cwd: string, managerOverride?: WorkspaceManager): WorkspaceInfos | undefined;
+/**
+ * Get an array with names, paths, and package.json contents for each package ("workspace" in
+ * npm/yarn/pnpm terms) within a monorepo. The list of included packages is based on the
+ * workspace/monorepo manager's config file.
+ *
+ * Notes:
+ * - **WARNING**: As of writing, this will start promises to read all package.json files in
+ *   parallel, without direct concurrency control.
+ * - The workspace manager, root, and list of package paths for `cwd` are cached internally,
+ *   but the package contents are not.
+ * - To get an object with package names as keys, use `getPackageInfosAsync` instead.
+ *
+ * @param managerOverride Workspace/monorepo manager to use instead of auto-detecting
+ *
+ * @returns Array of workspace package infos, or undefined if not found (not a monorepo)
+ * or there's any issue. (Logs verbose warnings instead of throwing on error.)
+ */
+export declare function getWorkspaceInfosAsync(cwd: string, managerOverride?: WorkspaceManager): Promise<WorkspaceInfos | undefined>;

package/lib/workspaces/getWorkspaceInfos.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get getWorkspaceInfos () {
+        return getWorkspaceInfos;
+    },
+    get getWorkspaceInfosAsync () {
+        return getWorkspaceInfosAsync;
+    }
+});
+const _getPackageInfo = require("../getPackageInfo.js");
+const _getWorkspacePackagePaths = require("./getWorkspacePackagePaths.js");
+const _wrapWorkspaceUtility = require("./wrapWorkspaceUtility.js");
+function getWorkspaceInfos(cwd, managerOverride) {
+    return (0, _wrapWorkspaceUtility.wrapWorkspaceUtility)({
+        cwd,
+        managerOverride,
+        description: "workspace package infos",
+        impl: ({ manager })=>{
+            return (0, _getWorkspacePackagePaths.getWorkspacePackagePaths)(cwd, manager)?.map((packagePath)=>{
+                // getPackageInfo logs a warning if it can't be read
+                const packageJson = (0, _getPackageInfo.getPackageInfo)(packagePath);
+                return packageJson && {
+                    name: packageJson.name,
+                    path: packagePath,
+                    packageJson
+                };
+            }).filter(Boolean);
+        }
+    });
+}
+async function getWorkspaceInfosAsync(cwd, managerOverride) {
+    return (0, _wrapWorkspaceUtility.wrapAsyncWorkspaceUtility)({
+        cwd,
+        managerOverride,
+        description: "workspace package infos",
+        impl: async ({ manager })=>{
+            const packagePaths = await (0, _getWorkspacePackagePaths.getWorkspacePackagePathsAsync)(cwd, manager);
+            if (!packagePaths) return undefined;
+            const workspacePkgPromises = packagePaths.map(async (packagePath)=>{
+                // getPackageInfoAsync logs a warning if it can't be read
+                const packageJson = await (0, _getPackageInfo.getPackageInfoAsync)(packagePath);
+                return packageJson && {
+                    name: packageJson.name,
+                    path: packagePath,
+                    packageJson
+                };
+            });
+            return (await Promise.all(workspacePkgPromises)).filter(Boolean);
+        }
+    });
+}

package/lib/workspaces/getWorkspaceInfos.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/workspaces/getWorkspaceInfos.ts"],"sourcesContent":["import { getPackageInfo, getPackageInfoAsync } from \"../getPackageInfo.js\";\nimport type { WorkspaceInfos, WorkspacePackageInfo } from \"../types/WorkspaceInfo.js\";\nimport type { WorkspaceManager } from \"../types/WorkspaceManager.js\";\nimport { getWorkspacePackagePaths, getWorkspacePackagePathsAsync } from \"./getWorkspacePackagePaths.js\";\nimport { wrapAsyncWorkspaceUtility, wrapWorkspaceUtility } from \"./wrapWorkspaceUtility.js\";\n\n/**\n * Get an array with names, paths, and package.json contents for each package (\"workspace\" in\n * npm/yarn/pnpm terms) within a monorepo. The list of included packages is based on the\n * workspace/monorepo manager's config file.\n *\n * Notes:\n * - The workspace manager, root, and list of package paths for `cwd` are cached internally,\n *   but the package contents are not.\n * - To get an object with package names as keys, use `getPackageInfos` instead.\n *\n * @param managerOverride Workspace/monorepo manager to use instead of auto-detecting\n *\n * @returns Array of workspace package infos, or undefined if not found (not a monorepo)\n * or there's any issue. (Logs verbose warnings instead of throwing on error.)\n */\nexport function getWorkspaceInfos(cwd: string, managerOverride?: WorkspaceManager): WorkspaceInfos | undefined {\n  return wrapWorkspaceUtility({\n    cwd,\n    managerOverride,\n    description: \"workspace package infos\",\n    impl: ({ manager }) => {\n      return getWorkspacePackagePaths(cwd, manager)\n        ?.map<WorkspacePackageInfo | undefined>((packagePath) => {\n          // getPackageInfo logs a warning if it can't be read\n          const packageJson = getPackageInfo(packagePath);\n          return packageJson && { name: packageJson.name, path: packagePath, packageJson };\n        })\n        .filter(Boolean) as WorkspaceInfos | undefined;\n    },\n  });\n}\n\n/**\n * Get an array with names, paths, and package.json contents for each package (\"workspace\" in\n * npm/yarn/pnpm terms) within a monorepo. The list of included packages is based on the\n * workspace/monorepo manager's config file.\n *\n * Notes:\n * - **WARNING**: As of writing, this will start promises to read all package.json files in\n *   parallel, without direct concurrency control.\n * - The workspace manager, root, and list of package paths for `cwd` are cached internally,\n *   but the package contents are not.\n * - To get an object with package names as keys, use `getPackageInfosAsync` instead.\n *\n * @param managerOverride Workspace/monorepo manager to use instead of auto-detecting\n *\n * @returns Array of workspace package infos, or undefined if not found (not a monorepo)\n * or there's any issue. (Logs verbose warnings instead of throwing on error.)\n */\nexport async function getWorkspaceInfosAsync(\n  cwd: string,\n  managerOverride?: WorkspaceManager\n): Promise<WorkspaceInfos | undefined> {\n  return wrapAsyncWorkspaceUtility({\n    cwd,\n    managerOverride,\n    description: \"workspace package infos\",\n    impl: async ({ manager }) => {\n      const packagePaths = await getWorkspacePackagePathsAsync(cwd, manager);\n      if (!packagePaths) return undefined;\n\n      const workspacePkgPromises = packagePaths.map<Promise<WorkspacePackageInfo | undefined>>(async (packagePath) => {\n        // getPackageInfoAsync logs a warning if it can't be read\n        const packageJson = await getPackageInfoAsync(packagePath);\n        return packageJson && { name: packageJson.name, path: packagePath, packageJson };\n      });\n\n      return (await Promise.all(workspacePkgPromises)).filter(Boolean) as WorkspaceInfos;\n    },\n  });\n}\n"],"names":["getWorkspaceInfos","getWorkspaceInfosAsync","cwd","managerOverride","wrapWorkspaceUtility","description","impl","manager","getWorkspacePackagePaths","map","packagePath","packageJson","getPackageInfo","name","path","filter","Boolean","wrapAsyncWorkspaceUtility","packagePaths","getWorkspacePackagePathsAsync","undefined","workspacePkgPromises","getPackageInfoAsync","Promise","all"],"mappings":";;;;;;;;;;;QAqBgBA;eAAAA;;QAkCMC;eAAAA;;;gCAvD8B;0CAGoB;sCACR;AAiBzD,SAASD,kBAAkBE,GAAW,EAAEC,eAAkC;IAC/E,OAAOC,IAAAA,0CAAoB,EAAC;QAC1BF;QACAC;QACAE,aAAa;QACbC,MAAM,CAAC,EAAEC,OAAO,EAAE;YAChB,OAAOC,IAAAA,kDAAwB,EAACN,KAAKK,UACjCE,IAAsC,CAACC;gBACvC,oDAAoD;gBACpD,MAAMC,cAAcC,IAAAA,8BAAc,EAACF;gBACnC,OAAOC,eAAe;oBAAEE,MAAMF,YAAYE,IAAI;oBAAEC,MAAMJ;oBAAaC;gBAAY;YACjF,GACCI,OAAOC;QACZ;IACF;AACF;AAmBO,eAAef,uBACpBC,GAAW,EACXC,eAAkC;IAElC,OAAOc,IAAAA,+CAAyB,EAAC;QAC/Bf;QACAC;QACAE,aAAa;QACbC,MAAM,OAAO,EAAEC,OAAO,EAAE;YACtB,MAAMW,eAAe,MAAMC,IAAAA,uDAA6B,EAACjB,KAAKK;YAC9D,IAAI,CAACW,cAAc,OAAOE;YAE1B,MAAMC,uBAAuBH,aAAaT,GAAG,CAA4C,OAAOC;gBAC9F,yDAAyD;gBACzD,MAAMC,cAAc,MAAMW,IAAAA,mCAAmB,EAACZ;gBAC9C,OAAOC,eAAe;oBAAEE,MAAMF,YAAYE,IAAI;oBAAEC,MAAMJ;oBAAaC;gBAAY;YACjF;YAEA,OAAO,AAAC,CAAA,MAAMY,QAAQC,GAAG,CAACH,qBAAoB,EAAGN,MAAM,CAACC;QAC1D;IACF;AACF"}

package/lib/workspaces/getWorkspaceManagerRoot.d.ts

@@ -0,0 +1,16 @@
+import type { WorkspaceManager } from "../types/WorkspaceManager.js";
+/**
+ * Get the root directory of a monorepo, defined as the directory where the workspace/monorepo manager
+ * config file is located. (Does not rely in any way on git, and the result is cached by `cwd`.)
+ *
+ * @param cwd Start searching from here
+ * @param managerOverride Search for only this manager's config file
+ *
+ * @returns Workspace manager root directory. Returns undefined (and verbose logs) on error or if
+ * not found, unless `throwOnError` is set.
+ */
+export declare function getWorkspaceManagerRoot(cwd: string, managerOverride?: WorkspaceManager): string | undefined;
+export declare function getWorkspaceManagerRoot(cwd: string, managerOverride: WorkspaceManager | undefined, options?: {
+    /** Throw if there's an error or if the root is not found */
+    throwOnError: true;
+}): string;

package/lib/workspaces/getWorkspaceManagerRoot.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getWorkspaceManagerRoot", {
+    enumerable: true,
+    get: function() {
+        return getWorkspaceManagerRoot;
+    }
+});
+const _logging = require("../logging.js");
+const _implementations = require("./implementations");
+function getWorkspaceManagerRoot(cwd, managerOverride, options) {
+    const logOrThrow = (message)=>{
+        if (options?.throwOnError) {
+            throw new Error(message);
+        } else {
+            (0, _logging.logVerboseWarning)(message);
+        }
+    };
+    let root;
+    try {
+        root = (0, _implementations.getWorkspaceManagerAndRoot)(cwd, undefined, managerOverride)?.root;
+    } catch (err) {
+        logOrThrow(`Error getting ${managerOverride || "workspace/monorepo manager"} root from ${cwd}: ${err}`);
+        return;
+    }
+    if (!root) {
+        logOrThrow(`Could not find ${managerOverride || "workspace/monorepo manager"} root from ${cwd}`);
+    }
+    return root;
+}

package/lib/workspaces/getWorkspaceManagerRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/workspaces/getWorkspaceManagerRoot.ts"],"sourcesContent":["import { logVerboseWarning } from \"../logging.js\";\nimport { getWorkspaceManagerAndRoot } from \"./implementations\";\nimport type { WorkspaceManager } from \"../types/WorkspaceManager.js\";\n\n/**\n * Get the root directory of a monorepo, defined as the directory where the workspace/monorepo manager\n * config file is located. (Does not rely in any way on git, and the result is cached by `cwd`.)\n *\n * @param cwd Start searching from here\n * @param managerOverride Search for only this manager's config file\n *\n * @returns Workspace manager root directory. Returns undefined (and verbose logs) on error or if\n * not found, unless `throwOnError` is set.\n */\nexport function getWorkspaceManagerRoot(cwd: string, managerOverride?: WorkspaceManager): string | undefined;\nexport function getWorkspaceManagerRoot(\n  cwd: string,\n  managerOverride: WorkspaceManager | undefined,\n  options?: {\n    /** Throw if there's an error or if the root is not found */\n    throwOnError: true;\n  }\n): string;\nexport function getWorkspaceManagerRoot(\n  cwd: string,\n  managerOverride?: WorkspaceManager,\n  options?: { throwOnError: true }\n): string | undefined {\n  const logOrThrow = (message: string) => {\n    if (options?.throwOnError) {\n      throw new Error(message);\n    } else {\n      logVerboseWarning(message);\n    }\n  };\n\n  let root: string | undefined;\n  try {\n    root = getWorkspaceManagerAndRoot(cwd, undefined, managerOverride)?.root;\n  } catch (err) {\n    logOrThrow(`Error getting ${managerOverride || \"workspace/monorepo manager\"} root from ${cwd}: ${err}`);\n    return;\n  }\n\n  if (!root) {\n    logOrThrow(`Could not find ${managerOverride || \"workspace/monorepo manager\"} root from ${cwd}`);\n  }\n  return root;\n}\n"],"names":["getWorkspaceManagerRoot","cwd","managerOverride","options","logOrThrow","message","throwOnError","Error","logVerboseWarning","root","getWorkspaceManagerAndRoot","undefined","err"],"mappings":";;;;+BAuBgBA;;;eAAAA;;;yBAvBkB;iCACS;AAsBpC,SAASA,wBACdC,GAAW,EACXC,eAAkC,EAClCC,OAAgC;IAEhC,MAAMC,aAAa,CAACC;QAClB,IAAIF,SAASG,cAAc;YACzB,MAAM,IAAIC,MAAMF;QAClB,OAAO;YACLG,IAAAA,0BAAiB,EAACH;QACpB;IACF;IAEA,IAAII;IACJ,IAAI;QACFA,OAAOC,IAAAA,2CAA0B,EAACT,KAAKU,WAAWT,kBAAkBO;IACtE,EAAE,OAAOG,KAAK;QACZR,WAAW,CAAC,cAAc,EAAEF,mBAAmB,6BAA6B,WAAW,EAAED,IAAI,EAAE,EAAEW,KAAK;QACtG;IACF;IAEA,IAAI,CAACH,MAAM;QACTL,WAAW,CAAC,eAAe,EAAEF,mBAAmB,6BAA6B,WAAW,EAAED,KAAK;IACjG;IACA,OAAOQ;AACT"}

package/lib/workspaces/getWorkspacePackagePaths.d.ts

@@ -1,10 +1,25 @@
+import type { WorkspaceManager } from "../types/WorkspaceManager.js";
 /**
  * Get a list of package folder paths in the monorepo. The list of included packages is based on
  * the manager's config file and matching package folders (which must contain package.json) on disk.
+ *
+ * (The list of package paths is cached per monorepo root if caching is enabled.)
+ *
+ * @param managerOverride Workspace/monorepo manager to use instead of auto-detecting
+ *
+ * @returns Package paths, or undefined if there's any issue
+ * (logs verbose warnings instead of throwing on error)
  */
-export declare function getWorkspacePackagePaths(cwd: string): string[];
+export declare function getWorkspacePackagePaths(cwd: string, managerOverride?: WorkspaceManager): string[] | undefined;
 /**
  * Get a list of package folder paths in the monorepo. The list of included packages is based on
  * the manager's config file and matching package folders (which must contain package.json) on disk.
+ *
+ * (The list of package paths is cached per monorepo root if caching is enabled.)
+ *
+ * @param managerOverride Workspace/monorepo manager to use instead of auto-detecting
+ *
+ * @returns Package paths, or undefined if there's any issue
+ * (logs verbose warnings instead of throwing on error)
  */
-export declare function getWorkspacePackagePathsAsync(cwd: string): Promise<string[]>;
+export declare function getWorkspacePackagePathsAsync(cwd: string, managerOverride?: WorkspaceManager): Promise<string[] | undefined>;

package/lib/workspaces/getWorkspacePackagePaths.js

@@ -1,30 +1,144 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWorkspacePackagePathsAsync = exports.getWorkspacePackagePaths = void 0;
-const implementations_1 = require("./implementations");
-/**
- * Get a list of package folder paths in the monorepo. The list of included packages is based on
- * the manager's config file and matching package folders (which must contain package.json) on disk.
- */
-function getWorkspacePackagePaths(cwd) {
-    const utils = (0, implementations_1.getWorkspaceUtilities)(cwd);
-    return utils?.getWorkspacePackagePaths(cwd) || [];
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get getWorkspacePackagePaths () {
+        return getWorkspacePackagePaths;
+    },
+    get getWorkspacePackagePathsAsync () {
+        return getWorkspacePackagePathsAsync;
+    }
+});
+const _fastglob = /*#__PURE__*/ _interop_require_default(require("fast-glob"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _implementations = require("./implementations");
+const _isCachingEnabled = require("../isCachingEnabled.js");
+const _wrapWorkspaceUtility = require("./wrapWorkspaceUtility.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+/** Mapping from root path to resolved package paths, or undefined if there was an error */ const packagePathsCache = new Map();
+const globOptions = {
+    absolute: true,
+    ignore: [
+        "**/node_modules/**",
+        "**/__fixtures__/**"
+    ],
+    stats: false
+};
+function getWorkspacePackagePaths(cwd, managerOverride) {
+    return (0, _wrapWorkspaceUtility.wrapWorkspaceUtility)({
+        cwd,
+        managerOverride,
+        description: "workspace package paths",
+        impl: ({ manager, root })=>{
+            const initialResult = getInitialPathsOrGlobs({
+                manager,
+                root
+            });
+            if (!initialResult || "resolvedPaths" in initialResult) {
+                return initialResult?.resolvedPaths;
+            }
+            try {
+                const globResults = _fastglob.default.sync(initialResult.globs, {
+                    cwd: root,
+                    ...globOptions
+                });
+                return resolveAndCacheGlobResults({
+                    root,
+                    globResults
+                });
+            } catch (err) {
+                (0, _isCachingEnabled.isCachingEnabled)() && packagePathsCache.set(root, undefined);
+                throw err;
+            }
+        }
+    });
+}
+async function getWorkspacePackagePathsAsync(cwd, managerOverride) {
+    return (0, _wrapWorkspaceUtility.wrapAsyncWorkspaceUtility)({
+        cwd,
+        managerOverride,
+        description: "workspace package paths",
+        impl: async ({ manager, root })=>{
+            const initialResult = getInitialPathsOrGlobs({
+                manager,
+                root
+            });
+            if (!initialResult || "resolvedPaths" in initialResult) {
+                return initialResult?.resolvedPaths;
+            }
+            try {
+                const globResults = await (0, _fastglob.default)(initialResult.globs, {
+                    cwd: root,
+                    ...globOptions
+                });
+                return resolveAndCacheGlobResults({
+                    root,
+                    globResults
+                });
+            } catch (err) {
+                (0, _isCachingEnabled.isCachingEnabled)() && packagePathsCache.set(root, undefined);
+                throw err;
+            }
+        }
+    });
 }
-exports.getWorkspacePackagePaths = getWorkspacePackagePaths;
 /**
- * Get a list of package folder paths in the monorepo. The list of included packages is based on
- * the manager's config file and matching package folders (which must contain package.json) on disk.
- */
-async function getWorkspacePackagePathsAsync(cwd) {
-    const utils = (0, implementations_1.getWorkspaceUtilities)(cwd);
-    if (!utils) {
-        return [];
+ * Handles the shared synchronous initial logic:
+ * - Used the cached result if available
+ * - Else, call `getWorkspacePackagePatterns`
+ *   - If the results are relative paths (not patterns), resolve, cache, and return them
+ *   - Else, return the prepared globs for sync or async resolution as appropriate.
+ */ function getInitialPathsOrGlobs(params) {
+    const canCache = (0, _isCachingEnabled.isCachingEnabled)();
+    if (canCache && packagePathsCache.has(params.root)) {
+        // Return the cached result, even if it was a failure
+        const cachedPaths = packagePathsCache.get(params.root);
+        return cachedPaths && {
+            resolvedPaths: cachedPaths
+        };
     }
-    if (!utils.getWorkspacePackagePathsAsync) {
-        const managerName = (0, implementations_1.getWorkspaceManagerAndRoot)(cwd)?.manager;
-        throw new Error(`${cwd} is using ${managerName} which has not been converted to async yet`);
+    const managerUtilities = (0, _implementations.getWorkspaceUtilities)(params.manager);
+    const managerSetting = managerUtilities.getWorkspacePatterns({
+        root: params.root
+    });
+    if (managerSetting?.type === "pattern") {
+        return {
+            globs: managerSetting.patterns.map((p)=>_path.default.join(p, "package.json").replace(/\\/g, "/"))
+        };
+    }
+    if (managerSetting?.type === "path") {
+        const resolvedPaths = managerSetting.patterns.map((p)=>_path.default.resolve(params.root, p));
+        if (canCache) {
+            packagePathsCache.set(params.root, resolvedPaths);
+        }
+        return {
+            resolvedPaths
+        };
+    }
+    return undefined;
+}
+/**
+ * Given the results from globbing package.json files, resolve to package folder paths
+ * and cache the results.
+ */ function resolveAndCacheGlobResults(params) {
+    const { root, globResults } = params;
+    const resolvedPaths = globResults.map((packageJsonPath)=>{
+        const packagePath = _path.default.dirname(packageJsonPath);
+        return _path.default.sep === "/" ? packagePath : packagePath.replace(/\//g, _path.default.sep);
+    });
+    if ((0, _isCachingEnabled.isCachingEnabled)()) {
+        packagePathsCache.set(root, resolvedPaths);
     }
-    return utils.getWorkspacePackagePathsAsync(cwd);
+    return resolvedPaths;
 }
-exports.getWorkspacePackagePathsAsync = getWorkspacePackagePathsAsync;
-//# sourceMappingURL=getWorkspacePackagePaths.js.map