@pie-lib/editable-html-tip-tap 1.2.0-next.8 → 2.0.0

package/src/components/respArea/__tests__/MathTemplated.test.jsx

@@ -0,0 +1,210 @@
+import React from 'react';
+import { render } from '@testing-library/react';
+import MathTemplated from '../MathTemplated';
+
+// Mock the dependencies
+jest.mock('@tiptap/react', () => ({
+  NodeViewWrapper: ({ children, ...props }) => (
+    <div data-testid="node-view-wrapper" {...props}>
+      {children}
+    </div>
+  ),
+}));
+
+jest.mock('@pie-lib/math-input', () => ({
+  mq: {
+    Static: ({ latex }) => (
+      <div data-testid="mq-static" data-latex={latex}>
+        {latex}
+      </div>
+    ),
+  },
+}));
+
+describe('MathTemplated', () => {
+  const defaultProps = {
+    node: {
+      attrs: {
+        value: 'x^2 + y^2 = r^2',
+        index: 0,
+      },
+    },
+    options: {},
+    selected: false,
+  };
+
+  it('renders without crashing', () => {
+    const { container } = render(<MathTemplated {...defaultProps} />);
+    expect(container).toBeInTheDocument();
+  });
+
+  it('renders NodeViewWrapper with correct className', () => {
+    const { getByTestId } = render(<MathTemplated {...defaultProps} />);
+    const wrapper = getByTestId('node-view-wrapper');
+    expect(wrapper).toHaveClass('math-templated');
+  });
+
+  it('displays correct response key for index 0', () => {
+    const { getByText } = render(<MathTemplated {...defaultProps} />);
+    expect(getByText('R 1')).toBeInTheDocument();
+  });
+
+  it('displays correct response key for index 1', () => {
+    const props = {
+      ...defaultProps,
+      node: {
+        attrs: {
+          value: 'a + b',
+          index: 1,
+        },
+      },
+    };
+    const { getByText } = render(<MathTemplated {...props} />);
+    expect(getByText('R 2')).toBeInTheDocument();
+  });
+
+  it('displays correct response key for index 5', () => {
+    const props = {
+      ...defaultProps,
+      node: {
+        attrs: {
+          value: 'c = d',
+          index: 5,
+        },
+      },
+    };
+    const { getByText } = render(<MathTemplated {...props} />);
+    expect(getByText('R 6')).toBeInTheDocument();
+  });
+
+  it('renders LaTeX value correctly', () => {
+    const { getByTestId } = render(<MathTemplated {...defaultProps} />);
+    const mqStatic = getByTestId('mq-static');
+    expect(mqStatic).toHaveAttribute('data-latex', 'x^2 + y^2 = r^2');
+  });
+
+  it('renders different LaTeX value', () => {
+    const props = {
+      ...defaultProps,
+      node: {
+        attrs: {
+          value: '\\frac{a}{b}',
+          index: 2,
+        },
+      },
+    };
+    const { getByTestId } = render(<MathTemplated {...props} />);
+    const mqStatic = getByTestId('mq-static');
+    expect(mqStatic).toHaveAttribute('data-latex', '\\frac{a}{b}');
+  });
+
+  it('passes selected prop to NodeViewWrapper', () => {
+    const props = {
+      ...defaultProps,
+      selected: true,
+    };
+    const { getByTestId } = render(<MathTemplated {...props} />);
+    const wrapper = getByTestId('node-view-wrapper');
+    expect(wrapper).toHaveAttribute('data-selected', 'true');
+  });
+
+  it('passes false selected prop to NodeViewWrapper', () => {
+    const { getByTestId } = render(<MathTemplated {...defaultProps} />);
+    const wrapper = getByTestId('node-view-wrapper');
+    expect(wrapper).toHaveAttribute('data-selected', 'false');
+  });
+
+  it('applies correct inline styles to NodeViewWrapper', () => {
+    const { getByTestId } = render(<MathTemplated {...defaultProps} />);
+    const wrapper = getByTestId('node-view-wrapper');
+    expect(wrapper).toHaveStyle({
+      display: 'inline-flex',
+      minHeight: '36px',
+      minWidth: '50px',
+      cursor: 'pointer',
+    });
+  });
+
+  it('handles string index correctly', () => {
+    const props = {
+      ...defaultProps,
+      node: {
+        attrs: {
+          value: 'test',
+          index: '3',
+        },
+      },
+    };
+    const { getByText } = render(<MathTemplated {...props} />);
+    expect(getByText('R 4')).toBeInTheDocument();
+  });
+
+  it('handles empty value', () => {
+    const props = {
+      ...defaultProps,
+      node: {
+        attrs: {
+          value: '',
+          index: 0,
+        },
+      },
+    };
+    const { getByTestId } = render(<MathTemplated {...props} />);
+    const mqStatic = getByTestId('mq-static');
+    expect(mqStatic).toHaveAttribute('data-latex', '');
+  });
+
+  it('renders all styled components', () => {
+    const { container, getByText } = render(<MathTemplated {...defaultProps} />);
+
+    // Check for response box
+    expect(getByText('R 1')).toBeInTheDocument();
+
+    // Check for math block with LaTeX
+    const mqStatic = container.querySelector('[data-testid="mq-static"]');
+    expect(mqStatic).toBeInTheDocument();
+  });
+
+  it('handles zero index', () => {
+    const props = {
+      ...defaultProps,
+      node: {
+        attrs: {
+          value: 'x = 0',
+          index: 0,
+        },
+      },
+    };
+    const { getByText } = render(<MathTemplated {...props} />);
+    expect(getByText('R 1')).toBeInTheDocument();
+  });
+
+  it('handles large index values', () => {
+    const props = {
+      ...defaultProps,
+      node: {
+        attrs: {
+          value: 'x = 100',
+          index: 99,
+        },
+      },
+    };
+    const { getByText } = render(<MathTemplated {...props} />);
+    expect(getByText('R 100')).toBeInTheDocument();
+  });
+
+  it('renders with complex LaTeX expression', () => {
+    const props = {
+      ...defaultProps,
+      node: {
+        attrs: {
+          value: '\\sqrt{x^2 + y^2}',
+          index: 0,
+        },
+      },
+    };
+    const { getByTestId } = render(<MathTemplated {...props} />);
+    const mqStatic = getByTestId('mq-static');
+    expect(mqStatic).toHaveAttribute('data-latex', '\\sqrt{x^2 + y^2}');
+  });
+});

