@gitkraken/core-gitlens 0.1.0

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

@@ -0,0 +1,296 @@
+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

@@ -0,0 +1,154 @@
+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';
+
+const detachedHEADRegex = /^(HEAD|\(.*\))$/;
+
+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

@@ -0,0 +1,89 @@
+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/contributor.utils.ts

@@ -0,0 +1,81 @@
+import type { GitCommitStats } from '../models/commit.js';
+import type { GitContributionTiers, GitContributor, GitContributorsStats } from '../models/contributor.js';
+import type { GitUser } from '../models/user.js';
+
+export interface ContributorScoreOptions {
+	// Thresholds
+	recentThresholdInDays: number;
+	maxScoreNormalization: number;
+
+	// Time-based weights
+	recentWeight: number;
+
+	// Impact weights
+	additionsWeight: number;
+	deletionsWeight: number;
+}
+
+export const defaultContributorScoreOptions: ContributorScoreOptions = {
+	recentThresholdInDays: 30,
+	recentWeight: 1.5,
+	additionsWeight: 0.8,
+	deletionsWeight: 1.2,
+	maxScoreNormalization: 1000,
+};
+
+export function calculateContributionScore(
+	stats: GitCommitStats | undefined,
+	timestamp: number,
+	options: ContributorScoreOptions = defaultContributorScoreOptions,
+): number {
+	if (stats == null) return 0;
+
+	const now = Date.now();
+	const ageInDays = (now - timestamp) / (24 * 3600 * 1000);
+
+	// Time decay factor (exponential decay)
+	const recencyScore = Math.exp(-ageInDays / options.recentThresholdInDays);
+
+	// Impact score with weighted components
+	const impactScore = stats.additions * options.additionsWeight + stats.deletions * options.deletionsWeight;
+
+	return Math.min(impactScore * (1 + recencyScore * options.recentWeight), options.maxScoreNormalization);
+}
+
+export function calculateDistribution<T extends string>(
+	stats: GitContributorsStats | undefined,
+	prefix: T,
+): Record<`${typeof prefix}${GitContributionTiers}`, number> {
+	if (stats == null) return {} as unknown as Record<`${typeof prefix}${GitContributionTiers}`, number>;
+
+	const distribution: Record<`${string}${GitContributionTiers}`, number> = {
+		[`${prefix}[1]`]: 0,
+		[`${prefix}[2-5]`]: 0,
+		[`${prefix}[6-10]`]: 0,
+		[`${prefix}[11-50]`]: 0,
+		[`${prefix}[51-100]`]: 0,
+		[`${prefix}[101+]`]: 0,
+	};
+
+	for (const c of stats.contributions) {
+		if (c === 1) {
+			distribution[`${prefix}[1]`]++;
+		} else if (c <= 5) {
+			distribution[`${prefix}[2-5]`]++;
+		} else if (c <= 10) {
+			distribution[`${prefix}[6-10]`]++;
+		} else if (c <= 50) {
+			distribution[`${prefix}[11-50]`]++;
+		} else if (c <= 100) {
+			distribution[`${prefix}[51-100]`]++;
+		} else {
+			distribution[`${prefix}[101+]`]++;
+		}
+	}
+
+	return distribution;
+}
+
+export function matchContributor(c: GitContributor, user: GitUser): boolean {
+	return c.name === user.name && c.email === user.email && c.username === user.username;
+}

package/src/git/utils/fetch.utils.ts

@@ -0,0 +1,48 @@
+const millisecondsPerMinute = 60 * 1000;
+const millisecondsPerHour = 60 * 60 * 1000;
+export const millisecondsPerDay = 24 * 60 * 60 * 1000;
+
+/**
+ * Calculates the update interval for fetch status based on how long ago the last fetch occurred.
+ * Uses stepped intervals to prevent thrashing from frequent recalculations.
+ *
+ * @param lastFetched - Timestamp (in milliseconds) of the last fetch
+ * @returns Update interval in milliseconds
+ *
+ * Interval schedule:
+ * - < 15 minutes ago: refresh every 5 minutes
+ * - < 30 minutes ago: refresh every 10 minutes
+ * - < 1 hour ago: refresh every 20 minutes
+ * - < 3 hours ago: refresh every 1 hour
+ * - < 6 hours ago: refresh every 2 hours
+ * - < 12 hours ago: refresh every 4 hours
+ * - < 2 days ago: refresh every 8 hours
+ * - ≥ 2 days ago: refresh every 1 day
+ */
+export function getLastFetchedUpdateInterval(lastFetched: number): number {
+	const timeDiff = Date.now() - lastFetched;
+
+	// Stepped intervals to prevent thrashing
+	if (timeDiff < 15 * millisecondsPerMinute) {
+		return 5 * millisecondsPerMinute;
+	}
+	if (timeDiff < 30 * millisecondsPerMinute) {
+		return 10 * millisecondsPerMinute;
+	}
+	if (timeDiff < millisecondsPerHour) {
+		return 20 * millisecondsPerMinute;
+	}
+	if (timeDiff < 3 * millisecondsPerHour) {
+		return millisecondsPerHour;
+	}
+	if (timeDiff < 6 * millisecondsPerHour) {
+		return 2 * millisecondsPerHour;
+	}
+	if (timeDiff < 12 * millisecondsPerHour) {
+		return 4 * millisecondsPerHour;
+	}
+	if (timeDiff < 2 * millisecondsPerDay) {
+		return 8 * millisecondsPerHour;
+	}
+	return millisecondsPerDay;
+}