@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/src/git/utils/rebase.utils.ts

@@ -1,128 +0,0 @@
-import type { Mutable } from '../../utils/types.js';
-import type {
-	ProcessedRebaseCommitEntry,
-	ProcessedRebaseEntry,
-	ProcessedRebaseTodo,
-	RebaseTodoCommandAction,
-	RebaseTodoCommitAction,
-	RebaseTodoEntry,
-	RebaseTodoMergesAction,
-} from '../models/rebase.js';
-
-/** Commit actions that have SHAs and are editable */
-export const commitRebaseActions = new Set<RebaseTodoCommitAction>([
-	'pick',
-	'reword',
-	'edit',
-	'squash',
-	'fixup',
-	'drop',
-]);
-
-/** Command actions that are movable but not editable */
-export const commandRebaseActions = new Set<RebaseTodoCommandAction>(['exec', 'break', 'noop']);
-
-/** Actions that indicate --rebase-merges mode */
-export const mergesRebaseActions = new Set<RebaseTodoMergesAction>(['label', 'reset', 'merge']);
-
-export function formatRebaseTodoEntryLine(entry: ProcessedRebaseEntry, overrideAction?: string): string {
-	const action = overrideAction ?? entry.action;
-	if (entry.type === 'commit') {
-		const flagPart = entry.flag ? ` ${entry.flag}` : '';
-		return `${action}${flagPart} ${entry.sha} # ${entry.message}`;
-	}
-
-	// Command entries (exec, break, noop)
-	if (entry.action === 'exec') {
-		return `exec${entry.command ? ` ${entry.command}` : ''}`;
-	}
-	return entry.action; // break, noop
-}
-
-/** Formats an update-ref line for output */
-export function formatUpdateRefLine(ref: string): string {
-	return `update-ref ${ref}`;
-}
-
-/** Checks if an entry is a commit-based action */
-type RebaseTodoCommitEntry = RebaseTodoEntry<RebaseTodoCommitAction> & { sha: string; message: string };
-function isCommitEntry(entry: RebaseTodoEntry): entry is RebaseTodoCommitEntry {
-	return (
-		entry.sha != null && entry.message != null && commitRebaseActions.has(entry.action as RebaseTodoCommitAction)
-	);
-}
-
-/** Checks if an entry is a command action (exec/break/noop) */
-type RebaseTodoCommandEntry = RebaseTodoEntry<RebaseTodoCommandAction> & { command: string };
-function isCommandEntry(entry: RebaseTodoEntry): entry is RebaseTodoCommandEntry {
-	return commandRebaseActions.has(entry.action as RebaseTodoCommandAction);
-}
-
-/**
- * Checks if this is a --rebase-merges rebase that actually has merge commits
- * Only actual 'merge' commands indicate a true DAG that cannot be safely reordered.
- * If just label/reset are present (no merge), the history is linear and editable.
- */
-function hasActualMergeCommands(entries: RebaseTodoEntry[]): boolean {
-	return entries.some(e => e.action === 'merge');
-}
-
-/** Checks if an entry is a structural label/reset command (filtered from UI) */
-function isStructuralEntry(entry: RebaseTodoEntry): boolean {
-	return entry.action === 'label' || entry.action === 'reset';
-}
-
-/** Checks if an entry is an update-ref action */
-type RebaseTodoUpdateRefEntry = RebaseTodoEntry<'update-ref'> & { ref: string };
-function isUpdateRefEntry(entry: RebaseTodoEntry): entry is RebaseTodoUpdateRefEntry {
-	return entry.action === 'update-ref' && entry.ref != null;
-}
-
-/**
- * Processes parsed rebase entries into a flat list with type discriminators.
- * - Adds `type: 'commit' | 'command'` to each entry
- * - Attaches update-ref entries to their preceding commits
- * - Filters out structural label/reset entries (they're preserved in the raw file)
- * - Detects rebases with actual merge commits (reordering disabled but actions allowed)
- */
-export function processRebaseEntries(entries: RebaseTodoEntry[], done?: boolean): ProcessedRebaseTodo {
-	// Only flag as preservesMerges if there are actual merge commands
-	// label/reset alone (no merge) means linear history that can be edited
-	const preservesMerges = hasActualMergeCommands(entries);
-
-	const result: ProcessedRebaseEntry[] = [];
-	const commits = new Map<string, ProcessedRebaseCommitEntry>();
-
-	// Track the last commit to attach update-refs to
-	let lastCommit: ProcessedRebaseCommitEntry | undefined;
-
-	for (const entry of entries) {
-		// Skip structural label/reset entries - they're preserved in the raw file
-		// but not shown in the UI (the UI only shows commits and command actions)
-		if (isStructuralEntry(entry)) continue;
-
-		if (isCommitEntry(entry)) {
-			const commitEntry: ProcessedRebaseCommitEntry = { ...entry, type: 'commit', id: entry.sha, done: done };
-			result.push(commitEntry);
-			commits.set(commitEntry.sha, commitEntry);
-			lastCommit = commitEntry;
-			continue;
-		}
-
-		if (isUpdateRefEntry(entry)) {
-			// Attach update-ref to the preceding commit (with line number for reordering)
-			if (lastCommit) {
-				(lastCommit as Mutable<ProcessedRebaseCommitEntry>).updateRefs ??= [];
-				lastCommit.updateRefs!.push({ ref: entry.ref, line: entry.line });
-			}
-			continue;
-		}
-
-		if (isCommandEntry(entry)) {
-			result.push({ ...entry, type: 'command', id: `${done ? 'done:' : ''}line:${entry.line}`, done: done });
-			continue;
-		}
-	}
-
-	return { entries: result, commits: commits, preservesMerges: preservesMerges };
-}

