@gitkraken/core-gitlens 0.15.3 → 0.15.4

package/dist/git-cli/providers/branches.js

@@ -736,6 +736,26 @@ var BranchesGitSubProvider = class {
 		const branches = new PageableResult((p) => this.getBranches(repoPath, p != null ? { paging: p } : void 0, cancellation));
 		return getLocalBranchByUpstream(remoteBranchName, branches);
 	}
+	async getPushTarget(repoPath, branch, cancellation) {
+		const records = await this.provider.refs.getRefs(repoPath, cancellation);
+		if (!records.length) return { known: false };
+		if (branch == null) {
+			const current = await this.getCurrentBranchReference(repoPath, cancellation);
+			if (current == null) return { known: false };
+			if (current.remote || isDetachedHead(current.name)) return {
+				known: true,
+				push: void 0,
+				upstream: void 0
+			};
+			branch = current.name;
+		}
+		const record = findRefRecord(records, branch.startsWith("refs/heads/") ? branch : `refs/heads/${branch}`);
+		return {
+			known: true,
+			push: record?.push ? toPushTargetRef(records, record.push) : void 0,
+			upstream: record?.upstream ? toPushTargetRef(records, record.upstream) : void 0
+		};
+	}
 	/** Detects potential conflicts when applying commits onto a target branch (git rebase and cherry-pick) */
 	async getPotentialApplyConflicts(repoPath, targetBranch, shas, options, cancellation) {
 		if (!shas.length) return { status: "clean" };
@@ -1006,7 +1026,7 @@ var BranchesGitSubProvider = class {
 			};
 			if (createdFrom !== "HEAD") {
 				if (options?.upstream) {
-					const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${createdFrom}@{u}`, priorityOpts);
+					const upstream = await this.getUpstreamName(repoPath, createdFrom, priorityOpts, cancellation);
 					if (upstream) return {
 						branch: upstream,
 						failed: false
@@ -1030,7 +1050,7 @@ var BranchesGitSubProvider = class {
 			if (match?.length === 2) {
 				let name = match[1];
 				if (options?.upstream) {
-					const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`, priorityOpts);
+					const upstream = await this.getUpstreamName(repoPath, name, priorityOpts, cancellation);
 					if (upstream) return {
 						branch: upstream,
 						failed: false
@@ -1106,6 +1126,21 @@ var BranchesGitSubProvider = class {
 		if (await this.isSelfRef(repoPath, name, branch, cancellation)) return void 0;
 		return name;
 	}
+	getAheadOfBaseConfigKey(repoPath, cancellation) {
+		return this.cache.getAheadOfBaseConfigKey(repoPath, async (commonPath, cacheable, signal) => {
+			const result = await this.git.run({
+				cwd: commonPath,
+				cancellation: signal,
+				expectedExitCodes: [1]
+			}, "config", "--null", "--get-regexp", "^(branch\\..*\\.(remote|merge)|remote\\..*|init\\.defaultbranch)$");
+			if (signal?.aborted) throw new CancellationError();
+			if (result.completion.status !== "exited") {
+				cacheable.invalidate();
+				return;
+			}
+			return result.stdout;
+		}, cancellation);
+	}
 	async getAheadOfBase(repoPath, branch, options, cancellation) {
 		if (branch != null && isDetachedHead(branch)) branch = void 0;
 		const dependsOn = new Set(branch != null ? [`refs/heads/${branch}`] : []);
@@ -1547,7 +1582,7 @@ var BranchesGitSubProvider = class {
 		if (!candidate || candidate.startsWith("-")) return void 0;
 		if (candidate === branch || candidate === `refs/heads/${branch}`) return void 0;
 		addRefDependencies(dependsOn, candidate);
-		const upstreamName = this.provider.refs.getSymbolicReferenceName(repoPath, `${candidate}@{u}`, void 0, cancellation);
+		const upstreamName = this.getUpstreamName(repoPath, candidate, void 0, cancellation);
 		const getUpstreamFork = async () => {
 			const upstream = await upstreamName;
 			if (!upstream || upstream.startsWith("-")) return void 0;
@@ -1599,6 +1634,14 @@ var BranchesGitSubProvider = class {
 		} : void 0;
 	}
 	/**
+	* `<name>@{u}`, without asking git when the cached ref list shows `name` can't have one: a failed lookup isn't
+	* cached, so asking it of a remote-tracking ref (`origin/main`, the usual default) re-spawns on every read.
+	*/
+	async getUpstreamName(repoPath, name, options, cancellation) {
+		if (!mayHaveUpstream(await this.provider.refs.getRefs(repoPath, cancellation), name)) return void 0;
+		return this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`, options, cancellation);
+	}
+	/**
 	* The base for a branch that is itself the default branch, with its tip: its own upstream, `upstream/<branch>`
 	* when an `upstream` remote has it, else `<branch>@{u}`. Read from the cached ref and branch lists; only a
 	* `<branch>` that isn't checked out spawns, for its `@{u}`. `undefined` when there is neither, or its ref is gone.
@@ -1844,16 +1887,18 @@ __decorate([debug()], BranchesGitSubProvider.prototype, "deleteLocalBranch", nul
 __decorate([debug()], BranchesGitSubProvider.prototype, "deleteRemoteBranch", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "getBranchMergedStatus", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "getLocalBranchByUpstream", null);
+__decorate([trace({ exit: true })], BranchesGitSubProvider.prototype, "getPushTarget", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialApplyConflicts", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialMergeConflicts", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialStashReapplyConflicts", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getBaseBranchName", null);
+__decorate([trace()], BranchesGitSubProvider.prototype, "getAheadOfBaseConfigKey", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getAheadOfBase", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getAheadBehindCounts", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getMergedBranches", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getStoredMergeTargetBranchName", null);
-__decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getStoredDetectedMergeTargetBranchName", null);
-__decorate([debug()], BranchesGitSubProvider.prototype, "getStoredUserMergeTargetBranchName", null);
+__decorate([trace({ exit: true })], BranchesGitSubProvider.prototype, "getStoredDetectedMergeTargetBranchName", null);
+__decorate([trace()], BranchesGitSubProvider.prototype, "getStoredUserMergeTargetBranchName", null);
 __decorate([trace()], BranchesGitSubProvider.prototype, "onCurrentBranchAccessed", null);
 __decorate([trace()], BranchesGitSubProvider.prototype, "onCurrentBranchModified", null);
 __decorate([trace()], BranchesGitSubProvider.prototype, "onCurrentBranchAgentActivity", null);
@@ -1870,19 +1915,14 @@ function parseSymbolicFullNames(stdout) {
 		upstream: upstream || void 0
 	};
 }
-/** Each ref list {@link findRefTip} searched, by full name: one base read looks up many names in the same cached list */
+/** Each ref list {@link findRefTip} and {@link findRefRecord} searched, by full name: one base read looks up many names in the same cached list */
 const refRecordsByName = /* @__PURE__ */ new WeakMap();
 /**
 * The commit `name` resolves to among `records`, tried in git's own order for a short name (`refs/tags/` before
 * `refs/heads/` before `refs/remotes/`); annotated tags peel to their commit. `undefined` when no listed ref matches.
 */
 function findRefTip(records, name) {
-	let byName = refRecordsByName.get(records);
-	if (byName == null) {
-		byName = /* @__PURE__ */ new Map();
-		for (const record of records) if (!byName.has(record.name)) byName.set(record.name, record);
-		refRecordsByName.set(records, byName);
-	}
+	const byName = getRefRecordsByName(records);
 	for (const candidate of [
 		name,
 		`refs/${name}`,
@@ -1895,6 +1935,38 @@ function findRefTip(records, name) {
 		if (record != null) return record.peeledObjectname || record.objectname;
 	}
 }
+function getRefRecordsByName(records) {
+	let byName = refRecordsByName.get(records);
+	if (byName == null) {
+		byName = /* @__PURE__ */ new Map();
+		for (const record of records) if (!byName.has(record.name)) byName.set(record.name, record);
+		refRecordsByName.set(records, byName);
+	}
+	return byName;
+}
+/** The record for the full ref name `fullName` in `records`, the cached ref list; no short-name resolution */
+function findRefRecord(records, fullName) {
+	return getRefRecordsByName(records).get(fullName);
+}
+function toPushTargetRef(records, ref) {
+	const record = findRefRecord(records, ref);
+	return {
+		ref,
+		sha: record != null ? record.peeledObjectname || record.objectname : void 0
+	};
+}
+/**
+* Whether `<name>@{u}` can resolve, judged from `records`, the cached ref list. git follows `@{u}` only from the
+* upstream configured for a branch of that short name (`branch.<name>.merge`), so a remote-tracking ref, a tag or a
+* full ref name (`refs/heads/main@{u}` is "no such branch") has none. A name that names a local branch, or no ref at
+* all (a deleted branch's leftover config still answers), is asked. An empty list is a failed enumeration (see
+* `getRefTip`), which says nothing either way.
+*/
+function mayHaveUpstream(records, name) {
+	if (!records.length || name === "HEAD") return true;
+	if (findRefTip(records, `refs/heads/${name}`) != null) return true;
+	return findRefTip(records, name) == null;
+}
 /**
 * Adds the full ref names a `.git/refs` watcher would report for `name`. A short name can't be told tag from local
 * from remote without a spawn, so it adds every form, including the tag git resolves it to first; a spurious one