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

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":";;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;AACAA,IAAI,CAACC,IAAL,CAAU,0BAAV,EAAsC;AAAA,SAAO;AAC3CC,IAAAA,UAAU,EAAEF,IAAI,CAACG,EAAL,EAD+B;AAE3CC,IAAAA,YAAY,EAAEJ,IAAI,CAACG,EAAL,GAAUE,cAAV,EAF6B;AAG3CC,IAAAA,aAAa,EAAEN,IAAI,CAACG,EAAL;AAH4B,GAAP;AAAA,CAAtC;AAMAH,IAAI,CAACC,IAAL,CAAU,uBAAV,EAAmC;AAAA,SAAO;AACxCM,IAAAA,WAAW,EAAE;AAAA,0BAAM,4CAAN;AAAA,KAD2B;AAExCC,IAAAA,WAAW,EAAE;AAAA,0BAAM,4CAAN;AAAA;AAF2B,GAAP;AAAA,CAAnC;AAKAR,IAAI,CAACC,IAAL,CAAU,yBAAV,EAAqC;AAAA,yCAChCD,IAAI,CAACS,aAAL,CAAmB,yBAAnB,CADgC;AAEnCC,IAAAA,UAAU,EAAEV,IAAI,CAACG,EAAL,CAAQ,YAAM;AACxB,aAAO,eAAP;AACD,KAFW;AAFuB;AAAA,CAArC;AAMA,IAAMQ,GAAG,GAAG,uBAAM,kCAAN,CAAZ,C,CAEA;;AACAC,QAAQ,CAAC,YAAD,EAAe,YAAM;AAC3BA,EAAAA,QAAQ,CAAC,SAAD,EAAY,YAAM;AACxBA,IAAAA,QAAQ,CAAC,SAAD,EAAY,YAAM;AACxB,UAAIC,MAAJ,EAAYC,UAAZ,EAAwBC,KAAxB,EAA+BC,QAA/B;AACAC,MAAAA,UAAU,CAAC,YAAM;AACfJ,QAAAA,MAAM,GAAG,uBAAW,EAAX,CAAT;AACAC,QAAAA,UAAU,GAAG,IAAII,sBAAJ,EAAb;AACAH,QAAAA,KAAK,GAAG;AACNI,UAAAA,MAAM,EAAEnB,IAAI,CAACG,EAAL,CAAQ;AAAA,mBAAMW,UAAN;AAAA,WAAR;AADF,SAAR;AAGAE,QAAAA,QAAQ,GAAGhB,IAAI,CAACG,EAAL,EAAX;AACAU,QAAAA,MAAM,CAACO,OAAP,CAAeC,OAAf,CAAuBN,KAAvB,EAA8BC,QAA9B;AACD,OARS,CAAV;AAUAM,MAAAA,IAAI,CAAC,oBAAD,EAAuB,YAAM;AAC/BC,QAAAA,MAAM,CAACT,UAAU,CAACU,YAAZ,CAAN,CAAgCC,cAAhC,CAA+CF,MAAM,CAACG,gBAAP,CAAwB;AAAEC,UAAAA,IAAI,EAAE,yBAAaA;AAArB,SAAxB,CAA/C;AACD,OAFG,CAAJ;AAIAL,MAAAA,IAAI,CAAC,mBAAD,EAAsB,YAAM;AAC9BC,QAAAA,MAAM,CAACP,QAAD,CAAN,CAAiBY,oBAAjB,CAAsCd,UAAtC;AACD,OAFG,CAAJ;AAGD,KAnBO,CAAR;AAoBD,GArBO,CAAR;AAuBAF,EAAAA,QAAQ,CAAC,YAAD,EAAe,YAAM;AAC3BU,IAAAA,IAAI,CAAC,yBAAD,EAA4B,YAAM;AACpC,UAAMT,MAAM,GAAG,uBAAW,EAAX,CAAf;;AACA,+BAAkBA,MAAM,CAACgB,UAAP,CAAkB;AAAEC,QAAAA,IAAI,EAAE;AAAEC,UAAAA,IAAI,EAAE;AAAR;AAAR,OAAlB,CAAlB;AAAA,UAAQC,KAAR,sBAAQA,KAAR;;AACAT,MAAAA,MAAM,CAACS,KAAK,CAACF,IAAP,CAAN,CAAmBG,OAAnB,CAA2B;AAAEF,QAAAA,IAAI,EAAE;AAAR,OAA3B;AACD,KAJG,CAAJ;AAKD,GANO,CAAR;AAQAnB,EAAAA,QAAQ,CAAC,eAAD,EAAkB,YAAM;AAC9BA,IAAAA,QAAQ,CAAC,aAAD,EAAgB,YAAM;AAC5B,UAAMsB,iBAAiB,GAAG,SAApBA,iBAAoB,CAACC,IAAD,EAAOC,QAAP,EAAiBC,QAAjB,EAA8B;AACtDC,QAAAA,EAAE,sBAAeH,IAAf,kCAA2CC,QAA3C,6BAAsEC,QAAtE,GAAkF,YAAM;AACxF,cAAME,EAAE,GAAG;AACTC,YAAAA,OAAO,EAAE,MADA;AAETC,YAAAA,UAAU,EAAE,EAFH;AAGTC,YAAAA,YAAY,EAAE1C,IAAI,CAACG,EAAL,CAAQ;AAAA,qBAAM,EAAN;AAAA,aAAR,CAHL;AAITwC,YAAAA,YAAY,EAAE3C,IAAI,CAACG,EAAL,CAAQ;AAAA,qBAAM,IAAN;AAAA,aAAR,CAJL;AAKTyC,YAAAA,SAAS,EAAET;AALF,WAAX;AAOA,cAAMU,IAAI,GAAG7C,IAAI,CAACG,EAAL,EAAb;;AAEA,cAAM2C,GAAG,GAAGC,qBAAcC,WAAd,CAA0BT,EAA1B,EAA8BM,IAA9B,CAAZ;;AACAtB,UAAAA,MAAM,CAACuB,GAAD,CAAN,CAAYb,OAAZ,CAAoB;AAClBgB,YAAAA,MAAM,EAAE,QADU;AAElBlB,YAAAA,IAAI,EAAE,MAFY;AAGlBmB,YAAAA,MAAM,EAAE,IAHU;AAIlBC,YAAAA,KAAK,EAAE,EAJW;AAKlBxB,YAAAA,IAAI,EAAE;AACJyB,cAAAA,KAAK,EAAEhB,QADH;AAEJiB,cAAAA,OAAO,EAAEhB;AAFL;AALY,WAApB;AAUD,SArBC,CAAF;AAsBD,OAvBD;;AAyBAH,MAAAA,iBAAiB,CAAC,UAAD,EAAa,GAAb,EAAkBoB,kBAAWC,MAA7B,CAAjB;AACArB,MAAAA,iBAAiB,CAAC,QAAD,EAAW,GAAX,EAAgBoB,kBAAWC,MAA3B,CAAjB;AACArB,MAAAA,iBAAiB,CAAC,YAAD,EAAe,GAAf,EAAoBoB,kBAAWE,cAA/B,CAAjB;AACAtB,MAAAA,iBAAiB,CAAC,YAAD,EAAe,GAAf,EAAoBoB,kBAAWE,cAA/B,CAAjB;AACAtB,MAAAA,iBAAiB,CAAC,OAAD,EAAU,OAAV,EAAmBoB,kBAAWE,cAA9B,CAAjB;AACAtB,MAAAA,iBAAiB,CAAC,oBAAD,EAAuB,KAAvB,EAA8BoB,kBAAWE,cAAzC,CAAjB;AAEAlB,MAAAA,EAAE,CAAC,4EAAD,EAA+E,YAAM;AACrFgB,0BAAWG,aAAX,CAAyBC,UAAzB,GAAsC,IAAtC;AACA,YAAMnB,EAAE,GAAG;AACTC,UAAAA,OAAO,EAAE,MADA;AAETmB,UAAAA,SAAS,EACP;AAHO,SAAX;AAKA,YAAMd,IAAI,GAAG7C,IAAI,CAACG,EAAL,EAAb;;AAEA,YAAM2C,GAAG,GAAGC,qBAAcC,WAAd,CAA0BT,EAA1B,EAA8BM,IAA9B,CAAZ;;AAEAtB,QAAAA,MAAM,CAACuB,GAAD,CAAN,CAAYb,OAAZ,CAAoB;AAClBgB,UAAAA,MAAM,EAAE,QADU;AAElBlB,UAAAA,IAAI,EAAE,MAFY;AAGlBmB,UAAAA,MAAM,EAAE,IAHU;AAIlBC,UAAAA,KAAK,EAAE,EAJW;AAKlBxB,UAAAA,IAAI,EAAE;AACJyB,YAAAA,KAAK,EAAE,eADH;AAEJC,YAAAA,OAAO,EAAE;AAFL;AALY,SAApB;AAUD,OArBC,CAAF;AAuBAf,MAAAA,EAAE,CAAC,6EAAD,EAAgF,YAAM;AACtFgB,0BAAWG,aAAX,CAAyBC,UAAzB,GAAsC,KAAtC;AACA,YAAMnB,EAAE,GAAG;AACTC,UAAAA,OAAO,EAAE,MADA;AAETmB,UAAAA,SAAS,EACP;AAHO,SAAX;AAKA,YAAMd,IAAI,GAAG7C,IAAI,CAACG,EAAL,EAAb;;AAEA,YAAM2C,GAAG,GAAGC,qBAAcC,WAAd,CAA0BT,EAA1B,EAA8BM,IAA9B,CAAZ;;AAEAtB,QAAAA,MAAM,CAACuB,GAAD,CAAN,CAAYb,OAAZ,CAAoB;AAClBgB,UAAAA,MAAM,EAAE,QADU;AAElBC,UAAAA,MAAM,EAAE,IAFU;AAGlBnB,UAAAA,IAAI,EAAE,QAHY;AAIlBJ,UAAAA,IAAI,EAAE;AACJQ,YAAAA,IAAI,EAAEI,EAAE,CAACoB;AADL;AAJY,SAApB;AAQD,OAnBC,CAAF;AAoBD,KA5EO,CAAR;AA8EA/C,IAAAA,QAAQ,CAAC,WAAD,EAAc,YAAM;AAC1B,UAAMgD,eAAe,GAAG,SAAlBA,eAAkB,CAACR,KAAD,EAAQS,YAAR,EAAsBR,OAAtB,EAAkC;AACxDA,QAAAA,OAAO,GAAGA,OAAO,IAAIC,kBAAWE,cAAhC;AACAlB,QAAAA,EAAE,WAAIc,KAAJ,gCAA+BS,YAA/B,GAA+C,YAAM;AACrD,cAAMZ,MAAM,GAAG;AACba,YAAAA,IAAI,EAAE,QADO;AAEb/B,YAAAA,IAAI,EAAE,MAFO;AAGbmB,YAAAA,MAAM,EAAE,IAHK;AAIbC,YAAAA,KAAK,EAAE,EAJM;AAKbxB,YAAAA,IAAI,EAAEoC,YAAKC,MAAL,CAAY;AAAEZ,cAAAA,KAAK,EAALA,KAAF;AAASC,cAAAA,OAAO,EAAPA;AAAT,aAAZ;AALO,WAAf;AAOA,cAAMY,QAAQ,GAAG,EAAjB;;AAEA,cAAMnB,GAAG,GAAGC,qBAAcmB,SAAd,CAAwBjB,MAAxB,EAAgCgB,QAAhC,CAAZ;;AACAtD,UAAAA,GAAG,CAAC,OAAD,EAAUmC,GAAV,CAAH;AACAvB,UAAAA,MAAM,CAACuB,GAAD,CAAN,CAAYb,OAAZ,eACE;AAAM,0BAAW,EAAjB;AAAoB,wBAAUmB;AAA9B,aACGS,YADH,CADF;AAKD,SAjBC,CAAF;AAkBD,OApBD;;AAsBAD,MAAAA,eAAe,CAAC,OAAD,EAAU,aAAV,EAAyBN,kBAAWE,cAApC,CAAf;AACAI,MAAAA,eAAe,CAAC,OAAD,EAAU,aAAV,EAAyBN,kBAAWa,eAApC,CAAf;AACAP,MAAAA,eAAe,CAAC,OAAD,EAAU,SAAV,EAAqBN,kBAAWC,MAAhC,CAAf;AACAK,MAAAA,eAAe,CAAC,OAAD,EAAU,SAAV,EAAqBN,kBAAWc,aAAhC,CAAf;AAEA;AACN;AACA;;AACMR,MAAAA,eAAe,CAAC,GAAD,EAAM,SAAN,CAAf;AACAA,MAAAA,eAAe,CAAC,KAAD,EAAQ,WAAR,CAAf;AACD,KAjCO,CAAR;AAkCD,GAjHO,CAAR;AAkHD,CAlJO,CAAR;AAoJAhD,QAAQ,CAAC,mBAAD,EAAsB,YAAM;AAClC,MAAIyD,YAAJ;AACA,MAAIC,aAAJ;;AAEA,MAAMjB,OAAO,GAAG,SAAVA,OAAU,CAACkB,MAAD,EAAY;AAC1B,QAAIzD,UAAU,GAAG,IAAII,sBAAJ,EAAjB;AACA,QAAMsD,QAAQ,GAAG;AACf1C,MAAAA,IAAI,EAAE;AACJ2C,QAAAA,GAAG,EAAE,GADD;AAEJ9C,QAAAA,IAAI,EAAEoC,YAAKC,MAAL,CAAY;AAAEZ,UAAAA,KAAK,EAAE;AAAT,SAAZ,CAFF;AAGJsB,QAAAA,MAAM,EAAE;AAAA,iBAAM,IAAN;AAAA;AAHJ,OADS;AAMf3D,MAAAA,KAAK,EAAE;AACL4D,QAAAA,QAAQ,EAAE;AACRC,UAAAA,WAAW,EAAE5E,IAAI,CAACG,EAAL,GAAU0E,eAAV,CAA0B;AAAEJ,YAAAA,GAAG,EAAE;AAAP,WAA1B;AADL,SADL;AAILtD,QAAAA,MAAM,EAAEnB,IAAI,CAACG,EAAL,GAAU0E,eAAV,CAA0B/D,UAA1B;AAJH,OANQ;AAYfuD,MAAAA,YAAY,EAAZA,YAZe;AAafC,MAAAA,aAAa,EAAbA;AAbe,KAAjB;;AAgBA,QAAMtC,KAAK,mCACNwC,QADM,GAEND,MAFM,CAAX;;AAKA,WAAO,mCAAQ,gCAAC,wBAAD,EAAuBvC,KAAvB,CAAR,CAAP;AACD,GAxBD;;AA0BApB,EAAAA,QAAQ,CAAC,QAAD,EAAW,YAAM;AACvB0B,IAAAA,EAAE,CAAC,oCAAD,EAAuC,YAAM;AAC7C,UAAMwC,CAAC,GAAGzB,OAAO,EAAjB;AAEA9B,MAAAA,MAAM,CAACuD,CAAD,CAAN,CAAUC,eAAV;AAEAD,MAAAA,CAAC,CAACE,QAAF,CAAW;AAAEC,QAAAA,WAAW,EAAE;AAAEC,UAAAA,IAAI,EAAE;AAAEC,YAAAA,UAAU,EAAE;AAAd;AAAR;AAAf,OAAX;AAEA5D,MAAAA,MAAM,CAACuD,CAAD,CAAN,CAAUC,eAAV;AACD,KARC,CAAF;AAUAzC,IAAAA,EAAE,CAAC,iCAAD,EAAoC,YAAM;AAC1C,UAAMwC,CAAC,GAAGzB,OAAO,CAAC;AAAE4B,QAAAA,WAAW,EAAE;AAAEC,UAAAA,IAAI,EAAE;AAAEC,YAAAA,UAAU,EAAE;AAAd;AAAR;AAAf,OAAD,CAAjB;AAEA5D,MAAAA,MAAM,CAACuD,CAAD,CAAN,CAAUC,eAAV;AAEAD,MAAAA,CAAC,CAACE,QAAF,CAAW;AAAEC,QAAAA,WAAW,EAAE;AAAEC,UAAAA,IAAI,EAAE;AAAEC,YAAAA,UAAU,EAAE;AAAd;AAAR;AAAf,OAAX;AAEA5D,MAAAA,MAAM,CAACuD,CAAD,CAAN,CAAUC,eAAV;AACD,KARC,CAAF;AASD,GApBO,CAAR;AAsBAnE,EAAAA,QAAQ,CAAC,QAAD,EAAW,YAAM;AACvB0B,IAAAA,EAAE,CAAC,qBAAD,EAAwB,YAAM;AAC9BgC,MAAAA,aAAa,GAAGtE,IAAI,CAACG,EAAL,EAAhB;AACA,UAAM2E,CAAC,GAAGzB,OAAO,EAAjB;AACAyB,MAAAA,CAAC,CAACM,IAAF,CAAO5E,wBAAP,EAAoB6E,IAApB,CAAyB,QAAzB,EAAmC,IAAnC;AACA9D,MAAAA,MAAM,CAAC+C,aAAD,CAAN,CAAsB1C,oBAAtB,CAA2CL,MAAM,CAAC+D,QAAP,EAA3C,EAA8D,KAA9D;AACD,KALC,CAAF;AAMD,GAPO,CAAR;AASA1E,EAAAA,QAAQ,CAAC,UAAD,EAAa,YAAM;AACzB0B,IAAAA,EAAE,CAAC,oBAAD,EAAuB,YAAM;AAC7B+B,MAAAA,YAAY,GAAGrE,IAAI,CAACG,EAAL,EAAf;AACA,UAAM2E,CAAC,GAAGzB,OAAO,EAAjB;AACAyB,MAAAA,CAAC,CAACM,IAAF,CAAO5E,wBAAP,EAAoB6E,IAApB,CAAyB,UAAzB,EAAqC,IAArC;AACA9D,MAAAA,MAAM,CAAC8C,YAAD,CAAN,CAAqBzC,oBAArB,CAA0C,GAA1C,EAA+C;AAAEwB,QAAAA,KAAK,EAAE;AAAT,OAA/C;AACD,KALC,CAAF;AAMD,GAPO,CAAR;AAQD,CArEO,CAAR","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"]}