test: created tests around TOC programmatic update

Author: chittolina

packages/super-editor/src/editors/v1/components/context-menu/tests/menuItems.test.js

@@ -31,6 +31,7 @@ vi.mock('../constants.js', () => ({
     trackChangesAccept: 'Accept Tracked Changes',
     trackChangesReject: 'Reject Tracked Changes',
     cellBackground: 'Cell background',
+    updateTableOfContents: 'Update table of contents',
   },
   ICONS: {
     ai: '<svg>ai-icon</svg>',
@@ -42,6 +43,7 @@ vi.mock('../constants.js', () => ({
     copy: '<svg>copy-icon</svg>',
     paste: '<svg>paste-icon</svg>',
     cellBackground: '<svg>cell-background-icon</svg>',
+    updateTableOfContents: '<svg>rotate-right-icon</svg>',
   },
   TRIGGERS: {
     slash: 'slash',
@@ -1059,4 +1061,110 @@ describe('menuItems.js', () => {
       expect(callOrder).toEqual(['setSelection', 'handleClipboardPaste']);
     });
   });
+
+  // ---------------------------------------------------------------------------
+  // SD-2664 — "Update table of contents" item
+  // ---------------------------------------------------------------------------
+
+  describe('update-table-of-contents item', () => {
+    const findItem = (sections) => {
+      for (const section of sections) {
+        const item = section.items.find((it) => it.id === 'update-table-of-contents');
+        if (item) return item;
+      }
+      return undefined;
+    };
+
+    it('appears when right-clicking inside a TOC (tocAncestor.sdBlockId set, click trigger)', () => {
+      mockContext = createMockContext({
+        editor: mockEditor,
+        trigger: TRIGGERS.click,
+        tocAncestor: { node: {}, pos: 5, sdBlockId: 'toc-1' },
+      });
+      const sections = getItems(mockContext);
+      expect(findItem(sections)).toBeDefined();
+    });
+
+    it('is hidden when no tocAncestor is present', () => {
+      mockContext = createMockContext({
+        editor: mockEditor,
+        trigger: TRIGGERS.click,
+        tocAncestor: null,
+      });
+      const sections = getItems(mockContext);
+      expect(findItem(sections)).toBeUndefined();
+    });
+
+    it('is hidden when tocAncestor exists but sdBlockId is missing', () => {
+      mockContext = createMockContext({
+        editor: mockEditor,
+        trigger: TRIGGERS.click,
+        tocAncestor: { node: {}, pos: 5, sdBlockId: null },
+      });
+      const sections = getItems(mockContext);
+      expect(findItem(sections)).toBeUndefined();
+    });
+
+    it('is hidden on the slash trigger even when inside a TOC', () => {
+      mockContext = createMockContext({
+        editor: mockEditor,
+        trigger: TRIGGERS.slash,
+        tocAncestor: { node: {}, pos: 5, sdBlockId: 'toc-1' },
+      });
+      const sections = getItems(mockContext);
+      expect(findItem(sections)).toBeUndefined();
+    });
+
+    it('action invokes editor.doc.toc.update with the resolved sdBlockId and mode "all"', () => {
+      const update = vi.fn();
+      const ed = { ...mockEditor, doc: { toc: { update } } };
+      mockContext = createMockContext({
+        editor: ed,
+        trigger: TRIGGERS.click,
+        tocAncestor: { node: {}, pos: 5, sdBlockId: 'toc-42' },
+      });
+      const sections = getItems(mockContext);
+      const item = findItem(sections);
+      expect(item).toBeDefined();
+      item.action(ed, mockContext);
+      expect(update).toHaveBeenCalledWith({
+        target: { kind: 'block', nodeType: 'tableOfContents', nodeId: 'toc-42' },
+        mode: 'all',
+      });
+    });
+
+    it('action is a no-op when sdBlockId is missing', () => {
+      const update = vi.fn();
+      const ed = { ...mockEditor, doc: { toc: { update } } };
+      // showWhen would normally hide the item — invoke action directly to assert the guard.
+      mockContext = createMockContext({
+        editor: ed,
+        trigger: TRIGGERS.click,
+        tocAncestor: { node: {}, pos: 5, sdBlockId: 'toc-1' },
+      });
+      const sections = getItems(mockContext);
+      const item = findItem(sections);
+      // Re-invoke action with a context that has no sdBlockId.
+      item.action(ed, { ...mockContext, tocAncestor: { node: {}, pos: 5, sdBlockId: null } });
+      expect(update).not.toHaveBeenCalled();
+    });
+
+    it('action swallows errors thrown by editor.doc.toc.update', () => {
+      const update = vi.fn(() => {
+        throw new Error('boom');
+      });
+      const ed = { ...mockEditor, doc: { toc: { update } } };
+      mockContext = createMockContext({
+        editor: ed,
+        trigger: TRIGGERS.click,
+        tocAncestor: { node: {}, pos: 5, sdBlockId: 'toc-1' },
+      });
+      const sections = getItems(mockContext);
+      const item = findItem(sections);
+      const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      expect(() => item.action(ed, mockContext)).not.toThrow();
+      expect(warn).toHaveBeenCalled();
+      warn.mockRestore();
+    });
+  });
 });

packages/super-editor/src/editors/v1/extensions/field-update/field-update.js

@@ -6,14 +6,10 @@ import {
   resolveMainBodyEditor,
 } from '../../document-api-adapters/helpers/word-statistics.js';
 
-/** Field types eligible for value updates via F9. */
+/** Stat-field types refreshed by F9 when the doc has no TOCs. */
 const UPDATABLE_FIELD_TYPES = new Set(['NUMWORDS', 'NUMCHARS', 'NUMPAGES']);
 
-/**
- * Collect every `tableOfContents` node's sdBlockId, in document order.
- * @param {import('prosemirror-model').Node} doc
- * @returns {string[]}
- */
+/** Every `tableOfContents` node's sdBlockId in document order. */
 function collectTocBlockIds(doc) {
   const ids = [];
   doc.descendants((node) => {

packages/super-editor/src/editors/v1/extensions/field-update/field-update.test.js

@@ -4,12 +4,16 @@
  * Tests for the FieldUpdate extension's updateFieldsInSelection command.
  *
  * Uses the numwords.docx fixture which contains NUMWORDS, NUMCHARS, and
- * NUMPAGES fields with known imported values.
+ * NUMPAGES fields with known imported values for the stat-field path. The
+ * TOC path is exercised via direct command-function invocation against a
+ * synthetic doc/editor — no docx fixture required.
  */
 
-import { afterEach, beforeAll, describe, expect, it } from 'vitest';
+import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest';
+import { Schema } from 'prosemirror-model';
 import { initTestEditor, loadTestDataForEditorTests } from '@tests/helpers/helpers.js';
 import { getWordStatistics } from '../../document-api-adapters/helpers/word-statistics.js';
+import { FieldUpdate } from './field-update.js';
 
 describe('FieldUpdate extension', () => {
   let docData;
@@ -107,3 +111,135 @@ describe('FieldUpdate extension', () => {
     expect(numcharsField.attrs.resolvedText).toBe(expectedValue);
   });
 });
+
+// ---------------------------------------------------------------------------
+// TOC path — invoked directly against synthetic state to avoid needing a
+// fully-imported TOC fixture.
+// ---------------------------------------------------------------------------
+
+const tocSchema = new Schema({
+  nodes: {
+    doc: { content: 'block+' },
+    paragraph: { group: 'block', content: 'inline*', toDOM: () => ['p', 0] },
+    tableOfContents: {
+      group: 'block',
+      content: 'paragraph*',
+      attrs: { sdBlockId: { default: null } },
+      toDOM: () => ['div', 0],
+    },
+    text: { group: 'inline' },
+  },
+});
+
+const buildTocDoc = (sdBlockIds) => {
+  const para = (txt) => tocSchema.nodes.paragraph.create({}, txt ? tocSchema.text(txt) : null);
+  const tocs = sdBlockIds.map((id) => tocSchema.nodes.tableOfContents.create({ sdBlockId: id }, [para('entry')]));
+  return tocSchema.nodes.doc.create({}, [para('intro'), ...tocs, para('outro')]);
+};
+
+const runUpdateFields = (overrides) => {
+  const { doc, editor } = overrides;
+  const dispatch = 'dispatch' in overrides ? overrides.dispatch : () => {};
+  // FieldUpdate is wrapped by Extension.create(); reach into config.addCommands
+  // to invoke the raw command function the same way ExtensionService does.
+  const commands = FieldUpdate.config.addCommands.call({ editor });
+  const command = commands.updateFieldsInSelection();
+  const tr = { setMeta: vi.fn() };
+  const state = { doc, selection: { from: 0, to: 0 }, schema: tocSchema, tr };
+  return { result: command({ editor, state, tr, dispatch }), tr };
+};
+
+describe('updateFieldsInSelection — TOC path', () => {
+  it('calls editor.doc.toc.update for every tableOfContents node in document order', () => {
+    const update = vi.fn(() => ({ success: true }));
+    const editor = { doc: { toc: { update } } };
+    const doc = buildTocDoc(['toc-a', 'toc-b']);
+
+    const { result } = runUpdateFields({ doc, editor });
+
+    expect(result).toBe(true);
+    expect(update).toHaveBeenCalledTimes(2);
+    expect(update.mock.calls[0][0]).toEqual({
+      target: { kind: 'block', nodeType: 'tableOfContents', nodeId: 'toc-a' },
+      mode: 'all',
+    });
+    expect(update.mock.calls[1][0]).toEqual({
+      target: { kind: 'block', nodeType: 'tableOfContents', nodeId: 'toc-b' },
+      mode: 'all',
+    });
+  });
+
+  it('sets preventDispatch on the framework tr so CommandService skips its auto-dispatch', () => {
+    const update = vi.fn(() => ({ success: true }));
+    const editor = { doc: { toc: { update } } };
+    const doc = buildTocDoc(['toc-a']);
+
+    const { tr } = runUpdateFields({ doc, editor });
+    expect(tr.setMeta).toHaveBeenCalledWith('preventDispatch', true);
+  });
+
+  it('returns true on a can()-style probe (no dispatch) when any TOC exists', () => {
+    const update = vi.fn();
+    const editor = { doc: { toc: { update } } };
+    const doc = buildTocDoc(['toc-a']);
+
+    const { result } = runUpdateFields({ doc, editor, dispatch: undefined });
+    expect(result).toBe(true);
+    expect(update).not.toHaveBeenCalled();
+  });
+
+  it('skips a TOC whose sdBlockId is missing or empty', () => {
+    const update = vi.fn(() => ({ success: true }));
+    const editor = { doc: { toc: { update } } };
+    const doc = buildTocDoc([null, '', 'toc-real']);
+
+    runUpdateFields({ doc, editor });
+    expect(update).toHaveBeenCalledTimes(1);
+    expect(update.mock.calls[0][0].target.nodeId).toBe('toc-real');
+  });
+
+  it('swallows toc.update errors and continues with the remaining TOCs', () => {
+    const update = vi
+      .fn()
+      .mockImplementationOnce(() => {
+        throw new Error('boom');
+      })
+      .mockImplementationOnce(() => ({ success: true }));
+    const editor = { doc: { toc: { update } } };
+    const doc = buildTocDoc(['toc-a', 'toc-b']);
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const { result } = runUpdateFields({ doc, editor });
+    expect(result).toBe(true);
+    expect(update).toHaveBeenCalledTimes(2);
+    expect(warnSpy).toHaveBeenCalled();
+    warnSpy.mockRestore();
+  });
+
+  it('falls through to the stat-field path when the doc has no TOCs', () => {
+    const update = vi.fn();
+    const editor = { doc: { toc: { update } } };
+    const para = (txt) => tocSchema.nodes.paragraph.create({}, txt ? tocSchema.text(txt) : null);
+    const doc = tocSchema.nodes.doc.create({}, [para('hello world')]);
+
+    const { tr } = runUpdateFields({ doc, editor });
+    expect(update).not.toHaveBeenCalled();
+    expect(tr.setMeta).not.toHaveBeenCalled(); // no preventDispatch when not taking the TOC path
+  });
+});
+
+describe('FieldUpdate extension shortcuts', () => {
+  it('binds F9 to updateFieldsInSelection', () => {
+    const ed = { commands: { updateFieldsInSelection: vi.fn(() => true) } };
+    const shortcuts = FieldUpdate.config.addShortcuts.call({ editor: ed });
+    expect(typeof shortcuts.F9).toBe('function');
+    shortcuts.F9();
+    expect(ed.commands.updateFieldsInSelection).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not bind any other key alongside F9', () => {
+    const ed = { commands: { updateFieldsInSelection: vi.fn() } };
+    const shortcuts = FieldUpdate.config.addShortcuts.call({ editor: ed });
+    expect(Object.keys(shortcuts)).toEqual(['F9']);
+  });
+});

tests/behavior/tests/navigation/toc-update.spec.ts

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { test, expect } from '../../fixtures/superdoc.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DOC_PATH = path.resolve(__dirname, '../../test-data/layout/toc-with-heading2.docx');
+
+test.skip(!fs.existsSync(DOC_PATH), 'Test document not available — run pnpm corpus:pull');
+
+/**
+ * Reads every TOC entry's title text from the document.
+ *
+ * The rebuilt entries are wrapped in `run` nodes whose first text run holds
+ * the title (without the page-number `tocPageNumber` mark).
+ */
+const readTocTitles = async (superdoc) =>
+  superdoc.page.evaluate(() => {
+    const editor = (window as unknown as { editor?: { state: { doc: unknown } } }).editor;
+    if (!editor?.state?.doc) return [];
+    const titles: string[] = [];
+    (editor.state.doc as { descendants: (cb: (n: any) => boolean | void) => void }).descendants((node) => {
+      if (node?.type?.name !== 'tableOfContents') return true;
+      node.descendants((child: any) => {
+        if (child?.type?.name !== 'paragraph') return true;
+        // First non-page-number text run is the entry title.
+        let captured = false;
+        child.descendants((leaf: any) => {
+          if (captured) return false;
+          if (!leaf.isText || !leaf.text) return true;
+          const isPageNumber = (leaf.marks ?? []).some((m: any) => m.type?.name === 'tocPageNumber');
+          if (!isPageNumber) {
+            titles.push(leaf.text);
+            captured = true;
+          }
+          return true;
+        });
+        return false;
+      });
+      return false;
+    });
+    return titles;
+  });
+
+test('@behavior SD-2664: updateFieldsInSelection (F9) rebuilds every TOC entry from the document headings', async ({
+  superdoc,
+}) => {
+  await superdoc.loadDocument(DOC_PATH);
+  await superdoc.waitForStable(2000);
+
+  // Capture the original TOC entries.
+  const titlesBefore = await readTocTitles(superdoc);
+  expect(titlesBefore.length).toBeGreaterThan(0);
+
+  // Read the heading texts that should drive the rebuilt TOC. The fixture
+  // contains Heading1/Heading2 paragraphs in the body.
+  const headingTexts = await superdoc.page.evaluate(() => {
+    const editor = (window as unknown as { editor?: { state: { doc: unknown } } }).editor;
+    if (!editor?.state?.doc) return [];
+    const out: string[] = [];
+    (editor.state.doc as { descendants: (cb: (n: any) => boolean | void) => void }).descendants((node) => {
+      if (node?.type?.name === 'tableOfContents') return false; // skip TOC contents
+      if (node?.type?.name !== 'paragraph') return true;
+      const styleId = node.attrs?.paragraphProperties?.styleId;
+      if (!styleId || !/^Heading[1-9]$/.test(styleId)) return true;
+      let text = '';
+      node.descendants((c: any) => {
+        if (c.isText && c.text) text += c.text;
+        return true;
+      });
+      if (text.trim()) out.push(text.trim());
+      return true;
+    });
+    return out;
+  });
+  expect(headingTexts.length).toBeGreaterThan(0);
+
+  // Press F9 — the FieldUpdate extension binds it to updateFieldsInSelection,
+  // which routes through editor.doc.toc.update for every TOC in the doc.
+  await superdoc.executeCommand('updateFieldsInSelection');
+  await superdoc.waitForStable(2000);
+
+  const titlesAfter = await readTocTitles(superdoc);
+  // Every heading in the doc should now appear as an entry, and every entry
+  // should map to a heading text. Order must match document order.
+  expect(titlesAfter).toEqual(headingTexts);
+});