fix: fallback to debounced diff for slow diffs

Author: Vinzent03

package.json

@@ -47,7 +47,7 @@
     },
     "dependencies": {
         "@codemirror/commands": "^6.8.1",
-        "@codemirror/merge": "^6.10.2",
+        "@codemirror/merge": "^6.11.2",
         "@codemirror/search": "^6.5.11",
         "@codemirror/state": "^6.5.2",
         "@codemirror/view": "^6.38.1",

pnpm-lock.yaml

@@ -189,6 +189,11 @@ export function rawHunkFromChunk(
     return rawHunk;
 }
 
+const diffConfig = {
+    scanLimit: 1000,
+    timeout: 200,
+};
+
 function diffViaCMMerge(
     textA: string,
     textB: string,
@@ -199,8 +204,8 @@ function diffViaCMMerge(
     const bDoc = Text.of(textB.split("\n"));
     const newChunks =
         chunks && changes
-            ? Chunk.updateB(chunks, aDoc, bDoc, changes)
-            : Chunk.build(aDoc, bDoc);
+            ? Chunk.updateB(chunks, aDoc, bDoc, changes, diffConfig)
+            : Chunk.build(aDoc, bDoc, diffConfig);
     const rawHunks: RawHunk[] = [];
     for (let i = 0; i < newChunks.length; i++) {
         const chunk = newChunks[i];
@@ -220,7 +225,8 @@ export function computeHunks(
     chunks: readonly Chunk[] | undefined,
     changes: ChangeDesc | undefined
 ): { hunks: Hunk[]; chunks: readonly Chunk[] } {
-    return diffViaCMMerge(textA, textB, chunks, changes);
+    const res = diffViaCMMerge(textA, textB, chunks, changes);
+    return res;
     // const lineDiff = diff.diffLines(textA, textB, {
     //     newlineIsToken: true,
     // });

src/editor/signs/diff.ts

@@ -2,7 +2,7 @@ import { RangeSet, StateField, Transaction } from "@codemirror/state";
 import { EditorView, gutter, GutterMarker } from "@codemirror/view";
 import { Hunks, type Hunk, type SignType } from "./hunks";
 import {
-    GitCompareResultEffectType,
+    DebouncedComputeHunksEffectType,
     hunksState,
     HunksStateHelper,
 } from "./signs";
@@ -35,10 +35,14 @@ export const signsMarker = StateField.define({
         if (!data) {
             return RangeSet.empty;
         }
-        const isNewCompare = tr.effects.some((effect) =>
-            effect.is(GitCompareResultEffectType)
+        const newDebouncedHunks = tr.effects.some((effect) =>
+            effect.is(DebouncedComputeHunksEffectType)
         );
-        if (tr.docChanged || isNewCompare) {
+
+        if (
+            newDebouncedHunks ||
+            ((tr.docChanged || rangeSet.size == 0) && data.isDirty == false)
+        ) {
             const linesWithSign = new Set<number>();
             const markers = getMarkers(tr, data.hunks, false, linesWithSign);
             const stagedMarkers = getMarkers(
@@ -49,6 +53,8 @@ export const signsMarker = StateField.define({
             );
             rangeSet = RangeSet.of([...markers, ...stagedMarkers], true);
             return rangeSet;
+        } else if (tr.docChanged) {
+            rangeSet = rangeSet.map(tr.changes);
         }
         return rangeSet;
     },

src/editor/signs/gutter.ts

@@ -1,4 +1,5 @@
 import {
+    ChangeDesc,
     EditorState,
     StateEffect,
     StateField,
@@ -9,7 +10,12 @@ import { Hunks, type Hunk } from "../signs/hunks";
 import { computeHunks } from "./diff";
 import type { Chunk } from "@codemirror/merge";
 import { pluginRef } from "src/pluginGlobalRef";
-import { editorInfoField } from "obsidian";
+import {
+    debounce,
+    editorEditorField,
+    editorInfoField,
+    type Debouncer,
+} from "obsidian";
 
 /**
  * Given a document and a position, return the corresponding line number in the
@@ -27,7 +33,7 @@ export function lineFromPos(doc: Text, pos: number): number {
 export abstract class HunksStateHelper {
     static hasHunksData(state: EditorState): boolean {
         const data = state.field(hunksState, false);
-        return !!data;
+        return !!data && !data.isDirty;
     }
 
     static getHunks(state: EditorState, staged: boolean): Hunk[] {
@@ -142,70 +148,205 @@ export const hunksState: StateField<HunksData | undefined> = StateField.define<
 >({
     create: (_state) => undefined,
     update: (previous, transaction) => {
-        const prev: HunksData = previous
+        const hunksData: HunksData = previous
             ? { ...previous }
             : {
+                  maxDiffTimeMs: 0,
                   hunks: [],
                   stagedHunks: [],
                   chunks: undefined,
+                  isDirty: false,
               };
         let newCompare = false;
 
         for (const effect of transaction.effects) {
             if (effect.is(GitCompareResultEffectType)) {
-                newCompare = true;
-                prev.compareText = effect.value.compareText;
-                prev.compareTextHead = effect.value.compareTextHead;
+                hunksData.compareText = effect.value.compareText;
+                hunksData.compareTextHead = effect.value.compareTextHead;
+
+                // Only issue new hunk computation if compareText has changed
+                newCompare = previous?.compareText !== effect.value.compareText;
+                if (newCompare) {
+                    hunksData.chunks = undefined;
+                }
             }
-        }
-        if (prev.compareText !== undefined) {
-            const editorText = transaction.state.doc.toString();
-            if (newCompare) {
-                prev.chunks = undefined;
+            if (effect.is(DebouncedComputeHunksEffectType)) {
+                applyHunkComputation(
+                    hunksData,
+                    effect.value,
+                    transaction.state
+                );
             }
+        }
+        if (hunksData.compareText !== undefined) {
             if (newCompare || transaction.docChanged) {
-                const { hunks, chunks } = computeHunks(
-                    prev.compareText,
-                    editorText,
-                    prev.chunks,
-                    transaction.changes
-                );
-                // const headHunks = computeHunks(
-                //     prev.compareTextHead ?? "",
-                //     editorText
-                // );
-                prev.hunks = hunks;
-                prev.chunks = chunks;
-                // prev.stagedHunks = Hunks.computeStagedHunks(
-                //     headHunks,
-                //     hunks,
-                //     prev
-                // );
-
-                const file = transaction.state.field(editorInfoField).file;
-                pluginRef.plugin?.editorIntegration.signsFeature.changeStatusBar?.display(
-                    hunks,
-                    file
+                hunksData.isDirty = true;
+                const res = scheduleHunkComputation(
+                    transaction,
+                    hunksData.compareText,
+                    hunksData.chunks,
+                    hunksData.maxDiffTimeMs
                 );
+                if (res) {
+                    applyHunkComputation(hunksData, res, transaction.state);
+                }
             }
         } else {
-            prev.compareText = undefined;
-            prev.compareTextHead = undefined;
-            prev.chunks = undefined;
-            prev.hunks = [];
-            prev.stagedHunks = [];
+            hunksData.compareText = undefined;
+            hunksData.compareTextHead = undefined;
+            hunksData.chunks = undefined;
+            hunksData.hunks = [];
+            hunksData.stagedHunks = [];
+            hunksData.isDirty = false;
         }
-        return prev;
+        return hunksData;
     },
 });
 
+function applyHunkComputation(
+    hunkData: HunksData,
+    computeData: ComputedHunksData,
+    state: EditorState
+) {
+    hunkData.hunks = computeData.hunks;
+    hunkData.chunks = computeData.chunks;
+    hunkData.isDirty = false;
+    hunkData.maxDiffTimeMs = Math.max(
+        0.95 * hunkData.maxDiffTimeMs,
+        computeData.diffDuration
+    );
+    const file = state.field(editorInfoField).file;
+    pluginRef.plugin?.editorIntegration.signsFeature.changeStatusBar?.display(
+        hunkData.hunks,
+        file
+    );
+}
+
+export const computeHunksDebouncerStateField = StateField.define<{
+    changeDesc?: ChangeDesc;
+    debouncer: Debouncer<
+        [
+            {
+                state: EditorState;
+                compareText: string;
+                previousChunks: readonly Chunk[] | undefined;
+                changeDesc: ChangeDesc | undefined;
+            },
+        ],
+        void
+    >;
+}>({
+    create: () => {
+        return {
+            debouncer: debounce(
+                (data) => {
+                    const { state, compareText, previousChunks, changeDesc } =
+                        data;
+                    const res = computeHunksTimed(
+                        state,
+                        compareText,
+                        previousChunks,
+                        changeDesc
+                    );
+                    state.field(editorEditorField).dispatch({
+                        effects: DebouncedComputeHunksEffectType.of(res),
+                    });
+                },
+                1000,
+                true
+            ),
+            maxDiffTimeMs: 0,
+        };
+    },
+    update: (data, transaction) => {
+        for (const effect of transaction.effects) {
+            if (effect.is(DebouncedComputeHunksEffectType)) {
+                data.changeDesc = undefined;
+                return data;
+            }
+        }
+        if (!data.changeDesc && transaction.changes) {
+            data.changeDesc = transaction.changes;
+        } else {
+            data.changeDesc = data.changeDesc?.composeDesc(transaction.changes);
+        }
+        return data;
+    },
+});
+
+function computeHunksTimed(
+    state: EditorState,
+    compareText: string,
+    previousChunks: readonly Chunk[] | undefined,
+    changeDesc: ChangeDesc | undefined
+): ComputedHunksData {
+    const editorText = state.doc.toString();
+
+    const startTime = performance.now();
+    const { hunks, chunks } = computeHunks(
+        compareText,
+        editorText,
+        previousChunks,
+        changeDesc
+    );
+    const diffDuration = performance.now() - startTime;
+    return { hunks, chunks, diffDuration };
+}
+
+function scheduleHunkComputation(
+    transaction: Transaction,
+    compareText: string,
+    previousChunks: readonly Chunk[] | undefined,
+    maxDiffTimeMs: number
+): ComputedHunksData | undefined {
+    const state = transaction.state;
+    const changeLength = Math.abs(
+        transaction.changes.length - transaction.changes.newLength
+    );
+
+    const debouncerField = state.field(computeHunksDebouncerStateField);
+
+    // Debounce large changes or if a previous diff took long time
+    if (changeLength > 1000 || maxDiffTimeMs > 10) {
+        debouncerField.debouncer({
+            state,
+            compareText,
+            previousChunks,
+            changeDesc: debouncerField.changeDesc,
+        });
+    } else {
+        // This technically breaks the immutability of the StateField, but I
+        // think it's acceptable here. The debouncer itself is not very
+        // immutable either way.
+        debouncerField.changeDesc = undefined;
+
+        return computeHunksTimed(
+            state,
+            compareText,
+            previousChunks,
+            transaction.changes
+        );
+    }
+}
+
 export const GitCompareResultEffectType =
     StateEffect.define<GitCompareResult>();
 
+export const DebouncedComputeHunksEffectType =
+    StateEffect.define<ComputedHunksData>();
+
+export type ComputedHunksData = {
+    hunks: Hunk[];
+    chunks: readonly Chunk[] | undefined;
+    diffDuration: number;
+};
+
 export type HunksData = {
     hunks: Hunk[];
     stagedHunks: Hunk[];
     chunks: readonly Chunk[] | undefined;
+    isDirty: boolean;
+    maxDiffTimeMs: number;
 } & GitCompareResult;
 
 export type GitCompareResult = {