@pie-lib/editable-html-tip-tap 1.1.1-next.3 → 1.1.1-next.4

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

@@ -0,0 +1,96 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _MediaWrapper = _interopRequireDefault(require("../media/MediaWrapper"));
+describe('MediaWrapper', function () {
+  it('renders without crashing', function () {
+    var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], null, "Content")),
+      container = _render.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('renders children', function () {
+    var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], null, /*#__PURE__*/_react["default"].createElement("div", null, "Test Content"))),
+      getByText = _render2.getByText;
+    expect(getByText('Test Content')).toBeInTheDocument();
+  });
+  it('applies default width of 300', function () {
+    var _render3 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], null, "Content")),
+      container = _render3.container;
+    var wrapper = container.firstChild;
+    expect(wrapper).toHaveStyle({
+      width: '300px'
+    });
+  });
+  it('applies custom width from props', function () {
+    var _render4 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], {
+        width: 500
+      }, "Content")),
+      container = _render4.container;
+    var wrapper = container.firstChild;
+    expect(wrapper).toHaveStyle({
+      width: '500px'
+    });
+  });
+  it('applies string width', function () {
+    var _render5 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], {
+        width: "50%"
+      }, "Content")),
+      container = _render5.container;
+    var wrapper = container.firstChild;
+    expect(wrapper).toHaveStyle({
+      width: '50%'
+    });
+  });
+  it('applies editor styles when editor prop is true', function () {
+    var _render6 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], {
+        editor: true
+      }, "Content")),
+      container = _render6.container;
+    var wrapper = container.firstChild;
+    expect(wrapper).toHaveStyle({
+      display: 'inline-block',
+      overflow: 'hidden'
+    });
+  });
+  it('does not apply editor styles when editor prop is false', function () {
+    var _render7 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], {
+        editor: false
+      }, "Content")),
+      container = _render7.container;
+    var wrapper = container.firstChild;
+    expect(wrapper).not.toHaveStyle({
+      display: 'inline-block'
+    });
+  });
+  it('has relative positioning', function () {
+    var _render8 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], null, "Content")),
+      container = _render8.container;
+    var wrapper = container.firstChild;
+    expect(wrapper).toHaveStyle({
+      position: 'relative'
+    });
+  });
+  it('renders multiple children', function () {
+    var _render9 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], null, /*#__PURE__*/_react["default"].createElement("div", null, "First"), /*#__PURE__*/_react["default"].createElement("div", null, "Second"))),
+      getByText = _render9.getByText;
+    expect(getByText('First')).toBeInTheDocument();
+    expect(getByText('Second')).toBeInTheDocument();
+  });
+  it('passes additional props through', function () {
+    var _render0 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], {
+        "data-testid": "custom",
+        className: "custom-class"
+      }, "Content")),
+      container = _render0.container;
+    var wrapper = container.firstChild;
+    expect(wrapper).toHaveAttribute('data-testid', 'custom');
+  });
+  it('renders without children', function () {
+    var _render1 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_MediaWrapper["default"], null)),
+      container = _render1.container;
+    expect(container.firstChild).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_MediaWrapper","describe","it","_render","render","createElement","container","expect","toBeInTheDocument","_render2","getByText","_render3","wrapper","firstChild","toHaveStyle","width","_render4","_render5","_render6","editor","display","overflow","_render7","not","_render8","position","_render9","_render0","className","toHaveAttribute","_render1"],"sources":["../../../src/components/__tests__/MediaWrapper.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render } from '@testing-library/react';\nimport MediaWrapper from '../media/MediaWrapper';\n\ndescribe('MediaWrapper', () => {\n  it('renders without crashing', () => {\n    const { container } = render(<MediaWrapper>Content</MediaWrapper>);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('renders children', () => {\n    const { getByText } = render(\n      <MediaWrapper>\n        <div>Test Content</div>\n      </MediaWrapper>,\n    );\n    expect(getByText('Test Content')).toBeInTheDocument();\n  });\n\n  it('applies default width of 300', () => {\n    const { container } = render(<MediaWrapper>Content</MediaWrapper>);\n    const wrapper = container.firstChild;\n    expect(wrapper).toHaveStyle({ width: '300px' });\n  });\n\n  it('applies custom width from props', () => {\n    const { container } = render(<MediaWrapper width={500}>Content</MediaWrapper>);\n    const wrapper = container.firstChild;\n    expect(wrapper).toHaveStyle({ width: '500px' });\n  });\n\n  it('applies string width', () => {\n    const { container } = render(<MediaWrapper width=\"50%\">Content</MediaWrapper>);\n    const wrapper = container.firstChild;\n    expect(wrapper).toHaveStyle({ width: '50%' });\n  });\n\n  it('applies editor styles when editor prop is true', () => {\n    const { container } = render(<MediaWrapper editor={true}>Content</MediaWrapper>);\n    const wrapper = container.firstChild;\n    expect(wrapper).toHaveStyle({ display: 'inline-block', overflow: 'hidden' });\n  });\n\n  it('does not apply editor styles when editor prop is false', () => {\n    const { container } = render(<MediaWrapper editor={false}>Content</MediaWrapper>);\n    const wrapper = container.firstChild;\n    expect(wrapper).not.toHaveStyle({ display: 'inline-block' });\n  });\n\n  it('has relative positioning', () => {\n    const { container } = render(<MediaWrapper>Content</MediaWrapper>);\n    const wrapper = container.firstChild;\n    expect(wrapper).toHaveStyle({ position: 'relative' });\n  });\n\n  it('renders multiple children', () => {\n    const { getByText } = render(\n      <MediaWrapper>\n        <div>First</div>\n        <div>Second</div>\n      </MediaWrapper>,\n    );\n    expect(getByText('First')).toBeInTheDocument();\n    expect(getByText('Second')).toBeInTheDocument();\n  });\n\n  it('passes additional props through', () => {\n    const { container } = render(\n      <MediaWrapper data-testid=\"custom\" className=\"custom-class\">\n        Content\n      </MediaWrapper>,\n    );\n    const wrapper = container.firstChild;\n    expect(wrapper).toHaveAttribute('data-testid', 'custom');\n  });\n\n  it('renders without children', () => {\n    const { container } = render(<MediaWrapper />);\n    expect(container.firstChild).toBeInTheDocument();\n  });\n});\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,459 @@
+"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'
+          };
+        }),
+        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();
+  });
+});
+//# 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","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"],"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      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"],"mappings":"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","ignoreList":[]}