@gitkraken/core-gitlens 0.17.0 → 0.18.0

package/dist/git/watching/worktreeSummary.js

@@ -25,6 +25,7 @@ const allFields = 7;
 const maxConcurrentReadsPerRepository = 4;
 const maxConcurrentReads = 8;
 const maxUnwatchedReads = 256;
+const maxDeferredDirtyMs = 1e4;
 const emptyRefs = Object.freeze([]);
 const noBaseKeys = [
 	void 0,
@@ -66,6 +67,9 @@ var SummarySubscription = class {
 	get current() {
 		return this.disposed ? void 0 : this.entry.value;
 	}
+	get dirtyReadAt() {
+		return this.disposed || this.entry.value == null ? void 0 : this.entry.dirtyReadAt;
+	}
 	get onDidChange() {
 		return this.emitter.event;
 	}
@@ -101,7 +105,10 @@ var SummarySubscription = class {
 * has working changes, and how far it is past its base — kept current by the repository watch layer.
 *
 * **Lifecycle.** Entries are per repository key and ref-counted across {@link subscribe} calls. The first subscriber
-* starts watching the worktree and reads everything; the last one to leave aborts any in-flight read, releases the
+* starts watching the worktree and reads everything, or, for a worktree last read without a subscription, starts from
+* that read: it re-reads the groups whose inputs moved since, by the same rules as such a read, and always `dirty` —
+* unless its working-tree watch is still starting, when the rescan that watch owes reads it, and the summary keeps the
+* saved read's flag, with its `dirtyReadAt`, until then. The last one to leave aborts any in-flight read, releases the
 * watch and drops the value. Each subscriber's timing options join the watch session's cadence (the shortest wins);
 * the service's own listening subscriptions never constrain it.
 *
@@ -128,7 +135,8 @@ var SummarySubscription = class {
 * **Value-change-only notification.** {@link WorktreeSummarySubscription.onDidChange} and {@link onDidChangeSummary}
 * fire only when some field's value differs from the previous summary — a recompute that reads the same answer is
 * silent, so a consumer can re-render on every event without diffing. A failed recompute keeps the last values and
-* sets `stale` (firing once); the next successful one clears it.
+* sets `stale` (firing once); the next successful one clears it. A summary still showing the dirty flag of a read
+* without a subscription fires again, unchanged, once that flag is read again (its `dirtyReadAt` cleared).
 *
 * **Worktrees without a subscription.** {@link getSummary} and {@link getSummarySnapshot} answer one from its last read
 * (kept for the {@link maxUnwatchedReads} most recently asked), re-reading only the groups whose inputs moved since:
@@ -140,11 +148,14 @@ var SummarySubscription = class {
 * asks about this way for others' changes to show. Its working tree is unwatched, so an edit that leaves the index
 * alone goes unseen until `dirty` is read again: the snapshot says when that was, and `probeDirty` reads it anyway.
 * Concurrent reads of a worktree share one, and take no read slot: each is a caller's foreground read, which never
-* waits behind subscribed worktrees' runs.
+* waits behind subscribed worktrees' runs. A first subscriber takes over the last read.
 */
 var WorktreeSummaryService = class {
 	_onDidChangeSummary = new Emitter();
-	/** Fires when the summary of any subscribed worktree changes value */
+	/**
+	* Fires when the summary of any subscribed worktree changes value, and with the same summary when a dirty flag kept
+	* from a read without a subscription is read again (see {@link WorktreeSummarySubscription.dirtyReadAt})
+	*/
 	get onDidChangeSummary() {
 		return this._onDidChangeSummary.event;
 	}
@@ -192,7 +203,11 @@ var WorktreeSummaryService = class {
 		this.entries.clear();
 		this._onDidChangeSummary.dispose();
 	}
-	/** Subscribes to a worktree's summary, starting to watch and read it if this is its first subscriber */
+	/**
+	* Subscribes to a worktree's summary, starting to watch and read it if this is its first subscriber: from its last
+	* read without a subscription, if any, re-reading the groups whose inputs moved since and the dirty flag — at once,
+	* or, while its working-tree watch is still starting, as that watch goes live
+	*/
 	subscribe(repoPath, options) {
 		const key = getRepositoryKey(repoPath);
 		let entry = this._disposed ? void 0 : this.entries.get(key);
@@ -207,16 +222,11 @@ var WorktreeSummaryService = class {
 		target.subscribers.add(subscription);
 		if (isNew) {
 			if (!target.disposed) {
-				this.unwatchedReads.delete(key);
 				this.unwatchedFlights.delete(key);
-				target.pending = 23;
 				target.running = this.start(target);
 			}
 		} else if (target.handle != null) subscription.attach(target.handle.session);
-		else if (target.running == null && !target.disposed) {
-			target.pending = 23;
-			target.running = this.start(target);
-		}
+		else if (target.running == null && !target.disposed) target.running = this.start(target);
 		return subscription;
 	}
 	/**
@@ -232,7 +242,8 @@ var WorktreeSummaryService = class {
 	}
 	/**
 	* Returns a worktree's summary, with when its dirty flag was read. A subscribed worktree answers as
-	* {@link getSummary} does, with `dirtyReadAt` `undefined`, since its summary follows its working tree. Any other
+	* {@link getSummary} does, with `dirtyReadAt` `undefined` once its summary follows its working tree, and until then
+	* the saved read's (see {@link WorktreeSummarySubscription.dirtyReadAt}), which `probeDirty` reads again. Any other
 	* answers from its last read, re-reading only the groups whose inputs moved since (no git when none did), and in
 	* full the first time, or after a failed or stale read. Its working tree is unwatched, so the dirty flag is re-read
 	* only when the index file moved, or with `probeDirty`; a rejection drops the last read. Its inputs are core's
@@ -242,9 +253,17 @@ var WorktreeSummaryService = class {
 		const key = getRepositoryKey(repoPath);
 		const entry = this.entries.get(key);
 		if (entry == null) return this.getUnwatchedSnapshot(key, options?.probeDirty ?? false, options?.cancellation);
+		return this.getSubscribedSnapshot(entry, options?.probeDirty ?? false, options?.cancellation);
+	}
+	async getSubscribedSnapshot(entry, probeDirty, cancellation) {
+		let summary = await this.getSubscribedSummary(entry, cancellation);
+		if (probeDirty && entry.dirtyReadAt != null) {
+			this.queue(entry, dirtyField);
+			summary = await this.getSubscribedSummary(entry, cancellation);
+		}
 		return {
-			summary: await this.getSubscribedSummary(entry, options?.cancellation),
-			dirtyReadAt: void 0
+			summary,
+			dirtyReadAt: entry.dirtyReadAt
 		};
 	}
 	async getSubscribedSummary(entry, cancellation) {
@@ -269,10 +288,7 @@ var WorktreeSummaryService = class {
 				if (flight === waited) flight = void 0;
 			}
 			const entry = this.entries.get(key);
-			if (entry != null) return {
-				summary: await this.getSubscribedSummary(entry, cancellation),
-				dirtyReadAt: void 0
-			};
+			if (entry != null) return this.getSubscribedSnapshot(entry, true, cancellation);
 		}
 		if (flight == null) {
 			flight = new UnwatchedFlight(key, probeDirty, this._disposed, (f) => this.readUnwatched(f));
@@ -313,33 +329,14 @@ var WorktreeSummaryService = class {
 			const repo = this.getRepository(key);
 			if (repo == null) throw new Error(`No repository found for '${key}'`);
 			const headRemotes = last != null ? getHeadRemotes(last.result.summary.baseDependsOn) : void 0;
-			const probe = await this.probeUnwatched(repo, headRemotes, signal);
+			const probe = await this.probeUnwatched(repo, headRemotes, true, signal);
 			if (flight.disposed) throw new CancellationError();
 			let fields;
 			let baseMoves;
 			if (last == null) fields = 23;
 			else {
-				fields = last.due;
-				const { inputs } = last;
-				const previous = last.result.summary;
-				if (probe.branch !== inputs.branch || probe.detached !== inputs.detached || probe.sha !== inputs.sha) fields |= allFields;
-				else {
-					if (probe.upstream !== inputs.upstream) fields |= 18;
-					else if (getUpstreamTips(probe.tips, probe.upstream) !== inputs.upstreamTips) fields |= branchField;
-					for (const ref of previous.baseDependsOn) {
-						const value = getBaseInput(probe, ref);
-						if (value !== null && value === inputs.baseTips.get(ref)) continue;
-						baseMoves ??= /* @__PURE__ */ new Set();
-						baseMoves.add(ref);
-					}
-					if (baseMoves != null) fields |= baseMoveField;
-					if ((fields & baseConfigField) === 0 && last.result.baseConfigKey != null && repo.branches.getAheadOfBase != null && (probe.detached || probe.branch != null)) {
-						const configKey = getBaseConfigKey(await readBaseConfig(repo, signal), previous);
-						if (flight.disposed) throw new CancellationError();
-						if (configKey != null && configKey !== last.result.baseConfigKey) fields |= 18;
-					}
-				}
-				if (flight.probeDirty || probe.index == null || probe.index !== inputs.index) fields |= dirtyField;
+				({fields, baseMoves} = await getMovedFields(repo, last, probe, flight.probeDirty, signal));
+				if (flight.disposed) throw new CancellationError();
 				if (fields === 0) {
 					this.unwatchedReads.touch(key);
 					return last;
@@ -370,18 +367,18 @@ var WorktreeSummaryService = class {
 	}
 	/**
 	* Reads an unwatched read's inputs: cached answers but for the index file's stat (see {@link UnwatchedInputs}), with
-	* the `HEAD` symrefs of `remotes` (every remote's when `undefined`)
+	* the `HEAD` symrefs of `remotes` (every remote's when `undefined`); without `statIndex`, the index is unknown
 	*/
-	async probeUnwatched(repo, remotes, signal) {
+	async probeUnwatched(repo, remotes, statIndex, signal) {
 		const remoteHeads = /* @__PURE__ */ new Map();
+		const stat = statIndex ? this.stat : void 0;
 		const [current, tips, gitDir] = await Promise.all([
 			repo.branches.getBranch(void 0, void 0, signal),
 			repo.refs.getRefTips(void 0, signal),
-			getGitDir(repo),
+			stat != null ? getGitDir(repo) : void 0,
 			readRemoteHeads(repo, remoteHeads, remotes, signal)
 		]);
 		let index;
-		const stat = this.stat;
 		if (stat != null && gitDir != null) try {
 			const stats = await stat(joinPaths(gitDir.uri.fsPath, "index"));
 			index = stats != null ? `${stats.size}:${stats.mtime}` : "";
@@ -419,6 +416,15 @@ var WorktreeSummaryService = class {
 			this.fail(entry, /* @__PURE__ */ new Error(`Unable to watch '${entry.key}': no repository or git directory`));
 			return;
 		}
+		let last = this.unwatchedReads.get(entry.key);
+		this.unwatchedReads.delete(entry.key);
+		if (last?.result.summary.stale) last = void 0;
+		if (last != null) {
+			entry.seed = last.result.summary;
+			entry.baseKeys = last.result.baseKeys;
+			entry.baseConfigKey = last.result.baseConfigKey;
+			entry.baseDefaultBranch = last.result.baseDefaultBranch;
+		} else entry.pending |= 23;
 		entry.handle = handle;
 		entry.slotsKey = getRepositoryKey(gitDir.commonUri ?? gitDir.uri);
 		const session = handle.session;
@@ -437,10 +443,56 @@ var WorktreeSummaryService = class {
 			workingTreeSub
 		];
 		for (const subscription of entry.subscribers) subscription.attach(session);
+		if (last != null) {
+			await this.queueSeedStart(entry, last, this.watchService.isWorkingTreeStarting(entry.key));
+			if (entry.disposed) return;
+		}
 		await this.drain(entry);
 	}
+	/**
+	* Queues the groups of the saved read `last` whose inputs moved since, as an unwatched read finds them, and the
+	* dirty flag, which no input vouches for; everything when its inputs can't be read. With `deferDirty`, the dirty
+	* flag is left to the rescan of a working-tree watch still starting, and the value keeps `last`'s until then
+	*/
+	async queueSeedStart(entry, last, deferDirty) {
+		const signal = entry.abort.signal;
+		let moved;
+		try {
+			const repo = this.getRepository(entry.key);
+			if (repo != null) {
+				const probe = await this.probeUnwatched(repo, getHeadRemotes(last.result.summary.baseDependsOn), false, signal);
+				if (entry.disposed) return;
+				moved = await getMovedFields(repo, last, probe, true, signal);
+			}
+		} catch {}
+		if (entry.disposed) return;
+		if (moved == null) {
+			dropSeed(entry);
+			entry.pending |= 23;
+			return;
+		}
+		if (deferDirty) {
+			entry.pending |= moved.fields & -2;
+			entry.dirtyReadAt = last.dirtyReadAt;
+			entry.dirtyReadTimer = setTimeout(() => {
+				entry.dirtyReadTimer = void 0;
+				this.queue(entry, dirtyField);
+			}, maxDeferredDirtyMs);
+			if (entry.pending === 0 && entry.seed != null) {
+				const seed = entry.seed;
+				entry.error = void 0;
+				entry.seed = void 0;
+				entry.value = seed;
+				this.fireChange(entry, seed);
+			}
+		} else entry.pending |= moved.fields;
+		if (moved.baseMoves != null) {
+			entry.baseMoves ??= /* @__PURE__ */ new Set();
+			for (const ref of moved.baseMoves) entry.baseMoves.add(ref);
+		}
+	}
 	onRepoChanged(entry, e) {
-		const value = entry.value;
+		const value = entry.value ?? entry.seed;
 		if (value == null || e.changed("unknown", "head")) {
 			this.queue(entry, allFields | (e.changed("config") ? baseConfigField : 0));
 			return;
@@ -497,7 +549,8 @@ var WorktreeSummaryService = class {
 	}
 	queue(entry, fields, baseMoves) {
 		if (entry.disposed || fields === 0) return;
-		entry.pending |= entry.value == null || entry.value.stale ? fields | 23 : fields;
+		const value = entry.value ?? entry.seed;
+		entry.pending |= value == null || value.stale ? fields | 23 : fields;
 		if (baseMoves != null) {
 			entry.baseMoves ??= /* @__PURE__ */ new Set();
 			for (const ref of baseMoves) entry.baseMoves.add(ref);
@@ -559,7 +612,8 @@ var WorktreeSummaryService = class {
 		return true;
 	}
 	async run(entry, fields, baseMoves) {
-		const previous = entry.value;
+		const { value, seed } = entry;
+		const previous = value ?? seed;
 		let result;
 		try {
 			const repo = this.getRepository(entry.key);
@@ -573,16 +627,27 @@ var WorktreeSummaryService = class {
 		if (entry.disposed) return;
 		if (result.summary.stale && (previous == null || !previous.stale)) _logger.warn(`WorktreeSummaryService: reading the base of '${entry.key}' failed: ${String(result.baseError)}`);
 		entry.error = void 0;
+		entry.seed = void 0;
 		entry.baseKeys = result.baseKeys;
 		entry.baseConfigKey = entry.pending & baseConfigField ? void 0 : result.baseConfigKey;
 		entry.baseDefaultBranch = result.baseDefaultBranch;
-		if (previous != null && summariesEqual(previous, result.summary)) return;
-		entry.value = result.summary;
-		this.fireChange(entry, result.summary);
+		const dirtyConfirmed = result.dirtyReadAt != null && entry.dirtyReadAt != null;
+		if (dirtyConfirmed) clearDeferredDirty(entry);
+		if (value != null && summariesEqual(value, result.summary)) {
+			if (dirtyConfirmed) this.fireChange(entry, value);
+			return;
+		}
+		const summary = value == null && seed != null && summariesEqual(seed, result.summary) ? seed : result.summary;
+		entry.value = summary;
+		this.fireChange(entry, summary);
 	}
 	fail(entry, ex) {
 		const previous = entry.value;
 		if (previous == null) {
+			if (entry.seed != null) {
+				dropSeed(entry);
+				if (entry.pending !== 0) entry.pending |= 23;
+			}
 			if (entry.error == null) _logger.warn(`WorktreeSummaryService: reading '${entry.key}' failed: ${String(ex)}`);
 			entry.error = ex instanceof Error ? ex : new Error(String(ex));
 			return;
@@ -617,6 +682,8 @@ var WorktreeSummaryService = class {
 		entry.handle?.dispose();
 		entry.handle = void 0;
 		entry.value = void 0;
+		entry.seed = void 0;
+		clearDeferredDirty(entry);
 		entry.baseKeys = void 0;
 		entry.baseConfigKey = void 0;
 		entry.baseDefaultBranch = void 0;
@@ -635,6 +702,19 @@ function* getConfigRelevantRefs(value) {
 	if (value.upstream != null) yield `refs/heads/${value.upstream.name}`;
 	yield* value.baseDependsOn;
 }
+/** Drops the saved read a first run was to start from, with the values its base read consulted and its dirty flag */
+function dropSeed(entry) {
+	entry.seed = void 0;
+	clearDeferredDirty(entry);
+	entry.baseKeys = void 0;
+	entry.baseConfigKey = void 0;
+	entry.baseDefaultBranch = void 0;
+}
+function clearDeferredDirty(entry) {
+	entry.dirtyReadAt = void 0;
+	clearTimeout(entry.dirtyReadTimer);
+	entry.dirtyReadTimer = void 0;
+}
 function createEntry(key) {
 	return {
 		key,
@@ -644,6 +724,9 @@ function createEntry(key) {
 		handle: void 0,
 		listeners: void 0,
 		value: void 0,
+		seed: void 0,
+		dirtyReadAt: void 0,
+		dirtyReadTimer: void 0,
 		baseKeys: void 0,
 		baseConfigKey: void 0,
 		baseDefaultBranch: void 0,
@@ -807,6 +890,37 @@ function getTipsByName(tips) {
 	}
 	return byName;
 }
+/**
+* The read groups due on a read from `last`, given what `probe` found of its inputs since (with the refs the base
+* depends on that moved): those `last` made due, and those whose inputs moved
+*/
+async function getMovedFields(repo, last, probe, probeDirty, signal) {
+	let fields = last.due;
+	let baseMoves;
+	const { inputs } = last;
+	const previous = last.result.summary;
+	if (probe.branch !== inputs.branch || probe.detached !== inputs.detached || probe.sha !== inputs.sha) fields |= allFields;
+	else {
+		if (probe.upstream !== inputs.upstream) fields |= 18;
+		else if (getUpstreamTips(probe.tips, probe.upstream) !== inputs.upstreamTips) fields |= branchField;
+		for (const ref of previous.baseDependsOn) {
+			const value = getBaseInput(probe, ref);
+			if (value !== null && value === inputs.baseTips.get(ref)) continue;
+			baseMoves ??= /* @__PURE__ */ new Set();
+			baseMoves.add(ref);
+		}
+		if (baseMoves != null) fields |= baseMoveField;
+		if ((fields & baseConfigField) === 0 && last.result.baseConfigKey != null && repo.branches.getAheadOfBase != null && (probe.detached || probe.branch != null)) {
+			const configKey = getBaseConfigKey(await readBaseConfig(repo, signal), previous);
+			if (configKey != null && configKey !== last.result.baseConfigKey) fields |= 18;
+		}
+	}
+	if (probeDirty || probe.index == null || probe.index !== inputs.index) fields |= dirtyField;
+	return {
+		fields,
+		baseMoves
+	};
+}
 /** The upstream's tips as a remote-tracking and as a local branch, since its short name doesn't say which */
 function getUpstreamTips(tips, upstream) {
 	if (upstream == null) return void 0;