@gitkraken/core-gitlens 0.1.0

package/src/git/utils/sorting.ts

@@ -0,0 +1,291 @@
+import { sortCompare } from '../../utils/string.js';
+import type { GitBranch } from '../models/branch.js';
+import type { GitContributor } from '../models/contributor.js';
+import type { GitRemote } from '../models/remote.js';
+import type { GitTag } from '../models/tag.js';
+import type { GitWorktree } from '../models/worktree.js';
+
+export type BranchSorting = 'date:desc' | 'date:asc' | 'name:asc' | 'name:desc';
+export type TagSorting = 'date:desc' | 'date:asc' | 'name:asc' | 'name:desc';
+export type ContributorSorting =
+	| 'count:desc'
+	| 'count:asc'
+	| 'date:desc'
+	| 'date:asc'
+	| 'name:asc'
+	| 'name:desc'
+	| 'score:desc'
+	| 'score:asc';
+
+export interface BranchSortOptions {
+	current?: boolean;
+	groupByType?: boolean;
+	missingUpstream?: boolean;
+	orderBy?: BranchSorting;
+	openedWorktreesByBranch?: Set<string>;
+}
+
+export function sortBranches(branches: GitBranch[], options?: BranchSortOptions): GitBranch[] {
+	options = { current: true, groupByType: true, orderBy: 'date:desc', ...options };
+
+	switch (options.orderBy) {
+		case 'date:asc':
+			return branches.sort(
+				(a, b) =>
+					(options.missingUpstream ? (a.upstream?.missing ? -1 : 1) - (b.upstream?.missing ? -1 : 1) : 0) ||
+					(options.current ? (a.current ? -1 : 1) - (b.current ? -1 : 1) : 0) ||
+					(options.openedWorktreesByBranch
+						? (options.openedWorktreesByBranch.has(a.id) ? -1 : 1) -
+							(options.openedWorktreesByBranch.has(b.id) ? -1 : 1)
+						: 0) ||
+					(a.starred ? -1 : 1) - (b.starred ? -1 : 1) ||
+					(options.groupByType ? (b.remote ? -1 : 1) - (a.remote ? -1 : 1) : 0) ||
+					(a.date == null ? -1 : a.date.getTime()) - (b.date == null ? -1 : b.date.getTime()) ||
+					sortCompare(a.name, b.name),
+			);
+		case 'name:asc':
+			return branches.sort(
+				(a, b) =>
+					(options.missingUpstream ? (a.upstream?.missing ? -1 : 1) - (b.upstream?.missing ? -1 : 1) : 0) ||
+					(options.current ? (a.current ? -1 : 1) - (b.current ? -1 : 1) : 0) ||
+					(options.openedWorktreesByBranch
+						? (options.openedWorktreesByBranch.has(a.id) ? -1 : 1) -
+							(options.openedWorktreesByBranch.has(b.id) ? -1 : 1)
+						: 0) ||
+					(a.starred ? -1 : 1) - (b.starred ? -1 : 1) ||
+					(a.name === 'main' ? -1 : 1) - (b.name === 'main' ? -1 : 1) ||
+					(a.name === 'master' ? -1 : 1) - (b.name === 'master' ? -1 : 1) ||
+					(a.name === 'develop' ? -1 : 1) - (b.name === 'develop' ? -1 : 1) ||
+					(options.groupByType ? (b.remote ? -1 : 1) - (a.remote ? -1 : 1) : 0) ||
+					sortCompare(a.name, b.name),
+			);
+		case 'name:desc':
+			return branches.sort(
+				(a, b) =>
+					(options.missingUpstream ? (a.upstream?.missing ? -1 : 1) - (b.upstream?.missing ? -1 : 1) : 0) ||
+					(options.current ? (a.current ? -1 : 1) - (b.current ? -1 : 1) : 0) ||
+					(options.openedWorktreesByBranch
+						? (options.openedWorktreesByBranch.has(a.id) ? -1 : 1) -
+							(options.openedWorktreesByBranch.has(b.id) ? -1 : 1)
+						: 0) ||
+					(a.starred ? -1 : 1) - (b.starred ? -1 : 1) ||
+					(a.name === 'main' ? -1 : 1) - (b.name === 'main' ? -1 : 1) ||
+					(a.name === 'master' ? -1 : 1) - (b.name === 'master' ? -1 : 1) ||
+					(a.name === 'develop' ? -1 : 1) - (b.name === 'develop' ? -1 : 1) ||
+					(options.groupByType ? (b.remote ? -1 : 1) - (a.remote ? -1 : 1) : 0) ||
+					sortCompare(b.name, a.name),
+			);
+		case 'date:desc':
+		default:
+			return branches.sort(
+				(a, b) =>
+					(options.missingUpstream ? (a.upstream?.missing ? -1 : 1) - (b.upstream?.missing ? -1 : 1) : 0) ||
+					(options.current ? (a.current ? -1 : 1) - (b.current ? -1 : 1) : 0) ||
+					(options.openedWorktreesByBranch
+						? (options.openedWorktreesByBranch.has(a.id) ? -1 : 1) -
+							(options.openedWorktreesByBranch.has(b.id) ? -1 : 1)
+						: 0) ||
+					(a.starred ? -1 : 1) - (b.starred ? -1 : 1) ||
+					(options.groupByType ? (b.remote ? -1 : 1) - (a.remote ? -1 : 1) : 0) ||
+					(b.date == null ? -1 : b.date.getTime()) - (a.date == null ? -1 : a.date.getTime()) ||
+					sortCompare(b.name, a.name),
+			);
+	}
+}
+
+export interface ContributorSortOptions<T = GitContributor> {
+	current?: true;
+	orderBy?: ContributorSorting;
+	accessor?: (item: T) => GitContributor;
+	preCompare?: (a: T, b: T) => number;
+}
+
+export function sortContributors<T = GitContributor>(contributors: T[], options?: ContributorSortOptions<T>): T[] {
+	const { accessor, preCompare, ...rest } = { current: true as const, orderBy: 'count:desc' as const, ...options };
+	const get = accessor ?? ((item: T) => item as unknown as GitContributor);
+	const pre = preCompare ?? (() => 0);
+
+	switch (rest.orderBy) {
+		case 'count:asc':
+			return contributors.sort((a, b) => {
+				const ca = get(a);
+				const cb = get(b);
+				return (
+					pre(a, b) ||
+					(rest.current ? (ca.current ? -1 : 1) - (cb.current ? -1 : 1) : 0) ||
+					ca.contributionCount - cb.contributionCount ||
+					(ca.latestCommitDate?.getTime() ?? 0) - (cb.latestCommitDate?.getTime() ?? 0)
+				);
+			});
+		case 'date:desc':
+			return contributors.sort((a, b) => {
+				const ca = get(a);
+				const cb = get(b);
+				return (
+					pre(a, b) ||
+					(rest.current ? (ca.current ? -1 : 1) - (cb.current ? -1 : 1) : 0) ||
+					(cb.latestCommitDate?.getTime() ?? 0) - (ca.latestCommitDate?.getTime() ?? 0) ||
+					cb.contributionCount - ca.contributionCount
+				);
+			});
+		case 'date:asc':
+			return contributors.sort((a, b) => {
+				const ca = get(a);
+				const cb = get(b);
+				return (
+					pre(a, b) ||
+					(rest.current ? (ca.current ? -1 : 1) - (cb.current ? -1 : 1) : 0) ||
+					(ca.latestCommitDate?.getTime() ?? 0) - (cb.latestCommitDate?.getTime() ?? 0) ||
+					cb.contributionCount - ca.contributionCount
+				);
+			});
+		case 'name:asc':
+			return contributors.sort((a, b) => {
+				const ca = get(a);
+				const cb = get(b);
+				return (
+					pre(a, b) ||
+					(rest.current ? (ca.current ? -1 : 1) - (cb.current ? -1 : 1) : 0) ||
+					sortCompare(ca.name ?? ca.username!, cb.name ?? cb.username!)
+				);
+			});
+		case 'name:desc':
+			return contributors.sort((a, b) => {
+				const ca = get(a);
+				const cb = get(b);
+				return (
+					pre(a, b) ||
+					(rest.current ? (ca.current ? -1 : 1) - (cb.current ? -1 : 1) : 0) ||
+					sortCompare(cb.name ?? cb.username!, ca.name ?? ca.username!)
+				);
+			});
+		case 'score:desc':
+			return contributors.sort((a, b) => {
+				const ca = get(a);
+				const cb = get(b);
+				return (
+					pre(a, b) ||
+					(rest.current ? (ca.current ? -1 : 1) - (cb.current ? -1 : 1) : 0) ||
+					(cb.stats?.contributionScore ?? 0) - (ca.stats?.contributionScore ?? 0) ||
+					cb.contributionCount - ca.contributionCount ||
+					(cb.latestCommitDate?.getTime() ?? 0) - (ca.latestCommitDate?.getTime() ?? 0)
+				);
+			});
+		case 'score:asc':
+			return contributors.sort((a, b) => {
+				const ca = get(a);
+				const cb = get(b);
+				return (
+					pre(a, b) ||
+					(rest.current ? (ca.current ? -1 : 1) - (cb.current ? -1 : 1) : 0) ||
+					(ca.stats?.contributionScore ?? 0) - (cb.stats?.contributionScore ?? 0) ||
+					ca.contributionCount - cb.contributionCount ||
+					(ca.latestCommitDate?.getTime() ?? 0) - (cb.latestCommitDate?.getTime() ?? 0)
+				);
+			});
+		case 'count:desc':
+		default:
+			return contributors.sort((a, b) => {
+				const ca = get(a);
+				const cb = get(b);
+				return (
+					pre(a, b) ||
+					(rest.current ? (ca.current ? -1 : 1) - (cb.current ? -1 : 1) : 0) ||
+					cb.contributionCount - ca.contributionCount ||
+					(cb.latestCommitDate?.getTime() ?? 0) - (ca.latestCommitDate?.getTime() ?? 0)
+				);
+			});
+	}
+}
+
+export function sortRemotes<T extends GitRemote>(remotes: T[]): T[] {
+	return remotes.sort(
+		(a, b) =>
+			(a.default ? -1 : 1) - (b.default ? -1 : 1) ||
+			(a.name === 'origin' ? -1 : 1) - (b.name === 'origin' ? -1 : 1) ||
+			(a.name === 'upstream' ? -1 : 1) - (b.name === 'upstream' ? -1 : 1) ||
+			sortCompare(a.name, b.name),
+	);
+}
+
+export interface TagSortOptions {
+	orderBy?: TagSorting;
+}
+
+export function sortTags(tags: GitTag[], options?: TagSortOptions): GitTag[] {
+	options = { orderBy: 'date:desc', ...options };
+
+	switch (options.orderBy) {
+		case 'date:asc':
+			return tags.sort((a, b) => (a.date?.getTime() ?? 0) - (b.date?.getTime() ?? 0));
+		case 'name:asc':
+			return tags.sort((a, b) => sortCompare(a.name, b.name));
+		case 'name:desc':
+			return tags.sort((a, b) => sortCompare(b.name, a.name));
+		case 'date:desc':
+		default:
+			return tags.sort((a, b) => (b.date?.getTime() ?? 0) - (a.date?.getTime() ?? 0));
+	}
+}
+
+export interface WorktreeSortOptions<T = GitWorktree> {
+	orderBy?: BranchSorting;
+	accessor?: (item: T) => GitWorktree;
+}
+
+export function sortWorktrees<T = GitWorktree>(worktrees: T[], options?: WorktreeSortOptions<T>): T[] {
+	const { accessor, ...rest } = { orderBy: 'date:desc' as const, ...options };
+	const get = accessor ?? ((item: T) => item as unknown as GitWorktree);
+
+	switch (rest.orderBy) {
+		case 'date:asc':
+			return worktrees.sort((a, b) => {
+				const wa = get(a);
+				const wb = get(b);
+				return (
+					(wa.opened ? -1 : 1) - (wb.opened ? -1 : 1) ||
+					(wa.isDefault ? -1 : 1) - (wb.isDefault ? -1 : 1) ||
+					(wa.date == null ? -1 : wa.date.getTime()) - (wb.date == null ? -1 : wb.date.getTime()) ||
+					sortCompare(wa.name, wb.name)
+				);
+			});
+		case 'name:asc':
+			return worktrees.sort((a, b) => {
+				const wa = get(a);
+				const wb = get(b);
+				return (
+					(wa.opened ? -1 : 1) - (wb.opened ? -1 : 1) ||
+					(wa.isDefault ? -1 : 1) - (wb.isDefault ? -1 : 1) ||
+					(wa.name === 'main' ? -1 : 1) - (wb.name === 'main' ? -1 : 1) ||
+					(wa.name === 'master' ? -1 : 1) - (wb.name === 'master' ? -1 : 1) ||
+					(wa.name === 'develop' ? -1 : 1) - (wb.name === 'develop' ? -1 : 1) ||
+					sortCompare(wa.name, wb.name)
+				);
+			});
+		case 'name:desc':
+			return worktrees.sort((a, b) => {
+				const wa = get(a);
+				const wb = get(b);
+				return (
+					(wa.opened ? -1 : 1) - (wb.opened ? -1 : 1) ||
+					(wa.isDefault ? -1 : 1) - (wb.isDefault ? -1 : 1) ||
+					(wa.name === 'main' ? -1 : 1) - (wb.name === 'main' ? -1 : 1) ||
+					(wa.name === 'master' ? -1 : 1) - (wb.name === 'master' ? -1 : 1) ||
+					(wa.name === 'develop' ? -1 : 1) - (wb.name === 'develop' ? -1 : 1) ||
+					sortCompare(wb.name, wa.name)
+				);
+			});
+		case 'date:desc':
+		default:
+			return worktrees.sort((a, b) => {
+				const wa = get(a);
+				const wb = get(b);
+				return (
+					(wa.opened ? -1 : 1) - (wb.opened ? -1 : 1) ||
+					(wa.isDefault ? -1 : 1) - (wb.isDefault ? -1 : 1) ||
+					(wb.date == null ? -1 : wb.date.getTime()) - (wa.date == null ? -1 : wa.date.getTime()) ||
+					sortCompare(wb.name, wa.name)
+				);
+			});
+	}
+}