package/src/extensions/__tests__/divNode.test.js

@@ -0,0 +1,87 @@
+import { DivNode } from '../div-node';
+
+jest.mock('@tiptap/core', () => ({
+  Node: {
+    create: jest.fn((config) => config),
+  },
+}));
+
+describe('DivNode', () => {
+  describe('configuration', () => {
+    it('has correct name', () => {
+      expect(DivNode.name).toBe('div');
+    });
+
+    it('is block level', () => {
+      expect(DivNode.group).toBe('block');
+      expect(DivNode.content).toBe('inline*');
+    });
+  });
+
+  describe('parseHTML', () => {
+    it('parses <div> tags', () => {
+      const rules = DivNode.parseHTML();
+
+      expect(Array.isArray(rules)).toBe(true);
+      expect(rules).toHaveLength(1);
+      expect(rules[0]).toHaveProperty('tag', 'div');
+    });
+  });
+
+  describe('renderHTML', () => {
+    it('renders a <div> tag', () => {
+      const result = DivNode.renderHTML({ HTMLAttributes: { class: 'foo' } });
+
+      expect(result[0]).toBe('div');
+      expect(result[1]).toEqual({ class: 'foo' });
+    });
+  });
+
+  describe('addKeyboardShortcuts', () => {
+    it('does nothing when current block is not div', () => {
+      const mockEditor = {
+        state: {
+          selection: {
+            $from: {
+              parent: { type: { name: 'paragraph' } },
+            },
+          },
+        },
+      };
+
+      const shortcuts = DivNode.addKeyboardShortcuts.call({ editor: mockEditor });
+      const handled = shortcuts.Enter();
+
+      expect(handled).toBe(false);
+    });
+
+    it('turns div into paragraph and splits when Enter is pressed in a div', () => {
+      const chain = {
+        focus: jest.fn(() => chain),
+        setNode: jest.fn(() => chain),
+        splitBlock: jest.fn(() => chain),
+        run: jest.fn(() => true),
+      };
+
+      const mockEditor = {
+        state: {
+          selection: {
+            $from: {
+              parent: { type: { name: 'div' } },
+            },
+          },
+        },
+        chain: () => chain,
+      };
+
+      const shortcuts = DivNode.addKeyboardShortcuts.call({ editor: mockEditor });
+      const handled = shortcuts.Enter();
+
+      expect(chain.focus).toHaveBeenCalled();
+      expect(chain.setNode).toHaveBeenCalledWith('paragraph');
+      expect(chain.splitBlock).toHaveBeenCalled();
+      expect(chain.run).toHaveBeenCalled();
+      expect(handled).toBe(true);
+    });
+  });
+});

package/src/extensions/__tests__/ensure-empty-root-div.test.js

