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

package/lib/__tests__/EditableHtml.test.js

@@ -0,0 +1,831 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _react3 = require("@tiptap/react");
+var _EditableHtml = require("../components/EditableHtml");
+var _responseArea = require("../extensions/responseArea");
+var _excluded = ["editor"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// Mock TipTap dependencies
+jest.mock('@tiptap/react', function () {
+  return {
+    EditorContent: function EditorContent(_ref) {
+      var editor = _ref.editor,
+        props = (0, _objectWithoutProperties2["default"])(_ref, _excluded);
+      return /*#__PURE__*/_react["default"].createElement("div", (0, _extends2["default"])({
+        "data-testid": "editor-content"
+      }, props));
+    },
+    useEditor: jest.fn(function (config) {
+      var mockEditor = {
+        getHTML: jest.fn(function () {
+          return '<p>test content</p>';
+        }),
+        setEditable: jest.fn(),
+        commands: {
+          setContent: jest.fn()
+        },
+        isActive: jest.fn(function () {
+          return false;
+        }),
+        isFocused: false
+      };
+      return mockEditor;
+    }),
+    useEditorState: jest.fn(function () {
+      return {
+        isFocused: false
+      };
+    })
+  };
+});
+jest.mock('@tiptap/starter-kit', function () {
+  return {
+    __esModule: true,
+    "default": {
+      configure: jest.fn(function () {
+        return {};
+      })
+    }
+  };
+});
+jest.mock('@tiptap/extension-text-style', function () {
+  return {
+    TextStyleKit: {}
+  };
+});
+jest.mock('@tiptap/extension-character-count', function () {
+  return {
+    CharacterCount: {
+      configure: jest.fn(function () {
+        return {};
+      })
+    }
+  };
+});
+jest.mock('@tiptap/extension-superscript', function () {
+  return {
+    __esModule: true,
+    "default": {}
+  };
+});
+jest.mock('@tiptap/extension-subscript', function () {
+  return {
+    __esModule: true,
+    "default": {}
+  };
+});
+jest.mock('@tiptap/extension-text-align', function () {
+  return {
+    __esModule: true,
+    "default": {
+      configure: jest.fn(function () {
+        return {};
+      })
+    }
+  };
+});
+jest.mock('@tiptap/extension-image', function () {
+  return {
+    __esModule: true,
+    "default": {}
+  };
+});
+jest.mock('@tiptap/extension-table', function () {
+  return {
+    __esModule: true,
+    "default": {}
+  };
+});
+jest.mock('@tiptap/extension-table-row', function () {
+  return {
+    TableRow: {}
+  };
+});
+jest.mock('../extensions/extended-table-cell', function () {
+  return {
+    ExtendedTableCell: {},
+    ExtendedTableHeader: {}
+  };
+});
+jest.mock('../extensions/extended-table', function () {
+  return {
+    __esModule: true,
+    "default": {}
+  };
+});
+jest.mock('../extensions/ensure-empty-root-div', function () {
+  return {
+    EnsureEmptyRootIsDiv: {}
+  };
+});
+jest.mock('../extensions/extended-list-item', function () {
+  return {
+    ExtendedListItem: {}
+  };
+});
+jest.mock('../extensions/ensure-list-item-content-is-div', function () {
+  return {
+    EnsureListItemContentIsDiv: {}
+  };
+});
+jest.mock('../extensions/responseArea', function () {
+  return {
+    ExplicitConstructedResponseNode: {
+      configure: jest.fn(function () {
+        return {};
+      })
+    },
+    DragInTheBlankNode: {
+      configure: jest.fn(function () {
+        return {};
+      })
+    },
+    InlineDropdownNode: {
+      configure: jest.fn(function () {
+        return {};
+      })
+    },
+    MathTemplatedNode: {
+      configure: jest.fn(function () {
+        return {};
+      })
+    },
+    ResponseAreaExtension: {
+      configure: jest.fn(function () {
+        return {};
+      })
+    }
+  };
+});
+jest.mock('../extensions/math', function () {
+  return {
+    MathNode: {
+      configure: jest.fn(function () {
+        return {};
+      })
+    }
+  };
+});
+jest.mock('../extensions/image', function () {
+  return {
+    ImageUploadNode: {
+      configure: jest.fn(function () {
+        return {};
+      })
+    }
+  };
+});
+jest.mock('../extensions/media', function () {
+  return {
+    Media: {
+      configure: jest.fn(function () {
+        return {};
+      })
+    }
+  };
+});
+jest.mock('../extensions/css', function () {
+  return {
+    CSSMark: {
+      configure: jest.fn(function () {
+        return {};
+      })
+    }
+  };
+});
+jest.mock('../components/TiptapContainer', function () {
+  return {
+    __esModule: true,
+    "default": function _default(_ref2) {
+      var children = _ref2.children;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "editor-container"
+      }, children);
+    }
+  };
+});
+jest.mock('../extensions', function () {
+  return _objectSpread(_objectSpread({}, jest.requireActual('../extensions')), {}, {
+    buildExtensions: jest.fn(function () {
+      return [];
+    })
+  });
+});
+describe('EditableHtml', function () {
+  var defaultProps = {
+    markup: '<p>Hello World</p>',
+    onChange: jest.fn(),
+    onDone: jest.fn(),
+    disabled: false
+  };
+  beforeEach(function () {
+    jest.clearAllMocks();
+  });
+  it('renders without crashing', function () {
+    var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, defaultProps)),
+      container = _render.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('renders editor container', function () {
+    var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, defaultProps)),
+      getByTestId = _render2.getByTestId;
+    expect(getByTestId('editor-container')).toBeInTheDocument();
+  });
+  it('renders editor content when editor is initialized', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var _render3, getByTestId;
+    return _regenerator["default"].wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _render3 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, defaultProps)), getByTestId = _render3.getByTestId;
+          _context.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(getByTestId('editor-content')).toBeInTheDocument();
+          });
+        case 1:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('accepts custom toolbar options', function () {
+    var toolbarOpts = {
+      position: 'top',
+      alignment: 'center',
+      alwaysVisible: true,
+      showDone: false,
+      doneOn: 'change'
+    };
+    var _render4 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        toolbarOpts: toolbarOpts
+      }))),
+      container = _render4.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts custom active plugins', function () {
+    var activePlugins = ['bold', 'italic', 'underline'];
+    var _render5 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        activePlugins: activePlugins
+      }))),
+      container = _render5.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts plugin props', function () {
+    var pluginProps = {
+      showParagraphs: {
+        disabled: false
+      },
+      separateParagraphs: {
+        disabled: false
+      }
+    };
+    var _render6 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        pluginProps: pluginProps
+      }))),
+      container = _render6.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts response area props', function () {
+    var responseAreaProps = {
+      type: 'explicit-constructed-response',
+      options: {}
+    };
+    var _render7 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        responseAreaProps: responseAreaProps
+      }))),
+      container = _render7.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('passes blur done behavior to inline dropdown toolbar close', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+    var onChange, onDone, html, configureCall, inlineDropdownOptions, editor;
+    return _regenerator["default"].wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          onChange = jest.fn();
+          onDone = jest.fn();
+          html = '<p>from inline dropdown close</p>';
+          (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+            markup: "<p>Hello World</p>",
+            onChange: onChange,
+            onDone: onDone,
+            toolbarOpts: {
+              doneOn: 'blur'
+            },
+            responseAreaProps: {
+              type: 'inline-dropdown'
+            }
+          })));
+          _context2.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(_responseArea.InlineDropdownNode.configure).toHaveBeenCalled();
+          });
+        case 1:
+          configureCall = _responseArea.InlineDropdownNode.configure.mock.calls[_responseArea.InlineDropdownNode.configure.mock.calls.length - 1];
+          inlineDropdownOptions = configureCall[0];
+          editor = {
+            getHTML: jest.fn(function () {
+              return html;
+            })
+          };
+          inlineDropdownOptions.onInlineDropdownToolbarClose(editor);
+          expect(editor.getHTML).toHaveBeenCalledTimes(1);
+          expect(onChange).toHaveBeenCalledWith(html);
+          expect(onDone).toHaveBeenCalledWith(html);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('accepts size props', function () {
+    var sizeProps = {
+      width: 500,
+      height: 300,
+      minHeight: 200,
+      maxHeight: 400,
+      minWidth: 300,
+      maxWidth: 600
+    };
+    var _render8 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, sizeProps))),
+      container = _render8.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts character limit', function () {
+    var _render9 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        charactersLimit: 500
+      }))),
+      container = _render9.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts image support props', function () {
+    var imageSupport = {
+      add: jest.fn(),
+      "delete": jest.fn()
+    };
+    var _render0 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        imageSupport: imageSupport
+      }))),
+      container = _render0.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts max image dimensions', function () {
+    var _render1 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        maxImageWidth: 800,
+        maxImageHeight: 600
+      }))),
+      container = _render1.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts language characters props', function () {
+    var languageCharactersProps = [{
+      label: 'Greek',
+      value: 'greek'
+    }, {
+      label: 'Cyrillic',
+      value: 'cyrillic'
+    }];
+    var _render10 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        languageCharactersProps: languageCharactersProps
+      }))),
+      container = _render10.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts extra CSS rules', function () {
+    var extraCSSRules = {
+      '.custom-class': {
+        color: 'red'
+      }
+    };
+    var _render11 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        extraCSSRules: extraCSSRules
+      }))),
+      container = _render11.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts upload sound support', function () {
+    var uploadSoundSupport = {
+      add: jest.fn(),
+      "delete": jest.fn()
+    };
+    var _render12 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        uploadSoundSupport: uploadSoundSupport
+      }))),
+      container = _render12.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts onKeyDown handler', function () {
+    var onKeyDown = jest.fn();
+    var _render13 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        onKeyDown: onKeyDown
+      }))),
+      container = _render13.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('accepts disableImageAlignmentButtons prop', function () {
+    var _render14 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        disableImageAlignmentButtons: true
+      }))),
+      container = _render14.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('calls editorRef callback when editor is initialized', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+    var editorRef;
+    return _regenerator["default"].wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          editorRef = jest.fn();
+          (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+            editorRef: editorRef
+          })));
+          _context3.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(editorRef).toHaveBeenCalled();
+          });
+        case 1:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('calls editorRef with the editor instance', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+    var editorRef;
+    return _regenerator["default"].wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          editorRef = jest.fn();
+          (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+            editorRef: editorRef
+          })));
+          _context4.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(editorRef).toHaveBeenCalled();
+            // Verify it was called with an object that has editor-like properties
+            var callArg = editorRef.mock.calls[0][0];
+            expect(callArg).toHaveProperty('getHTML');
+            expect(callArg).toHaveProperty('commands');
+          });
+        case 1:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('handles editorRef being undefined', function () {
+    var _render15 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+        editorRef: undefined
+      }))),
+      container = _render15.container;
+    expect(container).toBeInTheDocument();
+  });
+  it('applies flex display to StyledEditorContent', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+    var _render16, getByTestId;
+    return _regenerator["default"].wrap(function (_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          _render16 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, defaultProps)), getByTestId = _render16.getByTestId;
+          _context5.next = 1;
+          return (0, _react2.waitFor)(function () {
+            var editorContent = getByTestId('editor-content');
+            expect(editorContent).toBeInTheDocument();
+          });
+        case 1:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+  it('does not run blur onChange/onDone while an image insert flow is active', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+    var onChange, onDone, editorConfig, blurEditor;
+    return _regenerator["default"].wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          jest.useFakeTimers();
+          onChange = jest.fn();
+          onDone = jest.fn();
+          (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+            markup: "<p>Hello World</p>",
+            onChange: onChange,
+            onDone: onDone,
+            toolbarOpts: _objectSpread(_objectSpread({}, defaultProps.toolbarOpts), {}, {
+              doneOn: 'blur'
+            })
+          })));
+          _context6.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(_react3.useEditor).toHaveBeenCalled();
+          });
+        case 1:
+          editorConfig = _react3.useEditor.mock.calls[_react3.useEditor.mock.calls.length - 1][0];
+          blurEditor = {
+            getHTML: jest.fn(function () {
+              return '<p>changed</p>';
+            }),
+            schema: {},
+            _insertingImage: true,
+            _toolbarOpened: false,
+            isActive: jest.fn(function () {
+              return false;
+            })
+          };
+          editorConfig.onBlur({
+            editor: blurEditor
+          });
+          jest.advanceTimersByTime(200);
+          expect(onChange).not.toHaveBeenCalled();
+          expect(onDone).not.toHaveBeenCalled();
+          jest.useRealTimers();
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('does not run blur onChange/onDone when editor has no schema', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+    var onChange, onDone, editorConfig, getHTML, blurEditor;
+    return _regenerator["default"].wrap(function (_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          jest.useFakeTimers();
+          onChange = jest.fn();
+          onDone = jest.fn();
+          (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+            markup: "<p>Hello World</p>",
+            onChange: onChange,
+            onDone: onDone,
+            toolbarOpts: {
+              doneOn: 'blur'
+            }
+          })));
+          _context7.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(_react3.useEditor).toHaveBeenCalled();
+          });
+        case 1:
+          editorConfig = _react3.useEditor.mock.calls[_react3.useEditor.mock.calls.length - 1][0];
+          getHTML = jest.fn(function () {
+            return '<p>changed</p>';
+          });
+          blurEditor = {
+            getHTML: getHTML,
+            schema: undefined,
+            _insertingImage: false,
+            _toolbarOpened: false,
+            isActive: jest.fn(function () {
+              return false;
+            })
+          };
+          editorConfig.onBlur({
+            editor: blurEditor
+          });
+          jest.advanceTimersByTime(200);
+          expect(getHTML).not.toHaveBeenCalled();
+          expect(onChange).not.toHaveBeenCalled();
+          expect(onDone).not.toHaveBeenCalled();
+          jest.useRealTimers();
+        case 2:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  })));
+  it('calls getHTML once on blur and passes the same html to onChange and onDone', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee8() {
+    var onChange, onDone, html, editorConfig, getHTML, blurEditor;
+    return _regenerator["default"].wrap(function (_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          jest.useFakeTimers();
+          onChange = jest.fn();
+          onDone = jest.fn();
+          html = '<p>from editor</p>';
+          (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+            markup: "<p>Hello World</p>",
+            onChange: onChange,
+            onDone: onDone,
+            toolbarOpts: {
+              doneOn: 'blur'
+            }
+          })));
+          _context8.next = 1;
+          return (0, _react2.waitFor)(function () {
+            expect(_react3.useEditor).toHaveBeenCalled();
+          });
+        case 1:
+          editorConfig = _react3.useEditor.mock.calls[_react3.useEditor.mock.calls.length - 1][0];
+          getHTML = jest.fn(function () {
+            return html;
+          });
+          blurEditor = {
+            getHTML: getHTML,
+            schema: {},
+            _insertingImage: false,
+            _toolbarOpened: false,
+            isActive: jest.fn(function () {
+              return false;
+            })
+          };
+          editorConfig.onBlur({
+            editor: blurEditor
+          });
+          jest.advanceTimersByTime(200);
+          expect(getHTML).toHaveBeenCalledTimes(1);
+          expect(onChange).toHaveBeenCalledWith(html);
+          expect(onDone).toHaveBeenCalledWith(html);
+          jest.useRealTimers();
+        case 2:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  describe('onUpdate callback', function () {
+    it('calls onChange when transaction.isDone is true', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee9() {
+      var onChange, markup, editorConfig, mockEditor, mockTransaction;
+      return _regenerator["default"].wrap(function (_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            onChange = jest.fn();
+            markup = '<p>Initial content</p>';
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+              markup: markup,
+              onChange: onChange
+            })));
+            _context9.next = 1;
+            return (0, _react2.waitFor)(function () {
+              expect(_react3.useEditor).toHaveBeenCalled();
+            });
+          case 1:
+            editorConfig = _react3.useEditor.mock.calls[_react3.useEditor.mock.calls.length - 1][0];
+            mockEditor = {
+              getHTML: jest.fn(function () {
+                return '<p>Updated content</p>';
+              })
+            };
+            mockTransaction = {
+              isDone: true
+            };
+            editorConfig.onUpdate({
+              editor: mockEditor,
+              transaction: mockTransaction
+            });
+            expect(onChange).toHaveBeenCalledWith('<p>Updated content</p>');
+          case 2:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    })));
+    it('does not call onChange when transaction.isDone is false even if markup differs from editor HTML', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee0() {
+      var onChange, markup, editorConfig, mockEditor, mockTransaction;
+      return _regenerator["default"].wrap(function (_context0) {
+        while (1) switch (_context0.prev = _context0.next) {
+          case 0:
+            onChange = jest.fn();
+            markup = '<p>Initial content</p>';
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+              markup: markup,
+              onChange: onChange
+            })));
+            _context0.next = 1;
+            return (0, _react2.waitFor)(function () {
+              expect(_react3.useEditor).toHaveBeenCalled();
+            });
+          case 1:
+            editorConfig = _react3.useEditor.mock.calls[_react3.useEditor.mock.calls.length - 1][0];
+            mockEditor = {
+              getHTML: jest.fn(function () {
+                return '<p>Different content</p>';
+              })
+            };
+            mockTransaction = {
+              isDone: false
+            };
+            editorConfig.onUpdate({
+              editor: mockEditor,
+              transaction: mockTransaction
+            });
+            expect(onChange).not.toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context0.stop();
+        }
+      }, _callee0);
+    })));
+    it('does not call onChange when transaction.isDone is false and markup matches editor HTML', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee1() {
+      var onChange, markup, editorConfig, mockEditor, mockTransaction;
+      return _regenerator["default"].wrap(function (_context1) {
+        while (1) switch (_context1.prev = _context1.next) {
+          case 0:
+            onChange = jest.fn();
+            markup = '<p>Same content</p>';
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+              markup: markup,
+              onChange: onChange
+            })));
+            _context1.next = 1;
+            return (0, _react2.waitFor)(function () {
+              expect(_react3.useEditor).toHaveBeenCalled();
+            });
+          case 1:
+            editorConfig = _react3.useEditor.mock.calls[_react3.useEditor.mock.calls.length - 1][0];
+            mockEditor = {
+              getHTML: jest.fn(function () {
+                return '<p>Same content</p>';
+              })
+            };
+            mockTransaction = {
+              isDone: false
+            };
+            editorConfig.onUpdate({
+              editor: mockEditor,
+              transaction: mockTransaction
+            });
+            expect(onChange).not.toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context1.stop();
+        }
+      }, _callee1);
+    })));
+    it('calls onChange when transaction.isDone is true even if markup matches', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+      var onChange, markup, editorConfig, mockEditor, mockTransaction;
+      return _regenerator["default"].wrap(function (_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            onChange = jest.fn();
+            markup = '<p>Same content</p>';
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+              markup: markup,
+              onChange: onChange
+            })));
+            _context10.next = 1;
+            return (0, _react2.waitFor)(function () {
+              expect(_react3.useEditor).toHaveBeenCalled();
+            });
+          case 1:
+            editorConfig = _react3.useEditor.mock.calls[_react3.useEditor.mock.calls.length - 1][0];
+            mockEditor = {
+              getHTML: jest.fn(function () {
+                return '<p>Same content</p>';
+              })
+            };
+            mockTransaction = {
+              isDone: true
+            };
+            editorConfig.onUpdate({
+              editor: mockEditor,
+              transaction: mockTransaction
+            });
+            expect(onChange).toHaveBeenCalledWith('<p>Same content</p>');
+          case 2:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10);
+    })));
+    it('does not call onChange when onChange is not provided', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee11() {
+      var markup, editorConfig, mockEditor, mockTransaction;
+      return _regenerator["default"].wrap(function (_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            markup = '<p>Content</p>';
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_EditableHtml.EditableHtml, (0, _extends2["default"])({}, defaultProps, {
+              markup: markup,
+              onChange: undefined
+            })));
+            _context11.next = 1;
+            return (0, _react2.waitFor)(function () {
+              expect(_react3.useEditor).toHaveBeenCalled();
+            });
+          case 1:
+            editorConfig = _react3.useEditor.mock.calls[_react3.useEditor.mock.calls.length - 1][0];
+            mockEditor = {
+              getHTML: jest.fn(function () {
+                return '<p>Updated content</p>';
+              })
+            };
+            mockTransaction = {
+              isDone: true
+            }; // Should not throw error when onChange is undefined
+            expect(function () {
+              editorConfig.onUpdate({
+                editor: mockEditor,
+                transaction: mockTransaction
+              });
+            }).not.toThrow();
+          case 2:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11);
+    })));
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_react3","_EditableHtml","_responseArea","_excluded","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","EditorContent","_ref","editor","props","_objectWithoutProperties2","createElement","_extends2","useEditor","fn","config","mockEditor","getHTML","setEditable","commands","setContent","isActive","isFocused","useEditorState","__esModule","configure","TextStyleKit","CharacterCount","TableRow","ExtendedTableCell","ExtendedTableHeader","EnsureEmptyRootIsDiv","ExtendedListItem","EnsureListItemContentIsDiv","ExplicitConstructedResponseNode","DragInTheBlankNode","InlineDropdownNode","MathTemplatedNode","ResponseAreaExtension","MathNode","ImageUploadNode","Media","CSSMark","default","_ref2","children","requireActual","buildExtensions","describe","defaultProps","markup","onChange","onDone","disabled","beforeEach","clearAllMocks","it","_render","render","EditableHtml","container","expect","toBeInTheDocument","_render2","getByTestId","_asyncToGenerator2","_regenerator","mark","_callee","_render3","wrap","_context","prev","next","waitFor","stop","toolbarOpts","position","alignment","alwaysVisible","showDone","doneOn","_render4","activePlugins","_render5","pluginProps","showParagraphs","separateParagraphs","_render6","responseAreaProps","type","options","_render7","_callee2","html","configureCall","inlineDropdownOptions","_context2","toHaveBeenCalled","calls","onInlineDropdownToolbarClose","toHaveBeenCalledTimes","toHaveBeenCalledWith","sizeProps","width","height","minHeight","maxHeight","minWidth","maxWidth","_render8","_render9","charactersLimit","imageSupport","add","_render0","_render1","maxImageWidth","maxImageHeight","languageCharactersProps","label","value","_render10","extraCSSRules","color","_render11","uploadSoundSupport","_render12","onKeyDown","_render13","_render14","disableImageAlignmentButtons","_callee3","editorRef","_context3","_callee4","_context4","callArg","toHaveProperty","_render15","undefined","_callee5","_render16","_context5","editorContent","_callee6","editorConfig","blurEditor","_context6","useFakeTimers","schema","_insertingImage","_toolbarOpened","onBlur","advanceTimersByTime","not","useRealTimers","_callee7","_context7","_callee8","_context8","_callee9","mockTransaction","_context9","isDone","onUpdate","transaction","_callee0","_context0","_callee1","_context1","_callee10","_context10","_callee11","_context11","toThrow"],"sources":["../../src/__tests__/EditableHtml.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render, waitFor } from '@testing-library/react';\nimport { useEditor } from '@tiptap/react';\nimport { EditableHtml } from '../components/EditableHtml';\nimport { InlineDropdownNode } from '../extensions/responseArea';\n\n// Mock TipTap dependencies\njest.mock('@tiptap/react', () => ({\n  EditorContent: ({ editor, ...props }) => <div data-testid=\"editor-content\" {...props} />,\n  useEditor: jest.fn((config) => {\n    const mockEditor = {\n      getHTML: jest.fn(() => '<p>test content</p>'),\n      setEditable: jest.fn(),\n      commands: {\n        setContent: jest.fn(),\n      },\n      isActive: jest.fn(() => false),\n      isFocused: false,\n    };\n    return mockEditor;\n  }),\n  useEditorState: jest.fn(() => ({\n    isFocused: false,\n  })),\n}));\n\njest.mock('@tiptap/starter-kit', () => ({\n  __esModule: true,\n  default: {\n    configure: jest.fn(() => ({})),\n  },\n}));\n\njest.mock('@tiptap/extension-text-style', () => ({\n  TextStyleKit: {},\n}));\n\njest.mock('@tiptap/extension-character-count', () => ({\n  CharacterCount: {\n    configure: jest.fn(() => ({})),\n  },\n}));\n\njest.mock('@tiptap/extension-superscript', () => ({\n  __esModule: true,\n  default: {},\n}));\n\njest.mock('@tiptap/extension-subscript', () => ({\n  __esModule: true,\n  default: {},\n}));\n\njest.mock('@tiptap/extension-text-align', () => ({\n  __esModule: true,\n  default: {\n    configure: jest.fn(() => ({})),\n  },\n}));\n\njest.mock('@tiptap/extension-image', () => ({\n  __esModule: true,\n  default: {},\n}));\n\njest.mock('@tiptap/extension-table', () => ({\n  __esModule: true,\n  default: {},\n}));\n\njest.mock('@tiptap/extension-table-row', () => ({\n  TableRow: {},\n}));\n\njest.mock('../extensions/extended-table-cell', () => ({\n  ExtendedTableCell: {},\n  ExtendedTableHeader: {},\n}));\n\njest.mock('../extensions/extended-table', () => ({\n  __esModule: true,\n  default: {},\n}));\n\njest.mock('../extensions/ensure-empty-root-div', () => ({\n  EnsureEmptyRootIsDiv: {},\n}));\n\njest.mock('../extensions/extended-list-item', () => ({\n  ExtendedListItem: {},\n}));\n\njest.mock('../extensions/ensure-list-item-content-is-div', () => ({\n  EnsureListItemContentIsDiv: {},\n}));\n\njest.mock('../extensions/responseArea', () => ({\n  ExplicitConstructedResponseNode: {\n    configure: jest.fn(() => ({})),\n  },\n  DragInTheBlankNode: {\n    configure: jest.fn(() => ({})),\n  },\n  InlineDropdownNode: {\n    configure: jest.fn(() => ({})),\n  },\n  MathTemplatedNode: {\n    configure: jest.fn(() => ({})),\n  },\n  ResponseAreaExtension: {\n    configure: jest.fn(() => ({})),\n  },\n}));\n\njest.mock('../extensions/math', () => ({\n  MathNode: {\n    configure: jest.fn(() => ({})),\n  },\n}));\n\njest.mock('../extensions/image', () => ({\n  ImageUploadNode: {\n    configure: jest.fn(() => ({})),\n  },\n}));\n\njest.mock('../extensions/media', () => ({\n  Media: {\n    configure: jest.fn(() => ({})),\n  },\n}));\n\njest.mock('../extensions/css', () => ({\n  CSSMark: {\n    configure: jest.fn(() => ({})),\n  },\n}));\n\njest.mock('../components/TiptapContainer', () => ({\n  __esModule: true,\n  default: ({ children }) => <div data-testid=\"editor-container\">{children}</div>,\n}));\n\njest.mock('../extensions', () => ({\n  ...jest.requireActual('../extensions'),\n  buildExtensions: jest.fn(() => []),\n}));\n\ndescribe('EditableHtml', () => {\n  const defaultProps = {\n    markup: '<p>Hello World</p>',\n    onChange: jest.fn(),\n    onDone: jest.fn(),\n    disabled: false,\n  };\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n  });\n\n  it('renders without crashing', () => {\n    const { container } = render(<EditableHtml {...defaultProps} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('renders editor container', () => {\n    const { getByTestId } = render(<EditableHtml {...defaultProps} />);\n    expect(getByTestId('editor-container')).toBeInTheDocument();\n  });\n\n  it('renders editor content when editor is initialized', async () => {\n    const { getByTestId } = render(<EditableHtml {...defaultProps} />);\n    await waitFor(() => {\n      expect(getByTestId('editor-content')).toBeInTheDocument();\n    });\n  });\n\n  it('accepts custom toolbar options', () => {\n    const toolbarOpts = {\n      position: 'top',\n      alignment: 'center',\n      alwaysVisible: true,\n      showDone: false,\n      doneOn: 'change',\n    };\n    const { container } = render(<EditableHtml {...defaultProps} toolbarOpts={toolbarOpts} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts custom active plugins', () => {\n    const activePlugins = ['bold', 'italic', 'underline'];\n    const { container } = render(<EditableHtml {...defaultProps} activePlugins={activePlugins} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts plugin props', () => {\n    const pluginProps = {\n      showParagraphs: { disabled: false },\n      separateParagraphs: { disabled: false },\n    };\n    const { container } = render(<EditableHtml {...defaultProps} pluginProps={pluginProps} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts response area props', () => {\n    const responseAreaProps = {\n      type: 'explicit-constructed-response',\n      options: {},\n    };\n    const { container } = render(<EditableHtml {...defaultProps} responseAreaProps={responseAreaProps} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('passes blur done behavior to inline dropdown toolbar close', async () => {\n    const onChange = jest.fn();\n    const onDone = jest.fn();\n    const html = '<p>from inline dropdown close</p>';\n\n    render(\n      <EditableHtml\n        {...defaultProps}\n        markup=\"<p>Hello World</p>\"\n        onChange={onChange}\n        onDone={onDone}\n        toolbarOpts={{ doneOn: 'blur' }}\n        responseAreaProps={{ type: 'inline-dropdown' }}\n      />,\n    );\n\n    await waitFor(() => {\n      expect(InlineDropdownNode.configure).toHaveBeenCalled();\n    });\n\n    const configureCall = InlineDropdownNode.configure.mock.calls[InlineDropdownNode.configure.mock.calls.length - 1];\n    const inlineDropdownOptions = configureCall[0];\n    const editor = {\n      getHTML: jest.fn(() => html),\n    };\n\n    inlineDropdownOptions.onInlineDropdownToolbarClose(editor);\n\n    expect(editor.getHTML).toHaveBeenCalledTimes(1);\n    expect(onChange).toHaveBeenCalledWith(html);\n    expect(onDone).toHaveBeenCalledWith(html);\n  });\n\n  it('accepts size props', () => {\n    const sizeProps = {\n      width: 500,\n      height: 300,\n      minHeight: 200,\n      maxHeight: 400,\n      minWidth: 300,\n      maxWidth: 600,\n    };\n    const { container } = render(<EditableHtml {...defaultProps} {...sizeProps} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts character limit', () => {\n    const { container } = render(<EditableHtml {...defaultProps} charactersLimit={500} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts image support props', () => {\n    const imageSupport = {\n      add: jest.fn(),\n      delete: jest.fn(),\n    };\n    const { container } = render(<EditableHtml {...defaultProps} imageSupport={imageSupport} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts max image dimensions', () => {\n    const { container } = render(<EditableHtml {...defaultProps} maxImageWidth={800} maxImageHeight={600} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts language characters props', () => {\n    const languageCharactersProps = [\n      { label: 'Greek', value: 'greek' },\n      { label: 'Cyrillic', value: 'cyrillic' },\n    ];\n    const { container } = render(<EditableHtml {...defaultProps} languageCharactersProps={languageCharactersProps} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts extra CSS rules', () => {\n    const extraCSSRules = {\n      '.custom-class': { color: 'red' },\n    };\n    const { container } = render(<EditableHtml {...defaultProps} extraCSSRules={extraCSSRules} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts upload sound support', () => {\n    const uploadSoundSupport = {\n      add: jest.fn(),\n      delete: jest.fn(),\n    };\n    const { container } = render(<EditableHtml {...defaultProps} uploadSoundSupport={uploadSoundSupport} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts onKeyDown handler', () => {\n    const onKeyDown = jest.fn();\n    const { container } = render(<EditableHtml {...defaultProps} onKeyDown={onKeyDown} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('accepts disableImageAlignmentButtons prop', () => {\n    const { container } = render(<EditableHtml {...defaultProps} disableImageAlignmentButtons={true} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('calls editorRef callback when editor is initialized', async () => {\n    const editorRef = jest.fn();\n    render(<EditableHtml {...defaultProps} editorRef={editorRef} />);\n\n    await waitFor(() => {\n      expect(editorRef).toHaveBeenCalled();\n    });\n  });\n\n  it('calls editorRef with the editor instance', async () => {\n    const editorRef = jest.fn();\n    render(<EditableHtml {...defaultProps} editorRef={editorRef} />);\n\n    await waitFor(() => {\n      expect(editorRef).toHaveBeenCalled();\n      // Verify it was called with an object that has editor-like properties\n      const callArg = editorRef.mock.calls[0][0];\n      expect(callArg).toHaveProperty('getHTML');\n      expect(callArg).toHaveProperty('commands');\n    });\n  });\n\n  it('handles editorRef being undefined', () => {\n    const { container } = render(<EditableHtml {...defaultProps} editorRef={undefined} />);\n    expect(container).toBeInTheDocument();\n  });\n\n  it('applies flex display to StyledEditorContent', async () => {\n    const { getByTestId } = render(<EditableHtml {...defaultProps} />);\n    await waitFor(() => {\n      const editorContent = getByTestId('editor-content');\n      expect(editorContent).toBeInTheDocument();\n    });\n  });\n\n  it('does not run blur onChange/onDone while an image insert flow is active', async () => {\n    jest.useFakeTimers();\n    const onChange = jest.fn();\n    const onDone = jest.fn();\n\n    render(\n      <EditableHtml\n        {...defaultProps}\n        markup=\"<p>Hello World</p>\"\n        onChange={onChange}\n        onDone={onDone}\n        toolbarOpts={{ ...defaultProps.toolbarOpts, doneOn: 'blur' }}\n      />,\n    );\n\n    await waitFor(() => {\n      expect(useEditor).toHaveBeenCalled();\n    });\n\n    const editorConfig = useEditor.mock.calls[useEditor.mock.calls.length - 1][0];\n    const blurEditor = {\n      getHTML: jest.fn(() => '<p>changed</p>'),\n      schema: {},\n      _insertingImage: true,\n      _toolbarOpened: false,\n      isActive: jest.fn(() => false),\n    };\n\n    editorConfig.onBlur({ editor: blurEditor });\n    jest.advanceTimersByTime(200);\n\n    expect(onChange).not.toHaveBeenCalled();\n    expect(onDone).not.toHaveBeenCalled();\n\n    jest.useRealTimers();\n  });\n\n  it('does not run blur onChange/onDone when editor has no schema', async () => {\n    jest.useFakeTimers();\n    const onChange = jest.fn();\n    const onDone = jest.fn();\n\n    render(\n      <EditableHtml\n        {...defaultProps}\n        markup=\"<p>Hello World</p>\"\n        onChange={onChange}\n        onDone={onDone}\n        toolbarOpts={{ doneOn: 'blur' }}\n      />,\n    );\n\n    await waitFor(() => {\n      expect(useEditor).toHaveBeenCalled();\n    });\n\n    const editorConfig = useEditor.mock.calls[useEditor.mock.calls.length - 1][0];\n    const getHTML = jest.fn(() => '<p>changed</p>');\n    const blurEditor = {\n      getHTML,\n      schema: undefined,\n      _insertingImage: false,\n      _toolbarOpened: false,\n      isActive: jest.fn(() => false),\n    };\n\n    editorConfig.onBlur({ editor: blurEditor });\n    jest.advanceTimersByTime(200);\n\n    expect(getHTML).not.toHaveBeenCalled();\n    expect(onChange).not.toHaveBeenCalled();\n    expect(onDone).not.toHaveBeenCalled();\n\n    jest.useRealTimers();\n  });\n\n  it('calls getHTML once on blur and passes the same html to onChange and onDone', async () => {\n    jest.useFakeTimers();\n    const onChange = jest.fn();\n    const onDone = jest.fn();\n    const html = '<p>from editor</p>';\n\n    render(\n      <EditableHtml\n        {...defaultProps}\n        markup=\"<p>Hello World</p>\"\n        onChange={onChange}\n        onDone={onDone}\n        toolbarOpts={{ doneOn: 'blur' }}\n      />,\n    );\n\n    await waitFor(() => {\n      expect(useEditor).toHaveBeenCalled();\n    });\n\n    const editorConfig = useEditor.mock.calls[useEditor.mock.calls.length - 1][0];\n    const getHTML = jest.fn(() => html);\n    const blurEditor = {\n      getHTML,\n      schema: {},\n      _insertingImage: false,\n      _toolbarOpened: false,\n      isActive: jest.fn(() => false),\n    };\n\n    editorConfig.onBlur({ editor: blurEditor });\n    jest.advanceTimersByTime(200);\n\n    expect(getHTML).toHaveBeenCalledTimes(1);\n    expect(onChange).toHaveBeenCalledWith(html);\n    expect(onDone).toHaveBeenCalledWith(html);\n\n    jest.useRealTimers();\n  });\n\n  describe('onUpdate callback', () => {\n    it('calls onChange when transaction.isDone is true', async () => {\n      const onChange = jest.fn();\n      const markup = '<p>Initial content</p>';\n\n      render(<EditableHtml {...defaultProps} markup={markup} onChange={onChange} />);\n\n      await waitFor(() => {\n        expect(useEditor).toHaveBeenCalled();\n      });\n\n      const editorConfig = useEditor.mock.calls[useEditor.mock.calls.length - 1][0];\n      const mockEditor = {\n        getHTML: jest.fn(() => '<p>Updated content</p>'),\n      };\n\n      const mockTransaction = {\n        isDone: true,\n      };\n\n      editorConfig.onUpdate({ editor: mockEditor, transaction: mockTransaction });\n\n      expect(onChange).toHaveBeenCalledWith('<p>Updated content</p>');\n    });\n\n    it('does not call onChange when transaction.isDone is false even if markup differs from editor HTML', async () => {\n      const onChange = jest.fn();\n      const markup = '<p>Initial content</p>';\n\n      render(<EditableHtml {...defaultProps} markup={markup} onChange={onChange} />);\n\n      await waitFor(() => {\n        expect(useEditor).toHaveBeenCalled();\n      });\n\n      const editorConfig = useEditor.mock.calls[useEditor.mock.calls.length - 1][0];\n      const mockEditor = {\n        getHTML: jest.fn(() => '<p>Different content</p>'),\n      };\n\n      const mockTransaction = {\n        isDone: false,\n      };\n\n      editorConfig.onUpdate({ editor: mockEditor, transaction: mockTransaction });\n\n      expect(onChange).not.toHaveBeenCalled();\n    });\n\n    it('does not call onChange when transaction.isDone is false and markup matches editor HTML', async () => {\n      const onChange = jest.fn();\n      const markup = '<p>Same content</p>';\n\n      render(<EditableHtml {...defaultProps} markup={markup} onChange={onChange} />);\n\n      await waitFor(() => {\n        expect(useEditor).toHaveBeenCalled();\n      });\n\n      const editorConfig = useEditor.mock.calls[useEditor.mock.calls.length - 1][0];\n      const mockEditor = {\n        getHTML: jest.fn(() => '<p>Same content</p>'),\n      };\n\n      const mockTransaction = {\n        isDone: false,\n      };\n\n      editorConfig.onUpdate({ editor: mockEditor, transaction: mockTransaction });\n\n      expect(onChange).not.toHaveBeenCalled();\n    });\n\n    it('calls onChange when transaction.isDone is true even if markup matches', async () => {\n      const onChange = jest.fn();\n      const markup = '<p>Same content</p>';\n\n      render(<EditableHtml {...defaultProps} markup={markup} onChange={onChange} />);\n\n      await waitFor(() => {\n        expect(useEditor).toHaveBeenCalled();\n      });\n\n      const editorConfig = useEditor.mock.calls[useEditor.mock.calls.length - 1][0];\n      const mockEditor = {\n        getHTML: jest.fn(() => '<p>Same content</p>'),\n      };\n\n      const mockTransaction = {\n        isDone: true,\n      };\n\n      editorConfig.onUpdate({ editor: mockEditor, transaction: mockTransaction });\n\n      expect(onChange).toHaveBeenCalledWith('<p>Same content</p>');\n    });\n\n    it('does not call onChange when onChange is not provided', async () => {\n      const markup = '<p>Content</p>';\n\n      render(<EditableHtml {...defaultProps} markup={markup} onChange={undefined} />);\n\n      await waitFor(() => {\n        expect(useEditor).toHaveBeenCalled();\n      });\n\n      const editorConfig = useEditor.mock.calls[useEditor.mock.calls.length - 1][0];\n      const mockEditor = {\n        getHTML: jest.fn(() => '<p>Updated content</p>'),\n      };\n\n      const mockTransaction = {\n        isDone: true,\n      };\n\n      // Should not throw error when onChange is undefined\n      expect(() => {\n        editorConfig.onUpdate({ editor: mockEditor, transaction: mockTransaction });\n      }).not.toThrow();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}