package/src/git/utils/status.utils.ts

@@ -0,0 +1,114 @@
+import { pluralize } from '../../utils/string.js';
+import type { GitTrackingUpstream } from '../models/branch.js';
+import type { GitDiffFileStats } from '../models/diff.js';
+
+// Unicode arrows (from GlyphChars)
+const arrowDown = '\u2193';
+const arrowUp = '\u2191';
+
+export function getFormattedDiffStatus(
+	stats: GitDiffFileStats,
+	options?: {
+		compact?: boolean;
+		empty?: string;
+		expand?: boolean;
+		prefix?: string;
+		separator?: string;
+		suffix?: string;
+	},
+): string {
+	const { added, changed, deleted } = stats;
+	if (added === 0 && changed === 0 && deleted === 0) return options?.empty ?? '';
+
+	const prefix = options?.prefix ?? '';
+	const separator = options?.separator ?? ' ';
+	const suffix = options?.suffix ?? '';
+
+	if (options?.expand) {
+		let status = '';
+		if (added) {
+			status += `${pluralize('file', added)} added`;
+		}
+		if (changed) {
+			status += `${status.length === 0 ? '' : separator}${pluralize('file', changed)} changed`;
+		}
+		if (deleted) {
+			status += `${status.length === 0 ? '' : separator}${pluralize('file', deleted)} deleted`;
+		}
+		return `${prefix}${status}${suffix}`;
+	}
+
+	let status = '';
+	if (options?.compact) {
+		if (added !== 0) {
+			status += `+${added}`;
+		}
+		if (changed !== 0) {
+			status += `${status.length === 0 ? '' : separator}~${changed}`;
+		}
+		if (deleted !== 0) {
+			status += `${status.length === 0 ? '' : separator}-${deleted}`;
+		}
+	} else {
+		status += `+${added}${separator}~${changed}${separator}-${deleted}`;
+	}
+
+	return `${prefix}${status}${suffix}`;
+}
+
+export function getUpstreamStatus(
+	upstream: GitTrackingUpstream | undefined,
+	options?: {
+		count?: boolean;
+		empty?: string;
+		expand?: boolean;
+		icons?: boolean;
+		prefix?: string;
+		separator?: string;
+		suffix?: string;
+	},
+): string {
+	if (upstream == null) return options?.empty ?? '';
+	const {
+		state: { ahead, behind },
+	} = upstream;
+	if (!behind && !ahead) return options?.empty ?? '';
+
+	let count = true;
+	let expand = false;
+	let icons = false;
+	let prefix = '';
+	let separator = ' ';
+	let suffix = '';
+	if (options != null) {
+		({ count = true, expand = false, icons = false, prefix = '', separator = ' ', suffix = '' } = options);
+	}
+
+	if (expand) {
+		let status = '';
+		if (upstream.missing) {
+			status = 'missing';
+		} else {
+			if (behind) {
+				status += `${pluralize('commit', behind, {
+					infix: icons ? '$(arrow-down) ' : undefined,
+				})} behind`;
+			}
+			if (ahead) {
+				status += `${status.length === 0 ? '' : separator}${pluralize('commit', ahead, {
+					infix: icons ? '$(arrow-up) ' : undefined,
+				})} ahead`;
+				if (suffix.includes(upstream.name.split('/')[0])) {
+					status += ' of';
+				}
+			}
+		}
+		return `${prefix}${status}${suffix}`;
+	}
+
+	const showCounts = count && !upstream.missing;
+
+	return `${prefix}${showCounts ? behind : ''}${showCounts || behind !== 0 ? arrowDown : ''}${separator}${
+		showCounts ? ahead : ''
+	}${showCounts || ahead !== 0 ? arrowUp : ''}${suffix}`;
+}

