workspace-tools 0.41.5 → 0.41.7

package/lib/git/index.js

@@ -5,11 +5,38 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     addGitObserver: null,
     clearGitObservers: null,
+    commit: null,
+    fetchRemote: null,
+    fetchRemoteBranch: null,
+    getBranchChanges: null,
+    getBranchName: null,
+    getChanges: null,
+    getChangesBetweenRefs: null,
     getConfigValue: null,
+    getCurrentHash: null,
+    getDefaultBranch: null,
     getDefaultRemote: null,
     getDefaultRemoteBranch: null,
+    getFileAddedHash: null,
+    getFileFromRef: null,
+    getFullBranchRef: null,
+    getParentBranch: null,
+    getRecentCommitMessages: null,
+    getRemoteBranch: null,
+    getShortBranchName: null,
+    getStagedChanges: null,
+    getUnstagedChanges: null,
+    getUntrackedChanges: null,
+    getUserEmail: null,
     git: null,
-    gitFailFast: null
+    gitFailFast: null,
+    init: null,
+    listAllTrackedFiles: null,
+    parseRemoteBranch: null,
+    resolveRemoteBranch: null,
+    revertLocalChanges: null,
+    stage: null,
+    stageAndCommit: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -24,39 +51,118 @@ _export(exports, {
     get clearGitObservers () {
         return _git.clearGitObservers;
     },
+    get commit () {
+        return _stageAndCommit.commit;
+    },
+    get fetchRemote () {
+        return _fetchRemote.fetchRemote;
+    },
+    get fetchRemoteBranch () {
+        return _fetchRemote.fetchRemoteBranch;
+    },
+    get getBranchChanges () {
+        return _getChanges.getBranchChanges;
+    },
+    get getBranchName () {
+        return _branchRefs.getBranchName;
+    },
+    get getChanges () {
+        return _getChanges.getChanges;
+    },
+    get getChangesBetweenRefs () {
+        return _getChanges.getChangesBetweenRefs;
+    },
     get getConfigValue () {
         return _config.getConfigValue;
     },
+    get getCurrentHash () {
+        return _getCurrentHash.getCurrentHash;
+    },
+    get getDefaultBranch () {
+        return _config.getDefaultBranch;
+    },
     get getDefaultRemote () {
         return _getDefaultRemote.getDefaultRemote;
     },
     get getDefaultRemoteBranch () {
         return _getDefaultRemoteBranch.getDefaultRemoteBranch;
     },
+    get getFileAddedHash () {
+        return _getFileAddedHash.getFileAddedHash;
+    },
+    get getFileFromRef () {
+        return _getFileFromRef.getFileFromRef;
+    },
+    get getFullBranchRef () {
+        return _branchRefs.getFullBranchRef;
+    },
+    get getParentBranch () {
+        return _gitUtilities.getParentBranch;
+    },
+    get getRecentCommitMessages () {
+        return _getRecentCommitMessages.getRecentCommitMessages;
+    },
+    get getRemoteBranch () {
+        return _branchRefs.getRemoteBranch;
+    },
+    get getShortBranchName () {
+        return _branchRefs.getShortBranchName;
+    },
+    get getStagedChanges () {
+        return _getChanges.getStagedChanges;
+    },
+    get getUnstagedChanges () {
+        return _getChanges.getUnstagedChanges;
+    },
+    get getUntrackedChanges () {
+        return _getChanges.getUntrackedChanges;
+    },
+    get getUserEmail () {
+        return _config.getUserEmail;
+    },
     get git () {
         return _git.git;
     },
     get gitFailFast () {
         return _git.gitFailFast;
+    },
+    get init () {
+        return _init.init;
+    },
+    get listAllTrackedFiles () {
+        return _listAllTrackedFiles.listAllTrackedFiles;
+    },
+    get parseRemoteBranch () {
+        return _parseRemoteBranch.parseRemoteBranch;
+    },
+    get resolveRemoteBranch () {
+        return _getDefaultRemoteBranch.resolveRemoteBranch;
+    },
+    get revertLocalChanges () {
+        return _revertLocalChanges.revertLocalChanges;
+    },
+    get stage () {
+        return _stageAndCommit.stage;
+    },
+    get stageAndCommit () {
+        return _stageAndCommit.stageAndCommit;
     }
 });
-0 && __export(require("./gitUtilities.js"));
-const _git = require("./git.js");
+const _branchRefs = require("./branchRefs.js");
 const _config = require("./config.js");
+const _fetchRemote = require("./fetchRemote.js");
+const _getChanges = require("./getChanges.js");
+const _getCurrentHash = require("./getCurrentHash.js");
 const _getDefaultRemote = require("./getDefaultRemote.js");
 const _getDefaultRemoteBranch = require("./getDefaultRemoteBranch.js");
