@gitkraken/core-gitlens 0.2.0 → 0.3.1

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

@@ -14,9 +14,24 @@
  */
 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;
 	}
@@ -55,6 +70,7 @@ export class LruMap<K, V> {
 	 */
 	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);
@@ -67,6 +83,9 @@ export class LruMap<K, V> {
 
 	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> {
@@ -78,10 +97,16 @@ export class LruMap<K, V> {
 	}
 
 	private evict(): void {
-		while (this._map.size > this.limit) {
-			const oldest = this._map.keys().next().value;
-			if (oldest === undefined) break;
-			this._map.delete(oldest);
+		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/object.ts

@@ -1,11 +1,62 @@
-export function areEqual(a: any, b: any): boolean {
+/**
+ * Structural deep-equality. Walks both values and short-circuits on the first difference without
+ * serializing to a string (unlike a `JSON.stringify` compare): the `a === b` fast path skips
+ * unchanged shared subtrees, and unequal values bail at the first mismatched field. Handles
+ * primitives, `null`/`undefined`, `Date` (by timestamp), arrays, and plain objects.
+ *
+ * Differs from the prior `JSON.stringify` compare in three ways — each intended or matching the old
+ * behavior:
+ * - Key-order-insensitive (the old compare was order-sensitive). Observable at one caller
+ *   (`configuration.update`, when a config value equals its schema default but with different key
+ *   order), where it harmlessly treats the value as the default rather than persisting a redundant
+ *   override.
+ * - A present-but-`undefined` key is distinct from an absent key (the old compare dropped
+ *   `undefined` keys).
+ * - `Map`/`Set`/`RegExp` and other exotic objects are NOT deep-compared — they reduce to their
+ *   own-enumerable keys (so two are effectively always-equal), same as the old stringify behavior.
+ *   No caller compares those.
+ *
+ * Assumes acyclic input — it recurses without a cycle guard (a self-referential value would
+ * overflow the stack). Every caller compares JSON-origin or same-shape data.
+ */
+export function areEqual(a: unknown, b: unknown): boolean {
 	if (a === b) return true;
 	if (a == null || b == null) return false;
 
-	const aType = typeof a;
-	if (aType === typeof b && (aType === 'string' || aType === 'number' || aType === 'boolean')) return false;
+	const type = typeof a;
+	if (type !== typeof b || type !== 'object') return false;
+
+	// Both are non-null objects from here.
+	if (a instanceof Date) return b instanceof Date && a.getTime() === b.getTime();
+	if (b instanceof Date) return false;
+
+	const aIsArray = Array.isArray(a);
+	if (aIsArray !== Array.isArray(b)) return false;
+
+	if (aIsArray) {
+		const arrA = a as unknown[];
+		const arrB = b as unknown[];
+		if (arrA.length !== arrB.length) return false;
 
-	return JSON.stringify(a) === JSON.stringify(b);
+		for (let i = 0; i < arrA.length; i++) {
+			if (!areEqual(arrA[i], arrB[i])) return false;
+		}
+		return true;
+	}
+
+	const objA = a as Record<string, unknown>;
+	const objB = b as Record<string, unknown>;
+	const keysA = Object.keys(objA);
+	if (keysA.length !== Object.keys(objB).length) return false;
+
+	// Equal key COUNT alone doesn't prove equal key SETS — without the `hasOwn` check,
+	// `{ a: 1, b: undefined }` and `{ a: 1, c: undefined }` would falsely compare equal (each
+	// missing key reads as `undefined`). The count check plus "every A-key is an own-key of B"
+	// together guarantee identical key sets.
+	for (const key of keysA) {
+		if (!Object.hasOwn(objB, key) || !areEqual(objA[key], objB[key])) return false;
+	}
+	return true;
 }
 
 type Primitive = string | number | boolean;

package/src/utils/paging.ts

@@ -26,24 +26,24 @@ export class PageableResult<T> {
 	}
 
 	async *values(): AsyncIterable<NonNullable<T>> {
-		if (this.cached != null) {
-			for (const value of this.cached.values) {
-				yield value;
-			}
+		let page = this.cached;
+		if (page == null) {
+			// No seed or cached results yet, so perform the initial fetch
+			page = await this.fetch(undefined);
+			this.cached = page;
 		}
 
-		let results = this.cached;
-		while (results == null || results.paging?.more) {
-			results = await this.fetch(results?.paging);
+		const cached = page; // memoized accumulator (the first page)
+		for (const value of cached.values) {
+			yield value;
+		}
 
-			if (this.cached == null) {
-				this.cached = results;
-			} else {
-				this.cached.values.push(...results.values);
-				this.cached.paging = results.paging;
-			}
+		while (page.paging?.more) {
+			page = await this.fetch(page.paging);
+			cached.values.push(...page.values);
+			cached.paging = page.paging;
 
-			for (const value of results.values) {
+			for (const value of page.values) {
 				yield value;
 			}
 		}

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;
@@ -171,14 +172,18 @@ export class PromiseCache<K, V> {
 		this.controllers.set(key, cacheable);
 
 		const promise = factory(cacheable, abortAgg.signal);
-		void promise.finally(() => {
-			if (cacheable.invalidated) {
-				this.cache.delete(key);
-			}
-			abortAgg.dispose();
-			this.aborts.delete(key);
-			this.controllers.delete(key);
-		});
+		void promise
+			.finally(() => {
+				if (cacheable.invalidated) {
+					this.cache.delete(key);
+				}
+				abortAgg.dispose();
+				this.aborts.delete(key);
+				this.controllers.delete(key);
+			})
+			// Swallow the cleanup chain's rejection so it doesn't surface as an unhandled rejection
+			// separate from the caller-facing promise's own handling (e.g. on cancellation).
+			.catch(() => {});
 
 		if (options?.onError != null) {
 			// Wrap the promise to handle errors with the onError callback
@@ -392,14 +397,18 @@ export class PromiseMap<K, V> {
 
 		// Automatically remove failed promises from the cache
 		promise.catch(() => this.cache.delete(key));
-		void promise.finally(() => {
-			if (cacheable.invalidated) {
-				this.cache.delete(key);
-			}
-			aborts.dispose();
-			this.aborts.delete(key);
-			this.controllers.delete(key);
-		});
+		void promise
+			.finally(() => {
+				if (cacheable.invalidated) {
+					this.cache.delete(key);
+				}
+				aborts.dispose();
+				this.aborts.delete(key);
+				this.controllers.delete(key);
+			})
+			// Swallow the cleanup chain's rejection so it doesn't surface as an unhandled rejection
+			// separate from the caller-facing promise's own handling (e.g. on cancellation).
+			.catch(() => {});
 
 		this.cache.set(key, promise);
 
@@ -686,6 +695,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 };
 			}
@@ -767,7 +769,7 @@ export function pluralize(
 }
 
 // Removes \ / : * ? " < > | and C0 and C1 control codes
-// eslint-disable-next-line no-control-regex
+// oxlint-disable-next-line no-control-regex
 const illegalCharsForFSRegex = /[\\/:*?"<>|\x00-\x1f\x80-\x9f]/g;
 
 export function sanitizeForFileSystem(s: string, replacement: string = '_'): string {

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

@@ -96,6 +96,7 @@ export function compareByVersion(a: string, b: string): number {
 		} else {
 			// Compare non-digit characters lexicographically
 			if (ca !== cb) return ca - cb;
+
 			i++;
 			j++;
 		}

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":""}