@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/src/utils/dedupedAsyncCache.ts

@@ -1,74 +0,0 @@
-/**
- * Per-key cache for async resolution that dedupes concurrent first-time callers and caches the
- * resolved value (including `undefined`) for subsequent reads.
- *
- * Two internal Maps drive the semantics:
- * - `_resolved` holds settled values. `has(key)` distinguishes a cached `undefined` from "never
- *   resolved", so callers can intentionally cache "no result" without re-running the resolver.
- * - `_resolving` holds in-flight Promises. While a key resolves, concurrent `getOrResolve` callers
- *   share the same Promise instead of each invoking the resolver.
- *
- * Failed resolutions do not poison the cache — the entry is removed when the in-flight Promise
- * rejects, so the next call retries.
- */
-export class DedupedAsyncCache<K, V> {
-	private readonly _resolved = new Map<K, V>();
-	private readonly _resolving = new Map<K, Promise<V>>();
-
-	/** True iff `key` has a settled value cached. Distinct from "currently resolving". */
-	has(key: K): boolean {
-		return this._resolved.has(key);
-	}
-
-	/** Settled value for `key`, or `undefined` when not yet cached. May also legitimately return
-	 *  `undefined` for a key whose cached value is `undefined`; use `has` to disambiguate. */
-	get(key: K): V | undefined {
-		return this._resolved.get(key);
-	}
-
-	/** Populates the cache directly, bypassing the resolver. Used by callers that already know the
-	 *  value (e.g. event payloads, post-write reconciles) and want subsequent reads to hit. */
-	set(key: K, value: V): void {
-		this._resolved.set(key, value);
-	}
-
-	/** Removes both the settled value and any in-flight Promise for `key`. */
-	delete(key: K): void {
-		this._resolved.delete(key);
-		this._resolving.delete(key);
-	}
-
-	/** Clears everything — both settled values and in-flight Promises. */
-	clear(): void {
-		this._resolved.clear();
-		this._resolving.clear();
-	}
-
-	/**
-	 * Returns the cached value for `key`, invoking `resolver` only on a cache miss. Concurrent
-	 * cache-miss callers for the same key share the same in-flight Promise — `resolver` is invoked
-	 * exactly once per cache fill. If `resolver` rejects, the entry is removed so subsequent calls
-	 * retry rather than receiving a permanently cached failure.
-	 */
-	getOrResolve(key: K, resolver: () => Promise<V>): Promise<V> {
-		if (this._resolved.has(key)) {
-			// Map.get returns `V | undefined`; `has` confirmed presence, so the value (even if it
-			// is `undefined` by intent) is the cached one. Cast pins the return type.
-			return Promise.resolve(this._resolved.get(key) as V);
-		}
-
-		const existing = this._resolving.get(key);
-		if (existing != null) return existing;
-
-		const pending = resolver()
-			.then(value => {
-				this._resolved.set(key, value);
-				return value;
-			})
-			.finally(() => {
-				this._resolving.delete(key);
-			});
-		this._resolving.set(key, pending);
-		return pending;
-	}
-}

package/src/utils/diff.ts