-_export_star(require("./gitUtilities.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}
+const _getFileAddedHash = require("./getFileAddedHash.js");
+const _getFileFromRef = require("./getFileFromRef.js");
+const _getRecentCommitMessages = require("./getRecentCommitMessages.js");
+const _git = require("./git.js");
+const _gitUtilities = require("./gitUtilities.js");
+const _init = require("./init.js");
+const _listAllTrackedFiles = require("./listAllTrackedFiles.js");
+const _parseRemoteBranch = require("./parseRemoteBranch.js");
+const _revertLocalChanges = require("./revertLocalChanges.js");
+const _stageAndCommit = require("./stageAndCommit.js");
  // getRepositoryName is not currently exported; could be changed if it would be useful externally

package/lib/git/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/git/index.ts"],"sourcesContent":["export {\n  type GitError,\n  type GitObserver,\n  type GitOptions,\n  type GitProcessOutput,\n  addGitObserver,\n  clearGitObservers,\n  git,\n  gitFailFast,\n} from \"./git.js\";\nexport { getConfigValue } from \"./config.js\";\nexport { type GetDefaultRemoteOptions, getDefaultRemote } from \"./getDefaultRemote.js\";\nexport { type GetDefaultRemoteBranchOptions, getDefaultRemoteBranch } from \"./getDefaultRemoteBranch.js\";\nexport * from \"./gitUtilities.js\";\n// getRepositoryName is not currently exported; could be changed if it would be useful externally\n"],"names":["addGitObserver","clearGitObservers","getConfigValue","getDefaultRemote","getDefaultRemoteBranch","git","gitFailFast"],"mappings":";;;;;;;;;;;;;;;;;;;;QAKEA;eAAAA,mBAAc;;QACdC;eAAAA,sBAAiB;;QAIVC;eAAAA,sBAAc;;QACgBC;eAAAA,kCAAgB;;QACVC;eAAAA,8CAAsB;;QALjEC;eAAAA,QAAG;;QACHC;eAAAA,gBAAW;;;;qBACN;wBACwB;kCACgC;wCACY;qBAC7D;;;;;;;;;;;;;;CACd,iGAAiG"}
+{"version":3,"sources":["../../src/git/index.ts"],"sourcesContent":["export { getBranchName, getFullBranchRef, getRemoteBranch, getShortBranchName } from \"./branchRefs.js\";\nexport { getConfigValue, getDefaultBranch, getUserEmail } from \"./config.js\";\nexport { fetchRemote, fetchRemoteBranch } from \"./fetchRemote.js\";\nexport {\n  getBranchChanges,\n  getChanges,\n  getChangesBetweenRefs,\n  getStagedChanges,\n  getUnstagedChanges,\n  getUntrackedChanges,\n} from \"./getChanges.js\";\nexport { getCurrentHash } from \"./getCurrentHash.js\";\nexport { getDefaultRemote, type GetDefaultRemoteOptions } from \"./getDefaultRemote.js\";\nexport {\n  getDefaultRemoteBranch,\n  type GetDefaultRemoteBranchOptions,\n  resolveRemoteBranch,\n} from \"./getDefaultRemoteBranch.js\";\nexport { getFileAddedHash } from \"./getFileAddedHash.js\";\nexport { getFileFromRef } from \"./getFileFromRef.js\";\nexport { getRecentCommitMessages } from \"./getRecentCommitMessages.js\";\nexport {\n  addGitObserver,\n  clearGitObservers,\n  git,\n  gitFailFast,\n  type GitError,\n  type GitObserver,\n  type GitOptions,\n  type GitProcessOutput,\n} from \"./git.js\";\nexport { getParentBranch } from \"./gitUtilities.js\";\nexport { init } from \"./init.js\";\nexport { listAllTrackedFiles } from \"./listAllTrackedFiles.js\";\nexport { parseRemoteBranch } from \"./parseRemoteBranch.js\";\nexport { revertLocalChanges } from \"./revertLocalChanges.js\";\nexport { commit, stage, stageAndCommit } from \"./stageAndCommit.js\";\n\n// getRepositoryName is not currently exported; could be changed if it would be useful externally\n"],"names":["addGitObserver","clearGitObservers","commit","fetchRemote","fetchRemoteBranch","getBranchChanges","getBranchName","getChanges","getChangesBetweenRefs","getConfigValue","getCurrentHash","getDefaultBranch","getDefaultRemote","getDefaultRemoteBranch","getFileAddedHash","getFileFromRef","getFullBranchRef","getParentBranch","getRecentCommitMessages","getRemoteBranch","getShortBranchName","getStagedChanges","getUnstagedChanges","getUntrackedChanges","getUserEmail","git","gitFailFast","init","listAllTrackedFiles","parseRemoteBranch","resolveRemoteBranch","revertLocalChanges","stage","stageAndCommit"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsBEA;eAAAA,mBAAc;;QACdC;eAAAA,sBAAiB;;QAaVC;eAAAA,sBAAM;;QAlCNC;eAAAA,wBAAW;;QAAEC;eAAAA,8BAAiB;;QAErCC;eAAAA,4BAAgB;;QAJTC;eAAAA,yBAAa;;QAKpBC;eAAAA,sBAAU;;QACVC;eAAAA,iCAAqB;;QALdC;eAAAA,sBAAc;;QAUdC;eAAAA,8BAAc;;QAVEC;eAAAA,wBAAgB;;QAWhCC;eAAAA,kCAAgB;;QAEvBC;eAAAA,8CAAsB;;QAIfC;eAAAA,kCAAgB;;QAChBC;eAAAA,8BAAc;;QAnBCC;eAAAA,4BAAgB;;QA+B/BC;eAAAA,6BAAe;;QAXfC;eAAAA,gDAAuB;;QApBUC;eAAAA,2BAAe;;QAAEC;eAAAA,8BAAkB;;QAO3EC;eAAAA,4BAAgB;;QAChBC;eAAAA,8BAAkB;;QAClBC;eAAAA,+BAAmB;;QARsBC;eAAAA,oBAAY;;QAuBrDC;eAAAA,QAAG;;QACHC;eAAAA,gBAAW;;QAOJC;eAAAA,UAAI;;QACJC;eAAAA,wCAAmB;;QACnBC;eAAAA,oCAAiB;;QAlBxBC;eAAAA,2CAAmB;;QAmBZC;eAAAA,sCAAkB;;QACVC;eAAAA,qBAAK;;QAAEC;eAAAA,8BAAc;;;4BApC+C;wBACtB;6BAChB;4BAQxC;gCACwB;kCACgC;wCAKxD;kCAC0B;gCACF;yCACS;qBAUjC;8BACyB;sBACX;qCACe;mCACF;oCACC;gCACW;CAE9C,iGAAiG"}

package/lib/git/init.d.ts

@@ -0,0 +1,11 @@
+import type { GitInitOptions } from "./types.js";
+/**
+ * Run `git init` and verify that the `user.name` and `user.email` configs are set (at any level).
+ * Throws an error if `git init` fails.
+ *
+ * If `user.email` and `user.name` aren't already set globally, and the missing value is provided
+ * in params, set it at the repo level. Otherwise, throw an error.
+ */
+export declare function init(options: GitInitOptions): void;
+/** @deprecated Use object params version */
+export declare function init(cwd: string, email?: string, username?: string): void;

package/lib/git/init.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "init", {
+    enumerable: true,
+    get: function() {
+        return init;
+    }
+});
+const _config = require("./config.js");
+const _git = require("./git.js");
+function init(cwdOrOptions, _email, _username) {
+    const { email, username, ...options } = typeof cwdOrOptions === "string" ? {
+        cwd: cwdOrOptions,
+        email: _email,
+        username: _username
+    } : cwdOrOptions;
+    (0, _git.git)([
+        "init"
+    ], {
+        ...options,
+        throwOnError: true
+    });
+    if (!(0, _config.getConfigValue)({
+        key: "user.name",
+        ...options
+    })) {
+        if (!username) {
+            throw new Error("must include a username when initializing git repo");
+        }
+        (0, _git.git)([
+            "config",
+            "user.name",
+            username
+        ], options);
+    }
+    if (!(0, _config.getUserEmail)(options)) {
+        if (!email) {
+            throw new Error("must include a email when initializing git repo");
+        }
+        (0, _git.git)([
+            "config",
+            "user.email",
+            email
+        ], options);
+    }
+}

package/lib/git/init.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/git/init.ts"],"sourcesContent":["import { getConfigValue, getUserEmail } from \"./config.js\";\nimport { git } from \"./git.js\";\nimport type { GitInitOptions } from \"./types.js\";\n\n/**\n * Run `git init` and verify that the `user.name` and `user.email` configs are set (at any level).\n * Throws an error if `git init` fails.\n *\n * If `user.email` and `user.name` aren't already set globally, and the missing value is provided\n * in params, set it at the repo level. Otherwise, throw an error.\n */\nexport function init(options: GitInitOptions): void;\n/** @deprecated Use object params version */\nexport function init(cwd: string, email?: string, username?: string): void;\nexport function init(cwdOrOptions: string | GitInitOptions, _email?: string, _username?: string): void {\n  const { email, username, ...options } =\n    typeof cwdOrOptions === \"string\" ? { cwd: cwdOrOptions, email: _email, username: _username } : cwdOrOptions;\n\n  git([\"init\"], { ...options, throwOnError: true });\n\n  if (!getConfigValue({ key: \"user.name\", ...options })) {\n    if (!username) {\n      throw new Error(\"must include a username when initializing git repo\");\n    }\n    git([\"config\", \"user.name\", username], options);\n  }\n\n  if (!getUserEmail(options)) {\n    if (!email) {\n      throw new Error(\"must include a email when initializing git repo\");\n    }\n    git([\"config\", \"user.email\", email], options);\n  }\n}\n"],"names":["init","cwdOrOptions","_email","_username","email","username","options","cwd","git","throwOnError","getConfigValue","key","Error","getUserEmail"],"mappings":";;;;+BAcgBA;;;eAAAA;;;wBAd6B;qBACzB;AAab,SAASA,KAAKC,YAAqC,EAAEC,MAAe,EAAEC,SAAkB;IAC7F,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGC,SAAS,GACnC,OAAOL,iBAAiB,WAAW;QAAEM,KAAKN;QAAcG,OAAOF;QAAQG,UAAUF;IAAU,IAAIF;IAEjGO,IAAAA,QAAG,EAAC;QAAC;KAAO,EAAE;QAAE,GAAGF,OAAO;QAAEG,cAAc;IAAK;IAE/C,IAAI,CAACC,IAAAA,sBAAc,EAAC;QAAEC,KAAK;QAAa,GAAGL,OAAO;IAAC,IAAI;QACrD,IAAI,CAACD,UAAU;YACb,MAAM,IAAIO,MAAM;QAClB;QACAJ,IAAAA,QAAG,EAAC;YAAC;YAAU;YAAaH;SAAS,EAAEC;IACzC;IAEA,IAAI,CAACO,IAAAA,oBAAY,EAACP,UAAU;QAC1B,IAAI,CAACF,OAAO;YACV,MAAM,IAAIQ,MAAM;QAClB;QACAJ,IAAAA,QAAG,EAAC;YAAC;YAAU;YAAcJ;SAAM,EAAEE;IACvC;AACF"}

