@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/src/utils/event.ts

@@ -1,230 +0,0 @@
-import type { UnifiedDisposable } from './disposable.js';
-import { createDisposable } from './disposable.js';
-import { Logger } from './logger.js';
-import type { Deferred } from './promise.js';
-
-export interface Event<T> {
-	(listener: (e: T) => any, thisArgs?: unknown, disposables?: { dispose(): void }[]): UnifiedDisposable;
-}
-
-export class Emitter<T> {
-	private _listeners?: { callback: (e: T) => any; thisArgs?: unknown }[];
-	private _event?: Event<T>;
-	private _disposed: boolean = false;
-
-	/**
-	 * For the public to allow to subscribe
-	 * to events from this Emitter
-	 */
-	get event(): Event<T> {
-		this._event ??= (listener: (e: T) => any, thisArgs?: unknown, disposables?: { dispose(): void }[]) => {
-			if (this._disposed) {
-				return createDisposable(() => {});
-			}
-
-			this._listeners ??= [];
-
-			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);
-					}
-				}
-			});
-
-			if (disposables instanceof Array) {
-				disposables.push(result);
-			}
-
-			return result;
-		};
-		return this._event;
-	}
-
-	/**
-	 * To be kept private to fire an event to
-	 * subscribers
-	 */
-	fire(event: T): void {
-		if (this._listeners) {
-			// put all [listener,event] pairs into delivery queue
-			// then emit
-			// for now, just sync emit
-			for (const listener of this._listeners.slice()) {
-				try {
-					listener.callback.call(listener.thisArgs, event);
-				} catch (e) {
-					Logger.error(e);
-				}
-			}
-		}
-	}
-
-	dispose(): void {
-		if (!this._disposed) {
-			this._disposed = true;
-			this._listeners = undefined;
-		}
-	}
-
-	[Symbol.dispose](): void {
-		this.dispose();
-	}
-}
-
-/**
- * Minimal event type compatible with both VS Code's `Event<T>` and `@gitkraken/core-gitlens/utils` `Event<T>`.
- * Use this as the parameter type when a function should accept events from either source.
- */
-export type EventLike<T> = (listener: (e: T) => any, thisArgs?: any, ...args: any[]) => { dispose(): void };
-
-export function once<T>(event: EventLike<T>, disposables?: { dispose(): void }[]): EventLike<T> {
-	return take<T>(event, 1, disposables);
-}
-
-export function take<T>(event: EventLike<T>, count: number, disposables?: { dispose(): void }[]): EventLike<T> {
-	return (listener: (e: T) => unknown, thisArgs?: unknown) => {
-		let i = 0;
-		const result = event(e => {
-			const shouldDispose = ++i >= count;
-			if (shouldDispose) {
-				result.dispose();
-			}
-			return listener.call(thisArgs, e);
-		});
-
-		if (disposables instanceof Array) {
-			disposables.push(result);
-		}
-
-		return result;
-	};
-}
-
-export type DeferredEvent<T> = Omit<Deferred<T>, 'fulfill'>;
-
-export type DeferredEventExecutor<T, U> = (
-	value: T,
-	resolve: (value: U | PromiseLike<U>) => void,
-	reject: (reason: any) => void,
-) => any;
-
-const resolveExecutor = (value: any, resolve: (value?: any) => void) => resolve(value);
-
-/**
- * Return a promise that resolves with the next emitted event, or with some future
- * event as decided by an executor.
- *
- * If specified, the executor is a function that will be called with `(value, resolve, reject)`.
- * It will be called once per event until it resolves or rejects.
- *
- * The default executor just resolves with the value.
- *
- * @param event the event
- * @param executor controls resolution of the returned promise
- * @returns a cancellable deferred promise that resolves or rejects as specified by the executor
- */
-export function promisifyDeferred<T, U>(
-	event: EventLike<T>,
-	executor: DeferredEventExecutor<T, U> = resolveExecutor,
-): DeferredEvent<U> {
-	let cancel: ((reason?: any) => void) | undefined;
-	let disposable: { dispose(): void };
-
-	let pending = true;
-	const promise = new Promise<U>((resolve, reject) => {
-		cancel = () => {
-			pending = false;
-			cancel = undefined;
-			reject();
-		};
-
-		disposable = event(async (value: T) => {
-			try {
-				await executor(value, resolve, reject);
-				pending = false;
-			} catch (ex) {
-				pending = false;
-
-				// oxlint-disable-next-line typescript/prefer-promise-reject-errors
-				reject(ex);
-			}
-		});
-	}).then(
-		(value: U) => {
-			disposable.dispose();
-			return value;
-		},
-		(reason: unknown) => {
-			disposable.dispose();
-			throw reason;
-		},
-	);
-
-	return {
-		get pending() {
-			return pending;
-		},
-		promise: promise,
-		cancel: () => cancel?.(),
-	};
-}
-
-export function weakEvent<T, U extends object>(
-	event: EventLike<T>,
-	listener: (e: T) => any,
-	thisArg: U,
-	alsoDisposeOnReleaseOrDispose?: { dispose(): void }[],
-): { dispose(): void } {
-	const ref = new WeakRef<U>(thisArg);
-
-	let disposed = false;
-	let disposable: { dispose(): void };
-
-	const d = event((e: T) => {
-		const obj = ref.deref();
-		if (obj != null) {
-			listener.call(obj, e);
-		} else if (!disposed) {
-			Logger.warn(`weakEvent GC'd; disposing listener`);
-			disposable.dispose();
-		}
-	});
-
-	if (alsoDisposeOnReleaseOrDispose == null) {
-		disposable = {
-			dispose: () => {
-				disposed = true;
-				d.dispose();
-			},
-		};
-	} else {
-		const wrapped = disposableFrom(d, ...alsoDisposeOnReleaseOrDispose);
-		disposable = {
-			dispose: () => {
-				disposed = true;
-				wrapped.dispose();
-			},
-		};
-	}
-	return disposable;
-}
-
-function disposableFrom(...inDisposables: { dispose(): any }[]): { dispose(): void } {
-	let disposables: ReadonlyArray<{ dispose(): any }> | undefined = inDisposables;
-	return {
-		dispose: function () {
-			if (disposables) {
-				for (const disposable of disposables) {
-					if (disposable && typeof disposable.dispose === 'function') {
-						disposable.dispose();
-					}
-				}
-				disposables = undefined;
-			}
-		},
-	};
-}

