Fix sequence diff alignment (#493)

* Fix sequence diff alignment

* Align sequence diff with Toolbox

Author: younes-io

src/model/check.ts

@@ -581,13 +581,7 @@ function findSetChanges(prev: SetValue, state: SetValue): boolean {
 /**
  * Recursively finds and marks all the changes between two collections.
  */
-export function findChanges(prev: CollectionValue, state: CollectionValue): boolean {
-    // Special handling for sets - they are unordered collections
-    if (prev instanceof SetValue && state instanceof SetValue) {
-        return findSetChanges(prev, state);
-    }
-
-    // For other collections (sequences, structures), use ordered comparison
+function findOrderedChanges(prev: CollectionValue, state: CollectionValue): boolean {
     let pi = 0;
     let si = 0;
     let modified = false;
@@ -630,6 +624,92 @@ export function findChanges(prev: CollectionValue, state: CollectionValue): bool
     return modified;
 }
 
+function findSequenceChanges(prev: SequenceValue, state: SequenceValue): boolean {
+    const prevItems = prev.items;
+    const stateItems = state.items;
+    if (prevItems.length === stateItems.length) {
+        return findOrderedChanges(prev, state);
+    }
+
+    let shorter = prevItems;
+    let longer = stateItems;
+    let firstShorter = true;
+    if (prevItems.length > stateItems.length) {
+        shorter = stateItems;
+        longer = prevItems;
+        firstShorter = false;
+    }
+
+    let isPrefix = true;
+    for (let i = 0; i < shorter.length; i++) {
+        if (shorter[i].str !== longer[i].str) {
+            isPrefix = false;
+            break;
+        }
+    }
+
+    let isSuffix = true;
+    for (let i = 0; i < shorter.length; i++) {
+        if (shorter[i].str !== longer[i + longer.length - shorter.length].str) {
+            isSuffix = false;
+            break;
+        }
+    }
+
+    if (isPrefix && isSuffix) {
+        if (firstShorter) {
+            isSuffix = false;
+        } else {
+            isPrefix = false;
+        }
+    } else if (!(isPrefix || isSuffix)) {
+        return findOrderedChanges(prev, state);
+    }
+
+    let modified = false;
+    const firstEltToMark = isPrefix ? shorter.length : 0;
+    const diffCount = longer.length - shorter.length;
+    if (firstShorter) {
+        for (let i = 0; i < diffCount; i++) {
+            stateItems[firstEltToMark + i].changeType = Change.ADDED;
+            modified = true;
+        }
+    } else {
+        const deletedItems: Value[] = [];
+        for (let i = 0; i < diffCount; i++) {
+            deletedItems.push(prevItems[firstEltToMark + i]);
+        }
+        if (deletedItems.length > 0) {
+            state.addDeletedItems(deletedItems);
+            modified = true;
+        }
+    }
+    if (modified) {
+        state.changeType = Change.MODIFIED;
+    }
+    return modified;
+}
+
+/**
+ * Recursively finds and marks all the changes between two collections.
+ */
+export function findChanges(prev: CollectionValue, state: CollectionValue): boolean {
+    // Special handling for sets - they are unordered collections
+    if (prev instanceof SetValue && state instanceof SetValue) {
+        return findSetChanges(prev, state);
+    }
+
+    if (prev instanceof SequenceValue && state instanceof SequenceValue) {
+        if (prev.items.length === state.items.length) {
+            return findOrderedChanges(prev, state);
+        }
+        return findSequenceChanges(prev, state);
+    }
+
+    // For other collections (structures, functions), use ordered comparison
+    return findOrderedChanges(prev, state);
+}
+
 function dateTimeToStr(dateTime: Moment | undefined): string {
     if (!dateTime) {
         return 'not yet';

src/webview/checkResultView/errorTraceSection/errorTraceVariable.tsx

@@ -50,8 +50,9 @@ export const ErrorTraceVariable = React.memo(({ value, stateId, settings }: Erro
     const changeHintKey = value.changeType as keyof typeof changeHints;
     const changeHint = changeHints[changeHintKey] ?? '';
     const changeTypeClass = 'value-' + value.changeType;
+    const isSequence = value.prefix === '<<' && value.postfix === '>>';
     const hasValueChildren = hasVariableChildrenToDisplay(value);
-    const hasDeletedChildren = Array.isArray(value.deletedItems) && value.deletedItems.length > 0;
+    const hasDeletedChildren = !isSequence && Array.isArray(value.deletedItems) && value.deletedItems.length > 0;
     const hasChildren = hasValueChildren || hasDeletedChildren;
 
     return (
@@ -97,7 +98,7 @@ export const ErrorTraceVariable = React.memo(({ value, stateId, settings }: Erro
                             stateId={stateId}
                             settings={settings} />)}
 
-            {value.deletedItems &&
+            {!isSequence && value.deletedItems &&
                 value.deletedItems.map(
                     (childValue) =>
                         <ErrorTraceVariable

tests/suite/model/check.test.ts

@@ -93,6 +93,46 @@ suite('Check Model Test Suite', () => {
         );
     });
 
+    test('Sequence diff treats head deletion as deletion only (value-based)', () => {
+        const expected = seqX(ROOT, Change.MODIFIED,
+            vX(1, Change.NOT_CHANGED, '2'),
+            vX(2, Change.NOT_CHANGED, '3')
+        );
+        expected.addDeletedItems([v(1, '1')]);
+        assertChanges(
+            seq(ROOT, v(1, '1'), v(2, '2'), v(3, '3')),
+            seq(ROOT, v(1, '2'), v(2, '3')),
+            expected
+        );
+    });
+
+    test('Sequence diff treats middle deletion as function diff when not prefix/suffix', () => {
+        const expected = seqX(ROOT, Change.MODIFIED,
+            vX(1, Change.NOT_CHANGED, '1'),
+            vX(2, Change.MODIFIED, '3'),
+            vX(3, Change.MODIFIED, '4')
+        );
+        expected.addDeletedItems([v(4, '4')]);
+        assertChanges(
+            seq(ROOT, v(1, '1'), v(2, '2'), v(3, '3'), v(4, '4')),
+            seq(ROOT, v(1, '1'), v(2, '3'), v(3, '4')),
+            expected
+        );
+    });
+
+    test('Sequence diff treats head insertion as addition only (value-based)', () => {
+        const expected = seqX(ROOT, Change.MODIFIED,
+            vX(1, Change.ADDED, '1'),
+            vX(2, Change.NOT_CHANGED, '2'),
+            vX(3, Change.NOT_CHANGED, '3')
+        );
+        assertChanges(
+            seq(ROOT, v(1, '2'), v(2, '3')),
+            seq(ROOT, v(1, '1'), v(2, '2'), v(3, '3')),
+            expected
+        );
+    });
+
     test('Handles unchanged set', () => {
         assertChanges(
             set(ROOT, v(1, 'foo'), v(2, 'bar')),