package/lib/git/listAllTrackedFiles.d.ts

@@ -0,0 +1,12 @@
+import type { GitCommonOptions } from "./types.js";
+/**
+ * Lists all tracked files matching the given patterns.
+ * Throws on error by default.
+ * @returns An array of file paths, or an empty array if no files are found
+ */
+export declare function listAllTrackedFiles(options: {
+    /** File patterns to match (passed to git ls-files) */
+    patterns: string[];
+} & GitCommonOptions): string[];
+/** @deprecated Use object params version */
+export declare function listAllTrackedFiles(patterns: string[], cwd: string): string[];

package/lib/git/listAllTrackedFiles.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "listAllTrackedFiles", {
+    enumerable: true,
+    get: function() {
+        return listAllTrackedFiles;
+    }
+});
+const _git = require("./git.js");
+function listAllTrackedFiles(patternsOrOptions, cwd) {
+    const { patterns, ...options } = Array.isArray(patternsOrOptions) ? {
+        patterns: patternsOrOptions,
+        cwd: cwd
+    } : patternsOrOptions;
+    const results = (0, _git.git)([
+        "ls-files",
+        ...patterns
+    ], {
+        throwOnError: true,
+        ...options
+    });
+    return (0, _git.processGitOutput)(results);
+}

package/lib/git/listAllTrackedFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/git/listAllTrackedFiles.ts"],"sourcesContent":["import { git, processGitOutput } from \"./git.js\";\nimport type { GitCommonOptions } from \"./types.js\";\n\n/**\n * Lists all tracked files matching the given patterns.\n * Throws on error by default.\n * @returns An array of file paths, or an empty array if no files are found\n */\nexport function listAllTrackedFiles(\n  options: {\n    /** File patterns to match (passed to git ls-files) */\n    patterns: string[];\n  } & GitCommonOptions\n): string[];\n/** @deprecated Use object params version */\nexport function listAllTrackedFiles(patterns: string[], cwd: string): string[];\nexport function listAllTrackedFiles(\n  patternsOrOptions: string[] | ({ patterns: string[] } & GitCommonOptions),\n  cwd?: string\n): string[] {\n  const { patterns, ...options } = Array.isArray(patternsOrOptions)\n    ? { patterns: patternsOrOptions, cwd: cwd! }\n    : patternsOrOptions;\n\n  const results = git([\"ls-files\", ...patterns], { throwOnError: true, ...options });\n\n  return processGitOutput(results);\n}\n"],"names":["listAllTrackedFiles","patternsOrOptions","cwd","patterns","options","Array","isArray","results","git","throwOnError","processGitOutput"],"mappings":";;;;+BAgBgBA;;;eAAAA;;;qBAhBsB;AAgB/B,SAASA,oBACdC,iBAAyE,EACzEC,GAAY;IAEZ,MAAM,EAAEC,QAAQ,EAAE,GAAGC,SAAS,GAAGC,MAAMC,OAAO,CAACL,qBAC3C;QAAEE,UAAUF;QAAmBC,KAAKA;IAAK,IACzCD;IAEJ,MAAMM,UAAUC,IAAAA,QAAG,EAAC;QAAC;WAAeL;KAAS,EAAE;QAAEM,cAAc;QAAM,GAAGL,OAAO;IAAC;IAEhF,OAAOM,IAAAA,qBAAgB,EAACH;AAC1B"}