package/src/git/utils/statusFile.utils.ts

@@ -0,0 +1,182 @@
+import { normalizePath } from '../../utils/path.js';
+import { fileUri, joinUriPath } from '../../utils/uri.js';
+import type { GitCommit } from '../models/commit.js';
+import { GitFileChange } from '../models/fileChange.js';
+import { uncommitted, uncommittedStaged } from '../models/revision.js';
+import type { GitStatusFile } from '../models/statusFile.js';
+import type { GitUser } from '../models/user.js';
+import { createUncommittedChangesCommit } from './commit.utils.js';
+
+export function getPseudoCommits(
+	files: GitStatusFile[] | undefined,
+	filteredPath: string | undefined,
+	user: GitUser | undefined,
+): GitCommit[] {
+	if (!files?.length) return [];
+
+	let now = new Date();
+	const repoPath = files[0].repoPath;
+	const repoUri = fileUri(normalizePath(repoPath));
+
+	let conflicted: GitFileChange[] | undefined;
+	let staged: GitFileChange[] | undefined;
+	let wip: GitFileChange[] | undefined;
+
+	for (const file of files) {
+		const mode = file.submodule != null ? '160000' : undefined;
+		const originalUri =
+			file.originalPath != null ? joinUriPath(repoUri, normalizePath(file.originalPath)) : undefined;
+
+		if (file.conflicted) {
+			conflicted ??= [];
+			conflicted.push(
+				new GitFileChange(
+					repoPath,
+					file.path,
+					file.status,
+					file.uri,
+					file.originalPath,
+					originalUri,
+					'HEAD',
+					undefined,
+					false,
+					undefined,
+					mode,
+					file.submodule,
+				),
+			);
+		} else {
+			if (file.wip) {
+				wip ??= [];
+				wip.push(
+					new GitFileChange(
+						repoPath,
+						file.path,
+						file.workingTreeStatus ?? file.status,
+						file.uri,
+						file.originalPath,
+						originalUri,
+						file.staged ? uncommittedStaged : 'HEAD',
+						undefined,
+						false,
+						undefined,
+						mode,
+						file.submodule,
+					),
+				);
+			}
+
+			if (file.staged) {
+				staged ??= [];
+				staged.push(
+					new GitFileChange(
+						repoPath,
+						file.path,
+						file.indexStatus ?? file.status,
+						file.uri,
+						file.originalPath,
+						originalUri,
+						'HEAD',
+						undefined,
+						true,
+						undefined,
+						mode,
+						file.submodule,
+					),
+				);
+			}
+		}
+	}
+
+	const commits: GitCommit[] = [];
+
+	if (conflicted?.length || wip?.length) {
+		const conflictedAndWipFiles = [...(conflicted ?? []), ...(wip ?? [])];
+		commits.push(
+			createUncommittedChangesCommit(repoPath, uncommitted, now, user, {
+				fileset: filteredPath
+					? { files: undefined, filtered: { files: conflictedAndWipFiles, pathspec: filteredPath } }
+					: { files: conflictedAndWipFiles },
+				parents: [staged?.length ? uncommittedStaged : 'HEAD'],
+			}),
+		);
+
+		// Decrements the date to guarantee the staged entry (if exists) will be sorted before the working entry (most recent first)
+		now = new Date(now.getTime() - 60000);
+	}
+
+	if (staged?.length) {
+		commits.push(
+			createUncommittedChangesCommit(repoPath, uncommittedStaged, now, user, {
+				fileset: filteredPath
+					? { files: undefined, filtered: { files: staged, pathspec: filteredPath } }
+					: { files: staged },
+				parents: ['HEAD'],
+			}),
+		);
+	}
+
+	return commits;
+}
+
+export function getStatusFilePseudoCommits(file: GitStatusFile, user: GitUser | undefined): GitCommit[] {
+	return getPseudoCommits([file], file.path, user);
+}
+
+export function getStatusFilePseudoFileChanges(file: GitStatusFile): GitFileChange[] {
+	const repoUri = fileUri(normalizePath(file.repoPath));
+	const originalUri = file.originalPath != null ? joinUriPath(repoUri, normalizePath(file.originalPath)) : undefined;
+
+	if (file.conflicted) {
+		return [
+			new GitFileChange(
+				file.repoPath,
+				file.path,
+				file.status,
+				file.uri,
+				file.originalPath,
+				originalUri,
+				'HEAD',
+				undefined,
+				false,
+			),
+		];
+	}
+
+	const files: GitFileChange[] = [];
+	const staged = file.staged;
+
+	if (file.wip) {
+		files.push(
+			new GitFileChange(
+				file.repoPath,
+				file.path,
+				file.status,
+				file.uri,
+				file.originalPath,
+				originalUri,
+				staged ? uncommittedStaged : 'HEAD',
+				undefined,
+				false,
+			),
+		);
+	}
+
+	if (staged) {
+		files.push(
+			new GitFileChange(
+				file.repoPath,
+				file.path,
+				file.status,
+				file.uri,
+				file.originalPath,
+				originalUri,
+				'HEAD',
+				undefined,
+				true,
+			),
+		);
+	}
+
+	return files;
+}