@@ -1,61 +0,0 @@
-// Annotates diff to make is easier for agentic reference to line number.
-// Brackets sit AFTER the line-type marker so file-level diff parsers
-// (e.g. `filterDiffFiles`) that key off `diff --git` / `+++` / `---` headers still work.
-export function annotateDiffWithNewLineNumbers(diff: string): string {
-	if (!diff) return diff;
-
-	const lines = diff.split('\n');
-	const out: string[] = new Array(lines.length);
-	let newLine = 0;
-	let inHunk = false;
-
-	for (let i = 0; i < lines.length; i++) {
-		const line = lines[i];
-
-		if (line.startsWith('@@')) {
-			const match = /\+(\d+)(?:,\d+)?\s/.exec(line);
-			newLine = match != null ? parseInt(match[1], 10) : 0;
-			inHunk = true;
-			out[i] = line;
-			continue;
-		}
-
-		if (
-			line.startsWith('diff --git') ||
-			line.startsWith('index ') ||
-			line.startsWith('--- ') ||
-			line.startsWith('+++ ') ||
-			line.startsWith('new file') ||
-			line.startsWith('deleted file') ||
-			line.startsWith('rename ') ||
-			line.startsWith('copy ') ||
-			line.startsWith('similarity ') ||
-			line.startsWith('dissimilarity ') ||
-			line.startsWith('Binary files')
-		) {
-			inHunk = false;
-			out[i] = line;
-			continue;
-		}
-
-		if (!inHunk || line.startsWith('\\')) {
-			out[i] = line;
-			continue;
-		}
-
-		const marker = line[0];
-		if (marker === '-') {
-			out[i] = `-[     ]${line.slice(1)}`;
-			continue;
-		}
-		if (marker === '+' || marker === ' ') {
-			out[i] = `${marker}[${String(newLine).padStart(5, ' ')}]${line.slice(1)}`;
-			newLine++;
-			continue;
-		}
-
-		out[i] = line;
-	}
-
-	return out.join('\n');
-}

package/src/utils/disposable.ts

@@ -1,156 +0,0 @@
-import { once } from './function.js';
-
-/**
- * Minimal disposable contract — a single `dispose(): void` method.
- *
- * Mirrors the shape of `vscode.Disposable` so vscode-free packages can name
- * the contract without requiring lib.es2022's `[Symbol.dispose]`. Classes that
- * already implement `dispose()` (the vscode-style) satisfy it without changes.
- *
- * Use {@link UnifiedDisposable} when you also need the `using`-statement
- * (`Symbol.dispose`) protocol; everything else can stay on this looser type.
- */
-
-export type Disposable = { dispose: () => void };
-
-export type UnifiedDisposable = { dispose: () => void } & globalThis.Disposable;
-export type UnifiedAsyncDisposable = { dispose: () => Promise<void> } & AsyncDisposable;
-
-export function createDisposable(dispose: () => void, options?: { once?: boolean }): UnifiedDisposable;
-export function createDisposable(
-	dispose: (() => void) | undefined,
-	options?: { once?: boolean },
-): UnifiedDisposable | undefined;
-export function createDisposable(
-	dispose?: (() => void) | undefined,
-	options?: { once?: boolean },
-): UnifiedDisposable | undefined {
-	if (dispose == null) return undefined;
-
-	if (options?.once) {
-		dispose = once(dispose);
-	}
-
-	return {
-		dispose: dispose,
-		[Symbol.dispose]: dispose,
-	};
-}
-
-export function createAsyncDisposable(
-	dispose: () => Promise<any>,
-	options?: { once?: boolean },
-): UnifiedAsyncDisposable {
-	if (options?.once) {
-		dispose = once(dispose);
-	}
-
-	return {
-		dispose: dispose,
-		[Symbol.asyncDispose]: dispose,
-	};
-}
-
-export function disposableInterval(fn: (...args: any[]) => void, ms: number): UnifiedDisposable {
-	let timer: ReturnType<typeof setInterval> | undefined;
-	const dispose = () => {
-		if (timer != null) {
-			clearInterval(timer);
-			timer = undefined;
-		}
-	};
-
-	const disposable = {
-		[Symbol.dispose]: dispose,
-		dispose: dispose,
-	};
-	timer = setInterval(fn, ms);
-
-	return disposable;
-}
-
-export function fromDisposables(
-	...disposables: (UnifiedDisposable | globalThis.Disposable | { dispose: () => void } | undefined)[]
-): UnifiedDisposable {
-	let disposed = false;
-	const dispose = () => {
-		if (disposed) return;
-
-		disposed = true;
-
-		for (const d of disposables) {
-			if (d == null) continue;
-
-			if ('dispose' in d) {
-				d.dispose();
-			} else {
-				d[Symbol.dispose]?.();
-			}
-		}
-	};
-
-	return {
-		dispose: dispose,
-		[Symbol.dispose]: dispose,
-	};
-}
-
-/** Returns the existing object with disposable methods added */
-export function mixinDisposable<T extends { dispose: () => void }>(disposable: T): T & UnifiedDisposable;
-export function mixinDisposable<T extends { dispose: () => void } | undefined>(
-	disposable: T,
-): (T & UnifiedDisposable) | undefined;
-export function mixinDisposable<T extends object & { dispose?: never }>(
-	obj: T,
-	dispose: () => void,
-): T & UnifiedDisposable;
-export function mixinDisposable<T extends (object & { dispose?: never }) | { dispose: () => void }>(
-	obj: T,
-	dispose?: () => void,
-): (T & UnifiedDisposable) | undefined {
-	if (obj == null) return undefined;
-
-	if (dispose != null) {
-		(obj as any).dispose = dispose;
-		(obj as any)[Symbol.dispose] = dispose;
-		return obj as T & UnifiedDisposable;
-	}
-
-	if ('dispose' in obj && obj.dispose != null) {
-		(obj as any)[Symbol.dispose] = obj.dispose;
-		return obj as T & UnifiedDisposable;
-	}
-
-	throw new Error('Object does not have a dispose method or a dispose function was not provided');
-}
-
-/** Returns the existing object with async disposable methods added */
-export function mixinAsyncDisposable<T extends { dispose: () => Promise<any> }>(
-	disposable: T,
-): T & UnifiedAsyncDisposable;
-export function mixinAsyncDisposable<T extends { dispose: () => Promise<any> } | undefined>(
-	disposable: T,
-): (T & UnifiedAsyncDisposable) | undefined;
-export function mixinAsyncDisposable<T extends object & { dispose?: never }>(
-	obj: T,
-	dispose: () => Promise<any>,
-): T & UnifiedAsyncDisposable;
-export function mixinAsyncDisposable<T extends (object & { dispose?: never }) | { dispose: () => Promise<any> }>(
-	obj: T,
-	dispose?: () => Promise<any>,
-): (T & UnifiedAsyncDisposable) | undefined {
-	if (obj == null) return undefined;
-
-	if (dispose != null) {
-		(obj as any).dispose = dispose;
-		(obj as any)[Symbol.asyncDispose] = dispose;
-		return obj as T & UnifiedAsyncDisposable;
-	}
-
-	if ('dispose' in obj && obj.dispose != null) {
-		(obj as any)[Symbol.asyncDispose] = obj.dispose;
-		return obj as T & UnifiedAsyncDisposable;
-	}
-
-	throw new Error('Object does not have a dispose method or a dispose function was not provided');
-}