package/lib/git/parseRemoteBranch.d.ts

@@ -0,0 +1,26 @@
+import type { ParsedRemoteBranch, ParseRemoteBranchOptions } from "./types.js";
+/**
+ * Get the remote and branch name from a full branch name that may include a remote prefix.
+ * If the path doesn't start with one of `options.knownRemotes` (but has multiple segments),
+ * the actual list of remotes will be read via `git config` to see if one of those matches.
+ *
+ * With `throwOnError: true`, currently it will NOT throw if the branch prefix matches `knownRemotes`
+ * regardless of the actual state of remotes in the repo. If it has to get the actual list of
+ * remotes, it will throw in the same cases as {@link getRemotes}.
+ *
+ * NOTE: The additional verification is new in the object params version; the original version
+ * incorrectly assumes the first segment before a slash is always a remote.
+ */
+export declare function parseRemoteBranch(options: ParseRemoteBranchOptions): ParsedRemoteBranch;
+/**
+ * @deprecated Use object params version, which does more verification. This version inaccurately
+ * assumes the first segment before a slash is always a remote, which could lead to tricky bugs.
+ */
+export declare function parseRemoteBranch(branch: string): ParsedRemoteBranch;
+/**
+ * See {@link parseRemoteBranch}. This version also returns the remotes in the result if they were
+ * read from git, for reuse by other operations.
+ */
+export declare function parseRemoteBranchPlusRemotes(options: ParseRemoteBranchOptions): ParsedRemoteBranch & {
+    remotes: Record<string, string> | undefined;
+};

package/lib/git/parseRemoteBranch.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    parseRemoteBranch: null,
+    parseRemoteBranchPlusRemotes: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get parseRemoteBranch () {
+        return parseRemoteBranch;
+    },
+    get parseRemoteBranchPlusRemotes () {
+        return parseRemoteBranchPlusRemotes;
+    }
+});
+const _getRemotes = require("./getRemotes.js");
+function parseRemoteBranch(branchOrOptions) {
+    if (typeof branchOrOptions === "string") {
+        const branch = branchOrOptions;
+        const firstSlashPos = branch.indexOf("/", 0);
+        return {
+            remote: branch.substring(0, firstSlashPos),
+            remoteBranch: branch.substring(firstSlashPos + 1)
+        };
+    }
+    // Remove the list of remotes from the result
+    const { remote, remoteBranch } = parseRemoteBranchPlusRemotes(branchOrOptions);
+    return {
+        remote,
+        remoteBranch
+    };
+}
+function parseRemoteBranchPlusRemotes(options) {
+    const { branch, knownRemotes = [
+        "origin",
+        "upstream"
+    ], ...otherOptions } = options;
+    if (!branch.includes("/")) {
+        return {
+            remote: "",
+            remoteBranch: branch,
+            remotes: undefined
+        };
+    }
+    // As a shortcut, check for the most common remote names before doing git operations
+    let remote = knownRemotes.find((r)=>branch.startsWith(`${r}/`));
+    let remotes;
+    if (!remote) {
+        // There's a slash in the branch name, but it doesn't start with one of the common remote names.
+        // Get the real list of remotes from git to see if it matches any of those, or is just a branch
+        // with a slash in the name (e.g. "feature/foo/bar"). This just reads the git config and isn't
+        // an expensive operation, but save the returned remotes for later anyway.
+        remotes = (0, _getRemotes.getRemotes)(otherOptions);
+        if (remotes) {
+            remote = Object.keys(remotes).find((r)=>branch.startsWith(`${r}/`));
+        }
+    }
+    if (remote) {
+        return {
+            remote,
+            remoteBranch: branch.slice(remote.length + 1),
+            remotes
+        };
+    }
+    return {
+        remote: "",
+        remoteBranch: branch,
+        remotes
+    };
+}

