Bug: [lexical-y] Undoing a format takes it off a word a collaborator later formatted the same way over a wider range #9675

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 *
 */

// @vitest-environment node

import {buildEditorFromExtensions} from '@lexical/extension';
import {RichTextExtension} from '@lexical/rich-text';
import {createYDoc, YCollabExtension} from '@lexical/y';
import {seedYState} from '@lexical/y/headless';
import * as Y from '@y/y';
import {
  $createParagraphNode,
  $createRangeSelection,
  $createTextNode,
  $getRoot,
  $setSelection,
  configExtension,
  defineExtension,
  type LexicalEditor,
  type TextNode,
  UNDO_COMMAND,
} from 'lexical';
import {expect, test} from 'vitest';

const CONFIG = {extensions: [RichTextExtension], schemaVersion: 1};

function client(seed: Uint8Array, id: number) {
  const doc = createYDoc();
  doc.clientID = id;
  Y.applyUpdate(doc, seed);
  const editor = buildEditorFromExtensions(
    defineExtension({
      dependencies: [
        RichTextExtension,
        configExtension(YCollabExtension, {doc, schemaVersion: 1, synced: true}),
      ],
      name: `repro/${id}`,
    }),
  );
  return {doc, editor};
}

// Bold the characters [from, to) of line `line0` up to [.., to) of line `line1`.
function bold(editor: LexicalEditor, line0: number, from: number, line1: number, to: number) {
  editor.update(
    () => {
      const a = $getRoot().getChildAtIndex(line0)!.getFirstDescendant() as TextNode;
      const b = $getRoot().getChildAtIndex(line1)!.getLastDescendant() as TextNode;
      const s = $createRangeSelection();
      s.anchor.set(a.getKey(), from, 'text');
      s.focus.set(b.getKey(), to - (b.getPreviousSiblings().reduce((n, x) => n + x.getTextContentSize(), 0)), 'text');
      s.format = a.getFormat();
      s.formatText('bold');
      $setSelection(null);
    },
    {discrete: true},
  );
}

const show = (editor: LexicalEditor) =>
  editor.getEditorState().read(() =>
    ($getRoot().getAllTextNodes() as TextNode[]).map(
      (n) => `${n.getTextContent()}${n.hasFormat('bold') ? '[b]' : ''}`,
    ),
  );

for (const [idB, idC] of [
  [1, 2],
  [2, 1],
]) {
  test(`undoing a bold keeps a collaborator's later bold over the same word (ids ${idB}, ${idC})`, () => {
    const seed = seedYState(CONFIG, () => {
      $getRoot()
        .clear()
        .append(
          $createParagraphNode().append($createTextNode('alpha beta gamma')),
          $createParagraphNode().append($createTextNode('delta epsilon')),
        );
    });
    const B = client(seed, idB);
    const C = client(seed, idC);
    const sync = () => {
      Y.applyUpdate(C.doc, Y.encodeStateAsUpdate(B.doc, Y.encodeStateVector(C.doc)));
      Y.applyUpdate(B.doc, Y.encodeStateAsUpdate(C.doc, Y.encodeStateVector(B.doc)));
    };
    bold(B.editor, 0, 6, 0, 10); // B bolds "beta"
    sync();
    bold(C.editor, 0, 0, 1, 5); // C bolds "alpha beta gamma" / "delta"
    sync();
    expect(show(B.editor)).toEqual(['alpha beta gamma[b]', 'delta[b]', ' epsilon']);
    B.editor.dispatchCommand(UNDO_COMMAND, undefined); // B undoes its bold
    sync();
    expect(show(C.editor)).toEqual(show(B.editor));
    // C bolded "beta" too: it stays bold.
    expect(show(B.editor)).toEqual(['alpha beta gamma[b]', 'delta[b]', ' epsilon']);
  });
}