@gitkraken/core-gitlens 0.1.0

package/dist/git/errors.js

@@ -0,0 +1,681 @@
+import { pluralize } from '../utils/string.js';
+export class GitCommandError extends Error {
+    static is(ex) {
+        return ex instanceof GitCommandError;
+    }
+    _details;
+    get details() {
+        return this._details;
+    }
+    set details(details) {
+        this._details = details;
+        this.message = this.buildErrorMessage(details);
+    }
+    original;
+    constructor(message, details, original) {
+        super(message);
+        this.original = original;
+        this.details = details;
+        Error.captureStackTrace?.(this, new.target);
+    }
+    update(changes) {
+        this.details = { ...this.details, ...changes };
+        return this;
+    }
+}
+export class GitSearchError extends Error {
+    original;
+    static is(ex) {
+        return ex instanceof GitSearchError;
+    }
+    constructor(original) {
+        super(original.message);
+        this.original = original;
+        Error.captureStackTrace?.(this, new.target);
+    }
+}
+export class ApplyPatchCommitError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof ApplyPatchCommitError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to apply patch', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = 'Unable to apply patch';
+        switch (details.reason) {
+            case 'applyFailed':
+                return `${baseMessage}${this.original instanceof CherryPickError ? `. ${this.original.message}` : ''}`;
+            case 'appliedWithConflicts':
+                return 'Patch applied with conflicts';
+            case 'checkoutFailed':
+                return `${baseMessage} as we were unable to checkout the branch '${details.branch}'${this.original instanceof CheckoutError ? `. ${this.original.message}` : ''}`;
+            case 'createWorktreeFailed':
+                return `${baseMessage} as we were unable to create a worktree${this.original instanceof WorktreeCreateError ? `. ${this.original.message}` : ''}`;
+            case 'stashFailed':
+                return `${baseMessage} as we were unable to stash your working changes${this.original instanceof StashPushError ? `. ${this.original.message}` : ''}`;
+            case 'wouldOverwriteChanges':
+                return `${baseMessage} as some local changes would be overwritten`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class CommitError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof CommitError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to commit', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = 'Unable to commit';
+        switch (details.reason) {
+            case 'nothingToCommit':
+                return `${baseMessage} because there are no staged changes`;
+            case 'conflicts':
+                return `${baseMessage} because there are unresolved merge conflicts`;
+            case 'noUserNameConfigured':
+                return 'Please configure your git user name and email before committing';
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class BlameIgnoreRevsFileError extends Error {
+    fileName;
+    original;
+    static is(ex) {
+        return ex instanceof BlameIgnoreRevsFileError;
+    }
+    constructor(fileName, original) {
+        super(`Invalid blame.ignoreRevsFile: '${fileName}'`);
+        this.fileName = fileName;
+        this.original = original;
+        Error.captureStackTrace?.(this, new.target);
+    }
+}
+export class BlameIgnoreRevsFileBadRevisionError extends Error {
+    revision;
+    original;
+    static is(ex) {
+        return ex instanceof BlameIgnoreRevsFileBadRevisionError;
+    }
+    constructor(revision, original) {
+        super(`Invalid revision in blame.ignoreRevsFile: '${revision}'`);
+        this.revision = revision;
+        this.original = original;
+        Error.captureStackTrace?.(this, new.target);
+    }
+}
+export class BranchError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof BranchError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to perform action on branch', details, original);
+    }
+    buildErrorMessage(details) {
+        let baseMessage;
+        if (details.action != null) {
+            baseMessage = `Unable to ${details.action} branch ${details.branch ? `'${details.branch}'` : ''}`;
+        }
+        else {
+            baseMessage = `Unable to perform action ${details.branch ? `with branch '${details.branch}'` : 'on branch'}`;
+        }
+        switch (details.reason) {
+            case 'alreadyExists':
+                return `${baseMessage} because it already exists`;
+            case 'notFullyMerged':
+                return `${baseMessage} because it is not fully merged`;
+            case 'invalidName':
+                return `${baseMessage} because the branch name is invalid`;
+            case 'noRemoteReference':
+                return `${baseMessage} because the remote reference does not exist`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class CheckoutError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof CheckoutError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to checkout', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = `Unable to checkout${details.ref ? ` '${details.ref}'` : ''}`;
+        switch (details.reason) {
+            case 'invalidRef':
+                return `${baseMessage} because the reference is invalid`;
+            case 'pathspecNotFound':
+                return `${baseMessage} because the path or reference does not exist`;
+            case 'wouldOverwriteChanges':
+                return `${baseMessage}. Your local changes would be overwritten. Please commit or stash your changes before switching branches.`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class CherryPickError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof CherryPickError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to cherry-pick', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = `Unable to cherry-pick${details.revs?.length
+            ? details.revs.length === 1
+                ? ` commit '${details.revs[0]}'`
+                : ` ${pluralize('commit', details.revs.length)}`
+            : ''}`;
+        switch (details.reason) {
+            case 'aborted':
+                return `${baseMessage} as it was aborted.`;
+            case 'alreadyInProgress':
+                return `${baseMessage} as a cherry-pick is already in progress.`;
+            case 'conflicts':
+                return `${baseMessage} due to conflicts.`;
+            case 'emptyCommit':
+                return `${baseMessage} because it is an empty commit.`;
+            case 'wouldOverwriteChanges':
+                return `${baseMessage} as some local changes would be overwritten.`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class FetchError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof FetchError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to fetch', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = `Unable to fetch${details.branch ? ` branch '${details.branch}'` : ''}${details.remote ? ` from ${details.remote}` : ''}`;
+        switch (details.reason) {
+            case 'noFastForward':
+                return `${baseMessage} as it cannot be fast-forwarded`;
+            case 'noRemote':
+                return `${baseMessage} without a remote repository specified.`;
+            case 'remoteConnectionFailed':
+                return `${baseMessage}. Could not connect to the remote repository.`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class MergeError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof MergeError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to merge', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = `Unable to merge${details.ref ? ` '${details.ref}'` : ''}`;
+        switch (details.reason) {
+            case 'aborted':
+                return `Merge${details.ref ? ` of '${details.ref}'` : ''} was aborted`;
+            case 'alreadyInProgress':
+                return `${baseMessage} because a merge is already in progress`;
+            case 'conflicts':
+                return `${baseMessage} due to conflicts. Resolve the conflicts first and continue the merge`;
+            case 'uncommittedChanges':
+                return `${baseMessage} because there are uncommitted changes`;
+            case 'wouldOverwriteChanges':
+                return `${baseMessage} because some local changes would be overwritten`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class PausedOperationAbortError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof PausedOperationAbortError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to abort operation', details, original);
+    }
+    buildErrorMessage(details) {
+        switch (details.reason) {
+            case 'nothingToAbort':
+                return `Cannot abort as there is no ${details.operation.type} operation in progress`;
+            default:
+                return `Unable to abort the ${details.operation.type} operation${this.original ? `: ${this.original.message}` : ''}`;
+        }
+    }
+}
+export class PausedOperationContinueError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof PausedOperationContinueError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to continue operation', details, original);
+    }
+    buildErrorMessage(details) {
+        switch (details.reason) {
+            case 'conflicts':
+                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as there are unresolved conflicts`;
+            case 'emptyCommit':
+                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as the previous commit is empty`;
+            case 'nothingToContinue':
+                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as there is no ${details.operation.type} in progress`;
+            case 'uncommittedChanges':
+                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as there are uncommitted changes`;
+            case 'unmergedFiles':
+                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as there are unmerged files`;
+            case 'unstagedChanges':
+                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as there are unstaged changes`;
+            case 'wouldOverwriteChanges':
+                return `Cannot ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation as some local changes would be overwritten`;
+            default:
+                return `Unable to ${details.skip ? 'skip' : 'continue'} the ${details.operation.type} operation${this.original ? `: ${this.original.message}` : ''}`;
+        }
+    }
+}
+export class PullError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof PullError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to pull', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = 'Unable to pull';
+        switch (details.reason) {
+            case 'conflict':
+                return 'Unable to complete pull due to conflicts which must be resolved.';
+            case 'gitIdentity':
+                return `${baseMessage} because you have not yet set up your Git identity.`;
+            case 'rebaseMultipleBranches':
+                return `${baseMessage} because you are trying to rebase onto multiple branches.`;
+            case 'refLocked':
+                return `${baseMessage} because a local ref could not be updated.`;
+            case 'remoteConnectionFailed':
+                return `${baseMessage} because the remote repository could not be reached.`;
+            case 'tagConflict':
+                return `${baseMessage} because a local tag would be overwritten.`;
+            case 'uncommittedChanges':
+                return `${baseMessage} because you have uncommitted changes.`;
+            case 'unmergedFiles':
+                return `${baseMessage} because you have unmerged files.`;
+            case 'unstagedChanges':
+                return `${baseMessage} because you have unstaged changes.`;
+            case 'wouldOverwriteChanges':
+                return `${baseMessage} because local changes to some files would be overwritten.`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class PushError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof PushError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to push', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = `Unable to push${details.branch ? ` branch '${details.branch}'` : ''}${details.remote ? ` to ${details.remote}` : ''}`;
+        switch (details.reason) {
+            case 'noUpstream':
+                return `${baseMessage} because it has no upstream branch.`;
+            case 'permissionDenied':
+                return `${baseMessage} because you don't have permission to push to this remote repository.`;
+            case 'rejected':
+                return `${baseMessage} because some refs failed to push or the push was rejected. Try pulling first.`;
+            case 'rejectedRefDoesNotExist':
+                return `Unable to delete remote branch${details.branch ? ` '${details.branch}'` : ''}${details.remote ? ` from ${details.remote}` : ''}, the remote reference does not exist`;
+            case 'rejectedWithLease':
+            case 'rejectedWithLeaseIfIncludes':
+                return `Unable to force push${details.branch ? ` branch '${details.branch}'` : ''}${details.remote ? ` to ${details.remote}` : ''} because some refs failed to push or the push was rejected. The tip of the remote-tracking branch has been updated since the last checkout. Try pulling first.`;
+            case 'remoteAhead':
+                return `${baseMessage} because the remote contains work that you do not have locally. Try fetching first.`;
+            case 'remoteConnectionFailed':
+                return `${baseMessage} because the remote repository could not be reached.`;
+            case 'tipBehind':
+                return `${baseMessage} as it is behind its remote counterpart. Try pulling first.`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class RebaseError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof RebaseError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to rebase', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = `Unable to rebase${details.upstream ? ` onto '${details.upstream}'` : ''}`;
+        switch (details.reason) {
+            case 'aborted':
+                return `Rebase${details.upstream ? ` onto '${details.upstream}'` : ''} was aborted`;
+            case 'alreadyInProgress':
+                return `${baseMessage} because a rebase is already in progress`;
+            case 'conflicts':
+                return `${baseMessage} due to conflicts. Resolve the conflicts first and continue the rebase`;
+            case 'uncommittedChanges':
+                return `${baseMessage} because there are uncommitted changes`;
+            case 'wouldOverwriteChanges':
+                return `${baseMessage} because some local changes would be overwritten`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class ResetError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof ResetError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to reset', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = 'Unable to reset';
+        switch (details.reason) {
+            case 'ambiguousArgument':
+                return `${baseMessage} because the argument is ambiguous`;
+            case 'detachedHead':
+                return `${baseMessage} because you are in a detached HEAD state`;
+            case 'notUpToDate':
+                return `${baseMessage} because the index is not up to date (you may have unresolved merge conflicts)`;
+            case 'permissionDenied':
+                return `${baseMessage} because you don't have permission to modify affected files`;
+            case 'refLocked':
+                return `${baseMessage} because the ref is locked`;
+            case 'unmergedChanges':
+                return `${baseMessage} because there are unmerged changes`;
+            case 'wouldOverwriteChanges':
+                return `${baseMessage} because your local changes would be overwritten`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class RevertError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof RevertError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to revert', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = `Unable to revert${details.refs?.length ? ` ${details.refs.join(', ')}` : ''}`;
+        switch (details.reason) {
+            case 'aborted':
+                return `Revert${details.refs?.length ? ` of ${details.refs.join(', ')}` : ''} was aborted`;
+            case 'alreadyInProgress':
+                return `${baseMessage} because a revert is already in progress`;
+            case 'conflicts':
+                return `${baseMessage} due to conflicts. Resolve the conflicts first and continue the revert`;
+            case 'uncommittedChanges':
+                return `${baseMessage} because there are uncommitted changes`;
+            case 'wouldOverwriteChanges':
+                return `${baseMessage} because some local changes would be overwritten`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class StashApplyError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof StashApplyError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to apply stash', details, original);
+    }
+    buildErrorMessage(details) {
+        switch (details.reason) {
+            case 'uncommittedChanges':
+                return 'Unable to apply stash. Your working tree changes would be overwritten. Please commit or stash your changes before trying again';
+            default:
+                return 'Unable to apply stash';
+        }
+    }
+}
+export class StashPushError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof StashPushError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to stash', details, original);
+    }
+    buildErrorMessage(details) {
+        switch (details.reason) {
+            case 'conflictingStagedAndUnstagedLines':
+                return 'Changes were stashed, but the working tree cannot be updated because at least one file has staged and unstaged changes on the same line(s)';
+            case 'nothingToSave':
+                return 'No files to stash';
+            default:
+                return 'Unable to stash';
+        }
+    }
+}
+export class ShowError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof ShowError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to show file', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = `Unable to show${details.path ? ` '${details.path}'` : ' file'}${details.rev ? ` at revision '${details.rev}'` : ''}`;
+        switch (details.reason) {
+            case 'invalidObject':
+                return `${baseMessage} because the path is not a file`;
+            case 'invalidRevision':
+                return `${baseMessage} because the specified revision is invalid`;
+            case 'notFound':
+                return `${baseMessage} because the file does not exist`;
+            case 'notInRevision':
+                return `${baseMessage} because the file is not in the specified revision`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class TagError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof TagError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to perform action on tag', details, original);
+    }
+    buildErrorMessage(details) {
+        let baseMessage;
+        if (details.action != null) {
+            baseMessage = `Unable to ${details.action} tag ${details.tag ? `'${details.tag}'` : ''}`;
+        }
+        else {
+            baseMessage = `Unable to perform action${details.tag ? ` with tag '${details.tag}'` : 'on tag'}`;
+        }
+        switch (details.reason) {
+            case 'alreadyExists':
+                return `${baseMessage} because it already exists`;
+            case 'invalidName':
+                return `${baseMessage} because the tag name is invalid`;
+            case 'notFound':
+                return `${baseMessage} because it does not exist`;
+            case 'permissionDenied':
+                return `${baseMessage} because you don't have permission to push to this remote repository.`;
+            case 'remoteRejected':
+                return `${baseMessage} because the remote repository rejected the push.`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+export class WorkspaceUntrustedError extends Error {
+    static is(ex) {
+        return ex instanceof WorkspaceUntrustedError;
+    }
+    constructor() {
+        super('Unable to perform Git operations because the current workspace is untrusted');
+        Error.captureStackTrace?.(this, new.target);
+    }
+}
+export class WorktreeCreateError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof WorktreeCreateError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to create worktree', details, original);
+    }
+    buildErrorMessage(details) {
+        switch (details.reason) {
+            case 'alreadyCheckedOut':
+                return 'Unable to create worktree because it is already checked out';
+            case 'alreadyExists':
+                return 'Unable to create worktree because it already exists';
+            default:
+                return 'Unable to create worktree';
+        }
+    }
+}
+export class WorktreeDeleteError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof WorktreeDeleteError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to delete worktree', details, original);
+    }
+    buildErrorMessage(details) {
+        switch (details.reason) {
+            case 'defaultWorkingTree':
+                return 'Cannot delete worktree because it is the default working tree';
+            case 'directoryNotEmpty':
+                return 'Unable to delete worktree because the directory is not empty';
+            case 'uncommittedChanges':
+                return 'Unable to delete worktree because there are uncommitted changes';
+            default:
+                return 'Unable to delete worktree';
+        }
+    }
+}
+export var AuthenticationErrorReason;
+(function (AuthenticationErrorReason) {
+    AuthenticationErrorReason[AuthenticationErrorReason["UserDidNotConsent"] = 1] = "UserDidNotConsent";
+    AuthenticationErrorReason[AuthenticationErrorReason["Unauthorized"] = 2] = "Unauthorized";
+    AuthenticationErrorReason[AuthenticationErrorReason["Forbidden"] = 3] = "Forbidden";
+})(AuthenticationErrorReason || (AuthenticationErrorReason = {}));
+export class AuthenticationError extends Error {
+    id;
+    original;
+    reason;
+    authInfo;
+    constructor(info, messageOrReason, original) {
+        const { providerId: id, type, cloud, scopes, expiresAt } = info;
+        const tokenDetails = [
+            cloud ? 'cloud' : 'self-managed',
+            type,
+            info.microHash,
+            expiresAt && `expiresAt=${isNaN(expiresAt.getTime()) ? expiresAt.toString() : expiresAt.toISOString()}`,
+            scopes && `[${scopes.join(',')}]`,
+        ]
+            .filter(v => v)
+            .join(', ');
+        const authInfo = `(token details: ${tokenDetails})`;
+        let message;
+        let reason;
+        if (messageOrReason == null) {
+            message = `Unable to get required authentication session for '${id}'`;
+        }
+        else if (typeof messageOrReason === 'string') {
+            message = messageOrReason;
+            reason = undefined;
+        }
+        else {
+            reason = messageOrReason;
+            switch (reason) {
+                case AuthenticationErrorReason.UserDidNotConsent:
+                    message = `'${id}' authentication is required for this operation`;
+                    break;
+                case AuthenticationErrorReason.Unauthorized:
+                    message = `Your '${id}' credentials are either invalid or expired`;
+                    break;
+                case AuthenticationErrorReason.Forbidden:
+                    message = `Your '${id}' credentials do not have the required access`;
+                    break;
+            }
+        }
+        super(message);
+        this.id = id;
+        this.original = original;
+        this.reason = reason;
+        this.authInfo = authInfo;
+        Error.captureStackTrace?.(this, new.target);
+    }
+    static is(ex) {
+        return ex instanceof AuthenticationError;
+    }
+    toString() {
+        return `${super.toString()} ${this.authInfo}`;
+    }
+}
+export class RequestClientError extends Error {
+    original;
+    static is(ex) {
+        return ex instanceof RequestClientError;
+    }
+    constructor(original) {
+        super(original.message);
+        this.original = original;
+        Error.captureStackTrace?.(this, new.target);
+    }
+}
+export class RequestNotFoundError extends Error {
+    original;
+    static is(ex) {
+        return ex instanceof RequestNotFoundError;
+    }
+    constructor(original) {
+        super(original.message);
+        this.original = original;
+        Error.captureStackTrace?.(this, new.target);
+    }
+}
+export class RequestRateLimitError extends Error {
+    original;
+    token;
+    resetAt;
+    static is(ex) {
+        return ex instanceof RequestRateLimitError;
+    }
+    constructor(original, token, resetAt) {
+        super(original.message);
+        this.original = original;
+        this.token = token;
+        this.resetAt = resetAt;
+        Error.captureStackTrace?.(this, new.target);
+    }
+}
+export class SigningError extends GitCommandError {
+    static is(ex, reason) {
+        return ex instanceof SigningError && (reason == null || ex.details.reason === reason);
+    }
+    constructor(details, original) {
+        super('Unable to sign commit', details, original);
+    }
+    buildErrorMessage(details) {
+        const baseMessage = 'Unable to sign commit';
+        switch (details.reason) {
+            case 'noKey':
+                return `${baseMessage} because no signing key is configured`;
+            case 'gpgNotFound':
+                return `${baseMessage} because GPG program was not found`;
+            case 'sshNotFound':
+                return `${baseMessage} because SSH program was not found`;
+            case 'passphraseFailed':
+                return `${baseMessage} because GPG passphrase failed or was cancelled`;
+            default:
+                return baseMessage;
+        }
+    }
+}
+//# sourceMappingURL=errors.js.map