package/lib/git/parseRemoteBranch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/git/parseRemoteBranch.ts"],"sourcesContent":["import { getRemotes } from \"./getRemotes.js\";\nimport type { ParsedRemoteBranch, ParseRemoteBranchOptions } from \"./types.js\";\n\n/**\n * Get the remote and branch name from a full branch name that may include a remote prefix.\n * If the path doesn't start with one of `options.knownRemotes` (but has multiple segments),\n * the actual list of remotes will be read via `git config` to see if one of those matches.\n *\n * With `throwOnError: true`, currently it will NOT throw if the branch prefix matches `knownRemotes`\n * regardless of the actual state of remotes in the repo. If it has to get the actual list of\n * remotes, it will throw in the same cases as {@link getRemotes}.\n *\n * NOTE: The additional verification is new in the object params version; the original version\n * incorrectly assumes the first segment before a slash is always a remote.\n */\nexport function parseRemoteBranch(options: ParseRemoteBranchOptions): ParsedRemoteBranch;\n/**\n * @deprecated Use object params version, which does more verification. This version inaccurately\n * assumes the first segment before a slash is always a remote, which could lead to tricky bugs.\n */\nexport function parseRemoteBranch(branch: string): ParsedRemoteBranch;\nexport function parseRemoteBranch(branchOrOptions: string | ParseRemoteBranchOptions): ParsedRemoteBranch {\n  if (typeof branchOrOptions === \"string\") {\n    const branch = branchOrOptions;\n    const firstSlashPos = branch.indexOf(\"/\", 0);\n    return {\n      remote: branch.substring(0, firstSlashPos),\n      remoteBranch: branch.substring(firstSlashPos + 1),\n    };\n  }\n\n  // Remove the list of remotes from the result\n  const { remote, remoteBranch } = parseRemoteBranchPlusRemotes(branchOrOptions);\n  return { remote, remoteBranch };\n}\n\n/**\n * See {@link parseRemoteBranch}. This version also returns the remotes in the result if they were\n * read from git, for reuse by other operations.\n */\nexport function parseRemoteBranchPlusRemotes(\n  options: ParseRemoteBranchOptions\n): ParsedRemoteBranch & { remotes: Record<string, string> | undefined } {\n  const { branch, knownRemotes = [\"origin\", \"upstream\"], ...otherOptions } = options;\n\n  if (!branch.includes(\"/\")) {\n    return { remote: \"\", remoteBranch: branch, remotes: undefined };\n  }\n\n  // As a shortcut, check for the most common remote names before doing git operations\n  let remote = knownRemotes.find((r) => branch.startsWith(`${r}/`));\n\n  let remotes: Record<string, string> | undefined;\n  if (!remote) {\n    // There's a slash in the branch name, but it doesn't start with one of the common remote names.\n    // Get the real list of remotes from git to see if it matches any of those, or is just a branch\n    // with a slash in the name (e.g. \"feature/foo/bar\"). This just reads the git config and isn't\n    // an expensive operation, but save the returned remotes for later anyway.\n    remotes = getRemotes(otherOptions);\n    if (remotes) {\n      remote = Object.keys(remotes).find((r) => branch.startsWith(`${r}/`));\n    }\n  }\n\n  if (remote) {\n    return { remote, remoteBranch: branch.slice(remote.length + 1), remotes };\n  }\n  return { remote: \"\", remoteBranch: branch, remotes };\n}\n"],"names":["parseRemoteBranch","parseRemoteBranchPlusRemotes","branchOrOptions","branch","firstSlashPos","indexOf","remote","substring","remoteBranch","options","knownRemotes","otherOptions","includes","remotes","undefined","find","r","startsWith","getRemotes","Object","keys","slice","length"],"mappings":";;;;;;;;;;;;;;;QAqBgBA;eAAAA;;QAmBAC;eAAAA;;;4BAxCW;AAqBpB,SAASD,kBAAkBE,eAAkD;IAClF,IAAI,OAAOA,oBAAoB,UAAU;QACvC,MAAMC,SAASD;QACf,MAAME,gBAAgBD,OAAOE,OAAO,CAAC,KAAK;QAC1C,OAAO;YACLC,QAAQH,OAAOI,SAAS,CAAC,GAAGH;YAC5BI,cAAcL,OAAOI,SAAS,CAACH,gBAAgB;QACjD;IACF;IAEA,6CAA6C;IAC7C,MAAM,EAAEE,MAAM,EAAEE,YAAY,EAAE,GAAGP,6BAA6BC;IAC9D,OAAO;QAAEI;QAAQE;IAAa;AAChC;AAMO,SAASP,6BACdQ,OAAiC;IAEjC,MAAM,EAAEN,MAAM,EAAEO,eAAe;QAAC;QAAU;KAAW,EAAE,GAAGC,cAAc,GAAGF;IAE3E,IAAI,CAACN,OAAOS,QAAQ,CAAC,MAAM;QACzB,OAAO;YAAEN,QAAQ;YAAIE,cAAcL;YAAQU,SAASC;QAAU;IAChE;IAEA,oFAAoF;IACpF,IAAIR,SAASI,aAAaK,IAAI,CAAC,CAACC,IAAMb,OAAOc,UAAU,CAAC,GAAGD,EAAE,CAAC,CAAC;IAE/D,IAAIH;IACJ,IAAI,CAACP,QAAQ;QACX,gGAAgG;QAChG,+FAA+F;QAC/F,8FAA8F;QAC9F,0EAA0E;QAC1EO,UAAUK,IAAAA,sBAAU,EAACP;QACrB,IAAIE,SAAS;YACXP,SAASa,OAAOC,IAAI,CAACP,SAASE,IAAI,CAAC,CAACC,IAAMb,OAAOc,UAAU,CAAC,GAAGD,EAAE,CAAC,CAAC;QACrE;IACF;IAEA,IAAIV,QAAQ;QACV,OAAO;YAAEA;YAAQE,cAAcL,OAAOkB,KAAK,CAACf,OAAOgB,MAAM,GAAG;YAAIT;QAAQ;IAC1E;IACA,OAAO;QAAEP,QAAQ;QAAIE,cAAcL;QAAQU;IAAQ;AACrD"}

package/lib/git/revertLocalChanges.d.ts

@@ -0,0 +1,9 @@
+import type { GitCommonOptions } from "./types.js";
+/**
+ * Reverts all local changes (both staged and unstaged) by stashing them and then dropping the stash.
+ * @returns True if the revert was successful, false otherwise. It will also be false if there were
+ * no changes to revert. (To distinguish between this case and errors, use the `throwOnError` option.)
+ */
+export declare function revertLocalChanges(options: GitCommonOptions): boolean;
+/** @deprecated Use object params version */
+export declare function revertLocalChanges(cwd: string): boolean;