package/src/utils/encoding.ts

@@ -1,8 +0,0 @@
-export function encodeUrl(url: string): string;
-export function encodeUrl(url: string | undefined): string | undefined;
-export function encodeUrl(url: string | undefined): string | undefined {
-	if (url == null) return undefined;
-
-	// Not a fan of this, but it's hard to gauge previous encoding and this is the most common case
-	return encodeURI(url.replace(/%20/g, ' '));
-}

package/src/utils/env/browser/base64.ts

@@ -1,50 +0,0 @@
-const { fromCharCode } = String;
-const textEncoder = new TextEncoder();
-const textDecoder = new TextDecoder();
-
-export function base64(s: string): string;
-export function base64(bytes: Uint8Array): string;
-export function base64(data: string | Uint8Array): string {
-	const bytes = typeof data === 'string' ? textEncoder.encode(data) : data;
-
-	let output = '';
-	for (let i = 0, { length } = bytes; i < length; i++) {
-		output += fromCharCode(bytes[i]);
-	}
-	return globalThis.btoa(output);
-}
-
-export function fromBase64(s: string): Uint8Array<ArrayBuffer> {
-	const decoded = globalThis.atob(s);
-
-	const len = decoded.length;
-	const bytes = new Uint8Array(len);
-
-	// Unrolled loop for better performance on larger strings
-	let i = 0;
-	const end = len - (len % 8);
-	for (; i < end; i += 8) {
-		bytes[i] = decoded.charCodeAt(i);
-		bytes[i + 1] = decoded.charCodeAt(i + 1);
-		bytes[i + 2] = decoded.charCodeAt(i + 2);
-		bytes[i + 3] = decoded.charCodeAt(i + 3);
-		bytes[i + 4] = decoded.charCodeAt(i + 4);
-		bytes[i + 5] = decoded.charCodeAt(i + 5);
-		bytes[i + 6] = decoded.charCodeAt(i + 6);
-		bytes[i + 7] = decoded.charCodeAt(i + 7);
-	}
-	// Handle remaining bytes
-	for (; i < len; i++) {
-		bytes[i] = decoded.charCodeAt(i);
-	}
-
-	return bytes;
-}
-
-/**
- * Decodes a base64-encoded string directly to a UTF-8 string.
- * More efficient than fromBase64().toString() for string conversion.
- */
-export function fromBase64ToString(s: string): string {
-	return textDecoder.decode(fromBase64(s));
-}