@@ -0,0 +1,57 @@
+import { Editor } from '@tiptap/core';
+import StarterKit from '@tiptap/starter-kit';
+import { DivNode } from '../div-node';
+import { EnsureEmptyRootIsDiv } from '../ensure-empty-root-div';
+
+/** Match EditableHtml so TrailingNode does not add a second empty block next to an empty paragraph. */
+const starterKitConfigured = StarterKit.configure({
+  trailingNode: {
+    node: 'paragraph',
+    notAfter: ['paragraph', 'div'],
+  },
+});
+
+describe('EnsureEmptyRootIsDiv', () => {
+  const extensions = [starterKitConfigured, DivNode, EnsureEmptyRootIsDiv];
+
+  let editor;
+
+  afterEach(() => {
+    if (editor) {
+      editor.destroy();
+      editor = null;
+    }
+  });
+
+  it('replaces a lone root paragraph with an empty div after select-all and delete (full delete flow)', () => {
+    editor = new Editor({
+      extensions,
+      content: '<p>hello</p>',
+    });
+
+    editor.chain().focus().selectAll().deleteSelection().run();
+
+    expect(editor.state.doc.childCount).toBe(1);
+    expect(editor.state.doc.firstChild.type.name).toBe('div');
+    expect(editor.state.doc.firstChild.textContent).toBe('');
+  });
+
+  it('does not replace a root paragraph that still has text', () => {
+    editor = new Editor({
+      extensions,
+      content: '<p>x</p>',
+    });
+
+    expect(editor.state.doc.firstChild.type.name).toBe('paragraph');
+  });
+
+  it('does not run when there is more than one top-level block', () => {
+    editor = new Editor({
+      extensions,
+      content: '<p>a</p><p>b</p>',
+    });
+
+    expect(editor.state.doc.childCount).toBe(2);
+    expect(editor.state.doc.firstChild.type.name).toBe('paragraph');
+  });
+});

package/src/extensions/__tests__/ensure-list-item-content-is-div.test.js

@@ -0,0 +1,44 @@
+import { EnsureListItemContentIsDiv } from '../ensure-list-item-content-is-div';
+
+describe('EnsureListItemContentIsDiv', () => {
+  it('registers a ProseMirror plugin that rewrites listItem paragraph children to div', () => {
+    const plugins = EnsureListItemContentIsDiv.config.addProseMirrorPlugins();
+    expect(Array.isArray(plugins)).toBe(true);
+    expect(plugins).toHaveLength(1);
+
+    const plugin = plugins[0];
+    const divType = { name: 'div' };
+    const tr = { setNodeMarkup: jest.fn() };
+
+    const paragraphChild = {
+      type: { name: 'paragraph' },
+      attrs: { class: 'x' },
+      nodeSize: 6,
+    };
+
+    const listItemNode = {
+      type: { name: 'listItem' },
+      forEach: (cb) => cb(paragraphChild),
+    };
+
+    const newState = {
+      schema: { nodes: { div: divType } },
+      tr,
+      doc: {
+        descendants: (cb) => cb(listItemNode, 10),
+      },
+    };
+
+    const result = plugin.spec.appendTransaction([{ docChanged: true }], {}, newState);
+
+    expect(tr.setNodeMarkup).toHaveBeenCalledWith(11, divType, paragraphChild.attrs);
+    expect(result).toBe(tr);
+  });
+
+  it('returns null when there is no document change', () => {
+    const plugin = EnsureListItemContentIsDiv.config.addProseMirrorPlugins()[0];
+
+    const result = plugin.spec.appendTransaction([{ docChanged: false }], {}, {});
+    expect(result).toBeNull();
+  });
+});

package/src/extensions/__tests__/extended-list-item.test.js