package/src/git/utils/tag.utils.ts

@@ -0,0 +1,17 @@
+import type { GitReference, GitTagReference } from '../models/reference.js';
+
+export function getTagId(repoPath: string, name: string): string {
+	return `${repoPath}|tags/${name}`;
+}
+
+export function isOfTagRefType(tag: GitReference | undefined): tag is GitTagReference {
+	return tag?.refType === 'tag';
+}
+
+const tagsPrefixRegex = /^(refs\/)?tags\//i;
+
+export function parseRefName(refName: string): { name: string } {
+	// Strip off refs/tags/
+	const name = refName.replace(tagsPrefixRegex, '');
+	return { name: name };
+}

package/src/git/utils/tooltip.utils.ts

@@ -0,0 +1,37 @@
+import { getUpstreamStatus } from './status.utils.js';
+
+/**
+ * Formats italic markdown indicators, e.g. ` \u00a0(_default, active_)`.
+ * Returns empty string if no indicators.
+ */
+export function formatIndicators(indicators: string[]): string {
+	if (!indicators.length) return '';
+	return ` \u00a0(_${indicators.join(', ')}_)`;
+}
+
+/**
+ * Formats the "Branch is ..." tracking status line for markdown tooltips.
+ * Shared by tree-view nodes (branchNode, worktreeNode) and graph sidebar tooltips.
+ */
+export function formatTrackingTooltip(
+	upstreamName: string,
+	upstreamMissing: boolean,
+	tracking?: { ahead: number; behind: number },
+	providerName?: string,
+): string {
+	const provider = providerName ? ` on ${providerName}` : '';
+	return `Branch is ${getUpstreamStatus(
+		{
+			name: upstreamName,
+			missing: upstreamMissing,
+			state: tracking ?? { ahead: 0, behind: 0 },
+		},
+		{
+			empty: `${upstreamMissing ? 'missing upstream' : 'up to date with'} \\\n $(git-branch) \`${upstreamName}\`${provider}`,
+			expand: true,
+			icons: true,
+			separator: ', ',
+			suffix: `\\\n$(git-branch) \`${upstreamName}\`${provider}`,
+		},
+	)}`;
+}

package/src/git/utils/uriAuthority.ts

@@ -0,0 +1,34 @@
+import { decodeUtf8Hex, encodeUtf8Hex } from '../../utils/hex.js';
+
+export interface RevisionUriData {
+	ref?: string;
+	repoPath: string;
+	uncPath?: string;
+	submoduleSha?: string;
+}
+
+export interface RevisionUriOptions {
+	submoduleSha?: string;
+}
+
+export function encodeGitLensRevisionUriAuthority<T>(metadata: T): string {
+	return encodeUtf8Hex(JSON.stringify(metadata));
+}
+
+export function decodeGitLensRevisionUriAuthority<T>(authority: string): T {
+	return JSON.parse(decodeUtf8Hex(authority)) as T;
+}
+
+export function decodeRemoteHubAuthority<T>(authority: string): { scheme: string; metadata: T | undefined } {
+	const [scheme, encoded] = authority.split('+');
+
+	let metadata: T | undefined;
+	if (encoded) {
+		try {
+			const data = JSON.parse(decodeUtf8Hex(encoded));
+			metadata = data as T;
+		} catch {}
+	}
+
+	return { scheme: scheme, metadata: metadata };
+}

package/src/git/utils/user.utils.ts

@@ -0,0 +1,20 @@
+import type { GitUser } from '../models/user.js';
+
+export function isUserMatch(
+	user: GitUser | undefined,
+	name: string | undefined,
+	email: string | undefined,
+	username?: string | undefined,
+): boolean {
+	return (
+		user != null &&
+		// Name or e-mail is provided
+		(user.name != null || user.email != null || user.username != null) &&
+		// Match on name if provided
+		(user.name == null || user.name === name) &&
+		// Match on email if provided
+		(user.email == null || user.email === email) &&
+		// Match on username if provided
+		(user.username == null || user.username === username)
+	);
+}