import type { FileDiffMetadata } from "@pierre/diffs";
import type {
FileTreeBatchOperation,
FileTreeIconConfig,
FileTreeSortComparator,
GitStatus,
} from "@pierre/trees";
import { resolveFileDiffPath } from "~/lib/diffRendering";
import { basenameOfPath, resolvePierreIconForEntry, T3_PIERRE_ICONS } from "~/pierre-icons";
export interface DiffFileTreeEntry {
readonly path: string;
readonly status: GitStatus;
}
function toGitStatus(file: FileDiffMetadata): GitStatus {
switch (file.type) {
case "new":
return "added";
case "deleted":
return "deleted";
case "rename-pure":
case "rename-changed":
return "renamed";
case "change":
return "modified";
}
}
export function diffFileTreeEntries(
files: ReadonlyArray<FileDiffMetadata>,
): ReadonlyArray<DiffFileTreeEntry> {
const statusByPath = new Map<string, GitStatus>();
for (const file of files) {
const path = resolveFileDiffPath(file);
const status = toGitStatus(file);
const previous = statusByPath.get(path);
statusByPath.set(path, previous === undefined || previous === status ? status : "modified");
}
return [...statusByPath].map(([path, status]) => ({ path, status }));
}
// Pierre cannot store a file and a directory at the same path. Give only those
// files an invisible suffix, keeping real paths at the diff/viewer boundary.
export function diffFileTreeModel(paths: ReadonlyArray<string>) {
const directories = new Set(collectDirectoryPaths(paths));
// Icon overrides match basenames case-insensitively, so aliases must also avoid
// real names in other directories, including names that already contain the suffix.
const occupiedNames = new Set(paths.flatMap((path) => path.toLowerCase().split("/")));
const selectionByModelPath = new Map<string, string>();
const modelBySelectionPath = new Map<string, string>();
const byFileName: FileTreeIconConfig["byFileName"] = { ...T3_PIERRE_ICONS.byFileName };
const modelPaths = paths.map((path) => {
if (!directories.has(`${path}/`)) return path;
let modelPath = path;
do {
modelPath += "\u200b";
} while (occupiedNames.has(basenameOfPath(modelPath).toLowerCase()));
occupiedNames.add(basenameOfPath(modelPath).toLowerCase());
selectionByModelPath.set(modelPath, path);
modelBySelectionPath.set(path, modelPath);
const icon = resolvePierreIconForEntry(path, "file");
if (icon !== null) byFileName[basenameOfPath(modelPath)] = icon;
return modelPath;
});
return {
paths: modelBySelectionPath.size === 0 ? paths : modelPaths,
selectionPath: (modelPath: string) => selectionByModelPath.get(modelPath) ?? modelPath,
modelPath: (path: string) => modelBySelectionPath.get(path) ?? path,
icons: modelBySelectionPath.size === 0 ? T3_PIERRE_ICONS : { ...T3_PIERRE_ICONS, byFileName },
};
}
export function collectDirectoryPaths(paths: ReadonlyArray<string>): ReadonlyArray<string> {
const directories = new Set<string>();
for (const path of paths) {
const segments = path.split("/");
let directory = "";
for (const segment of segments.slice(0, -1)) {
directory += `${segment}/`;
directories.add(directory);
}
}
return [...directories];
}
export function diffFileTreePositions(paths: ReadonlyArray<string>): ReadonlyMap<string, number> {
const positions = new Map<string, number>();
paths.forEach((path, index) => {
positions.set(path, index);
let directory = "";
for (const segment of path.split("/").slice(0, -1)) {
directory += `${segment}/`;
if (!positions.has(directory)) positions.set(directory, index);
}
});
return positions;
}
// A flat list in tree order: each directory stays contiguous, siblings ranked as
// compareDiffFileTreeEntries ranks them, so the list never disagrees with the tree.
export function orderDiffFilesLikeTree(
files: ReadonlyArray<FileDiffMetadata>,
): ReadonlyArray<FileDiffMetadata> {
const paths = files.map(resolveFileDiffPath);
const positions = diffFileTreePositions(paths);
const keys = paths.map((path) => {
const key: number[] = [];
let directory = "";
for (const segment of path.split("/").slice(0, -1)) {
directory += `${segment}/`;
key.push(positions.get(directory)!);
}
key.push(positions.get(path)!);
return key;
});
return files
.map((file, index) => ({ file, key: keys[index]! }))
.toSorted((left, right) => {
const length = Math.min(left.key.length, right.key.length);
for (let index = 0; index < length; index++) {
const difference = left.key[index]! - right.key[index]!;
if (difference !== 0) return difference;
}
return left.key.length - right.key.length;
})
.map(({ file }) => file);
}
export function compareDiffFileTreeEntries(
getPositions: () => ReadonlyMap<string, number>,
): FileTreeSortComparator {
return (left, right) => {
const positions = getPositions();
return (
(positions.get(left.path) ?? Number.MAX_SAFE_INTEGER) -
(positions.get(right.path) ?? Number.MAX_SAFE_INTEGER) ||
left.depth - right.depth ||
left.path.localeCompare(right.path)
);
};
}
function pathDepth(path: string): number {
return path.split("/").filter(Boolean).length;
}
export function buildDiffFileTreeUpdates(
previousPaths: ReadonlyArray<string>,
nextPaths: ReadonlyArray<string>,
): FileTreeBatchOperation[] {
const previousDirectories = new Set(collectDirectoryPaths(previousPaths));
const nextDirectories = new Set(collectDirectoryPaths(nextPaths));
const previous = new Set(previousPaths);
const next = new Set(nextPaths);
const updates: FileTreeBatchOperation[] = [];
for (const path of previousPaths) {
if (!next.has(path)) updates.push({ type: "remove", path });
}
const removedDirectories = [...previousDirectories]
.filter((directory) => !nextDirectories.has(directory))
.toSorted((left, right) => pathDepth(right) - pathDepth(left));
for (const directory of removedDirectories) {
updates.push({ type: "remove", path: directory, recursive: true });
}
const addedDirectories = [...nextDirectories]
.filter((directory) => !previousDirectories.has(directory))
.toSorted((left, right) => pathDepth(left) - pathDepth(right));
for (const directory of addedDirectories) updates.push({ type: "add", path: directory });
for (const path of nextPaths) {
if (!previous.has(path)) updates.push({ type: "add", path });
}
return updates;
}