@gitkraken/core-gitlens 0.4.0 → 0.4.100

package/src/utils/date.ts

@@ -11,6 +11,15 @@ const relativeUnitThresholds: [Intl.RelativeTimeFormatUnit, number, number, stri
 	['minute', 60 * 1000, 60 * 1000, 'm'],
 	['second', 1000, 1000, 's'],
 ];
+// Built ONCE from the table above (not per-call `.find()` scans, and not a Map — plain object property
+// reads are monomorphic/faster than Map.get for this) — backs unitDivisorMs/unitThresholdMs below. Never
+// touched on fromNow's own hot path (see the loop in fromNow itself).
+const unitDivisors: Partial<Record<Intl.RelativeTimeFormatUnit, number>> = {};
+const unitThresholds: Partial<Record<Intl.RelativeTimeFormatUnit, number>> = {};
+for (const [unit, threshold, divisor] of relativeUnitThresholds) {
+	unitDivisors[unit] = divisor;
+	unitThresholds[unit] = threshold;
+}
 
 type DateStyle = 'full' | 'long' | 'medium' | 'short';
 type TimeStyle = 'full' | 'long' | 'medium' | 'short';
@@ -78,6 +87,69 @@ export function createFromDateDelta(
 	return d;
 }
 
+/** The unit + truncated magnitude `fromNow` would pick for `date` relative to `now` — same threshold
+ *  table + truncation `fromNow` formats with, factored out so a caller that needs to CLASSIFY a date
+ *  (not just format it) can't drift from what the column actually displays. Allocation-free (no `Date`
+ *  construction — both `date` and `now` are read as epoch ms when passed as numbers). `now` defaults to
+ *  `Date.now()`; a caller classifying many rows against the SAME instant should pass it explicitly. */
+export function fromNowUnit(
+	date: Date | number,
+	now: Date | number = Date.now(),
+): { unit: Intl.RelativeTimeFormatUnit; value: number } | undefined {
+	const elapsed =
+		(typeof date === 'number' ? date : date.getTime()) - (typeof now === 'number' ? now : now.getTime());
+	// Guard against invalid dates (e.g. `new Date(<unparseable>)`) — mirrors fromNow's own guard.
+	if (!Number.isFinite(elapsed)) return undefined;
+
+	const elapsedABS = Math.abs(elapsed);
+	for (const [unit, threshold, divisor] of relativeUnitThresholds) {
+		if (elapsedABS >= threshold || threshold === 1000 /* second */) {
+			return { unit: unit, value: Math.trunc(elapsed / divisor) };
+		}
+	}
+	return undefined;
+}
+
+/** Allocation-free sibling of `fromNowUnit` for a caller that only needs to CLASSIFY (compare two dates'
+ *  groups) rather than build the `{unit,value}` object — same loop over the same table, so it can't
+ *  drift from `fromNowUnit`/`fromNow`. Encodes the result as `unitOrdinal*100000 + truncValue` (ordinal
+ *  0 = 'year' … 6 = 'second', matching `relativeUnitThresholds`' order; `truncValue` keeps its sign, so
+ *  a positive result means `date` is in the FUTURE relative to `now`). */
+export function fromNowUnitKey(date: Date | number, now: Date | number = Date.now()): number | undefined {
+	const elapsed =
+		(typeof date === 'number' ? date : date.getTime()) - (typeof now === 'number' ? now : now.getTime());
+	if (!Number.isFinite(elapsed)) return undefined;
+
+	const elapsedABS = Math.abs(elapsed);
+	let ordinal = 0;
+	for (const [, threshold, divisor] of relativeUnitThresholds) {
+		if (elapsedABS >= threshold || threshold === 1000 /* second */) {
+			return ordinal * 100_000 + Math.trunc(elapsed / divisor);
+		}
+
+		ordinal++;
+	}
+	return undefined;
+}
+
+/** The divisor (ms) `fromNowUnit` divides elapsed time by for `unit` — i.e. the elapsed-ms width one
+ *  step of `value` represents. Exported so a caller reconstructing a `fromNowUnit` result's elapsed
+ *  WINDOW (its start/end bounds) doesn't have to re-derive the thresholds table itself. */
+export function unitDivisorMs(unit: Intl.RelativeTimeFormatUnit): number {
+	return unitDivisors[unit] ?? 0;
+}
+
+/** The elapsed-ms THRESHOLD `fromNowUnit` requires to classify into `unit` at all (only differs from
+ *  `unitDivisorMs` for 'year' — see the table above). Exported so a caller clamping a group's elapsed
+ *  window to where the NEXT unit actually takes over (not just `n+1` steps of the same divisor) can read
+ *  the real cutover point instead of re-deriving the thresholds table itself. */
+export function unitThresholdMs(unit: Intl.RelativeTimeFormatUnit): number {
+	return unitThresholds[unit] ?? 0;
+}
+
+// fromNow keeps its OWN single-pass loop (not routed through fromNowUnit) — one iteration, no
+// intermediate {unit,value} object allocation on this hot formatting path; fromNowUnit below iterates
+// the SAME `relativeUnitThresholds` array, so the two classifications can't drift apart.
 export function fromNow(date: Date | number, short?: boolean): string {
 	const elapsed = (typeof date === 'number' ? date : date.getTime()) - Date.now();
 	// Guard against invalid dates (e.g. `new Date(<unparseable>)`), since a non-finite value would throw in `Intl.RelativeTimeFormat.format`

package/src/utils/debounce.ts

@@ -276,7 +276,7 @@ export function debounce<F extends (...args: any[]) => ReturnType<F>>(
 		if (aggregator != null && lastArgs != null) {
 			lastArgs = aggregator(lastArgs, args);
 		} else {
-			// oxlint-disable-next-line @typescript-eslint/no-this-alias
+			// oxlint-disable-next-line typescript/no-this-alias
 			lastThis = this;
 			lastArgs = args;
 		}

package/src/utils/decorators/gate.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* oxlint-disable typescript/no-unsafe-return */
 import { CancellationError } from '../cancellation.js';
 import type { UnifiedDisposable } from '../disposable.js';
 import { createDisposable } from '../disposable.js';
@@ -28,7 +28,7 @@ export function gate<T extends (...args: any[]) => any>(
 	timeout ??= 300000;
 
 	return (_target: any, key: string, descriptor: PropertyDescriptor): void => {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+		// oxlint-disable-next-line typescript/no-unsafe-function-type
 		let fn: Function | undefined;
 		if (typeof descriptor.value === 'function') {
 			fn = descriptor.value;

package/src/utils/decorators/log.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* oxlint-disable typescript/no-unsafe-return */
 import { getParameters } from '../function.js';
 import { getDurationMilliseconds, hrtime } from '../hrtime.js';
 import type { LogLevel } from '../logger.js';
@@ -38,9 +38,9 @@ interface LogOptions<T extends (...args: any[]) => any> {
 }
 
 // Using Function type to support classes with private/protected constructors
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+// oxlint-disable-next-line typescript/no-unsafe-function-type
 export function logName<T>(fn: (c: T, name: string) => string): (target: Function & { prototype: T }) => void {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+	// oxlint-disable-next-line typescript/no-unsafe-function-type
 	return (target: (abstract new (...args: any[]) => T) | (Function & { prototype: T })): void =>
 		void customLoggableNameFns.set(target, fn);
 }
@@ -54,7 +54,7 @@ export function logName<T>(fn: (c: T, name: string) => string): (target: Functio
  * Defaults to `id` if the instance has one, otherwise just `ClassName`.
  */
 export function loggable<T extends object>(fn?: (instance: T) => string) {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+	// oxlint-disable-next-line typescript/no-unsafe-function-type
 	return (target: (abstract new (...args: any[]) => T) | (Function & { prototype: T })): void => {
 		target.prototype.toLoggable = function (this: T): string {
 			const name = getLoggableName(this);
@@ -105,7 +105,7 @@ function log<T extends (...arg: any[]) => any>(
 		logLevel === 'trace' ? Logger.trace : logLevel === 'debug' ? Logger.debug : Logger.info;
 
 	return (_target: any, key: string, descriptor: PropertyDescriptor & Record<string, any>) => {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+		// oxlint-disable-next-line typescript/no-unsafe-function-type
 		let fn: Function | undefined;
 		let fnKey: string | undefined;
 		if (typeof descriptor.value === 'function') {

package/src/utils/decorators/memoize.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* oxlint-disable typescript/no-unsafe-return */
 import { resolveProp } from './resolver.js';
 
 /** Keys for memoize version invalidation */
@@ -43,7 +43,7 @@ export function memoize<T extends (...args: any[]) => any>(
 	const opts = options ?? {};
 
 	return (_target: any, key: string, descriptor: PropertyDescriptor & Record<string, any>): void => {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+		// oxlint-disable-next-line typescript/no-unsafe-function-type
 		let fn: Function | undefined;
 		let fnKey: string | undefined;
 

package/src/utils/decorators/sequentialize.ts

@@ -43,7 +43,7 @@ export function sequentialize<T extends (...args: any[]) => any>(
 	const getDedupingKey = options?.getDedupingKey;
 
 	return (_target: any, key: string, descriptor: PropertyDescriptor) => {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+		// oxlint-disable-next-line typescript/no-unsafe-function-type
 		let fn: Function | undefined;
 		if (typeof descriptor.value === 'function') {
 			fn = descriptor.value;
@@ -69,7 +69,7 @@ export function sequentialize<T extends (...args: any[]) => any>(
 			}
 
 			const state: SequentializeState | undefined = this[prop];
-			// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+			// oxlint-disable-next-line typescript/no-unsafe-return
 			const run = async () => await fn.apply(this, args);
 
 			// Compute the dedupe key once

package/src/utils/decorators/serializable.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+/* oxlint-disable typescript/no-unsafe-function-type */
 
 /**
  * Class decorator that adds a `toJSON()` method materializing all prototype getters into the

package/src/utils/env/node/exec.ts

@@ -277,9 +277,9 @@ export function run<T extends number | string>(
 					let stderrDecoded: string;
 					if (encoding === 'utf8' || encoding === 'binary' || encoding === 'buffer') {
 						// stdout & stderr can be `Buffer` or `string
-						// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
+						// oxlint-disable-next-line typescript/no-unnecessary-type-conversion
 						stdoutDecoded = stdout.toString();
-						// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
+						// oxlint-disable-next-line typescript/no-unnecessary-type-conversion
 						stderrDecoded = stderr.toString();
 					} else {
 						if (decode == null) {
@@ -332,7 +332,15 @@ export function run<T extends number | string>(
 }
 
 export interface RunExitResult {
-	exitCode: number;
+	/**
+	 * The process's exit code. ABSENT when the process never exited normally — killed by a signal, in which
+	 * case {@link signal} is set. Deliberately optional rather than defaulted to `0`: a signalled process
+	 * reported as `exitCode: 0` is indistinguishable from a clean success, so callers would read a partial
+	 * or empty stdout as a complete answer.
+	 */
+	readonly exitCode?: number;
+	/** Set when the process was terminated by a signal instead of exiting; {@link exitCode} is then absent. */
+	readonly signal?: NodeJS.Signals;
 }
 
 export interface RunResult<T extends string | Buffer> extends RunExitResult {
@@ -412,7 +420,11 @@ export function runSpawn<T extends string | Buffer>(
 
 		proc.once('close', async (code, signal) => {
 			if (options?.exitCodeOnly) {
-				resolve({ exitCode: code ?? 0 });
+				// Resolves unconditionally, so this is the one path that can hand back a signalled run. `code`
+				// is null exactly when the process was killed — report the signal rather than coercing to `0`,
+				// which would claim a clean success for a command that never finished. Note this returns BEFORE
+				// the SIGTERM-to-cancellation diversion below, so callers have to classify that themselves.
+				resolve({ exitCode: code ?? undefined, signal: signal ?? undefined });
 
 				return;
 			}
@@ -453,7 +465,10 @@ export function runSpawn<T extends string | Buffer>(
 				);
 			}
 
-			resolve({ exitCode: code ?? 0, stdout: stdout, stderr: stderr });
+			// The guard above already rejected every non-zero and every signalled close, so this is a clean
+			// zero exit — `code` cannot be null here. (The optional typing exists for the `exitCodeOnly`
+			// branch, which is where a codeless result can genuinely surface.)
+			resolve({ exitCode: code ?? undefined, signal: signal ?? undefined, stdout: stdout, stderr: stderr });
 		});
 
 		if (stdin) {

package/src/utils/event.ts

@@ -17,36 +17,30 @@ export class Emitter<T> {
 	 * to events from this Emitter
 	 */
 	get event(): Event<T> {
-		if (!this._event) {
-			this._event = (listener: (e: T) => any, thisArgs?: unknown, disposables?: { dispose(): void }[]) => {
-				if (this._disposed) {
-					return createDisposable(() => {});
-				}
+		this._event ??= (listener: (e: T) => any, thisArgs?: unknown, disposables?: { dispose(): void }[]) => {
+			if (this._disposed) {
+				return createDisposable(() => {});
+			}
 
-				if (!this._listeners) {
-					this._listeners = [];
-				}
+			this._listeners ??= [];
 
-				this._listeners.push({ callback: listener, thisArgs: thisArgs });
+			this._listeners.push({ callback: listener, thisArgs: thisArgs });
 
-				const result = createDisposable(() => {
-					if (!this._disposed && this._listeners) {
-						const index = this._listeners.findIndex(
-							l => l.callback === listener && l.thisArgs === thisArgs,
-						);
-						if (index > -1) {
-							this._listeners.splice(index, 1);
-						}
+			const result = createDisposable(() => {
+				if (!this._disposed && this._listeners) {
+					const index = this._listeners.findIndex(l => l.callback === listener && l.thisArgs === thisArgs);
+					if (index > -1) {
+						this._listeners.splice(index, 1);
 					}
-				});
-
-				if (disposables instanceof Array) {
-					disposables.push(result);
 				}
+			});
 
-				return result;
-			};
-		}
+			if (disposables instanceof Array) {
+				disposables.push(result);
+			}
+
+			return result;
+		};
 		return this._event;
 	}
 
@@ -155,7 +149,7 @@ export function promisifyDeferred<T, U>(
 			} catch (ex) {
 				pending = false;
 
-				// eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+				// oxlint-disable-next-line typescript/prefer-promise-reject-errors
 				reject(ex);
 			}
 		});

package/src/utils/function.ts

@@ -8,7 +8,7 @@ const fnBodyRegex = /\(([\s\S]*)\)/;
 const fnBodyStripCommentsRegex = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/gm;
 const fnBodyStripParamDefaultValueRegex = /\s?=.*$/;
 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+// oxlint-disable-next-line typescript/no-unsafe-function-type
 export function getParameters(fn: Function): string[] {
 	if (typeof fn !== 'function') throw new Error('Not supported');
 
@@ -73,7 +73,7 @@ export function partial<T extends (...args: any[]) => any, P extends any[]>(
 	fn: T,
 	...partialArgs: PartialArgs<Parameters<T>, P>
 ): (...rest: DropFirstN<Parameters<T>, P['length']>) => ReturnType<T> {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+	// oxlint-disable-next-line typescript/no-unsafe-return
 	return (...rest) => fn(...partialArgs, ...rest);
 }
 
@@ -93,7 +93,7 @@ export function sequentialize<T extends (...args: any[]) => Promise<any>>(fn: T)
 	let promise: Promise<unknown> | undefined;
 
 	return function (...args: any[]): Promise<any> {
-		// eslint-disable-next-line @typescript-eslint/no-unsafe-return
+		// oxlint-disable-next-line typescript/no-unsafe-return
 		const run = async () => await fn(...args);
 		if (promise == null) {
 			promise = run();

package/src/utils/iterable.ts

@@ -113,9 +113,7 @@ class ConcatIterator<T> implements IterableIterator<T> {
 
 		while (this.sourceIndex < this.sources.length) {
 			// Initialize iterator for current source if needed
-			if (this.currentIterator === undefined) {
-				this.currentIterator = this.sources[this.sourceIndex][Symbol.iterator]();
-			}
+			this.currentIterator ??= this.sources[this.sourceIndex][Symbol.iterator]();
 
 			const result = this.currentIterator.next();
 			if (!result.done) {
@@ -708,9 +706,7 @@ class UnionIterator<T> implements IterableIterator<T> {
 			}
 
 			// Initialize iterator for current source if needed
-			if (this.currentIterator === undefined) {
-				this.currentIterator = source[Symbol.iterator]();
-			}
+			this.currentIterator ??= source[Symbol.iterator]();
 
 			const result = this.currentIterator.next();
 			if (!result.done) {

package/src/utils/logger.scoped.ts

@@ -35,7 +35,7 @@ export function createLogScope(scopeId: number, prevScopeId: number | undefined,
 	let exitDetails: string[] | undefined;
 	let exitFailed: string | undefined;
 
-	// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+	// oxlint-disable-next-line typescript/consistent-type-assertions
 	const scope: ScopedLogger = {
 		scopeId: scopeId,
 		prevScopeId: prevScopeId,

package/src/utils/logger.ts

@@ -217,7 +217,7 @@ class Logger {
 
 		const errorMessage = `  ${message ?? ''}${this.#toLoggableParams(false, params)}`;
 		if (ex != null) {
-			// eslint-disable-next-line @typescript-eslint/no-base-to-string
+			// oxlint-disable-next-line typescript/no-base-to-string
 			this.#output?.error(String(ex), errorMessage);
 		} else {
 			this.#output?.error(errorMessage);

package/src/utils/paging.ts

@@ -4,6 +4,26 @@ export interface PagedResult<T> {
 	readonly paging?: {
 		readonly cursor: string;
 		readonly more: boolean;
+		/**
+		 * True when the results may be incomplete in a way that following `cursor` won't resolve. Two sources:
+		 * a read that fetched a single default page and can't report `hasNextPage` (no cursor to follow at all),
+		 * or a multi-scope read where a sibling scope failed (`partial`/`unknown` completeness) even though the
+		 * current scope still exposes a real next page. `truncated` is therefore independent of `more`: `more`
+		 * means "there is a next page you can fetch with `cursor`"; `truncated` means "content may be missing
+		 * that paging alone won't recover." Consumers should surface this as a truncation signal rather than
+		 * treating the result as complete, and should not assume `truncated` implies `more` is false.
+		 */
+		readonly truncated?: boolean;
+		/** 1-based page that produced this result. Populated by numbered-page providers only. */
+		readonly page?: number;
+		/** Items requested per page, when known. */
+		readonly pageSize?: number;
+		/** Next page number, when the provider pages by number. */
+		readonly nextPage?: number;
+		/** Total number of pages, when the provider reports totals. */
+		readonly totalPages?: number;
+		/** Total number of items across all pages, when the provider reports totals. */
+		readonly totalCount?: number;
 	};
 	readonly values: NonNullable<T>[];
 }
@@ -13,6 +33,10 @@ export const emptyPagedResult: PagedResult<any> = Object.freeze({ values: [] });
 
 export interface PagingOptions {
 	cursor?: string;
+	/** 1-based page to request from numbered-page providers. */
+	page?: number;
+	/** Items to request per page (numbered-page providers, and GitHub's cursor pages). */
+	pageSize?: number;
 }
 
 export class PageableResult<T> {
@@ -49,3 +73,25 @@ export class PageableResult<T> {
 		}
 	}
 }
+
+/**
+ * Drains a paged fetcher into a single array, following `paging.cursor` until exhausted. Bounded by
+ * `maxPages` (default 20) as a backstop against a provider that never stops paging.
+ */
+export async function collectPagedResults<T>(
+	fetch: (cursor: string | undefined) => Promise<PagedResult<T> | undefined>,
+	maxPages = 20,
+): Promise<NonNullable<T>[]> {
+	const all: NonNullable<T>[] = [];
+	let cursor: string | undefined;
+	for (let page = 0; page < maxPages; page++) {
+		const result = await fetch(cursor);
+		if (result == null) break;
+
+		all.push(...result.values);
+		if (!result.paging?.more || result.paging.cursor === cursor) break;
+
+		cursor = result.paging.cursor;
+	}
+	return all;
+}

package/src/utils/promise.ts

@@ -91,6 +91,36 @@ export async function batchResults<T, R>(
 	return results;
 }
 
+/**
+ * `Promise.all(items.map(task))` with at most `concurrency` tasks in flight. Unlike {@link batchResults} this is
+ * a sliding window rather than a barrier per batch, so a slow item doesn't idle the rest of the window. Results
+ * are returned in input order and the first rejection propagates, matching `Promise.all`.
+ *
+ * Use it for a fan-out whose width is data-driven (one task per org/project/provider): unbounded `Promise.all`
+ * over such a list opens as many concurrent upstream requests as there are items, which invites provider rate
+ * limiting and socket exhaustion.
+ */
+export async function mapBounded<T, R>(
+	items: readonly T[],
+	concurrency: number,
+	task: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+	const limit = Math.max(1, Math.trunc(concurrency));
+	if (items.length <= limit) return Promise.all(items.map((item, index) => task(item, index)));
+
+	const results = new Array<R>(items.length);
+	let next = 0;
+
+	async function worker(): Promise<void> {
+		for (let index = next++; index < items.length; index = next++) {
+			results[index] = await task(items[index], index);
+		}
+	}
+
+	await Promise.all(Array.from({ length: limit }, () => worker()));
+	return results;
+}
+
 export class PromiseCancelledError<T extends Promise<any> = Promise<any>> extends Error {
 	constructor(
 		public readonly promise: T,
@@ -177,7 +207,7 @@ export function cancellable<T>(
 				disposeCancellation?.dispose();
 				disposeTimeout?.dispose();
 
-				// eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+				// oxlint-disable-next-line typescript/prefer-promise-reject-errors
 				reject(ex);
 			},
 		);
@@ -222,7 +252,7 @@ export function getDeferredPromiseIfPending<T>(deferred: Deferred<T> | undefined
 export type MaybePromiseArr<T> = (Promise<T | undefined> | T | undefined)[];
 
 export async function nonnullSettled<T>(arr: MaybePromiseArr<T>): Promise<T[]> {
-	// eslint-disable-next-line @typescript-eslint/await-thenable
+	// oxlint-disable-next-line typescript/await-thenable
 	const all = await Promise.allSettled(arr);
 	return all.map(r => getSettledValue(r)).filter(v => v != null);
 }
@@ -485,7 +515,7 @@ export async function pauseOnCancelOrTimeoutMapTuple<Id, T, U extends unknown[]>
 	}
 
 	const results = await Promise.all(
-		// eslint-disable-next-line @typescript-eslint/await-thenable
+		// oxlint-disable-next-line typescript/await-thenable
 		map(source, ([id, [promise, ...rest]]) =>
 			promise == null
 				? ([id, [undefined, ...rest]] as const)