Move all selection logic into a TS file

Author: Caleb-T-Owens

apps/desktop/src/components/v3/FileListItemWrapper.svelte

@@ -5,15 +5,15 @@
 	import { draggableChips } from '$lib/dragging/draggable';
 	import { ChangeDropData } from '$lib/dragging/draggables';
 	import { getFilename } from '$lib/files/utils';
-	import { previousPathBytesFromTreeChange, type TreeChange } from '$lib/hunks/change';
+	import { type TreeChange } from '$lib/hunks/change';
+	import { DiffService, type HunkGroup } from '$lib/hunks/diffService.svelte';
 	import {
-		DiffService,
-		hunkGroupToKey,
-		type HunkAssignments,
-		type HunkGroup
-	} from '$lib/hunks/diffService.svelte';
-	import { hunkHeaderEquals, type HunkHeader } from '$lib/hunks/hunk';
-	import { ChangeSelectionService, type SelectedHunk } from '$lib/selection/changeSelection.svelte';
+		someAssignedToCurrentGroupSelected,
+		ChangeSelectionService,
+		deselectAllForChangeInGroup,
+		selectAllForChangeInGroup,
+		allAssignedToCurrentGroupSelected
+	} from '$lib/selection/changeSelection.svelte';
 	import { IdSelection } from '$lib/selection/idSelection.svelte';
 	import { key, type SelectionId } from '$lib/selection/key';
 	import { TestId } from '$lib/testing/testIds';
@@ -89,9 +89,9 @@
 			? diffService.hunkAssignments(projectId, changesKeyResult.current)
 			: undefined;
 	});
-	const selection = $derived(changeSelection.getById(change.path));
 	const selectedChanges = $derived(idSelection.treeChanges(projectId, selectionId));
 	const isUncommitted = $derived(selectionId?.type === 'worktree');
+	const selectedFile = $derived(changeSelection.getById(change.path));
 
 	const previousTooltipText = $derived(
 		(change.status.subject as Rename).previousPath
@@ -109,189 +109,64 @@
 		return undefined;
 	});
 
