@pie-element/explicit-constructed-response 11.0.1 → 11.1.0-beta.1

package/configure/lib/__tests__/alternateSection.test.js

@@ -0,0 +1,372 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = require("@testing-library/react");
+var _react2 = _interopRequireDefault(require("react"));
+var _styles = require("@mui/material/styles");
+var _alternateSection = require("../alternateSection");
+jest.mock('@pie-lib/editable-html-tip-tap', () => ({
+  __esModule: true,
+  default: ({
+    markup,
+    onChange
+  }) => /*#__PURE__*/_react2.default.createElement("div", {
+    "data-testid": "editable-html",
+    onClick: () => onChange && onChange('test')
+  }, markup),
+  ALL_PLUGINS: []
+}));
+const theme = (0, _styles.createTheme)();
+const choices = [{
+  label: 'cow',
+  value: '0'
+}, {
+  label: 'cattle',
+  value: '1'
+}, {
+  label: 'calf',
+  value: '2'
+}];
+describe('Choice', () => {
+  let onChange = jest.fn();
+  let onDelete = jest.fn();
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  const renderChoice = () => {
+    const defaults = {
+      classes: {},
+      key: '0',
+      markup: 'cow',
+      onChange,
+      onDelete
+    };
+    const props = {
+      ...defaults
+    };
+    return (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react2.default.createElement(_alternateSection.Choice, props)));
+  };
+  describe('logic', () => {
+    it('calls onChange', () => {
+      jest.useFakeTimers();
+      const testInstance = new _alternateSection.Choice({
+        classes: {},
+        key: '0',
+        markup: 'cow',
+        onChange,
+        onDelete
+      });
+
+      // Initialize state and mock setState
+      testInstance.state = {
+        value: 'cow'
+      };
+      testInstance.setState = jest.fn(newState => {
+        testInstance.state = {
+          ...testInstance.state,
+          ...newState
+        };
+      });
+
+      // Call onChange with a string (as EditableHtml does)
+      testInstance.onChange('TEST');
+
+      // Fast-forward time to trigger debounced callback
+      jest.advanceTimersByTime(400);
+      expect(onChange).toHaveBeenCalledWith('TEST');
+      jest.useRealTimers();
+    });
+  });
+});
+describe('AlternateSection', () => {
+  let onSelect = jest.fn();
+  let choiceChanged = jest.fn();
+  let choiceRemoved = jest.fn();
+  let lengthChanged = jest.fn();
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  // Helper function to create a properly initialized test instance
+  const createTestInstance = (extras = {}) => {
+    const defaults = {
+      classes: {},
+      key: '0',
+      value: 'cow',
+      onSelect,
+      choiceChanged,
+      choiceRemoved,
+      lengthChanged,
+      selectChoices: [{
+        label: 'moon',
+        value: '2'
+      }],
+      choices,
+      maxLength: 10,
+      ...extras
+    };
+    const testInstance = new _alternateSection.AlternateSection(defaults);
+    // Initialize state manually since we're not mounting
+    testInstance.state = {
+      choices: []
+    };
+
+    // Mock setState to capture state updates
+    testInstance.setState = jest.fn(newState => {
+      testInstance.state = {
+        ...testInstance.state,
+        ...newState
+      };
+    });
+    return testInstance;
+  };
+  const renderAlternateSection = (extras = {}) => {
+    const defaults = {
+      classes: {},
+      key: '0',
+      value: 'cow',
+      onSelect,
+      choiceChanged,
+      choiceRemoved,
+      lengthChanged,
+      selectChoices: [{
+        label: 'moon',
+        value: '2'
+      }],
+      choices,
+      maxLength: 10,
+      ...extras
+    };
+    const props = {
+      ...defaults
+    };
+    return (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react2.default.createElement(_alternateSection.AlternateSection, props)));
+  };
+  describe('logic', () => {
+    describe('updateChoicesIfNeeded', () => {
+      it('does not set state', () => {
+        const testInstance = createTestInstance();
+        testInstance.updateChoicesIfNeeded({
+          choices
+        });
+        expect(testInstance.state).toEqual(expect.objectContaining({
+          choices
+        }));
+      });
+      it('sets state, updates edited choice', () => {
+        const testInstance = createTestInstance();
+        const newChoices = [{
+          label: 'cow',
+          value: '0'
+        }, {
+          label: 'cattle',
+          value: '1'
+        }, {
+          label: 'little calf',
+          value: '2'
+        }];
+        testInstance.updateChoicesIfNeeded({
+          choices: newChoices
+        });
+        expect(testInstance.state).toEqual(expect.objectContaining({
+          choices: newChoices
+        }));
+      });
+      it('sets state, updates adding new choice', () => {
+        const testInstance = createTestInstance();
+        const newChoices = [{
+          label: 'cow',
+          value: '0'
+        }, {
+          label: 'cattle',
+          value: '1'
+        }, {
+          label: 'little calf',
+          value: '2'
+        }];
+        testInstance.updateChoicesIfNeeded({
+          choices: newChoices
+        });
+        expect(testInstance.state).toEqual(expect.objectContaining({
+          choices: newChoices
+        }));
+      });
+      it('sets state, updates removing choice', () => {
+        const testInstance = createTestInstance();
+        const newChoices = [{
+          label: 'cow',
+          value: '0'
+        }, {
+          label: 'cattle',
+          value: '1'
+        }];
+        testInstance.updateChoicesIfNeeded({
+          choices: newChoices
+        });
+        expect(testInstance.state).toEqual(expect.objectContaining({
+          choices: newChoices
+        }));
+      });
+    });
+    describe('handleSelect', () => {
+      it('calls onSelect', () => {
+        const testInstance = createTestInstance();
+        testInstance.handleSelect({
+          target: {
+            value: '2'
+          }
+        });
+        expect(onSelect).toBeCalledWith({
+          label: 'moon',
+          value: '2'
+        });
+      });
+    });
+    describe('onAddChoice', () => {
+      it('adds choice', () => {
+        const testInstance = createTestInstance();
+        testInstance.state = {
+          choices: [...choices]
+        };
+        const stateBefore = [...testInstance.state.choices];
+        testInstance.onAddChoice();
+        expect(testInstance.state.choices).toEqual([...stateBefore, {
+          value: '3',
+          label: ''
+        }]);
+      });
+      it('does not add choice if previously added choice is empty', () => {
+        const testInstance = createTestInstance();
+        testInstance.state = {
+          choices: [...choices]
+        };
+        const stateBefore = [...testInstance.state.choices];
+        testInstance.onAddChoice();
+        const afterFirstAdd = [...testInstance.state.choices];
+        expect(afterFirstAdd).toEqual([...stateBefore, {
+          value: '3',
+          label: ''
+        }]);
+        testInstance.onAddChoice();
+        expect(testInstance.state.choices).toEqual(afterFirstAdd);
+      });
+    });
+    describe('onChoiceChanged', () => {
+      beforeEach(() => {
+        choiceChanged.mockClear();
+        lengthChanged.mockClear();
+      });
+      it('calls choiceChanged', () => {
+        const testInstance = createTestInstance();
+        testInstance.state = {
+          choices: [...choices]
+        };
+        testInstance.onChoiceChanged({
+          value: '0',
+          label: 'cow'
+        }, 'New value');
+        expect(choiceChanged).toBeCalledWith({
+          value: '0',
+          label: 'New value'
+        });
+      });
+      it('calls lengthChanged when new max length is greater than current maxLength', () => {
+        // ['cow', 'cattle', 'calf'] - max length is 6 (cattle)
+        // maxLength prop is 10, so we need something longer than 10
+        const longChoice = 'Very long choice text'; // 21 characters
+
+        const testInstance = createTestInstance();
+        testInstance.state = {
+          choices: [...choices]
+        };
+        testInstance.onChoiceChanged({
+          value: '0',
+          label: 'cow'
+        }, longChoice, 0);
+
+        // 21 + 5 = 26
+        expect(lengthChanged).toHaveBeenCalledWith(26);
+      });
+      it('calls lengthChanged when new max length is significantly smaller', () => {
+        const testInstance = createTestInstance({
+          maxLength: 30
+        });
+        testInstance.state = {
+          choices: [...choices]
+        };
+
+        // ['cow', 'cattle', 'calf'] - max length is 6
+        testInstance.onChoiceChanged({
+          value: '1',
+          label: 'cattle'
+        }, 'a', 1);
+
+        // max length will be 4 (max of 'cow', 'a', 'calf')
+        // Since 4 + 10 = 14 <= 30, this should trigger lengthChanged
+        expect(lengthChanged).toHaveBeenCalledWith(7); // getAdjustedLength(4) = 4 + 3 = 7
+      });
+      it('does not call lengthChanged when new max length is within threshold', () => {
+        // ['cow', 'cattle', 'calf'] - max length is 6
+        // maxLength is 10, change to something that keeps max around the same
+        const testInstance = createTestInstance();
+        testInstance.state = {
+          choices: [...choices]
+        };
+        testInstance.onChoiceChanged({
+          value: '0',
+          label: 'cow'
+        }, 'bull', 0);
+
+        // max length will still be 6 (cattle), which is not > 10 and not <= 0 (10-10)
+        expect(lengthChanged).not.toHaveBeenCalled();
+      });
+      it('calculates max length across all choices correctly', () => {
+        const shortChoices = [{
+          label: 'a',
+          value: '0'
+        }, {
+          label: 'bb',
+          value: '1'
+        }, {
+          label: 'ccc',
+          value: '2'
+        }];
+        const testInstance = createTestInstance({
+          choices: shortChoices,
+          maxLength: 5
+        });
+        testInstance.state = {
+          choices: [...shortChoices]
+        };
+        testInstance.onChoiceChanged({
+          value: '2',
+          label: 'ccc'
+        }, 'This is much longer', 2);
+        expect(lengthChanged).toHaveBeenCalledWith(24);
+      });
+      it('handles mixed special characters correctly', () => {
+        lengthChanged.mockClear();
+        const mixedSpecialChoice = 'Test with & < > " \' symbols'; // 27 chars when decoded
+
+        const testInstance = createTestInstance({
+          maxLength: 5
+        });
+        testInstance.state = {
+          choices: [...choices]
+        };
+        testInstance.onChoiceChanged({
+          value: '0',
+          label: 'cow'
+        }, mixedSpecialChoice, 0);
+
+        // 27 normal characters + 5 buffer = 32
+        expect(lengthChanged).toHaveBeenCalledWith(32);
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","_react2","_interopRequireDefault","_styles","_alternateSection","jest","mock","__esModule","default","markup","onChange","createElement","onClick","ALL_PLUGINS","theme","createTheme","choices","label","value","describe","fn","onDelete","beforeEach","clearAllMocks","renderChoice","defaults","classes","key","props","render","ThemeProvider","Choice","it","useFakeTimers","testInstance","state","setState","newState","advanceTimersByTime","expect","toHaveBeenCalledWith","useRealTimers","onSelect","choiceChanged","choiceRemoved","lengthChanged","createTestInstance","extras","selectChoices","maxLength","AlternateSection","renderAlternateSection","updateChoicesIfNeeded","toEqual","objectContaining","newChoices","handleSelect","target","toBeCalledWith","stateBefore","onAddChoice","afterFirstAdd","mockClear","onChoiceChanged","longChoice","not","toHaveBeenCalled","shortChoices","mixedSpecialChoice"],"sources":["../../src/__tests__/alternateSection.test.jsx"],"sourcesContent":["import { render } from '@testing-library/react';\nimport React from 'react';\nimport { ThemeProvider, createTheme } from '@mui/material/styles';\n\nimport { AlternateSection, Choice } from '../alternateSection';\n\njest.mock('@pie-lib/editable-html-tip-tap', () => ({\n  __esModule: true,\n  default: ({ markup, onChange }) => (\n    <div data-testid=\"editable-html\" onClick={() => onChange && onChange('test')}>\n      {markup}\n    </div>\n  ),\n  ALL_PLUGINS: [],\n}));\n\nconst theme = createTheme();\n\nconst choices = [\n  { label: 'cow', value: '0' },\n  { label: 'cattle', value: '1' },\n  { label: 'calf', value: '2' },\n];\n\ndescribe('Choice', () => {\n  let onChange = jest.fn();\n  let onDelete = jest.fn();\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n  });\n\n  const renderChoice = () => {\n    const defaults = {\n      classes: {},\n      key: '0',\n      markup: 'cow',\n      onChange,\n      onDelete,\n    };\n    const props = { ...defaults };\n\n    return render(\n      <ThemeProvider theme={theme}>\n        <Choice {...props} />\n      </ThemeProvider>\n    );\n  };\n\n  describe('logic', () => {\n    it('calls onChange', () => {\n      jest.useFakeTimers();\n\n      const testInstance = new Choice({\n        classes: {},\n        key: '0',\n        markup: 'cow',\n        onChange,\n        onDelete,\n      });\n\n      // Initialize state and mock setState\n      testInstance.state = { value: 'cow' };\n      testInstance.setState = jest.fn((newState) => {\n        testInstance.state = { ...testInstance.state, ...newState };\n      });\n\n      // Call onChange with a string (as EditableHtml does)\n      testInstance.onChange('TEST');\n\n      // Fast-forward time to trigger debounced callback\n      jest.advanceTimersByTime(400);\n\n      expect(onChange).toHaveBeenCalledWith('TEST');\n\n      jest.useRealTimers();\n    });\n  });\n});\n\ndescribe('AlternateSection', () => {\n  let onSelect = jest.fn();\n  let choiceChanged = jest.fn();\n  let choiceRemoved = jest.fn();\n  let lengthChanged = jest.fn();\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n  });\n\n  // Helper function to create a properly initialized test instance\n  const createTestInstance = (extras = {}) => {\n    const defaults = {\n      classes: {},\n      key: '0',\n      value: 'cow',\n      onSelect,\n      choiceChanged,\n      choiceRemoved,\n      lengthChanged,\n      selectChoices: [{ label: 'moon', value: '2' }],\n      choices,\n      maxLength: 10,\n      ...extras\n    };\n\n    const testInstance = new AlternateSection(defaults);\n    // Initialize state manually since we're not mounting\n    testInstance.state = { choices: [] };\n\n    // Mock setState to capture state updates\n    testInstance.setState = jest.fn((newState) => {\n      testInstance.state = { ...testInstance.state, ...newState };\n    });\n\n    return testInstance;\n  };\n\n  const renderAlternateSection = (extras = {}) => {\n    const defaults = {\n      classes: {},\n      key: '0',\n      value: 'cow',\n      onSelect,\n      choiceChanged,\n      choiceRemoved,\n      lengthChanged,\n      selectChoices: [{ label: 'moon', value: '2' }],\n      choices,\n      maxLength: 10,\n      ...extras\n    };\n    const props = { ...defaults };\n\n    return render(\n      <ThemeProvider theme={theme}>\n        <AlternateSection {...props} />\n      </ThemeProvider>\n    );\n  };\n\n  describe('logic', () => {\n    describe('updateChoicesIfNeeded', () => {\n      it('does not set state', () => {\n        const testInstance = createTestInstance();\n\n        testInstance.updateChoicesIfNeeded({ choices });\n\n        expect(testInstance.state).toEqual(expect.objectContaining({ choices }));\n      });\n\n      it('sets state, updates edited choice', () => {\n        const testInstance = createTestInstance();\n\n        const newChoices = [\n          { label: 'cow', value: '0' },\n          { label: 'cattle', value: '1' },\n          { label: 'little calf', value: '2' },\n        ];\n\n        testInstance.updateChoicesIfNeeded({ choices: newChoices });\n\n        expect(testInstance.state).toEqual(\n          expect.objectContaining({\n            choices: newChoices,\n          }),\n        );\n      });\n\n      it('sets state, updates adding new choice', () => {\n        const testInstance = createTestInstance();\n\n        const newChoices = [\n          { label: 'cow', value: '0' },\n          { label: 'cattle', value: '1' },\n          { label: 'little calf', value: '2' },\n        ];\n\n        testInstance.updateChoicesIfNeeded({ choices: newChoices });\n\n        expect(testInstance.state).toEqual(\n          expect.objectContaining({\n            choices: newChoices,\n          }),\n        );\n      });\n\n      it('sets state, updates removing choice', () => {\n        const testInstance = createTestInstance();\n\n        const newChoices = [\n          { label: 'cow', value: '0' },\n          { label: 'cattle', value: '1' },\n        ];\n\n        testInstance.updateChoicesIfNeeded({ choices: newChoices });\n\n        expect(testInstance.state).toEqual(\n          expect.objectContaining({\n            choices: newChoices,\n          }),\n        );\n      });\n    });\n\n    describe('handleSelect', () => {\n      it('calls onSelect', () => {\n        const testInstance = createTestInstance();\n\n        testInstance.handleSelect({ target: { value: '2' } });\n\n        expect(onSelect).toBeCalledWith({ label: 'moon', value: '2' });\n      });\n    });\n\n    describe('onAddChoice', () => {\n      it('adds choice', () => {\n        const testInstance = createTestInstance();\n        testInstance.state = { choices: [...choices] };\n\n        const stateBefore = [...testInstance.state.choices];\n\n        testInstance.onAddChoice();\n\n        expect(testInstance.state.choices).toEqual([...stateBefore, { value: '3', label: '' }]);\n      });\n\n      it('does not add choice if previously added choice is empty', () => {\n        const testInstance = createTestInstance();\n        testInstance.state = { choices: [...choices] };\n\n        const stateBefore = [...testInstance.state.choices];\n\n        testInstance.onAddChoice();\n\n        const afterFirstAdd = [...testInstance.state.choices];\n        expect(afterFirstAdd).toEqual([...stateBefore, { value: '3', label: '' }]);\n\n        testInstance.onAddChoice();\n\n        expect(testInstance.state.choices).toEqual(afterFirstAdd);\n      });\n    });\n\n    describe('onChoiceChanged', () => {\n      beforeEach(() => {\n        choiceChanged.mockClear();\n        lengthChanged.mockClear();\n      });\n\n      it('calls choiceChanged', () => {\n        const testInstance = createTestInstance();\n        testInstance.state = { choices: [...choices] };\n\n        testInstance.onChoiceChanged({ value: '0', label: 'cow' }, 'New value');\n\n        expect(choiceChanged).toBeCalledWith({ value: '0', label: 'New value' });\n      });\n\n      it('calls lengthChanged when new max length is greater than current maxLength', () => {\n        // ['cow', 'cattle', 'calf'] - max length is 6 (cattle)\n        // maxLength prop is 10, so we need something longer than 10\n        const longChoice = 'Very long choice text'; // 21 characters\n\n        const testInstance = createTestInstance();\n        testInstance.state = { choices: [...choices] };\n\n        testInstance.onChoiceChanged({ value: '0', label: 'cow' }, longChoice, 0);\n\n        // 21 + 5 = 26\n        expect(lengthChanged).toHaveBeenCalledWith(26);\n      });\n\n      it('calls lengthChanged when new max length is significantly smaller', () => {\n        const testInstance = createTestInstance({ maxLength: 30 });\n        testInstance.state = { choices: [...choices] };\n\n        // ['cow', 'cattle', 'calf'] - max length is 6\n        testInstance.onChoiceChanged({ value: '1', label: 'cattle' }, 'a', 1);\n\n        // max length will be 4 (max of 'cow', 'a', 'calf')\n        // Since 4 + 10 = 14 <= 30, this should trigger lengthChanged\n        expect(lengthChanged).toHaveBeenCalledWith(7); // getAdjustedLength(4) = 4 + 3 = 7\n      });\n\n      it('does not call lengthChanged when new max length is within threshold', () => {\n        // ['cow', 'cattle', 'calf'] - max length is 6\n        // maxLength is 10, change to something that keeps max around the same\n        const testInstance = createTestInstance();\n        testInstance.state = { choices: [...choices] };\n\n        testInstance.onChoiceChanged({ value: '0', label: 'cow' }, 'bull', 0);\n\n        // max length will still be 6 (cattle), which is not > 10 and not <= 0 (10-10)\n        expect(lengthChanged).not.toHaveBeenCalled();\n      });\n\n      it('calculates max length across all choices correctly', () => {\n        const shortChoices = [\n          { label: 'a', value: '0' },\n          { label: 'bb', value: '1' },\n          { label: 'ccc', value: '2' },\n        ];\n\n        const testInstance = createTestInstance({\n          choices: shortChoices,\n          maxLength: 5\n        });\n        testInstance.state = { choices: [...shortChoices] };\n\n        testInstance.onChoiceChanged(\n          { value: '2', label: 'ccc' },\n          'This is much longer',\n          2\n        );\n        expect(lengthChanged).toHaveBeenCalledWith(24);\n      });\n\n      it('handles mixed special characters correctly', () => {\n        lengthChanged.mockClear();\n        const mixedSpecialChoice = 'Test with & < > \" \\' symbols'; // 27 chars when decoded\n\n        const testInstance = createTestInstance({ maxLength: 5 });\n        testInstance.state = { choices: [...choices] };\n\n        testInstance.onChoiceChanged({ value: '0', label: 'cow' }, mixedSpecialChoice, 0);\n\n        // 27 normal characters + 5 buffer = 32\n        expect(lengthChanged).toHaveBeenCalledWith(32);\n      });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/configure/lib/__tests__/ecr-toolbar.test.js

@@ -0,0 +1,214 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = require("@testing-library/react");
+var _react2 = _interopRequireDefault(require("react"));
+var _styles = require("@mui/material/styles");
+var _ecrToolbar = require("../ecr-toolbar");
+jest.mock('@pie-lib/editable-html-tip-tap', () => ({
+  __esModule: true,
+  default: ({
+    markup,
+    onChange
+  }) => /*#__PURE__*/_react2.default.createElement("div", {
+    "data-testid": "editable-html",
+    onClick: () => onChange && onChange('test')
+  }, markup)
+}));
+const theme = (0, _styles.createTheme)();
+describe('ECRToolbar', () => {
+  let onChangeResponse = jest.fn();
+  let onToolbarDone = jest.fn();
+  let editor;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    editor = {
+      commands: {
+        updateAttributes: jest.fn()
+      },
+      state: {
+        selection: {
+          from: 0
+        },
+        tr: {
+          setNodeMarkup: jest.fn()
+        }
+      },
+      view: {
+        dispatch: jest.fn(),
+        nodeDOM: jest.fn().mockReturnValue({
+          nodeType: 1,
+          getBoundingClientRect: jest.fn().mockReturnValue({
+            top: 100,
+            left: 50,
+            width: 200,
+            height: 30
+          }),
+          closest: jest.fn().mockReturnValue({
+            getBoundingClientRect: jest.fn().mockReturnValue({
+              top: 0,
+              left: 0
+            })
+          })
+        })
+      }
+    };
+  });
+  const renderToolbar = () => {
+    const defaults = {
+      onChangeResponse,
+      onToolbarDone,
+      classes: {},
+      node: {
+        key: 1,
+        attrs: {
+          index: '2',
+          value: 'moon'
+        },
+        data: {
+          get: prop => {
+            if (prop === 'index') {
+              return '2';
+            }
+            return 'moon';
+          },
+          toJSON: jest.fn()
+        }
+      },
+      pos: 5,
+      editor,
+      correctChoice: {
+        value: '0',
+        label: 'moon'
+      }
+    };
+    const props = {
+      ...defaults
+    };
+    return (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react2.default.createElement(_ecrToolbar.ECRToolbar, props)));
+  };
+  describe('logic', () => {
+    it('onDone: calls onToolbarDone and onChangeResponse', () => {
+      // Create an instance to test the internal method
+      const mockTr = {
+        setNodeMarkup: jest.fn(),
+        doc: {
+          nodeAt: jest.fn().mockReturnValue({
+            isText: false,
+            isAtom: true,
+            isInline: true
+          })
+        }
+      };
+      const testEditor = {
+        ...editor,
+        state: {
+          ...editor.state,
+          tr: mockTr
+        }
+      };
+      const testInstance = new _ecrToolbar.ECRToolbar({
+        onChangeResponse,
+        onToolbarDone,
+        classes: {},
+        node: {
+          key: 1,
+          attrs: {
+            index: '2',
+            value: 'moon'
+          },
+          data: {
+            get: prop => {
+              if (prop === 'index') {
+                return '2';
+              }
+              return 'moon';
+            },
+            toJSON: jest.fn()
+          }
+        },
+        pos: 5,
+        editor: testEditor,
+        value: {
+          change: jest.fn().mockReturnValue({
+            setNodeByKey: jest.fn().mockReturnValue({
+              moveFocusTo: jest.fn().mockReturnValue({
+                moveAnchorTo: jest.fn()
+              })
+            })
+          }),
+          document: {
+            getNextText: jest.fn().mockReturnValue({
+              key: 1
+            })
+          }
+        },
+        correctChoice: {
+          value: '0',
+          label: 'moon'
+        }
+      });
+      testInstance.onDone('test markup');
+      expect(mockTr.setNodeMarkup).toHaveBeenCalledWith(5, undefined, {
+        index: '2',
+        value: 'test markup'
+      });
+      expect(testEditor.view.dispatch).toHaveBeenCalledWith(mockTr);
+      expect(onToolbarDone).toHaveBeenCalledWith(true);
+      expect(onChangeResponse).toHaveBeenCalledWith('test markup');
+    });
+    it('onRespAreaChange updates state', () => {
+      const testInstance = new _ecrToolbar.ECRToolbar({
+        onChangeResponse,
+        onToolbarDone,
+        classes: {},
+        node: {
+          key: 1,
+          attrs: {
+            index: '2',
+            value: 'moon'
+          },
+          data: {
+            get: prop => {
+              if (prop === 'index') {
+                return '2';
+              }
+              return 'moon';
+            },
+            toJSON: jest.fn()
+          }
+        },
+        pos: 5,
+        editor,
+        value: {
+          change: jest.fn().mockReturnValue({
+            setNodeByKey: jest.fn().mockReturnValue({
+              moveFocusTo: jest.fn().mockReturnValue({
+                moveAnchorTo: jest.fn()
+              })
+            })
+          }),
+          document: {
+            getNextText: jest.fn().mockReturnValue({
+              key: 1
+            })
+          }
+        },
+        correctChoice: {
+          value: '0',
+          label: 'moon'
+        }
+      });
+
+      // Spy on setState to verify it's called with the right value
+      const setStateSpy = jest.spyOn(testInstance, 'setState');
+      testInstance.onRespAreaChange('test');
+      expect(setStateSpy).toHaveBeenCalledWith({
+        respAreaMarkup: 'test'
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","_react2","_interopRequireDefault","_styles","_ecrToolbar","jest","mock","__esModule","default","markup","onChange","createElement","onClick","theme","createTheme","describe","onChangeResponse","fn","onToolbarDone","editor","beforeEach","clearAllMocks","commands","updateAttributes","state","selection","from","tr","setNodeMarkup","view","dispatch","nodeDOM","mockReturnValue","nodeType","getBoundingClientRect","top","left","width","height","closest","renderToolbar","defaults","classes","node","key","attrs","index","value","data","get","prop","toJSON","pos","correctChoice","label","props","render","ThemeProvider","ECRToolbar","it","mockTr","doc","nodeAt","isText","isAtom","isInline","testEditor","testInstance","change","setNodeByKey","moveFocusTo","moveAnchorTo","document","getNextText","onDone","expect","toHaveBeenCalledWith","undefined","setStateSpy","spyOn","onRespAreaChange","respAreaMarkup"],"sources":["../../src/__tests__/ecr-toolbar.test.jsx"],"sourcesContent":["import { render } from '@testing-library/react';\nimport React from 'react';\nimport { ThemeProvider, createTheme } from '@mui/material/styles';\n\nimport { ECRToolbar } from '../ecr-toolbar';\n\njest.mock('@pie-lib/editable-html-tip-tap', () => ({\n  __esModule: true,\n  default: ({ markup, onChange }) => (\n    <div data-testid=\"editable-html\" onClick={() => onChange && onChange('test')}>\n      {markup}\n    </div>\n  ),\n}));\n\nconst theme = createTheme();\n\ndescribe('ECRToolbar', () => {\n  let onChangeResponse = jest.fn();\n  let onToolbarDone = jest.fn();\n  let editor;\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n    editor = {\n      commands: {\n        updateAttributes: jest.fn()\n      },\n      state: {\n        selection: {\n          from: 0,\n        },\n        tr: {\n          setNodeMarkup: jest.fn(),\n        },\n      },\n      view: {\n        dispatch: jest.fn(),\n        nodeDOM: jest.fn().mockReturnValue({\n          nodeType: 1,\n          getBoundingClientRect: jest.fn().mockReturnValue({\n            top: 100,\n            left: 50,\n            width: 200,\n            height: 30,\n          }),\n          closest: jest.fn().mockReturnValue({\n            getBoundingClientRect: jest.fn().mockReturnValue({\n              top: 0,\n              left: 0,\n            }),\n          }),\n        }),\n      },\n    };\n  });\n\n  const renderToolbar = () => {\n    const defaults = {\n      onChangeResponse,\n      onToolbarDone,\n      classes: {},\n      node: {\n        key: 1,\n        attrs: {\n          index: '2',\n          value: 'moon',\n        },\n        data: {\n          get: (prop) => {\n            if (prop === 'index') {\n              return '2';\n            }\n\n            return 'moon';\n          },\n          toJSON: jest.fn(),\n        },\n      },\n      pos: 5,\n      editor,\n      correctChoice: { value: '0', label: 'moon' },\n    };\n    const props = { ...defaults };\n\n    return render(\n      <ThemeProvider theme={theme}>\n        <ECRToolbar {...props} />\n      </ThemeProvider>\n    );\n  };\n\n  describe('logic', () => {\n    it('onDone: calls onToolbarDone and onChangeResponse', () => {\n      // Create an instance to test the internal method\n      const mockTr = {\n        setNodeMarkup: jest.fn(),\n        doc: {\n          nodeAt: jest.fn().mockReturnValue({\n            isText: false,\n            isAtom: true,\n            isInline: true,\n          }),\n        },\n      };\n      const testEditor = {\n        ...editor,\n        state: {\n          ...editor.state,\n          tr: mockTr,\n        },\n      };\n      const testInstance = new ECRToolbar({\n        onChangeResponse,\n        onToolbarDone,\n        classes: {},\n        node: {\n          key: 1,\n          attrs: {\n            index: '2',\n            value: 'moon',\n          },\n          data: {\n            get: (prop) => {\n              if (prop === 'index') {\n                return '2';\n              }\n              return 'moon';\n            },\n            toJSON: jest.fn(),\n          },\n        },\n        pos: 5,\n        editor: testEditor,\n        value: {\n          change: jest.fn().mockReturnValue({\n            setNodeByKey: jest.fn().mockReturnValue({\n              moveFocusTo: jest.fn().mockReturnValue({\n                moveAnchorTo: jest.fn(),\n              }),\n            }),\n          }),\n          document: {\n            getNextText: jest.fn().mockReturnValue({\n              key: 1,\n            }),\n          },\n        },\n        correctChoice: { value: '0', label: 'moon' },\n      });\n\n      testInstance.onDone('test markup');\n\n      expect(mockTr.setNodeMarkup).toHaveBeenCalledWith(5, undefined, {\n        index: '2',\n        value: 'test markup',\n      });\n      expect(testEditor.view.dispatch).toHaveBeenCalledWith(mockTr);\n      expect(onToolbarDone).toHaveBeenCalledWith(true);\n      expect(onChangeResponse).toHaveBeenCalledWith('test markup');\n    });\n\n    it('onRespAreaChange updates state', () => {\n      const testInstance = new ECRToolbar({\n        onChangeResponse,\n        onToolbarDone,\n        classes: {},\n        node: {\n          key: 1,\n          attrs: {\n            index: '2',\n            value: 'moon',\n          },\n          data: {\n            get: (prop) => {\n              if (prop === 'index') {\n                return '2';\n              }\n              return 'moon';\n            },\n            toJSON: jest.fn(),\n          },\n        },\n        pos: 5,\n        editor,\n        value: {\n          change: jest.fn().mockReturnValue({\n            setNodeByKey: jest.fn().mockReturnValue({\n              moveFocusTo: jest.fn().mockReturnValue({\n                moveAnchorTo: jest.fn(),\n              }),\n            }),\n          }),\n          document: {\n            getNextText: jest.fn().mockReturnValue({\n              key: 1,\n            }),\n          },\n        },\n        correctChoice: { value: '0', label: 'moon' },\n      });\n\n      // Spy on setState to verify it's called with the right value\n      const setStateSpy = jest.spyOn(testInstance, 'setState');\n\n      testInstance.onRespAreaChange('test');\n\n      expect(setStateSpy).toHaveBeenCalledWith({ respAreaMarkup: 'test' });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}