isomorphic-git 1.21.0 → 1.23.0

package/index.d.ts

@@ -648,6 +648,7 @@ declare namespace index {
     export { TREE };
     export { WORKDIR };
     export { add };
+    export { abortMerge };
     export { addNote };
     export { addRemote };
     export { annotatedTag };
@@ -742,6 +743,8 @@ export var Errors: Readonly<{
     UnsafeFilepathError: typeof UnsafeFilepathError;
     UrlParseError: typeof UrlParseError;
     UserCanceledError: typeof UserCanceledError;
+    UnmergedPathsError: typeof UnmergedPathsError;
+    IndexResetError: typeof IndexResetError;
 }>;
 /**
  * @returns {Walker}
@@ -759,6 +762,37 @@ export function TREE({ ref }?: {
  * @returns {Walker}
  */
 export function WORKDIR(): Walker;
+/**
+ * Abort a merge in progress.
+ *
+ * Based on the behavior of git reset --merge, i.e.  "Resets the index and updates the files in the working tree that are different between <commit> and HEAD, but keeps those which are different between the index and working tree (i.e. which have changes which have not been added). If a file that is different between <commit> and the index has unstaged changes, reset is aborted."
+ *
+ * Essentially, abortMerge will reset any files affected by merge conflicts to their last known good version at HEAD.
+ * Any unstaged changes are saved and any staged changes are reset as well.
+ *
+ * NOTE: The behavior of this command differs slightly from canonical git in that an error will be thrown if a file exists in the index and nowhere else.
+ * Canonical git will reset the file and continue aborting the merge in this case.
+ *
+ * **WARNING:** Running git merge with non-trivial uncommitted changes is discouraged: while possible, it may leave you in a state that is hard to back out of in the case of a conflict.
+ * If there were uncommitted changes when the merge started (and especially if those changes were further modified after the merge was started), `git.abortMerge` will in some cases be unable to reconstruct the original (pre-merge) changes.
+ *
+ * @param {object} args
+ * @param {FsClient} args.fs - a file system implementation
+ * @param {string} args.dir - The [working tree](dir-vs-gitdir.md) directory path
+ * @param {string} [args.gitdir=join(dir, '.git')] - [required] The [git directory](dir-vs-gitdir.md) path
+ * @param {string} [args.commit='HEAD'] - commit to reset the index and worktree to, defaults to HEAD
+ * @param {object} [args.cache] - a [cache](cache.md) object
+ *
+ * @returns {Promise<void>} Resolves successfully once the git index has been updated
+ *
+ */
+export function abortMerge({ fs: _fs, dir, gitdir, commit, cache, }: {
+    fs: CallbackFsClient | PromiseFsClient;
+    dir: string;
+    gitdir?: string;
+    commit?: string;
+    cache?: any;
+}): Promise<void>;
 /**
  * Add a file to the git index (aka staging area)
  *
@@ -4176,6 +4210,36 @@ declare namespace UserCanceledError {
     const code_28: 'UserCanceledError';
     export { code_28 as code };
 }
+declare class UnmergedPathsError extends BaseError {
+    /**
+     * @param {Array<string>} filepaths
+     */
+    constructor(filepaths: string[]);
+    code: "UnmergedPathsError";
+    name: "UnmergedPathsError";
+    data: {
+        filepaths: string[];
+    };
+}
+declare namespace UnmergedPathsError {
+    const code_29: 'UnmergedPathsError';
+    export { code_29 as code };
+}
+declare class IndexResetError extends BaseError {
+    /**
+     * @param {Array<string>} filepaths
+     */
+    constructor(filepath: any);
+    code: "IndexResetError";
+    name: "IndexResetError";
+    data: {
+        filepath: any;
+    };
+}
+declare namespace IndexResetError {
+    const code_30: 'IndexResetError';
+    export { code_30 as code };
+}
 /**
  * @typedef {Object} GitProgressEvent
  * @property {string} phase