package/src/utils/formatter.ts

@@ -1,198 +0,0 @@
-import type { TokenOptions } from './string.js';
-import { getTokensFromTemplate, getTruncatedWidth, getWidth, interpolate, interpolateAsync } from './string.js';
-
-export interface FormatOptions {
-	dateFormat?: string | null;
-	tokenOptions?: Record<string, TokenOptions | undefined>;
-}
-
-type Constructor<T = Record<string, unknown>> = new (...args: any[]) => T;
-
-const hasTokenRegexMap = new Map<string, RegExp>();
-const spaceRegex = / /g;
-
-export declare type RequiredTokenOptions<Options extends FormatOptions> = Options &
-	Required<Pick<Options, 'tokenOptions'>>;
-
-const defaultTokenOptions: Required<TokenOptions> = {
-	collapseWhitespace: false,
-	padDirection: 'left',
-	prefix: undefined,
-	suffix: undefined,
-	truncateTo: undefined,
-};
-
-export abstract class Formatter<Item = any, Options extends FormatOptions = FormatOptions> {
-	protected _item!: Item;
-	protected _options!: RequiredTokenOptions<Options>;
-
-	constructor(item: Item, options?: Options) {
-		this.reset(item, options);
-	}
-
-	reset(item: Item, options?: Options): void {
-		this._item = item;
-		this.collapsableWhitespace = 0;
-
-		if (options == null && this._options != null) return;
-
-		options ??= {} as unknown as Options;
-
-		options.dateFormat ??= 'MMMM Do, YYYY h:mma';
-
-		options.tokenOptions ??= {};
-
-		this._options = options as RequiredTokenOptions<Options>;
-	}
-
-	private collapsableWhitespace: number = 0;
-
-	protected _padOrTruncate(s: string, options: TokenOptions | undefined): string {
-		if (s == null || s.length === 0) return s;
-
-		// NOTE: the collapsable whitespace logic relies on the javascript template evaluation to be left to right
-		options ??= defaultTokenOptions;
-
-		// 0 is a special case to collapse to just the prefix and suffix
-		if (options.truncateTo === 0) {
-			return `${options.prefix ? options.prefix.trimEnd() : ''}${
-				options.suffix ? options.suffix.trimStart() : ''
-			}`;
-		}
-
-		if (options.prefix) {
-			s = `${options.prefix}${s}`;
-		}
-
-		const suffixWidth = options.suffix ? getWidth(options.suffix) : 0;
-
-		let max = options.truncateTo;
-		if (max == null) {
-			this.collapsableWhitespace = 0;
-			return options.suffix ? `${s}${options.suffix}` : s;
-		}
-
-		max += this.collapsableWhitespace;
-		this.collapsableWhitespace = 0;
-
-		const r = getTruncatedWidth(s, max, suffixWidth + 1);
-		if (r.truncated) return `${s.slice(0, r.index)}${r.ellipsed ? '\u2026' : ''}${options.suffix ?? ''}`;
-
-		let width = r.width;
-		if (options.suffix) {
-			s += options.suffix;
-			width += suffixWidth;
-		}
-
-		if (width === max) return s;
-
-		if (options.collapseWhitespace) {
-			this.collapsableWhitespace = max - width;
-		}
-
-		if (options.padDirection === 'left') {
-			return s.padStart(max, '\u00a0');
-		}
-
-		if (options.collapseWhitespace) return s;
-
-		return s.padEnd(max, '\u00a0');
-	}
-
-	private static _formatter: Formatter | undefined = undefined;
-
-	protected static fromTemplateCore<TFormatter extends Formatter<Item, Options>, Item, Options extends FormatOptions>(
-		formatter: TFormatter | Constructor<TFormatter>,
-		template: string,
-		item: Item,
-		dateFormatOrOptions?: string | null | Options,
-	): string {
-		// Preserve spaces
-		template = template.replace(spaceRegex, '\u00a0');
-		if (formatter instanceof Formatter) return interpolate(template, formatter);
-
-		let options: Options;
-		if (dateFormatOrOptions == null || typeof dateFormatOrOptions === 'string') {
-			options = {
-				dateFormat: dateFormatOrOptions,
-			} as unknown as Options;
-		} else {
-			options = dateFormatOrOptions;
-		}
-
-		if (options.tokenOptions == null) {
-			const tokenOptions = getTokensFromTemplate(template).reduce<Record<string, TokenOptions | undefined>>(
-				(map, token) => {
-					map[token.key] = token.options;
-					return map;
-				},
-				Object.create(null),
-			);
-
-			options.tokenOptions = tokenOptions;
-		}
-
-		if (this._formatter == null) {
-			this._formatter = new formatter(item, options);
-		} else {
-			this._formatter.reset(item, options);
-		}
-
-		return interpolate(template, this._formatter);
-	}
-
-	protected static fromTemplateCoreAsync<
-		TFormatter extends Formatter<Item, Options>,
-		Item,
-		Options extends FormatOptions,
-	>(
-		formatter: TFormatter | Constructor<TFormatter>,
-		template: string,
-		item: Item,
-		dateFormatOrOptions?: string | null | Options,
-	): Promise<string> {
-		// Preserve spaces
-		template = template.replace(spaceRegex, '\u00a0');
-		if (formatter instanceof Formatter) return interpolateAsync(template, formatter);
-
-		let options: Options;
-		if (dateFormatOrOptions == null || typeof dateFormatOrOptions === 'string') {
-			options = {
-				dateFormat: dateFormatOrOptions,
-			} as unknown as Options;
-		} else {
-			options = dateFormatOrOptions;
-		}
-
-		if (options.tokenOptions == null) {
-			const tokenOptions = getTokensFromTemplate(template).reduce<Record<string, TokenOptions | undefined>>(
-				(map, token) => {
-					map[token.key] = token.options;
-					return map;
-				},
-				Object.create(null),
-			);
-
-			options.tokenOptions = tokenOptions;
-		}
-
-		// Always allocate a fresh formatter: `interpolateAsync` awaits between tokens, so a
-		// concurrent call that reset a shared instance would poison in-flight token resolution.
-		return interpolateAsync(template, new formatter(item, options));
-	}
-
-	static has<TOptions extends FormatOptions>(
-		template: string,
-		...tokens: (keyof NonNullable<TOptions['tokenOptions']>)[]
-	): boolean {
-		const token = tokens.length === 1 ? (tokens[0] as string) : `(${tokens.join('|')})`;
-
-		let regex = hasTokenRegexMap.get(token);
-		if (regex == null) {
-			regex = new RegExp(`\\b${token}\\b`);
-			hasTokenRegexMap.set(token, regex);
-		}
-
-		return regex.test(template);
-	}
-}

