@gitkraken/core-gitlens 0.1.0 → 0.2.0

package/src/utils/lruMap.ts

@@ -0,0 +1,87 @@
+/**
+ * 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>();
+
+	constructor(private readonly limit: number) {}
+
+	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();
+	}
+
+	keys(): IterableIterator<K> {
+		return this._map.keys();
+	}
+
+	values(): IterableIterator<V> {
+		return this._map.values();
+	}
+
+	private evict(): void {
+		while (this._map.size > this.limit) {
+			const oldest = this._map.keys().next().value;
+			if (oldest === undefined) break;
+			this._map.delete(oldest);
+		}
+	}
+}

package/src/utils/version.ts

@@ -55,6 +55,54 @@ 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}`,