es-git 0.3.0-next.129 → 0.3.0-next.131

package/index.d.ts

@@ -825,6 +825,125 @@ export interface AddMailmapEntryData {
  * ```
  */
 export declare function createMailmapFromBuffer(content: string): Mailmap
+export type FileFavor = /**
+ * When a region of a file is changed in both branches, a conflict will be
+ * recorded in the index so that git_checkout can produce a merge file with
+ * conflict markers in the working directory. This is the default.
+ */
+'Normal' | /**
+ * When a region of a file is changed in both branches, the file created
+ * in the index will contain the "ours" side of any conflicting region.
+ * The index will not record a conflict.
+ */
+'Ours' | /**
+ * When a region of a file is changed in both branches, the file created
+ * in the index will contain the "theirs" side of any conflicting region.
+ * The index will not record a conflict.
+ */
+'Theirs' | /**
+ * When a region of a file is changed in both branches, the file created
+ * in the index will contain each unique line from each side, which has
+ * the result of combining both files. The index will not record a conflict.
+ */
+'Union';
+export interface MergeOptions {
+  /** Detect file renames */
+  findRenames?: boolean
+  /**
+   * If a conflict occurs, exit immediately instead of attempting to continue
+   * resolving conflicts
+   */
+  failOnConflict?: boolean
+  /** Do not write the REUC extension on the generated index */
+  skipReuc?: boolean
+  /**
+   * If the commits being merged have multiple merge bases, do not build a
+   * recursive merge base (by merging the multiple merge bases), instead
+   * simply use the first base.
+   */
+  noRecursive?: boolean
+  /** Similarity to consider a file renamed (default 50) */
+  renameThreshold?: number
+  /**
+   *  Maximum similarity sources to examine for renames (default 200).
+   * If the number of rename candidates (add / delete pairs) is greater
+   * than this value, inexact rename detection is aborted. This setting
+   * overrides the `merge.renameLimit` configuration value.
+   */
+  targetLimit?: number
+  /**
+   * Maximum number of times to merge common ancestors to build a
+   * virtual merge base when faced with criss-cross merges.  When
+   * this limit is reached, the next ancestor will simply be used
+   * instead of attempting to merge it.  The default is unlimited.
+   */
+  recursionLimit?: number
+  /** Specify a side to favor for resolving conflicts */
+  filFavor?: FileFavor
+  /** Create standard conflicted merge files */
+  standardStyle?: boolean
+  /** Create diff3-style file */
+  diff3Style?: boolean
+  /** Condense non-alphanumeric regions for simplified diff file */
+  simplifyAlnum?: boolean
+  /** Ignore all whitespace */
+  ignoreWhitespace?: boolean
+  /** Ignore changes in amount of whitespace */
+  ignoreWhitespaceChange?: boolean
+  /** Ignore whitespace at end of line */
+  ignoreWhitespaceEol?: boolean
+  /** Use the "patience diff" algorithm */
+  patience?: boolean
+  /** Take extra time to find minimal diff */
+  minimal?: boolean
+}
+export interface MergeAnalysis {
+  /** No merge is possible. */
+  none: boolean
+  /**
+   * A "normal" merge; both HEAD and the given merge input have diverged
+   * from their common ancestor. The divergent commits must be merged.
+   */
+  normal: boolean
+  /**
+   * All given merge inputs are reachable from HEAD, meaning the
+   * repository is up-to-date and no merge needs to be performed.
+   */
+  upToDate: boolean
+  /**
+   * The given merge input is a fast-forward from HEAD and no merge
+   * needs to be performed.  Instead, the client can check out the
+   * given merge input.
+   */
+  fastForward: boolean
+  /**
+   * The HEAD of the current repository is "unborn" and does not point to
+   * a valid commit.  No merge can be performed, but the caller may wish
+   * to simply set HEAD to the target commit(s).
+   */
+  unborn: boolean
+}
+export interface MergePreference {
+  /**
+   * No configuration was found that suggests a preferred behavior for
+   * merge.
+   */
+  none: boolean
+  /**
+   * There is a `merge.ff=false` configuration setting, suggesting that
+   * the user does not want to allow a fast-forward merge.
+   */
+  noFastForward: boolean
+  /**
+   * There is a `merge.ff=only` configuration setting, suggesting that
+   * the user only wants fast-forward merges.
+   */
+  fastForwardOnly: boolean
+}
+export interface MergeAnalysisResult {
+  analysis: MergeAnalysis
+  preference: MergePreference
+}
 /**
  * - `Any` : Any kind of git object
  * - `Commit` : An object which corresponds to a git commit
@@ -1715,6 +1834,45 @@ export interface CreateLightweightTagOptions {
  * - `PostOrder` : Runs the traversal in post-order.
  */
 export type TreeWalkMode = 'PreOrder' | 'PostOrder';
+/**
+ * A structure to represent an annotated commit, the input to merge and rebase.
+ *
+ * An annotated commit contains information about how it was looked up, which
+ * may be useful for functions like merge or rebase to provide context to the
+ * operation.
+ */
+export declare class AnnotatedCommit {
+  /**
+   * Gets the commit ID that the given Annotated Commit refers to.
+   *
+   * @category AnnotatedCommit/Methods
+   * @signature
+   * ```ts
+   * class AnnotatedCommit {
+   *   id(): string;
+   * }
+   * ```
+   *
+   * @returns The commit ID that this Annotated Commit refers to.
+   */
+  id(): string
+  /**
+   * Get the refname that the given Annotated Commit refers to.
+   *
+   * @category AnnotatedCommit/Methods
+   * @signature
+   * ```ts
+   * class AnnotatedCommit {
+   *   refname(): string | null;
+   * }
+   * ```
+   *
+   * @returns The refname that this Annotated Commit refers to. If this created from a reference,
+   * the return value is `null`.
+   * @throws Throws error if the refname is not valid utf-8.
+   */
+  refname(): string | null
+}
 /** A wrapper around git2::Blame providing Node.js bindings */
 export declare class Blame {
   /**
@@ -3931,6 +4089,57 @@ export declare class Remote {
  * This class corresponds to a git repository in libgit2.
  */
 export declare class Repository {
+  /**
+   * Creates an Annotated Commit from the given commit.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   getAnnotatedCommit(commit: Commit): AnnotatedCommit;
+   * }
+   * ```
+   *
+   * @param {Commit} commit - Commit to creates a Annotated Commit.
+   * @returns An Annotated Commit created from commit.
+   */
+  getAnnotatedCommit(commit: Commit): AnnotatedCommit
+  /**
+   * Creates a Annotated Commit from the given reference.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   getAnnotatedCommitFromReference(reference: Reference): AnnotatedCommit;
+   * }
+   * ```
+   *
+   * @param {Reference} reference - Reference to creates a Annotated Commit.
+   * @returns An Annotated Commit created from reference.
+   */
+  getAnnotatedCommitFromReference(reference: GitReference): AnnotatedCommit
+  /**
+   * Creates a Annotated Commit from `FETCH_HEAD`.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   getAnnotatedCommitFromFetchHead(
+   *     branchName: string,
+   *     remoteUrl: string,
+   *     id: string,
+   *   ): AnnotatedCommit;
+   * }
+   * ```
+   *
+   * @param {String} branchName - Name of the remote branch.
+   * @param {String} remoteUrl - Url of the remote.
+   * @param {String} id - The commit object id of the remote branch.
+   * @returns An Annotated Commit created from `FETCH_HEAD`.
+   */
+  getAnnotatedCommitFromFetchHead(branchName: string, remoteUrl: string, id: string): AnnotatedCommit
   /**
    * Creates a blame object for the file at the given path
    *
@@ -4408,6 +4617,225 @@ export declare class Repository {
    * @returns The mailmap object if it exists, null otherwise
    */
   mailmap(): Mailmap | null
+  /**
+   * Find a merge base between two commits
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   mergeBase(one: string, two: string): string;
+   * }
+   * ```
+   *
+   * @param {string} one - One of the commits OID.
+   * @param {string} two - The other commit OID.
+   * @returns The OID of a merge base between 'one' and 'two'.
+   */
+  getMergeBase(one: string, two: string): string
+  /**
+   * Find a merge base given a list of commits
+   *
+   * This behaves similar to [`git merge-base`](https://git-scm.com/docs/git-merge-base#_discussion).
+   * Given three commits `a`, `b`, and `c`, `getMergeBaseMany([a, b, c])`
+   * will compute a hypothetical commit `m`, which is a merge between `b`
+   * and `c`.
+   *
+   * For example, with the following topology:
+   * ```text
+   *        o---o---o---o---C
+   *       /
+   *      /   o---o---o---B
+   *     /   /
+   * ---2---1---o---o---o---A
+   * ```
+   *
+   * the result of `getMergeBaseMany([a, b, c])` is 1. This is because the
+   * equivalent topology with a merge commit `m` between `b` and `c` would
+   * is:
+   * ```text
+   *        o---o---o---o---o
+   *       /                 \
+   *      /   o---o---o---o---M
+   *     /   /
+   * ---2---1---o---o---o---A
+   * ```
+   *
+   * and the result of `getMergeBaseMany([a, m])` is 1.
+   *
+   * ---
+   *
+   * If you're looking to recieve the common merge base between all the
+   * given commits, use `getMergeBaseOctopus`.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   getMergeBaseMany(oids: string[]): string;
+   * }
+   * ```
+   *
+   * @param {string[]} oids - Oids of the commits.
+   * @returns The OID of a merge base considering all the commits.
+   */
+  getMergeBaseMany(oids: Array<string>): string
+  /**
+   * Find a merge base in preparation for an octopus merge.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   getMergeBaseOctopus(oids: string[]): string;
+   * }
+   * ```
+   *
+   * @param {string[]} oids - Oids of the commits.
+   * @returns The OID of a merge base considering all the commits.
+   */
+  getMergeBaseOctopus(oids: Array<string>): string
+  /**
+   * Find all merge bases between two commits
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   getMergeBases(one: string, two: string): string[];
+   * }
+   * ```
+   *
+   * @param {string} one - One of the commits OID.
+   * @param {string} two - The other commit OID.
+   * @returns Array in which to store the resulting OIDs.
+   */
+  getMergeBases(one: string, two: string): Array<string>
+  /**
+   * Find all merge bases given a list of commits
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   getMergeBasesMany(oids: string[]): string[];
+   * }
+   * ```
+   *
+   * @param {string[]} oids - Oids of the commits.
+   * @returns Array in which to store the resulting OIDs.
+   */
+  getMergeBasesMany(oids: Array<string>): Array<string>
+  /**
+   * Merges the given commit(s) into HEAD, writing the results into the
+   * working directory. Any changes are staged for commit and any conflicts
+   * are written to the index. Callers should inspect the repository's index
+   * after this completes, resolve any conflicts and prepare a commit.
+   *
+   * For compatibility with git, the repository is put into a merging state.
+   * Once the commit is done (or if the user wishes to abort), you should
+   * clear this state by calling `cleanupState()`.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   merge(
+   *     annotatedCommits: AnnotatedCommit[],
+   *     mergeOptions?: MergeOptions | undefined | null,
+   *     checkoutOptions?: CheckoutOptions | undefined | null,
+   *   ): void;
+   * }
+   * ```
+   *
+   * @param {AnnotatedCommit[]} annotatedCommits - Commits to merge.
+   * @param {MergeOptions} [mergeOptions] - Merge options.
+   * @param {CheckoutOptions} [checkoutOptions] - Checkout options.
+   */
+  merge(annotatedCommits: Array<AnnotatedCommit>, mergeOptions?: MergeOptions | undefined | null, checkoutOptions?: CheckoutOptions | undefined | null): void
+  /**
+   * Merge two commits, producing an index that reflects the result of
+   * the merge. The index may be written as-is to the working directory or
+   * checked out. If the index is to be converted to a tree, the caller
+   * should resolve any conflicts that arose as part of the merge.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   mergeCommits(
+   *     ourCommit: Commit,
+   *     theirCommit: Commit,
+   *     options?: MergeOptions | undefined | null,
+   *   ): Index;
+   * }
+   * ```
+   *
+   * @param {Commit} outCommit - The commit that reflects the destination tree.
+   * @param {Commit} theirCommit - The commit to merge in to `ourCommit`.
+   * @param {MergeOptions} [options] - Merge options.
+   * @returns The index result.
+   */
+  mergeCommits(ourCommit: Commit, theirCommit: Commit, options?: MergeOptions | undefined | null): Index
+  /**
+   * Merge two trees, producing an index that reflects the result of
+   * the merge. The index may be written as-is to the working directory or
+   * checked out. If the index is to be converted to a tree, the caller
+   * should resolve any conflicts that arose as part of the merge.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   mergeTrees(
+   *     ancestorTree: Tree,
+   *     ourTree: Tree,
+   *     theirTree: Tree,
+   *     options?: MergeOptions | undefined | null,
+   *   ): Index;
+   * }
+   * ```
+   *
+   * @param {Tree} ancestorTree - The common ancestor between.
+   * @param {Tree} outTree - The tree that reflects the destination tree.
+   * @param {Tree} theirTree - The tree to merge in to `ourTree`.
+   * @param {MergeOptions} [options] - Merge options.
+   * @returns The index result.
+   */
+  mergeTrees(ancestorTree: Tree, ourTree: Tree, theirTree: Tree, options?: MergeOptions | undefined | null): Index
+  /**
+   * Analyzes the given branch(es) and determines the opportunities for
+   * merging them into the HEAD of the repository.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   analyzeMergeFor(theirHeads: AnnotatedCommit[]): MergeAnalysisResult;
+   * }
+   * ```
+   *
+   * @param {AnnotatedCommit[]} theirHeads - The heads to merge into.
+   * @returns Merge analysis result.
+   */
+  analyzeMerge(theirHeads: Array<AnnotatedCommit>): MergeAnalysisResult
+  /**
+   * Analyzes the given branch(es) and determines the opportunities for
+   * merging them into a reference.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   analyzeMergeForRef(ourRef: Reference, theirHeads: AnnotatedCommit[]): MergeAnalysisResult;
+   * }
+   * ```
+   *
+   * @param {Reference} ourRef - The reference to perform the analysis from.
+   * @param {AnnotatedCommit[]} theirHeads - The heads to merge into.
+   * @returns Merge analysis result.
+   */
+  analyzeMergeForRef(ourRef: Reference, theirHeads: Array<AnnotatedCommit>): MergeAnalysisResult
   /**
    * Lookup a reference to one of the objects in a repository.
    *
@@ -4701,6 +5129,64 @@ export declare class Repository {
    * @param {string} refname - Specified reference to point into `HEAD`.
    */
   setHead(refname: string): void
+  /**
+   * Determines whether the repository `HEAD` is detached.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   headDetached(): boolean;
+   * }
+   * ```
+   *
+   * @returns Returns `true` if the repository `HEAD` is detached.
+   */
+  headDetached(): boolean
+  /**
+   * Make the repository HEAD directly point to the commit.
+   *
+   * If the provided commitish cannot be found in the repository, the HEAD
+   * is unaltered and an error is returned.
+   *
+   * If the provided commitish cannot be peeled into a commit, the HEAD is
+   * unaltered and an error is returned.
+   *
+   * Otherwise, the HEAD will eventually be detached and will directly point
+   * to the peeled commit.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   setHeadDetached(commitish: Commit): void;
+   * }
+   * ```
+   *
+   * @param {Commit} commitish - A Commit which the HEAD should point to.
+   */
+  setHeadDetached(commit: Commit): void
+  /**
+   * Make the repository HEAD directly point to the commit.
+   *
+   * If the provided commitish cannot be found in the repository, the HEAD
+   * is unaltered and an error is returned.
+   * If the provided commitish cannot be peeled into a commit, the HEAD is
+   * unaltered and an error is returned.
+   * Otherwise, the HEAD will eventually be detached and will directly point
+   * to the peeled commit.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   setHeadDetachedFromAnnotated(commitish: AnnotatedCommit): void;
+   * }
+   * ```
+   *
+   * @param {AnnotatedCommit} commitish - An Annotated Commit which the HEAD should point to.
+   */
+  setHeadDetachedFromAnnotated(commitish: AnnotatedCommit): void
   /**
    * Extract a signature from an object identified by its ID.
    *
@@ -4720,6 +5206,19 @@ export declare class Repository {
    *          or null if the object is not signed.
    */
   extractSignature(oid: string): ExtractedSignature | null
+  /**
+   * Remove all the metadata associated with an ongoing command like merge,
+   * revert, cherry-pick, etc. For example: `MERGE_HEAD`, `MERGE_MSG`, etc.
+   *
+   * @category Repository/Methods
+   * @signature
+   * ```ts
+   * class Repository {
+   *   cleanupState(): void;
+   * }
+   * ```
+   */
+  cleanupState(): void
   /**
    * Execute a rev-parse operation against the `spec` listed.
    *

package/index.js

@@ -310,8 +310,9 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { Blame, BlameHunks, BlameHunksByLine, Blob, isValidBranchName, Branch, Branches, BranchType, Commit, ConfigLevel, ConfigEntries, Config, openConfig, openDefaultConfig, findGlobalConfigPath, findSystemConfigPath, findXdgConfigPath, parseConfigBool, parseConfigI32, parseConfigI64, DiffFlags, diffFlagsContains, DeltaType, DiffFormat, Diff, DiffStats, Deltas, DiffDelta, FileMode, DiffFile, IndexStage, Index, IndexEntries, Mailmap, createMailmapFromBuffer, ObjectType, GitObject, isValidOid, isZeroOid, zeroOid, hashObjectOid, hashFileOid, ReferenceType, Reference, isValidReferenceName, ReferenceFormat, normalizeReferenceName, Direction, CredentialType, FetchPrune, AutotagOption, RemoteRedirect, Remote, RepositoryState, RepositoryInitMode, Repository, initRepository, openRepository, discoverRepository, cloneRepository, RevparseMode, revparseModeContains, RevwalkSort, Revwalk, createSignature, StatusShow, Statuses, StatusesIter, StatusEntry, isValidTagName, Tag, TreeWalkMode, Tree, TreeIter, TreeEntry } = nativeBinding
+const { AnnotatedCommit, Blame, BlameHunks, BlameHunksByLine, Blob, isValidBranchName, Branch, Branches, BranchType, Commit, ConfigLevel, ConfigEntries, Config, openConfig, openDefaultConfig, findGlobalConfigPath, findSystemConfigPath, findXdgConfigPath, parseConfigBool, parseConfigI32, parseConfigI64, DiffFlags, diffFlagsContains, DeltaType, DiffFormat, Diff, DiffStats, Deltas, DiffDelta, FileMode, DiffFile, IndexStage, Index, IndexEntries, Mailmap, createMailmapFromBuffer, FileFavor, ObjectType, GitObject, isValidOid, isZeroOid, zeroOid, hashObjectOid, hashFileOid, ReferenceType, Reference, isValidReferenceName, ReferenceFormat, normalizeReferenceName, Direction, CredentialType, FetchPrune, AutotagOption, RemoteRedirect, Remote, RepositoryState, RepositoryInitMode, Repository, initRepository, openRepository, discoverRepository, cloneRepository, RevparseMode, revparseModeContains, RevwalkSort, Revwalk, createSignature, StatusShow, Statuses, StatusesIter, StatusEntry, isValidTagName, Tag, TreeWalkMode, Tree, TreeIter, TreeEntry } = nativeBinding
 
+module.exports.AnnotatedCommit = AnnotatedCommit
 module.exports.Blame = Blame
 module.exports.BlameHunks = BlameHunks
 module.exports.BlameHunksByLine = BlameHunksByLine
@@ -347,6 +348,7 @@ module.exports.Index = Index
 module.exports.IndexEntries = IndexEntries
 module.exports.Mailmap = Mailmap
 module.exports.createMailmapFromBuffer = createMailmapFromBuffer
+module.exports.FileFavor = FileFavor
 module.exports.ObjectType = ObjectType
 module.exports.GitObject = GitObject
 module.exports.isValidOid = isValidOid

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-git",
-  "version": "0.3.0-next.129+c063836",
+  "version": "0.3.0-next.131+28f3abd",
   "main": "index.js",
   "types": "index.d.ts",
   "files": [
@@ -57,15 +57,15 @@
     "vitest": "^3.0.5"
   },
   "optionalDependencies": {
-    "es-git-darwin-x64": "0.3.0-next.129+c063836",
-    "es-git-darwin-arm64": "0.3.0-next.129+c063836",
-    "es-git-win32-x64-msvc": "0.3.0-next.129+c063836",
-    "es-git-win32-arm64-msvc": "0.3.0-next.129+c063836",
-    "es-git-linux-x64-gnu": "0.3.0-next.129+c063836",
-    "es-git-linux-x64-musl": "0.3.0-next.129+c063836",
-    "es-git-android-arm64": "0.3.0-next.129+c063836",
-    "es-git-linux-arm64-gnu": "0.3.0-next.129+c063836",
-    "es-git-linux-arm64-musl": "0.3.0-next.129+c063836",
-    "es-git-android-arm-eabi": "0.3.0-next.129+c063836"
+    "es-git-darwin-x64": "0.3.0-next.131+28f3abd",
+    "es-git-darwin-arm64": "0.3.0-next.131+28f3abd",
+    "es-git-win32-x64-msvc": "0.3.0-next.131+28f3abd",
+    "es-git-win32-arm64-msvc": "0.3.0-next.131+28f3abd",
+    "es-git-linux-x64-gnu": "0.3.0-next.131+28f3abd",
+    "es-git-linux-x64-musl": "0.3.0-next.131+28f3abd",
+    "es-git-android-arm64": "0.3.0-next.131+28f3abd",
+    "es-git-linux-arm64-gnu": "0.3.0-next.131+28f3abd",
+    "es-git-linux-arm64-musl": "0.3.0-next.131+28f3abd",
+    "es-git-android-arm-eabi": "0.3.0-next.131+28f3abd"
   }
 }