package/lib/git/revertLocalChanges.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "revertLocalChanges", {
+    enumerable: true,
+    get: function() {
+        return revertLocalChanges;
+    }
+});
+const _git = require("./git.js");
+function revertLocalChanges(cwdOrOptions) {
+    const options = typeof cwdOrOptions === "string" ? {
+        cwd: cwdOrOptions
+    } : cwdOrOptions;
+    const stash = `workspace-tools_${new Date().getTime()}`;
+    if (!(0, _git.git)([
+        "stash",
+        "push",
+        "-u",
+        "-m",
+        stash
+    ], options).success) {
+        return false;
+    }
+    const results = (0, _git.git)([
+        "stash",
+        "list"
+    ], options);
+    if (results.success) {
+        const matched = results.stdout.split(/\n/).find((line)=>line.includes(stash))?.match(/^[^:]+/);
+        if (matched) {
+            (0, _git.git)([
+                "stash",
+                "drop",
+                matched[0]
+            ], options);
+            return true;
+        }
+    }
+    return false;
+}

package/lib/git/revertLocalChanges.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/git/revertLocalChanges.ts"],"sourcesContent":["import { git } from \"./git.js\";\nimport type { GitCommonOptions } from \"./types.js\";\n\n/**\n * Reverts all local changes (both staged and unstaged) by stashing them and then dropping the stash.\n * @returns True if the revert was successful, false otherwise. It will also be false if there were\n * no changes to revert. (To distinguish between this case and errors, use the `throwOnError` option.)\n */\nexport function revertLocalChanges(options: GitCommonOptions): boolean;\n/** @deprecated Use object params version */\nexport function revertLocalChanges(cwd: string): boolean;\nexport function revertLocalChanges(cwdOrOptions: string | GitCommonOptions): boolean {\n  const options: GitCommonOptions = typeof cwdOrOptions === \"string\" ? { cwd: cwdOrOptions } : cwdOrOptions;\n\n  const stash = `workspace-tools_${new Date().getTime()}`;\n  if (!git([\"stash\", \"push\", \"-u\", \"-m\", stash], options).success) {\n    return false;\n  }\n\n  const results = git([\"stash\", \"list\"], options);\n  if (results.success) {\n    const matched = results.stdout\n      .split(/\\n/)\n      .find((line) => line.includes(stash))\n      ?.match(/^[^:]+/);\n\n    if (matched) {\n      git([\"stash\", \"drop\", matched[0]], options);\n      return true;\n    }\n  }\n\n  return false;\n}\n"],"names":["revertLocalChanges","cwdOrOptions","options","cwd","stash","Date","getTime","git","success","results","matched","stdout","split","find","line","includes","match"],"mappings":";;;;+BAWgBA;;;eAAAA;;;qBAXI;AAWb,SAASA,mBAAmBC,YAAuC;IACxE,MAAMC,UAA4B,OAAOD,iBAAiB,WAAW;QAAEE,KAAKF;IAAa,IAAIA;IAE7F,MAAMG,QAAQ,CAAC,gBAAgB,EAAE,IAAIC,OAAOC,OAAO,IAAI;IACvD,IAAI,CAACC,IAAAA,QAAG,EAAC;QAAC;QAAS;QAAQ;QAAM;QAAMH;KAAM,EAAEF,SAASM,OAAO,EAAE;QAC/D,OAAO;IACT;IAEA,MAAMC,UAAUF,IAAAA,QAAG,EAAC;QAAC;QAAS;KAAO,EAAEL;IACvC,IAAIO,QAAQD,OAAO,EAAE;QACnB,MAAME,UAAUD,QAAQE,MAAM,CAC3BC,KAAK,CAAC,MACNC,IAAI,CAAC,CAACC,OAASA,KAAKC,QAAQ,CAACX,SAC5BY,MAAM;QAEV,IAAIN,SAAS;YACXH,IAAAA,QAAG,EAAC;gBAAC;gBAAS;gBAAQG,OAAO,CAAC,EAAE;aAAC,EAAER;YACnC,OAAO;QACT;IACF;IAEA,OAAO;AACT"}

package/lib/git/stageAndCommit.d.ts

@@ -0,0 +1,21 @@
+import type { GitCommitOptions, GitStageOptions } from "./types.js";
+/**
+ * Stages files matching the given patterns.
+ */
+export declare function stage(options: GitStageOptions): void;
+/** @deprecated Use object params version */
+export declare function stage(patterns: string[], cwd: string): void;
+/**
+ * Commit changes. Throws an error on failure by default.
+ */
+export declare function commit(options: GitCommitOptions): void;
+/** @deprecated Use object params version */
+export declare function commit(message: string, cwd: string, options?: string[]): void;
+/**
+ * Stages files matching the given patterns and creates a commit with the specified message.
+ * Convenience function that combines `stage()` and `commit()`.
+ * Throws an error on commit failure by default.
+ */
+export declare function stageAndCommit(options: GitStageOptions & GitCommitOptions): void;
+/** @deprecated Use object params version */
+export declare function stageAndCommit(patterns: string[], message: string, cwd: string, commitOptions?: string[]): void;

package/lib/git/stageAndCommit.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    commit: null,
+    stage: null,
+    stageAndCommit: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get commit () {
+        return commit;
+    },
+    get stage () {
+        return stage;
+    },
+    get stageAndCommit () {
+        return stageAndCommit;
+    }
+});
+const _git = require("./git.js");
+function stage(patternsOrOptions, cwd) {
+    const { patterns, ...options } = Array.isArray(patternsOrOptions) ? {
+        patterns: patternsOrOptions,
+        cwd: cwd
+    } : patternsOrOptions;
+    for (const pattern of patterns){
+        (0, _git.git)([
+            "add",
+            pattern
+        ], {
+            ...options,
+            description: `Staging changes (git add ${pattern})`
+        });
+    }
+}
+function commit(messageOrOptions, _cwd, _options) {
+    const { message, options, ...gitOptions } = typeof messageOrOptions === "string" ? {
+        message: messageOrOptions,
+        cwd: _cwd,
+        options: _options
+    } : messageOrOptions;
+    (0, _git.git)([
+        "commit",
+        "-m",
+        message,
+        ...options || []
+    ], {
+        throwOnError: true,
+        description: "Committing changes",
+        ...gitOptions
+    });
+}
+function stageAndCommit(patternsOrOptions, message, cwd, commitOptions) {
+    const options = Array.isArray(patternsOrOptions) ? {
+        patterns: patternsOrOptions,
+        message: message,
+        cwd: cwd,
+        options: commitOptions
+    } : patternsOrOptions;
+    stage(options);
+    commit(options);
+}

