@pie-element/inline-dropdown 10.1.8 → 10.2.0-beta.0

package/configure/lib/__tests__/inline-dropdown-toolbar.test.js

@@ -0,0 +1,1654 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _react = require("@testing-library/react");
+var _react2 = _interopRequireDefault(require("react"));
+require("@testing-library/jest-dom");
+var _inlineDropdownToolbar = _interopRequireDefault(require("../inline-dropdown-toolbar"));
+// Mock the external dependencies
+jest.mock('@pie-lib/editable-html-tip-tap', () => {
+  return function MockEditableHtml(props) {
+    return /*#__PURE__*/_react2.default.createElement("div", {
+      "data-testid": "editable-html",
+      onBlur: props.onBlur,
+      onKeyDown: props.onKeyDown
+    }, /*#__PURE__*/_react2.default.createElement("input", {
+      placeholder: props.placeholder,
+      onChange: e => props.onChange(e.target.value),
+      onBlur: props.onBlur,
+      "data-testid": "editable-input"
+    }));
+  };
+});
+jest.mock('@pie-lib/math-rendering', () => ({
+  renderMath: jest.fn()
+}));
+describe('RespAreaToolbar', () => {
+  let onAddChoice;
+  let onRemoveChoice;
+  let onSelectChoice;
+  let onToolbarDone;
+  let onCheck;
+  let editor;
+  let mockDomNode;
+  let mockEditorNode;
+  beforeEach(() => {
+    onAddChoice = jest.fn();
+    onRemoveChoice = jest.fn();
+    onSelectChoice = jest.fn();
+    onToolbarDone = jest.fn();
+    onCheck = jest.fn();
+
+    // Create mock DOM nodes
+    mockDomNode = {
+      nodeType: 1,
+      getBoundingClientRect: jest.fn().mockReturnValue({
+        top: 100,
+        left: 50,
+        height: 20
+      }),
+      closest: jest.fn().mockReturnValue({
+        getBoundingClientRect: jest.fn().mockReturnValue({
+          left: 25
+        })
+      })
+    };
+    mockEditorNode = {
+      getBoundingClientRect: jest.fn().mockReturnValue({
+        top: 80,
+        left: 25
+      })
+    };
+    mockDomNode.closest.mockReturnValue(mockEditorNode);
+    editor = {
+      commands: {
+        updateAttributes: jest.fn(),
+        refreshResponseArea: jest.fn()
+      },
+      view: {
+        nodeDOM: jest.fn().mockReturnValue(mockDomNode),
+        dispatch: jest.fn()
+      },
+      state: {
+        selection: {
+          from: 0
+        },
+        tr: {
+          isDone: false,
+          deleteSelection: jest.fn()
+        }
+      }
+    };
+  });
+  const defaultProps = {
+    onAddChoice,
+    onRemoveChoice,
+    onSelectChoice,
+    onToolbarDone,
+    node: {
+      key: '1',
+      attrs: {
+        index: '0',
+        value: 'cow'
+      }
+    },
+    pos: 0,
+    editor,
+    choices: [{
+      label: 'cow',
+      value: '0',
+      correct: true
+    }, {
+      label: 'dog',
+      value: '1',
+      correct: false
+    }, {
+      label: 'cat',
+      value: '2',
+      correct: false
+    }]
+  };
+  const createInstance = (props = {}) => {
+    const mergedProps = {
+      ...defaultProps,
+      ...props
+    };
+    const instance = new _inlineDropdownToolbar.default(mergedProps);
+    instance.props = mergedProps;
+
+    // Mock setState to execute updates synchronously for testing
+    const originalSetState = instance.setState.bind(instance);
+    instance.setState = jest.fn(state => {
+      if (typeof state === 'function') {
+        instance.state = {
+          ...instance.state,
+          ...state(instance.state)
+        };
+      } else {
+        instance.state = {
+          ...instance.state,
+          ...state
+        };
+      }
+    });
+    return instance;
+  };
+  describe('Component Lifecycle', () => {
+    it('should set toolbar position on mount relative to the editor', () => {
+      const localEditor = {
+        ...editor,
+        view: {
+          ...editor.view,
+          nodeDOM: jest.fn().mockReturnValue(mockDomNode)
+        }
+      };
+      const instance = createInstance({
+        editor: localEditor
+      });
+      instance.componentDidMount();
+      expect(instance.setState).toHaveBeenCalled();
+      expect(instance.state.toolbarStyle).toBeDefined();
+      expect(instance.state.toolbarStyle.position).toBe('absolute');
+      // (domNodeRect.top - editorRect.top) + domNodeRect.height + 25
+      expect(instance.state.toolbarStyle.top).toBe('65px');
+      // domNodeRect.left - editorRect.left
+      expect(instance.state.toolbarStyle.left).toBe('25px');
+    });
+    it('should position toolbar below the response area node within the editor', () => {
+      const domNodeRect = {
+        top: 200,
+        left: 120,
+        height: 30
+      };
+      const editorRect = {
+        top: 150,
+        left: 100
+      };
+      const domNode = {
+        nodeType: 1,
+        getBoundingClientRect: jest.fn().mockReturnValue(domNodeRect),
+        closest: jest.fn().mockReturnValue({
+          getBoundingClientRect: jest.fn().mockReturnValue(editorRect)
+        })
+      };
+      const localEditor = {
+        ...editor,
+        view: {
+          ...editor.view,
+          nodeDOM: jest.fn().mockReturnValue(domNode)
+        }
+      };
+      const instance = createInstance({
+        editor: localEditor
+      });
+      instance.componentDidMount();
+      expect(instance.state.toolbarStyle.top).toBe('105px');
+      expect(instance.state.toolbarStyle.left).toBe('20px');
+    });
+    it('should handle missing DOM node gracefully', () => {
+      const localEditor = {
+        ...editor,
+        view: {
+          ...editor.view,
+          nodeDOM: jest.fn().mockReturnValue(null)
+        }
+      };
+      const instance = createInstance({
+        editor: localEditor
+      });
+      expect(() => instance.componentDidMount()).not.toThrow();
+    });
+    it('should handle DOM node without nodeType', () => {
+      const localEditor = {
+        ...editor,
+        view: {
+          ...editor.view,
+          nodeDOM: jest.fn().mockReturnValue({
+            nodeType: 3
+          }) // Text node
+        }
+      };
+      const instance = createInstance({
+        editor: localEditor
+      });
+      instance.componentDidMount();
+      expect(instance.state.toolbarStyle).toBeUndefined();
+    });
+    it('should call renderMath on update', () => {
+      const {
+        renderMath
+      } = require('@pie-lib/math-rendering');
+      renderMath.mockClear();
+      const localEditor = {
+        ...editor,
+        view: {
+          ...editor.view,
+          nodeDOM: jest.fn().mockReturnValue(mockDomNode)
+        }
+      };
+
+      // Use a class component wrapper to test componentDidUpdate
+      class TestWrapper extends _react2.default.Component {
+        render() {
+          return /*#__PURE__*/_react2.default.createElement(_inlineDropdownToolbar.default, this.props);
+        }
+      }
+      const {
+        rerender
+      } = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(TestWrapper, (0, _extends2.default)({}, defaultProps, {
+        editor: localEditor
+      })));
+
+      // Trigger an update by rerendering with new props
+      rerender(/*#__PURE__*/_react2.default.createElement(TestWrapper, (0, _extends2.default)({}, defaultProps, {
+        editor: localEditor,
+        choices: [...defaultProps.choices]
+      })));
+      expect(renderMath).toHaveBeenCalled();
+    });
+  });
+  describe('State Management', () => {
+    describe('onRespAreaChange', () => {
+      it('should update respAreaMarkup state', () => {
+        const instance = createInstance();
+        const markup = '<div>test content</div>';
+        instance.onRespAreaChange(markup);
+        expect(instance.state.respAreaMarkup).toBe(markup);
+      });
+    });
+  });
+  describe('Choice Management', () => {
+    describe('onAddChoice', () => {
+      it('should set isDone on transaction and dispatch', () => {
+        const mockTr = {
+          isDone: false,
+          deleteSelection: jest.fn()
+        };
+        const localEditor = {
+          ...editor,
+          state: {
+            ...editor.state,
+            tr: mockTr
+          }
+        };
+        const instance = createInstance({
+          editor: localEditor
+        });
+        instance.onAddChoice();
+        expect(mockTr.isDone).toBe(true);
+        expect(localEditor.view.dispatch).toHaveBeenCalledWith(mockTr);
+      });
+    });
+    describe('onDone', () => {
+      it('should not call onAddChoice if choice is empty', () => {
+        const instance = createInstance();
+        instance.onDone('<div><p></p></div>');
+        expect(onAddChoice).not.toHaveBeenCalled();
+      });
+      it('should not call onAddChoice if choice is only whitespace', () => {
+        const instance = createInstance();
+        instance.onDone('<div>   </div>');
+        expect(onAddChoice).not.toHaveBeenCalled();
+      });
+      it('should call onAddChoice with correct parameters for new choice', () => {
+        const localOnAddChoice = jest.fn();
+        const localEditor = {
+          ...editor,
+          commands: {
+            ...editor.commands,
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice,
+          editor: localEditor
+        });
+        const markup = '<div>new choice</div>';
+        instance.onDone(markup);
+        expect(localOnAddChoice).toHaveBeenCalledWith('0', markup, -1);
+        expect(localEditor.commands.refreshResponseArea).toHaveBeenCalled();
+      });
+      it('should update editor attributes when editing correct choice', () => {
+        const localEditor = {
+          ...editor,
+          commands: {
+            updateAttributes: jest.fn(),
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const localOnToolbarDone = jest.fn();
+        const localOnAddChoice = jest.fn();
+        const instance = createInstance({
+          editor: localEditor,
+          onToolbarDone: localOnToolbarDone,
+          onAddChoice: localOnAddChoice
+        });
+        instance.state.editedChoiceIndex = 0;
+        const markup = '<div>updated cow</div>';
+        instance.onDone(markup);
+        expect(localEditor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', {
+          value: markup
+        });
+      });
+      it('should call onAddChoice when editing a choice', () => {
+        const localOnAddChoice = jest.fn();
+        const localEditor = {
+          ...editor,
+          commands: {
+            ...editor.commands,
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice,
+          editor: localEditor
+        });
+        instance.state.editedChoiceIndex = 1;
+        const markup = '<div>updated dog</div>';
+        instance.onDone(markup);
+        expect(localOnAddChoice).toHaveBeenCalledWith('0', markup, 1);
+      });
+      it('should reset editedChoiceIndex after done', () => {
+        const localOnAddChoice = jest.fn();
+        const localEditor = {
+          ...editor,
+          commands: {
+            ...editor.commands,
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice,
+          editor: localEditor
+        });
+        instance.state.editedChoiceIndex = 1;
+        instance.onDone('<div>test</div>');
+        expect(instance.state.editedChoiceIndex).toBe(-1);
+      });
+    });
+    describe('onSelectChoice', () => {
+      it('should update editor attributes with new value', () => {
+        const localEditor = {
+          ...editor,
+          commands: {
+            updateAttributes: jest.fn(),
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const localOnToolbarDone = jest.fn();
+        const localOnSelectChoice = jest.fn();
+        const instance = createInstance({
+          editor: localEditor,
+          onToolbarDone: localOnToolbarDone,
+          onSelectChoice: localOnSelectChoice
+        });
+        const newValue = 'cat';
+        const index = 2;
+        instance.onSelectChoice(newValue, index);
+        expect(localEditor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', {
+          value: newValue
+        });
+      });
+      it('should call onSelectChoice without closing the toolbar', () => {
+        const localEditor = {
+          ...editor,
+          commands: {
+            updateAttributes: jest.fn(),
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const localOnToolbarDone = jest.fn();
+        const localOnSelectChoice = jest.fn();
+        const instance = createInstance({
+          editor: localEditor,
+          onToolbarDone: localOnToolbarDone,
+          onSelectChoice: localOnSelectChoice
+        });
+        const newValue = 'cat';
+        const index = 2;
+        instance.onSelectChoice(newValue, index);
+        expect(localOnToolbarDone).not.toHaveBeenCalled();
+        expect(localOnSelectChoice).toHaveBeenCalledWith(index);
+      });
+      it('should refresh response area', () => {
+        const localEditor = {
+          ...editor,
+          commands: {
+            updateAttributes: jest.fn(),
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const localOnToolbarDone = jest.fn();
+        const localOnSelectChoice = jest.fn();
+        const instance = createInstance({
+          editor: localEditor,
+          onToolbarDone: localOnToolbarDone,
+          onSelectChoice: localOnSelectChoice
+        });
+        instance.onSelectChoice('dog', 1);
+        expect(localEditor.commands.refreshResponseArea).toHaveBeenCalled();
+      });
+    });
+    describe('onRemoveChoice', () => {
+      it('should update editor attributes to null when removing selected choice', () => {
+        const localEditor = {
+          ...editor,
+          commands: {
+            updateAttributes: jest.fn(),
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const localOnToolbarDone = jest.fn();
+        const localOnRemoveChoice = jest.fn();
+        const instance = createInstance({
+          editor: localEditor,
+          onToolbarDone: localOnToolbarDone,
+          onRemoveChoice: localOnRemoveChoice
+        });
+        const value = 'cow';
+        const index = 0;
+        instance.onRemoveChoice(value, index);
+        expect(localEditor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', {
+          value: null
+        });
+        expect(localOnToolbarDone).not.toHaveBeenCalled();
+      });
+      it('should call onRemoveChoice for non-selected choice', () => {
+        const localEditor = {
+          ...editor,
+          commands: {
+            updateAttributes: jest.fn(),
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const localOnRemoveChoice = jest.fn();
+        const instance = createInstance({
+          editor: localEditor,
+          onRemoveChoice: localOnRemoveChoice
+        });
+        const value = 'cat';
+        const index = 2;
+        instance.onRemoveChoice(value, index);
+        expect(localOnRemoveChoice).toHaveBeenCalledWith(index);
+      });
+      it('should refresh response area after removal', () => {
+        const localEditor = {
+          ...editor,
+          commands: {
+            updateAttributes: jest.fn(),
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const localOnRemoveChoice = jest.fn();
+        const instance = createInstance({
+          editor: localEditor,
+          onRemoveChoice: localOnRemoveChoice
+        });
+        instance.onRemoveChoice('dog', 1);
+        expect(localEditor.commands.refreshResponseArea).toHaveBeenCalled();
+      });
+      it('should not update editor attributes when removing non-selected choice', () => {
+        const localEditor = {
+          ...editor,
+          commands: {
+            updateAttributes: jest.fn(),
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const localOnRemoveChoice = jest.fn();
+        const instance = createInstance({
+          editor: localEditor,
+          onRemoveChoice: localOnRemoveChoice
+        });
+        instance.onRemoveChoice('dog', 1);
+        expect(localEditor.commands.updateAttributes).not.toHaveBeenCalled();
+      });
+    });
+    describe('onEditChoice', () => {
+      it('should update respAreaMarkup state', () => {
+        const instance = createInstance();
+        const value = 'dog';
+        const index = 1;
+        instance.onEditChoice(value, index);
+        expect(instance.state.respAreaMarkup).toBe(value);
+      });
+      it('should set editedChoiceIndex', () => {
+        const instance = createInstance();
+        const value = 'cat';
+        const index = 2;
+        instance.onEditChoice(value, index);
+        expect(instance.state.editedChoiceIndex).toBe(index);
+      });
+      it('should set preventDone to true', () => {
+        const instance = createInstance();
+        const value = 'dog';
+        const index = 1;
+        instance.preventDone = false;
+        instance.onEditChoice(value, index);
+        expect(instance.preventDone).toBe(true);
+      });
+      it('should set clickedInside so blur from opening edit does not commit', () => {
+        const instance = createInstance();
+        instance.clickedInside = false;
+        instance.onEditChoice('dog', 1);
+        expect(instance.clickedInside).toBe(true);
+      });
+      it('should save current edit before starting a new edit', () => {
+        const localOnAddChoice = jest.fn();
+        const localEditor = {
+          ...editor,
+          commands: {
+            ...editor.commands,
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice,
+          editor: localEditor
+        });
+        instance.editorRef = {
+          getHTML: jest.fn().mockReturnValue('<div>modified dog</div>')
+        };
+
+        // Start editing first choice
+        instance.onEditChoice('dog', 1);
+        expect(instance.state.editedChoiceIndex).toBe(1);
+
+        // Start editing second choice without finishing the first
+        instance.onEditChoice('cat', 2);
+
+        // Should have called onDone with the previous edit
+        expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>modified dog</div>', 1);
+        expect(instance.state.editedChoiceIndex).toBe(2);
+        expect(instance.state.respAreaMarkup).toBe('cat');
+      });
+      it('should not call onDone if no choice is currently being edited', () => {
+        const localOnAddChoice = jest.fn();
+        const localEditor = {
+          ...editor,
+          commands: {
+            ...editor.commands,
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice,
+          editor: localEditor
+        });
+        instance.editorRef = {
+          getHTML: jest.fn().mockReturnValue('<div>test</div>')
+        };
+
+        // editedChoiceIndex is -1 (no choice being edited)
+        instance.state.editedChoiceIndex = -1;
+        instance.onEditChoice('dog', 1);
+
+        // Should not have called onDone
+        expect(localOnAddChoice).not.toHaveBeenCalled();
+        expect(instance.state.editedChoiceIndex).toBe(1);
+      });
+      it('should handle empty HTML when saving previous edit', () => {
+        const localOnAddChoice = jest.fn();
+        const localEditor = {
+          ...editor,
+          commands: {
+            ...editor.commands,
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice,
+          editor: localEditor
+        });
+        instance.editorRef = {
+          getHTML: jest.fn().mockReturnValue('')
+        };
+
+        // Start editing first choice
+        instance.onEditChoice('dog', 1);
+
+        // Start editing second choice with empty content in first
+        instance.onEditChoice('cat', 2);
+
+        // Should not call onAddChoice for empty content
+        expect(localOnAddChoice).not.toHaveBeenCalled();
+        expect(instance.state.editedChoiceIndex).toBe(2);
+      });
+    });
+  });
+  describe('Event Handlers', () => {
+    describe('finishEditing', () => {
+      it('should call onDone with editor HTML and set preventDone', () => {
+        const localOnAddChoice = jest.fn();
+        const localEditor = {
+          ...editor,
+          commands: {
+            ...editor.commands,
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice,
+          editor: localEditor
+        });
+        instance.editorRef = {
+          getHTML: jest.fn().mockReturnValue('<div>finished edit</div>')
+        };
+        instance.preventDone = false;
+        instance.finishEditing();
+        expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>finished edit</div>', -1);
+        expect(instance.preventDone).toBe(true);
+      });
+      it('should handle empty HTML from editor', () => {
+        const localOnAddChoice = jest.fn();
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice
+        });
+        instance.editorRef = {
+          getHTML: jest.fn().mockReturnValue('')
+        };
+        instance.finishEditing();
+        expect(localOnAddChoice).not.toHaveBeenCalled();
+        expect(instance.preventDone).toBe(true);
+      });
+    });
+    describe('onKeyDown', () => {
+      it('should call onDone and return true when Enter is pressed', () => {
+        const localOnAddChoice = jest.fn();
+        const localEditor = {
+          ...editor,
+          commands: {
+            ...editor.commands,
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice,
+          editor: localEditor
+        });
+        instance.editorRef = {
+          getHTML: jest.fn().mockReturnValue('<div>new choice</div>')
+        };
+        const event = {
+          key: 'Enter'
+        };
+        const result = instance.onKeyDown(event);
+        expect(localOnAddChoice).toHaveBeenCalled();
+        expect(instance.preventDone).toBe(true);
+        expect(result).toBe(true);
+      });
+      it('should return false for other keys', () => {
+        const instance = createInstance();
+        const event = {
+          key: 'Tab'
+        };
+        const result = instance.onKeyDown(event);
+        expect(result).toBe(false);
+      });
+      it('should handle empty HTML from editor', () => {
+        const instance = createInstance();
+        instance.editorRef = {
+          getHTML: jest.fn().mockReturnValue('')
+        };
+        const event = {
+          key: 'Enter'
+        };
+        instance.onKeyDown(event);
+        expect(onAddChoice).not.toHaveBeenCalled();
+      });
+    });
+    describe('onBlur', () => {
+      it('should return early if clicked inside', () => {
+        const instance = createInstance();
+        instance.clickedInside = true;
+        instance.onBlur();
+        expect(instance.clickedInside).toBe(false);
+        expect(onToolbarDone).not.toHaveBeenCalled();
+      });
+      it('should commit pending choice on blur without closing the toolbar', () => {
+        const mockTr = {
+          isDone: false,
+          deleteSelection: jest.fn()
+        };
+        const mockDispatch = jest.fn();
+        const localEditor = {
+          ...editor,
+          state: {
+            ...editor.state,
+            tr: mockTr
+          },
+          view: {
+            ...editor.view,
+            dispatch: mockDispatch
+          }
+        };
+        const localOnToolbarDone = jest.fn();
+        const instance = createInstance({
+          choices: null,
+          editor: localEditor,
+          onToolbarDone: localOnToolbarDone
+        });
+        instance.onBlur();
+        expect(mockDispatch).toHaveBeenCalled();
+        expect(localOnToolbarDone).not.toHaveBeenCalled();
+      });
+      it('should save the choice being edited when blurring with no relatedTarget', () => {
+        const localOnAddChoice = jest.fn();
+        const localEditor = {
+          ...editor,
+          commands: {
+            updateAttributes: jest.fn(),
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const instance = createInstance({
+          editor: localEditor,
+          onAddChoice: localOnAddChoice
+        });
+        instance.editorRef = {
+          getHTML: () => '<div>updated label</div>'
+        };
+        instance.state.editedChoiceIndex = 1;
+        instance.preventDone = true;
+        instance.onBlur();
+        expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>updated label</div>', 1);
+        expect(instance.state.editedChoiceIndex).toBe(-1);
+        expect(instance.preventDone).toBe(false);
+      });
+    });
+    describe('componentWillUnmount', () => {
+      it('should save the choice being edited when the toolbar unmounts', () => {
+        const localOnAddChoice = jest.fn();
+        const localEditor = {
+          ...editor,
+          commands: {
+            updateAttributes: jest.fn(),
+            refreshResponseArea: jest.fn()
+          }
+        };
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice,
+          editor: localEditor
+        });
+        instance.editorRef = {
+          getHTML: () => '<div>saved on close</div>'
+        };
+        instance.state.editedChoiceIndex = 0;
+        instance.componentWillUnmount();
+        expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>saved on close</div>', 0);
+        expect(instance.state.editedChoiceIndex).toBe(-1);
+      });
+      it('should not call onAddChoice when not editing a choice', () => {
+        const localOnAddChoice = jest.fn();
+        const instance = createInstance({
+          onAddChoice: localOnAddChoice
+        });
+        instance.state.editedChoiceIndex = -1;
+        instance.componentWillUnmount();
+        expect(localOnAddChoice).not.toHaveBeenCalled();
+      });
+    });
+    describe('onClickInside', () => {
+      it('should set clickedInside to true', () => {
+        const instance = createInstance();
+        instance.clickedInside = false;
+        instance.onClickInside();
+        expect(instance.clickedInside).toBe(true);
+      });
+    });
+  });
+  describe('Rendering', () => {
+    it('should return null if toolbarStyle is not set', () => {
+      const instance = createInstance();
+      instance.state.toolbarStyle = null;
+      const result = instance.render();
+      expect(result).toBeNull();
+    });
+    it('should render choices when provided', () => {
+      const instance = createInstance();
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      expect(wrapper.container.querySelector('[aria-label="Edit"]')).toBeTruthy();
+      expect(wrapper.container.querySelector('[aria-label="Remove"]')).toBeTruthy();
+    });
+    it('should not render choices section when choices is null', () => {
+      const instance = createInstance({
+        choices: null
+      });
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const menuItems = wrapper.container.querySelectorAll('[aria-label="Edit"]');
+      expect(menuItems.length).toBe(0);
+    });
+    it('should render Add button when not editing a choice', () => {
+      const instance = createInstance();
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      instance.state.editedChoiceIndex = -1;
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const addButton = wrapper.container.querySelector('[aria-label="Add"]');
+      expect(addButton).toBeTruthy();
+      expect(addButton.querySelector('[data-testid="AddIcon"]')).toBeTruthy();
+    });
+    it('should render Check icon on toolbar button when editing a choice', () => {
+      const instance = createInstance();
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      instance.state.editedChoiceIndex = 1;
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const toolbarButton = wrapper.container.querySelector('[aria-label="Add"]');
+      expect(toolbarButton).toBeTruthy();
+      expect(toolbarButton.querySelector('[data-testid="CheckIcon"]')).toBeTruthy();
+      expect(toolbarButton.querySelector('[data-testid="AddIcon"]')).toBeNull();
+    });
+    it('should finish editing when toolbar button is clicked while editing', () => {
+      const localOnAddChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          ...editor.commands,
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const instance = createInstance({
+        onAddChoice: localOnAddChoice,
+        editor: localEditor
+      });
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      instance.state.editedChoiceIndex = 1;
+      instance.editorRef = {
+        getHTML: jest.fn().mockReturnValue('<div>updated dog</div>')
+      };
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      _react.fireEvent.click(wrapper.container.querySelector('[aria-label="Add"]'));
+      expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>updated dog</div>', 1);
+      expect(instance.preventDone).toBe(true);
+    });
+    it('should call onAddChoice when toolbar button is clicked while not editing', () => {
+      const mockTr = {
+        isDone: false,
+        deleteSelection: jest.fn()
+      };
+      const localEditor = {
+        ...editor,
+        state: {
+          ...editor.state,
+          tr: mockTr
+        }
+      };
+      const instance = createInstance({
+        editor: localEditor
+      });
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      instance.state.editedChoiceIndex = -1;
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      _react.fireEvent.click(wrapper.container.querySelector('[aria-label="Add"]'));
+      expect(mockTr.isDone).toBe(true);
+      expect(localEditor.view.dispatch).toHaveBeenCalledWith(mockTr);
+    });
+    it('should render toolbar above other elements with a high z-index', () => {
+      const instance = createInstance();
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const toolbar = wrapper.container.querySelector('[data-inline-dropdown-toolbar]');
+      expect(toolbar).toBeTruthy();
+      expect(toolbar.style.zIndex).toBe('999');
+    });
+  });
+  describe('Integration', () => {
+    it('should handle complete flow of adding a choice', () => {
+      const localOnAddChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          ...editor.commands,
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const instance = createInstance({
+        onAddChoice: localOnAddChoice,
+        editor: localEditor
+      });
+      instance.editorRef = {
+        getHTML: jest.fn().mockReturnValue('<div>new choice</div>')
+      };
+
+      // User types and presses Enter
+      const event = {
+        key: 'Enter'
+      };
+      instance.onKeyDown(event);
+      expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>new choice</div>', -1);
+      expect(localEditor.commands.refreshResponseArea).toHaveBeenCalled();
+    });
+    it('should handle complete flow of editing a choice', () => {
+      const localOnAddChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          ...editor.commands,
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const instance = createInstance({
+        onAddChoice: localOnAddChoice,
+        editor: localEditor
+      });
+
+      // User clicks edit button
+      instance.onEditChoice('dog', 1);
+      expect(instance.state.respAreaMarkup).toBe('dog');
+      expect(instance.state.editedChoiceIndex).toBe(1);
+
+      // User completes edit
+      instance.onDone('<div>updated dog</div>');
+      expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>updated dog</div>', 1);
+      expect(instance.state.editedChoiceIndex).toBe(-1);
+    });
+    it('should handle complete flow of removing a choice', () => {
+      const localOnRemoveChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          ...editor.commands,
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const instance = createInstance({
+        onRemoveChoice: localOnRemoveChoice,
+        editor: localEditor
+      });
+      instance.onRemoveChoice('dog', 1);
+      expect(localOnRemoveChoice).toHaveBeenCalledWith(1);
+      expect(localEditor.commands.refreshResponseArea).toHaveBeenCalled();
+    });
+    it('should handle switching between editing choices without finishing', () => {
+      const localOnAddChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          updateAttributes: jest.fn(),
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const instance = createInstance({
+        onAddChoice: localOnAddChoice,
+        editor: localEditor
+      });
+
+      // Mock editor with HTML content
+      instance.editorRef = {
+        getHTML: jest.fn().mockReturnValueOnce('<div>modified dog</div>').mockReturnValueOnce('<div>modified cat</div>')
+      };
+
+      // Start editing first choice
+      instance.onEditChoice('dog', 1);
+      expect(instance.state.editedChoiceIndex).toBe(1);
+      expect(instance.state.respAreaMarkup).toBe('dog');
+
+      // Switch to editing second choice without explicitly calling onDone
+      localOnAddChoice.mockClear();
+      instance.onEditChoice('cat', 2);
+
+      // Should have auto-saved the previous edit
+      expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>modified dog</div>', 1);
+      expect(instance.state.editedChoiceIndex).toBe(2);
+      expect(instance.state.respAreaMarkup).toBe('cat');
+    });
+    it('should handle editing the correct choice and switching to another', () => {
+      const localOnAddChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          updateAttributes: jest.fn(),
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const localOnToolbarDone = jest.fn();
+      const instance = createInstance({
+        onAddChoice: localOnAddChoice,
+        editor: localEditor,
+        onToolbarDone: localOnToolbarDone
+      });
+
+      // Mock editor with HTML content
+      instance.editorRef = {
+        getHTML: jest.fn().mockReturnValue('<div>modified cow</div>')
+      };
+
+      // Start editing the correct choice (index 0)
+      instance.onEditChoice('cow', 0);
+      expect(instance.state.editedChoiceIndex).toBe(0);
+
+      // Switch to editing another choice
+      instance.onEditChoice('dog', 1);
+
+      // Should have auto-saved and updated attributes since it was the correct choice
+      expect(localEditor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', {
+        value: '<div>modified cow</div>'
+      });
+      expect(instance.state.editedChoiceIndex).toBe(1);
+    });
+  });
+  describe('Edge Cases', () => {
+    it('should handle missing node attrs', () => {
+      const localOnAddChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          ...editor.commands,
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const instance = createInstance({
+        node: {
+          key: '1',
+          attrs: {}
+        },
+        onAddChoice: localOnAddChoice,
+        editor: localEditor
+      });
+      instance.onDone('<div>test</div>');
+      expect(localOnAddChoice).toHaveBeenCalledWith(undefined, '<div>test</div>', -1);
+    });
+    it('should handle HTML with nested tags', () => {
+      const localOnAddChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          ...editor.commands,
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const instance = createInstance({
+        onAddChoice: localOnAddChoice,
+        editor: localEditor
+      });
+      const complexHtml = '<div><p><strong>Bold</strong> and <em>italic</em></p></div>';
+      instance.onDone(complexHtml);
+      expect(localOnAddChoice).toHaveBeenCalledWith('0', complexHtml, -1);
+    });
+    it('should handle special characters in choices', () => {
+      const localOnAddChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          ...editor.commands,
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const instance = createInstance({
+        onAddChoice: localOnAddChoice,
+        editor: localEditor
+      });
+      const specialChars = '<div>&lt;script&gt;alert("test")&lt;/script&gt;</div>';
+      instance.onDone(specialChars);
+      expect(localOnAddChoice).toHaveBeenCalled();
+    });
+    it('should handle empty choices array', () => {
+      const mockTr = {
+        isDone: false,
+        deleteSelection: jest.fn()
+      };
+      const mockDispatch = jest.fn();
+      const localEditor = {
+        ...editor,
+        state: {
+          ...editor.state,
+          tr: mockTr
+        },
+        view: {
+          ...editor.view,
+          dispatch: mockDispatch
+        }
+      };
+      const localOnToolbarDone = jest.fn();
+      const instance = createInstance({
+        choices: [],
+        editor: localEditor,
+        onToolbarDone: localOnToolbarDone
+      });
+      instance.onBlur();
+      expect(mockDispatch).toHaveBeenCalled();
+      expect(localOnToolbarDone).not.toHaveBeenCalled();
+    });
+  });
+  describe('Props Configuration', () => {
+    it('should pass spellCheck prop to EditableHtml', () => {
+      const instance = createInstance({
+        spellCheck: true
+      });
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+
+      // The mock EditableHtml should receive spellCheck prop
+      expect(wrapper.container).toBeTruthy();
+    });
+    it('should pass uploadSoundSupport prop to EditableHtml', () => {
+      const uploadSoundSupport = {
+        enabled: true
+      };
+      const instance = createInstance({
+        uploadSoundSupport
+      });
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      expect(wrapper.container).toBeTruthy();
+    });
+    it('should pass mathMlOptions prop to EditableHtml', () => {
+      const mathMlOptions = {
+        mmlEditing: true
+      };
+      const instance = createInstance({
+        mathMlOptions
+      });
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      expect(wrapper.container).toBeTruthy();
+    });
+    it('should handle editorCallback prop', () => {
+      const editorCallback = jest.fn();
+      const instance = createInstance({
+        editorCallback
+      });
+      instance.state.toolbarStyle = {
+        position: 'absolute',
+        top: '100px',
+        left: '50px'
+      };
+      const wrapper = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+
+      // editorCallback would be called in the editorRef callback
+      // This is tested implicitly through rendering
+      expect(wrapper.container).toBeTruthy();
+    });
+  });
+});
+describe('MenuItem Integration Tests', () => {
+  let onAddChoice;
+  let onRemoveChoice;
+  let onSelectChoice;
+  let onToolbarDone;
+  let editor;
+  let mockDomNode;
+  let mockEditorNode;
+  beforeEach(() => {
+    onAddChoice = jest.fn();
+    onRemoveChoice = jest.fn();
+    onSelectChoice = jest.fn();
+    onToolbarDone = jest.fn();
+    mockDomNode = {
+      nodeType: 1,
+      getBoundingClientRect: jest.fn().mockReturnValue({
+        top: 100,
+        left: 50,
+        height: 20
+      }),
+      closest: jest.fn()
+    };
+    mockEditorNode = {
+      getBoundingClientRect: jest.fn().mockReturnValue({
+        top: 80,
+        left: 25
+      })
+    };
+    mockDomNode.closest.mockReturnValue(mockEditorNode);
+    editor = {
+      commands: {
+        updateAttributes: jest.fn(),
+        refreshResponseArea: jest.fn()
+      },
+      view: {
+        nodeDOM: jest.fn().mockReturnValue(mockDomNode),
+        dispatch: jest.fn()
+      },
+      state: {
+        selection: {
+          from: 0
+        },
+        tr: {
+          isDone: false,
+          deleteSelection: jest.fn()
+        }
+      }
+    };
+  });
+  const createToolbar = choices => {
+    const props = {
+      onAddChoice,
+      onRemoveChoice,
+      onSelectChoice,
+      onToolbarDone,
+      node: {
+        key: '1',
+        attrs: {
+          index: '0',
+          value: 'cow'
+        }
+      },
+      pos: 0,
+      editor,
+      choices
+    };
+    const instance = new _inlineDropdownToolbar.default(props);
+    instance.props = props;
+
+    // Mock setState to execute updates synchronously
+    instance.setState = jest.fn(state => {
+      if (typeof state === 'function') {
+        instance.state = {
+          ...instance.state,
+          ...state(instance.state)
+        };
+      } else {
+        instance.state = {
+          ...instance.state,
+          ...state
+        };
+      }
+    });
+    instance.componentDidMount();
+    return instance;
+  };
+  describe('MenuItem Rendering via Parent', () => {
+    it('should render all choice items', () => {
+      const choices = [{
+        label: 'cow',
+        correct: true
+      }, {
+        label: 'dog',
+        correct: false
+      }, {
+        label: 'cat',
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const editButtons = rendered.getAllByLabelText('Edit');
+      const removeButtons = rendered.getAllByLabelText('Remove');
+      expect(editButtons.length).toBe(3);
+      expect(removeButtons.length).toBe(3);
+    });
+    it('should display correct indicator only for correct choice', () => {
+      const choices = [{
+        label: 'cow',
+        correct: true
+      }, {
+        label: 'dog',
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+
+      // Check that correct styling is applied
+      expect(rendered.container).toBeTruthy();
+    });
+    it('should render choice labels as HTML', () => {
+      const choices = [{
+        label: '<p><strong>Bold choice</strong></p>',
+        correct: true
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      expect(rendered.container.innerHTML).toContain('Bold choice');
+    });
+  });
+  describe('MenuItem Click Interactions', () => {
+    it('should call onSelectChoice when clicking a choice', () => {
+      const choices = [{
+        label: 'cow',
+        correct: true
+      }, {
+        label: 'dog',
+        correct: false
+      }];
+      const localOnSelectChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          updateAttributes: jest.fn(),
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const props = {
+        onAddChoice,
+        onRemoveChoice,
+        onSelectChoice: localOnSelectChoice,
+        onToolbarDone,
+        node: {
+          key: '1',
+          attrs: {
+            index: '0',
+            value: 'cow'
+          }
+        },
+        pos: 0,
+        editor: localEditor,
+        choices
+      };
+      const instance = new _inlineDropdownToolbar.default(props);
+      instance.props = props;
+      instance.setState = jest.fn(state => {
+        if (typeof state === 'function') {
+          instance.state = {
+            ...instance.state,
+            ...state(instance.state)
+          };
+        } else {
+          instance.state = {
+            ...instance.state,
+            ...state
+          };
+        }
+      });
+      instance.componentDidMount();
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+
+      // Find the second choice (dog) - use the parent div that has onClick
+      const choiceElements = rendered.container.querySelectorAll('[dangerouslySetInnerHTML]');
+      if (choiceElements[1]) {
+        _react.fireEvent.click(choiceElements[1]);
+        expect(localEditor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', {
+          value: 'dog'
+        });
+        expect(localOnSelectChoice).toHaveBeenCalledWith(1);
+      }
+    });
+    it('should call onEditChoice when clicking Edit button', () => {
+      const choices = [{
+        label: 'cow',
+        correct: true
+      }, {
+        label: 'dog',
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      // Mock editorRef to prevent errors when auto-saving
+      instance.editorRef = {
+        getHTML: jest.fn().mockReturnValue('')
+      };
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const editButtons = rendered.getAllByLabelText('Edit');
+      _react.fireEvent.click(editButtons[1]);
+      expect(instance.state.respAreaMarkup).toBe('dog');
+      expect(instance.state.editedChoiceIndex).toBe(1);
+    });
+    it('should call onRemoveChoice when clicking Remove button', () => {
+      const choices = [{
+        label: 'cow',
+        correct: true
+      }, {
+        label: 'dog',
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const removeButtons = rendered.getAllByLabelText('Remove');
+      _react.fireEvent.click(removeButtons[1]);
+      expect(onRemoveChoice).toHaveBeenCalledWith(1);
+      expect(editor.commands.refreshResponseArea).toHaveBeenCalled();
+    });
+    it('should update to null when removing the selected choice', () => {
+      const choices = [{
+        label: 'cow',
+        correct: true
+      }, {
+        label: 'dog',
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const removeButtons = rendered.getAllByLabelText('Remove');
+      _react.fireEvent.click(removeButtons[0]); // Remove 'cow' which is the selected value
+
+      expect(editor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', {
+        value: null
+      });
+      expect(onToolbarDone).not.toHaveBeenCalled();
+    });
+  });
+  describe('MenuItem Edit/Remove Action Buttons', () => {
+    it('should have Edit and Remove buttons for each choice', () => {
+      const choices = [{
+        label: 'choice1',
+        correct: false
+      }, {
+        label: 'choice2',
+        correct: false
+      }, {
+        label: 'choice3',
+        correct: true
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const editButtons = rendered.getAllByLabelText('Edit');
+      const removeButtons = rendered.getAllByLabelText('Remove');
+      expect(editButtons.length).toBe(3);
+      expect(removeButtons.length).toBe(3);
+    });
+    it('should not trigger choice selection when clicking action buttons', () => {
+      const choices = [{
+        label: 'cow',
+        correct: true
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const editButton = rendered.getByLabelText('Edit');
+      _react.fireEvent.click(editButton);
+
+      // onSelectChoice should not be called, only state should update
+      expect(onSelectChoice).not.toHaveBeenCalled();
+      expect(instance.state.editedChoiceIndex).toBe(0);
+    });
+  });
+  describe('MenuItem Visual States', () => {
+    it('should apply correct styling to correct choice', () => {
+      const choices = [{
+        label: 'correct answer',
+        correct: true
+      }, {
+        label: 'wrong answer',
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+
+      // The correct choice should have special styling
+      expect(rendered.container).toBeTruthy();
+    });
+    it('should show check icon for correct choice', () => {
+      const choices = [{
+        label: 'correct answer',
+        correct: true
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+
+      // Check for CheckIcon in the rendered output
+      const checkIcon = rendered.container.querySelector('svg');
+      expect(checkIcon).toBeTruthy();
+    });
+  });
+  describe('MenuItem Edge Cases', () => {
+    it('should handle empty label gracefully', () => {
+      const choices = [{
+        label: '',
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const editButtons = rendered.getAllByLabelText('Edit');
+      expect(editButtons.length).toBe(1);
+    });
+    it('should handle HTML entities in labels', () => {
+      const choices = [{
+        label: '&lt;p&gt;escaped&lt;/p&gt;',
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      expect(rendered.container).toBeTruthy();
+    });
+    it('should handle very long labels', () => {
+      const longLabel = '<p>' + 'a'.repeat(500) + '</p>';
+      const choices = [{
+        label: longLabel,
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      expect(rendered.container).toBeTruthy();
+    });
+    it('should handle special characters in labels', () => {
+      const choices = [{
+        label: '<p>Math: x² + y² = z²</p>',
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      expect(rendered.container.innerHTML).toContain('x²');
+    });
+  });
+  describe('Multiple MenuItem Interactions', () => {
+    it('should allow editing multiple choices sequentially', () => {
+      const choices = [{
+        label: 'choice1',
+        correct: false
+      }, {
+        label: 'choice2',
+        correct: false
+      }];
+      const instance = createToolbar(choices);
+      // Mock editorRef to prevent errors when auto-saving
+      instance.editorRef = {
+        getHTML: jest.fn().mockReturnValue('')
+      };
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const editButtons = rendered.getAllByLabelText('Edit');
+      _react.fireEvent.click(editButtons[0]);
+      expect(instance.state.editedChoiceIndex).toBe(0);
+      _react.fireEvent.click(editButtons[1]);
+      expect(instance.state.editedChoiceIndex).toBe(1);
+    });
+    it('should auto-save when switching between editing choices', () => {
+      const localOnAddChoice = jest.fn();
+      const localEditor = {
+        ...editor,
+        commands: {
+          updateAttributes: jest.fn(),
+          refreshResponseArea: jest.fn()
+        }
+      };
+      const choices = [{
+        label: 'choice1',
+        correct: false
+      }, {
+        label: 'choice2',
+        correct: false
+      }];
+      const props = {
+        onAddChoice: localOnAddChoice,
+        onRemoveChoice,
+        onSelectChoice,
+        onToolbarDone,
+        node: {
+          key: '1',
+          attrs: {
+            index: '0',
+            value: 'cow'
+          }
+        },
+        pos: 0,
+        editor: localEditor,
+        choices
+      };
+      const instance = new _inlineDropdownToolbar.default(props);
+      instance.props = props;
+      instance.setState = jest.fn(state => {
+        if (typeof state === 'function') {
+          instance.state = {
+            ...instance.state,
+            ...state(instance.state)
+          };
+        } else {
+          instance.state = {
+            ...instance.state,
+            ...state
+          };
+        }
+      });
+      instance.editorRef = {
+        getHTML: jest.fn().mockReturnValue('<div>modified choice1</div>')
+      };
+      instance.componentDidMount();
+
+      // Start editing first choice directly
+      instance.onEditChoice('choice1', 0);
+      expect(instance.state.editedChoiceIndex).toBe(0);
+
+      // Start editing second choice - should auto-save first choice
+      instance.onEditChoice('choice2', 1);
+      expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>modified choice1</div>', 0);
+      expect(instance.state.editedChoiceIndex).toBe(1);
+    });
+    it('should allow removing multiple choices', () => {
+      const choices = [{
+        label: 'choice1',
+        correct: false
+      }, {
+        label: 'choice2',
+        correct: false
+      }, {
+        label: 'choice3',
+        correct: true
+      }];
+      const instance = createToolbar(choices);
+      const rendered = (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_react2.default.Fragment, null, instance.render()));
+      const removeButtons = rendered.getAllByLabelText('Remove');
+      _react.fireEvent.click(removeButtons[0]);
+      expect(onRemoveChoice).toHaveBeenCalledWith(0);
+      _react.fireEvent.click(removeButtons[1]);
+      expect(onRemoveChoice).toHaveBeenCalledWith(1);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","_react2","_interopRequireDefault","_inlineDropdownToolbar","jest","mock","MockEditableHtml","props","default","createElement","onBlur","onKeyDown","placeholder","onChange","e","target","value","renderMath","fn","describe","onAddChoice","onRemoveChoice","onSelectChoice","onToolbarDone","onCheck","editor","mockDomNode","mockEditorNode","beforeEach","nodeType","getBoundingClientRect","mockReturnValue","top","left","height","closest","commands","updateAttributes","refreshResponseArea","view","nodeDOM","dispatch","state","selection","from","tr","isDone","deleteSelection","defaultProps","node","key","attrs","index","pos","choices","label","correct","createInstance","mergedProps","instance","RespAreaToolbar","originalSetState","setState","bind","it","localEditor","componentDidMount","expect","toHaveBeenCalled","toolbarStyle","toBeDefined","position","toBe","domNodeRect","editorRect","domNode","not","toThrow","toBeUndefined","mockClear","TestWrapper","React","Component","render","rerender","_extends2","markup","onRespAreaChange","respAreaMarkup","mockTr","toHaveBeenCalledWith","onDone","localOnAddChoice","localOnToolbarDone","editedChoiceIndex","localOnSelectChoice","newValue","localOnRemoveChoice","onEditChoice","preventDone","clickedInside","editorRef","getHTML","finishEditing","event","result","mockDispatch","componentWillUnmount","onClickInside","toBeNull","wrapper","Fragment","container","querySelector","toBeTruthy","menuItems","querySelectorAll","length","addButton","toolbarButton","fireEvent","click","toolbar","style","zIndex","mockReturnValueOnce","undefined","complexHtml","specialChars","spellCheck","uploadSoundSupport","enabled","mathMlOptions","mmlEditing","editorCallback","createToolbar","rendered","editButtons","getAllByLabelText","removeButtons","innerHTML","toContain","choiceElements","editButton","getByLabelText","checkIcon","longLabel","repeat"],"sources":["../../src/__tests__/inline-dropdown-toolbar.test.jsx"],"sourcesContent":["import { render, screen, fireEvent } from '@testing-library/react';\nimport React from 'react';\nimport '@testing-library/jest-dom';\n\nimport RespAreaToolbar from '../inline-dropdown-toolbar';\n\n// Mock the external dependencies\njest.mock('@pie-lib/editable-html-tip-tap', () => {\n  return function MockEditableHtml(props) {\n    return (\n      <div data-testid=\"editable-html\" onBlur={props.onBlur} onKeyDown={props.onKeyDown}>\n        <input\n          placeholder={props.placeholder}\n          onChange={(e) => props.onChange(e.target.value)}\n          onBlur={props.onBlur}\n          data-testid=\"editable-input\"\n        />\n      </div>\n    );\n  };\n});\n\njest.mock('@pie-lib/math-rendering', () => ({\n  renderMath: jest.fn(),\n}));\n\ndescribe('RespAreaToolbar', () => {\n  let onAddChoice;\n  let onRemoveChoice;\n  let onSelectChoice;\n  let onToolbarDone;\n  let onCheck;\n  let editor;\n  let mockDomNode;\n  let mockEditorNode;\n\n  beforeEach(() => {\n    onAddChoice = jest.fn();\n    onRemoveChoice = jest.fn();\n    onSelectChoice = jest.fn();\n    onToolbarDone = jest.fn();\n    onCheck = jest.fn();\n\n    // Create mock DOM nodes\n    mockDomNode = {\n      nodeType: 1,\n      getBoundingClientRect: jest.fn().mockReturnValue({\n        top: 100,\n        left: 50,\n        height: 20,\n      }),\n      closest: jest.fn().mockReturnValue({\n        getBoundingClientRect: jest.fn().mockReturnValue({\n          left: 25,\n        }),\n      }),\n    };\n\n    mockEditorNode = {\n      getBoundingClientRect: jest.fn().mockReturnValue({\n        top: 80,\n        left: 25,\n      }),\n    };\n\n    mockDomNode.closest.mockReturnValue(mockEditorNode);\n\n    editor = {\n      commands: {\n        updateAttributes: jest.fn(),\n        refreshResponseArea: jest.fn(),\n      },\n      view: {\n        nodeDOM: jest.fn().mockReturnValue(mockDomNode),\n        dispatch: jest.fn(),\n      },\n      state: {\n        selection: {\n          from: 0,\n        },\n        tr: {\n          isDone: false,\n          deleteSelection: jest.fn(),\n        },\n      },\n    };\n  });\n\n  const defaultProps = {\n    onAddChoice,\n    onRemoveChoice,\n    onSelectChoice,\n    onToolbarDone,\n    node: {\n      key: '1',\n      attrs: {\n        index: '0',\n        value: 'cow',\n      },\n    },\n    pos: 0,\n    editor,\n    choices: [\n      {\n        label: 'cow',\n        value: '0',\n        correct: true,\n      },\n      {\n        label: 'dog',\n        value: '1',\n        correct: false,\n      },\n      {\n        label: 'cat',\n        value: '2',\n        correct: false,\n      },\n    ],\n  };\n\n  const createInstance = (props = {}) => {\n    const mergedProps = { ...defaultProps, ...props };\n    const instance = new RespAreaToolbar(mergedProps);\n    instance.props = mergedProps;\n\n    // Mock setState to execute updates synchronously for testing\n    const originalSetState = instance.setState.bind(instance);\n    instance.setState = jest.fn((state) => {\n      if (typeof state === 'function') {\n        instance.state = { ...instance.state, ...state(instance.state) };\n      } else {\n        instance.state = { ...instance.state, ...state };\n      }\n    });\n\n    return instance;\n  };\n\n  describe('Component Lifecycle', () => {\n    it('should set toolbar position on mount relative to the editor', () => {\n      const localEditor = {\n        ...editor,\n        view: {\n          ...editor.view,\n          nodeDOM: jest.fn().mockReturnValue(mockDomNode),\n        },\n      };\n      const instance = createInstance({ editor: localEditor });\n      instance.componentDidMount();\n\n      expect(instance.setState).toHaveBeenCalled();\n      expect(instance.state.toolbarStyle).toBeDefined();\n      expect(instance.state.toolbarStyle.position).toBe('absolute');\n      // (domNodeRect.top - editorRect.top) + domNodeRect.height + 25\n      expect(instance.state.toolbarStyle.top).toBe('65px');\n      // domNodeRect.left - editorRect.left\n      expect(instance.state.toolbarStyle.left).toBe('25px');\n    });\n\n    it('should position toolbar below the response area node within the editor', () => {\n      const domNodeRect = { top: 200, left: 120, height: 30 };\n      const editorRect = { top: 150, left: 100 };\n\n      const domNode = {\n        nodeType: 1,\n        getBoundingClientRect: jest.fn().mockReturnValue(domNodeRect),\n        closest: jest.fn().mockReturnValue({\n          getBoundingClientRect: jest.fn().mockReturnValue(editorRect),\n        }),\n      };\n\n      const localEditor = {\n        ...editor,\n        view: {\n          ...editor.view,\n          nodeDOM: jest.fn().mockReturnValue(domNode),\n        },\n      };\n      const instance = createInstance({ editor: localEditor });\n      instance.componentDidMount();\n\n      expect(instance.state.toolbarStyle.top).toBe('105px');\n      expect(instance.state.toolbarStyle.left).toBe('20px');\n    });\n\n    it('should handle missing DOM node gracefully', () => {\n      const localEditor = {\n        ...editor,\n        view: {\n          ...editor.view,\n          nodeDOM: jest.fn().mockReturnValue(null),\n        },\n      };\n      const instance = createInstance({ editor: localEditor });\n\n      expect(() => instance.componentDidMount()).not.toThrow();\n    });\n\n    it('should handle DOM node without nodeType', () => {\n      const localEditor = {\n        ...editor,\n        view: {\n          ...editor.view,\n          nodeDOM: jest.fn().mockReturnValue({ nodeType: 3 }), // Text node\n        },\n      };\n      const instance = createInstance({ editor: localEditor });\n\n      instance.componentDidMount();\n      expect(instance.state.toolbarStyle).toBeUndefined();\n    });\n\n    it('should call renderMath on update', () => {\n      const { renderMath } = require('@pie-lib/math-rendering');\n      renderMath.mockClear();\n\n      const localEditor = {\n        ...editor,\n        view: {\n          ...editor.view,\n          nodeDOM: jest.fn().mockReturnValue(mockDomNode),\n        },\n      };\n\n      // Use a class component wrapper to test componentDidUpdate\n      class TestWrapper extends React.Component {\n        render() {\n          return <RespAreaToolbar {...this.props} />;\n        }\n      }\n\n      const { rerender } = render(<TestWrapper {...defaultProps} editor={localEditor} />);\n\n      // Trigger an update by rerendering with new props\n      rerender(<TestWrapper {...defaultProps} editor={localEditor} choices={[...defaultProps.choices]} />);\n\n      expect(renderMath).toHaveBeenCalled();\n    });\n  });\n\n  describe('State Management', () => {\n    describe('onRespAreaChange', () => {\n      it('should update respAreaMarkup state', () => {\n        const instance = createInstance();\n        const markup = '<div>test content</div>';\n\n        instance.onRespAreaChange(markup);\n\n        expect(instance.state.respAreaMarkup).toBe(markup);\n      });\n    });\n  });\n\n  describe('Choice Management', () => {\n    describe('onAddChoice', () => {\n      it('should set isDone on transaction and dispatch', () => {\n        const mockTr = { isDone: false, deleteSelection: jest.fn() };\n        const localEditor = {\n          ...editor,\n          state: {\n            ...editor.state,\n            tr: mockTr,\n          },\n        };\n        const instance = createInstance({ editor: localEditor });\n\n        instance.onAddChoice();\n\n        expect(mockTr.isDone).toBe(true);\n        expect(localEditor.view.dispatch).toHaveBeenCalledWith(mockTr);\n      });\n    });\n\n    describe('onDone', () => {\n      it('should not call onAddChoice if choice is empty', () => {\n        const instance = createInstance();\n        instance.onDone('<div><p></p></div>');\n\n        expect(onAddChoice).not.toHaveBeenCalled();\n      });\n\n      it('should not call onAddChoice if choice is only whitespace', () => {\n        const instance = createInstance();\n        instance.onDone('<div>   </div>');\n\n        expect(onAddChoice).not.toHaveBeenCalled();\n      });\n\n      it('should call onAddChoice with correct parameters for new choice', () => {\n        const localOnAddChoice = jest.fn();\n        const localEditor = {\n          ...editor,\n          commands: {\n            ...editor.commands,\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const instance = createInstance({\n          onAddChoice: localOnAddChoice,\n          editor: localEditor,\n        });\n        const markup = '<div>new choice</div>';\n\n        instance.onDone(markup);\n\n        expect(localOnAddChoice).toHaveBeenCalledWith('0', markup, -1);\n        expect(localEditor.commands.refreshResponseArea).toHaveBeenCalled();\n      });\n\n      it('should update editor attributes when editing correct choice', () => {\n        const localEditor = {\n          ...editor,\n          commands: {\n            updateAttributes: jest.fn(),\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const localOnToolbarDone = jest.fn();\n        const localOnAddChoice = jest.fn();\n        const instance = createInstance({\n          editor: localEditor,\n          onToolbarDone: localOnToolbarDone,\n          onAddChoice: localOnAddChoice,\n        });\n        instance.state.editedChoiceIndex = 0;\n        const markup = '<div>updated cow</div>';\n\n        instance.onDone(markup);\n\n        expect(localEditor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', { value: markup });\n      });\n\n      it('should call onAddChoice when editing a choice', () => {\n        const localOnAddChoice = jest.fn();\n        const localEditor = {\n          ...editor,\n          commands: {\n            ...editor.commands,\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const instance = createInstance({\n          onAddChoice: localOnAddChoice,\n          editor: localEditor,\n        });\n        instance.state.editedChoiceIndex = 1;\n        const markup = '<div>updated dog</div>';\n\n        instance.onDone(markup);\n\n        expect(localOnAddChoice).toHaveBeenCalledWith('0', markup, 1);\n      });\n\n      it('should reset editedChoiceIndex after done', () => {\n        const localOnAddChoice = jest.fn();\n        const localEditor = {\n          ...editor,\n          commands: {\n            ...editor.commands,\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const instance = createInstance({\n          onAddChoice: localOnAddChoice,\n          editor: localEditor,\n        });\n        instance.state.editedChoiceIndex = 1;\n\n        instance.onDone('<div>test</div>');\n\n        expect(instance.state.editedChoiceIndex).toBe(-1);\n      });\n    });\n\n    describe('onSelectChoice', () => {\n      it('should update editor attributes with new value', () => {\n        const localEditor = {\n          ...editor,\n          commands: {\n            updateAttributes: jest.fn(),\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const localOnToolbarDone = jest.fn();\n        const localOnSelectChoice = jest.fn();\n        const instance = createInstance({\n          editor: localEditor,\n          onToolbarDone: localOnToolbarDone,\n          onSelectChoice: localOnSelectChoice,\n        });\n        const newValue = 'cat';\n        const index = 2;\n\n        instance.onSelectChoice(newValue, index);\n\n        expect(localEditor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', { value: newValue });\n      });\n\n      it('should call onSelectChoice without closing the toolbar', () => {\n        const localEditor = {\n          ...editor,\n          commands: {\n            updateAttributes: jest.fn(),\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const localOnToolbarDone = jest.fn();\n        const localOnSelectChoice = jest.fn();\n        const instance = createInstance({\n          editor: localEditor,\n          onToolbarDone: localOnToolbarDone,\n          onSelectChoice: localOnSelectChoice,\n        });\n        const newValue = 'cat';\n        const index = 2;\n\n        instance.onSelectChoice(newValue, index);\n\n        expect(localOnToolbarDone).not.toHaveBeenCalled();\n        expect(localOnSelectChoice).toHaveBeenCalledWith(index);\n      });\n\n      it('should refresh response area', () => {\n        const localEditor = {\n          ...editor,\n          commands: {\n            updateAttributes: jest.fn(),\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const localOnToolbarDone = jest.fn();\n        const localOnSelectChoice = jest.fn();\n        const instance = createInstance({\n          editor: localEditor,\n          onToolbarDone: localOnToolbarDone,\n          onSelectChoice: localOnSelectChoice,\n        });\n\n        instance.onSelectChoice('dog', 1);\n\n        expect(localEditor.commands.refreshResponseArea).toHaveBeenCalled();\n      });\n    });\n\n    describe('onRemoveChoice', () => {\n      it('should update editor attributes to null when removing selected choice', () => {\n        const localEditor = {\n          ...editor,\n          commands: {\n            updateAttributes: jest.fn(),\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const localOnToolbarDone = jest.fn();\n        const localOnRemoveChoice = jest.fn();\n        const instance = createInstance({\n          editor: localEditor,\n          onToolbarDone: localOnToolbarDone,\n          onRemoveChoice: localOnRemoveChoice,\n        });\n        const value = 'cow';\n        const index = 0;\n\n        instance.onRemoveChoice(value, index);\n\n        expect(localEditor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', { value: null });\n        expect(localOnToolbarDone).not.toHaveBeenCalled();\n      });\n\n      it('should call onRemoveChoice for non-selected choice', () => {\n        const localEditor = {\n          ...editor,\n          commands: {\n            updateAttributes: jest.fn(),\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const localOnRemoveChoice = jest.fn();\n        const instance = createInstance({\n          editor: localEditor,\n          onRemoveChoice: localOnRemoveChoice,\n        });\n        const value = 'cat';\n        const index = 2;\n\n        instance.onRemoveChoice(value, index);\n\n        expect(localOnRemoveChoice).toHaveBeenCalledWith(index);\n      });\n\n      it('should refresh response area after removal', () => {\n        const localEditor = {\n          ...editor,\n          commands: {\n            updateAttributes: jest.fn(),\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const localOnRemoveChoice = jest.fn();\n        const instance = createInstance({\n          editor: localEditor,\n          onRemoveChoice: localOnRemoveChoice,\n        });\n\n        instance.onRemoveChoice('dog', 1);\n\n        expect(localEditor.commands.refreshResponseArea).toHaveBeenCalled();\n      });\n\n      it('should not update editor attributes when removing non-selected choice', () => {\n        const localEditor = {\n          ...editor,\n          commands: {\n            updateAttributes: jest.fn(),\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const localOnRemoveChoice = jest.fn();\n        const instance = createInstance({\n          editor: localEditor,\n          onRemoveChoice: localOnRemoveChoice,\n        });\n\n        instance.onRemoveChoice('dog', 1);\n\n        expect(localEditor.commands.updateAttributes).not.toHaveBeenCalled();\n      });\n    });\n\n    describe('onEditChoice', () => {\n      it('should update respAreaMarkup state', () => {\n        const instance = createInstance();\n        const value = 'dog';\n        const index = 1;\n\n        instance.onEditChoice(value, index);\n\n        expect(instance.state.respAreaMarkup).toBe(value);\n      });\n\n      it('should set editedChoiceIndex', () => {\n        const instance = createInstance();\n        const value = 'cat';\n        const index = 2;\n\n        instance.onEditChoice(value, index);\n\n        expect(instance.state.editedChoiceIndex).toBe(index);\n      });\n\n      it('should set preventDone to true', () => {\n        const instance = createInstance();\n        const value = 'dog';\n        const index = 1;\n\n        instance.preventDone = false;\n        instance.onEditChoice(value, index);\n\n        expect(instance.preventDone).toBe(true);\n      });\n\n      it('should set clickedInside so blur from opening edit does not commit', () => {\n        const instance = createInstance();\n\n        instance.clickedInside = false;\n        instance.onEditChoice('dog', 1);\n\n        expect(instance.clickedInside).toBe(true);\n      });\n\n      it('should save current edit before starting a new edit', () => {\n        const localOnAddChoice = jest.fn();\n        const localEditor = {\n          ...editor,\n          commands: {\n            ...editor.commands,\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const instance = createInstance({\n          onAddChoice: localOnAddChoice,\n          editor: localEditor,\n        });\n        instance.editorRef = {\n          getHTML: jest.fn().mockReturnValue('<div>modified dog</div>'),\n        };\n\n        // Start editing first choice\n        instance.onEditChoice('dog', 1);\n        expect(instance.state.editedChoiceIndex).toBe(1);\n\n        // Start editing second choice without finishing the first\n        instance.onEditChoice('cat', 2);\n\n        // Should have called onDone with the previous edit\n        expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>modified dog</div>', 1);\n        expect(instance.state.editedChoiceIndex).toBe(2);\n        expect(instance.state.respAreaMarkup).toBe('cat');\n      });\n\n      it('should not call onDone if no choice is currently being edited', () => {\n        const localOnAddChoice = jest.fn();\n        const localEditor = {\n          ...editor,\n          commands: {\n            ...editor.commands,\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const instance = createInstance({\n          onAddChoice: localOnAddChoice,\n          editor: localEditor,\n        });\n        instance.editorRef = {\n          getHTML: jest.fn().mockReturnValue('<div>test</div>'),\n        };\n\n        // editedChoiceIndex is -1 (no choice being edited)\n        instance.state.editedChoiceIndex = -1;\n        instance.onEditChoice('dog', 1);\n\n        // Should not have called onDone\n        expect(localOnAddChoice).not.toHaveBeenCalled();\n        expect(instance.state.editedChoiceIndex).toBe(1);\n      });\n\n      it('should handle empty HTML when saving previous edit', () => {\n        const localOnAddChoice = jest.fn();\n        const localEditor = {\n          ...editor,\n          commands: {\n            ...editor.commands,\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const instance = createInstance({\n          onAddChoice: localOnAddChoice,\n          editor: localEditor,\n        });\n        instance.editorRef = {\n          getHTML: jest.fn().mockReturnValue(''),\n        };\n\n        // Start editing first choice\n        instance.onEditChoice('dog', 1);\n\n        // Start editing second choice with empty content in first\n        instance.onEditChoice('cat', 2);\n\n        // Should not call onAddChoice for empty content\n        expect(localOnAddChoice).not.toHaveBeenCalled();\n        expect(instance.state.editedChoiceIndex).toBe(2);\n      });\n    });\n  });\n\n  describe('Event Handlers', () => {\n    describe('finishEditing', () => {\n      it('should call onDone with editor HTML and set preventDone', () => {\n        const localOnAddChoice = jest.fn();\n        const localEditor = {\n          ...editor,\n          commands: {\n            ...editor.commands,\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const instance = createInstance({\n          onAddChoice: localOnAddChoice,\n          editor: localEditor,\n        });\n        instance.editorRef = {\n          getHTML: jest.fn().mockReturnValue('<div>finished edit</div>'),\n        };\n        instance.preventDone = false;\n\n        instance.finishEditing();\n\n        expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>finished edit</div>', -1);\n        expect(instance.preventDone).toBe(true);\n      });\n\n      it('should handle empty HTML from editor', () => {\n        const localOnAddChoice = jest.fn();\n        const instance = createInstance({ onAddChoice: localOnAddChoice });\n        instance.editorRef = {\n          getHTML: jest.fn().mockReturnValue(''),\n        };\n\n        instance.finishEditing();\n\n        expect(localOnAddChoice).not.toHaveBeenCalled();\n        expect(instance.preventDone).toBe(true);\n      });\n    });\n\n    describe('onKeyDown', () => {\n      it('should call onDone and return true when Enter is pressed', () => {\n        const localOnAddChoice = jest.fn();\n        const localEditor = {\n          ...editor,\n          commands: {\n            ...editor.commands,\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const instance = createInstance({\n          onAddChoice: localOnAddChoice,\n          editor: localEditor,\n        });\n        instance.editorRef = {\n          getHTML: jest.fn().mockReturnValue('<div>new choice</div>'),\n        };\n\n        const event = { key: 'Enter' };\n        const result = instance.onKeyDown(event);\n\n        expect(localOnAddChoice).toHaveBeenCalled();\n        expect(instance.preventDone).toBe(true);\n        expect(result).toBe(true);\n      });\n\n      it('should return false for other keys', () => {\n        const instance = createInstance();\n        const event = { key: 'Tab' };\n\n        const result = instance.onKeyDown(event);\n\n        expect(result).toBe(false);\n      });\n\n      it('should handle empty HTML from editor', () => {\n        const instance = createInstance();\n        instance.editorRef = {\n          getHTML: jest.fn().mockReturnValue(''),\n        };\n\n        const event = { key: 'Enter' };\n        instance.onKeyDown(event);\n\n        expect(onAddChoice).not.toHaveBeenCalled();\n      });\n    });\n\n    describe('onBlur', () => {\n      it('should return early if clicked inside', () => {\n        const instance = createInstance();\n        instance.clickedInside = true;\n\n        instance.onBlur();\n\n        expect(instance.clickedInside).toBe(false);\n        expect(onToolbarDone).not.toHaveBeenCalled();\n      });\n\n      it('should commit pending choice on blur without closing the toolbar', () => {\n        const mockTr = { isDone: false, deleteSelection: jest.fn() };\n        const mockDispatch = jest.fn();\n        const localEditor = {\n          ...editor,\n          state: {\n            ...editor.state,\n            tr: mockTr,\n          },\n          view: {\n            ...editor.view,\n            dispatch: mockDispatch,\n          },\n        };\n        const localOnToolbarDone = jest.fn();\n        const instance = createInstance({\n          choices: null,\n          editor: localEditor,\n          onToolbarDone: localOnToolbarDone,\n        });\n\n        instance.onBlur();\n\n        expect(mockDispatch).toHaveBeenCalled();\n        expect(localOnToolbarDone).not.toHaveBeenCalled();\n      });\n\n      it('should save the choice being edited when blurring with no relatedTarget', () => {\n        const localOnAddChoice = jest.fn();\n        const localEditor = {\n          ...editor,\n          commands: {\n            updateAttributes: jest.fn(),\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const instance = createInstance({\n          editor: localEditor,\n          onAddChoice: localOnAddChoice,\n        });\n\n        instance.editorRef = { getHTML: () => '<div>updated label</div>' };\n        instance.state.editedChoiceIndex = 1;\n        instance.preventDone = true;\n\n        instance.onBlur();\n\n        expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>updated label</div>', 1);\n        expect(instance.state.editedChoiceIndex).toBe(-1);\n        expect(instance.preventDone).toBe(false);\n      });\n    });\n\n    describe('componentWillUnmount', () => {\n      it('should save the choice being edited when the toolbar unmounts', () => {\n        const localOnAddChoice = jest.fn();\n        const localEditor = {\n          ...editor,\n          commands: {\n            updateAttributes: jest.fn(),\n            refreshResponseArea: jest.fn(),\n          },\n        };\n        const instance = createInstance({ onAddChoice: localOnAddChoice, editor: localEditor });\n\n        instance.editorRef = { getHTML: () => '<div>saved on close</div>' };\n        instance.state.editedChoiceIndex = 0;\n\n        instance.componentWillUnmount();\n\n        expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>saved on close</div>', 0);\n        expect(instance.state.editedChoiceIndex).toBe(-1);\n      });\n\n      it('should not call onAddChoice when not editing a choice', () => {\n        const localOnAddChoice = jest.fn();\n        const instance = createInstance({ onAddChoice: localOnAddChoice });\n\n        instance.state.editedChoiceIndex = -1;\n        instance.componentWillUnmount();\n\n        expect(localOnAddChoice).not.toHaveBeenCalled();\n      });\n    });\n\n    describe('onClickInside', () => {\n      it('should set clickedInside to true', () => {\n        const instance = createInstance();\n        instance.clickedInside = false;\n\n        instance.onClickInside();\n\n        expect(instance.clickedInside).toBe(true);\n      });\n    });\n  });\n\n  describe('Rendering', () => {\n    it('should return null if toolbarStyle is not set', () => {\n      const instance = createInstance();\n      instance.state.toolbarStyle = null;\n\n      const result = instance.render();\n\n      expect(result).toBeNull();\n    });\n\n    it('should render choices when provided', () => {\n      const instance = createInstance();\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n\n      const wrapper = render(<>{instance.render()}</>);\n\n      expect(wrapper.container.querySelector('[aria-label=\"Edit\"]')).toBeTruthy();\n      expect(wrapper.container.querySelector('[aria-label=\"Remove\"]')).toBeTruthy();\n    });\n\n    it('should not render choices section when choices is null', () => {\n      const instance = createInstance({ choices: null });\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n\n      const wrapper = render(<>{instance.render()}</>);\n\n      const menuItems = wrapper.container.querySelectorAll('[aria-label=\"Edit\"]');\n      expect(menuItems.length).toBe(0);\n    });\n\n    it('should render Add button when not editing a choice', () => {\n      const instance = createInstance();\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n      instance.state.editedChoiceIndex = -1;\n\n      const wrapper = render(<>{instance.render()}</>);\n\n      const addButton = wrapper.container.querySelector('[aria-label=\"Add\"]');\n      expect(addButton).toBeTruthy();\n      expect(addButton.querySelector('[data-testid=\"AddIcon\"]')).toBeTruthy();\n    });\n\n    it('should render Check icon on toolbar button when editing a choice', () => {\n      const instance = createInstance();\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n      instance.state.editedChoiceIndex = 1;\n\n      const wrapper = render(<>{instance.render()}</>);\n\n      const toolbarButton = wrapper.container.querySelector('[aria-label=\"Add\"]');\n      expect(toolbarButton).toBeTruthy();\n      expect(toolbarButton.querySelector('[data-testid=\"CheckIcon\"]')).toBeTruthy();\n      expect(toolbarButton.querySelector('[data-testid=\"AddIcon\"]')).toBeNull();\n    });\n\n    it('should finish editing when toolbar button is clicked while editing', () => {\n      const localOnAddChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          ...editor.commands,\n          refreshResponseArea: jest.fn(),\n        },\n      };\n      const instance = createInstance({\n        onAddChoice: localOnAddChoice,\n        editor: localEditor,\n      });\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n      instance.state.editedChoiceIndex = 1;\n      instance.editorRef = {\n        getHTML: jest.fn().mockReturnValue('<div>updated dog</div>'),\n      };\n\n      const wrapper = render(<>{instance.render()}</>);\n      fireEvent.click(wrapper.container.querySelector('[aria-label=\"Add\"]'));\n\n      expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>updated dog</div>', 1);\n      expect(instance.preventDone).toBe(true);\n    });\n\n    it('should call onAddChoice when toolbar button is clicked while not editing', () => {\n      const mockTr = { isDone: false, deleteSelection: jest.fn() };\n      const localEditor = {\n        ...editor,\n        state: {\n          ...editor.state,\n          tr: mockTr,\n        },\n      };\n      const instance = createInstance({ editor: localEditor });\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n      instance.state.editedChoiceIndex = -1;\n\n      const wrapper = render(<>{instance.render()}</>);\n      fireEvent.click(wrapper.container.querySelector('[aria-label=\"Add\"]'));\n\n      expect(mockTr.isDone).toBe(true);\n      expect(localEditor.view.dispatch).toHaveBeenCalledWith(mockTr);\n    });\n\n    it('should render toolbar above other elements with a high z-index', () => {\n      const instance = createInstance();\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n\n      const wrapper = render(<>{instance.render()}</>);\n      const toolbar = wrapper.container.querySelector('[data-inline-dropdown-toolbar]');\n\n      expect(toolbar).toBeTruthy();\n      expect(toolbar.style.zIndex).toBe('999');\n    });\n  });\n\n  describe('Integration', () => {\n    it('should handle complete flow of adding a choice', () => {\n      const localOnAddChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          ...editor.commands,\n          refreshResponseArea: jest.fn(),\n        },\n      };\n      const instance = createInstance({\n        onAddChoice: localOnAddChoice,\n        editor: localEditor,\n      });\n      instance.editorRef = {\n        getHTML: jest.fn().mockReturnValue('<div>new choice</div>'),\n      };\n\n      // User types and presses Enter\n      const event = { key: 'Enter' };\n      instance.onKeyDown(event);\n\n      expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>new choice</div>', -1);\n      expect(localEditor.commands.refreshResponseArea).toHaveBeenCalled();\n    });\n\n    it('should handle complete flow of editing a choice', () => {\n      const localOnAddChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          ...editor.commands,\n          refreshResponseArea: jest.fn(),\n        },\n      };\n      const instance = createInstance({\n        onAddChoice: localOnAddChoice,\n        editor: localEditor,\n      });\n\n      // User clicks edit button\n      instance.onEditChoice('dog', 1);\n      expect(instance.state.respAreaMarkup).toBe('dog');\n      expect(instance.state.editedChoiceIndex).toBe(1);\n\n      // User completes edit\n      instance.onDone('<div>updated dog</div>');\n      expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>updated dog</div>', 1);\n      expect(instance.state.editedChoiceIndex).toBe(-1);\n    });\n\n    it('should handle complete flow of removing a choice', () => {\n      const localOnRemoveChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          ...editor.commands,\n          refreshResponseArea: jest.fn(),\n        },\n      };\n      const instance = createInstance({\n        onRemoveChoice: localOnRemoveChoice,\n        editor: localEditor,\n      });\n\n      instance.onRemoveChoice('dog', 1);\n\n      expect(localOnRemoveChoice).toHaveBeenCalledWith(1);\n      expect(localEditor.commands.refreshResponseArea).toHaveBeenCalled();\n    });\n\n    it('should handle switching between editing choices without finishing', () => {\n      const localOnAddChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          updateAttributes: jest.fn(),\n          refreshResponseArea: jest.fn(),\n        },\n      };\n      const instance = createInstance({\n        onAddChoice: localOnAddChoice,\n        editor: localEditor,\n      });\n\n      // Mock editor with HTML content\n      instance.editorRef = {\n        getHTML: jest\n          .fn()\n          .mockReturnValueOnce('<div>modified dog</div>')\n          .mockReturnValueOnce('<div>modified cat</div>'),\n      };\n\n      // Start editing first choice\n      instance.onEditChoice('dog', 1);\n      expect(instance.state.editedChoiceIndex).toBe(1);\n      expect(instance.state.respAreaMarkup).toBe('dog');\n\n      // Switch to editing second choice without explicitly calling onDone\n      localOnAddChoice.mockClear();\n      instance.onEditChoice('cat', 2);\n\n      // Should have auto-saved the previous edit\n      expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>modified dog</div>', 1);\n      expect(instance.state.editedChoiceIndex).toBe(2);\n      expect(instance.state.respAreaMarkup).toBe('cat');\n    });\n\n    it('should handle editing the correct choice and switching to another', () => {\n      const localOnAddChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          updateAttributes: jest.fn(),\n          refreshResponseArea: jest.fn(),\n        },\n      };\n      const localOnToolbarDone = jest.fn();\n      const instance = createInstance({\n        onAddChoice: localOnAddChoice,\n        editor: localEditor,\n        onToolbarDone: localOnToolbarDone,\n      });\n\n      // Mock editor with HTML content\n      instance.editorRef = {\n        getHTML: jest.fn().mockReturnValue('<div>modified cow</div>'),\n      };\n\n      // Start editing the correct choice (index 0)\n      instance.onEditChoice('cow', 0);\n      expect(instance.state.editedChoiceIndex).toBe(0);\n\n      // Switch to editing another choice\n      instance.onEditChoice('dog', 1);\n\n      // Should have auto-saved and updated attributes since it was the correct choice\n      expect(localEditor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', {\n        value: '<div>modified cow</div>',\n      });\n      expect(instance.state.editedChoiceIndex).toBe(1);\n    });\n  });\n\n  describe('Edge Cases', () => {\n    it('should handle missing node attrs', () => {\n      const localOnAddChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          ...editor.commands,\n          refreshResponseArea: jest.fn(),\n        },\n      };\n      const instance = createInstance({\n        node: {\n          key: '1',\n          attrs: {},\n        },\n        onAddChoice: localOnAddChoice,\n        editor: localEditor,\n      });\n\n      instance.onDone('<div>test</div>');\n\n      expect(localOnAddChoice).toHaveBeenCalledWith(undefined, '<div>test</div>', -1);\n    });\n\n    it('should handle HTML with nested tags', () => {\n      const localOnAddChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          ...editor.commands,\n          refreshResponseArea: jest.fn(),\n        },\n      };\n      const instance = createInstance({\n        onAddChoice: localOnAddChoice,\n        editor: localEditor,\n      });\n      const complexHtml = '<div><p><strong>Bold</strong> and <em>italic</em></p></div>';\n\n      instance.onDone(complexHtml);\n\n      expect(localOnAddChoice).toHaveBeenCalledWith('0', complexHtml, -1);\n    });\n\n    it('should handle special characters in choices', () => {\n      const localOnAddChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          ...editor.commands,\n          refreshResponseArea: jest.fn(),\n        },\n      };\n      const instance = createInstance({\n        onAddChoice: localOnAddChoice,\n        editor: localEditor,\n      });\n      const specialChars = '<div>&lt;script&gt;alert(\"test\")&lt;/script&gt;</div>';\n\n      instance.onDone(specialChars);\n\n      expect(localOnAddChoice).toHaveBeenCalled();\n    });\n\n    it('should handle empty choices array', () => {\n      const mockTr = { isDone: false, deleteSelection: jest.fn() };\n      const mockDispatch = jest.fn();\n      const localEditor = {\n        ...editor,\n        state: {\n          ...editor.state,\n          tr: mockTr,\n        },\n        view: {\n          ...editor.view,\n          dispatch: mockDispatch,\n        },\n      };\n      const localOnToolbarDone = jest.fn();\n      const instance = createInstance({\n        choices: [],\n        editor: localEditor,\n        onToolbarDone: localOnToolbarDone,\n      });\n\n      instance.onBlur();\n\n      expect(mockDispatch).toHaveBeenCalled();\n      expect(localOnToolbarDone).not.toHaveBeenCalled();\n    });\n  });\n\n  describe('Props Configuration', () => {\n    it('should pass spellCheck prop to EditableHtml', () => {\n      const instance = createInstance({ spellCheck: true });\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n\n      const wrapper = render(<>{instance.render()}</>);\n\n      // The mock EditableHtml should receive spellCheck prop\n      expect(wrapper.container).toBeTruthy();\n    });\n\n    it('should pass uploadSoundSupport prop to EditableHtml', () => {\n      const uploadSoundSupport = { enabled: true };\n      const instance = createInstance({ uploadSoundSupport });\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n\n      const wrapper = render(<>{instance.render()}</>);\n\n      expect(wrapper.container).toBeTruthy();\n    });\n\n    it('should pass mathMlOptions prop to EditableHtml', () => {\n      const mathMlOptions = { mmlEditing: true };\n      const instance = createInstance({ mathMlOptions });\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n\n      const wrapper = render(<>{instance.render()}</>);\n\n      expect(wrapper.container).toBeTruthy();\n    });\n\n    it('should handle editorCallback prop', () => {\n      const editorCallback = jest.fn();\n      const instance = createInstance({ editorCallback });\n      instance.state.toolbarStyle = { position: 'absolute', top: '100px', left: '50px' };\n\n      const wrapper = render(<>{instance.render()}</>);\n\n      // editorCallback would be called in the editorRef callback\n      // This is tested implicitly through rendering\n      expect(wrapper.container).toBeTruthy();\n    });\n  });\n});\n\ndescribe('MenuItem Integration Tests', () => {\n  let onAddChoice;\n  let onRemoveChoice;\n  let onSelectChoice;\n  let onToolbarDone;\n  let editor;\n  let mockDomNode;\n  let mockEditorNode;\n\n  beforeEach(() => {\n    onAddChoice = jest.fn();\n    onRemoveChoice = jest.fn();\n    onSelectChoice = jest.fn();\n    onToolbarDone = jest.fn();\n\n    mockDomNode = {\n      nodeType: 1,\n      getBoundingClientRect: jest.fn().mockReturnValue({\n        top: 100,\n        left: 50,\n        height: 20,\n      }),\n      closest: jest.fn(),\n    };\n\n    mockEditorNode = {\n      getBoundingClientRect: jest.fn().mockReturnValue({\n        top: 80,\n        left: 25,\n      }),\n    };\n\n    mockDomNode.closest.mockReturnValue(mockEditorNode);\n\n    editor = {\n      commands: {\n        updateAttributes: jest.fn(),\n        refreshResponseArea: jest.fn(),\n      },\n      view: {\n        nodeDOM: jest.fn().mockReturnValue(mockDomNode),\n        dispatch: jest.fn(),\n      },\n      state: {\n        selection: { from: 0 },\n        tr: { isDone: false, deleteSelection: jest.fn() },\n      },\n    };\n  });\n\n  const createToolbar = (choices) => {\n    const props = {\n      onAddChoice,\n      onRemoveChoice,\n      onSelectChoice,\n      onToolbarDone,\n      node: {\n        key: '1',\n        attrs: { index: '0', value: 'cow' },\n      },\n      pos: 0,\n      editor,\n      choices,\n    };\n\n    const instance = new RespAreaToolbar(props);\n    instance.props = props;\n\n    // Mock setState to execute updates synchronously\n    instance.setState = jest.fn((state) => {\n      if (typeof state === 'function') {\n        instance.state = { ...instance.state, ...state(instance.state) };\n      } else {\n        instance.state = { ...instance.state, ...state };\n      }\n    });\n\n    instance.componentDidMount();\n\n    return instance;\n  };\n\n  describe('MenuItem Rendering via Parent', () => {\n    it('should render all choice items', () => {\n      const choices = [\n        { label: 'cow', correct: true },\n        { label: 'dog', correct: false },\n        { label: 'cat', correct: false },\n      ];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      const editButtons = rendered.getAllByLabelText('Edit');\n      const removeButtons = rendered.getAllByLabelText('Remove');\n\n      expect(editButtons.length).toBe(3);\n      expect(removeButtons.length).toBe(3);\n    });\n\n    it('should display correct indicator only for correct choice', () => {\n      const choices = [\n        { label: 'cow', correct: true },\n        { label: 'dog', correct: false },\n      ];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      // Check that correct styling is applied\n      expect(rendered.container).toBeTruthy();\n    });\n\n    it('should render choice labels as HTML', () => {\n      const choices = [{ label: '<p><strong>Bold choice</strong></p>', correct: true }];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      expect(rendered.container.innerHTML).toContain('Bold choice');\n    });\n  });\n\n  describe('MenuItem Click Interactions', () => {\n    it('should call onSelectChoice when clicking a choice', () => {\n      const choices = [\n        { label: 'cow', correct: true },\n        { label: 'dog', correct: false },\n      ];\n\n      const localOnSelectChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          updateAttributes: jest.fn(),\n          refreshResponseArea: jest.fn(),\n        },\n      };\n\n      const props = {\n        onAddChoice,\n        onRemoveChoice,\n        onSelectChoice: localOnSelectChoice,\n        onToolbarDone,\n        node: {\n          key: '1',\n          attrs: { index: '0', value: 'cow' },\n        },\n        pos: 0,\n        editor: localEditor,\n        choices,\n      };\n\n      const instance = new RespAreaToolbar(props);\n      instance.props = props;\n      instance.setState = jest.fn((state) => {\n        if (typeof state === 'function') {\n          instance.state = { ...instance.state, ...state(instance.state) };\n        } else {\n          instance.state = { ...instance.state, ...state };\n        }\n      });\n      instance.componentDidMount();\n\n      const rendered = render(<>{instance.render()}</>);\n\n      // Find the second choice (dog) - use the parent div that has onClick\n      const choiceElements = rendered.container.querySelectorAll('[dangerouslySetInnerHTML]');\n      if (choiceElements[1]) {\n        fireEvent.click(choiceElements[1]);\n\n        expect(localEditor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', { value: 'dog' });\n        expect(localOnSelectChoice).toHaveBeenCalledWith(1);\n      }\n    });\n\n    it('should call onEditChoice when clicking Edit button', () => {\n      const choices = [\n        { label: 'cow', correct: true },\n        { label: 'dog', correct: false },\n      ];\n\n      const instance = createToolbar(choices);\n      // Mock editorRef to prevent errors when auto-saving\n      instance.editorRef = {\n        getHTML: jest.fn().mockReturnValue(''),\n      };\n      const rendered = render(<>{instance.render()}</>);\n\n      const editButtons = rendered.getAllByLabelText('Edit');\n      fireEvent.click(editButtons[1]);\n\n      expect(instance.state.respAreaMarkup).toBe('dog');\n      expect(instance.state.editedChoiceIndex).toBe(1);\n    });\n\n    it('should call onRemoveChoice when clicking Remove button', () => {\n      const choices = [\n        { label: 'cow', correct: true },\n        { label: 'dog', correct: false },\n      ];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      const removeButtons = rendered.getAllByLabelText('Remove');\n      fireEvent.click(removeButtons[1]);\n\n      expect(onRemoveChoice).toHaveBeenCalledWith(1);\n      expect(editor.commands.refreshResponseArea).toHaveBeenCalled();\n    });\n\n    it('should update to null when removing the selected choice', () => {\n      const choices = [\n        { label: 'cow', correct: true },\n        { label: 'dog', correct: false },\n      ];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      const removeButtons = rendered.getAllByLabelText('Remove');\n      fireEvent.click(removeButtons[0]); // Remove 'cow' which is the selected value\n\n      expect(editor.commands.updateAttributes).toHaveBeenCalledWith('inline_dropdown', { value: null });\n      expect(onToolbarDone).not.toHaveBeenCalled();\n    });\n  });\n\n  describe('MenuItem Edit/Remove Action Buttons', () => {\n    it('should have Edit and Remove buttons for each choice', () => {\n      const choices = [\n        { label: 'choice1', correct: false },\n        { label: 'choice2', correct: false },\n        { label: 'choice3', correct: true },\n      ];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      const editButtons = rendered.getAllByLabelText('Edit');\n      const removeButtons = rendered.getAllByLabelText('Remove');\n\n      expect(editButtons.length).toBe(3);\n      expect(removeButtons.length).toBe(3);\n    });\n\n    it('should not trigger choice selection when clicking action buttons', () => {\n      const choices = [{ label: 'cow', correct: true }];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      const editButton = rendered.getByLabelText('Edit');\n      fireEvent.click(editButton);\n\n      // onSelectChoice should not be called, only state should update\n      expect(onSelectChoice).not.toHaveBeenCalled();\n      expect(instance.state.editedChoiceIndex).toBe(0);\n    });\n  });\n\n  describe('MenuItem Visual States', () => {\n    it('should apply correct styling to correct choice', () => {\n      const choices = [\n        { label: 'correct answer', correct: true },\n        { label: 'wrong answer', correct: false },\n      ];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      // The correct choice should have special styling\n      expect(rendered.container).toBeTruthy();\n    });\n\n    it('should show check icon for correct choice', () => {\n      const choices = [{ label: 'correct answer', correct: true }];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      // Check for CheckIcon in the rendered output\n      const checkIcon = rendered.container.querySelector('svg');\n      expect(checkIcon).toBeTruthy();\n    });\n  });\n\n  describe('MenuItem Edge Cases', () => {\n    it('should handle empty label gracefully', () => {\n      const choices = [{ label: '', correct: false }];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      const editButtons = rendered.getAllByLabelText('Edit');\n      expect(editButtons.length).toBe(1);\n    });\n\n    it('should handle HTML entities in labels', () => {\n      const choices = [{ label: '&lt;p&gt;escaped&lt;/p&gt;', correct: false }];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      expect(rendered.container).toBeTruthy();\n    });\n\n    it('should handle very long labels', () => {\n      const longLabel = '<p>' + 'a'.repeat(500) + '</p>';\n      const choices = [{ label: longLabel, correct: false }];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      expect(rendered.container).toBeTruthy();\n    });\n\n    it('should handle special characters in labels', () => {\n      const choices = [{ label: '<p>Math: x² + y² = z²</p>', correct: false }];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      expect(rendered.container.innerHTML).toContain('x²');\n    });\n  });\n\n  describe('Multiple MenuItem Interactions', () => {\n    it('should allow editing multiple choices sequentially', () => {\n      const choices = [\n        { label: 'choice1', correct: false },\n        { label: 'choice2', correct: false },\n      ];\n\n      const instance = createToolbar(choices);\n      // Mock editorRef to prevent errors when auto-saving\n      instance.editorRef = {\n        getHTML: jest.fn().mockReturnValue(''),\n      };\n      const rendered = render(<>{instance.render()}</>);\n\n      const editButtons = rendered.getAllByLabelText('Edit');\n\n      fireEvent.click(editButtons[0]);\n      expect(instance.state.editedChoiceIndex).toBe(0);\n\n      fireEvent.click(editButtons[1]);\n      expect(instance.state.editedChoiceIndex).toBe(1);\n    });\n\n    it('should auto-save when switching between editing choices', () => {\n      const localOnAddChoice = jest.fn();\n      const localEditor = {\n        ...editor,\n        commands: {\n          updateAttributes: jest.fn(),\n          refreshResponseArea: jest.fn(),\n        },\n      };\n\n      const choices = [\n        { label: 'choice1', correct: false },\n        { label: 'choice2', correct: false },\n      ];\n\n      const props = {\n        onAddChoice: localOnAddChoice,\n        onRemoveChoice,\n        onSelectChoice,\n        onToolbarDone,\n        node: {\n          key: '1',\n          attrs: { index: '0', value: 'cow' },\n        },\n        pos: 0,\n        editor: localEditor,\n        choices,\n      };\n\n      const instance = new RespAreaToolbar(props);\n      instance.props = props;\n      instance.setState = jest.fn((state) => {\n        if (typeof state === 'function') {\n          instance.state = { ...instance.state, ...state(instance.state) };\n        } else {\n          instance.state = { ...instance.state, ...state };\n        }\n      });\n      instance.editorRef = {\n        getHTML: jest.fn().mockReturnValue('<div>modified choice1</div>'),\n      };\n      instance.componentDidMount();\n\n      // Start editing first choice directly\n      instance.onEditChoice('choice1', 0);\n      expect(instance.state.editedChoiceIndex).toBe(0);\n\n      // Start editing second choice - should auto-save first choice\n      instance.onEditChoice('choice2', 1);\n      expect(localOnAddChoice).toHaveBeenCalledWith('0', '<div>modified choice1</div>', 0);\n      expect(instance.state.editedChoiceIndex).toBe(1);\n    });\n\n    it('should allow removing multiple choices', () => {\n      const choices = [\n        { label: 'choice1', correct: false },\n        { label: 'choice2', correct: false },\n        { label: 'choice3', correct: true },\n      ];\n\n      const instance = createToolbar(choices);\n      const rendered = render(<>{instance.render()}</>);\n\n      const removeButtons = rendered.getAllByLabelText('Remove');\n\n      fireEvent.click(removeButtons[0]);\n      expect(onRemoveChoice).toHaveBeenCalledWith(0);\n\n      fireEvent.click(removeButtons[1]);\n      expect(onRemoveChoice).toHaveBeenCalledWith(1);\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}