@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/src/git/utils/blame.utils.ts

@@ -1,298 +0,0 @@
-import { fnv1aHash } from '../../utils/hash.js';
-import type { GitBlame, GitBlameAuthor } from '../models/blame.js';
-import type { GitCommit, GitCommitLine } from '../models/commit.js';
-import { uncommitted } from '../models/revision.js';
-import type { DiffRange } from '../providers/types.js';
-
-/**
- * Filters a {@link GitBlame} object to only include lines within the given range.
- * This is a pure data transform — no I/O or provider access needed.
- *
- * @param blame - The full blame to filter
- * @param range - 1-based line range (inclusive)
- */
-export function getBlameRange(blame: GitBlame, range: DiffRange): GitBlame | undefined {
-	if (blame.lines.length === 0) return blame;
-
-	// DiffRange is 1-based; lines array is 0-indexed
-	const startIdx = range.startLine - 1;
-	const endIdx = range.endLine; // endLine is inclusive, slice is exclusive
-
-	if (startIdx === 0 && endIdx >= blame.lines.length) return blame;
-
-	const lines = blame.lines.slice(startIdx, endIdx);
-	const shas = new Set(lines.map(l => l.sha));
-
-	const authors = new Map<string, GitBlameAuthor>();
-	const commits = new Map<string, GitCommit>();
-	for (const c of blame.commits.values()) {
-		if (!shas.has(c.sha)) continue;
-
-		const commit = c.with({
-			lines: c.lines.filter(l => l.line >= range.startLine && l.line <= range.endLine),
-		});
-		commits.set(c.sha, commit);
-
-		let author = authors.get(commit.author.name);
-		if (author == null) {
-			author = {
-				name: commit.author.name,
-				lineCount: 0,
-				current: commit.author.current,
-			};
-			authors.set(author.name, author);
-		}
-
-		author.lineCount += commit.lines.length;
-	}
-
-	const sortedAuthors = new Map([...authors.entries()].sort((a, b) => b[1].lineCount - a[1].lineCount));
-
-	return {
-		repoPath: blame.repoPath,
-		authors: sortedAuthors,
-		commits: commits,
-		lines: lines,
-	};
-}
-
-/** Result of a line-level diff between baseline and dirty content */
-export interface LineMappingResult {
-	/** Number of matching lines at the start */
-	readonly prefixLen: number;
-	/** Number of matching lines at the end */
-	readonly suffixLen: number;
-	/** Start of changed region in baseline (0-based) */
-	readonly baseMiddleStart: number;
-	/** End of changed region in baseline (exclusive) */
-	readonly baseMiddleEnd: number;
-	/** Start of changed region in dirty (0-based) */
-	readonly dirtyMiddleStart: number;
-	/** End of changed region in dirty (exclusive) */
-	readonly dirtyMiddleEnd: number;
-	/**
-	 * For lines in the dirty middle section, maps dirty offset → baseline offset.
-	 * Undefined means the line is new/modified (uncommitted).
-	 * Indices are relative to the middle section starts.
-	 */
-	readonly middleMapping: (number | undefined)[];
-}
-
-/**
- * Line-level diff optimized for "mostly unchanged" content.
- *
- * Strategy:
- * 1. Strip common prefix (hash + string comparison)
- * 2. Strip common suffix (hash + string comparison)
- * 3. For the small middle section, use hash-map matching with string verification
- *
- * Performance: < 0.1ms for typical edits on files up to 5000 lines.
- */
-export function diffLineMapping(
-	baselineHashes: Uint32Array,
-	baselineLines: readonly string[],
-	dirtyLines: readonly string[],
-	dirtyHashes?: Uint32Array,
-): LineMappingResult {
-	if (dirtyHashes == null) {
-		dirtyHashes = new Uint32Array(dirtyLines.length);
-		for (let i = 0; i < dirtyLines.length; i++) {
-			dirtyHashes[i] = fnv1aHash(dirtyLines[i]);
-		}
-	}
-
-	const baseLen = baselineHashes.length;
-	const dirtyLen = dirtyHashes.length;
-	const minLen = Math.min(baseLen, dirtyLen);
-
-	// Common prefix scan — hash + string verification to avoid silent collision misattribution
-	let prefixLen = 0;
-	while (
-		prefixLen < minLen &&
-		baselineHashes[prefixLen] === dirtyHashes[prefixLen] &&
-		baselineLines[prefixLen] === dirtyLines[prefixLen]
-	) {
-		prefixLen++;
-	}
-
-	// Common suffix scan — hash + string verification
-	let suffixLen = 0;
-	const maxSuffix = minLen - prefixLen;
-	while (
-		suffixLen < maxSuffix &&
-		baselineHashes[baseLen - 1 - suffixLen] === dirtyHashes[dirtyLen - 1 - suffixLen] &&
-		baselineLines[baseLen - 1 - suffixLen] === dirtyLines[dirtyLen - 1 - suffixLen]
-	) {
-		suffixLen++;
-	}
-
-	const baseMiddleStart = prefixLen;
-	const baseMiddleEnd = baseLen - suffixLen;
-	const dirtyMiddleStart = prefixLen;
-	const dirtyMiddleEnd = dirtyLen - suffixLen;
-
-	const baseMiddleLen = baseMiddleEnd - baseMiddleStart;
-	const dirtyMiddleLen = dirtyMiddleEnd - dirtyMiddleStart;
-
-	const middleMapping: (number | undefined)[] = new Array(dirtyMiddleLen).fill(undefined);
-
-	if (baseMiddleLen > 0 && dirtyMiddleLen > 0) {
-		// Build a map from hash → list of baseline middle indices
-		const hashToBaseIndices = new Map<number, number[]>();
-		for (let i = 0; i < baseMiddleLen; i++) {
-			const h = baselineHashes[baseMiddleStart + i];
-			let indices = hashToBaseIndices.get(h);
-			if (indices == null) {
-				indices = [];
-				hashToBaseIndices.set(h, indices);
-			}
-			indices.push(i);
-		}
-
-		// For each dirty middle line, find a matching baseline line.
-		// Prefer same relative position first (handles identical lines like "}" or blank
-		// lines staying in place), then fall back to first available hash-map match.
-		const usedBaseIndices = new Set<number>();
-		for (let di = 0; di < dirtyMiddleLen; di++) {
-			const dh = dirtyHashes[dirtyMiddleStart + di];
-
-			// Positional bias: check same relative position first
-			if (
-				di < baseMiddleLen &&
-				!usedBaseIndices.has(di) &&
-				baselineHashes[baseMiddleStart + di] === dh &&
-				baselineLines[baseMiddleStart + di] === dirtyLines[dirtyMiddleStart + di]
-			) {
-				middleMapping[di] = di;
-				usedBaseIndices.add(di);
-				continue;
-			}
-
-			// Fall back to first available match from hash-map candidates
-			const candidates = hashToBaseIndices.get(dh);
-			if (candidates == null) continue;
-
-			for (const bi of candidates) {
-				if (usedBaseIndices.has(bi)) continue;
-
-				// Verify with string comparison (in case of hash collision)
-				if (baselineLines[baseMiddleStart + bi] === dirtyLines[dirtyMiddleStart + di]) {
-					middleMapping[di] = bi;
-					usedBaseIndices.add(bi);
-					break;
-				}
-			}
-		}
-	}
-
-	return {
-		prefixLen: prefixLen,
-		suffixLen: suffixLen,
-		baseMiddleStart: baseMiddleStart,
-		baseMiddleEnd: baseMiddleEnd,
-		dirtyMiddleStart: dirtyMiddleStart,
-		dirtyMiddleEnd: dirtyMiddleEnd,
-		middleMapping: middleMapping,
-	};
-}
-
-/**
- * Build a dirty blame result from a clean blame and a line mapping.
- */
-export function buildDirtyBlame(cleanBlame: GitBlame, mapping: LineMappingResult, dirtyLineCount: number): GitBlame {
-	const dirtyBlameLines: GitCommitLine[] = new Array(dirtyLineCount);
-	const commits = new Map(cleanBlame.commits);
-
-	// Prefix lines — direct mapping
-	for (let i = 0; i < mapping.prefixLen; i++) {
-		const cleanLine = cleanBlame.lines[i];
-		if (cleanLine != null) {
-			dirtyBlameLines[i] = { ...cleanLine, line: i + 1 };
-		} else {
-			dirtyBlameLines[i] = makeUncommittedLine(i);
-		}
-	}
-
-	// Middle section — use the mapping
-	const dirtyMiddleLen = mapping.dirtyMiddleEnd - mapping.dirtyMiddleStart;
-	for (let di = 0; di < dirtyMiddleLen; di++) {
-		const dirtyIdx = mapping.dirtyMiddleStart + di;
-		const baseOffset = mapping.middleMapping[di];
-
-		if (baseOffset != null) {
-			const baseIdx = mapping.baseMiddleStart + baseOffset;
-			const cleanLine = cleanBlame.lines[baseIdx];
-			if (cleanLine != null) {
-				dirtyBlameLines[dirtyIdx] = { ...cleanLine, line: dirtyIdx + 1 };
-			} else {
-				dirtyBlameLines[dirtyIdx] = makeUncommittedLine(dirtyIdx);
-			}
-		} else {
-			dirtyBlameLines[dirtyIdx] = makeUncommittedLine(dirtyIdx);
-		}
-	}
-
-	// Suffix lines — direct mapping from end
-	const baseLen = cleanBlame.lines.length;
-	for (let si = 0; si < mapping.suffixLen; si++) {
-		const dirtyIdx = dirtyLineCount - mapping.suffixLen + si;
-		const baseIdx = baseLen - mapping.suffixLen + si;
-		const cleanLine = cleanBlame.lines[baseIdx];
-		if (cleanLine != null) {
-			dirtyBlameLines[dirtyIdx] = { ...cleanLine, line: dirtyIdx + 1 };
-		} else {
-			dirtyBlameLines[dirtyIdx] = makeUncommittedLine(dirtyIdx);
-		}
-	}
-
-	// Recompute line counts per sha and authors
-	const lineCountsBySha = new Map<string, number>();
-	for (const blameLine of dirtyBlameLines) {
-		if (blameLine == null) continue;
-
-		lineCountsBySha.set(blameLine.sha, (lineCountsBySha.get(blameLine.sha) ?? 0) + 1);
-	}
-
-	const authors = new Map<string, GitBlameAuthor>();
-	for (const [sha, lineCount] of lineCountsBySha) {
-		if (sha === uncommitted) {
-			const uncommittedCommit = commits.get(uncommitted);
-			const userName = uncommittedCommit?.author.name ?? '';
-			authors.set(userName, { name: userName, lineCount: lineCount, current: true });
-			continue;
-		}
-
-		const c = commits.get(sha);
-		if (!c?.author.name) continue;
-
-		const existing = authors.get(c.author.name);
-		if (existing != null) {
-			existing.lineCount += lineCount;
-		} else {
-			authors.set(c.author.name, { name: c.author.name, lineCount: lineCount, current: c.author.current });
-		}
-	}
-
-	// Include authors from commits that have no lines in the dirty blame (zero lineCount)
-	for (const [, c] of commits) {
-		if (!c.author.name) continue;
-		if (authors.has(c.author.name)) continue;
-
-		authors.set(c.author.name, { name: c.author.name, lineCount: 0, current: c.author.current });
-	}
-
-	return {
-		repoPath: cleanBlame.repoPath,
-		authors: authors,
-		commits: commits,
-		lines: dirtyBlameLines,
-	};
-}
-
-function makeUncommittedLine(dirtyIndex: number): GitCommitLine {
-	return {
-		sha: uncommitted,
-		line: dirtyIndex + 1,
-		originalLine: 0,
-	};
-}