package/src/git/utils/reference.utils.ts

@@ -1,267 +0,0 @@
-import { capitalize } from '../../utils/string.js';
-import type {
-	GitBranchReference,
-	GitReference,
-	GitRevisionReference,
-	GitStashReference,
-	GitTagReference,
-} from '../models/reference.js';
-import { getBranchNameWithoutRemote, getRemoteNameFromBranchName } from './branch.utils.js';
-import { isRevisionRange, isShaWithParentSuffix, shortenRevision } from './revision.utils.js';
-
-interface GitBranchReferenceOptions {
-	refType: 'branch';
-	id?: string;
-	name: string;
-	remote: boolean;
-	sha?: string;
-	upstream?: { name: string; missing: boolean };
-	worktree?: { path: string; isDefault: boolean } | boolean;
-}
-
-interface GitCommitReferenceOptions {
-	refType: 'revision';
-	name?: string;
-	message?: string;
-}
-
-interface GitStashReferenceOptions {
-	refType: 'stash';
-	name: string;
-	number: string | undefined;
-	message?: string;
-	stashOnRef?: string;
-}
-
-interface GitTagReferenceOptions {
-	refType: 'tag';
-	id?: string;
-	name: string;
-	sha?: string;
-}
-
-export function createReference(ref: string, repoPath: string, options: GitBranchReferenceOptions): GitBranchReference;
-export function createReference(ref: string, repoPath: string, options: GitStashReferenceOptions): GitStashReference;
-export function createReference(ref: string, repoPath: string, options: GitTagReferenceOptions): GitTagReference;
-export function createReference(
-	ref: string,
-	repoPath: string,
-	options?: GitCommitReferenceOptions,
-): GitRevisionReference;
-export function createReference(
-	ref: string,
-	repoPath: string,
-	options:
-		| GitBranchReferenceOptions
-		| GitStashReferenceOptions
-		| GitTagReferenceOptions
-		| GitCommitReferenceOptions = { refType: 'revision' },
-): GitReference {
-	switch (options.refType) {
-		case 'branch':
-			return {
-				refType: 'branch',
-				repoPath: repoPath,
-				ref: ref,
-				name: options.name,
-				id: options.id,
-				remote: options.remote,
-				sha: options.sha,
-				upstream: options.upstream,
-				worktree: options.worktree,
-			};
-		case 'stash':
-			return {
-				refType: 'stash',
-				repoPath: repoPath,
-				ref: ref,
-				sha: ref,
-				name: options.name,
-				stashNumber: options.number,
-				message: options.message,
-				stashOnRef: options.stashOnRef,
-			};
-		case 'tag':
-			return {
-				refType: 'tag',
-				repoPath: repoPath,
-				ref: ref,
-				name: options.name,
-				id: options.id,
-				sha: options.sha,
-			};
-		default:
-			return {
-				refType: 'revision',
-				repoPath: repoPath,
-				ref: ref,
-				sha: ref,
-				name: options.name ?? shortenRevision(ref, { strings: { working: 'Working Tree' } }),
-				message: options.message,
-			};
-	}
-}
-
-export function getReferenceNameWithoutRemote(ref: GitReference): string {
-	if (ref.refType === 'branch') {
-		return ref.remote ? getBranchNameWithoutRemote(ref.name) : ref.name;
-	}
-	return ref.name;
-}
-
-export function getReferenceTypeLabel(ref: GitReference | undefined): 'Branch' | 'Commit' | 'Stash' | 'Tag' {
-	switch (ref?.refType) {
-		case 'branch':
-			return 'Branch';
-		case 'stash':
-			return 'Stash';
-		case 'tag':
-			return 'Tag';
-		default:
-			return 'Commit';
-	}
-}
-
-export function isBranchReference(ref: GitReference | undefined): ref is GitBranchReference {
-	return ref?.refType === 'branch';
-}
-
-export function isGitReference(ref: unknown): ref is GitReference {
-	if (ref == null || typeof ref !== 'object') return false;
-
-	const r = ref as GitReference;
-	return (
-		typeof r.refType === 'string' &&
-		typeof r.repoPath === 'string' &&
-		typeof r.ref === 'string' &&
-		typeof r.name === 'string'
-	);
-}
-
-export function isRevisionReference(ref: GitReference | undefined): ref is GitRevisionReference {
-	return ref?.refType === 'revision';
-}
-
-export function isRevisionRangeReference(ref: GitReference | undefined): ref is GitRevisionReference {
-	return ref?.refType === 'revision' && isRevisionRange(ref.ref);
-}
-
-export function isStashReference(ref: GitReference | undefined): ref is GitStashReference {
-	return ref?.refType === 'stash' || (ref?.refType === 'revision' && Boolean('stashName' in ref && ref.stashName));
-}
-
-export function isTagReference(ref: GitReference | undefined): ref is GitTagReference {
-	return ref?.refType === 'tag';
-}
-
-export function getReferenceLabel(
-	refs: GitReference | GitReference[] | undefined,
-	options?: { capitalize?: boolean; expand?: boolean; icon?: boolean; label?: boolean; quoted?: boolean } | false,
-): string {
-	if (refs == null) return '';
-
-	options =
-		options === false
-			? {}
-			: { expand: true, icon: true, label: options?.label ?? options?.expand ?? true, ...options };
-
-	let result;
-	if (!Array.isArray(refs) || refs.length === 1) {
-		const ref = Array.isArray(refs) ? refs[0] : refs;
-		let refName = options?.quoted ? `'${ref.name}'` : ref.name;
-		switch (ref.refType) {
-			case 'branch': {
-				if (ref.remote) {
-					refName = `${getRemoteNameFromBranchName(refName)}: ${getBranchNameWithoutRemote(refName)}`;
-					refName = options?.quoted ? `'${refName}'` : refName;
-				}
-
-				let label;
-				if (options.label) {
-					if (options.capitalize && options.expand) {
-						label = `${ref.remote ? 'Remote ' : ''}Branch `;
-					} else {
-						label = `${ref.remote ? 'remote ' : ''}branch `;
-					}
-				} else {
-					label = '';
-				}
-
-				result = `${label}${options.icon ? `$(git-branch)\u00a0${refName}` : refName}`;
-				break;
-			}
-			case 'tag':
-				result = `${options.label ? 'tag ' : ''}${options.icon ? `$(tag)\u00a0${refName}` : refName}`;
-				break;
-			default: {
-				if (isStashReference(ref)) {
-					let message;
-					if (options.expand && ref.message) {
-						message = `${ref.stashNumber != null ? `#${ref.stashNumber}: ` : ''}${
-							ref.message.length > 20 ? `${ref.message.substring(0, 20).trimEnd()}\u2026` : ref.message
-						}`;
-					}
-
-					result = `${options.label ? 'stash ' : ''}${
-						options.icon
-							? `$(archive)\u00a0${message ?? ref.name}`
-							: (message ?? (ref.stashNumber ? `#${ref.stashNumber}` : ref.name))
-					}`;
-				} else if (isRevisionRange(ref.ref)) {
-					result = refName;
-				} else {
-					let message;
-					if (options.expand && ref.message) {
-						message =
-							ref.message.length > 20
-								? ` (${ref.message.substring(0, 20).trimEnd()}\u2026)`
-								: ` (${ref.message})`;
-					}
-
-					let prefix;
-					if (options.expand && options.label && isShaWithParentSuffix(ref.ref)) {
-						refName = ref.name.endsWith('^') ? ref.name.substring(0, ref.name.length - 1) : ref.name;
-						if (options?.quoted) {
-							refName = `'${refName}'`;
-						}
-						prefix = 'before ';
-					} else {
-						prefix = '';
-					}
-
-					result = `${options.label ? `${prefix}commit ` : ''}${
-						options.icon ? `$(git-commit)\u00a0${refName}${message ?? ''}` : `${refName}${message ?? ''}`
-					}`;
-				}
-				break;
-			}
-		}
-
-		return options.capitalize && options.expand && options.label !== false ? capitalize(result) : result;
-	}
-
-	const expanded = options.expand ? ` (${refs.map(r => r.name).join(', ')})` : '';
-	switch (refs[0].refType) {
-		case 'branch':
-			return `${refs.length} branches${expanded}`;
-		case 'tag':
-			return `${refs.length} tags${expanded}`;
-		default:
-			return `${refs.length} ${isStashReference(refs[0]) ? 'stashes' : 'commits'}${expanded}`;
-	}
-}
-
-export function getReferenceTypeIcon(ref: GitReference | undefined, webview?: boolean): string {
-	switch (ref?.refType) {
-		case 'branch':
-			if (ref.remote) return 'cloud';
-			if (ref.worktree) return webview ? 'gl-worktree' : 'gitlens-worktree';
-			return 'git-branch';
-		case 'tag':
-			return 'tag';
-		case 'stash':
-			return 'archive';
-		default:
-			return 'git-commit';
-	}
-}

package/src/git/utils/remote.utils.ts

@@ -1,146 +0,0 @@
-import type { GitRemote } from '../models/remote.js';
-import type { RemoteProvider } from '../models/remoteProvider.js';
-import type { RemoteResource } from '../models/remoteResource.js';
-import { RemoteResourceType } from '../models/remoteResource.js';
-
-export function getDefaultRemoteOrHighlander<T extends GitRemote>(remotes: T[]): T | undefined {
-	return remotes.length === 1 ? remotes[0] : remotes.find(r => r.default);
-}
-
-/** Like {@link getDefaultRemoteOrHighlander}, but falls back to `origin` when no remote is designated
- *  default — otherwise features keyed on "the default remote" silently do nothing on multi-remote repos */
-export function getDefaultRemoteOrOrigin<T extends GitRemote>(remotes: T[]): T | undefined {
-	return getDefaultRemoteOrHighlander(remotes) ?? remotes.find(r => r.name === 'origin');
-}
-
-export function getHighlanderProviderName(remotes: GitRemote<RemoteProvider>[]): string | undefined {
-	if (remotes.length === 0) return undefined;
-
-	const remote = getDefaultRemoteOrHighlander(remotes);
-	if (remote != null) return remote.provider.name;
-
-	const providerName = remotes[0].provider.name;
-	// Only use the real provider name if there is only 1 type of provider
-	if (remotes.every(r => r.provider.name === providerName)) return providerName;
-
-	return undefined;
-}
-
-export function getHighlanderProviders(remotes: GitRemote<RemoteProvider>[]): RemoteProvider[] | undefined {
-	if (remotes.length === 0) return undefined;
-
-	const remote = getDefaultRemoteOrHighlander(remotes);
-	if (remote != null) return [remote.provider];
-
-	const providerName = remotes[0].provider.name;
-	if (remotes.every(r => r.provider.name === providerName)) return remotes.map(r => r.provider);
-
-	return undefined;
-}
-
-export function getRemoteArrowsGlyph(remote: GitRemote): string {
-	let arrows;
-	let left;
-	let right;
-	for (const { type } of remote.urls) {
-		if (type === 'fetch') {
-			left = true;
-
-			if (right) break;
-		} else if (type === 'push') {
-			right = true;
-
-			if (left) break;
-		}
-	}
-
-	if (left && right) {
-		arrows = '\u21c4'; // ArrowsRightLeft
-	} else if (right) {
-		arrows = '\u2192'; // ArrowRight
-	} else if (left) {
-		arrows = '\u2190'; // ArrowLeft
-	} else {
-		arrows = '\u2014'; // Dash
-	}
-
-	return arrows;
-}
-
-export function getRemoteThemeIconString(remote: GitRemote | undefined): string {
-	return getRemoteProviderThemeIconString(remote?.provider);
-}
-
-export function getRemoteProviderThemeIconString(provider: RemoteProvider | undefined): string {
-	return provider != null ? `gitlens-provider-${provider.icon}` : 'cloud';
-}
-
-export function getRemoteUpstreamDescription(remote: GitRemote): string {
-	const arrows = getRemoteArrowsGlyph(remote);
-
-	const { provider } = remote;
-	if (provider != null) {
-		return `${arrows}\u00a0 ${provider.name} \u00a0\u2022\u00a0 ${provider.displayPath}`;
-	}
-
-	return `${arrows}\u00a0 ${remote.domain ? `${remote.domain} \u00a0\u2022\u00a0 ` : ''}${remote.path}`;
-}
-
-export function getVisibilityCacheKey(remote: GitRemote): string;
-export function getVisibilityCacheKey(remotes: GitRemote[]): string;
-export function getVisibilityCacheKey(remotes: GitRemote | GitRemote[]): string {
-	if (!Array.isArray(remotes)) return remotes.remoteKey;
-	return remotes
-		.map(r => r.remoteKey)
-		.sort()
-		.join(',');
-}
-
-export const gitSuffixRegex = /\.git\/?$/;
-
-// Test git urls
-/*
-http://host.xz/user/project.git
-https://host.xz/user/project.git
-git@host.xz:user/project.git
-git://host.xz/path/to/repo.git/
-ssh://host.xz/project.git
-ssh://user@host.xz/path/to/repo.git
-user@host.xz:path/to/repo.git
-*/
-export const remoteUrlRegex =
-	/^(?:(git:\/\/)(.*?)\/|(https?:\/\/)(?:.*?@)?(.*?)\/|git@(.*):|(ssh:\/\/)(?:.*@)?(.*?)(?::.*?)?(?:\/|(?=~))|(?:.*?@)(.*?):)(.*)$/;
-
-export function parseGitRemoteUrl(url: string): [scheme: string, domain: string, path: string] {
-	const match = remoteUrlRegex.exec(url);
-	if (match == null) return ['', '', url];
-
-	return [
-		match[1] || match[3] || match[6],
-		match[2] || match[4] || match[5] || match[7] || match[8],
-		match[9].replace(gitSuffixRegex, ''),
-	];
-}
-
-export function getNameFromRemoteResource(resource: RemoteResource): string {
-	switch (resource.type) {
-		case RemoteResourceType.Branch:
-			return 'Branch';
-		case RemoteResourceType.Branches:
-			return 'Branches';
-		case RemoteResourceType.Commit:
-			return 'Commit';
-		case RemoteResourceType.Comparison:
-			return 'Comparison';
-		case RemoteResourceType.CreatePullRequest:
-			return 'Create Pull Request';
-		case RemoteResourceType.File:
-			return 'File';
-		case RemoteResourceType.Repo:
-			return 'Repository';
-		case RemoteResourceType.Revision:
-			return 'File';
-		default:
-			return '';
-	}
-}

package/src/git/utils/repository.utils.ts

@@ -1,18 +0,0 @@
-import { normalizePath } from '../../utils/path.js';
-import type { Uri } from '../../utils/uri.js';
-
-export function getRepositoryOrWorktreePath(uri: Uri): string {
-	return uri.scheme === 'file' ? normalizePath(uri.fsPath) : uri.toString();
-}
-
-export function getCommonRepositoryPath(commonUri: Uri): string {
-	const uri = getCommonRepositoryUri(commonUri);
-	return getRepositoryOrWorktreePath(uri);
-}
-
-export function getCommonRepositoryUri(commonUri: Uri): Uri {
-	if (commonUri?.path.endsWith('/.git')) {
-		return commonUri.with({ path: commonUri.path.substring(0, commonUri.path.length - 5) });
-	}
-	return commonUri;
-}

package/src/git/utils/resourceDescriptor.utils.ts

@@ -1,26 +0,0 @@
-import type {
-	IssueResourceDescriptor,
-	RepositoryDescriptor,
-	ResourceDescriptor,
-} from '../models/resourceDescriptor.js';
-
-export function isRepositoryDescriptor(resource: ResourceDescriptor): resource is RepositoryDescriptor {
-	return (
-		'key' in resource &&
-		resource.key != null &&
-		'owner' in resource &&
-		resource.owner != null &&
-		'name' in resource &&
-		resource.name != null
-	);
-}
-export function isIssueResourceDescriptor(resource: ResourceDescriptor): resource is IssueResourceDescriptor {
-	return (
-		'key' in resource &&
-		resource.key != null &&
-		'id' in resource &&
-		resource.id != null &&
-		'name' in resource &&
-		resource.name != null
-	);
-}