-	function allAssignedToCurrentGroup(
-		assignments: HunkAssignments,
-		selectionId: SelectionId & { type: 'worktree' }
-	): boolean {
-		for (const [key, value] of assignments.entries()) {
-			if (key === hunkGroupToKey(selectionId.group)) continue;
-
-			if (value.has(change.path)) return false;
-		}
-
-		return true;
-	}
-
-	function allHunksForPath(assignments: HunkAssignments, except?: HunkGroup): HunkHeader[] {
-		const headers = [];
-
-		for (const [key, value] of assignments.entries()) {
-			if (except) {
-				if (key === hunkGroupToKey(except)) continue;
-			}
-
-			const assignments = value.get(change.path);
-			if (!assignments) continue;
-			headers.push(...assignments.map((assignment) => assignment.hunkHeader));
-		}
-
-		return headers;
-	}
-
-	function relevantHunkHeaders(
-		assignments: HunkAssignments,
-		selectionId: SelectionId & { type: 'worktree' }
-	): HunkHeader[] {
-		const stackGroup = assignments.get(hunkGroupToKey(selectionId.group));
-		if (!stackGroup) return [];
-		const hunkAssignments = stackGroup.get(change.path);
-
-		return hunkAssignments?.map((assignment) => assignment.hunkHeader) ?? [];
-	}
-
 	function onCheck() {
+		// TODO: Double check that we change partial hunk selections into whole
+		// hunk selections.
 		// Currently selection is only implemented for the worktree changes.
 		if (selectionId.type !== 'worktree') return;
 		if (!assignments?.current?.data) return;
 
-		// TODO: wtf do you do in the case where a whole group is selected, but
-		// a differently grouped hunk appears due to a disk change????
-		if (allAssignedToCurrentGroup(assignments.current.data, selectionId)) {
-			if (selection.current) {
-				changeSelection.remove(change.path);
-			} else {
-				const { path, pathBytes } = change;
-				changeSelection.upsert({
-					type: 'full',
-					path,
-					pathBytes,
-					previousPathBytes: previousPathBytesFromTreeChange(change)
-				});
-			}
+		if (
+			someAssignedToCurrentGroupSelected(
+				change,
+				selectionId.group,
+				assignments.current.data,
+				selectedFile.current
+			)
+		) {
+			deselectAllForChangeInGroup(
+				change,
+				selectionId.group,
+				assignments.current.data,
+				selectedFile.current,
+				changeSelection
+			);
 		} else {
-			// Handle selection/deselection when not all the hunks are assigned
-			// to the one group.
-			const relevantHeaders = relevantHunkHeaders(assignments.current.data, selectionId);
-			const { path, pathBytes } = change;
-			if (selection.current?.type === 'full') {
-				// Currently, all the hunks are selected; we want to replace the
-				// current selection with one that contains all the hunk hunk
-				// headers for this path _except_ for those in the current group
-				const hunkHeadersWithoutGroup = allHunksForPath(
-					assignments.current.data,
-					selectionId.group
-				);
-
-				changeSelection.upsert({
-					type: 'partial',
-					path,
-					pathBytes,
-					previousPathBytes: previousPathBytesFromTreeChange(change),
-					hunks: hunkHeadersWithoutGroup.map((header) => ({ ...header, type: 'full' }))
-				});
-			} else if (selection.current?.type === 'partial') {
-				const selectedHunks = selection.current.hunks;
-				// Handle selection/deselection when _some_ of the changes are
-				// selected for committing. We want to deselect if there are any
-				// hunks associated to the group already selected.
-
-				// TODO: Look at optimizing some of these N+1s
-				const includesRelevantHunks = selectedHunks.some((hunk) =>
-					relevantHeaders.some((header) => hunkHeaderEquals(header, hunk))
-				);
-
-				if (includesRelevantHunks) {
-					// We have found some selected hunks that are in the current
-					// group, so we want to filter them out of the current
-					// selection.
-					const selectionWithoutOwnedHunks = selectedHunks.filter(
-						(hunk) => !relevantHeaders.some((header) => hunkHeaderEquals(header, hunk))
-					);
-					if (selectionWithoutOwnedHunks.length === 0) {
-						// If there are no hunks left in the selection, then we
-						// can just clear the selection.
-						changeSelection.remove(path);
-					} else {
-						changeSelection.upsert({
-							type: 'partial',
-							path,
-							pathBytes,
-							previousPathBytes: previousPathBytesFromTreeChange(change),
-							hunks: selectionWithoutOwnedHunks
-						});
-					}
-				} else {
-					// We want to add the hunks that are associated with the
-					// current group to the selection.
-					const hunks: SelectedHunk[] = relevantHeaders.map((header) => ({
-						...header,
-						type: 'full'
-					}));
-					const combinedHunks = [...selection.current.hunks, ...hunks];
-					const allHunks = allHunksForPath(assignments.current.data);
-
-					if (combinedHunks.length === allHunks.length) {
-						// If all the hunks have ended up selected, let's
-						// replace it with a "full" selection.
-						changeSelection.upsert({
-							type: 'full',
-							path,
-							pathBytes,
-							previousPathBytes: previousPathBytesFromTreeChange(change)
-						});
-					} else {
-						changeSelection.upsert({
-							type: 'partial',
-							path,
-							pathBytes,
-							previousPathBytes: previousPathBytesFromTreeChange(change),
-							hunks: [...selection.current.hunks, ...hunks]
-						});
-					}
-				}
-			} else {
-				// There is no existing selection so we can simply select all
-				// the hunks belonging to the group
-				changeSelection.upsert({
-					type: 'partial',
-					path,
-					pathBytes,
-					previousPathBytes: previousPathBytesFromTreeChange(change),
-					hunks: relevantHeaders.map((header) => ({ ...header, type: 'full' }))
-				});
-			}
+			selectAllForChangeInGroup(
+				change,
+				selectionId.group,
+				assignments.current.data,
+				selectedFile.current,
+				changeSelection
+			);
 		}
 	}
 
 	const checkStatus = $derived.by((): 'checked' | 'indeterminate' | 'unchecked' => {
 		// Currently selection is only implemented for the worktree changes.
 		if (selectionId.type !== 'worktree') return 'unchecked';
 		if (!assignments?.current?.data) return 'unchecked';
-		const currentSelection = selection.current;
-		if (!currentSelection) return 'unchecked';
 
-		if (currentSelection.type === 'full') {
-			// If the selection type is "full", then we can assume that since
-			// this is rendered in the first place that it should indeed be
-			// checked.
+		if (
+			allAssignedToCurrentGroupSelected(
+				change,
+				selectionId.group,
+				assignments.current.data,
+				selectedFile.current
+			)
+		) {
 			return 'checked';
 		}
 
-		const relevantHeaders = relevantHunkHeaders(assignments.current.data, selectionId);
-
-		const includesRelevantHunks = currentSelection.hunks.some((hunk) =>
-			relevantHeaders.some((header) => hunkHeaderEquals(header, hunk))
-		);
-
-		if (includesRelevantHunks) {
-			const includesAllRelevantHunks = relevantHeaders.every((hunk) =>
-				currentSelection.hunks.some((header) => hunkHeaderEquals(header, hunk))
-			);
-			if (includesAllRelevantHunks) {
-				return 'checked';
-			} else {
-				return 'indeterminate';
-			}
+		if (
+			someAssignedToCurrentGroupSelected(
+				change,
+				selectionId.group,
+				assignments.current.data,
+				selectedFile.current
+			)
+		) {
+			return 'indeterminate';
 		}
 
 		return 'unchecked';

apps/desktop/src/components/v3/UnifiedDiffView.svelte

@@ -243,7 +243,9 @@
 		// We could have an encoding for hunk-headers that we can then put into
 		// a hash set.
 		return hunks.filter((hunk) =>
-			pathGroup.some((assignedHunk) => hunkHeaderEquals(hunk, assignedHunk.hunkHeader))
+			pathGroup.some((assignedHunk) =>
+				assignedHunk?.hunkHeader ? hunkHeaderEquals(hunk, assignedHunk.hunkHeader) : true
+			)
 		);
 	}
 </script>

apps/desktop/src/components/v3/WorktreeChanges.svelte

@@ -75,6 +75,7 @@
 		if (affectedPaths) {
 			untrack(() => {
 				changeSelection.retain(affectedPaths);
+				// TODO: We need to make this consider all groups
 				idSelection.retain(affectedPaths, { type: 'ungrouped' });
 			});
 		}

apps/desktop/src/lib/hunks/hunk.ts

@@ -98,7 +98,7 @@ export type HunkAssignment = {
 	/** The hunk that is being assigned. Together with path_bytes, this identifies the hunk.
 	 * If the file is binary, or too large to load, this will be None and in this case the path name is the only identity.
 	 */
-	readonly hunkHeader: HunkHeader;
+	readonly hunkHeader: HunkHeader | null;
 	/** The file path of the hunk. Used for display. */
 	readonly path: string;
 	/** The file path of the hunk in bytes. Used to correctly communicate to the backed when creating new assignments */