package/src/utils/env/browser/crypto.ts

@@ -1,21 +0,0 @@
-import { base64 } from './base64.js';
-import { convertToHex } from './hex.js';
-import { md5 as _md5 } from './md5.js';
-
-export function getNonce(): string {
-	return base64(globalThis.crypto.getRandomValues(new Uint8Array(16)));
-}
-
-export function md5(data: string, encoding: 'base64' | 'hex' = 'hex'): string {
-	return _md5(data, encoding);
-}
-
-export async function sha256(data: string, encoding: 'base64' | 'hex' = 'hex'): Promise<string> {
-	const buffer = new TextEncoder().encode(data);
-	const bytes = new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256', buffer));
-	return encoding === 'base64' ? base64(bytes) : convertToHex(bytes);
-}
-
-export function uuid(): string {
-	return globalThis.crypto.randomUUID();
-}

package/src/utils/env/browser/fs.ts

@@ -1,3 +0,0 @@
-export function realpath(path: string): Promise<string> {
-	return Promise.resolve(path);
-}

package/src/utils/env/browser/hex.ts

@@ -1,41 +0,0 @@
-const textDecoder = new TextDecoder();
-const textEncoder = new TextEncoder();
-const hexPairRegex = /(\w{2})/g;
-
-// prettier-ignore
-const precomputedByteToHex = [
-	'00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '0a', '0b', '0c', '0d', '0e', '0f', '10', '11', '12',
-	'13', '14', '15', '16', '17', '18', '19', '1a', '1b', '1c', '1d', '1e', '1f', '20', '21', '22', '23', '24', '25',
-	'26', '27', '28', '29', '2a', '2b', '2c', '2d', '2e', '2f', '30', '31', '32', '33', '34', '35', '36', '37', '38',
-	'39', '3a', '3b', '3c', '3d', '3e', '3f', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '4a', '4b',
-	'4c', '4d', '4e', '4f', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '5a', '5b', '5c', '5d', '5e',
-	'5f', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '6a', '6b', '6c', '6d', '6e', '6f', '70', '71',
-	'72', '73', '74', '75', '76', '77', '78', '79', '7a', '7b', '7c', '7d', '7e', '7f', '80', '81', '82', '83', '84',
-	'85', '86', '87', '88', '89', '8a', '8b', '8c', '8d', '8e', '8f', '90', '91', '92', '93', '94', '95', '96', '97',
-	'98', '99', '9a', '9b', '9c', '9d', '9e', '9f', 'a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'aa',
-	'ab', 'ac', 'ad', 'ae', 'af', 'b0', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'b9', 'ba', 'bb', 'bc', 'bd',
-	'be', 'bf', 'c0', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'ca', 'cb', 'cc', 'cd', 'ce', 'cf', 'd0',
-	'd1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'd9', 'da', 'db', 'dc', 'dd', 'de', 'df', 'e0', 'e1', 'e2', 'e3',
-	'e4', 'e5', 'e6', 'e7', 'e8', 'e9', 'ea', 'eb', 'ec', 'ed', 'ee', 'ef', 'f0', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6',
-	'f7', 'f8', 'f9', 'fa', 'fb', 'fc', 'fd', 'fe', 'ff',
-];
-
-export function convertToHex(bytes: Uint8Array): string {
-	const hex = new Array<string>(bytes.length);
-	for (let i = 0; i < bytes.length; ++i) {
-		hex[i] = precomputedByteToHex[bytes[i]];
-	}
-	return hex.join('');
-}
-
-export function encodeUtf8Hex(s: string): string {
-	return convertToHex(textEncoder.encode(s));
-}
-
-export function decodeUtf8Hex(hex: string): string {
-	const matches = hex.match(hexPairRegex);
-	if (matches === null) return '';
-
-	const bytes = new Uint8Array(matches.map(c => parseInt(c, 16)));
-	return textDecoder.decode(bytes);
-}