@@ -0,0 +1,13 @@
+import { ExtendedListItem } from '../extended-list-item';
+
+describe('ExtendedListItem', () => {
+  it('extends listItem and prefers div over paragraph in content spec', () => {
+    expect(ExtendedListItem.name).toBe('listItem');
+
+    const content =
+      ExtendedListItem.options?.content ?? ExtendedListItem.config?.content ?? ExtendedListItem.extendOptions?.content;
+
+    expect(String(content)).toMatch(/^\(div \| paragraph/);
+    expect(String(content)).toContain('imageUploadNode');
+  });
+});

package/src/extensions/__tests__/extended-table-cell.test.js

@@ -0,0 +1,22 @@
+import { ExtendedTableCell, ExtendedTableHeader } from '../extended-table-cell';
+
+describe('ExtendedTableCell / ExtendedTableHeader', () => {
+  it('exports cell and header extensions with div preferred over paragraph in content spec', () => {
+    expect(ExtendedTableCell.name).toBe('tableCell');
+    expect(ExtendedTableHeader.name).toBe('tableHeader');
+
+    const cellContent =
+      ExtendedTableCell.options?.content ??
+      ExtendedTableCell.config?.content ??
+      ExtendedTableCell.extendOptions?.content;
+
+    expect(String(cellContent)).toMatch(/^\(div \| paragraph/);
+
+    const headerContent =
+      ExtendedTableHeader.options?.content ??
+      ExtendedTableHeader.config?.content ??
+      ExtendedTableHeader.extendOptions?.content;
+
+    expect(headerContent).toBe(cellContent);
+  });
+});

package/src/extensions/__tests__/extended-table.test.js

@@ -1,12 +1,109 @@
-import ExtendedTable from '../extended-table';
+import ExtendedTable, { applyPresentationToTableElement, ExtendedTableView } from '../extended-table';
+
+const mockTableViewState = { updateReturns: true };
 
 jest.mock('@tiptap/extension-table', () => ({
   Table: {
     extend: jest.fn((config) => config),
   },
+  TableView: class TableView {
+    constructor() {
+      this.table = {
+        style: { setProperty: jest.fn() },
+        setAttribute: jest.fn(),
+      };
+    }
+
+    update() {
+      return mockTableViewState.updateReturns;
+    }
+  },
 }));
 
 describe('ExtendedTable', () => {
+  beforeEach(() => {
+    mockTableViewState.updateReturns = true;
+  });
+
+  describe('applyPresentationToTableElement', () => {
+    it('sets default border and theme styles', () => {
+      const table = document.createElement('table');
+      const setProperty = jest.spyOn(table.style, 'setProperty');
+
+      applyPresentationToTableElement(table, {});
+
+      expect(table.getAttribute('border')).toBe('1');
+      expect(setProperty).toHaveBeenCalledWith('color', 'var(--pie-text, black)');
+      expect(setProperty).toHaveBeenCalledWith('background-color', 'var(--pie-background, rgba(255, 255, 255))');
+      setProperty.mockRestore();
+    });
+
+    it('uses explicit border from attrs', () => {
+      const table = document.createElement('table');
+      applyPresentationToTableElement(table, { border: '0' });
+
+      expect(table.getAttribute('border')).toBe('0');
+    });
+
+    it('treats empty border as default', () => {
+      const table = document.createElement('table');
+      applyPresentationToTableElement(table, { border: '' });
+
+      expect(table.getAttribute('border')).toBe('1');
+    });
+  });
+
+  describe('ExtendedTableView', () => {
+    it('applies presentation after construction', () => {
+      const node = { attrs: { border: '2' } };
+      const view = new ExtendedTableView(node, 25);
+
+      expect(view.table.setAttribute).toHaveBeenCalledWith('border', '2');
+      expect(view.table.style.setProperty).toHaveBeenCalledWith('color', 'var(--pie-text, black)');
+      expect(view.table.style.setProperty).toHaveBeenCalledWith(
+        'background-color',
+        'var(--pie-background, rgba(255, 255, 255))',
+      );
+    });
+
+    it('reapplies presentation when super.update returns true', () => {
+      const view = new ExtendedTableView({ attrs: { border: '1' } }, 25);
+      view.table.setAttribute.mockClear();
+      view.table.style.setProperty.mockClear();
+
+      view.update({ attrs: { border: '0' } });
+
+      expect(view.table.setAttribute).toHaveBeenCalledWith('border', '0');
+      expect(view.table.style.setProperty).toHaveBeenCalledWith('color', 'var(--pie-text, black)');
+      expect(view.table.style.setProperty).toHaveBeenCalledWith(
+        'background-color',
+        'var(--pie-background, rgba(255, 255, 255))',
+      );
+    });
+
+    it('does not reapply presentation when super.update returns false', () => {
+      mockTableViewState.updateReturns = false;
+      const view = new ExtendedTableView({ attrs: { border: '1' } }, 25);
+      view.table.setAttribute.mockClear();
+      view.table.style.setProperty.mockClear();
+
+      const ok = view.update({ attrs: { border: '0' } });
+
+      expect(ok).toBe(false);
+      expect(view.table.setAttribute).not.toHaveBeenCalled();
+      expect(view.table.style.setProperty).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('addOptions', () => {
+    it('enables resizable table view with zero handle width for colgroup sync', () => {
+      const options = ExtendedTable.addOptions();
+      expect(options.resizable).toBe(true);
+      expect(options.handleWidth).toBe(0);
+      expect(options.View).toBe(ExtendedTableView);
+    });
+  });
+
   describe('addAttributes', () => {
     it('returns border attribute with default value', () => {
       const attributes = ExtendedTable.addAttributes();