Preserve edits during console history navigation

When editing a command from history, Up/Down navigation now preserves
the edits instead of dropping them. Edits are kept during navigation
and cleared when a new command is committed.

Bug: 355108929
Change-Id: Iaaf9e4a934161322133e3fa93521e83e9b8eb1bf
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/7363772
Commit-Queue: Helmut Januschka <helmut@januschka.com>
Reviewed-by: Samiya Caur <samiyac@chromium.org>
Reviewed-by: Nikolay Vitkov <nvitkov@chromium.org>

Author: hjanuschka

front_end/ui/components/text_editor/AutocompleteHistory.test.ts

@@ -60,6 +60,7 @@ describeWithEnvironment('AutocompleteHistory', () => {
       assert.strictEqual(history.previous(''), 'entry 1');
       assert.isUndefined(history.previous(''));
     });
+
   });
 
   describe('next', () => {
@@ -84,6 +85,7 @@ describeWithEnvironment('AutocompleteHistory', () => {
       assert.strictEqual(history.next(), 'entry 1');
       assert.strictEqual(history.next(), 'entry 2');
     });
+
   });
 
   it('stores the "temporary input" on the first "previous" call with a non-empty history', () => {
@@ -123,4 +125,99 @@ describeWithEnvironment('AutocompleteHistory', () => {
       assert.deepEqual([...matches], ['x === 19', 'x === 18', 'x === 17']);
     });
   });
+
+  describe('edit preservation during navigation', () => {
+    it('preserves edits made to history entries when navigating backward', () => {
+      history.pushHistoryItem('entry 1');
+      history.pushHistoryItem('entry 2');
+      history.pushHistoryItem('entry 3');
+
+      // Navigate to entry 2
+      history.previous('');  // now at entry 3
+      history.previous('');  // now at entry 2
+
+      // Edit entry 2 and navigate further back (passing edited text to previous)
+      history.previous('entry 2 EDITED');  // now at entry 1
+
+      // Navigate forward - should see the edit
+      assert.strictEqual(history.next(), 'entry 2 EDITED');
+    });
+
+    it('preserves multiple edits at different history positions', () => {
+      history.pushHistoryItem('entry 1');
+      history.pushHistoryItem('entry 2');
+      history.pushHistoryItem('entry 3');
+
+      // Edit entry 3 by passing edit when navigating away
+      history.previous('entry 3 EDITED');  // save edit, now at entry 2
+
+      // Edit entry 2 by passing edit when navigating away
+      history.previous('entry 2 EDITED');  // save edit, now at entry 1
+
+      // Navigate forward through edits
+      assert.strictEqual(history.next(), 'entry 2 EDITED');
+      assert.strictEqual(history.next(), 'entry 3 EDITED');
+    });
+
+    it('clears edits when a new command is committed', () => {
+      history.pushHistoryItem('entry 1');
+      history.pushHistoryItem('entry 2');
+
+      // Edit entry 2 by passing edit when navigating away
+      history.previous('entry 2 EDITED');
+
+      // Commit a new command
+      history.pushHistoryItem('entry 3');
+
+      // Navigate back - edit should be gone
+      assert.strictEqual(history.previous(''), 'entry 3');
+      assert.strictEqual(history.previous(''), 'entry 2');  // Original, not edited
+    });
+
+    it('preserves uncommitted input alongside history edits', () => {
+      history.pushHistoryItem('entry 1');
+      history.pushHistoryItem('entry 2');
+
+      // Start typing, then navigate back
+      history.previous('my uncommitted input');  // now at entry 2
+
+      // Edit entry 2 and go further back
+      history.previous('entry 2 EDITED');  // now at entry 1
+
+      // Navigate all the way forward
+      assert.strictEqual(history.next(), 'entry 2 EDITED');
+      assert.strictEqual(history.next(), 'my uncommitted input');
+    });
+
+    it('restores original if edit matches original', () => {
+      history.pushHistoryItem('entry 1');
+      history.pushHistoryItem('entry 2');
+
+      // Navigate to entry 2, "edit" it to same value
+      history.previous('');
+      history.previous('entry 2');  // edit back to original
+
+      // Should still work
+      assert.strictEqual(history.next(), 'entry 2');
+    });
+
+    it('restores original if text was emptied', () => {
+      history.pushHistoryItem('entry 1');
+      history.pushHistoryItem('entry 2');
+
+      // Navigate to entry 2, edit it
+      history.previous('');
+      history.previous('entry 2 EDITED');  // now at entry 1 with edit saved
+
+      // Verify edit is there
+      assert.strictEqual(history.next(), 'entry 2 EDITED');
+
+      // Now empty the text and navigate away
+      history.previous('');  // empty text, navigate back to entry 1
+
+      // Edit should be cleared, original restored
+      assert.strictEqual(history.next(), 'entry 2');
+    });
+  });
+
 });