package/src/git/utils/branch.utils.ts

@@ -1,165 +0,0 @@
-import type { PageableResult } from '../../utils/paging.js';
-import type { GitBranch, GitTrackingUpstream } from '../models/branch.js';
-import type { GitBranchReference, GitReference } from '../models/reference.js';
-import { shortenRevision } from './revision.utils.js';
-
-/**
- * The names git uses where a branch name would go when HEAD isn't on a branch — `(HEAD detached
- * at|from <rev>)`, `(no branch)`, `(no branch, rebasing <name>)`, `(no branch, bisect started on
- * <name>)`, and `git status --porcelain=v2`'s `branch.head` token `(detached)` — plus bare `HEAD`
- * and our own {@link formatDetachedHeadName} output (`(<rev>...)`).
- *
- * Deliberately NOT "anything parenthesized": parentheses are legal in ref names, so `(release)`,
- * `v1.0(rc)` and `feat/(wip)` are all real branches a user can be on. Matching those made
- * `GitBranch` rewrite a genuine branch's `name` to the synthesized `(sha…)` label and re-key its
- * `id` by SHA, which corrupts its identity for every downstream consumer.
- */
-const detachedHEADRegex = /^(?:HEAD|\(detached\)|\(HEAD detached (?:at|from) .+\)|\(no branch.*\)|\(.+\.\.\.\))$/;
-
-export function formatDetachedHeadName(sha: string): string {
-	return `(${shortenRevision(sha)}...)`;
-}
-
-export function getBranchId(repoPath: string, remote: boolean, name: string): string {
-	return `${repoPath}|${remote ? 'remotes/' : 'heads/'}${name}`;
-}
-
-export function getBranchNameAndRemote(ref: GitBranchReference): [name: string, remote: string | undefined] {
-	if (ref.remote) {
-		const index = getRemoteNameSlashIndex(ref.name);
-		if (index === -1) return [ref.name, undefined];
-
-		return [ref.name.substring(index + 1), ref.name.substring(0, index)];
-	}
-
-	if (ref.upstream?.name != null) {
-		const index = getRemoteNameSlashIndex(ref.upstream.name);
-		if (index === -1) return [ref.name, undefined];
-
-		return [ref.name, ref.upstream.name.substring(0, index)];
-	}
-
-	return [ref.name, undefined];
-}
-
-export function getBranchNameWithoutRemote(name: string): string {
-	return name.substring(getRemoteNameSlashIndex(name) + 1);
-}
-
-export function getBranchTrackingWithoutRemote(ref: GitBranchReference): string | undefined {
-	return ref.upstream?.name.substring(getRemoteNameSlashIndex(ref.upstream.name) + 1);
-}
-
-export function getRemoteNameFromBranchName(name: string): string {
-	return name.substring(0, getRemoteNameSlashIndex(name));
-}
-
-export function getRemoteNameSlashIndex(name: string): number {
-	return name.startsWith('remotes/') ? name.indexOf('/', 8) : name.indexOf('/');
-}
-
-export function isDetachedHead(name: string): boolean {
-	// If there is whitespace in the name assume this is not a valid branch name
-	// Deals with detached HEAD states
-	name = name.trim();
-	return name.length ? detachedHEADRegex.test(name) : true;
-}
-
-export function isOfBranchRefType(branch: GitReference | undefined): branch is GitBranchReference {
-	return branch?.refType === 'branch';
-}
-
-const localBranchesPrefixRegex = /^(refs\/)?heads\//i;
-const remoteBranchesPrefixRegex = /^(refs\/)?remotes\//i;
-const remoteHEADRegex = /^(refs\/)?remotes\/(.*\/)HEAD$/i;
-
-export function isRemoteBranch(refName: string): boolean {
-	return remoteBranchesPrefixRegex.test(refName);
-}
-
-export function isRemoteHEAD(refName: string): boolean {
-	return remoteHEADRegex.test(refName);
-}
-
-export function parseRefName(refName: string): { name: string; remote: boolean } {
-	const remote = isRemoteBranch(refName);
-
-	let name;
-	if (remote) {
-		// Strip off refs/remotes/
-		name = refName.replace(remoteBranchesPrefixRegex, '');
-	} else {
-		// Strip off refs/heads/
-		name = refName.replace(localBranchesPrefixRegex, '');
-	}
-
-	return { name: name, remote: remote };
-}
-
-export async function getLocalBranchByUpstream(
-	remoteBranchName: string,
-	branches: PageableResult<GitBranch> | ReadonlyMap<unknown, GitBranch>,
-): Promise<GitBranch | undefined> {
-	let qualifiedRemoteBranchName;
-	if (remoteBranchName.startsWith('remotes/')) {
-		qualifiedRemoteBranchName = remoteBranchName;
-		remoteBranchName = remoteBranchName.substring(8);
-	} else {
-		qualifiedRemoteBranchName = `remotes/${remoteBranchName}`;
-	}
-
-	function matches(branch: GitBranch): boolean {
-		return (
-			!branch.remote &&
-			branch.upstream?.name != null &&
-			(branch.upstream.name === remoteBranchName || branch.upstream.name === qualifiedRemoteBranchName!)
-		);
-	}
-
-	const values = branches.values();
-	if (Symbol.asyncIterator in values) {
-		for await (const branch of values) {
-			if (matches(branch)) return branch;
-		}
-	} else {
-		for (const branch of values) {
-			if (matches(branch)) return branch;
-		}
-	}
-
-	return undefined;
-}
-
-export async function getLocalBranchUpstreamNames(branches: PageableResult<GitBranch>): Promise<Set<string>> {
-	const remoteBranches = new Set<string>();
-
-	for await (const branch of branches.values()) {
-		if (!branch.remote && branch.upstream?.name != null) {
-			remoteBranches.add(branch.upstream.name);
-		}
-	}
-
-	return remoteBranches;
-}
-
-const trackingStateRegex = /(?:\[(?:ahead ([0-9]+))?[,\s]*(?:behind ([0-9]+))?]|\[(gone)])/;
-
-export function parseUpstream(upstream: string, tracking: string): GitTrackingUpstream | undefined {
-	if (!upstream) return undefined;
-
-	const { name } = parseRefName(upstream);
-
-	const match = trackingStateRegex.exec(tracking);
-	if (match == null) {
-		return { name: name, missing: false, state: { ahead: 0, behind: 0 } };
-	}
-
-	const ahead = match[1] == null ? 0 : Number(match[1]);
-	const behind = match[2] == null ? 0 : Number(match[2]);
-
-	return {
-		name: name,
-		missing: match[3] != null,
-		state: { ahead: isNaN(ahead) ? 0 : ahead, behind: isNaN(behind) ? 0 : behind },
-	};
-}

