@gitkraken/core-gitlens 0.15.3 → 0.15.5

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

@@ -540,7 +540,8 @@ var BranchesGitSubProvider = class {
 			}, ex));
 		} finally {
 			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-			this.context.hooks?.repository?.onChanged?.(repoPath, mayWriteTracking(ref, options?.noTracking) ? ["config", "heads"] : ["heads"]);
+			if (mayWriteTracking(ref, options?.noTracking)) this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"], [`refs/heads/${name}`], { configConfinedToRefs: true });
+			else this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"], [`refs/heads/${name}`]);
 		}
 	}
 	async deleteLocalBranch(repoPath, names, options) {
@@ -554,11 +555,12 @@ var BranchesGitSubProvider = class {
 			await this.git.run({ cwd: repoPath }, ...args);
 			for (const branch of branches) await this.forgetDeletedBranch(repoPath, branch);
 			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-			this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"]);
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"], branches.map((b) => `refs/heads/${b}`), { configConfinedToRefs: true });
 		} catch (ex) {
-			if (await this.cleanupDeletedBranchMetadata(repoPath, branches)) {
+			const deleted = await this.cleanupDeletedBranchMetadata(repoPath, branches);
+			if (deleted.length) {
 				this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-				this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"]);
+				this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"], deleted.map((b) => `refs/heads/${b}`), { configConfinedToRefs: true });
 			}
 			if (ex instanceof BranchError) throw ex.update({
 				action: options?.force ? "force delete" : "delete",
@@ -596,8 +598,8 @@ var BranchesGitSubProvider = class {
 	* for the partial-failure path — one extra `for-each-ref` is cheap while already handling an error,
 	* and keeps the success path free of it.
 	*
-	* Returns whether any of `names` is confirmed gone; `false` when the probe couldn't answer, so a
-	* spurious notification is never fired on an unrelated failure.
+	* Returns those of `names` confirmed gone; none when the probe couldn't answer, so a spurious
+	* notification is never fired on an unrelated failure.
 	*/
 	async cleanupDeletedBranchMetadata(repoPath, names) {
 		try {
@@ -605,18 +607,18 @@ var BranchesGitSubProvider = class {
 				cwd: repoPath,
 				errors: "ignore"
 			}, "for-each-ref", "--format=%(refname)", ...names.map((n) => `refs/heads/${n}`));
-			if (result.completion.status !== "exited" || result.exitCode !== 0) return false;
+			if (result.completion.status !== "exited" || result.exitCode !== 0) return [];
 			const prefix = "refs/heads/";
 			const surviving = new Set(result.stdout.split("\n").map((l) => l.trim()).filter((l) => l.startsWith(prefix)).map((l) => l.substring(11)));
-			let anyDeleted = false;
+			const deleted = [];
 			for (const name of names) {
 				if (surviving.has(name)) continue;
-				anyDeleted = true;
+				deleted.push(name);
 				await this.forgetDeletedBranch(repoPath, name);
 			}
-			return anyDeleted;
+			return deleted;
 		} catch {
-			return false;
+			return [];
 		}
 	}
 	async deleteRemoteBranch(repoPath, names, remote) {
@@ -736,6 +738,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 +1028,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 +1052,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 +1128,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 (checkoutPath, cacheable, signal) => {
+			const result = await this.git.run({
+				cwd: checkoutPath,
+				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 +1584,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 +1636,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.
@@ -1757,7 +1802,7 @@ var BranchesGitSubProvider = class {
 			}, ex));
 		} finally {
 			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-			this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"]);
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"], [`refs/heads/${oldName}`, `refs/heads/${newName}`], { configConfinedToRefs: true });
 		}
 	}
 	async setUpstreamBranch(repoPath, name, upstream) {
@@ -1785,7 +1830,7 @@ var BranchesGitSubProvider = class {
 			}, ex));
 		} finally {
 			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
-			this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"]);
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["config", "heads"], [`refs/heads/${name}`], { configConfinedToRefs: true });
 		}
 	}
 	async storeBaseBranchName(repoPath, ref, base, options) {
@@ -1844,16 +1889,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 +1917,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 +1937,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