@pie-lib/editable-html 13.0.14-beta.6 → 13.0.14-beta.8

package/lib/plugins/math/__tests__/index.test.js

@@ -0,0 +1,284 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _debug = _interopRequireDefault(require("debug"));
+var _mockChange = _interopRequireDefault(require("../../image/__tests__/mock-change"));
+var _slate = require("slate");
+var _index = _interopRequireWildcard(require("../index"));
+var _react2 = require("@testing-library/react");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+jest.mock('@pie-framework/mathquill', function () {
+  return {
+    StaticMath: jest.fn(),
+    getInterface: jest.fn().mockReturnThis(),
+    registerEmbed: jest.fn()
+  };
+});
+var mockMathToolbarOnChange;
+var mockMathToolbarOnDone;
+jest.mock('@pie-lib/math-toolbar', function () {
+  return {
+    MathPreview: function MathPreview() {
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "math-preview"
+      });
+    },
+    MathToolbar: function MathToolbar(props) {
+      // Store callbacks for testing
+      mockMathToolbarOnChange = props.onChange;
+      mockMathToolbarOnDone = props.onDone;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "math-toolbar",
+        role: "toolbar"
+      }, /*#__PURE__*/_react["default"].createElement("button", {
+        "data-testid": "toolbar-change",
+        onClick: function onClick() {
+          return props.onChange && props.onChange('test-latex');
+        }
+      }, "Change"), /*#__PURE__*/_react["default"].createElement("button", {
+        "data-testid": "toolbar-done",
+        onClick: function onClick() {
+          return props.onDone && props.onDone('test-latex');
+        }
+      }, "Done"));
+    }
+  };
+});
+jest.mock('@pie-lib/math-rendering', function () {
+  return _objectSpread(_objectSpread({}, jest.requireActual('@pie-lib/math-rendering')), {}, {
+    mmlToLatex: jest.fn(function () {
+      return '/foobar/latex';
+    })
+  });
+});
+var log = (0, _debug["default"])('@pie-lib:editable-html:test:math');
+
+// I believe @andrei is moving this stuff out.
+describe('MathPlugin', function () {
+  describe('toolbar', function () {
+    describe('onClick', function () {
+      var plugin, mockChange, value, onChange;
+      beforeEach(function () {
+        plugin = (0, _index["default"])({});
+        mockChange = new _mockChange["default"]();
+        value = {
+          change: jest.fn(function () {
+            return mockChange;
+          })
+        };
+        onChange = jest.fn();
+        plugin.toolbar.onClick(value, onChange);
+      });
+      test('calls insertInline', function () {
+        expect(mockChange.insertInline).toBeCalledWith(expect.objectContaining({
+          data: (0, _index.inlineMath)().data
+        }));
+      });
+      test('it calls onChange', function () {
+        expect(onChange).toHaveBeenCalledWith(mockChange);
+      });
+    });
+  });
+  describe('renderNode', function () {
+    test('the component has props', function () {
+      var plugin = (0, _index["default"])({});
+      var _plugin$renderNode = plugin.renderNode({
+          node: {
+            type: 'math'
+          }
+        }),
+        props = _plugin$renderNode.props;
+      expect(props.node).toEqual({
+        type: 'math'
+      });
+    });
+  });
+  describe('serialization', function () {
+    describe('deserialize', function () {
+      var assertDeserialize = function assertDeserialize(html, expected, wrapType) {
+        it("innerHTML: ".concat(html, " is deserialized to: ").concat(expected, " with wrapType: ").concat(wrapType), function () {
+          var el = {
+            tagName: 'span',
+            childNodes: [],
+            getAttribute: jest.fn(function () {
+              return '';
+            }),
+            hasAttribute: jest.fn(function () {
+              return true;
+            }),
+            innerHTML: html
+          };
+          var next = jest.fn();
+          var out = _index.serialization.deserialize(el, next);
+          expect(out).toEqual({
+            object: 'inline',
+            type: 'math',
+            isVoid: true,
+            nodes: [],
+            data: {
+              latex: expected,
+              wrapper: wrapType
+            }
+          });
+        });
+      };
+      assertDeserialize('$$&lt;$$', '<', _index["default"].DOLLAR);
+      assertDeserialize('$&lt;$', '<', _index["default"].DOLLAR);
+      assertDeserialize('\\(&lt;\\)', '<', _index["default"].ROUND_BRACKETS);
+      assertDeserialize('\\[&lt;\\]', '<', _index["default"].ROUND_BRACKETS);
+      assertDeserialize('latex', 'latex', _index["default"].ROUND_BRACKETS);
+      assertDeserialize('\\displaystyle foo', 'foo', _index["default"].ROUND_BRACKETS);
+      it('should make mathml editable if MathPlugin.mathMlOptions.mmlEditing is true', function () {
+        _index["default"].mathMlOptions.mmlEditing = true;
+        var el = {
+          tagName: 'math',
+          outerHTML: '<math xmlns="http://www.w3.org/1998/Math/MathML">  <mn>2</mn>  <mi>x</mi>  <mtext>&#xA0;</mtext>  <mo>&#x2264;</mo>  <mn>4</mn>  <mi>y</mi>  <mtext>&#xA0;</mtext>  <mo>+</mo>  <mtext>&#xA0;</mtext>  <mn>8</mn> <msqrt>    <mi>h</mi>  </msqrt></math>'
+        };
+        var next = jest.fn();
+        var out = _index.serialization.deserialize(el, next);
+        expect(out).toEqual({
+          object: 'inline',
+          type: 'math',
+          isVoid: true,
+          nodes: [],
+          data: {
+            latex: '/foobar/latex',
+            wrapper: 'round_brackets'
+          }
+        });
+      });
+      it('should make mathml readOnly if MathPlugin.mathMlOptions.mmlEditing is false', function () {
+        _index["default"].mathMlOptions.mmlEditing = false;
+        var el = {
+          tagName: 'math',
+          outerHTML: '<math xmlns="http://www.w3.org/1998/Math/MathML">  <mn>2</mn>  <mi>x</mi>  <mtext>&#xA0;</mtext>  <mo>&#x2264;</mo>  <mn>4</mn>  <mi>y</mi>  <mtext>&#xA0;</mtext>  <mo>+</mo>  <mtext>&#xA0;</mtext>  <mn>8</mn> <msqrt>    <mi>h</mi>  </msqrt></math>'
+        };
+        var next = jest.fn();
+        var out = _index.serialization.deserialize(el, next);
+        expect(out).toEqual({
+          object: 'inline',
+          isVoid: true,
+          type: 'mathml',
+          data: {
+            html: el.outerHTML
+          }
+        });
+      });
+    });
+    describe('serialize', function () {
+      var assertSerialize = function assertSerialize(latex, expectedHtml, wrapper) {
+        wrapper = wrapper || _index["default"].ROUND_BRACKETS;
+        it("".concat(latex, " is serialized to: ").concat(expectedHtml), function () {
+          var object = {
+            kind: 'inline',
+            type: 'math',
+            isVoid: true,
+            nodes: [],
+            data: _slate.Data.create({
+              latex: latex,
+              wrapper: wrapper
+            })
+          };
+          var children = [];
+          var out = _index.serialization.serialize(object, children);
+          log('out: ', out);
+          expect(out).toEqual(/*#__PURE__*/_react["default"].createElement("span", {
+            "data-latex": "",
+            "data-raw": latex
+          }, expectedHtml));
+        });
+      };
+      assertSerialize('latex', '\\(latex\\)', _index["default"].ROUND_BRACKETS);
+      assertSerialize('latex', '\\(latex\\)', _index["default"].SQUARE_BRACKETS);
+      assertSerialize('latex', '$latex$', _index["default"].DOLLAR);
+      assertSerialize('latex', '$latex$', _index["default"].DOUBLE_DOLLAR);
+
+      /**
+       * Note that when this is converted to html it get's escaped - but that's an issue with the slate html-serializer.
+       */
+      assertSerialize('<', '\\(<\\)');
+      assertSerialize('x<y', '\\(x<y\\)');
+    });
+  });
+});
+describe('CustomToolbarComp', function () {
+  var onDataChange;
+  var onToolbarDone;
+  var renderComponent = function renderComponent() {
+    var extras = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var mockChange = new _mockChange["default"]();
+    var defaults = {
+      node: {
+        key: '1',
+        data: _slate.Data.create({
+          latex: 'foo'
+        }),
+        equals: function equals() {
+          return true;
+        }
+      },
+      value: {
+        document: {
+          getNextText: jest.fn().mockReturnValue({
+            key: 'nt'
+          })
+        },
+        change: jest.fn().mockReturnValue(mockChange)
+      },
+      onDataChange: onDataChange,
+      onToolbarDone: onToolbarDone
+    };
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+    return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.CustomToolbarComp, props));
+  };
+  describe('render', function () {
+    it('renders toolbar without default keypadMode', function () {
+      renderComponent();
+
+      // Verify the toolbar is rendered
+      expect(_react2.screen.getByTestId('math-toolbar')).toBeInTheDocument();
+      expect(_react2.screen.getByRole('toolbar')).toBeInTheDocument();
+    });
+    it('renders toolbar with default keypadMode', function () {
+      renderComponent({
+        pluginProps: {
+          math: {
+            keypadMode: 'geometry'
+          }
+        }
+      });
+
+      // Verify the toolbar is rendered with keypadMode prop
+      expect(_react2.screen.getByTestId('math-toolbar')).toBeInTheDocument();
+      expect(_react2.screen.getByRole('toolbar')).toBeInTheDocument();
+    });
+  });
+  describe('onDone', function () {
+    it('calls onToolbarDone when done callback is triggered', function () {
+      onToolbarDone = jest.fn();
+      renderComponent();
+
+      // Trigger the onDone callback that was passed to MathToolbar
+      mockMathToolbarOnDone('oo');
+      expect(onToolbarDone).toHaveBeenCalledWith(expect.anything(), false);
+    });
+  });
+  describe('onChange', function () {
+    it('calls onDataChange when change callback is triggered', function () {
+      onDataChange = jest.fn();
+      renderComponent();
+
+      // Trigger the onChange callback that was passed to MathToolbar
+      mockMathToolbarOnChange('oo');
+      expect(onDataChange).toHaveBeenCalledWith('1', {
+        latex: 'oo'
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_debug","_mockChange","_slate","_index","_interopRequireWildcard","_react2","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","_typeof","has","get","set","_t","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ownKeys","keys","getOwnPropertySymbols","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","jest","mock","StaticMath","fn","getInterface","mockReturnThis","registerEmbed","mockMathToolbarOnChange","mockMathToolbarOnDone","MathPreview","createElement","MathToolbar","props","onChange","onDone","role","onClick","requireActual","mmlToLatex","log","debug","describe","plugin","mockChange","value","beforeEach","MathPlugin","MockChange","change","toolbar","test","expect","insertInline","toBeCalledWith","objectContaining","data","inlineMath","toHaveBeenCalledWith","_plugin$renderNode","renderNode","node","type","toEqual","assertDeserialize","html","expected","wrapType","it","concat","el","tagName","childNodes","getAttribute","hasAttribute","innerHTML","next","out","serialization","deserialize","object","isVoid","nodes","latex","wrapper","DOLLAR","ROUND_BRACKETS","mathMlOptions","mmlEditing","outerHTML","assertSerialize","expectedHtml","kind","Data","create","children","serialize","SQUARE_BRACKETS","DOUBLE_DOLLAR","onDataChange","onToolbarDone","renderComponent","extras","undefined","defaults","key","equals","document","getNextText","mockReturnValue","render","CustomToolbarComp","screen","getByTestId","toBeInTheDocument","getByRole","pluginProps","math","keypadMode","anything"],"sources":["../../../../src/plugins/math/__tests__/index.test.jsx"],"sourcesContent":["import React from 'react';\nimport debug from 'debug';\nimport MockChange from '../../image/__tests__/mock-change';\nimport { Data } from 'slate';\nimport MathPlugin, { CustomToolbarComp, inlineMath, serialization } from '../index';\nimport { render, screen } from '@testing-library/react';\n\njest.mock('@pie-framework/mathquill', () => ({\n  StaticMath: jest.fn(),\n  getInterface: jest.fn().mockReturnThis(),\n  registerEmbed: jest.fn(),\n}));\n\nlet mockMathToolbarOnChange;\nlet mockMathToolbarOnDone;\n\njest.mock('@pie-lib/math-toolbar', () => ({\n  MathPreview: () => <div data-testid=\"math-preview\" />,\n  MathToolbar: (props) => {\n    // Store callbacks for testing\n    mockMathToolbarOnChange = props.onChange;\n    mockMathToolbarOnDone = props.onDone;\n    return (\n      <div data-testid=\"math-toolbar\" role=\"toolbar\">\n        <button data-testid=\"toolbar-change\" onClick={() => props.onChange && props.onChange('test-latex')}>\n          Change\n        </button>\n        <button data-testid=\"toolbar-done\" onClick={() => props.onDone && props.onDone('test-latex')}>\n          Done\n        </button>\n      </div>\n    );\n  },\n}));\n\njest.mock('@pie-lib/math-rendering', () => ({\n  ...jest.requireActual('@pie-lib/math-rendering'),\n  mmlToLatex: jest.fn(() => {\n    return '/foobar/latex';\n  }),\n}));\nconst log = debug('@pie-lib:editable-html:test:math');\n\n// I believe @andrei is moving this stuff out.\ndescribe('MathPlugin', () => {\n  describe('toolbar', () => {\n    describe('onClick', () => {\n      let plugin, mockChange, value, onChange;\n      beforeEach(() => {\n        plugin = MathPlugin({});\n        mockChange = new MockChange();\n        value = {\n          change: jest.fn(() => mockChange),\n        };\n        onChange = jest.fn();\n        plugin.toolbar.onClick(value, onChange);\n      });\n\n      test('calls insertInline', () => {\n        expect(mockChange.insertInline).toBeCalledWith(expect.objectContaining({ data: inlineMath().data }));\n      });\n\n      test('it calls onChange', () => {\n        expect(onChange).toHaveBeenCalledWith(mockChange);\n      });\n    });\n  });\n\n  describe('renderNode', () => {\n    test('the component has props', () => {\n      const plugin = MathPlugin({});\n      const { props } = plugin.renderNode({ node: { type: 'math' } });\n      expect(props.node).toEqual({ type: 'math' });\n    });\n  });\n\n  describe('serialization', () => {\n    describe('deserialize', () => {\n      const assertDeserialize = (html, expected, wrapType) => {\n        it(`innerHTML: ${html} is deserialized to: ${expected} with wrapType: ${wrapType}`, () => {\n          const el = {\n            tagName: 'span',\n            childNodes: [],\n            getAttribute: jest.fn(() => ''),\n            hasAttribute: jest.fn(() => true),\n            innerHTML: html,\n          };\n          const next = jest.fn();\n\n          const out = serialization.deserialize(el, next);\n          expect(out).toEqual({\n            object: 'inline',\n            type: 'math',\n            isVoid: true,\n            nodes: [],\n            data: {\n              latex: expected,\n              wrapper: wrapType,\n            },\n          });\n        });\n      };\n\n      assertDeserialize('$$&lt;$$', '<', MathPlugin.DOLLAR);\n      assertDeserialize('$&lt;$', '<', MathPlugin.DOLLAR);\n      assertDeserialize('\\\\(&lt;\\\\)', '<', MathPlugin.ROUND_BRACKETS);\n      assertDeserialize('\\\\[&lt;\\\\]', '<', MathPlugin.ROUND_BRACKETS);\n      assertDeserialize('latex', 'latex', MathPlugin.ROUND_BRACKETS);\n      assertDeserialize('\\\\displaystyle foo', 'foo', MathPlugin.ROUND_BRACKETS);\n\n      it('should make mathml editable if MathPlugin.mathMlOptions.mmlEditing is true', () => {\n        MathPlugin.mathMlOptions.mmlEditing = true;\n        const el = {\n          tagName: 'math',\n          outerHTML:\n            '<math xmlns=\"http://www.w3.org/1998/Math/MathML\">  <mn>2</mn>  <mi>x</mi>  <mtext>&#xA0;</mtext>  <mo>&#x2264;</mo>  <mn>4</mn>  <mi>y</mi>  <mtext>&#xA0;</mtext>  <mo>+</mo>  <mtext>&#xA0;</mtext>  <mn>8</mn> <msqrt>    <mi>h</mi>  </msqrt></math>',\n        };\n        const next = jest.fn();\n\n        const out = serialization.deserialize(el, next);\n\n        expect(out).toEqual({\n          object: 'inline',\n          type: 'math',\n          isVoid: true,\n          nodes: [],\n          data: {\n            latex: '/foobar/latex',\n            wrapper: 'round_brackets',\n          },\n        });\n      });\n\n      it('should make mathml readOnly if MathPlugin.mathMlOptions.mmlEditing is false', () => {\n        MathPlugin.mathMlOptions.mmlEditing = false;\n        const el = {\n          tagName: 'math',\n          outerHTML:\n            '<math xmlns=\"http://www.w3.org/1998/Math/MathML\">  <mn>2</mn>  <mi>x</mi>  <mtext>&#xA0;</mtext>  <mo>&#x2264;</mo>  <mn>4</mn>  <mi>y</mi>  <mtext>&#xA0;</mtext>  <mo>+</mo>  <mtext>&#xA0;</mtext>  <mn>8</mn> <msqrt>    <mi>h</mi>  </msqrt></math>',\n        };\n        const next = jest.fn();\n\n        const out = serialization.deserialize(el, next);\n\n        expect(out).toEqual({\n          object: 'inline',\n          isVoid: true,\n          type: 'mathml',\n          data: {\n            html: el.outerHTML,\n          },\n        });\n      });\n    });\n\n    describe('serialize', () => {\n      const assertSerialize = (latex, expectedHtml, wrapper) => {\n        wrapper = wrapper || MathPlugin.ROUND_BRACKETS;\n        it(`${latex} is serialized to: ${expectedHtml}`, () => {\n          const object = {\n            kind: 'inline',\n            type: 'math',\n            isVoid: true,\n            nodes: [],\n            data: Data.create({ latex, wrapper }),\n          };\n          const children = [];\n\n          const out = serialization.serialize(object, children);\n          log('out: ', out);\n          expect(out).toEqual(\n            <span data-latex=\"\" data-raw={latex}>\n              {expectedHtml}\n            </span>,\n          );\n        });\n      };\n\n      assertSerialize('latex', '\\\\(latex\\\\)', MathPlugin.ROUND_BRACKETS);\n      assertSerialize('latex', '\\\\(latex\\\\)', MathPlugin.SQUARE_BRACKETS);\n      assertSerialize('latex', '$latex$', MathPlugin.DOLLAR);\n      assertSerialize('latex', '$latex$', MathPlugin.DOUBLE_DOLLAR);\n\n      /**\n       * Note that when this is converted to html it get's escaped - but that's an issue with the slate html-serializer.\n       */\n      assertSerialize('<', '\\\\(<\\\\)');\n      assertSerialize('x<y', '\\\\(x<y\\\\)');\n    });\n  });\n});\n\ndescribe('CustomToolbarComp', () => {\n  let onDataChange;\n  let onToolbarDone;\n\n  const renderComponent = (extras = {}) => {\n    let mockChange = new MockChange();\n    const defaults = {\n      node: {\n        key: '1',\n        data: Data.create({ latex: 'foo' }),\n        equals: () => true,\n      },\n      value: {\n        document: {\n          getNextText: jest.fn().mockReturnValue({ key: 'nt' }),\n        },\n        change: jest.fn().mockReturnValue(mockChange),\n      },\n      onDataChange,\n      onToolbarDone,\n    };\n\n    const props = {\n      ...defaults,\n      ...extras,\n    };\n\n    return render(<CustomToolbarComp {...props} />);\n  };\n\n  describe('render', () => {\n    it('renders toolbar without default keypadMode', () => {\n      renderComponent();\n\n      // Verify the toolbar is rendered\n      expect(screen.getByTestId('math-toolbar')).toBeInTheDocument();\n      expect(screen.getByRole('toolbar')).toBeInTheDocument();\n    });\n\n    it('renders toolbar with default keypadMode', () => {\n      renderComponent({ pluginProps: { math: { keypadMode: 'geometry' } } });\n\n      // Verify the toolbar is rendered with keypadMode prop\n      expect(screen.getByTestId('math-toolbar')).toBeInTheDocument();\n      expect(screen.getByRole('toolbar')).toBeInTheDocument();\n    });\n  });\n\n  describe('onDone', () => {\n    it('calls onToolbarDone when done callback is triggered', () => {\n      onToolbarDone = jest.fn();\n      renderComponent();\n\n      // Trigger the onDone callback that was passed to MathToolbar\n      mockMathToolbarOnDone('oo');\n\n      expect(onToolbarDone).toHaveBeenCalledWith(expect.anything(), false);\n    });\n  });\n\n  describe('onChange', () => {\n    it('calls onDataChange when change callback is triggered', () => {\n      onDataChange = jest.fn();\n      renderComponent();\n\n      // Trigger the onChange callback that was passed to MathToolbar\n      mockMathToolbarOnChange('oo');\n\n      expect(onDataChange).toHaveBeenCalledWith('1', { latex: 'oo' });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/plugins/media/__tests__/index.test.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _ = _interopRequireDefault(require("../"));
+describe('media plugin', function () {
+  var imagePlugin = (0, _["default"])('video');
+  describe('normalizeNode', function () {
+    it('should exit the function if the node is not of type document', function () {
+      var returnValue = imagePlugin.normalizeNode({
+        object: 'image'
+      });
+      expect(returnValue).toEqual(undefined);
+    });
+    it('should exit there are no changes needed', function () {
+      var nodes = [{
+        object: 'text',
+        text: 'Before Media'
+      }, {
+        type: 'video'
+      }, {
+        object: 'text',
+        text: 'After Media'
+      }];
+      var returnValue = imagePlugin.normalizeNode({
+        object: 'document',
+        findDescendant: jest.fn(function (callback) {
+          nodes.forEach(function (n) {
+            return callback(n);
+          });
+        })
+      });
+      expect(returnValue).toEqual(undefined);
+    });
+    it('should return a function if there is a node with an empty text before a media element', function () {
+      var nodes = [{
+        object: 'text',
+        text: '',
+        key: '1'
+      }, {
+        type: 'video',
+        key: '2'
+      }, {
+        object: 'text',
+        text: 'After Media',
+        key: '3'
+      }];
+      var findDescendant = jest.fn(function (callback) {
+        nodes.forEach(function (n) {
+          return callback(n);
+        });
+      });
+      var change = {
+        withoutNormalization: jest.fn(function (callback) {
+          callback();
+        }),
+        insertTextByKey: jest.fn()
+      };
+      var returnValue = imagePlugin.normalizeNode({
+        object: 'document',
+        findDescendant: findDescendant
+      });
+      expect(returnValue).toEqual(expect.any(Function));
+      returnValue(change);
+      expect(change.withoutNormalization).toHaveBeenCalledWith(expect.any(Function));
+      expect(change.insertTextByKey).toHaveBeenCalledWith('1', 0, ' ');
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/plugins/respArea/drag-in-the-blank/__tests__/choice.test.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _choice = _interopRequireDefault(require("../choice"));
+// Mock @dnd-kit hooks to avoid DndContext requirement
+jest.mock('@dnd-kit/core', function () {
+  return {
+    useDraggable: jest.fn(function () {
+      return {
+        attributes: {},
+        listeners: {},
+        setNodeRef: jest.fn(),
+        isDragging: false
+      };
+    }),
+    useDroppable: jest.fn(function () {
+      return {
+        setNodeRef: jest.fn(),
+        isOver: false,
+        active: null
+      };
+    })
+  };
+});
+jest.mock('@pie-lib/math-rendering', function () {
+  return {
+    renderMath: jest.fn()
+  };
+});
+
+// Collect the CSS rules emotion/MUI injected into the document (jsdom uses insertRule).
+var collectEmotionRules = function collectEmotionRules() {
+  var rules = [];
+  for (var _i = 0, _Array$from = Array.from(document.styleSheets); _i < _Array$from.length; _i++) {
+    var sheet = _Array$from[_i];
+    try {
+      for (var _i2 = 0, _Array$from2 = Array.from(sheet.cssRules); _i2 < _Array$from2.length; _i2++) {
+        var rule = _Array$from2[_i2];
+        rules.push(rule.cssText);
+      }
+    } catch (e) {
+      /* inaccessible stylesheet */
+    }
+  }
+  return rules;
+};
+describe('drag-in-the-blank choice', function () {
+  var defaultProps = {
+    value: {
+      id: '1',
+      value: '<math>1/2</math>'
+    },
+    disabled: false,
+    instanceId: 'test-instance',
+    n: {
+      key: 'key-0'
+    },
+    nodeProps: {},
+    opts: {
+      options: {
+        duplicates: false
+      }
+    }
+  };
+  it('renders without crashing', function () {
+    var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_choice["default"], defaultProps)),
+      container = _render.container;
+    expect(container.firstChild).toBeInTheDocument();
+  });
+  describe('fraction math styling', function () {
+    it('enlarges numerator/denominator digits adjacent to a fraction to 120%', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_choice["default"], defaultProps));
+      var rule = collectEmotionRules().find(function (r) {
+        return r.includes('mjx-mn') && r.includes('mjx-mfrac');
+      });
+      expect(rule).toBeDefined();
+      expect(rule).toMatch(/mjx-mn:has\(~\s*mjx-mfrac\)/);
+      expect(rule).toMatch(/mjx-mfrac\s*~\s*mjx-mn/);
+      expect(rule).toMatch(/font-size:\s*120%\s*!important/i);
+    });
+    it('keeps the existing mjx-frac 120% rule', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_choice["default"], defaultProps));
+      var rule = collectEmotionRules().find(function (r) {
+        return /(^|[^-])mjx-frac/.test(r) && !r.includes('mjx-mfrac');
+      });
+      expect(rule).toBeDefined();
+      expect(rule).toMatch(/font-size:\s*120%\s*!important/i);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfcmVhY3QiLCJfaW50ZXJvcFJlcXVpcmVEZWZhdWx0IiwicmVxdWlyZSIsIl9yZWFjdDIiLCJfY2hvaWNlIiwiamVzdCIsIm1vY2siLCJ1c2VEcmFnZ2FibGUiLCJmbiIsImF0dHJpYnV0ZXMiLCJsaXN0ZW5lcnMiLCJzZXROb2RlUmVmIiwiaXNEcmFnZ2luZyIsInVzZURyb3BwYWJsZSIsImlzT3ZlciIsImFjdGl2ZSIsInJlbmRlck1hdGgiLCJjb2xsZWN0RW1vdGlvblJ1bGVzIiwicnVsZXMiLCJfaSIsIl9BcnJheSRmcm9tIiwiQXJyYXkiLCJmcm9tIiwiZG9jdW1lbnQiLCJzdHlsZVNoZWV0cyIsImxlbmd0aCIsInNoZWV0IiwiX2kyIiwiX0FycmF5JGZyb20yIiwiY3NzUnVsZXMiLCJydWxlIiwicHVzaCIsImNzc1RleHQiLCJlIiwiZGVzY3JpYmUiLCJkZWZhdWx0UHJvcHMiLCJ2YWx1ZSIsImlkIiwiZGlzYWJsZWQiLCJpbnN0YW5jZUlkIiwibiIsImtleSIsIm5vZGVQcm9wcyIsIm9wdHMiLCJvcHRpb25zIiwiZHVwbGljYXRlcyIsIml0IiwiX3JlbmRlciIsInJlbmRlciIsImNyZWF0ZUVsZW1lbnQiLCJjb250YWluZXIiLCJleHBlY3QiLCJmaXJzdENoaWxkIiwidG9CZUluVGhlRG9jdW1lbnQiLCJmaW5kIiwiciIsImluY2x1ZGVzIiwidG9CZURlZmluZWQiLCJ0b01hdGNoIiwidGVzdCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9wbHVnaW5zL3Jlc3BBcmVhL2RyYWctaW4tdGhlLWJsYW5rL19fdGVzdHNfXy9jaG9pY2UudGVzdC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnO1xuaW1wb3J0IHsgcmVuZGVyIH0gZnJvbSAnQHRlc3RpbmctbGlicmFyeS9yZWFjdCc7XG5pbXBvcnQgRHJhZ0Ryb3BDaG9pY2UgZnJvbSAnLi4vY2hvaWNlJztcblxuLy8gTW9jayBAZG5kLWtpdCBob29rcyB0byBhdm9pZCBEbmRDb250ZXh0IHJlcXVpcmVtZW50XG5qZXN0Lm1vY2soJ0BkbmQta2l0L2NvcmUnLCAoKSA9PiAoe1xuICB1c2VEcmFnZ2FibGU6IGplc3QuZm4oKCkgPT4gKHtcbiAgICBhdHRyaWJ1dGVzOiB7fSxcbiAgICBsaXN0ZW5lcnM6IHt9LFxuICAgIHNldE5vZGVSZWY6IGplc3QuZm4oKSxcbiAgICBpc0RyYWdnaW5nOiBmYWxzZSxcbiAgfSkpLFxuICB1c2VEcm9wcGFibGU6IGplc3QuZm4oKCkgPT4gKHtcbiAgICBzZXROb2RlUmVmOiBqZXN0LmZuKCksXG4gICAgaXNPdmVyOiBmYWxzZSxcbiAgICBhY3RpdmU6IG51bGwsXG4gIH0pKSxcbn0pKTtcblxuamVzdC5tb2NrKCdAcGllLWxpYi9tYXRoLXJlbmRlcmluZycsICgpID0+ICh7XG4gIHJlbmRlck1hdGg6IGplc3QuZm4oKSxcbn0pKTtcblxuLy8gQ29sbGVjdCB0aGUgQ1NTIHJ1bGVzIGVtb3Rpb24vTVVJIGluamVjdGVkIGludG8gdGhlIGRvY3VtZW50IChqc2RvbSB1c2VzIGluc2VydFJ1bGUpLlxuY29uc3QgY29sbGVjdEVtb3Rpb25SdWxlcyA9ICgpID0+IHtcbiAgY29uc3QgcnVsZXMgPSBbXTtcbiAgZm9yIChjb25zdCBzaGVldCBvZiBBcnJheS5mcm9tKGRvY3VtZW50LnN0eWxlU2hlZXRzKSkge1xuICAgIHRyeSB7XG4gICAgICBmb3IgKGNvbnN0IHJ1bGUgb2YgQXJyYXkuZnJvbShzaGVldC5jc3NSdWxlcykpIHtcbiAgICAgICAgcnVsZXMucHVzaChydWxlLmNzc1RleHQpO1xuICAgICAgfVxuICAgIH0gY2F0Y2ggKGUpIHtcbiAgICAgIC8qIGluYWNjZXNzaWJsZSBzdHlsZXNoZWV0ICovXG4gICAgfVxuICB9XG4gIHJldHVybiBydWxlcztcbn07XG5cbmRlc2NyaWJlKCdkcmFnLWluLXRoZS1ibGFuayBjaG9pY2UnLCAoKSA9PiB7XG4gIGNvbnN0IGRlZmF1bHRQcm9wcyA9IHtcbiAgICB2YWx1ZTogeyBpZDogJzEnLCB2YWx1ZTogJzxtYXRoPjEvMjwvbWF0aD4nIH0sXG4gICAgZGlzYWJsZWQ6IGZhbHNlLFxuICAgIGluc3RhbmNlSWQ6ICd0ZXN0LWluc3RhbmNlJyxcbiAgICBuOiB7IGtleTogJ2tleS0wJyB9LFxuICAgIG5vZGVQcm9wczoge30sXG4gICAgb3B0czogeyBvcHRpb25zOiB7IGR1cGxpY2F0ZXM6IGZhbHNlIH0gfSxcbiAgfTtcblxuICBpdCgncmVuZGVycyB3aXRob3V0IGNyYXNoaW5nJywgKCkgPT4ge1xuICAgIGNvbnN0IHsgY29udGFpbmVyIH0gPSByZW5kZXIoPERyYWdEcm9wQ2hvaWNlIHsuLi5kZWZhdWx0UHJvcHN9IC8+KTtcbiAgICBleHBlY3QoY29udGFpbmVyLmZpcnN0Q2hpbGQpLnRvQmVJblRoZURvY3VtZW50KCk7XG4gIH0pO1xuXG4gIGRlc2NyaWJlKCdmcmFjdGlvbiBtYXRoIHN0eWxpbmcnLCAoKSA9PiB7XG4gICAgaXQoJ2VubGFyZ2VzIG51bWVyYXRvci9kZW5vbWluYXRvciBkaWdpdHMgYWRqYWNlbnQgdG8gYSBmcmFjdGlvbiB0byAxMjAlJywgKCkgPT4ge1xuICAgICAgcmVuZGVyKDxEcmFnRHJvcENob2ljZSB7Li4uZGVmYXVsdFByb3BzfSAvPik7XG4gICAgICBjb25zdCBydWxlID0gY29sbGVjdEVtb3Rpb25SdWxlcygpLmZpbmQoKHIpID0+IHIuaW5jbHVkZXMoJ21qeC1tbicpICYmIHIuaW5jbHVkZXMoJ21qeC1tZnJhYycpKTtcbiAgICAgIGV4cGVjdChydWxlKS50b0JlRGVmaW5lZCgpO1xuICAgICAgZXhwZWN0KHJ1bGUpLnRvTWF0Y2goL21qeC1tbjpoYXNcXCh+XFxzKm1qeC1tZnJhY1xcKS8pO1xuICAgICAgZXhwZWN0KHJ1bGUpLnRvTWF0Y2goL21qeC1tZnJhY1xccyp+XFxzKm1qeC1tbi8pO1xuICAgICAgZXhwZWN0KHJ1bGUpLnRvTWF0Y2goL2ZvbnQtc2l6ZTpcXHMqMTIwJVxccyohaW1wb3J0YW50L2kpO1xuICAgIH0pO1xuXG4gICAgaXQoJ2tlZXBzIHRoZSBleGlzdGluZyBtangtZnJhYyAxMjAlIHJ1bGUnLCAoKSA9PiB7XG4gICAgICByZW5kZXIoPERyYWdEcm9wQ2hvaWNlIHsuLi5kZWZhdWx0UHJvcHN9IC8+KTtcbiAgICAgIGNvbnN0IHJ1bGUgPSBjb2xsZWN0RW1vdGlvblJ1bGVzKCkuZmluZCgocikgPT4gLyhefFteLV0pbWp4LWZyYWMvLnRlc3QocikgJiYgIXIuaW5jbHVkZXMoJ21qeC1tZnJhYycpKTtcbiAgICAgIGV4cGVjdChydWxlKS50b0JlRGVmaW5lZCgpO1xuICAgICAgZXhwZWN0KHJ1bGUpLnRvTWF0Y2goL2ZvbnQtc2l6ZTpcXHMqMTIwJVxccyohaW1wb3J0YW50L2kpO1xuICAgIH0pO1xuICB9KTtcbn0pO1xuIl0sIm1hcHBpbmdzIjoiOzs7QUFBQSxJQUFBQSxNQUFBLEdBQUFDLHNCQUFBLENBQUFDLE9BQUE7QUFDQSxJQUFBQyxPQUFBLEdBQUFELE9BQUE7QUFDQSxJQUFBRSxPQUFBLEdBQUFILHNCQUFBLENBQUFDLE9BQUE7QUFFQTtBQUNBRyxJQUFJLENBQUNDLElBQUksQ0FBQyxlQUFlLEVBQUU7RUFBQSxPQUFPO0lBQ2hDQyxZQUFZLEVBQUVGLElBQUksQ0FBQ0csRUFBRSxDQUFDO01BQUEsT0FBTztRQUMzQkMsVUFBVSxFQUFFLENBQUMsQ0FBQztRQUNkQyxTQUFTLEVBQUUsQ0FBQyxDQUFDO1FBQ2JDLFVBQVUsRUFBRU4sSUFBSSxDQUFDRyxFQUFFLENBQUMsQ0FBQztRQUNyQkksVUFBVSxFQUFFO01BQ2QsQ0FBQztJQUFBLENBQUMsQ0FBQztJQUNIQyxZQUFZLEVBQUVSLElBQUksQ0FBQ0csRUFBRSxDQUFDO01BQUEsT0FBTztRQUMzQkcsVUFBVSxFQUFFTixJQUFJLENBQUNHLEVBQUUsQ0FBQyxDQUFDO1FBQ3JCTSxNQUFNLEVBQUUsS0FBSztRQUNiQyxNQUFNLEVBQUU7TUFDVixDQUFDO0lBQUEsQ0FBQztFQUNKLENBQUM7QUFBQSxDQUFDLENBQUM7QUFFSFYsSUFBSSxDQUFDQyxJQUFJLENBQUMseUJBQXlCLEVBQUU7RUFBQSxPQUFPO0lBQzFDVSxVQUFVLEVBQUVYLElBQUksQ0FBQ0csRUFBRSxDQUFDO0VBQ3RCLENBQUM7QUFBQSxDQUFDLENBQUM7O0FBRUg7QUFDQSxJQUFNUyxtQkFBbUIsR0FBRyxTQUF0QkEsbUJBQW1CQSxDQUFBLEVBQVM7RUFDaEMsSUFBTUMsS0FBSyxHQUFHLEVBQUU7RUFDaEIsU0FBQUMsRUFBQSxNQUFBQyxXQUFBLEdBQW9CQyxLQUFLLENBQUNDLElBQUksQ0FBQ0MsUUFBUSxDQUFDQyxXQUFXLENBQUMsRUFBQUwsRUFBQSxHQUFBQyxXQUFBLENBQUFLLE1BQUEsRUFBQU4sRUFBQSxJQUFFO0lBQWpELElBQU1PLEtBQUssR0FBQU4sV0FBQSxDQUFBRCxFQUFBO0lBQ2QsSUFBSTtNQUNGLFNBQUFRLEdBQUEsTUFBQUMsWUFBQSxHQUFtQlAsS0FBSyxDQUFDQyxJQUFJLENBQUNJLEtBQUssQ0FBQ0csUUFBUSxDQUFDLEVBQUFGLEdBQUEsR0FBQUMsWUFBQSxDQUFBSCxNQUFBLEVBQUFFLEdBQUEsSUFBRTtRQUExQyxJQUFNRyxJQUFJLEdBQUFGLFlBQUEsQ0FBQUQsR0FBQTtRQUNiVCxLQUFLLENBQUNhLElBQUksQ0FBQ0QsSUFBSSxDQUFDRSxPQUFPLENBQUM7TUFDMUI7SUFDRixDQUFDLENBQUMsT0FBT0MsQ0FBQyxFQUFFO01BQ1Y7SUFBQTtFQUVKO0VBQ0EsT0FBT2YsS0FBSztBQUNkLENBQUM7QUFFRGdCLFFBQVEsQ0FBQywwQkFBMEIsRUFBRSxZQUFNO0VBQ3pDLElBQU1DLFlBQVksR0FBRztJQUNuQkMsS0FBSyxFQUFFO01BQUVDLEVBQUUsRUFBRSxHQUFHO01BQUVELEtBQUssRUFBRTtJQUFtQixDQUFDO0lBQzdDRSxRQUFRLEVBQUUsS0FBSztJQUNmQyxVQUFVLEVBQUUsZUFBZTtJQUMzQkMsQ0FBQyxFQUFFO01BQUVDLEdBQUcsRUFBRTtJQUFRLENBQUM7SUFDbkJDLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDYkMsSUFBSSxFQUFFO01BQUVDLE9BQU8sRUFBRTtRQUFFQyxVQUFVLEVBQUU7TUFBTTtJQUFFO0VBQ3pDLENBQUM7RUFFREMsRUFBRSxDQUFDLDBCQUEwQixFQUFFLFlBQU07SUFDbkMsSUFBQUMsT0FBQSxHQUFzQixJQUFBQyxjQUFNLGVBQUNoRCxNQUFBLFlBQUFpRCxhQUFBLENBQUM3QyxPQUFBLFdBQWMsRUFBSytCLFlBQWUsQ0FBQyxDQUFDO01BQTFEZSxTQUFTLEdBQUFILE9BQUEsQ0FBVEcsU0FBUztJQUNqQkMsTUFBTSxDQUFDRCxTQUFTLENBQUNFLFVBQVUsQ0FBQyxDQUFDQyxpQkFBaUIsQ0FBQyxDQUFDO0VBQ2xELENBQUMsQ0FBQztFQUVGbkIsUUFBUSxDQUFDLHVCQUF1QixFQUFFLFlBQU07SUFDdENZLEVBQUUsQ0FBQyxzRUFBc0UsRUFBRSxZQUFNO01BQy9FLElBQUFFLGNBQU0sZUFBQ2hELE1BQUEsWUFBQWlELGFBQUEsQ0FBQzdDLE9BQUEsV0FBYyxFQUFLK0IsWUFBZSxDQUFDLENBQUM7TUFDNUMsSUFBTUwsSUFBSSxHQUFHYixtQkFBbUIsQ0FBQyxDQUFDLENBQUNxQyxJQUFJLENBQUMsVUFBQ0MsQ0FBQztRQUFBLE9BQUtBLENBQUMsQ0FBQ0MsUUFBUSxDQUFDLFFBQVEsQ0FBQyxJQUFJRCxDQUFDLENBQUNDLFFBQVEsQ0FBQyxXQUFXLENBQUM7TUFBQSxFQUFDO01BQy9GTCxNQUFNLENBQUNyQixJQUFJLENBQUMsQ0FBQzJCLFdBQVcsQ0FBQyxDQUFDO01BQzFCTixNQUFNLENBQUNyQixJQUFJLENBQUMsQ0FBQzRCLE9BQU8sQ0FBQyw2QkFBNkIsQ0FBQztNQUNuRFAsTUFBTSxDQUFDckIsSUFBSSxDQUFDLENBQUM0QixPQUFPLENBQUMsd0JBQXdCLENBQUM7TUFDOUNQLE1BQU0sQ0FBQ3JCLElBQUksQ0FBQyxDQUFDNEIsT0FBTyxDQUFDLGlDQUFpQyxDQUFDO0lBQ3pELENBQUMsQ0FBQztJQUVGWixFQUFFLENBQUMsdUNBQXVDLEVBQUUsWUFBTTtNQUNoRCxJQUFBRSxjQUFNLGVBQUNoRCxNQUFBLFlBQUFpRCxhQUFBLENBQUM3QyxPQUFBLFdBQWMsRUFBSytCLFlBQWUsQ0FBQyxDQUFDO01BQzVDLElBQU1MLElBQUksR0FBR2IsbUJBQW1CLENBQUMsQ0FBQyxDQUFDcUMsSUFBSSxDQUFDLFVBQUNDLENBQUM7UUFBQSxPQUFLLGtCQUFrQixDQUFDSSxJQUFJLENBQUNKLENBQUMsQ0FBQyxJQUFJLENBQUNBLENBQUMsQ0FBQ0MsUUFBUSxDQUFDLFdBQVcsQ0FBQztNQUFBLEVBQUM7TUFDdEdMLE1BQU0sQ0FBQ3JCLElBQUksQ0FBQyxDQUFDMkIsV0FBVyxDQUFDLENBQUM7TUFDMUJOLE1BQU0sQ0FBQ3JCLElBQUksQ0FBQyxDQUFDNEIsT0FBTyxDQUFDLGlDQUFpQyxDQUFDO0lBQ3pELENBQUMsQ0FBQztFQUNKLENBQUMsQ0FBQztBQUNKLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==