package/src/git/utils/commit.utils.ts

@@ -1,89 +0,0 @@
-import type { GitCommitFileset, GitCommitStats, GitCommitWithFullDetails } from '../models/commit.js';
-import { GitCommit, GitCommitIdentity } from '../models/commit.js';
-import type { GitReference } from '../models/reference.js';
-import { uncommittedStaged } from '../models/revision.js';
-import type { GitUser } from '../models/user.js';
-
-export type CurrentUserNameStyle = 'you' | 'name' | 'nameAndYou';
-
-export function formatCurrentUserDisplayName(name: string, style: CurrentUserNameStyle): string {
-	switch (style) {
-		case 'name':
-			return name;
-		case 'nameAndYou':
-			if (name === 'You' || name.endsWith(' (you)')) {
-				debugger;
-				return name;
-			}
-			return name ? `${name} (you)` : 'You';
-		case 'you':
-		default:
-			return 'You';
-	}
-}
-
-export function formatIdentityDisplayName(
-	identity: { name: string; current?: boolean | undefined },
-	style: CurrentUserNameStyle,
-): string {
-	return identity.current ? formatCurrentUserDisplayName(identity.name, style) : identity.name;
-}
-
-export function assertsCommitHasFullDetails(commit: GitCommit): asserts commit is GitCommitWithFullDetails {
-	if (!commit.hasFullDetails()) {
-		throw new Error(`GitCommit(${commit.sha}) is not fully loaded`);
-	}
-}
-
-export function getChangedFilesCount(changedFiles: GitCommitStats['files'] | undefined): number {
-	if (changedFiles == null) return 0;
-
-	return typeof changedFiles === 'number'
-		? changedFiles
-		: changedFiles.added + changedFiles.changed + changedFiles.deleted;
-}
-
-export function isOfCommitOrStashRefType(commit: GitReference | undefined): boolean {
-	return commit?.refType === 'revision' || commit?.refType === 'stash';
-}
-
-/**
- * use `\n` symbol is presented to split commit message to description and title
- */
-export function splitCommitMessage(commitMessage?: string): { summary: string; body?: string } {
-	if (!commitMessage) return { summary: '' };
-
-	const message = commitMessage.trim();
-	const index = message.indexOf('\n');
-	if (index < 0) return { summary: message };
-
-	return {
-		summary: message.substring(0, index),
-		body: message.substring(index + 1).trim(),
-	};
-}
-
-export function createUncommittedChangesCommit(
-	repoPath: string,
-	sha: string,
-	now: Date,
-	user: GitUser | undefined,
-	options?: {
-		fileset?: GitCommitFileset;
-		parents?: string[];
-		stats?: GitCommitStats;
-	},
-): GitCommit {
-	return new GitCommit(
-		repoPath,
-		sha,
-		new GitCommitIdentity(user?.name ?? '', user?.email ?? undefined, now, undefined, true),
-		new GitCommitIdentity(user?.name ?? '', user?.email ?? undefined, now, undefined, true),
-		'Uncommitted changes',
-		options?.parents ?? (sha === uncommittedStaged ? ['HEAD'] : []),
-		'Uncommitted changes',
-		options?.fileset,
-		options?.stats,
-		[],
-	);
-}

package/src/git/utils/config.utils.ts

@@ -1,8 +0,0 @@
-const falseValues = new Set(['', 'false', 'no', 'off', '0']);
-
-/** Interprets a git config value with git's boolean semantics; `undefined` in → `undefined` out (unset). */
-export function parseGitBoolean(value: string | null | undefined): boolean | undefined {
-	if (value == null) return undefined;
-
-	return !falseValues.has(value.trim().toLowerCase());
-}