front_end/ui/components/text_editor/AutocompleteHistory.ts

@@ -20,6 +20,12 @@ export class AutocompleteHistory {
   #historyOffset = 1;
   #uncommittedIsTop = false;
 
+  /**
+   * Tracks session-local edits made to history entries during navigation.
+   * Maps history index to edited text. Cleared when a new command is committed.
+   */
+  #editedEntries = new Map<number, string>();
+
   /**
    * Creates a new settings-backed history. The class assumes it has sole
    * ownership of the setting.
@@ -33,6 +39,7 @@ export class AutocompleteHistory {
     this.#data = [];
     this.#setting.set([]);
     this.#historyOffset = 1;
+    this.#editedEntries.clear();
   }
 
   length(): number {
@@ -49,6 +56,7 @@ export class AutocompleteHistory {
     }
 
     this.#historyOffset = 1;
+    this.#editedEntries.clear();
     if (text !== this.#currentHistoryItem()) {
       this.#data.push(text);
     }
@@ -72,11 +80,33 @@ export class AutocompleteHistory {
     }
     if (this.#historyOffset === 1) {
       this.#pushCurrentText(currentText);
+    } else {
+      this.#saveCurrentEdit(currentText);
     }
     ++this.#historyOffset;
     return this.#currentHistoryItem();
   }
 
+  /**
+   * Saves the current text as an edit if it differs from the current history item
+   * (which may already have edits from a previous navigation).
+   * Only saves non-empty edits to avoid issues with navigation-only calls.
+   */
+  #saveCurrentEdit(text: string): void {
+    const index = this.#data.length - this.#historyOffset;
+    const currentValue = this.#currentHistoryItem();
+    if (text === currentValue) {
+      return;
+    }
+    const original = this.#data[index];
+    if (text !== original && text.length > 0) {
+      this.#editedEntries.set(index, text);
+    } else {
+      // Remove edit if text was restored to original (or emptied)
+      this.#editedEntries.delete(index);
+    }
+  }
+
   next(): string|undefined {
     if (this.#historyOffset === 1) {
       return undefined;
@@ -98,7 +128,9 @@ export class AutocompleteHistory {
   }
 
   #currentHistoryItem(): string|undefined {
-    return this.#data[this.#data.length - this.#historyOffset];
+    const index = this.#data.length - this.#historyOffset;
+    // Return edited version if available, otherwise return original
+    return this.#editedEntries.get(index) ?? this.#data[index];
   }
 
   #store(): void {

front_end/ui/components/text_editor/TextEditorHistory.test.ts

@@ -128,6 +128,40 @@ describeWithEnvironment('TextEditorHistory', () => {
 
       assert.strictEqual(editor.state.selection.main.head, 10);
     });
+
+    describe('edit preservation', () => {
+      it('preserves edits when navigating through history', () => {
+        history.pushHistoryItem('entry 1');
+        history.pushHistoryItem('entry 2');
+        history.pushHistoryItem('entry 3');
+
+        // Navigate to entry 2 and edit it
+        editorHistory.moveHistory(Direction.BACKWARD);  // entry 3
+        editorHistory.moveHistory(Direction.BACKWARD);  // entry 2
+        setCodeMirrorContent(editor, 'entry 2 EDITED');
+
+        // Navigate back then forward
+        editorHistory.moveHistory(Direction.BACKWARD);  // entry 1
+        editorHistory.moveHistory(Direction.FORWARD);   // should be entry 2 EDITED
+
+        assert.strictEqual(editor.state.doc.toString(), 'entry 2 EDITED');
+      });
+
+      it('preserves uncommitted input when navigating through edited history', () => {
+        history.pushHistoryItem('entry 1');
+        history.pushHistoryItem('entry 2');
+        setCodeMirrorContent(editor, 'my new input');
+
+        // Navigate back, edit, navigate back more, then all the way forward
+        editorHistory.moveHistory(Direction.BACKWARD);  // entry 2
+        setCodeMirrorContent(editor, 'entry 2 EDITED');
+        editorHistory.moveHistory(Direction.BACKWARD);  // entry 1
+        editorHistory.moveHistory(Direction.FORWARD);   // entry 2 EDITED
+        editorHistory.moveHistory(Direction.FORWARD);   // my new input
+
+        assert.strictEqual(editor.state.doc.toString(), 'my new input');
+      });
+    });
   });
 
   describe('historyCompletions', () => {