@gitkraken/core-gitlens 0.1.0 → 0.3.0

package/src/utils/iterable.ts

@@ -179,7 +179,7 @@ class FilterIterator<T, U extends T = T> implements IterableIterator<T | U> {
 			}
 
 			if (this.predicate === undefined ? result.value != null : this.predicate(result.value)) {
-				return { done: false, value: result.value as T | U };
+				return { done: false, value: result.value };
 			}
 		}
 	}
@@ -269,6 +269,7 @@ export function findIndex<T>(source: Iterable<T> | IterableIterator<T>, predicat
 	let i = 0;
 	for (const item of source) {
 		if (predicate(item)) return i;
+
 		i++;
 	}
 	return -1;
@@ -329,6 +330,7 @@ class FlatMapIterator<T, TMapped> implements IterableIterator<TMapped> {
 				if (!mappedResult.done) {
 					return { done: false, value: mappedResult.value };
 				}
+
 				// Current mapped iterator is exhausted, move to next source item
 				this.currentMappedIterator = undefined;
 			}
@@ -576,6 +578,7 @@ class SkipIterator<T> implements IterableIterator<T> {
 				this.done = true;
 				return { done: true, value: undefined };
 			}
+
 			this.skipped++;
 		}
 

package/src/utils/logger.ts

@@ -364,6 +364,7 @@ export function getLoggableName(instance: object): string {
 		if (customNameFn != null) {
 			return customNameFn(instance, name);
 		}
+
 		proto = Object.getPrototypeOf(proto);
 	}
 

package/src/utils/lruMap.ts

@@ -0,0 +1,112 @@
+/**
+ * Bounded LRU map. On `set` / `update`, the touched key becomes the
+ * most-recently-used entry; on overflow, the least-recently-used key is
+ * evicted until `size <= limit`. Built on a plain `Map`, exploiting that
+ * `Map` preserves insertion order — re-inserting a key moves it to the end.
+ *
+ * Intentionally minimal — `get` / `set` / `delete` / `clear` / `size` /
+ * `has` / `keys` / `values` / `update`. No expiry, no async, no events.
+ * Callers that need invalidation rules layer them on top.
+ *
+ * `update(key, patch)` is a convenience for object-shaped values: merges
+ * `patch` into the existing entry (or seeds a new one) and touches the key.
+ * Use `set` for non-object values.
+ */
+export class LruMap<K, V> {
+	private readonly _map = new Map<K, V>();
+	private readonly _pinned = new Set<K>();
+
+	constructor(private readonly limit: number) {}
+
+	/**
+	 * Pin a key so it's never evicted by capacity pressure (it can still be explicitly
+	 * `delete`d / `clear`ed). Use for entries that must stay available regardless of how many
+	 * other keys churn — e.g. the selected repo's WIP, which the header badge derives from.
+	 * Pinning a key not yet present is fine; it takes effect once the key is `set`.
+	 */
+	pin(key: K): void {
+		this._pinned.add(key);
+	}
+
+	unpin(key: K): void {
+		this._pinned.delete(key);
+	}
+
+	get size(): number {
+		return this._map.size;
+	}
+
+	get(key: K): V | undefined {
+		return this._map.get(key);
+	}
+
+	has(key: K): boolean {
+		return this._map.has(key);
+	}
+
+	set(key: K, value: V): this {
+		// Re-insert to move the key to the end (most-recently-used).
+		this._map.delete(key);
+		this._map.set(key, value);
+		this.evict();
+		return this;
+	}
+
+	/**
+	 * Merge `patch` into the existing entry (or seed a new entry from it) and
+	 * touch the key. Returns the merged value. Object-shaped `V` only.
+	 */
+	update(key: K, patch: Partial<V>): V {
+		const existing = this._map.get(key);
+		const next = { ...(existing ?? {}), ...patch };
+		this.set(key, next as V);
+		return next as V;
+	}
+
+	/**
+	 * Promote an existing entry to most-recently-used without changing its value.
+	 * Returns `true` if the key was present (and therefore touched), `false` otherwise.
+	 * Use on cache hits when you want subsequent eviction pressure to skip this entry.
+	 */
+	touch(key: K): boolean {
+		if (!this._map.has(key)) return false;
+
+		const value = this._map.get(key) as V;
+		this._map.delete(key);
+		this._map.set(key, value);
+		return true;
+	}
+
+	delete(key: K): boolean {
+		return this._map.delete(key);
+	}
+
+	clear(): void {
+		this._map.clear();
+		// Drop pins too — a cleared map has no entries to protect, and leaving stale pins would
+		// wrongly shield the NEXT value set under a previously-pinned key from eviction.
+		this._pinned.clear();
+	}
+
+	keys(): IterableIterator<K> {
+		return this._map.keys();
+	}
+
+	values(): IterableIterator<V> {
+		return this._map.values();
+	}
+
+	private evict(): void {
+		if (this._map.size <= this.limit) return;
+
+		// Iterate oldest-first, deleting the first non-pinned keys until back at capacity.
+		// Pinned keys are skipped — if everything is pinned the map can exceed `limit`, which
+		// is the intended trade-off (pins are deliberate and few).
+		for (const key of this._map.keys()) {
+			if (this._map.size <= this.limit) break;
+			if (this._pinned.has(key)) continue;
+
+			this._map.delete(key);
+		}
+	}
+}

