@gitkraken/core-gitlens 0.1.0

package/src/utils/event.ts

@@ -0,0 +1,236 @@
+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> {
+		if (!this._event) {
+			this._event = (listener: (e: T) => any, thisArgs?: unknown, disposables?: { dispose(): void }[]) => {
+				if (this._disposed) {
+					return createDisposable(() => {});
+				}
+
+				if (!this._listeners) {
+					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;
+
+				// eslint-disable-next-line @typescript-eslint/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

@@ -0,0 +1,205 @@
+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;
+		}
+
+		if (this._formatter == null) {
+			this._formatter = new formatter(item, options);
+		} else {
+			this._formatter.reset(item, options);
+		}
+
+		return interpolateAsync(template, this._formatter);
+	}
+
+	static has<TOptions extends FormatOptions>(
+		template: string,
+		...tokens: (keyof NonNullable<TOptions['tokenOptions']>)[]
+	): boolean {
+		const token =
+			tokens.length === 1
+				? (tokens[0] as string)
+				: (`(${tokens.join('|')})` as keyof NonNullable<TOptions['tokenOptions']> as string);
+
+		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

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

package/src/utils/function.ts

@@ -0,0 +1,141 @@
+const comma = ',';
+const equals = '=';
+const openBrace = '{';
+const openParen = '(';
+const closeParen = ')';
+
+const fnBodyRegex = /\(([\s\S]*)\)/;
+const fnBodyStripCommentsRegex = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/gm;
+const fnBodyStripParamDefaultValueRegex = /\s?=.*$/;
+
+// eslint-disable-next-line @typescript-eslint/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> {
+	// eslint-disable-next-line @typescript-eslint/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> {
+		// eslint-disable-next-line @typescript-eslint/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 {}