feat: match word search behavior for tracked changes (#3025)

Co-authored-by: Artem Nistuley <artem@superdoc.dev>

Author: artem-harbour

packages/super-editor/src/editors/v1/components/toolbar/defaultItems.js

@@ -324,7 +324,7 @@ export const makeDefaultItems = ({
 
   const renderSearchDropdown = () => {
     const handleSubmit = ({ value }) => {
-      superToolbar.activeEditor.commands.search(value);
+      superToolbar.activeEditor.commands.search(value, { searchModel: 'visible' });
     };
 
     return h('div', {}, [

packages/super-editor/src/editors/v1/document-api-adapters/find-adapter.test.ts

@@ -1,7 +1,7 @@
 import type { Node as ProseMirrorNode } from 'prosemirror-model';
 import type { Editor } from '../core/Editor.js';
 import type { Query } from '@superdoc/document-api';
-import { findLegacyAdapter } from './find-adapter.js';
+import { findLegacyAdapter, sdFindAdapter } from './find-adapter.js';
 
 // ---------------------------------------------------------------------------
 // Helpers — lightweight ProseMirror-like stubs
@@ -703,6 +703,22 @@ describe('findLegacyAdapter — text selectors', () => {
     expect(capturedOptions!.maxMatches).toBe(Infinity);
   });
 
+  it('uses visible search model for text selector queries', () => {
+    let capturedOptions: Record<string, unknown> | undefined;
+    const doc = buildDoc({ typeName: 'paragraph', attrs: { sdBlockId: 'p1' }, nodeSize: 50, offset: 0 });
+    const search: SearchFn = (_pattern, options) => {
+      capturedOptions = options as Record<string, unknown>;
+      return [];
+    };
+    const editor = makeEditor(doc, search);
+    const query: Query = { select: { type: 'text', pattern: 'tracked' } };
+
+    findLegacyAdapter(editor, query);
+
+    expect(capturedOptions).toBeDefined();
+    expect(capturedOptions!.searchModel).toBe('visible');
+  });
+
   it('throws when editor has no search command', () => {
     const doc = buildDoc({ typeName: 'paragraph', attrs: { sdBlockId: 'p1' }, nodeSize: 50, offset: 0 });
     const editor = makeEditor(doc); // no search command
@@ -894,6 +910,51 @@ describe('findLegacyAdapter — text selectors', () => {
   });
 });
 
+describe('sdFindAdapter — tracked changes text search defaults', () => {
+  it('uses visible model semantics for delete/add/collapsed queries', () => {
+    const doc = buildDoc('beforeDELETEafter ADD', {
+      typeName: 'paragraph',
+      attrs: { sdBlockId: 'p1' },
+      nodeSize: 50,
+      offset: 0,
+    });
+
+    const search: SearchFn = (pattern, options) => {
+      const source = pattern instanceof RegExp ? pattern.source : String(pattern);
+      const searchModel = (options as { searchModel?: string } | undefined)?.searchModel ?? 'raw';
+      const isVisible = searchModel === 'visible';
+
+      if (source === 'DELETE') {
+        return isVisible ? [] : [{ from: 7, to: 13, text: 'DELETE' }];
+      }
+      if (source === 'ADD') {
+        return [{ from: 18, to: 21, text: 'ADD' }];
+      }
+      if (source === 'beforeafter') {
+        return isVisible ? [] : [{ from: 0, to: 11, text: 'beforeafter' }];
+      }
+
+      return [];
+    };
+
+    const editor = makeEditor(doc, search);
+
+    const deletedOnly = sdFindAdapter(editor, { select: { type: 'text', pattern: 'DELETE' } });
+    const addedOnly = sdFindAdapter(editor, { select: { type: 'text', pattern: 'ADD' } });
+    const collapsed = sdFindAdapter(editor, { select: { type: 'text', pattern: 'beforeafter' } });
+
+    expect(deletedOnly.total).toBe(0);
+    expect(deletedOnly.items).toHaveLength(0);
+
+    expect(addedOnly.total).toBe(1);
+    expect(addedOnly.items).toHaveLength(1);
+    expect(addedOnly.items[0].address).toEqual({ kind: 'block', nodeType: 'paragraph', nodeId: 'p1' });
+
+    expect(collapsed.total).toBe(0);
+    expect(collapsed.items).toHaveLength(0);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Context / snippet building
 // ---------------------------------------------------------------------------

packages/super-editor/src/editors/v1/document-api-adapters/find/text-strategy.ts

@@ -105,6 +105,7 @@ export function executeTextSelector(
     highlight: false,
     caseSensitive: selector.caseSensitive ?? false,
     maxMatches: Infinity,
+    searchModel: 'visible',
   });
 
   if (!Array.isArray(rawResult)) {

packages/super-editor/src/editors/v1/extensions/search/SearchIndex.js

@@ -24,6 +24,10 @@
 
 const BLOCK_SEPARATOR = '\n';
 const ATOM_PLACEHOLDER = '\ufffc';
+const DELETION_BARRIER = '\u0000';
+const DEFAULT_SEARCH_MODEL = 'raw';
+
+const hasTrackDeleteMark = (node) => node?.marks?.some((mark) => mark?.type?.name === 'trackDelete') ?? false;
 
 /**
  * SearchIndex provides a lazily-built, cached index for searching across
@@ -48,31 +52,107 @@ export class SearchIndex {
   /** @type {import('prosemirror-model').Node | null} */
   doc = null;
 
+  /** @type {'raw'|'visible'} */
+  searchModel = DEFAULT_SEARCH_MODEL;
+
   /**
    * Build the search index from a ProseMirror document.
    * Uses doc.textBetween for the flattened string and walks
    * the document to build the segment offset map.
    *
    * @param {import('prosemirror-model').Node} doc - The ProseMirror document
    */
-  build(doc) {
-    // Get the flattened text using ProseMirror's optimized textBetween
-    this.text = doc.textBetween(0, doc.content.size, BLOCK_SEPARATOR, ATOM_PLACEHOLDER);
+  build(doc, options = {}) {
+    const searchModel = options?.searchModel === 'visible' ? 'visible' : DEFAULT_SEARCH_MODEL;
+
+    if (searchModel === 'visible') {
+      this.#buildVisible(doc);
+    } else {
+      // Get the flattened text using ProseMirror's optimized textBetween
+      this.text = doc.textBetween(0, doc.content.size, BLOCK_SEPARATOR, ATOM_PLACEHOLDER);
+    }
+
     this.segments = [];
     this.docSize = doc.content.size;
     this.doc = doc;
+    this.searchModel = searchModel;
 
     // Walk the document to build the segment map
     // Note: doc node's content starts at position 0 (doc has no opening tag)
     let offset = 0;
-    this.#walkNodeContent(doc, 0, offset, (segment) => {
-      this.segments.push(segment);
-      offset = segment.offsetEnd;
-    });
+    const visibleContext = searchModel === 'visible' ? { deletionBarrierActive: false } : null;
+    this.#walkNodeContent(
+      doc,
+      0,
+      offset,
+      (segment) => {
+        this.segments.push(segment);
+        offset = segment.offsetEnd;
+      },
+      searchModel,
+      visibleContext,
+    );
 
     this.valid = true;
   }
 
+  /**
+   * Build flattened text for the `visible` model, where tracked deletions
+   * are removed from searchable text and replaced with a non-searchable
+   * barrier to prevent false collapsed matches.
+   *
+   * @param {import('prosemirror-model').Node} doc
+   */
+  #buildVisible(doc) {
+    const parts = [];
+    let emittedDeletionBarrier = false;
+
+    const appendDeletionBarrier = () => {
+      if (emittedDeletionBarrier) return;
+      parts.push(DELETION_BARRIER);
+      emittedDeletionBarrier = true;
+    };
+
+    const walkNodeContent = (node) => {
+      let isFirstChild = true;
+      node.forEach((child) => {
+        if (child.isBlock && !isFirstChild) {
+          parts.push(BLOCK_SEPARATOR);
+          emittedDeletionBarrier = false;
+        }
+        walkNode(child);
+        isFirstChild = false;
+      });
+    };
+
+    const walkNode = (node) => {
+      if (node.isText) {
+        const text = node.text || '';
+        if (!text.length) return;
+
+        if (hasTrackDeleteMark(node)) {
+          appendDeletionBarrier();
+          return;
+        }
+
+        parts.push(text);
+        emittedDeletionBarrier = false;
+        return;
+      }
+
+      if (node.isLeaf) {
+        parts.push(ATOM_PLACEHOLDER);
+        emittedDeletionBarrier = false;
+        return;
+      }
+
+      walkNodeContent(node);
+    };
+
+    walkNodeContent(doc);
+    this.text = parts.join('');
+  }
+
   /**
    * Walk the content of a node to build segments.
    * This method processes the children of a node, given the position
@@ -84,7 +164,7 @@ export class SearchIndex {
    * @param {(segment: Segment) => void} addSegment - Callback to add a segment
    * @returns {number} The new offset after processing this node's content
    */
-  #walkNodeContent(node, contentStart, offset, addSegment) {
+  #walkNodeContent(node, contentStart, offset, addSegment, searchModel = DEFAULT_SEARCH_MODEL, context = null) {
     let currentOffset = offset;
     let isFirstChild = true;
 
@@ -101,9 +181,12 @@ export class SearchIndex {
           kind: 'blockSep',
         });
         currentOffset += 1;
+        if (context && searchModel === 'visible') {
+          context.deletionBarrierActive = false;
+        }
       }
 
-      currentOffset = this.#walkNode(child, childDocPos, currentOffset, addSegment);
+      currentOffset = this.#walkNode(child, childDocPos, currentOffset, addSegment, searchModel, context);
       isFirstChild = false;
     });
 
@@ -119,11 +202,31 @@ export class SearchIndex {
    * @param {(segment: Segment) => void} addSegment - Callback to add a segment
    * @returns {number} The new offset after processing this node
    */
-  #walkNode(node, docPos, offset, addSegment) {
+  #walkNode(node, docPos, offset, addSegment, searchModel = DEFAULT_SEARCH_MODEL, context = null) {
     if (node.isText) {
+      if (searchModel === 'visible' && hasTrackDeleteMark(node)) {
+        if (context?.deletionBarrierActive) {
+          return offset;
+        }
+        addSegment({
+          offsetStart: offset,
+          offsetEnd: offset + 1,
+          docFrom: docPos,
+          docTo: docPos,
+          kind: 'atom',
+        });
+        if (context) {
+          context.deletionBarrierActive = true;
+        }
+        return offset + 1;
+      }
+
       // Text node: add a text segment
       const text = node.text || '';
       if (text.length > 0) {
+        if (context && searchModel === 'visible') {
+          context.deletionBarrierActive = false;
+        }
         addSegment({
           offsetStart: offset,
           offsetEnd: offset + text.length,
@@ -137,6 +240,9 @@ export class SearchIndex {
     }
 
     if (node.isLeaf) {
+      if (context && searchModel === 'visible') {
+        context.deletionBarrierActive = false;
+      }
       // Leaf node (atom): check if it's a hard_break or other atom
       if (node.type.name === 'hard_break') {
         addSegment({
@@ -161,7 +267,7 @@ export class SearchIndex {
 
     // For non-leaf nodes, recurse into content
     // Content starts at docPos + 1 (after opening tag)
-    return this.#walkNodeContent(node, docPos + 1, offset, addSegment);
+    return this.#walkNodeContent(node, docPos + 1, offset, addSegment, searchModel, context);
   }
 
   /**
@@ -177,8 +283,9 @@ export class SearchIndex {
    * @param {import('prosemirror-model').Node} doc - The document to check against
    * @returns {boolean} True if index is stale and needs rebuilding
    */
-  isStale(doc) {
-    return !this.valid || this.doc !== doc;
+  isStale(doc, options = {}) {
+    const searchModel = options?.searchModel === 'visible' ? 'visible' : DEFAULT_SEARCH_MODEL;
+    return !this.valid || this.doc !== doc || this.searchModel !== searchModel;
   }
 
   /**
@@ -187,9 +294,9 @@ export class SearchIndex {
    *
    * @param {import('prosemirror-model').Node} doc - The document
    */
-  ensureValid(doc) {
-    if (this.isStale(doc)) {
-      this.build(doc);
+  ensureValid(doc, options = {}) {
+    if (this.isStale(doc, options)) {
+      this.build(doc, options);
     }
   }