@pie-lib/editable-html-tip-tap 2.1.20-beta.1 → 2.1.20-beta.10

package/lib/components/__tests__/MenuBar.test.js

@@ -0,0 +1,502 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _MenuBar = _interopRequireDefault(require("../MenuBar"));
+jest.mock('@tiptap/react', function () {
+  return {
+    EditorContent: function EditorContent(_ref) {
+      var editor = _ref.editor;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "editor-content"
+      });
+    },
+    useEditorState: function useEditorState(_ref2) {
+      var selector = _ref2.selector;
+      var mockEditor = {
+        isActive: jest.fn(function () {
+          return false;
+        }),
+        can: jest.fn(function () {
+          return {
+            chain: jest.fn(function () {
+              return {
+                toggleBold: jest.fn(function () {
+                  return {
+                    run: jest.fn(function () {
+                      return true;
+                    })
+                  };
+                }),
+                insertTable: jest.fn(function () {
+                  return {
+                    run: jest.fn(function () {
+                      return true;
+                    })
+                  };
+                }),
+                toggleItalic: jest.fn(function () {
+                  return {
+                    run: jest.fn(function () {
+                      return true;
+                    })
+                  };
+                }),
+                toggleStrike: jest.fn(function () {
+                  return {
+                    run: jest.fn(function () {
+                      return true;
+                    })
+                  };
+                }),
+                toggleCode: jest.fn(function () {
+                  return {
+                    run: jest.fn(function () {
+                      return true;
+                    })
+                  };
+                }),
+                unsetAllMarks: jest.fn(function () {
+                  return {
+                    run: jest.fn(function () {
+                      return true;
+                    })
+                  };
+                }),
+                undo: jest.fn(function () {
+                  return {
+                    run: jest.fn(function () {
+                      return true;
+                    })
+                  };
+                }),
+                redo: jest.fn(function () {
+                  return {
+                    run: jest.fn(function () {
+                      return true;
+                    })
+                  };
+                })
+              };
+            })
+          };
+        }),
+        getAttributes: jest.fn(function () {
+          return {
+            border: '1'
+          };
+        }),
+        commandManager: {},
+        isFocused: true,
+        state: {
+          selection: {}
+        }
+      };
+      return selector({
+        editor: mockEditor
+      });
+    }
+  };
+});
+jest.mock('prosemirror-state', function () {
+  return {
+    NodeSelection: jest.fn()
+  };
+});
+jest.mock('../CharacterPicker', function () {
+  return {
+    CharacterIcon: function CharacterIcon(_ref3) {
+      var letter = _ref3.letter;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "character-icon"
+      }, letter);
+    },
+    CharacterPicker: function CharacterPicker(_ref4) {
+      var onClose = _ref4.onClose;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "character-picker"
+      }, /*#__PURE__*/_react["default"].createElement("button", {
+        onClick: onClose,
+        "data-testid": "close-picker"
+      }, "Close"));
+    }
+  };
+});
+jest.mock('../common/done-button', function () {
+  return {
+    DoneButton: function DoneButton(_ref5) {
+      var onClick = _ref5.onClick;
+      return /*#__PURE__*/_react["default"].createElement("button", {
+        onClick: onClick,
+        "data-testid": "done-button"
+      }, "Done");
+    }
+  };
+});
+describe('StyledMenuBar', function () {
+  var mockEditor = {
+    chain: jest.fn(function () {
+      return {
+        focus: jest.fn(function () {
+          return {
+            insertTable: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            toggleBold: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            toggleItalic: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            toggleStrike: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            toggleCode: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            toggleUnderline: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            toggleSubscript: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            toggleSuperscript: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            setImageUploadNode: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            insertMedia: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            toggleHeading: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            insertMath: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            toggleBulletList: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            toggleOrderedList: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            undo: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            redo: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            addRowAfter: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            deleteRow: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            addColumnAfter: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            deleteColumn: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            deleteTable: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            }),
+            insertResponseArea: jest.fn(function () {
+              return {
+                run: jest.fn()
+              };
+            })
+          };
+        })
+      };
+    }),
+    can: jest.fn(function () {
+      return {
+        chain: jest.fn(function () {
+          return {
+            toggleBold: jest.fn(function () {
+              return {
+                run: jest.fn(function () {
+                  return true;
+                })
+              };
+            }),
+            insertTable: jest.fn(function () {
+              return {
+                run: jest.fn(function () {
+                  return true;
+                })
+              };
+            }),
+            undo: jest.fn(function () {
+              return {
+                run: jest.fn(function () {
+                  return true;
+                })
+              };
+            }),
+            redo: jest.fn(function () {
+              return {
+                run: jest.fn(function () {
+                  return true;
+                })
+              };
+            })
+          };
+        })
+      };
+    }),
+    isActive: jest.fn(function (name) {
+      if (name === 'bold') return true;
+      if (name === 'italic') return false;
+      return false;
+    }),
+    getAttributes: jest.fn(function () {
+      return {
+        border: '1'
+      };
+    }),
+    getHTML: jest.fn(function () {
+      return '<p>Test</p>';
+    }),
+    commands: {
+      blur: jest.fn(),
+      openCSSClassDialog: jest.fn(),
+      updateAttributes: jest.fn()
+    },
+    isFocused: true,
+    state: {
+      selection: {}
+    },
+    _toolbarOpened: false
+  };
+  var defaultProps = {
+    editor: mockEditor,
+    activePlugins: ['bold', 'italic', 'underline', 'table'],
+    toolbarOpts: {},
+    responseAreaProps: {
+      type: 'explicit-constructed-response'
+    }
+  };
+  beforeEach(function () {
+    jest.clearAllMocks();
+  });
+  it('renders without crashing', function () {
+    var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], defaultProps)),
+      container = _render.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('renders toolbar with buttons', function () {
+    var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], defaultProps)),
+      container = _render2.container;
+    var buttons = container.querySelectorAll('button');
+    expect(buttons.length).toBeGreaterThan(0);
+  });
+  it('shows bold button when bold plugin is active', function () {
+    var _render3 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], defaultProps)),
+      container = _render3.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('hides buttons when isTable is true', function () {
+    var _render4 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        activePlugins: ['table']
+      }))),
+      container = _render4.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('shows table buttons when in table context', function () {
+    var _render5 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        activePlugins: ['table']
+      }))),
+      container = _render5.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('handles button clicks', function () {
+    var _render6 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], defaultProps)),
+      container = _render6.container;
+    var button = container.querySelector('button');
+    if (button) {
+      _react2.fireEvent.click(button);
+    }
+    expect(container).toBeInTheDocument();
+  });
+  it('shows done button when toolbarOpts.showDone is true', function () {
+    var _render7 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        toolbarOpts: {
+          showDone: true
+        },
+        onChange: jest.fn()
+      }))),
+      getByTestId = _render7.getByTestId;
+    expect(getByTestId('done-button')).toBeInTheDocument();
+  });
+  it('does not show done button when toolbarOpts.showDone is false', function () {
+    var _render8 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        toolbarOpts: {
+          showDone: false
+        }
+      }))),
+      queryByTestId = _render8.queryByTestId;
+    expect(queryByTestId('done-button')).not.toBeInTheDocument();
+  });
+  it('handles done button click', function () {
+    var onChange = jest.fn();
+    var _render9 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        toolbarOpts: {
+          showDone: true
+        },
+        onChange: onChange
+      }))),
+      getByTestId = _render9.getByTestId;
+    _react2.fireEvent.click(getByTestId('done-button'));
+    expect(onChange).toHaveBeenCalledWith('<p>Test</p>');
+    expect(mockEditor.commands.blur).toHaveBeenCalled();
+  });
+  it('applies custom minWidth from toolbarOpts', function () {
+    var _render0 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        toolbarOpts: {
+          minWidth: 500
+        }
+      }))),
+      container = _render0.container;
+    var toolbar = container.querySelector('.toolbar');
+    expect(toolbar).toHaveStyle({
+      minWidth: '500px'
+    });
+  });
+  it('applies hidden class when toolbarOpts.isHidden is true', function () {
+    var _render1 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        toolbarOpts: {
+          isHidden: true
+        }
+      }))),
+      container = _render1.container;
+    var toolbar = container.querySelector('.toolbar');
+    expect(toolbar).toHaveClass('hidden');
+  });
+  it('shows character picker when language character button is clicked', function () {
+    var _render10 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        activePlugins: ['languageCharacters']
+      }))),
+      container = _render10.container,
+      queryByTestId = _render10.queryByTestId;
+    expect(queryByTestId('character-picker')).not.toBeInTheDocument();
+  });
+  it('applies focused class when editor is focused', function () {
+    var _render11 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        toolbarOpts: {
+          alwaysVisible: false
+        }
+      }))),
+      container = _render11.container;
+    var toolbar = container.querySelector('.toolbar');
+    expect(toolbar).toHaveClass('focused');
+  });
+  it('shows response area button when responseArea plugin is active', function () {
+    var _render12 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        activePlugins: ['responseArea']
+      }))),
+      container = _render12.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('prevents default on mouse down', function () {
+    var _render13 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], defaultProps)),
+      container = _render13.container;
+    var toolbar = container.querySelector('.toolbar');
+    var event = new MouseEvent('mousedown', {
+      bubbles: true,
+      cancelable: true
+    });
+    var preventDefaultSpy = jest.spyOn(event, 'preventDefault');
+    toolbar === null || toolbar === void 0 || toolbar.dispatchEvent(event);
+    expect(preventDefaultSpy).toHaveBeenCalled();
+  });
+  it('calculates hasTextSelectionInTable correctly when selection is not empty in table', function () {
+    // This test verifies the hasTextSelectionInTable state computation
+    var _render14 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        activePlugins: ['table', 'bold', 'italic']
+      }))),
+      container = _render14.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('hides table manipulation buttons when text is selected in table', function () {
+    // When hasTextSelectionInTable is true, table row/column buttons should be hidden
+    var _render15 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        activePlugins: ['table']
+      }))),
+      container = _render15.container;
+    // The component should render but table manipulation buttons should be conditional
+    expect(container).toBeInTheDocument();
+  });
+  it('shows table manipulation buttons when no text is selected in table', function () {
+    // When hasTextSelectionInTable is false, table row/column buttons should be visible
+    var _render16 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        activePlugins: ['table']
+      }))),
+      container = _render16.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('shows text formatting buttons regardless of table state', function () {
+    // Bold, italic, etc. should always be visible when their plugin is active
+    var _render17 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        activePlugins: ['bold', 'italic', 'underline']
+      }))),
+      container = _render17.container;
+    var buttons = container.querySelectorAll('button');
+    expect(buttons.length).toBeGreaterThan(0);
+  });
+  it('does not hide text formatting buttons when in table', function () {
+    // Verify that the removal of "|| state.isTable" condition works correctly
+    var _render18 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MenuBar["default"], (0, _extends2["default"])({}, defaultProps, {
+        activePlugins: ['table', 'bold', 'italic']
+      }))),
+      container = _render18.container;
+    expect(container).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_MenuBar","jest","mock","EditorContent","_ref","editor","createElement","useEditorState","_ref2","selector","mockEditor","isActive","fn","can","chain","toggleBold","run","insertTable","toggleItalic","toggleStrike","toggleCode","unsetAllMarks","undo","redo","getAttributes","border","commandManager","isFocused","state","selection","NodeSelection","CharacterIcon","_ref3","letter","CharacterPicker","_ref4","onClose","onClick","DoneButton","_ref5","describe","focus","toggleUnderline","toggleSubscript","toggleSuperscript","setImageUploadNode","insertMedia","toggleHeading","insertMath","toggleBulletList","toggleOrderedList","addRowAfter","deleteRow","addColumnAfter","deleteColumn","deleteTable","insertResponseArea","name","getHTML","commands","blur","openCSSClassDialog","updateAttributes","_toolbarOpened","defaultProps","activePlugins","toolbarOpts","responseAreaProps","type","beforeEach","clearAllMocks","it","_render","render","container","expect","toBeInTheDocument","_render2","buttons","querySelectorAll","length","toBeGreaterThan","_render3","_render4","_extends2","_render5","_render6","button","querySelector","fireEvent","click","_render7","showDone","onChange","getByTestId","_render8","queryByTestId","not","_render9","toHaveBeenCalledWith","toHaveBeenCalled","_render0","minWidth","toolbar","toHaveStyle","_render1","isHidden","toHaveClass","_render10","_render11","alwaysVisible","_render12","_render13","event","MouseEvent","bubbles","cancelable","preventDefaultSpy","spyOn","dispatchEvent","_render14","_render15","_render16","_render17","_render18"],"sources":["../../../src/components/__tests__/MenuBar.test.jsx"],"sourcesContent":["import React from 'react';\nimport { fireEvent, render } from '@testing-library/react';\nimport StyledMenuBar from '../MenuBar';\n\njest.mock('@tiptap/react', () => ({\n  EditorContent: ({ editor }) => <div data-testid=\"editor-content\" />,\n  useEditorState: ({ selector }) => {\n    const mockEditor = {\n      isActive: jest.fn(() => false),\n      can: jest.fn(() => ({\n        chain: jest.fn(() => ({\n          toggleBold: jest.fn(() => ({ run: jest.fn(() => true) })),\n          insertTable: jest.fn(() => ({ run: jest.fn(() => true) })),\n          toggleItalic: jest.fn(() => ({ run: jest.fn(() => true) })),\n          toggleStrike: jest.fn(() => ({ run: jest.fn(() => true) })),\n          toggleCode: jest.fn(() => ({ run: jest.fn(() => true) })),\n          unsetAllMarks: jest.fn(() => ({ run: jest.fn(() => true) })),\n          undo: jest.fn(() => ({ run: jest.fn(() => true) })),\n          redo: jest.fn(() => ({ run: jest.fn(() => true) })),\n        })),\n      })),\n      getAttributes: jest.fn(() => ({ border: '1' })),\n      commandManager: {},\n      isFocused: true,\n      state: {\n        selection: {},\n      },\n    };\n\n    return selector({ editor: mockEditor });\n  },\n}));\n\njest.mock('prosemirror-state', () => ({\n  NodeSelection: jest.fn(),\n}));\n\njest.mock('../CharacterPicker', () => ({\n  CharacterIcon: ({ letter }) => <div data-testid=\"character-icon\">{letter}</div>,\n  CharacterPicker: ({ onClose }) => (\n    <div data-testid=\"character-picker\">\n      <button onClick={onClose} data-testid=\"close-picker\">\n        Close\n      </button>\n    </div>\n  ),\n}));\n\njest.mock('../common/done-button', () => ({\n  DoneButton: ({ onClick }) => (\n    <button onClick={onClick} data-testid=\"done-button\">\n      Done\n    </button>\n  ),\n}));\n\ndescribe('StyledMenuBar', () => {\n  const mockEditor = {\n    chain: jest.fn(() => ({\n      focus: jest.fn(() => ({\n        insertTable: jest.fn(() => ({ run: jest.fn() })),\n        toggleBold: jest.fn(() => ({ run: jest.fn() })),\n        toggleItalic: jest.fn(() => ({ run: jest.fn() })),\n        toggleStrike: jest.fn(() => ({ run: jest.fn() })),\n        toggleCode: jest.fn(() => ({ run: jest.fn() })),\n        toggleUnderline: jest.fn(() => ({ run: jest.fn() })),\n        toggleSubscript: jest.fn(() => ({ run: jest.fn() })),\n        toggleSuperscript: jest.fn(() => ({ run: jest.fn() })),\n        setImageUploadNode: jest.fn(() => ({ run: jest.fn() })),\n        insertMedia: jest.fn(() => ({ run: jest.fn() })),\n        toggleHeading: jest.fn(() => ({ run: jest.fn() })),\n        insertMath: jest.fn(() => ({ run: jest.fn() })),\n        toggleBulletList: jest.fn(() => ({ run: jest.fn() })),\n        toggleOrderedList: jest.fn(() => ({ run: jest.fn() })),\n        undo: jest.fn(() => ({ run: jest.fn() })),\n        redo: jest.fn(() => ({ run: jest.fn() })),\n        addRowAfter: jest.fn(() => ({ run: jest.fn() })),\n        deleteRow: jest.fn(() => ({ run: jest.fn() })),\n        addColumnAfter: jest.fn(() => ({ run: jest.fn() })),\n        deleteColumn: jest.fn(() => ({ run: jest.fn() })),\n        deleteTable: jest.fn(() => ({ run: jest.fn() })),\n        insertResponseArea: jest.fn(() => ({ run: jest.fn() })),\n      })),\n    })),\n    can: jest.fn(() => ({\n      chain: jest.fn(() => ({\n        toggleBold: jest.fn(() => ({ run: jest.fn(() => true) })),\n        insertTable: jest.fn(() => ({ run: jest.fn(() => true) })),\n        undo: jest.fn(() => ({ run: jest.fn(() => true) })),\n        redo: jest.fn(() => ({ run: jest.fn(() => true) })),\n      })),\n    })),\n    isActive: jest.fn((name) => {\n      if (name === 'bold') return true;\n      if (name === 'italic') return false;\n      return false;\n    }),\n    getAttributes: jest.fn(() => ({ border: '1' })),\n    getHTML: jest.fn(() => '<p>Test</p>'),\n    commands: {\n      blur: jest.fn(),\n      openCSSClassDialog: jest.fn(),\n      updateAttributes: jest.fn(),\n    },\n    isFocused: true,\n    state: {\n      selection: {},\n    },\n    _toolbarOpened: false,\n  };\n\n  const defaultProps = {\n    editor: mockEditor,\n    activePlugins: ['bold', 'italic', 'underline', 'table'],\n    toolbarOpts: {},\n    responseAreaProps: { type: 'explicit-constructed-response' },\n  };\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n  });\n\n  it('renders without crashing', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('renders toolbar with buttons', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} />);\n    const buttons = container.querySelectorAll('button');\n    expect(buttons.length).toBeGreaterThan(0);\n  });\n\n  it('shows bold button when bold plugin is active', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('hides buttons when isTable is true', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} activePlugins={['table']} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('shows table buttons when in table context', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} activePlugins={['table']} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('handles button clicks', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} />);\n    const button = container.querySelector('button');\n    if (button) {\n      fireEvent.click(button);\n    }\n    expect(container).toBeInTheDocument();\n  });\n\n  it('shows done button when toolbarOpts.showDone is true', () => {\n    const { getByTestId } = render(\n      <StyledMenuBar {...defaultProps} toolbarOpts={{ showDone: true }} onChange={jest.fn()} />,\n    );\n    expect(getByTestId('done-button')).toBeInTheDocument();\n  });\n\n  it('does not show done button when toolbarOpts.showDone is false', () => {\n    const { queryByTestId } = render(<StyledMenuBar {...defaultProps} toolbarOpts={{ showDone: false }} />);\n    expect(queryByTestId('done-button')).not.toBeInTheDocument();\n  });\n\n  it('handles done button click', () => {\n    const onChange = jest.fn();\n    const { getByTestId } = render(\n      <StyledMenuBar {...defaultProps} toolbarOpts={{ showDone: true }} onChange={onChange} />,\n    );\n    fireEvent.click(getByTestId('done-button'));\n    expect(onChange).toHaveBeenCalledWith('<p>Test</p>');\n    expect(mockEditor.commands.blur).toHaveBeenCalled();\n  });\n\n  it('applies custom minWidth from toolbarOpts', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} toolbarOpts={{ minWidth: 500 }} />);\n    const toolbar = container.querySelector('.toolbar');\n    expect(toolbar).toHaveStyle({ minWidth: '500px' });\n  });\n\n  it('applies hidden class when toolbarOpts.isHidden is true', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} toolbarOpts={{ isHidden: true }} />);\n    const toolbar = container.querySelector('.toolbar');\n    expect(toolbar).toHaveClass('hidden');\n  });\n\n  it('shows character picker when language character button is clicked', () => {\n    const { container, queryByTestId } = render(\n      <StyledMenuBar {...defaultProps} activePlugins={['languageCharacters']} />,\n    );\n    expect(queryByTestId('character-picker')).not.toBeInTheDocument();\n  });\n\n  it('applies focused class when editor is focused', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} toolbarOpts={{ alwaysVisible: false }} />);\n    const toolbar = container.querySelector('.toolbar');\n    expect(toolbar).toHaveClass('focused');\n  });\n\n  it('shows response area button when responseArea plugin is active', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} activePlugins={['responseArea']} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('prevents default on mouse down', () => {\n    const { container } = render(<StyledMenuBar {...defaultProps} />);\n    const toolbar = container.querySelector('.toolbar');\n    const event = new MouseEvent('mousedown', { bubbles: true, cancelable: true });\n    const preventDefaultSpy = jest.spyOn(event, 'preventDefault');\n    toolbar?.dispatchEvent(event);\n    expect(preventDefaultSpy).toHaveBeenCalled();\n  });\n\n  it('calculates hasTextSelectionInTable correctly when selection is not empty in table', () => {\n    // This test verifies the hasTextSelectionInTable state computation\n    const { container } = render(<StyledMenuBar {...defaultProps} activePlugins={['table', 'bold', 'italic']} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('hides table manipulation buttons when text is selected in table', () => {\n    // When hasTextSelectionInTable is true, table row/column buttons should be hidden\n    const { container } = render(<StyledMenuBar {...defaultProps} activePlugins={['table']} />);\n    // The component should render but table manipulation buttons should be conditional\n    expect(container).toBeInTheDocument();\n  });\n\n  it('shows table manipulation buttons when no text is selected in table', () => {\n    // When hasTextSelectionInTable is false, table row/column buttons should be visible\n    const { container } = render(<StyledMenuBar {...defaultProps} activePlugins={['table']} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('shows text formatting buttons regardless of table state', () => {\n    // Bold, italic, etc. should always be visible when their plugin is active\n    const { container } = render(<StyledMenuBar {...defaultProps} activePlugins={['bold', 'italic', 'underline']} />);\n    const buttons = container.querySelectorAll('button');\n    expect(buttons.length).toBeGreaterThan(0);\n  });\n\n  it('does not hide text formatting buttons when in table', () => {\n    // Verify that the removal of \"|| state.isTable\" condition works correctly\n    const { container } = render(<StyledMenuBar {...defaultProps} activePlugins={['table', 'bold', 'italic']} />);\n    expect(container).toBeInTheDocument();\n  });\n});\n"],"mappings":"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","ignoreList":[]}