@pie-lib/editable-html 11.1.1 → 11.3.0-beta.0

package/lib/plugins/list/index.js

@@ -17,8 +17,12 @@ var _propTypes = _interopRequireDefault(require("prop-types"));
 
 var _slateEditList = _interopRequireDefault(require("slate-edit-list"));
 
+var _options = _interopRequireDefault(require("slate-edit-list/dist/options"));
+
 var _debug = _interopRequireDefault(require("debug"));
 
+var _this = void 0;
+
 var log = (0, _debug["default"])('@pie-lib:editable-html:plugins:list');
 
 var b = function b(type, next, childNodes) {
@@ -66,6 +70,9 @@ exports.serialization = serialization;
 var createEditList = function createEditList() {
   var core = (0, _slateEditList["default"])({
     typeDefault: 'span'
+  });
+  var listOptions = new _options["default"]({
+    typeDefault: 'span'
   }); // fix outdated schema
 
   if (core.schema && core.schema.blocks) {
@@ -141,6 +148,86 @@ var createEditList = function createEditList() {
     return change.normalize();
   };
 
+  core.changes.unwrapList = function unwrapList(opts, change) {
+    var items = core.utils.getItemsAtRange(change.value);
+
+    if (items.isEmpty()) {
+      return change;
+    } // Unwrap the items from their list
+
+
+    items.forEach(function (item) {
+      return change.unwrapNodeByKey(item.key, {
+        normalize: false
+      });
+    }); // Parent of the list of the items
+
+    var firstItem = items.first();
+    var parent = change.value.document.getParent(firstItem.key);
+    var index = parent.nodes.findIndex(function (node) {
+      return node.key === firstItem.key;
+    }); // Unwrap the items' children
+
+    items.forEach(function (item) {
+      item.nodes.forEach(function (node) {
+        change.moveNodeByKey(node.key, parent.key, index, {
+          normalize: false
+        });
+        index += 1;
+      });
+    }); // Finally, remove the now empty items
+
+    items.forEach(function (item) {
+      return change.removeNodeByKey(item.key, {
+        normalize: false
+      });
+    });
+    return change;
+  }.bind(_this, listOptions);
+
+  core.utils.getItemsAtRange = function (opts, value, range) {
+    range = range || value.selection;
+
+    if (!range.startKey) {
+      return _immutable["default"].List();
+    }
+
+    var document = value.document;
+    var startBlock = document.getClosestBlock(range.startKey);
+    var endBlock = document.getClosestBlock(range.endKey);
+
+    if (startBlock === endBlock) {
+      var item = core.utils.getCurrentItem(value, startBlock);
+      return item ? _immutable["default"].List([item]) : _immutable["default"].List();
+    }
+
+    var ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);
+
+    if (core.utils.isList(ancestor)) {
+      var startPath = ancestor.getPath(startBlock.key);
+      var endPath = ancestor.getPath(endBlock.key);
+      return ancestor.nodes.slice(startPath.get(0), endPath.get(0) + 1);
+    } else if (ancestor.type === opts.typeItem) {
+      // The ancestor is the highest list item that covers the range
+      return _immutable["default"].List([ancestor]);
+    } // No list of items can cover the range
+
+
+    return _immutable["default"].List();
+  }.bind(_this, listOptions);
+
+  core.utils.getListForItem = function (opts, value, item) {
+    var document = value.document;
+    var parent = document.getParent(item.key);
+    return parent && core.utils.isList(parent) ? parent : null;
+  }.bind(_this, listOptions);
+
+  core.utils.isSelectionInList = function (opts, value, type) {
+    var items = core.utils.getItemsAtRange(value);
+    return !items.isEmpty() && ( // Check the type of the list if needed
+    !type || core.utils.getListForItem(value, items.first()).get('type') === type);
+  }.bind(_this, listOptions);
+
   return core;
 };
 
@@ -168,6 +255,7 @@ var _default = function _default(options) {
 
   core.toolbar = {
     isMark: false,
+    ariaLabel: type == 'ul_list' ? 'bulleted list' : 'numbered-list',
     type: type,
     icon: icon,
     isActive: function isActive(value, type) {
@@ -192,13 +280,55 @@ var _default = function _default(options) {
       }
     }
   };
+
+  core.normalizeNode = function (node) {
+    if (node.object !== 'document' && node.object !== 'block') {
+      return undefined;
+    }
+
+    var response = core.validateNode(node);
+    var invalidListItems = [];
+    node.forEachDescendant(function (d) {
+      if (d.type === 'list_item' && d.nodes.size === 1 && d.nodes.first().object === 'text') {
+        // if we have a list_item that has only a text inside, we need to add a block in it
+        invalidListItems.push(d);
+      }
+    });
+
+    if (!invalidListItems.length && !response) {
+      return undefined;
+    }
+
+    return function (change) {
+      if (response) {
+        response(change);
+      }
+
+      if (invalidListItems.length) {
+        change.withoutNormalization(function () {
+          invalidListItems.forEach(function (node) {
+            var textNode = node.nodes.first();
+            var wrappedBlock = {
+              object: 'block',
+              type: 'div',
+              nodes: [textNode.toJSON()]
+            };
+            change.removeNodeByKey(textNode.key);
+            change.insertNodeByKey(node.key, 0, wrappedBlock);
+          });
+        });
+      }
+    };
+  };
+
   core.renderNode.propTypes = {
     node: _propTypes["default"].object,
     attributes: _propTypes["default"].object,
     children: _propTypes["default"].func
   };
+  core.name = type;
   return core;
 };
 
 exports["default"] = _default;
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/plugins/list/index.jsx"],"names":["log","b","type","next","childNodes","object","nodes","serialization","deserialize","el","name","tagName","toLowerCase","children","length","Array","from","serialize","createEditList","core","typeDefault","listOptions","ListOptions","schema","blocks","Object","keys","forEach","key","block","parent","types","getHighestSelectedBlocks","value","range","selection","document","startBlock","getClosestBlock","startKey","endBlock","endKey","Immutable","List","ancestor","getCommonAncestor","startPath","getPath","endPath","slice","get","changes","wrapInList","change","data","selectedBlocks","wrapBlock","Data","create","normalize","node","utils","isList","_ref","unwrapNodeByKey","wrapBlockByKey","unwrapList","opts","items","getItemsAtRange","isEmpty","item","firstItem","first","getParent","index","findIndex","moveNodeByKey","removeNodeByKey","bind","getCurrentItem","typeItem","getListForItem","isSelectionInList","options","icon","renderNode","props","attributes","toolbar","isMark","ariaLabel","isActive","current","getCurrentList","onClick","onChange","inList","call","normalizeNode","undefined","response","validateNode","invalidListItems","forEachDescendant","d","size","push","withoutNormalization","textNode","wrappedBlock","toJSON","insertNodeByKey","propTypes","PropTypes","func"],"mappings":"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","sourcesContent":["import React from 'react';\nimport { Data } from 'slate';\nimport Immutable from 'immutable';\nimport PropTypes from 'prop-types';\nimport EditList from 'slate-edit-list';\nimport ListOptions from 'slate-edit-list/dist/options';\nimport debug from 'debug';\n\nconst log = debug('@pie-lib:editable-html:plugins:list');\n\nconst b = (type, next, childNodes) => ({\n  object: 'block',\n  type,\n  nodes: next(childNodes),\n});\n\nexport const serialization = {\n  deserialize(el, next) {\n    const name = el.tagName.toLowerCase();\n\n    if (name === 'li') {\n      return b('list_item', next, el.childNodes);\n    }\n\n    if (name === 'ul') {\n      return b('ul_list', next, el.children.length ? Array.from(el.children) : el.childNodes);\n    }\n\n    if (name === 'ol') {\n      return b('ol_list', next, el.children.length ? Array.from(el.children) : el.childNodes);\n    }\n  },\n  serialize(object, children) {\n    if (object.object !== 'block') return;\n\n    if (object.type === 'list_item') {\n      return <li>{children}</li>;\n    }\n\n    if (object.type === 'ul_list') {\n      return <ul>{children}</ul>;\n    }\n\n    if (object.type === 'ol_list') {\n      return <ol>{children}</ol>;\n    }\n  },\n};\n\nconst createEditList = () => {\n  const core = EditList({\n    typeDefault: 'span',\n  });\n\n  const listOptions = new ListOptions({\n    typeDefault: 'span',\n  });\n\n  // fix outdated schema\n  if (core.schema && core.schema.blocks) {\n    Object.keys(core.schema.blocks).forEach((key) => {\n      const block = core.schema.blocks[key];\n\n      if (block.parent) {\n        return;\n      }\n\n      block.nodes[0] = { type: block.nodes[0].types[0] };\n    });\n  }\n\n  /**\n   * This override of the core.changes.wrapInList is needed because the version\n   * of immutable that we have does not support getting the element at a specific\n   * index with a square bracket (list[0]). We have to use the list.get function instead\n   */\n\n  /**\n   * Returns the highest list of blocks that cover the current selection\n   */\n  const getHighestSelectedBlocks = (value) => {\n    const range = value.selection;\n    const document = value.document;\n\n    const startBlock = document.getClosestBlock(range.startKey);\n    const endBlock = document.getClosestBlock(range.endKey);\n\n    if (startBlock === endBlock) {\n      return Immutable.List([startBlock]);\n    }\n\n    const ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);\n    const startPath = ancestor.getPath(startBlock.key);\n    const endPath = ancestor.getPath(endBlock.key);\n\n    return ancestor.nodes.slice(startPath.get(0), endPath.get(0) + 1);\n  };\n\n  /**\n   * Wrap the blocks in the current selection in a new list. Selected\n   * lists are merged together.\n   */\n  core.changes.wrapInList = function(change, type, data) {\n    const selectedBlocks = getHighestSelectedBlocks(change.value);\n\n    // Wrap in container\n    change.wrapBlock({ type: type, data: Data.create(data) }, { normalize: false });\n\n    // Wrap in list items\n    selectedBlocks.forEach(function(node) {\n      if (core.utils.isList(node)) {\n        // Merge its items with the created list\n        node.nodes.forEach(function(_ref) {\n          const key = _ref.key;\n          return change.unwrapNodeByKey(key, { normalize: false });\n        });\n      } else if (node.type !== 'list_item') {\n        change.wrapBlockByKey(node.key, 'list_item', {\n          normalize: false,\n        });\n      }\n    });\n\n    return change.normalize();\n  };\n\n  core.changes.unwrapList = function unwrapList(opts, change) {\n    const items = core.utils.getItemsAtRange(change.value);\n\n    if (items.isEmpty()) {\n      return change;\n    }\n\n    // Unwrap the items from their list\n    items.forEach((item) => change.unwrapNodeByKey(item.key, { normalize: false }));\n\n    // Parent of the list of the items\n    const firstItem = items.first();\n    const parent = change.value.document.getParent(firstItem.key);\n\n    let index = parent.nodes.findIndex((node) => node.key === firstItem.key);\n\n    // Unwrap the items' children\n    items.forEach((item) => {\n      item.nodes.forEach((node) => {\n        change.moveNodeByKey(node.key, parent.key, index, {\n          normalize: false,\n        });\n        index += 1;\n      });\n    });\n\n    // Finally, remove the now empty items\n    items.forEach((item) => change.removeNodeByKey(item.key, { normalize: false }));\n\n    return change;\n  }.bind(this, listOptions);\n\n  core.utils.getItemsAtRange = function(opts, value, range) {\n    range = range || value.selection;\n\n    if (!range.startKey) {\n      return Immutable.List();\n    }\n\n    const { document } = value;\n\n    const startBlock = document.getClosestBlock(range.startKey);\n    const endBlock = document.getClosestBlock(range.endKey);\n\n    if (startBlock === endBlock) {\n      const item = core.utils.getCurrentItem(value, startBlock);\n      return item ? Immutable.List([item]) : Immutable.List();\n    }\n\n    const ancestor = document.getCommonAncestor(startBlock.key, endBlock.key);\n\n    if (core.utils.isList(ancestor)) {\n      const startPath = ancestor.getPath(startBlock.key);\n      const endPath = ancestor.getPath(endBlock.key);\n\n      return ancestor.nodes.slice(startPath.get(0), endPath.get(0) + 1);\n    } else if (ancestor.type === opts.typeItem) {\n      // The ancestor is the highest list item that covers the range\n      return Immutable.List([ancestor]);\n    }\n    // No list of items can cover the range\n    return Immutable.List();\n  }.bind(this, listOptions);\n\n  core.utils.getListForItem = function(opts, value, item) {\n    const { document } = value;\n    const parent = document.getParent(item.key);\n    return parent && core.utils.isList(parent) ? parent : null;\n  }.bind(this, listOptions);\n\n  core.utils.isSelectionInList = function(opts, value, type) {\n    const items = core.utils.getItemsAtRange(value);\n    return (\n      !items.isEmpty() &&\n      // Check the type of the list if needed\n      (!type || core.utils.getListForItem(value, items.first()).get('type') === type)\n    );\n  }.bind(this, listOptions);\n\n  return core;\n};\n\nexport default (options) => {\n  const { type, icon } = options;\n\n  const core = createEditList();\n\n  // eslint-disable-next-line react/display-name\n  core.renderNode = (props) => {\n    const { node, attributes, children } = props;\n\n    switch (node.type) {\n      case 'ul_list':\n        return <ul {...attributes}>{children}</ul>;\n      case 'ol_list':\n        return <ol {...attributes}>{children}</ol>;\n      case 'list_item':\n        return <li {...attributes}>{children}</li>;\n    }\n  };\n\n  core.toolbar = {\n    isMark: false,\n    ariaLabel: type == 'ul_list' ? 'bulleted list' : 'numbered-list',\n    type,\n    icon,\n    isActive: (value, type) => {\n      if (!core.utils.isSelectionInList(value)) {\n        return false;\n      }\n      const current = core.utils.getCurrentList(value);\n      return current ? current.type === type : false;\n    },\n    onClick: (value, onChange) => {\n      log('[onClick]', value);\n      const inList = core.utils.isSelectionInList(value);\n      if (inList) {\n        const change = value.change().call(core.changes.unwrapList);\n        onChange(change);\n      } else {\n        const change = value.change().call(core.changes.wrapInList, type);\n        onChange(change);\n      }\n    },\n  };\n\n  core.normalizeNode = (node) => {\n    if (node.object !== 'document' && node.object !== 'block') {\n      return undefined;\n    }\n\n    const response = core.validateNode(node);\n\n    const invalidListItems = [];\n\n    node.forEachDescendant((d) => {\n      if (d.type === 'list_item' && d.nodes.size === 1 && d.nodes.first().object === 'text') {\n        // if we have a list_item that has only a text inside, we need to add a block in it\n        invalidListItems.push(d);\n      }\n    });\n\n    if (!invalidListItems.length && !response) {\n      return undefined;\n    }\n\n    return (change) => {\n      if (response) {\n        response(change);\n      }\n\n      if (invalidListItems.length) {\n        change.withoutNormalization(() => {\n          invalidListItems.forEach((node) => {\n            const textNode = node.nodes.first();\n            const wrappedBlock = {\n              object: 'block',\n              type: 'div',\n              nodes: [textNode.toJSON()],\n            };\n\n            change.removeNodeByKey(textNode.key);\n\n            change.insertNodeByKey(node.key, 0, wrappedBlock);\n          });\n        });\n      }\n    };\n  };\n\n  core.renderNode.propTypes = {\n    node: PropTypes.object,\n    attributes: PropTypes.object,\n    children: PropTypes.func,\n  };\n  core.name = type;\n\n  return core;\n};\n"]}

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

@@ -0,0 +1,300 @@
+"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 _enzyme = require("enzyme");
+
+var _mathToolbar = require("@pie-lib/math-toolbar");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+jest.mock('@pie-framework/mathquill', function () {
+  return {
+    StaticMath: jest.fn(),
+    getInterface: jest.fn().mockReturnThis(),
+    registerEmbed: jest.fn()
+  };
+});
+jest.mock('@pie-lib/math-toolbar', function () {
+  return {
+    MathPreview: function MathPreview() {
+      return /*#__PURE__*/_react["default"].createElement("div", null);
+    },
+    MathToolbar: function MathToolbar() {
+      return /*#__PURE__*/_react["default"].createElement("div", null);
+    }
+  };
+});
+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 wrapper = function wrapper(extras) {
+    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, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_index.CustomToolbarComp, props));
+  };
+
+  describe('render', function () {
+    it('renders without default keypadMode', function () {
+      var w = wrapper();
+      expect(w).toMatchSnapshot();
+      w.setProps({
+        pluginProps: {
+          math: {
+            keypadMode: 3
+          }
+        }
+      });
+      expect(w).toMatchSnapshot();
+    });
+    it('renders with default keypadMode', function () {
+      var w = wrapper({
+        pluginProps: {
+          math: {
+            keypadMode: 'geometry'
+          }
+        }
+      });
+      expect(w).toMatchSnapshot();
+      w.setProps({
+        pluginProps: {
+          math: {
+            keypadMode: 3
+          }
+        }
+      });
+      expect(w).toMatchSnapshot();
+    });
+  });
+  describe('onDone', function () {
+    it('calls onToolbarDone', function () {
+      onToolbarDone = jest.fn();
+      var w = wrapper();
+      w.find(_mathToolbar.MathToolbar).prop('onDone')('oo');
+      expect(onToolbarDone).toHaveBeenCalledWith(expect.anything(), false);
+    });
+  });
+  describe('onChange', function () {
+    it('calls onDataChange', function () {
+      onDataChange = jest.fn();
+      var w = wrapper();
+      w.find(_mathToolbar.MathToolbar).prop('onChange')('oo');
+      expect(onDataChange).toHaveBeenCalledWith('1', {
+        latex: 'oo'
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/plugins/math/__tests__/index.test.jsx"],"names":["jest","mock","StaticMath","fn","getInterface","mockReturnThis","registerEmbed","MathPreview","MathToolbar","requireActual","mmlToLatex","log","describe","plugin","mockChange","value","onChange","beforeEach","MockChange","change","toolbar","onClick","test","expect","insertInline","toBeCalledWith","objectContaining","data","toHaveBeenCalledWith","renderNode","node","type","props","toEqual","assertDeserialize","html","expected","wrapType","it","el","tagName","childNodes","getAttribute","hasAttribute","innerHTML","next","out","serialization","deserialize","object","isVoid","nodes","latex","wrapper","MathPlugin","DOLLAR","ROUND_BRACKETS","mathMlOptions","mmlEditing","outerHTML","assertSerialize","expectedHtml","kind","Data","create","children","serialize","SQUARE_BRACKETS","DOUBLE_DOLLAR","onDataChange","onToolbarDone","extras","defaults","key","equals","document","getNextText","mockReturnValue","w","toMatchSnapshot","setProps","pluginProps","math","keypadMode","find","prop","anything"],"mappings":"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","sourcesContent":["import React from 'react';\nimport debug from 'debug';\nimport MockChange from '../../image/__tests__/mock-change';\nimport { Data } from 'slate';\nimport MathPlugin, { serialization, inlineMath, CustomToolbarComp } from '../index';\nimport { shallow } from 'enzyme';\nimport { MathToolbar } from '@pie-lib/math-toolbar';\njest.mock('@pie-framework/mathquill', () => ({\n  StaticMath: jest.fn(),\n  getInterface: jest.fn().mockReturnThis(),\n  registerEmbed: jest.fn(),\n}));\n\njest.mock('@pie-lib/math-toolbar', () => ({\n  MathPreview: () => <div />,\n  MathToolbar: () => <div />,\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 wrapper = (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 shallow(<CustomToolbarComp {...props} />);\n  };\n\n  describe('render', () => {\n    it('renders without default keypadMode', () => {\n      const w = wrapper();\n\n      expect(w).toMatchSnapshot();\n\n      w.setProps({ pluginProps: { math: { keypadMode: 3 } } });\n\n      expect(w).toMatchSnapshot();\n    });\n\n    it('renders with default keypadMode', () => {\n      const w = wrapper({ pluginProps: { math: { keypadMode: 'geometry' } } });\n\n      expect(w).toMatchSnapshot();\n\n      w.setProps({ pluginProps: { math: { keypadMode: 3 } } });\n\n      expect(w).toMatchSnapshot();\n    });\n  });\n\n  describe('onDone', () => {\n    it('calls onToolbarDone', () => {\n      onToolbarDone = jest.fn();\n      const w = wrapper();\n      w.find(MathToolbar).prop('onDone')('oo');\n      expect(onToolbarDone).toHaveBeenCalledWith(expect.anything(), false);\n    });\n  });\n\n  describe('onChange', () => {\n    it('calls onDataChange', () => {\n      onDataChange = jest.fn();\n      const w = wrapper();\n      w.find(MathToolbar).prop('onChange')('oo');\n      expect(onDataChange).toHaveBeenCalledWith('1', { latex: 'oo' });\n    });\n  });\n});\n"]}