package/lib/git/stageAndCommit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/git/stageAndCommit.ts"],"sourcesContent":["import { git } from \"./git.js\";\nimport type { GitCommitOptions, GitStageOptions } from \"./types.js\";\n\n/**\n * Stages files matching the given patterns.\n */\nexport function stage(options: GitStageOptions): void;\n/** @deprecated Use object params version */\nexport function stage(patterns: string[], cwd: string): void;\nexport function stage(patternsOrOptions: string[] | GitStageOptions, cwd?: string): void {\n  const { patterns, ...options } = Array.isArray(patternsOrOptions)\n    ? { patterns: patternsOrOptions, cwd: cwd! }\n    : patternsOrOptions;\n\n  for (const pattern of patterns) {\n    git([\"add\", pattern], { ...options, description: `Staging changes (git add ${pattern})` });\n  }\n}\n\n/**\n * Commit changes. Throws an error on failure by default.\n */\nexport function commit(options: GitCommitOptions): void;\n/** @deprecated Use object params version */\nexport function commit(message: string, cwd: string, options?: string[]): void;\nexport function commit(messageOrOptions: string | GitCommitOptions, _cwd?: string, _options?: string[]): void {\n  const { message, options, ...gitOptions } =\n    typeof messageOrOptions === \"string\"\n      ? { message: messageOrOptions, cwd: _cwd!, options: _options }\n      : messageOrOptions;\n\n  git([\"commit\", \"-m\", message, ...(options || [])], {\n    throwOnError: true,\n    description: \"Committing changes\",\n    ...gitOptions,\n  });\n}\n\n/**\n * Stages files matching the given patterns and creates a commit with the specified message.\n * Convenience function that combines `stage()` and `commit()`.\n * Throws an error on commit failure by default.\n */\nexport function stageAndCommit(options: GitStageOptions & GitCommitOptions): void;\n/** @deprecated Use object params version */\nexport function stageAndCommit(patterns: string[], message: string, cwd: string, commitOptions?: string[]): void;\nexport function stageAndCommit(\n  patternsOrOptions: string[] | (GitStageOptions & GitCommitOptions),\n  message?: string,\n  cwd?: string,\n  commitOptions?: string[]\n): void {\n  const options: GitStageOptions & GitCommitOptions = Array.isArray(patternsOrOptions)\n    ? { patterns: patternsOrOptions, message: message!, cwd: cwd!, options: commitOptions }\n    : patternsOrOptions;\n\n  stage(options);\n  commit(options);\n}\n"],"names":["commit","stage","stageAndCommit","patternsOrOptions","cwd","patterns","options","Array","isArray","pattern","git","description","messageOrOptions","_cwd","_options","message","gitOptions","throwOnError","commitOptions"],"mappings":";;;;;;;;;;;;;;;;QAyBgBA;eAAAA;;QAhBAC;eAAAA;;QAqCAC;eAAAA;;;qBA9CI;AASb,SAASD,MAAME,iBAA6C,EAAEC,GAAY;IAC/E,MAAM,EAAEC,QAAQ,EAAE,GAAGC,SAAS,GAAGC,MAAMC,OAAO,CAACL,qBAC3C;QAAEE,UAAUF;QAAmBC,KAAKA;IAAK,IACzCD;IAEJ,KAAK,MAAMM,WAAWJ,SAAU;QAC9BK,IAAAA,QAAG,EAAC;YAAC;YAAOD;SAAQ,EAAE;YAAE,GAAGH,OAAO;YAAEK,aAAa,CAAC,yBAAyB,EAAEF,QAAQ,CAAC,CAAC;QAAC;IAC1F;AACF;AAQO,SAAST,OAAOY,gBAA2C,EAAEC,IAAa,EAAEC,QAAmB;IACpG,MAAM,EAAEC,OAAO,EAAET,OAAO,EAAE,GAAGU,YAAY,GACvC,OAAOJ,qBAAqB,WACxB;QAAEG,SAASH;QAAkBR,KAAKS;QAAOP,SAASQ;IAAS,IAC3DF;IAENF,IAAAA,QAAG,EAAC;QAAC;QAAU;QAAMK;WAAaT,WAAW,EAAE;KAAE,EAAE;QACjDW,cAAc;QACdN,aAAa;QACb,GAAGK,UAAU;IACf;AACF;AAUO,SAASd,eACdC,iBAAkE,EAClEY,OAAgB,EAChBX,GAAY,EACZc,aAAwB;IAExB,MAAMZ,UAA8CC,MAAMC,OAAO,CAACL,qBAC9D;QAAEE,UAAUF;QAAmBY,SAASA;QAAUX,KAAKA;QAAME,SAASY;IAAc,IACpFf;IAEJF,MAAMK;IACNN,OAAOM;AACT"}

package/lib/git/types.d.ts

