@pie-lib/editable-html-tip-tap 2.1.20-beta.6 → 2.1.20-beta.8

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

@@ -0,0 +1,839 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _mathRendering = require("@pie-lib/math-rendering");
+var _InlineDropdown = _interopRequireDefault(require("../respArea/InlineDropdown"));
+var _excluded = ["children"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+jest.mock('@pie-lib/math-rendering', function () {
+  return {
+    renderMath: jest.fn()
+  };
+});
+jest.mock('@tiptap/react', function () {
+  return {
+    NodeViewWrapper: function NodeViewWrapper(_ref) {
+      var children = _ref.children,
+        props = (0, _objectWithoutProperties2["default"])(_ref, _excluded);
+      return /*#__PURE__*/_react["default"].createElement("div", (0, _extends2["default"])({
+        "data-testid": "node-view-wrapper"
+      }, props), children);
+    }
+  };
+});
+var mockCreatePortal = jest.fn(function (node) {
+  return node;
+});
+jest.mock('react-dom', function () {
+  return _objectSpread(_objectSpread({}, jest.requireActual('react-dom')), {}, {
+    createPortal: function createPortal() {
+      return mockCreatePortal.apply(void 0, arguments);
+    }
+  });
+});
+describe('InlineDropdown', function () {
+  var buildMockEditor = function buildMockEditor() {
+    var overrides = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var mockNodeAt = jest.fn(function (pos) {
+      return pos === 5 ? {
+        nodeSize: 1
+      } : null;
+    });
+    var mockDoc = {
+      descendants: jest.fn(),
+      nodeAt: mockNodeAt
+    };
+    var mockTr = {
+      "delete": jest.fn(),
+      doc: {
+        nodeAt: mockNodeAt
+      },
+      setSelection: jest.fn(),
+      setMeta: jest.fn(function setMeta() {
+        return mockTr;
+      })
+    };
+    return _objectSpread({
+      state: {
+        selection: {
+          from: 0,
+          to: 1
+        },
+        tr: mockTr,
+        doc: mockDoc
+      },
+      view: {
+        coordsAtPos: jest.fn(function () {
+          return {
+            top: 100,
+            left: 50
+          };
+        }),
+        dispatch: jest.fn()
+      },
+      commands: {
+        focus: jest.fn()
+      },
+      _tiptapContainerEl: document.createElement('div'),
+      _toolbarOpened: false
+    }, overrides);
+  };
+  var mockEditor;
+  var mockNode = {
+    attrs: {
+      index: '0',
+      value: 'Selected Option',
+      error: false
+    },
+    nodeSize: 1
+  };
+  var mockOptions = {
+    respAreaToolbar: jest.fn(function () {
+      return function () {
+        return /*#__PURE__*/_react["default"].createElement("div", {
+          "data-testid": "inline-dropdown-toolbar"
+        }, "Toolbar");
+      };
+    })
+  };
+  var defaultProps = {
+    editor: mockEditor,
+    node: mockNode,
+    getPos: function getPos() {
+      return 5;
+    },
+    options: mockOptions,
+    selected: false
+  };
+  beforeEach(function () {
+    jest.clearAllMocks();
+    mockCreatePortal.mockClear();
+    mockEditor = buildMockEditor();
+    defaultProps.editor = mockEditor;
+    Object.defineProperty(document.body, 'getBoundingClientRect', {
+      value: jest.fn(function () {
+        return {
+          top: 0,
+          left: 0
+        };
+      }),
+      configurable: true
+    });
+  });
+  it('renders without crashing', function () {
+    var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('renders NodeViewWrapper', function () {
+    var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      getByTestId = _render2.getByTestId;
+    expect(getByTestId('node-view-wrapper')).toBeInTheDocument();
+  });
+  it('displays selected value', function () {
+    var _render3 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render3.container;
+    var valueDiv = container.querySelector('div[style*="border"]');
+    expect(valueDiv).toBeInTheDocument();
+  });
+  it('renders math inside the value control on mount', function () {
+    var _render4 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render4.container;
+    var valueDiv = container.querySelector('div[style*="border"]');
+    expect(_mathRendering.renderMath).toHaveBeenCalledWith(valueDiv);
+  });
+  it('re-renders math when the value changes', function () {
+    var updatedNode = _objectSpread(_objectSpread({}, mockNode), {}, {
+      attrs: _objectSpread(_objectSpread({}, mockNode.attrs), {}, {
+        value: '<span>Updated math</span>'
+      })
+    });
+    var _render5 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render5.container,
+      rerender = _render5.rerender;
+    _mathRendering.renderMath.mockClear();
+    rerender(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+      node: updatedNode
+    })));
+    var valueDiv = container.querySelector('div[style*="border"]');
+    expect(_mathRendering.renderMath).toHaveBeenCalledWith(valueDiv);
+  });
+  it('uses 2px horizontal margin on the value control and no horizontal margin on the wrapper', function () {
+    var _render6 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render6.container,
+      getByTestId = _render6.getByTestId;
+    var valueDiv = container.querySelector('div[style*="border"]');
+    expect(valueDiv).toHaveStyle({
+      margin: '0 2px'
+    });
+    var wrapper = getByTestId('node-view-wrapper');
+    expect(wrapper.getAttribute('style') || '').not.toMatch(/margin/);
+  });
+  it('renders chevron icon', function () {
+    var _render7 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render7.container;
+    var chevron = container.querySelector('svg');
+    expect(chevron).toBeInTheDocument();
+  });
+  it('shows toolbar when selected and only this node is selected', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var _render8, queryByTestId;
+    return _regenerator["default"].wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _render8 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            selected: true
+          }))), queryByTestId = _render8.queryByTestId;
+          _context.next = 1;
+          return (0, _react2.waitFor)(function () {
+            // Toolbar is shown via portal
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('does not show toolbar when not selected', function () {
+    var _render9 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+        selected: false
+      }))),
+      queryByTestId = _render9.queryByTestId;
+    expect(queryByTestId('inline-dropdown-toolbar')).not.toBeInTheDocument();
+  });
+  it('shows toolbar on click', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+    var _render0, container, queryByTestId, dropdown;
+    return _regenerator["default"].wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _render0 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)), container = _render0.container, queryByTestId = _render0.queryByTestId;
+          dropdown = container.querySelector('div[style*="border"]');
+          if (!dropdown) {
+            _context2.next = 2;
+            break;
+          }
+          _react2.fireEvent.click(dropdown);
+          _context2.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 1:
+          _context2.next = 3;
+          break;
+        case 2:
+          // If dropdown is not found, just verify the component rendered
+          expect(container).toBeInTheDocument();
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('has correct minimum dimensions', function () {
+    var _render1 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render1.container;
+    var wrapper = container.querySelector('[data-testid="node-view-wrapper"]');
+    expect(wrapper).toHaveStyle({
+      height: '50px'
+    });
+  });
+  it('has inline-flex display', function () {
+    var _render10 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render10.container;
+    var wrapper = container.querySelector('[data-testid="node-view-wrapper"]');
+    expect(wrapper).toHaveStyle({
+      display: 'inline-flex'
+    });
+  });
+  it('has cursor pointer style', function () {
+    var _render11 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render11.container;
+    var wrapper = container.querySelector('[data-testid="node-view-wrapper"]');
+    expect(wrapper).toHaveStyle({
+      cursor: 'pointer'
+    });
+  });
+  it('renders with empty value as nbsp', function () {
+    var emptyNode = _objectSpread(_objectSpread({}, mockNode), {}, {
+      attrs: _objectSpread(_objectSpread({}, mockNode.attrs), {}, {
+        value: ''
+      })
+    });
+    var _render12 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+        node: emptyNode
+      }))),
+      container = _render12.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('calls respAreaToolbar with correct params', function () {
+    (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps));
+    expect(mockOptions.respAreaToolbar).toHaveBeenCalledWith([mockNode, 5], mockEditor, expect.any(Function));
+  });
+  it('closes toolbar on outside click', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+    var _render13, container, queryByTestId;
+    return _regenerator["default"].wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _render13 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            selected: true
+          }))), container = _render13.container, queryByTestId = _render13.queryByTestId;
+          _context3.next = 1;
+          return (0, _react2.waitFor)(function () {
+            _react2.fireEvent.mouseDown(document.body);
+          });
+        case 1:
+          _context3.next = 2;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).not.toBeInTheDocument();
+          });
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('calls close callback when toolbar closes on outside click', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+    var onInlineDropdownToolbarClose, options, _render14, queryByTestId;
+    return _regenerator["default"].wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          onInlineDropdownToolbarClose = jest.fn();
+          options = _objectSpread(_objectSpread({}, mockOptions), {}, {
+            onInlineDropdownToolbarClose: onInlineDropdownToolbarClose
+          });
+          _render14 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            options: options,
+            selected: true
+          }))), queryByTestId = _render14.queryByTestId;
+          _context4.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 1:
+          _react2.fireEvent.mouseDown(document.body);
+          _context4.next = 2;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).not.toBeInTheDocument();
+          });
+        case 2:
+          expect(onInlineDropdownToolbarClose).toHaveBeenCalledWith(mockEditor);
+        case 3:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('uses the current node when closing on outside click after the node prop changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+    var onToolbarCloseRequest, options, updatedNode, _render15, queryByTestId, rerender;
+    return _regenerator["default"].wrap(function (_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          onToolbarCloseRequest = jest.fn(function (_tuple, _editor, onConfirm) {
+            return onConfirm();
+          });
+          options = _objectSpread(_objectSpread({}, mockOptions), {}, {
+            onToolbarCloseRequest: onToolbarCloseRequest
+          });
+          updatedNode = {
+            attrs: {
+              index: '1',
+              value: 'Updated Option',
+              error: false
+            },
+            nodeSize: 1
+          };
+          _render15 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            options: options,
+            selected: true
+          }))), queryByTestId = _render15.queryByTestId, rerender = _render15.rerender;
+          _context5.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 1:
+          rerender(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            options: options,
+            node: updatedNode,
+            selected: true
+          })));
+          _react2.fireEvent.mouseDown(document.body);
+          _context5.next = 2;
+          return (0, _react2.waitFor)(function () {
+            expect(onToolbarCloseRequest).toHaveBeenCalledWith([updatedNode, 5], expect.anything(), expect.any(Function), expect.any(Function));
+          });
+        case 2:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+  it('respects hold state for the current node after the node prop changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+    var updatedNode, _render16, queryByTestId, rerender;
+    return _regenerator["default"].wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          updatedNode = {
+            attrs: {
+              index: '1',
+              value: 'Updated Option',
+              error: false
+            },
+            nodeSize: 1
+          };
+          mockEditor._holdInlineDropdownToolbarIndex = '1';
+          _render16 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            selected: true
+          }))), queryByTestId = _render16.queryByTestId, rerender = _render16.rerender;
+          _context6.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 1:
+          rerender(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            node: updatedNode,
+            selected: true
+          })));
+          _react2.fireEvent.mouseDown(document.body);
+          _context6.next = 2;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('rebinds the outside-click listener when the node prop changes while the toolbar is open', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+    var addSpy, removeSpy, updatedNode, _render17, rerender, removeCallsBeforeRerender;
+    return _regenerator["default"].wrap(function (_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          addSpy = jest.spyOn(document, 'addEventListener');
+          removeSpy = jest.spyOn(document, 'removeEventListener');
+          updatedNode = _objectSpread(_objectSpread({}, mockNode), {}, {
+            attrs: _objectSpread(_objectSpread({}, mockNode.attrs), {}, {
+              value: 'Updated Option'
+            })
+          });
+          _render17 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            selected: true
+          }))), rerender = _render17.rerender;
+          _context7.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(addSpy).toHaveBeenCalledWith('mousedown', expect.any(Function));
+          });
+        case 1:
+          removeCallsBeforeRerender = removeSpy.mock.calls.filter(function (_ref9) {
+            var _ref0 = (0, _slicedToArray2["default"])(_ref9, 1),
+              type = _ref0[0];
+            return type === 'mousedown';
+          }).length;
+          rerender(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            node: updatedNode,
+            selected: true
+          })));
+          _context7.next = 2;
+          return (0, _react2.waitFor)(function () {
+            var removeCallsAfterRerender = removeSpy.mock.calls.filter(function (_ref1) {
+              var _ref10 = (0, _slicedToArray2["default"])(_ref1, 1),
+                type = _ref10[0];
+              return type === 'mousedown';
+            }).length;
+            expect(removeCallsAfterRerender).toBeGreaterThan(removeCallsBeforeRerender);
+            expect(addSpy).toHaveBeenCalledWith('mousedown', expect.any(Function));
+          });
+        case 2:
+          addSpy.mockRestore();
+          removeSpy.mockRestore();
+        case 3:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  })));
+  it('has correct border styling', function () {
+    var _render18 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render18.container;
+    var dropdownDiv = container.querySelector('div[style*="border"]');
+    expect(dropdownDiv).toHaveStyle({
+      border: '1px solid #C0C3CF'
+    });
+  });
+  it('has correct min width', function () {
+    var _render19 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render19.container;
+    var dropdownDiv = container.querySelector('div[style*="border"]');
+    expect(dropdownDiv).toHaveStyle({
+      minWidth: '178px'
+    });
+  });
+  it('positions chevron correctly', function () {
+    var _render20 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render20.container;
+    var chevron = container.querySelector('svg');
+    // Chevron styling is applied inline, just verify it rendered
+    if (chevron) {
+      expect(chevron).toBeInTheDocument();
+    } else {
+      expect(container).toBeInTheDocument();
+    }
+  });
+  it('has ellipsis for overflow text', function () {
+    var _render21 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], defaultProps)),
+      container = _render21.container;
+    var textContainer = container.querySelector('div[style*="overflow"]');
+    expect(textContainer).toHaveStyle({
+      textOverflow: 'ellipsis',
+      whiteSpace: 'nowrap'
+    });
+  });
+  it('portals toolbar into editor container when _tiptapContainerEl is set', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee8() {
+    var containerEl, editor;
+    return _regenerator["default"].wrap(function (_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          containerEl = document.createElement('div');
+          editor = buildMockEditor({
+            _tiptapContainerEl: containerEl
+          });
+          (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            editor: editor,
+            selected: true
+          })));
+          _context8.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(mockCreatePortal).toHaveBeenCalled();
+          });
+        case 1:
+          expect(mockCreatePortal.mock.calls[0][1]).toBe(containerEl);
+        case 2:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  it('portals toolbar into document.body when _tiptapContainerEl is missing', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee9() {
+    var editor;
+    return _regenerator["default"].wrap(function (_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          editor = buildMockEditor({
+            _tiptapContainerEl: undefined
+          });
+          (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            editor: editor,
+            selected: true
+          })));
+          _context9.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(mockCreatePortal).toHaveBeenCalled();
+          });
+        case 1:
+          expect(mockCreatePortal.mock.calls[0][1]).toBe(document.body);
+        case 2:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9);
+  })));
+  it('passes editorCallback to InlineDropdownToolbar', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee0() {
+    var mockToolbarComponent, mockOptionsWithCallback, _render22, queryByTestId;
+    return _regenerator["default"].wrap(function (_context0) {
+      while (1) switch (_context0.prev = _context0.next) {
+        case 0:
+          mockToolbarComponent = jest.fn(function (_ref14) {
+            var editorCallback = _ref14.editorCallback;
+            editorCallback === null || editorCallback === void 0 || editorCallback({
+              instanceId: 'test-instance'
+            });
+            return /*#__PURE__*/_react["default"].createElement("div", {
+              "data-testid": "inline-dropdown-toolbar"
+            }, "Toolbar");
+          });
+          mockOptionsWithCallback = {
+            respAreaToolbar: jest.fn(function () {
+              return mockToolbarComponent;
+            })
+          };
+          _render22 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            options: mockOptionsWithCallback,
+            selected: true
+          }))), queryByTestId = _render22.queryByTestId;
+          _context0.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 1:
+        case "end":
+          return _context0.stop();
+      }
+    }, _callee0);
+  })));
+  it('stores toolbar editor instance in ref when editorCallback is called', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee1() {
+    var capturedCallback, mockToolbarComponent, mockOptionsWithCallback, _render23, queryByTestId;
+    return _regenerator["default"].wrap(function (_context1) {
+      while (1) switch (_context1.prev = _context1.next) {
+        case 0:
+          mockToolbarComponent = function mockToolbarComponent(_ref16) {
+            var editorCallback = _ref16.editorCallback;
+            capturedCallback = editorCallback;
+            return /*#__PURE__*/_react["default"].createElement("div", {
+              "data-testid": "inline-dropdown-toolbar"
+            }, "Toolbar");
+          };
+          mockOptionsWithCallback = {
+            respAreaToolbar: jest.fn(function () {
+              return mockToolbarComponent;
+            })
+          };
+          _render23 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            options: mockOptionsWithCallback,
+            selected: true
+          }))), queryByTestId = _render23.queryByTestId;
+          _context1.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 1:
+          // Verify callback exists
+          expect(capturedCallback).toBeDefined();
+        case 2:
+        case "end":
+          return _context1.stop();
+      }
+    }, _callee1);
+  })));
+  it('handles click outside logic with data-toolbar-for attribute', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+    var editorWithInstanceId, capturedCallback, mockToolbarComponent, mockOptionsWithCallback, _render24, container, queryByTestId, otherToolbar;
+    return _regenerator["default"].wrap(function (_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          editorWithInstanceId = _objectSpread(_objectSpread({}, mockEditor), {}, {
+            instanceId: 'editor-123',
+            _toolbarOpened: false
+          }); // Mock the toolbar callback to set the toolbar editor instance
+          mockToolbarComponent = function mockToolbarComponent(_ref18) {
+            var editorCallback = _ref18.editorCallback;
+            _react["default"].useEffect(function () {
+              capturedCallback = editorCallback;
+              if (editorCallback) {
+                editorCallback({
+                  instanceId: 'editor-123'
+                });
+              }
+            }, [editorCallback]);
+            return /*#__PURE__*/_react["default"].createElement("div", {
+              "data-testid": "inline-dropdown-toolbar"
+            }, "Toolbar");
+          };
+          mockOptionsWithCallback = {
+            respAreaToolbar: jest.fn(function () {
+              return mockToolbarComponent;
+            })
+          };
+          _render24 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            editor: editorWithInstanceId,
+            options: mockOptionsWithCallback,
+            selected: true
+          }))), container = _render24.container, queryByTestId = _render24.queryByTestId;
+          _context10.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 1:
+          // Create an element with data-toolbar-for attribute
+          otherToolbar = document.createElement('div');
+          otherToolbar.setAttribute('data-toolbar-for', 'editor-456');
+          document.body.appendChild(otherToolbar);
+          _context10.next = 2;
+          return (0, _react2.waitFor)(function () {
+            _react2.fireEvent.mouseDown(otherToolbar);
+          });
+        case 2:
+          // Cleanup
+          document.body.removeChild(otherToolbar);
+          expect(container).toBeInTheDocument();
+        case 3:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee10);
+  })));
+  it('does not close when clicking inside same editor toolbar', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee11() {
+    var editorWithInstanceId, toolbarEditorInstance, mockToolbarComponent, mockOptionsWithCallback;
+    return _regenerator["default"].wrap(function (_context11) {
+      while (1) switch (_context11.prev = _context11.next) {
+        case 0:
+          editorWithInstanceId = _objectSpread(_objectSpread({}, mockEditor), {}, {
+            instanceId: 'editor-123',
+            _toolbarOpened: false
+          });
+          mockToolbarComponent = function mockToolbarComponent(_ref20) {
+            var editorCallback = _ref20.editorCallback;
+            _react["default"].useEffect(function () {
+              if (editorCallback) {
+                editorCallback({
+                  instanceId: 'editor-123'
+                });
+                toolbarEditorInstance = {
+                  instanceId: 'editor-123'
+                };
+              }
+            }, [editorCallback]);
+            return /*#__PURE__*/_react["default"].createElement("div", {
+              "data-testid": "inline-dropdown-toolbar"
+            }, "Toolbar");
+          };
+          mockOptionsWithCallback = {
+            respAreaToolbar: jest.fn(function () {
+              return mockToolbarComponent;
+            })
+          };
+          (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            editor: editorWithInstanceId,
+            options: mockOptionsWithCallback,
+            selected: true
+          })));
+          _context11.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(mockOptionsWithCallback.respAreaToolbar).toHaveBeenCalled();
+          });
+        case 1:
+        case "end":
+          return _context11.stop();
+      }
+    }, _callee11);
+  })));
+  it('checks editor._toolbarOpened in click outside handler', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee12() {
+    var editorWithToolbarOpened, _render25, queryByTestId;
+    return _regenerator["default"].wrap(function (_context12) {
+      while (1) switch (_context12.prev = _context12.next) {
+        case 0:
+          editorWithToolbarOpened = buildMockEditor({
+            _toolbarOpened: true
+          });
+          _render25 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            editor: editorWithToolbarOpened,
+            selected: true
+          }))), queryByTestId = _render25.queryByTestId;
+          _context12.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 1:
+          // When _toolbarOpened is true, clicking outside should not close
+          _react2.fireEvent.mouseDown(document.body);
+
+          // Toolbar should still be visible
+          expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+        case 2:
+        case "end":
+          return _context12.stop();
+      }
+    }, _callee12);
+  })));
+  it('does not close toolbar when clicking the page scrollbar (documentElement)', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee13() {
+    var _render26, queryByTestId;
+    return _regenerator["default"].wrap(function (_context13) {
+      while (1) switch (_context13.prev = _context13.next) {
+        case 0:
+          _render26 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            selected: true
+          }))), queryByTestId = _render26.queryByTestId;
+          _context13.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 1:
+          _react2.fireEvent.mouseDown(document.documentElement);
+          _context13.next = 2;
+          return (0, _react2.waitFor)(function () {
+            expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();
+          });
+        case 2:
+        case "end":
+          return _context13.stop();
+      }
+    }, _callee13);
+  })));
+  it('renders delete control on portaled custom toolbar when container el is set', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee14() {
+    var _render27, findByLabelText, _t;
+    return _regenerator["default"].wrap(function (_context14) {
+      while (1) switch (_context14.prev = _context14.next) {
+        case 0:
+          _render27 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            selected: true
+          }))), findByLabelText = _render27.findByLabelText;
+          _t = expect;
+          _context14.next = 1;
+          return findByLabelText('Delete');
+        case 1:
+          _t(_context14.sent).toBeInTheDocument();
+        case 2:
+        case "end":
+          return _context14.stop();
+      }
+    }, _callee14);
+  })));
+  it('does not render portaled delete control when _tiptapContainerEl is missing', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee15() {
+    var editor, _render28, queryByLabelText, findByTestId, _t2;
+    return _regenerator["default"].wrap(function (_context15) {
+      while (1) switch (_context15.prev = _context15.next) {
+        case 0:
+          editor = buildMockEditor({
+            _tiptapContainerEl: undefined
+          });
+          _render28 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            editor: editor,
+            selected: true
+          }))), queryByLabelText = _render28.queryByLabelText, findByTestId = _render28.findByTestId;
+          _t2 = expect;
+          _context15.next = 1;
+          return findByTestId('inline-dropdown-toolbar');
+        case 1:
+          _t2(_context15.sent).toBeInTheDocument();
+          expect(queryByLabelText('Delete')).not.toBeInTheDocument();
+        case 2:
+        case "end":
+          return _context15.stop();
+      }
+    }, _callee15);
+  })));
+  it('delete clears toolbar flag, removes node range, dispatches, and focuses', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee16() {
+    var _render29, findByLabelText, _t3;
+    return _regenerator["default"].wrap(function (_context16) {
+      while (1) switch (_context16.prev = _context16.next) {
+        case 0:
+          mockEditor._toolbarOpened = true;
+          _render29 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], (0, _extends2["default"])({}, defaultProps, {
+            selected: true
+          }))), findByLabelText = _render29.findByLabelText;
+          _t3 = _react2.fireEvent;
+          _context16.next = 1;
+          return findByLabelText('Delete');
+        case 1:
+          _t3.mouseDown.call(_t3, _context16.sent);
+          expect(mockEditor.state.tr["delete"]).toHaveBeenCalledWith(5, 6);
+          expect(mockEditor.view.dispatch).toHaveBeenCalledTimes(2);
+          expect(mockEditor.view.dispatch).toHaveBeenNthCalledWith(1, mockEditor.state.tr);
+          expect(mockEditor.view.dispatch).toHaveBeenNthCalledWith(2, mockEditor.state.tr);
+          expect(mockEditor._toolbarOpened).toBe(false);
+          expect(mockEditor.commands.focus).toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context16.stop();
+      }
+    }, _callee16);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_mathRendering","_InlineDropdown","_excluded","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","renderMath","fn","NodeViewWrapper","_ref","children","props","_objectWithoutProperties2","createElement","_extends2","mockCreatePortal","node","requireActual","createPortal","describe","buildMockEditor","overrides","undefined","mockNodeAt","pos","nodeSize","mockDoc","descendants","nodeAt","mockTr","doc","setSelection","setMeta","state","selection","from","to","tr","view","coordsAtPos","top","left","dispatch","commands","focus","_tiptapContainerEl","document","_toolbarOpened","mockEditor","mockNode","attrs","index","value","error","mockOptions","respAreaToolbar","defaultProps","editor","getPos","options","selected","beforeEach","clearAllMocks","mockClear","body","configurable","it","_render","render","container","expect","toBeInTheDocument","_render2","getByTestId","_render3","valueDiv","querySelector","_render4","toHaveBeenCalledWith","updatedNode","_render5","rerender","_render6","toHaveStyle","margin","wrapper","getAttribute","not","toMatch","_render7","chevron","_asyncToGenerator2","_regenerator","mark","_callee","_render8","queryByTestId","wrap","_context","prev","next","waitFor","stop","_render9","_callee2","_render0","dropdown","_context2","fireEvent","click","_render1","height","_render10","display","_render11","cursor","emptyNode","_render12","any","Function","_callee3","_render13","_context3","mouseDown","_callee4","onInlineDropdownToolbarClose","_render14","_context4","_callee5","onToolbarCloseRequest","_render15","_context5","_tuple","_editor","onConfirm","anything","_callee6","_render16","_context6","_holdInlineDropdownToolbarIndex","_callee7","addSpy","removeSpy","_render17","removeCallsBeforeRerender","_context7","spyOn","calls","_ref9","_ref0","_slicedToArray2","type","removeCallsAfterRerender","_ref1","_ref10","toBeGreaterThan","mockRestore","_render18","dropdownDiv","border","_render19","minWidth","_render20","_render21","textContainer","textOverflow","whiteSpace","_callee8","containerEl","_context8","toHaveBeenCalled","toBe","_callee9","_context9","_callee0","mockToolbarComponent","mockOptionsWithCallback","_render22","_context0","_ref14","editorCallback","instanceId","_callee1","capturedCallback","_render23","_context1","_ref16","toBeDefined","_callee10","editorWithInstanceId","_render24","otherToolbar","_context10","_ref18","React","useEffect","setAttribute","appendChild","removeChild","_callee11","toolbarEditorInstance","_context11","_ref20","_callee12","editorWithToolbarOpened","_render25","_context12","_callee13","_render26","_context13","documentElement","_callee14","_render27","findByLabelText","_t","_context14","sent","_callee15","_render28","queryByLabelText","findByTestId","_t2","_context15","_callee16","_render29","_t3","_context16","call","toHaveBeenCalledTimes","toHaveBeenNthCalledWith"],"sources":["../../../src/components/__tests__/InlineDropdown.test.jsx"],"sourcesContent":["import React from 'react';\nimport { fireEvent, render, waitFor } from '@testing-library/react';\nimport { renderMath } from '@pie-lib/math-rendering';\nimport InlineDropdown from '../respArea/InlineDropdown';\n\njest.mock('@pie-lib/math-rendering', () => ({\n  renderMath: jest.fn(),\n}));\n\njest.mock('@tiptap/react', () => ({\n  NodeViewWrapper: ({ children, ...props }) => (\n    <div data-testid=\"node-view-wrapper\" {...props}>\n      {children}\n    </div>\n  ),\n}));\n\nconst mockCreatePortal = jest.fn((node) => node);\n\njest.mock('react-dom', () => ({\n  ...jest.requireActual('react-dom'),\n  createPortal: (...args) => mockCreatePortal(...args),\n}));\n\ndescribe('InlineDropdown', () => {\n  const buildMockEditor = (overrides = {}) => {\n    const mockNodeAt = jest.fn((pos) => (pos === 5 ? { nodeSize: 1 } : null));\n    const mockDoc = {\n      descendants: jest.fn(),\n      nodeAt: mockNodeAt,\n    };\n    const mockTr = {\n      delete: jest.fn(),\n      doc: { nodeAt: mockNodeAt },\n      setSelection: jest.fn(),\n      setMeta: jest.fn(function setMeta() {\n        return mockTr;\n      }),\n    };\n    return {\n      state: {\n        selection: {\n          from: 0,\n          to: 1,\n        },\n        tr: mockTr,\n        doc: mockDoc,\n      },\n      view: {\n        coordsAtPos: jest.fn(() => ({ top: 100, left: 50 })),\n        dispatch: jest.fn(),\n      },\n      commands: {\n        focus: jest.fn(),\n      },\n      _tiptapContainerEl: document.createElement('div'),\n      _toolbarOpened: false,\n      ...overrides,\n    };\n  };\n\n  let mockEditor;\n\n  const mockNode = {\n    attrs: {\n      index: '0',\n      value: 'Selected Option',\n      error: false,\n    },\n    nodeSize: 1,\n  };\n\n  const mockOptions = {\n    respAreaToolbar: jest.fn(() => () => <div data-testid=\"inline-dropdown-toolbar\">Toolbar</div>),\n  };\n\n  const defaultProps = {\n    editor: mockEditor,\n    node: mockNode,\n    getPos: () => 5,\n    options: mockOptions,\n    selected: false,\n  };\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n    mockCreatePortal.mockClear();\n    mockEditor = buildMockEditor();\n    defaultProps.editor = mockEditor;\n    Object.defineProperty(document.body, 'getBoundingClientRect', {\n      value: jest.fn(() => ({ top: 0, left: 0 })),\n      configurable: true,\n    });\n  });\n\n  it('renders without crashing', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('renders NodeViewWrapper', () => {\n    const { getByTestId } = render(<InlineDropdown {...defaultProps} />);\n    expect(getByTestId('node-view-wrapper')).toBeInTheDocument();\n  });\n\n  it('displays selected value', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    const valueDiv = container.querySelector('div[style*=\"border\"]');\n    expect(valueDiv).toBeInTheDocument();\n  });\n\n  it('renders math inside the value control on mount', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    const valueDiv = container.querySelector('div[style*=\"border\"]');\n\n    expect(renderMath).toHaveBeenCalledWith(valueDiv);\n  });\n\n  it('re-renders math when the value changes', () => {\n    const updatedNode = {\n      ...mockNode,\n      attrs: {\n        ...mockNode.attrs,\n        value: '<span>Updated math</span>',\n      },\n    };\n\n    const { container, rerender } = render(<InlineDropdown {...defaultProps} />);\n\n    renderMath.mockClear();\n\n    rerender(<InlineDropdown {...defaultProps} node={updatedNode} />);\n\n    const valueDiv = container.querySelector('div[style*=\"border\"]');\n    expect(renderMath).toHaveBeenCalledWith(valueDiv);\n  });\n\n  it('uses 2px horizontal margin on the value control and no horizontal margin on the wrapper', () => {\n    const { container, getByTestId } = render(<InlineDropdown {...defaultProps} />);\n    const valueDiv = container.querySelector('div[style*=\"border\"]');\n    expect(valueDiv).toHaveStyle({ margin: '0 2px' });\n    const wrapper = getByTestId('node-view-wrapper');\n    expect(wrapper.getAttribute('style') || '').not.toMatch(/margin/);\n  });\n\n  it('renders chevron icon', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    const chevron = container.querySelector('svg');\n    expect(chevron).toBeInTheDocument();\n  });\n\n  it('shows toolbar when selected and only this node is selected', async () => {\n    const { queryByTestId } = render(<InlineDropdown {...defaultProps} selected={true} />);\n    await waitFor(() => {\n      // Toolbar is shown via portal\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n  });\n\n  it('does not show toolbar when not selected', () => {\n    const { queryByTestId } = render(<InlineDropdown {...defaultProps} selected={false} />);\n    expect(queryByTestId('inline-dropdown-toolbar')).not.toBeInTheDocument();\n  });\n\n  it('shows toolbar on click', async () => {\n    const { container, queryByTestId } = render(<InlineDropdown {...defaultProps} />);\n    const dropdown = container.querySelector('div[style*=\"border\"]');\n    if (dropdown) {\n      fireEvent.click(dropdown);\n      await waitFor(() => {\n        expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n      });\n    } else {\n      // If dropdown is not found, just verify the component rendered\n      expect(container).toBeInTheDocument();\n    }\n  });\n\n  it('has correct minimum dimensions', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    const wrapper = container.querySelector('[data-testid=\"node-view-wrapper\"]');\n    expect(wrapper).toHaveStyle({ height: '50px' });\n  });\n\n  it('has inline-flex display', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    const wrapper = container.querySelector('[data-testid=\"node-view-wrapper\"]');\n    expect(wrapper).toHaveStyle({ display: 'inline-flex' });\n  });\n\n  it('has cursor pointer style', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    const wrapper = container.querySelector('[data-testid=\"node-view-wrapper\"]');\n    expect(wrapper).toHaveStyle({ cursor: 'pointer' });\n  });\n\n  it('renders with empty value as nbsp', () => {\n    const emptyNode = { ...mockNode, attrs: { ...mockNode.attrs, value: '' } };\n    const { container } = render(<InlineDropdown {...defaultProps} node={emptyNode} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('calls respAreaToolbar with correct params', () => {\n    render(<InlineDropdown {...defaultProps} />);\n    expect(mockOptions.respAreaToolbar).toHaveBeenCalledWith([mockNode, 5], mockEditor, expect.any(Function));\n  });\n\n  it('closes toolbar on outside click', async () => {\n    const { container, queryByTestId } = render(<InlineDropdown {...defaultProps} selected={true} />);\n    await waitFor(() => {\n      fireEvent.mouseDown(document.body);\n    });\n    // After clicking outside, toolbar should be hidden\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).not.toBeInTheDocument();\n    });\n  });\n\n  it('calls close callback when toolbar closes on outside click', async () => {\n    const onInlineDropdownToolbarClose = jest.fn();\n    const options = {\n      ...mockOptions,\n      onInlineDropdownToolbarClose,\n    };\n\n    const { queryByTestId } = render(<InlineDropdown {...defaultProps} options={options} selected={true} />);\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n\n    fireEvent.mouseDown(document.body);\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).not.toBeInTheDocument();\n    });\n\n    expect(onInlineDropdownToolbarClose).toHaveBeenCalledWith(mockEditor);\n  });\n\n  it('uses the current node when closing on outside click after the node prop changes', async () => {\n    const onToolbarCloseRequest = jest.fn((_tuple, _editor, onConfirm) => onConfirm());\n    const options = {\n      ...mockOptions,\n      onToolbarCloseRequest,\n    };\n    const updatedNode = {\n      attrs: { index: '1', value: 'Updated Option', error: false },\n      nodeSize: 1,\n    };\n\n    const { queryByTestId, rerender } = render(<InlineDropdown {...defaultProps} options={options} selected={true} />);\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n\n    rerender(<InlineDropdown {...defaultProps} options={options} node={updatedNode} selected={true} />);\n\n    fireEvent.mouseDown(document.body);\n\n    await waitFor(() => {\n      expect(onToolbarCloseRequest).toHaveBeenCalledWith(\n        [updatedNode, 5],\n        expect.anything(),\n        expect.any(Function),\n        expect.any(Function),\n      );\n    });\n  });\n\n  it('respects hold state for the current node after the node prop changes', async () => {\n    const updatedNode = {\n      attrs: { index: '1', value: 'Updated Option', error: false },\n      nodeSize: 1,\n    };\n\n    mockEditor._holdInlineDropdownToolbarIndex = '1';\n\n    const { queryByTestId, rerender } = render(<InlineDropdown {...defaultProps} selected={true} />);\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n\n    rerender(<InlineDropdown {...defaultProps} node={updatedNode} selected={true} />);\n\n    fireEvent.mouseDown(document.body);\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n  });\n\n  it('rebinds the outside-click listener when the node prop changes while the toolbar is open', async () => {\n    const addSpy = jest.spyOn(document, 'addEventListener');\n    const removeSpy = jest.spyOn(document, 'removeEventListener');\n    const updatedNode = { ...mockNode, attrs: { ...mockNode.attrs, value: 'Updated Option' } };\n\n    const { rerender } = render(<InlineDropdown {...defaultProps} selected={true} />);\n\n    await waitFor(() => {\n      expect(addSpy).toHaveBeenCalledWith('mousedown', expect.any(Function));\n    });\n\n    const removeCallsBeforeRerender = removeSpy.mock.calls.filter(([type]) => type === 'mousedown').length;\n\n    rerender(<InlineDropdown {...defaultProps} node={updatedNode} selected={true} />);\n\n    await waitFor(() => {\n      const removeCallsAfterRerender = removeSpy.mock.calls.filter(([type]) => type === 'mousedown').length;\n      expect(removeCallsAfterRerender).toBeGreaterThan(removeCallsBeforeRerender);\n      expect(addSpy).toHaveBeenCalledWith('mousedown', expect.any(Function));\n    });\n\n    addSpy.mockRestore();\n    removeSpy.mockRestore();\n  });\n\n  it('has correct border styling', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    const dropdownDiv = container.querySelector('div[style*=\"border\"]');\n    expect(dropdownDiv).toHaveStyle({ border: '1px solid #C0C3CF' });\n  });\n\n  it('has correct min width', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    const dropdownDiv = container.querySelector('div[style*=\"border\"]');\n    expect(dropdownDiv).toHaveStyle({ minWidth: '178px' });\n  });\n\n  it('positions chevron correctly', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    const chevron = container.querySelector('svg');\n    // Chevron styling is applied inline, just verify it rendered\n    if (chevron) {\n      expect(chevron).toBeInTheDocument();\n    } else {\n      expect(container).toBeInTheDocument();\n    }\n  });\n\n  it('has ellipsis for overflow text', () => {\n    const { container } = render(<InlineDropdown {...defaultProps} />);\n    const textContainer = container.querySelector('div[style*=\"overflow\"]');\n    expect(textContainer).toHaveStyle({ textOverflow: 'ellipsis', whiteSpace: 'nowrap' });\n  });\n\n  it('portals toolbar into editor container when _tiptapContainerEl is set', async () => {\n    const containerEl = document.createElement('div');\n    const editor = buildMockEditor({ _tiptapContainerEl: containerEl });\n\n    render(<InlineDropdown {...defaultProps} editor={editor} selected={true} />);\n\n    await waitFor(() => {\n      expect(mockCreatePortal).toHaveBeenCalled();\n    });\n\n    expect(mockCreatePortal.mock.calls[0][1]).toBe(containerEl);\n  });\n\n  it('portals toolbar into document.body when _tiptapContainerEl is missing', async () => {\n    const editor = buildMockEditor({ _tiptapContainerEl: undefined });\n\n    render(<InlineDropdown {...defaultProps} editor={editor} selected={true} />);\n\n    await waitFor(() => {\n      expect(mockCreatePortal).toHaveBeenCalled();\n    });\n\n    expect(mockCreatePortal.mock.calls[0][1]).toBe(document.body);\n  });\n\n  it('passes editorCallback to InlineDropdownToolbar', async () => {\n    const mockToolbarComponent = jest.fn(({ editorCallback }) => {\n      editorCallback?.({ instanceId: 'test-instance' });\n      return <div data-testid=\"inline-dropdown-toolbar\">Toolbar</div>;\n    });\n\n    const mockOptionsWithCallback = {\n      respAreaToolbar: jest.fn(() => mockToolbarComponent),\n    };\n\n    const { queryByTestId } = render(\n      <InlineDropdown {...defaultProps} options={mockOptionsWithCallback} selected={true} />,\n    );\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n  });\n\n  it('stores toolbar editor instance in ref when editorCallback is called', async () => {\n    let capturedCallback;\n    const mockToolbarComponent = ({ editorCallback }) => {\n      capturedCallback = editorCallback;\n      return <div data-testid=\"inline-dropdown-toolbar\">Toolbar</div>;\n    };\n\n    const mockOptionsWithCallback = {\n      respAreaToolbar: jest.fn(() => mockToolbarComponent),\n    };\n\n    const { queryByTestId } = render(\n      <InlineDropdown {...defaultProps} options={mockOptionsWithCallback} selected={true} />,\n    );\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n\n    // Verify callback exists\n    expect(capturedCallback).toBeDefined();\n  });\n\n  it('handles click outside logic with data-toolbar-for attribute', async () => {\n    const editorWithInstanceId = {\n      ...mockEditor,\n      instanceId: 'editor-123',\n      _toolbarOpened: false,\n    };\n\n    // Mock the toolbar callback to set the toolbar editor instance\n    let capturedCallback;\n    const mockToolbarComponent = ({ editorCallback }) => {\n      React.useEffect(() => {\n        capturedCallback = editorCallback;\n        if (editorCallback) {\n          editorCallback({ instanceId: 'editor-123' });\n        }\n      }, [editorCallback]);\n      return <div data-testid=\"inline-dropdown-toolbar\">Toolbar</div>;\n    };\n\n    const mockOptionsWithCallback = {\n      respAreaToolbar: jest.fn(() => mockToolbarComponent),\n    };\n\n    const { container, queryByTestId } = render(\n      <InlineDropdown\n        {...defaultProps}\n        editor={editorWithInstanceId}\n        options={mockOptionsWithCallback}\n        selected={true}\n      />,\n    );\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n\n    // Create an element with data-toolbar-for attribute\n    const otherToolbar = document.createElement('div');\n    otherToolbar.setAttribute('data-toolbar-for', 'editor-456');\n    document.body.appendChild(otherToolbar);\n\n    await waitFor(() => {\n      fireEvent.mouseDown(otherToolbar);\n    });\n\n    // Cleanup\n    document.body.removeChild(otherToolbar);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('does not close when clicking inside same editor toolbar', async () => {\n    const editorWithInstanceId = {\n      ...mockEditor,\n      instanceId: 'editor-123',\n      _toolbarOpened: false,\n    };\n\n    let toolbarEditorInstance;\n    const mockToolbarComponent = ({ editorCallback }) => {\n      React.useEffect(() => {\n        if (editorCallback) {\n          editorCallback({ instanceId: 'editor-123' });\n          toolbarEditorInstance = { instanceId: 'editor-123' };\n        }\n      }, [editorCallback]);\n      return <div data-testid=\"inline-dropdown-toolbar\">Toolbar</div>;\n    };\n\n    const mockOptionsWithCallback = {\n      respAreaToolbar: jest.fn(() => mockToolbarComponent),\n    };\n\n    render(\n      <InlineDropdown\n        {...defaultProps}\n        editor={editorWithInstanceId}\n        options={mockOptionsWithCallback}\n        selected={true}\n      />,\n    );\n\n    await waitFor(() => {\n      expect(mockOptionsWithCallback.respAreaToolbar).toHaveBeenCalled();\n    });\n  });\n\n  it('checks editor._toolbarOpened in click outside handler', async () => {\n    const editorWithToolbarOpened = buildMockEditor({ _toolbarOpened: true });\n\n    const { queryByTestId } = render(\n      <InlineDropdown {...defaultProps} editor={editorWithToolbarOpened} selected={true} />,\n    );\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n\n    // When _toolbarOpened is true, clicking outside should not close\n    fireEvent.mouseDown(document.body);\n\n    // Toolbar should still be visible\n    expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n  });\n\n  it('does not close toolbar when clicking the page scrollbar (documentElement)', async () => {\n    const { queryByTestId } = render(<InlineDropdown {...defaultProps} selected={true} />);\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n\n    fireEvent.mouseDown(document.documentElement);\n\n    await waitFor(() => {\n      expect(queryByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    });\n  });\n\n  it('renders delete control on portaled custom toolbar when container el is set', async () => {\n    const { findByLabelText } = render(<InlineDropdown {...defaultProps} selected />);\n    expect(await findByLabelText('Delete')).toBeInTheDocument();\n  });\n\n  it('does not render portaled delete control when _tiptapContainerEl is missing', async () => {\n    const editor = buildMockEditor({ _tiptapContainerEl: undefined });\n    const { queryByLabelText, findByTestId } = render(<InlineDropdown {...defaultProps} editor={editor} selected />);\n    expect(await findByTestId('inline-dropdown-toolbar')).toBeInTheDocument();\n    expect(queryByLabelText('Delete')).not.toBeInTheDocument();\n  });\n\n  it('delete clears toolbar flag, removes node range, dispatches, and focuses', async () => {\n    mockEditor._toolbarOpened = true;\n    const { findByLabelText } = render(<InlineDropdown {...defaultProps} selected />);\n    fireEvent.mouseDown(await findByLabelText('Delete'));\n    expect(mockEditor.state.tr.delete).toHaveBeenCalledWith(5, 6);\n    expect(mockEditor.view.dispatch).toHaveBeenCalledTimes(2);\n    expect(mockEditor.view.dispatch).toHaveBeenNthCalledWith(1, mockEditor.state.tr);\n    expect(mockEditor.view.dispatch).toHaveBeenNthCalledWith(2, mockEditor.state.tr);\n    expect(mockEditor._toolbarOpened).toBe(false);\n    expect(mockEditor.commands.focus).toHaveBeenCalled();\n  });\n});\n"],"mappings":"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","ignoreList":[]}