@gitkraken/core-gitlens 0.1.0

package/src/utils/markdown.ts

@@ -0,0 +1,114 @@
+const escapeMarkdownRegex = /[\\*_{}[\]()#+\-.!<>]/g;
+const unescapeMarkdownRegex = /\\([\\`*_{}[\]()#+\-.!<>])/g;
+// Regex to find markdown links: [text](url) allowing for escaped brackets/parens within text/url
+const markdownLinkRegex = /(\[((?:\\.|[^[\]\\])+)\]\(((?:\\.|[^()\\])+)\))/g;
+
+const escapeMarkdownHeaderRegex = /^===/gm;
+const unescapeMarkdownHeaderRegex = /^\u200b===/gm;
+
+// const sampleMarkdown = '## message `not code` *not important* _no underline_ \n> don\'t quote me \n- don\'t list me \n+ don\'t list me \n1. don\'t list me \nnot h1 \n=== \nnot h2 \n---\n***\n---\n___';
+const markdownQuotedRegex = /\r?\n/g;
+const markdownBacktickRegex = /`/g;
+
+export function escapeMarkdown(
+	s: string,
+	options?: { quoted?: boolean; inlineBackticks?: boolean; preserveLinks?: boolean },
+): string {
+	// If preserving links, replace them with placeholders first
+	if (options?.preserveLinks) {
+		const links = new Map<string, string>();
+		let linkIndex = 0;
+
+		s = s.replace(markdownLinkRegex, match => {
+			// Create a unique, unlikely-to-occur placeholder
+			const placeholder = `$$$GLLINK${linkIndex++}GLLINK$$$`;
+			links.set(placeholder, match);
+			return placeholder;
+		});
+
+		// Escape markdown characters
+		s = s.replace(escapeMarkdownRegex, '\\$&');
+
+		// Restore the original links if they were preserved
+		if (options?.preserveLinks && links.size) {
+			for (const [placeholder, originalLink] of links) {
+				s = s.replace(placeholder, originalLink);
+			}
+		}
+	} else {
+		// Escape markdown characters
+		s = s.replace(escapeMarkdownRegex, '\\$&');
+	}
+
+	// Escape markdown header (since the above regex won't match it)
+	s = s.replace(escapeMarkdownHeaderRegex, '\u200b===');
+
+	if (options?.inlineBackticks) {
+		s = escapeMarkdownCodeBlocks(s);
+	} else {
+		s = s.replace(markdownBacktickRegex, '\\$&');
+	}
+
+	if (!options?.quoted) return s;
+
+	// Keep under the same block-quote but with line breaks
+	return s.trim().replace(markdownQuotedRegex, '\t\\\n>  ');
+}
+
+/** escapes markdown code blocks */
+export function escapeMarkdownCodeBlocks(s: string): string {
+	const tripleBackticks = '```';
+	const escapedTripleBackticks = '\\`\\`\\`';
+
+	let result = '';
+	let allowed = true;
+	let quotesOpened = false;
+	let buffer = '';
+
+	for (let i = 0; i < s.length; i += 1) {
+		const char = s[i];
+		const chain = s.substring(i, i + 3);
+		if (char === '\n' && quotesOpened) {
+			allowed = false;
+		}
+		if (chain === tripleBackticks) {
+			if (quotesOpened) {
+				quotesOpened = false;
+				if (allowed) {
+					result += `${tripleBackticks}${buffer}${tripleBackticks}`;
+				} else {
+					result += `${escapedTripleBackticks}${buffer}${escapedTripleBackticks}`;
+					allowed = true;
+				}
+				buffer = '';
+			} else {
+				quotesOpened = true;
+			}
+			// skip chain
+			i += 2;
+			continue;
+		}
+		if (quotesOpened) {
+			buffer += char;
+		} else {
+			result += char;
+		}
+	}
+
+	if (quotesOpened) {
+		// Handle unclosed code block
+		result += allowed ? tripleBackticks + buffer : escapedTripleBackticks + buffer;
+	}
+
+	return result;
+}
+
+export function unescapeMarkdown(s: string): string {
+	return (
+		s
+			// Unescape markdown
+			.replace(unescapeMarkdownRegex, '$1')
+			// Unescape markdown header
+			.replace(unescapeMarkdownHeaderRegex, '===')
+	);
+}

package/src/utils/mru.ts

@@ -0,0 +1,66 @@
+export class MRU<T> {
+	private stack: T[] = [];
+
+	constructor(
+		public readonly maxSize: number = 10,
+		private readonly comparator?: (a: T, b: T) => boolean,
+	) {}
+
+	get count(): number {
+		return this.stack.length;
+	}
+
+	private _position: number = 0;
+	get position(): number {
+		return this._position;
+	}
+
+	add(item: T): void {
+		if (this._position > 0) {
+			this.stack.splice(0, this._position);
+			this._position = 0;
+		}
+
+		const index =
+			this.comparator != null ? this.stack.findIndex(i => this.comparator!(item, i)) : this.stack.indexOf(item);
+		if (index !== -1) {
+			this.stack.splice(index, 1);
+		} else if (this.stack.length === this.maxSize) {
+			this.stack.pop();
+		}
+
+		this.stack.unshift(item);
+		this._position = 0;
+	}
+
+	get(position?: number): T | undefined {
+		if (position != null) {
+			if (position < 0 || position >= this.stack.length) return undefined;
+			return this.stack[position];
+		}
+		return this.stack.length > 0 ? this.stack[0] : undefined;
+	}
+
+	insert(item: T): void {
+		if (this._position > 0) {
+			this.stack.splice(0, this._position);
+			this._position = 0;
+		}
+		this.stack.unshift(item);
+		this._position++;
+	}
+
+	navigate(direction: 'back' | 'forward'): T | undefined {
+		if (this.stack.length <= 1) return undefined;
+
+		if (direction === 'back') {
+			if (this._position >= this.stack.length - 1) return undefined;
+			this._position += 1;
+		} else {
+			if (this._position <= 0) return undefined;
+			this._position -= 1;
+		}
+
+		return this.stack[this._position];
+	}
+}

package/src/utils/object.ts

@@ -0,0 +1,227 @@
+export function areEqual(a: any, b: any): boolean {
+	if (a === b) return true;
+	if (a == null || b == null) return false;
+
+	const aType = typeof a;
+	if (aType === typeof b && (aType === 'string' || aType === 'number' || aType === 'boolean')) return false;
+
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+
+type Primitive = string | number | boolean;
+type FlattenedValue = string | number | boolean;
+type AddPrefix<P extends string | undefined, K extends string> = P extends '' | undefined ? K : `${P}.${K}`;
+type AddArrayIndex<P extends string | undefined, I extends number> = P extends '' | undefined ? `[${I}]` : `${P}[${I}]`;
+
+type Merge<U> = MergeUnion<U extends object ? { [K in keyof U]: U[K] } : never>;
+type MergeUnion<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void
+	? { [K in keyof I]: I[K] }
+	: never;
+
+type FlattenArray<T extends object, P extends string | undefined> = T extends (infer U)[]
+	? U extends object
+		? { [Key in `${AddArrayIndex<P, number>}.${string}`]: FlattenedValue }
+		: { [Key in AddArrayIndex<P, number>]: FlattenedValue }
+	: T extends object
+		? { [Key in `${AddArrayIndex<P, number>}.${string}`]: FlattenedValue }
+		: { [Key in AddArrayIndex<P, number>]: FlattenedValue };
+
+type FlattenSpread<T extends object, P extends string | undefined> =
+	T extends ReadonlyArray<any>
+		? FlattenArray<T, P>
+		: {
+				[K in keyof T & string]: NonNullable<T[K]> extends Primitive
+					? { [Key in AddPrefix<P, K>]: NonNullable<T[K]> }
+					: T[K] extends ReadonlyArray<any>
+						? FlattenArray<T[K], AddPrefix<P, K>>
+						: T[K] extends object
+							? FlattenSpread<T[K], AddPrefix<P, K>>
+							: { [Key in AddPrefix<P, K>]: string };
+			}[keyof T & string];
+
+type FlattenJoin<T extends object, P extends string | undefined> = {
+	[K in keyof T & string]: NonNullable<T[K]> extends Primitive
+		? { [Key in AddPrefix<P, K>]: NonNullable<T[K]> }
+		: T[K] extends ReadonlyArray<any>
+			? { [Key in AddPrefix<P, K>]: string }
+			: T[K] extends object
+				? FlattenJoin<T[K], AddPrefix<P, K>>
+				: { [Key in AddPrefix<P, K>]: string };
+}[keyof T & string];
+
+export type Flatten<
+	T extends object | null | undefined,
+	P extends string | undefined,
+	JoinArrays extends boolean,
+> = T extends object ? Merge<JoinArrays extends true ? FlattenJoin<T, P> : FlattenSpread<T, P>> : object;
+
+type FlattenOptions = {
+	joinArrays?: boolean;
+	skipPaths?: string[];
+};
+
+export function flatten<T extends object | null | undefined, P extends string | undefined, O extends FlattenOptions>(
+	o: T,
+	prefix?: P,
+	options?: O,
+): Flatten<T, P, NonNullable<O['joinArrays']> extends true ? true : false> {
+	const joinArrays = options?.joinArrays ?? false;
+
+	const skipPaths = options?.skipPaths?.length
+		? prefix
+			? options.skipPaths.map(p => `${prefix}.${p}`)
+			: options.skipPaths
+		: undefined;
+
+	function flattenCore(flattened: Record<string, any>, key: string, value: any) {
+		if (skipPaths?.includes(key)) return;
+
+		if (Object(value) !== value) {
+			if (value == null) return;
+
+			flattened[key] =
+				typeof value === 'string'
+					? value
+					: typeof value === 'number' || typeof value === 'boolean'
+						? value
+						: JSON.stringify(value);
+		} else if (Array.isArray(value)) {
+			const len = value.length;
+			if (len === 0) return;
+
+			if (joinArrays) {
+				flattened[key] = value.join(',');
+			} else {
+				for (let i = 0; i < len; i++) {
+					flattenCore(flattened, `${key}[${i}]`, value[i]);
+				}
+			}
+		} else {
+			const entries = Object.entries(value);
+			if (entries.length === 0) return;
+
+			for (const [k, v] of entries) {
+				flattenCore(flattened, key ? `${key}.${k}` : k, v);
+			}
+		}
+	}
+
+	const flattened: Record<string, any> = Object.create(null);
+	flattenCore(flattened, prefix ?? '', o);
+	return flattened as Flatten<T, P, NonNullable<O['joinArrays']> extends true ? true : false>;
+}
+
+export function filterMap<T, TMapped>(
+	o: Record<string, T> | undefined,
+	predicateMapper: (key: string, value: T) => TMapped | null | undefined,
+): Record<string, TMapped> {
+	if (o == null) return {};
+
+	const result: Record<string, TMapped> = {};
+	for (const [key, value] of Object.entries(o)) {
+		const mapped = predicateMapper(key, value);
+		if (mapped == null) continue;
+
+		result[key] = mapped;
+	}
+	return result;
+}
+
+export function filterMapEntries<T, TMapped>(
+	o: Record<string, T> | undefined,
+	predicateMapper: (key: string, value: T) => TMapped | null | undefined,
+): [string, TMapped][] {
+	if (o == null) return [];
+
+	const result: [string, TMapped][] = [];
+	for (const [key, value] of Object.entries(o)) {
+		const mapped = predicateMapper(key, value);
+		if (mapped == null) continue;
+
+		result.push([key, mapped]);
+	}
+	return result;
+}
+
+export function filterMapValues<T, TMapped>(
+	o: Record<string, T> | undefined,
+	predicateMapper: (value: T) => TMapped | null | undefined,
+): TMapped[] {
+	if (o == null) return [];
+
+	const result: TMapped[] = [];
+	for (const key in o) {
+		const mapped = predicateMapper(o[key]);
+		if (mapped == null) continue;
+
+		result.push(mapped);
+	}
+	return result;
+}
+
+export function paths(o: Record<string, any>, path?: string): string[] {
+	const results = [];
+
+	for (const key in o) {
+		const child = o[key];
+		if (typeof child === 'object') {
+			results.push(...paths(child, path === undefined ? key : `${path}.${key}`));
+		} else {
+			results.push(path === undefined ? key : `${path}.${key}`);
+		}
+	}
+
+	return results;
+}
+
+export function updateRecordValue<T>(
+	o: Record<string, T> | undefined,
+	key: string,
+	value: T | undefined,
+): Record<string, T> {
+	o ??= Object.create(null) as Record<string, T>;
+
+	if (value != null && (typeof value !== 'boolean' || value)) {
+		if (typeof value === 'object') {
+			o[key] = { ...value };
+		} else {
+			o[key] = value;
+		}
+	} else {
+		const { [key]: _, ...rest } = o;
+		o = rest;
+	}
+	return o;
+}
+
+/**
+ * Efficiently checks if an object has at least one own enumerable property
+ * @param o - The object to check
+ * @returns true if the object has at least one own enumerable property, false otherwise
+ */
+export function hasKeys(o: Record<string, any> | null | undefined): o is Record<string, any> {
+	for (const k in o) {
+		if (Object.hasOwn(o, k)) return true;
+	}
+	return false;
+}
+
+/**
+ * Efficiently checks if an object has at least the specified number of truthy values (or at least one if not specified)
+ * @param o - The object to check (typically a Record<string, boolean>)
+ * @param required - The minimum number of truthy values required (default: 1)
+ * @returns true if the object has at least the required number of properties with truthy values
+ */
+export function hasTruthyKeys(
+	o: Record<string, any> | null | undefined,
+	required: number = 1,
+): o is Record<string, any> {
+	let count = 0;
+	for (const k in o) {
+		if (Object.hasOwn(o, k) && o[k]) {
+			count++;
+			if (count >= required) return true; // Early exit once we know we have enough
+		}
+	}
+	return count >= required;
+}

package/src/utils/paging.ts

@@ -0,0 +1,51 @@
+import type { Mutable } from './types.js';
+
+export interface PagedResult<T> {
+	readonly paging?: {
+		readonly cursor: string;
+		readonly more: boolean;
+	};
+	readonly values: NonNullable<T>[];
+}
+
+/** A shared, frozen empty result to avoid allocating on every "nothing found" path. */
+export const emptyPagedResult: PagedResult<any> = Object.freeze({ values: [] });
+
+export interface PagingOptions {
+	cursor?: string;
+}
+
+export class PageableResult<T> {
+	private cached: Mutable<PagedResult<T>> | undefined;
+
+	constructor(
+		private readonly fetch: (paging: PagedResult<T>['paging']) => Promise<PagedResult<T>>,
+		seed?: PagedResult<T>,
+	) {
+		this.cached = seed;
+	}
+
+	async *values(): AsyncIterable<NonNullable<T>> {
+		if (this.cached != null) {
+			for (const value of this.cached.values) {
+				yield value;
+			}
+		}
+
+		let results = this.cached;
+		while (results == null || results.paging?.more) {
+			results = await this.fetch(results?.paging);
+
+			if (this.cached == null) {
+				this.cached = results;
+			} else {
+				this.cached.values.push(...results.values);
+				this.cached.paging = results.paging;
+			}
+
+			for (const value of results.values) {
+				yield value;
+			}
+		}
+	}
+}

package/src/utils/path.ts

@@ -0,0 +1,189 @@
+import { isAbsolute as _isAbsolute, basename, dirname } from 'path';
+import { isLinux, isWindows } from './platform.js';
+import type { Uri } from './uri.js';
+import { hasScheme, parseUri } from './uri.js';
+
+export { basename, dirname, extname, join as joinPaths } from 'path';
+
+const driveLetterNormalizeRegex = /(^\/?)([a-zA-Z])(?=:\/)/;
+const hasSchemeRegex = /^([a-zA-Z][\w+.-]+):/;
+const pathNormalizeRegex = /\\/g;
+const slash = 47;
+
+export function arePathsEqual(a: string, b: string, ignoreCase?: boolean): boolean {
+	if (ignoreCase || (ignoreCase == null && !isLinux)) {
+		a = a.toLowerCase();
+		b = b.toLowerCase();
+	}
+	return normalizePath(a) === normalizePath(b);
+}
+
+export function commonBase(s: string[], delimiter: string, ignoreCase?: boolean): string | undefined {
+	if (s.length === 0) return undefined;
+
+	let common = s[0];
+	for (let i = 1; i < s.length; i++) {
+		const index = commonBaseIndex(common, s[i], delimiter, ignoreCase);
+		if (index === 0) return undefined;
+		common = common.substring(0, index + 1);
+	}
+
+	return common;
+}
+
+export function commonBaseIndex(s1: string, s2: string, delimiter: string, ignoreCase?: boolean): number {
+	if (s1.length === 0 || s2.length === 0) return 0;
+
+	if (ignoreCase ?? !isLinux) {
+		s1 = s1.toLowerCase();
+		s2 = s2.toLowerCase();
+	}
+
+	let char;
+	let index = 0;
+	for (let i = 0; i < s1.length; i++) {
+		char = s1[i];
+		if (char !== s2[i]) break;
+
+		if (char === delimiter) {
+			index = i;
+		}
+	}
+
+	return index;
+}
+
+export function getScheme(path: string): string | undefined {
+	return hasSchemeRegex.exec(path)?.[1];
+}
+
+export function isAbsolute(path: string): boolean {
+	return !maybeUri(path) && _isAbsolute(path);
+}
+
+export function isFolderGlob(path: string): boolean {
+	return basename(path) === '*';
+}
+
+export function maybeUri(path: string): boolean {
+	return hasScheme(path);
+}
+
+export function normalizePath(path: string): string {
+	if (!path) return path;
+
+	path = path.replace(pathNormalizeRegex, '/');
+	if (path.charCodeAt(path.length - 1) === slash) {
+		// Don't remove the trailing slash on Windows root folders, such as z:\
+		if (!isWindows || path.length !== 3 || path[1] !== ':') {
+			path = path.slice(0, -1);
+		}
+	}
+
+	if (isWindows) {
+		// Ensure that drive casing is normalized (lower case) and no leading slash
+		path = path.replace(driveLetterNormalizeRegex, (_, _slash, d: string) => d.toLowerCase());
+	}
+
+	return path;
+}
+
+export function stripFolderGlob(path: string): string {
+	return isFolderGlob(path) ? path.slice(0, -2) : path;
+}
+
+export function getBestPath(pathOrUri: string): string {
+	if (!hasScheme(pathOrUri)) return normalizePath(pathOrUri);
+
+	const uri = parseUri(pathOrUri);
+	return normalizePath(uri.scheme === 'file' ? uri.fsPath : uri.path);
+}
+
+export function isChild(path: string, base: string): boolean {
+	if (!base.startsWith('/')) {
+		base = `/${base}`;
+	}
+
+	return (
+		isDescendant(path, base) && path.substring(base.length + (base.endsWith('/') ? 0 : 1)).split('/').length === 1
+	);
+}
+
+export function isDescendant(path: string, base: string, ignoreCase?: boolean): boolean {
+	let basePath = getBestPath(base);
+	if (!basePath.startsWith('/')) {
+		basePath = `${basePath}/`;
+	}
+
+	// Handles folder globs and ensure ending with a trailing slash
+	if (basePath.endsWith('/*')) {
+		basePath = basePath.substring(0, basePath.length - 1);
+	} else if (!basePath.endsWith('/')) {
+		basePath = `${basePath}/`;
+	}
+
+	let p = getBestPath(path);
+	if (!p.startsWith('/')) {
+		p = `${p}/`;
+	}
+
+	if (ignoreCase ?? !isLinux) {
+		basePath = basePath.toLowerCase();
+		p = p.toLowerCase();
+	}
+
+	return p.startsWith(basePath);
+}
+
+export function relative(from: string, to: string, ignoreCase?: boolean): string {
+	from = hasScheme(from) ? parseUri(from).path : normalizePath(from);
+	to = hasScheme(to) ? parseUri(to).path : normalizePath(to);
+
+	const index = commonBaseIndex(`${to}/`, `${from}/`, '/', ignoreCase);
+	return index > 0 ? to.substring(index + 1) : to;
+}
+
+export function relativeDir(relativePath: string, relativeTo?: string): string {
+	const dirPath = dirname(relativePath);
+	if (!dirPath || dirPath === '.' || dirPath === relativeTo) return '';
+	if (!relativeTo) return dirPath;
+
+	const [relativeDirPath] = splitPath(dirPath, relativeTo);
+	return relativeDirPath;
+}
+
+export function splitPath(
+	pathOrUri: string,
+	root: string | undefined,
+	splitOnBaseIfMissing: boolean = false,
+	ignoreCase?: boolean,
+): [path: string, root: string] {
+	pathOrUri = getBestPath(pathOrUri);
+
+	if (root) {
+		let repoUri: Uri | undefined;
+		if (hasScheme(root)) {
+			repoUri = parseUri(root);
+			root = getBestPath(root);
+		} else {
+			root = normalizePath(root);
+		}
+
+		const index = commonBaseIndex(`${root}/`, `${pathOrUri}/`, '/', ignoreCase);
+		if (index > 0) {
+			root = pathOrUri.substring(0, index);
+			pathOrUri = pathOrUri.substring(index + 1);
+		} else if (pathOrUri.startsWith('/')) {
+			pathOrUri = pathOrUri.slice(1);
+		}
+
+		if (repoUri != null) {
+			root = repoUri.with({ path: root }).toString();
+		}
+	} else {
+		root = normalizePath(splitOnBaseIfMissing ? dirname(pathOrUri) : '');
+		pathOrUri = splitOnBaseIfMissing ? basename(pathOrUri) : pathOrUri;
+	}
+
+	return [pathOrUri, root];
+}

package/src/utils/platform.ts

@@ -0,0 +1 @@
+export { isLinux, isMac, isWindows } from '#env/platform.js';