package/src/utils/env/browser/hrtime.ts

@@ -1,14 +0,0 @@
-export function hrtime(time?: [number, number]): [number, number] {
-	const now = performance.now() * 1e-3;
-	let seconds = Math.floor(now);
-	let nanoseconds = Math.floor((now % 1) * 1e9);
-	if (time !== undefined) {
-		seconds = seconds - time[0];
-		nanoseconds = nanoseconds - time[1];
-		if (nanoseconds < 0) {
-			seconds--;
-			nanoseconds += 1e9;
-		}
-	}
-	return [seconds, nanoseconds];
-}

package/src/utils/env/browser/logScope.ts

@@ -1,57 +0,0 @@
-import type { ScopedLogger } from '../../logger.scoped.js';
-
-// Browser fallback: counter-based scope tracking
-// Note: This may return incorrect scope after await if other scoped methods run concurrently.
-// The `using` pattern ensures LIFO disposal which works correctly, but concurrent async
-// operations may see stale or incorrect scope values after await.
-const scopes = new Map<number, ScopedLogger>();
-let currentScopeId: number | undefined;
-
-/**
- * Runs a function within a log scope context.
- * Note: In browser, scope tracking across async boundaries is best-effort only.
- */
-export function runInScope<T>(scope: ScopedLogger, fn: () => T): T {
-	const prevId = currentScopeId;
-	currentScopeId = scope.scopeId;
-	scopes.set(scope.scopeId!, scope);
-	try {
-		return fn();
-	} finally {
-		currentScopeId = prevId;
-		scopes.delete(scope.scopeId!);
-	}
-}
-
-/**
- * Gets the current log scope.
- * Note: In browser, this may be incorrect after await if other scoped methods run concurrently.
- * For reliable scope access, capture the scope immediately at method entry.
- */
-export function getCurrentScope(): ScopedLogger | undefined {
-	return currentScopeId != null ? scopes.get(currentScopeId) : undefined;
-}
-
-/**
- * Enters a log scope context (for use with `using` pattern).
- * Note: In browser, scope tracking across async boundaries is best-effort only.
- */
-export function enterScope(scope: ScopedLogger): void {
-	currentScopeId = scope.scopeId;
-	scopes.set(scope.scopeId!, scope);
-}
-
-/**
- * Exits a log scope context (for use with `using` pattern).
- * @param prevScope The scope to restore, or undefined to clear the current scope.
- * @param scopeToExit Optional scope that is being exited (for cleanup). If provided,
- *                    this scope's entry will be removed from the Map regardless of currentScopeId.
- */
-export function exitScope(prevScope: ScopedLogger | undefined, scopeToExit?: ScopedLogger): void {
-	// Clean up the scope being exited (if provided), otherwise clean up the current scope
-	const scopeIdToDelete = scopeToExit?.scopeId ?? currentScopeId;
-	if (scopeIdToDelete != null) {
-		scopes.delete(scopeIdToDelete);
-	}
-	currentScopeId = prevScope?.scopeId;
-}