package/src/utils/fs.ts

@@ -1 +0,0 @@
-export { realpath } from '#env/fs.js';

package/src/utils/function.ts

@@ -1,141 +0,0 @@
-const comma = ',';
-const equals = '=';
-const openBrace = '{';
-const openParen = '(';
-const closeParen = ')';
-
-const fnBodyRegex = /\(([\s\S]*)\)/;
-const fnBodyStripCommentsRegex = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/gm;
-const fnBodyStripParamDefaultValueRegex = /\s?=.*$/;
-
-// oxlint-disable-next-line typescript/no-unsafe-function-type
-export function getParameters(fn: Function): string[] {
-	if (typeof fn !== 'function') throw new Error('Not supported');
-
-	if (fn.length === 0) return [];
-
-	let fnBody: string = Function.prototype.toString.call(fn);
-	fnBody = fnBody.replace(fnBodyStripCommentsRegex, '') || fnBody;
-	fnBody = fnBody.slice(0, fnBody.indexOf(openBrace));
-
-	let open = fnBody.indexOf(openParen);
-	let close = fnBody.indexOf(closeParen);
-
-	open = open >= 0 ? open + 1 : 0;
-	close = close > 0 ? close : fnBody.indexOf(equals);
-
-	fnBody = fnBody.slice(open, close);
-	fnBody = `(${fnBody})`;
-
-	const match = fnBodyRegex.exec(fnBody);
-	return match != null
-		? match[1].split(comma).map(param => param.trim().replace(fnBodyStripParamDefaultValueRegex, ''))
-		: [];
-}
-
-export function is<T extends object>(o: T | null | undefined): o is T;
-export function is<T extends object>(o: object, prop: keyof T, value?: any): o is T;
-export function is<T extends object>(o: object, matcher: (o: object) => boolean): o is T;
-export function is<T extends object>(o: object, propOrMatcher?: keyof T | ((o: any) => boolean), value?: any): o is T {
-	if (propOrMatcher == null) return o != null;
-	if (typeof propOrMatcher === 'function') return propOrMatcher(o);
-
-	return value === undefined
-		? (o as Record<keyof T, unknown>)[propOrMatcher] !== undefined
-		: (o as Record<keyof T, unknown>)[propOrMatcher] === value;
-}
-
-export function once<T extends (...args: any[]) => unknown>(fn: T): T {
-	let result: ReturnType<T>;
-	let called = false;
-
-	return function (this: unknown, ...args: Parameters<T>): ReturnType<T> {
-		if (!called) {
-			called = true;
-			result = fn.apply(this, args) as ReturnType<T>;
-			fn = undefined!;
-		}
-
-		return result;
-	} as T;
-}
-
-type PartialArgs<T extends any[], P extends any[]> = {
-	[K in keyof P]: K extends keyof T ? T[K] : never;
-};
-
-type DropFirstN<T extends any[], N extends number, I extends any[] = []> = {
-	0: T;
-	1: T extends [infer _, ...infer R] ? DropFirstN<R, N, [any, ...I]> : T;
-}[I['length'] extends N ? 0 : 1];
-
-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> {
-	// oxlint-disable-next-line typescript/no-unsafe-return
-	return (...rest) => fn(...partialArgs, ...rest);
-}
-
-export async function runSequentially<T extends (...args: any[]) => unknown>(
-	fn: T,
-	arrayOfArgs: Parameters<T>[],
-	thisArg?: unknown,
-): Promise<any> {
-	for (const args of arrayOfArgs) {
-		try {
-			void (await fn.apply(thisArg, args));
-		} catch {}
-	}
-}
-
-export function sequentialize<T extends (...args: any[]) => Promise<any>>(fn: T): T {
-	let promise: Promise<unknown> | undefined;
-
-	return function (...args: any[]): Promise<any> {
-		// oxlint-disable-next-line typescript/no-unsafe-return
-		const run = async () => await fn(...args);
-		if (promise == null) {
-			promise = run();
-		} else {
-			promise = promise.then(run, run);
-		}
-
-		return promise;
-	} as T;
-}
-
-/**
- * Szudzik elegant pairing function
- * http://szudzik.com/ElegantPairing.pdf
- */
-export function szudzikPairing(x: number, y: number): number {
-	return x >= y ? x * x + x + y : x + y * y;
-}
-
-export function throttle<T extends (...args: any[]) => ReturnType<T>>(fn: T, delay: number) {
-	let waiting = false;
-	let waitingArgs: Parameters<T> | undefined;
-
-	return function (this: unknown, ...args: Parameters<T>): void {
-		if (waiting) {
-			waitingArgs = args;
-
-			return;
-		}
-
-		waiting = true;
-		fn.apply(this, args);
-
-		setTimeout(() => {
-			waiting = false;
-
-			if (waitingArgs != null) {
-				fn.apply(this, waitingArgs);
-			}
-		}, delay);
-	};
-}
-
-//** Used to cause compile errors for exhaustive type checking */
-export function typeCheck<T>(_value: T): asserts _value is T {}