@@ -43,9 +43,12 @@ export type ParseRemoteBranchOptions = GitCommonOptions & {
     knownRemotes?: string[];
 };
 export type ParsedRemoteBranch = {
-    /** Remote name, e.g. `origin` */
+    /**
+     * Remote name, e.g. `origin`.
+     * May be an empty string if the original branch reference didn't include a remote.
+     */
     remote: string;
-    /** Branch name without remote, e.g. `main` */
+    /** Branch name without remote, e.g. `main`. This is always set. */
     remoteBranch: string;
 };
 export type GitStageOptions = {

package/lib/git/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/git/types.ts"],"sourcesContent":["/** Options used for all git operations and wrappers */\nexport type GitCommonOptions = {\n  cwd: string;\n  /** If true, throw if the command fails */\n  throwOnError?: boolean;\n};\n\n/** Options for git operations related to a branch */\nexport type GitBranchOptions = { branch: string } & GitCommonOptions;\n\nexport type GitFetchOptions = GitCommonOptions & {\n  /** Remote name to fetch, e.g. \"origin\" (if not provided, fetches all remotes) */\n  remote?: string;\n  /** Branch name to fetch, e.g. \"main\". To use this, `remote` must also be set. */\n  remoteBranch?: string;\n  /** Extra command line options */\n  options?: string[];\n};\n\nexport type GetChangesBetweenRefsOptions = GitCommonOptions & {\n  /** The starting reference */\n  fromRef: string;\n  /** The ending reference */\n  toRef?: string;\n  /** Extra command line options */\n  options?: string[];\n  /** Optional file pattern to filter results */\n  pattern?: string;\n};\n\nexport type GitInitOptions = Omit<GitCommonOptions, \"throwOnError\"> & {\n  /** Email to set in the git config, if not already set */\n  email?: string;\n  /** Username to set in the git config, if not already set */\n  username?: string;\n};\n\nexport type ParseRemoteBranchOptions = GitCommonOptions & {\n  /** Branch name with possible remote prefix */\n  branch: string;\n  /**\n   * Well-known remote names. If these appear at the beginning of a branch name, they'll always\n   * be returned as `ParsedRemoteBranch.remote` regardless of whether they exist locally.\n   * @default [\"origin\", \"upstream\"]\n   */\n  knownRemotes?: string[];\n};\n\nexport type ParsedRemoteBranch = {\n  /** Remote name, e.g. `origin` */\n  remote: string;\n  /** Branch name without remote, e.g. `main` */\n  remoteBranch: string;\n};\n\nexport type GitStageOptions = {\n  /** File patterns to stage */\n  patterns: string[];\n} & GitCommonOptions;\n\nexport type GitCommitOptions = GitCommonOptions & {\n  /** Commit message */\n  message: string;\n  /** Additional git commit options */\n  options?: string[];\n};\n"],"names":[],"mappings":"AAAA,qDAAqD"}
+{"version":3,"sources":["../../src/git/types.ts"],"sourcesContent":["/** Options used for all git operations and wrappers */\nexport type GitCommonOptions = {\n  cwd: string;\n  /** If true, throw if the command fails */\n  throwOnError?: boolean;\n};\n\n/** Options for git operations related to a branch */\nexport type GitBranchOptions = { branch: string } & GitCommonOptions;\n\nexport type GitFetchOptions = GitCommonOptions & {\n  /** Remote name to fetch, e.g. \"origin\" (if not provided, fetches all remotes) */\n  remote?: string;\n  /** Branch name to fetch, e.g. \"main\". To use this, `remote` must also be set. */\n  remoteBranch?: string;\n  /** Extra command line options */\n  options?: string[];\n};\n\nexport type GetChangesBetweenRefsOptions = GitCommonOptions & {\n  /** The starting reference */\n  fromRef: string;\n  /** The ending reference */\n  toRef?: string;\n  /** Extra command line options */\n  options?: string[];\n  /** Optional file pattern to filter results */\n  pattern?: string;\n};\n\nexport type GitInitOptions = Omit<GitCommonOptions, \"throwOnError\"> & {\n  /** Email to set in the git config, if not already set */\n  email?: string;\n  /** Username to set in the git config, if not already set */\n  username?: string;\n};\n\nexport type ParseRemoteBranchOptions = GitCommonOptions & {\n  /** Branch name with possible remote prefix */\n  branch: string;\n  /**\n   * Well-known remote names. If these appear at the beginning of a branch name, they'll always\n   * be returned as `ParsedRemoteBranch.remote` regardless of whether they exist locally.\n   * @default [\"origin\", \"upstream\"]\n   */\n  knownRemotes?: string[];\n};\n\nexport type ParsedRemoteBranch = {\n  /**\n   * Remote name, e.g. `origin`.\n   * May be an empty string if the original branch reference didn't include a remote.\n   */\n  remote: string;\n  /** Branch name without remote, e.g. `main`. This is always set. */\n  remoteBranch: string;\n};\n\nexport type GitStageOptions = {\n  /** File patterns to stage */\n  patterns: string[];\n} & GitCommonOptions;\n\nexport type GitCommitOptions = GitCommonOptions & {\n  /** Commit message */\n  message: string;\n  /** Additional git commit options */\n  options?: string[];\n};\n"],"names":[],"mappings":"AAAA,qDAAqD"}

package/lib/workspaces/getCatalogVersion.d.ts

@@ -9,18 +9,23 @@ export declare function isCatalogVersion(version: string): boolean;
  *
  * Throws an error if there's anything invalid about the catalog spec (no catalogs defined,
  * no matching catalog, catalog doesn't contain `name`, recursive catalog version).
+ * If `allowNotFound` is true, it will return undefined if no match instead.
  *
  * Returns undefined if the version doesn't start with `catalog:`.
  * @see https://pnpm.io/catalogs
  * @see https://yarnpkg.com/features/catalogs
  *
- * @param name - Dependency package name
- * @param version - Dependency version spec, e.g. `catalog:my-catalog` or `catalog:`,
- * or some non-catalog spec like `^1.2.3`
  * @returns Actual version spec from the catalog, or undefined if not a catalog version
+ * (or undefined if `allowNotFound` is true and the package isn't in the catalog)
  */
 export declare function getCatalogVersion(params: {
+    /** Dependency package name */
     name: string;
+    /**
+     * Dependency version spec, e.g. `catalog:my-catalog` or `catalog:`, or some non-catalog
+     * spec like `^1.2.3`
+     */
     version: string;
     catalogs: Catalogs | undefined;
+    allowNotFound?: boolean;
 }): string | undefined;