@pie-lib/editable-html-tip-tap 1.0.0

package/lib/plugins/math/index.js

@@ -0,0 +1,454 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CustomToolbarComp = void 0;
+exports["default"] = MathPlugin;
+exports.serialization = exports.inlineMath = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _Functions = _interopRequireDefault(require("@material-ui/icons/Functions"));
+
+var _slate = require("slate");
+
+var _mathToolbar = require("@pie-lib/math-toolbar");
+
+var _mathRendering = require("@pie-lib/math-rendering");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _debug = _interopRequireDefault(require("debug"));
+
+var _slatePropTypes = _interopRequireDefault(require("slate-prop-types"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _blockTags = require("../../block-tags");
+
+var _isEqual = _interopRequireDefault(require("lodash/isEqual"));
+
+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; }
+
+var log = (0, _debug["default"])('@pie-lib:editable-html:plugins:math');
+var TEXT_NODE = 3;
+
+function generateAdditionalKeys() {
+  var keyData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return keyData.map(function (key) {
+    return {
+      name: key,
+      latex: key,
+      write: key,
+      label: key
+    };
+  });
+} // eslint-disable-next-line react/display-name
+
+
+var CustomToolbarComp = /*#__PURE__*/_react["default"].memo(function (props) {
+  var node = props.node,
+      value = props.value,
+      onFocus = props.onFocus,
+      onBlur = props.onBlur,
+      onClick = props.onClick;
+
+  var _ref = props || {},
+      pluginProps = _ref.pluginProps;
+
+  var _ref2 = pluginProps || {},
+      math = _ref2.math;
+
+  var _ref3 = math || {},
+      keypadMode = _ref3.keypadMode,
+      customKeys = _ref3.customKeys,
+      _ref3$controlledKeypa = _ref3.controlledKeypadMode,
+      controlledKeypadMode = _ref3$controlledKeypa === void 0 ? true : _ref3$controlledKeypa;
+
+  var onDone = function onDone(latex) {
+    var update = _objectSpread(_objectSpread({}, node.data.toObject()), {}, {
+      latex: latex
+    });
+
+    var change = value.change().setNodeByKey(node.key, {
+      data: update
+    });
+    var nextText = value.document.getNextText(node.key);
+    change.moveFocusTo(nextText.key, 0).moveAnchorTo(nextText.key, 0);
+    props.onToolbarDone(change, false);
+  };
+
+  var onChange = function onChange(latex) {
+    var update = _objectSpread(_objectSpread({}, node.data.toObject()), {}, {
+      latex: latex
+    });
+
+    var change = value.change().setNodeByKey(node.key, {
+      data: update
+    });
+    log('call onToolbarChange:', change);
+    props.onDataChange(node.key, update);
+  };
+
+  var latex = node.data.get('latex');
+  return /*#__PURE__*/_react["default"].createElement(_mathToolbar.MathToolbar, {
+    autoFocus: true,
+    additionalKeys: generateAdditionalKeys(customKeys),
+    latex: latex,
+    onChange: onChange,
+    onDone: onDone,
+    onBlur: onBlur,
+    onFocus: onFocus,
+    onClick: onClick,
+    keypadMode: keypadMode,
+    controlledKeypadMode: controlledKeypadMode
+  });
+}, function (prev, next) {
+  var node = prev.node,
+      _prev$pluginProps = prev.pluginProps;
+  _prev$pluginProps = _prev$pluginProps === void 0 ? {} : _prev$pluginProps;
+  var _prev$pluginProps$mat = _prev$pluginProps.math;
+  _prev$pluginProps$mat = _prev$pluginProps$mat === void 0 ? {} : _prev$pluginProps$mat;
+  var keypadMode = _prev$pluginProps$mat.keypadMode,
+      controlledKeypadMode = _prev$pluginProps$mat.controlledKeypadMode;
+  var nodeNext = next.node,
+      _next$pluginProps = next.pluginProps;
+  _next$pluginProps = _next$pluginProps === void 0 ? {} : _next$pluginProps;
+  var _next$pluginProps$mat = _next$pluginProps.math;
+  _next$pluginProps$mat = _next$pluginProps$mat === void 0 ? {} : _next$pluginProps$mat;
+  var keypadModeNext = _next$pluginProps$mat.keypadMode,
+      controlledKeypadModeNext = _next$pluginProps$mat.controlledKeypadMode;
+  var keypadModeChanged = keypadMode !== keypadModeNext;
+  var controlledKeypadModeChanged = controlledKeypadMode !== controlledKeypadModeNext;
+  var equal = node.equals(nodeNext);
+  return equal && !keypadModeChanged && !controlledKeypadModeChanged;
+});
+
+exports.CustomToolbarComp = CustomToolbarComp;
+CustomToolbarComp.propTypes = {
+  node: _slatePropTypes["default"].node.isRequired,
+  value: _slatePropTypes["default"].value,
+  onToolbarDone: _propTypes["default"].func,
+  onDataChange: _propTypes["default"].func,
+  onFocus: _propTypes["default"].func,
+  onClick: _propTypes["default"].func,
+  onBlur: _propTypes["default"].func
+};
+
+function MathPlugin(opts) {
+  MathPlugin.mathMlOptions = {
+    mmlOutput: opts.mmlOutput,
+    mmlEditing: opts.mmlEditing
+  };
+  return {
+    name: 'math',
+    toolbar: {
+      ariaLabel: 'Math Toolbar',
+      icon: /*#__PURE__*/_react["default"].createElement(_Functions["default"], null),
+      onClick: function onClick(value, onChange) {
+        log('[insertMath]');
+        var math = inlineMath();
+        var change = value.change().insertInline(math);
+        onChange(change);
+      },
+      supports: function supports(node) {
+        return node && node.object === 'inline' && node.type === 'math';
+      },
+
+      /**
+       * Return a react component function
+       * @param node {Slate.Node}
+       * @param value {Slate.Value}
+       * @param onDone {(change?: Slate.Change, finishEditing :boolea) => void} - a function to call once the toolbar
+       *   has made any changes, call with the node.key and a data object.
+       */
+      CustomToolbarComp: CustomToolbarComp
+    },
+    schema: {
+      document: {
+        match: [{
+          type: 'math'
+        }]
+      }
+    },
+    pluginStyles: function pluginStyles(node, parentNode, p) {
+      if (p) {
+        return {
+          position: 'absolute',
+          top: 'initial'
+        };
+      }
+    },
+    renderNode: function renderNode(props) {
+      if (props.node.type === 'math') {
+        log('[renderNode]: data:', props.node.data);
+        return /*#__PURE__*/_react["default"].createElement(_mathToolbar.MathPreview, props);
+      }
+      /**
+       * Here for rendering mathml content
+       */
+
+
+      if (props.node.type === 'mathml') {
+        var html = props.node.data.get('html');
+        return /*#__PURE__*/_react["default"].createElement("span", (0, _extends2["default"])({}, props.attributes, {
+          dangerouslySetInnerHTML: {
+            __html: html
+          }
+        }));
+      }
+    }
+  };
+}
+
+MathPlugin.ROUND_BRACKETS = 'round_brackets';
+MathPlugin.SQUARE_BRACKETS = 'square_brackets';
+MathPlugin.DOLLAR = 'dollar';
+MathPlugin.DOUBLE_DOLLAR = 'double_dollar';
+MathPlugin.mathMlOptions = {};
+MathPlugin.propTypes = {
+  attributes: _propTypes["default"].object,
+  node: _slatePropTypes["default"].node
+};
+
+var inlineMath = function inlineMath() {
+  return _slate.Inline.create({
+    object: 'inline',
+    type: 'math',
+    isVoid: true,
+    data: {
+      latex: ''
+    }
+  });
+};
+
+exports.inlineMath = inlineMath;
+
+var htmlDecode = function htmlDecode(input) {
+  var doc = new DOMParser().parseFromString(input, 'text/html');
+  return doc.documentElement.textContent;
+};
+
+var getTagName = function getTagName(el) {
+  return (el && el.tagName || '').toLowerCase();
+};
+/**
+ * Makes sure that strings that contain stuff like:
+ * x<y are not transformed into x by the DOMParser because it thinks
+ * that <y is the start of a dom element tag
+ * @param input
+ * @returns {*}
+ */
+
+
+var arrowHandlingCase = function arrowHandlingCase(input) {
+  /*
+  If we have a < character followed by a letter
+  we make sure to replace it with a &lt; sign instead
+   */
+  return input.replace(/<([a-zA-Z]*)/g, '&lt;$1');
+};
+
+function replaceLeftRight(latexInput) {
+  // for some reason, mmlToLatex parses () incorrectly - or at least in a way that our interpreter can not use them
+  // Replace '\\left.' and '\\right.' with an empty string
+  return latexInput.replace(/\\left\.\s*|\\right\.\s*/g, '');
+}
+
+var convertLatexToMathMl = function convertLatexToMathMl(_ref4) {
+  var latex = _ref4.latex,
+      decoded = _ref4.decoded,
+      wrapper = _ref4.wrapper;
+
+  var removeEmptyMos = function removeEmptyMos(mmlFromLatex) {
+    // Regular expression to match <mo>&#x2061;</mo> and <mo ...>&#x2061;</mo>, which get added when using log with base
+    // not sure why they get added, but they add an extra space which is not needed
+    var regex = /<mo(?: [^>]*)?>&#x2061;<\/mo>/g; // Replace all occurrences of the matched patterns
+
+    return mmlFromLatex.replace(regex, '');
+  };
+
+  var handled = arrowHandlingCase(decoded);
+  var latexToConvert = "<span data-latex=\"\" data-raw=\"".concat(handled, "\">").concat((0, _mathRendering.wrapMath)(handled, wrapper), "</span>"); // use math rendering (MathJax) to convert latex to mathMl
+
+  var mathMlFromLatex = (0, _mathRendering.renderMath)(latexToConvert, {
+    skipWaitForMathRenderingLib: true
+  }); // if renderMath returned the exact same string that we sent, it just means that the conversion could not be done
+
+  var conversionDidNotWork = (0, _isEqual["default"])(latexToConvert, mathMlFromLatex);
+  mathMlFromLatex = removeEmptyMos(mathMlFromLatex); // we convert resulted mathml to latex to check if the resulted mathMl can be converted back to latex if user wants to edit it later
+
+  var latexFromMathMl = mathMlFromLatex ? (0, _mathRendering.mmlToLatex)(mathMlFromLatex) : ''; // we need to remove all the spaces from the latex to be able to compare it
+
+  var strippedL = latex.replace(/\s/g, '');
+  var strippedNewL = latexFromMathMl.replace(/\s/g, ''); // we check if the latex keeps his form after being converted to mathml and back to latex
+  // if it does, we can safely convert it to mathml
+
+  if (!(0, _isEqual["default"])(strippedL, strippedNewL)) {
+    var correctedLatex = replaceLeftRight(latexFromMathMl); // As George requested in PD-3167, I will set the new mathML anyway, and also log differences
+    // if it doesn't, we keep the latex version
+    // eslint-disable-next-line no-console
+
+    console.log('This latex can not be safely converted to mathml so we will keep the latex version!!!', {
+      initialLatex: latex,
+      newLatex: latexFromMathMl,
+      correctedLatex: correctedLatex,
+      mathML: mathMlFromLatex,
+      conversionDidNotWork: conversionDidNotWork
+    });
+  }
+
+  return {
+    mathMlFromLatex: mathMlFromLatex,
+    conversionDidNotWork: conversionDidNotWork
+  };
+};
+
+var convertMathMlToLatex = function convertMathMlToLatex(mathMl) {
+  var htmlWithRemovedSpaces = mathMl.replaceAll('&nbsp;', ' ');
+  var htmlToUse = (0, _mathRendering.mmlToLatex)(htmlWithRemovedSpaces);
+  var latex = htmlDecode(htmlToUse); // todo fix this in mathml-to-latex
+
+  return replaceLeftRight(latex);
+};
+
+var serialization = {
+  deserialize: function deserialize(el) {
+    var tagName = getTagName(el);
+    /**
+     * This is used for when there's a wrapper over the mathml element.
+     * Because of this slate rule: "Only allow block nodes or inline and text nodes in blocks."
+     * The element that contains only the mathml is removed (along with the math) because it has
+     * an inline child and the block is of type block
+     * This is for legacy content only since our math rendering is valid for the core slate rules
+     */
+
+    var hasMathChild = _blockTags.BLOCK_TAGS[tagName] && el.childNodes.length === 1 && getTagName(el.firstChild) === 'math';
+    log('[deserialize] name: ', tagName);
+    /**
+     * This is here in order to be able to render mathml content
+     */
+
+    if (tagName === 'math' || el.dataset && el.dataset.type === 'mathml' || hasMathChild) {
+      var mathMl = hasMathChild ? el.innerHTML : el.outerHTML;
+
+      if (MathPlugin.mathMlOptions.mmlEditing) {
+        var _unWrapMath = (0, _mathRendering.unWrapMath)(convertMathMlToLatex(mathMl)),
+            unwrapped = _unWrapMath.unwrapped,
+            wrapType = _unWrapMath.wrapType;
+
+        return {
+          object: 'inline',
+          type: 'math',
+          isVoid: true,
+          nodes: [],
+          data: {
+            latex: unwrapped,
+            wrapper: wrapType
+          }
+        };
+      }
+
+      return {
+        object: 'inline',
+        isVoid: true,
+        type: 'mathml',
+        data: {
+          html: mathMl
+        }
+      };
+    }
+
+    if (el.nodeType === TEXT_NODE) {
+      return;
+    }
+
+    if (tagName !== 'span') {
+      return;
+    }
+
+    var hasLatex = el.hasAttribute('data-latex') || el.hasAttribute('latex');
+
+    if (hasLatex) {
+      var latex = htmlDecode(el.innerHTML);
+
+      var _unWrapMath2 = (0, _mathRendering.unWrapMath)(latex),
+          _unwrapped = _unWrapMath2.unwrapped,
+          _wrapType = _unWrapMath2.wrapType;
+
+      log('[deserialize]: noBrackets: ', _unwrapped, _wrapType);
+      return {
+        object: 'inline',
+        type: 'math',
+        isVoid: true,
+        nodes: [],
+        data: {
+          latex: _unwrapped,
+          wrapper: _wrapType
+        }
+      };
+    }
+  },
+  serialize: function serialize(object) {
+    if (object.type === 'math') {
+      var latex = object.data.get('latex');
+      var wrapper = object.data.get('wrapper');
+      var decoded = htmlDecode(arrowHandlingCase(latex));
+      log('[serialize] latex: ', latex);
+
+      if (MathPlugin.mathMlOptions.mmlOutput) {
+        var _convertLatexToMathMl = convertLatexToMathMl({
+          latex: latex,
+          decoded: decoded,
+          wrapper: wrapper
+        }),
+            mathMlFromLatex = _convertLatexToMathMl.mathMlFromLatex,
+            conversionDidNotWork = _convertLatexToMathMl.conversionDidNotWork;
+
+        if (conversionDidNotWork) {
+          // this means we could not convert latex to mathMl, so just return the latex version,
+          // same as we would do if mmlOutput would not be enabled
+          return /*#__PURE__*/_react["default"].createElement("span", {
+            "data-latex": "",
+            "data-raw": decoded
+          }, (0, _mathRendering.wrapMath)(decoded, wrapper));
+        }
+
+        return /*#__PURE__*/_react["default"].createElement("span", {
+          "data-type": "mathml",
+          dangerouslySetInnerHTML: {
+            __html: mathMlFromLatex
+          }
+        });
+      }
+
+      return /*#__PURE__*/_react["default"].createElement("span", {
+        "data-latex": "",
+        "data-raw": decoded
+      }, (0, _mathRendering.wrapMath)(decoded, wrapper));
+    }
+    /**
+     * Here for rendering mathml content
+     */
+
+
+    if (object.type === 'mathml') {
+      var html = object.data.get('html');
+      return /*#__PURE__*/_react["default"].createElement("span", {
+        "data-type": "mathml",
+        dangerouslySetInnerHTML: {
+          __html: html
+        }
+      });
+    }
+  }
+};
+exports.serialization = serialization;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/plugins/math/index.jsx"],"names":["log","TEXT_NODE","generateAdditionalKeys","keyData","map","key","name","latex","write","label","CustomToolbarComp","React","memo","props","node","value","onFocus","onBlur","onClick","pluginProps","math","keypadMode","customKeys","controlledKeypadMode","onDone","update","data","toObject","change","setNodeByKey","nextText","document","getNextText","moveFocusTo","moveAnchorTo","onToolbarDone","onChange","onDataChange","get","prev","next","nodeNext","keypadModeNext","controlledKeypadModeNext","keypadModeChanged","controlledKeypadModeChanged","equal","equals","propTypes","SlatePropTypes","isRequired","PropTypes","func","MathPlugin","opts","mathMlOptions","mmlOutput","mmlEditing","toolbar","ariaLabel","icon","inlineMath","insertInline","supports","object","type","schema","match","pluginStyles","parentNode","p","position","top","renderNode","html","attributes","__html","ROUND_BRACKETS","SQUARE_BRACKETS","DOLLAR","DOUBLE_DOLLAR","Inline","create","isVoid","htmlDecode","input","doc","DOMParser","parseFromString","documentElement","textContent","getTagName","el","tagName","toLowerCase","arrowHandlingCase","replace","replaceLeftRight","latexInput","convertLatexToMathMl","decoded","wrapper","removeEmptyMos","mmlFromLatex","regex","handled","latexToConvert","mathMlFromLatex","skipWaitForMathRenderingLib","conversionDidNotWork","latexFromMathMl","strippedL","strippedNewL","correctedLatex","console","initialLatex","newLatex","mathML","convertMathMlToLatex","mathMl","htmlWithRemovedSpaces","replaceAll","htmlToUse","serialization","deserialize","hasMathChild","BLOCK_TAGS","childNodes","length","firstChild","dataset","innerHTML","outerHTML","unwrapped","wrapType","nodes","nodeType","hasLatex","hasAttribute","serialize"],"mappings":"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","sourcesContent":["import Functions from '@material-ui/icons/Functions';\nimport { Inline } from 'slate';\nimport { MathPreview, MathToolbar } from '@pie-lib/math-toolbar';\nimport { wrapMath, unWrapMath, mmlToLatex, renderMath } from '@pie-lib/math-rendering';\nimport React from 'react';\nimport debug from 'debug';\nimport SlatePropTypes from 'slate-prop-types';\nimport PropTypes from 'prop-types';\n\nimport { BLOCK_TAGS } from '../../block-tags';\nimport isEqual from 'lodash/isEqual';\n\nconst log = debug('@pie-lib:editable-html:plugins:math');\n\nconst TEXT_NODE = 3;\n\nfunction generateAdditionalKeys(keyData = []) {\n  return keyData.map((key) => ({\n    name: key,\n    latex: key,\n    write: key,\n    label: key,\n  }));\n}\n\n// eslint-disable-next-line react/display-name\nexport const CustomToolbarComp = React.memo(\n  (props) => {\n    const { node, value, onFocus, onBlur, onClick } = props;\n    const { pluginProps } = props || {};\n    const { math } = pluginProps || {};\n    const { keypadMode, customKeys, controlledKeypadMode = true } = math || {};\n\n    const onDone = (latex) => {\n      const update = {\n        ...node.data.toObject(),\n        latex,\n      };\n\n      const change = value.change().setNodeByKey(node.key, { data: update });\n\n      const nextText = value.document.getNextText(node.key);\n\n      change.moveFocusTo(nextText.key, 0).moveAnchorTo(nextText.key, 0);\n\n      props.onToolbarDone(change, false);\n    };\n\n    const onChange = (latex) => {\n      const update = {\n        ...node.data.toObject(),\n        latex,\n      };\n      const change = value.change().setNodeByKey(node.key, { data: update });\n      log('call onToolbarChange:', change);\n      props.onDataChange(node.key, update);\n    };\n\n    const latex = node.data.get('latex');\n\n    return (\n      <MathToolbar\n        autoFocus\n        additionalKeys={generateAdditionalKeys(customKeys)}\n        latex={latex}\n        onChange={onChange}\n        onDone={onDone}\n        onBlur={onBlur}\n        onFocus={onFocus}\n        onClick={onClick}\n        keypadMode={keypadMode}\n        controlledKeypadMode={controlledKeypadMode}\n      />\n    );\n  },\n  (prev, next) => {\n    const { node, pluginProps: { math: { keypadMode, controlledKeypadMode } = {} } = {} } = prev;\n    const {\n      node: nodeNext,\n      pluginProps: { math: { keypadMode: keypadModeNext, controlledKeypadMode: controlledKeypadModeNext } = {} } = {},\n    } = next;\n    const keypadModeChanged = keypadMode !== keypadModeNext;\n    const controlledKeypadModeChanged = controlledKeypadMode !== controlledKeypadModeNext;\n\n    const equal = node.equals(nodeNext);\n    return equal && !keypadModeChanged && !controlledKeypadModeChanged;\n  },\n);\n\nCustomToolbarComp.propTypes = {\n  node: SlatePropTypes.node.isRequired,\n  value: SlatePropTypes.value,\n  onToolbarDone: PropTypes.func,\n  onDataChange: PropTypes.func,\n  onFocus: PropTypes.func,\n  onClick: PropTypes.func,\n  onBlur: PropTypes.func,\n};\n\nexport default function MathPlugin(opts) {\n  MathPlugin.mathMlOptions = {\n    mmlOutput: opts.mmlOutput,\n    mmlEditing: opts.mmlEditing,\n  };\n\n  return {\n    name: 'math',\n    toolbar: {\n      ariaLabel: 'Math Toolbar',\n      icon: <Functions />,\n      onClick: (value, onChange) => {\n        log('[insertMath]');\n        const math = inlineMath();\n        const change = value.change().insertInline(math);\n        onChange(change);\n      },\n      supports: (node) => node && node.object === 'inline' && node.type === 'math',\n      /**\n       * Return a react component function\n       * @param node {Slate.Node}\n       * @param value {Slate.Value}\n       * @param onDone {(change?: Slate.Change, finishEditing :boolea) => void} - a function to call once the toolbar\n       *   has made any changes, call with the node.key and a data object.\n       */\n      CustomToolbarComp,\n    },\n    schema: {\n      document: { match: [{ type: 'math' }] },\n    },\n\n    pluginStyles: (node, parentNode, p) => {\n      if (p) {\n        return {\n          position: 'absolute',\n          top: 'initial',\n        };\n      }\n    },\n\n    renderNode: (props) => {\n      if (props.node.type === 'math') {\n        log('[renderNode]: data:', props.node.data);\n        return <MathPreview {...props} />;\n      }\n\n      /**\n       * Here for rendering mathml content\n       */\n      if (props.node.type === 'mathml') {\n        const html = props.node.data.get('html');\n\n        return <span {...props.attributes} dangerouslySetInnerHTML={{ __html: html }} />;\n      }\n    },\n  };\n}\n\nMathPlugin.ROUND_BRACKETS = 'round_brackets';\nMathPlugin.SQUARE_BRACKETS = 'square_brackets';\nMathPlugin.DOLLAR = 'dollar';\nMathPlugin.DOUBLE_DOLLAR = 'double_dollar';\nMathPlugin.mathMlOptions = {};\n\nMathPlugin.propTypes = {\n  attributes: PropTypes.object,\n  node: SlatePropTypes.node,\n};\n\nexport const inlineMath = () =>\n  Inline.create({\n    object: 'inline',\n    type: 'math',\n    isVoid: true,\n    data: {\n      latex: '',\n    },\n  });\n\nconst htmlDecode = (input) => {\n  const doc = new DOMParser().parseFromString(input, 'text/html');\n\n  return doc.documentElement.textContent;\n};\n\nconst getTagName = (el) => {\n  return ((el && el.tagName) || '').toLowerCase();\n};\n\n/**\n * Makes sure that strings that contain stuff like:\n * x<y are not transformed into x by the DOMParser because it thinks\n * that <y is the start of a dom element tag\n * @param input\n * @returns {*}\n */\nconst arrowHandlingCase = (input) => {\n  /*\n  If we have a < character followed by a letter\n  we make sure to replace it with a &lt; sign instead\n   */\n  return input.replace(/<([a-zA-Z]*)/g, '&lt;$1');\n};\n\nfunction replaceLeftRight(latexInput) {\n  // for some reason, mmlToLatex parses () incorrectly - or at least in a way that our interpreter can not use them\n  // Replace '\\\\left.' and '\\\\right.' with an empty string\n  return latexInput.replace(/\\\\left\\.\\s*|\\\\right\\.\\s*/g, '');\n}\n\nconst convertLatexToMathMl = ({ latex, decoded, wrapper }) => {\n  const removeEmptyMos = (mmlFromLatex) => {\n    // Regular expression to match <mo>&#x2061;</mo> and <mo ...>&#x2061;</mo>, which get added when using log with base\n    // not sure why they get added, but they add an extra space which is not needed\n    const regex = /<mo(?: [^>]*)?>&#x2061;<\\/mo>/g;\n\n    // Replace all occurrences of the matched patterns\n    return mmlFromLatex.replace(regex, '');\n  };\n  const handled = arrowHandlingCase(decoded);\n\n  const latexToConvert = `<span data-latex=\"\" data-raw=\"${handled}\">${wrapMath(handled, wrapper)}</span>`;\n\n  // use math rendering (MathJax) to convert latex to mathMl\n  let mathMlFromLatex = renderMath(latexToConvert, {\n    skipWaitForMathRenderingLib: true,\n  });\n\n  // if renderMath returned the exact same string that we sent, it just means that the conversion could not be done\n  const conversionDidNotWork = isEqual(latexToConvert, mathMlFromLatex);\n\n  mathMlFromLatex = removeEmptyMos(mathMlFromLatex);\n\n  // we convert resulted mathml to latex to check if the resulted mathMl can be converted back to latex if user wants to edit it later\n  const latexFromMathMl = mathMlFromLatex ? mmlToLatex(mathMlFromLatex) : '';\n\n  // we need to remove all the spaces from the latex to be able to compare it\n  const strippedL = latex.replace(/\\s/g, '');\n  const strippedNewL = latexFromMathMl.replace(/\\s/g, '');\n\n  // we check if the latex keeps his form after being converted to mathml and back to latex\n  // if it does, we can safely convert it to mathml\n  if (!isEqual(strippedL, strippedNewL)) {\n    const correctedLatex = replaceLeftRight(latexFromMathMl);\n\n    // As George requested in PD-3167, I will set the new mathML anyway, and also log differences\n    // if it doesn't, we keep the latex version\n    // eslint-disable-next-line no-console\n    console.log('This latex can not be safely converted to mathml so we will keep the latex version!!!', {\n      initialLatex: latex,\n      newLatex: latexFromMathMl,\n      correctedLatex,\n      mathML: mathMlFromLatex,\n      conversionDidNotWork,\n    });\n  }\n\n  return { mathMlFromLatex, conversionDidNotWork };\n};\n\nconst convertMathMlToLatex = (mathMl) => {\n  const htmlWithRemovedSpaces = mathMl.replaceAll('&nbsp;', ' ');\n  const htmlToUse = mmlToLatex(htmlWithRemovedSpaces);\n  const latex = htmlDecode(htmlToUse);\n\n  // todo fix this in mathml-to-latex\n  return replaceLeftRight(latex);\n};\n\nexport const serialization = {\n  deserialize(el) {\n    const tagName = getTagName(el);\n    /**\n     * This is used for when there's a wrapper over the mathml element.\n     * Because of this slate rule: \"Only allow block nodes or inline and text nodes in blocks.\"\n     * The element that contains only the mathml is removed (along with the math) because it has\n     * an inline child and the block is of type block\n     * This is for legacy content only since our math rendering is valid for the core slate rules\n     */\n    const hasMathChild = BLOCK_TAGS[tagName] && el.childNodes.length === 1 && getTagName(el.firstChild) === 'math';\n    log('[deserialize] name: ', tagName);\n\n    /**\n     * This is here in order to be able to render mathml content\n     */\n    if (tagName === 'math' || (el.dataset && el.dataset.type === 'mathml') || hasMathChild) {\n      const mathMl = hasMathChild ? el.innerHTML : el.outerHTML;\n\n      if (MathPlugin.mathMlOptions.mmlEditing) {\n        const { unwrapped, wrapType } = unWrapMath(convertMathMlToLatex(mathMl));\n\n        return {\n          object: 'inline',\n          type: 'math',\n          isVoid: true,\n          nodes: [],\n          data: {\n            latex: unwrapped,\n            wrapper: wrapType,\n          },\n        };\n      }\n\n      return {\n        object: 'inline',\n        isVoid: true,\n        type: 'mathml',\n        data: {\n          html: mathMl,\n        },\n      };\n    }\n\n    if (el.nodeType === TEXT_NODE) {\n      return;\n    }\n\n    if (tagName !== 'span') {\n      return;\n    }\n\n    const hasLatex = el.hasAttribute('data-latex') || el.hasAttribute('latex');\n\n    if (hasLatex) {\n      const latex = htmlDecode(el.innerHTML);\n      const { unwrapped, wrapType } = unWrapMath(latex);\n      log('[deserialize]: noBrackets: ', unwrapped, wrapType);\n      return {\n        object: 'inline',\n        type: 'math',\n        isVoid: true,\n        nodes: [],\n        data: {\n          latex: unwrapped,\n          wrapper: wrapType,\n        },\n      };\n    }\n  },\n  serialize(object) {\n    if (object.type === 'math') {\n      const latex = object.data.get('latex');\n      const wrapper = object.data.get('wrapper');\n      const decoded = htmlDecode(arrowHandlingCase(latex));\n\n      log('[serialize] latex: ', latex);\n\n      if (MathPlugin.mathMlOptions.mmlOutput) {\n        const { mathMlFromLatex, conversionDidNotWork } = convertLatexToMathMl({ latex, decoded, wrapper });\n\n        if (conversionDidNotWork) {\n          // this means we could not convert latex to mathMl, so just return the latex version,\n          // same as we would do if mmlOutput would not be enabled\n          return (\n            <span data-latex=\"\" data-raw={decoded}>\n              {wrapMath(decoded, wrapper)}\n            </span>\n          );\n        }\n\n        return <span data-type=\"mathml\" dangerouslySetInnerHTML={{ __html: mathMlFromLatex }} />;\n      }\n\n      return (\n        <span data-latex=\"\" data-raw={decoded}>\n          {wrapMath(decoded, wrapper)}\n        </span>\n      );\n    }\n\n    /**\n     * Here for rendering mathml content\n     */\n    if (object.type === 'mathml') {\n      const html = object.data.get('html');\n\n      return <span data-type=\"mathml\" dangerouslySetInnerHTML={{ __html: html }} />;\n    }\n  },\n};\n"]}

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

@@ -0,0 +1,71 @@
+"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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