package/src/utils/markdown.ts

@@ -88,6 +88,7 @@ export function escapeMarkdownCodeBlocks(s: string): string {
 			i += 2;
 			continue;
 		}
+
 		if (quotesOpened) {
 			buffer += char;
 		} else {

package/src/utils/mru.ts

@@ -55,9 +55,11 @@ export class MRU<T> {
 
 		if (direction === 'back') {
 			if (this._position >= this.stack.length - 1) return undefined;
+
 			this._position += 1;
 		} else {
 			if (this._position <= 0) return undefined;
+
 			this._position -= 1;
 		}
 

package/src/utils/path.ts

@@ -25,6 +25,7 @@ export function commonBase(s: string[], delimiter: string, ignoreCase?: boolean)
 	for (let i = 1; i < s.length; i++) {
 		const index = commonBaseIndex(common, s[i], delimiter, ignoreCase);
 		if (index === 0) return undefined;
+
 		common = common.substring(0, index + 1);
 	}
 

package/src/utils/promise.ts

@@ -143,6 +143,7 @@ export function cancellable<T>(
 				resolver('cancelled');
 				return;
 			}
+
 			const handler = () => resolver('cancelled');
 			cancellation.addEventListener('abort', handler);
 			disposeCancellation = { dispose: () => cancellation.removeEventListener('abort', handler) };
@@ -156,6 +157,7 @@ export function cancellable<T>(
 					resolver('timedout');
 					return;
 				}
+
 				const handler = () => resolver('timedout');
 				timeout.addEventListener('abort', handler);
 				disposeTimeout = { dispose: () => timeout.removeEventListener('abort', handler) };
@@ -588,3 +590,23 @@ export function wait(ms: number): Promise<void> {
 export function waitUntilNextTick(): Promise<void> {
 	return new Promise<void>(resolve => queueMicrotask(resolve));
 }
+
+const _schedulerYield = (
+	globalThis as unknown as { scheduler?: { yield?: () => Promise<void> } }
+).scheduler?.yield?.bind((globalThis as any).scheduler);
+const _raf =
+	typeof (globalThis as any).requestAnimationFrame === 'function'
+		? (globalThis as unknown as { requestAnimationFrame?: (callback: (time: number) => void) => number })
+				.requestAnimationFrame
+		: undefined;
+
+export async function yieldToScheduler(): Promise<void> {
+	if (_schedulerYield != null) {
+		await _schedulerYield();
+	} else if (_raf != null) {
+		await new Promise(r => _raf(r));
+	} else {
+		// Node fallback
+		await new Promise(r => setTimeout(r, 0));
+	}
+}

package/src/utils/promiseCache.ts

@@ -97,6 +97,7 @@ export class PromiseCache<K, V> {
 		if (entry == null || this.expired(entry, now)) {
 			return undefined;
 		}
+
 		// Update accessed time
 		entry.accessed = now;
 		return entry.promise;
@@ -686,6 +687,29 @@ export class RepoPromiseCacheMap<K, V> {
 		return deleted;
 	}
 
+	/**
+	 * Invalidates all keys matching a prefix from a repository's cache. See `PromiseCache.invalidate`
+	 * for semantics — in-flight entries are marked invalidated and shared with new callers; settled
+	 * entries are hard-deleted. Prefer over `deleteByKeyPrefix` when the eviction is a "data has
+	 * changed" event and in-flight factories' results would still be valid for current waiters.
+	 * @param repoPath - The repository path
+	 * @param prefix - Key prefix to match
+	 * @returns true if something was invalidated
+	 */
+	invalidateByKeyPrefix(this: RepoPromiseCacheMap<string, V>, repoPath: string, prefix: string): boolean {
+		const repoCache = this.cache.get(repoPath);
+		if (repoCache == null) return false;
+
+		let invalidated = false;
+		for (const key of repoCache.keys()) {
+			if (key.startsWith(prefix)) {
+				repoCache.invalidate(key);
+				invalidated = true;
+			}
+		}
+		return invalidated;
+	}
+
 	/**
 	 * Clears all caches for all repositories.
 	 */

package/src/utils/string.ts

@@ -518,6 +518,7 @@ class IterableDelimiterIterator implements IterableIterator<string> {
 						this.done = true;
 						return { done: false, value: value };
 					}
+
 					this.done = true;
 					return { done: true, value: undefined };
 				}
@@ -631,6 +632,7 @@ class AsyncIterableDelimiterIterator implements AsyncIterableIterator<string> {
 					this.done = true;
 					return { done: false, value: value };
 				}
+
 				this.done = true;
 				return { done: true, value: undefined };
 			}

package/src/utils/uri.ts

@@ -105,6 +105,7 @@ export function reviveUri(data: UriComponents): Uri {
 export function getRepositoryKey(pathOrUri: string | Uri): string {
 	if (typeof pathOrUri === 'string') {
 		if (!hasScheme(pathOrUri)) return normalizePath(pathOrUri);
+
 		// Parse URI strings so file: URIs get normalized to fsPath
 		pathOrUri = URI.parse(pathOrUri);
 	}

package/src/utils/version.ts

@@ -55,6 +55,55 @@ export function fromVersion(v: Version, includePre?: boolean): `${number}.${numb
 	return `${v.major}.${v.minor}.${v.patch}${includePre && v.pre ? `-${v.pre}` : ''}`;
 }
 
+/**
+ * Compares two strings using version-aware sorting in descending order,
+ * matching git's `--sort=-version:refname` (based on glibc's `strverscmp`).
+ *
+ * Walks character-by-character: non-digit runs are compared lexicographically,
+ * digit runs are compared numerically. No prefix stripping (git only strips
+ * prefixes when `versionsort.prefix` is configured).
+ */
+export function compareByVersionDescending(a: string, b: string): number {
+	return -compareByVersion(a, b);
+}
+
+/**
+ * Compares two strings using version-aware sorting in ascending order,
+ * matching git's `--sort=version:refname` (based on glibc's `strverscmp`).
+ */
+export function compareByVersion(a: string, b: string): number {
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) {
+		const ca = a.charCodeAt(i);
+		const cb = b.charCodeAt(j);
+		const aIsDigit = ca >= 48 && ca <= 57; // '0'-'9'
+		const bIsDigit = cb >= 48 && cb <= 57;
+
+		if (aIsDigit && bIsDigit) {
+			// Both in a digit run — compare numerically
+			let numA = 0;
+			while (i < a.length && a.charCodeAt(i) >= 48 && a.charCodeAt(i) <= 57) {
+				numA = numA * 10 + (a.charCodeAt(i) - 48);
+				i++;
+			}
+			let numB = 0;
+			while (j < b.length && b.charCodeAt(j) >= 48 && b.charCodeAt(j) <= 57) {
+				numB = numB * 10 + (b.charCodeAt(j) - 48);
+				j++;
+			}
+			if (numA !== numB) return numA - numB;
+		} else {
+			// Compare non-digit characters lexicographically
+			if (ca !== cb) return ca - cb;
+
+			i++;
+			j++;
+		}
+	}
+	return a.length - b.length;
+}
+
 export function satisfies(
 	v: string | Version | null | undefined,
 	requirement: `${'=' | '>' | '>=' | '<' | '<='} ${string}`,

package/dist/git/exec.types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec.types.d.ts","sourceRoot":"","sources":["../../src/git/exec.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAEtE,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,QAAQ,CAAC;AAElD,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,IAAI;IACrE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACnB,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAEpB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B,WAAW,CACV,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,SAAS,EAAE,eAAe,KAAK,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,EACpE,OAAO,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAClD,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;CAC/B;AAED;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG,QAAQ,GAAG,YAAY,CAAC;AAEzE,MAAM,WAAW,cAAc;IAC9B,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,mGAAmG;IACnG,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,0GAA0G;IAC1G,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;OAGG;IACH,OAAO,CAAC,EAAE;QACT,KAAK,EAAE,cAAc,CAAC;QACtB,gGAAgG;QAChG,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE;YAAE,SAAS,CAAC,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KACrD,CAAC;IAGF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAC;IACvD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC/B,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAG5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IAClD,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,QAAQ,GAAG,MAAM,CAAC;IACvD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEhC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC1B"}

package/dist/git/exec.types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=exec.types.js.map

package/dist/git/exec.types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec.types.js","sourceRoot":"","sources":["../../src/git/exec.types.ts"],"names":[],"mappings":""}