@pie-lib/math-input-mathlive 1.1.5-beta.11 → 1.1.5-beta.13

package/lib/__tests__/longdiv-wiring.test.js

@@ -0,0 +1,215 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _input = _interopRequireDefault(require("../mf/input"));
+var _static = _interopRequireDefault(require("../mf/static"));
+var _keypad = require("../keypad");
+var _longdiv = require("../longdiv");
+/**
+ * Every place that draws MathLive output must apply the long-division
+ * correction (see longdiv.js): live fields after every render, static markup
+ * after it is written into the DOM.
+ */
+jest.mock('../mathlive-instance', function () {
+  var FakeMathfieldElement = /*#__PURE__*/(0, _createClass2["default"])(function FakeMathfieldElement() {
+    (0, _classCallCheck2["default"])(this, FakeMathfieldElement);
+    var el = global.document.createElement('math-field');
+    el.value = '';
+    el.getValue = function () {
+      return el.value;
+    };
+    return el;
+  });
+  return {
+    loadMathLive: function loadMathLive() {
+      return Promise.resolve({
+        MathfieldElement: FakeMathfieldElement
+      });
+    },
+    getMacros: function getMacros() {
+      return {};
+    },
+    MATH_MODE_SPACE: '\\ ',
+    applyShadowStyles: function applyShadowStyles() {},
+    trackPlaceholderCaret: function trackPlaceholderCaret() {
+      return function () {};
+    },
+    latexToMarkup: function latexToMarkup(l) {
+      return "<span>".concat(l, "</span>");
+    }
+  };
+});
+var mockUntrack = jest.fn();
+jest.mock('../longdiv', function () {
+  return {
+    trackLongDivision: jest.fn(function () {
+      return mockUntrack;
+    }),
+    fixLongDivisionWhenReady: jest.fn(),
+    fixLongDivision: jest.fn()
+  };
+});
+
+/* eslint-disable import/first */
+
+/* eslint-enable import/first */
+
+beforeEach(function () {
+  _longdiv.trackLongDivision.mockClear();
+  _longdiv.fixLongDivisionWhenReady.mockClear();
+  mockUntrack.mockClear();
+});
+describe('Input (the editor)', function () {
+  it('tracks the mathfield on mount and stops on unmount', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var input;
+    return _regenerator["default"].wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          input = new _input["default"]({});
+          input.holderRef = {
+            current: document.createElement('span')
+          };
+          _context.next = 1;
+          return input.componentDidMount();
+        case 1:
+          expect(_longdiv.trackLongDivision).toHaveBeenCalledWith(input.mathField);
+          input.componentWillUnmount();
+          expect(mockUntrack).toHaveBeenCalledTimes(1);
+          expect(input.untrackLongDivision).toBeUndefined();
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+});
+describe('Static', function () {
+  it('tracks the answer-block field on mount and stops on unmount', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+    var s;
+    return _regenerator["default"].wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          s = new _static["default"]({
+            latex: 'x=\\MathQuillMathField[r1]{}'
+          });
+          s.holderRef = {
+            current: document.createElement('span')
+          };
+          s.createLiveRegion = function () {};
+          _context2.next = 1;
+          return s.componentDidMount();
+        case 1:
+          expect(_longdiv.trackLongDivision).toHaveBeenCalledWith(s.mathField);
+          s.componentWillUnmount();
+          expect(mockUntrack).toHaveBeenCalledTimes(1);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+
+  // Display mode: the markup reaches the DOM through state, so it is corrected
+  // once React has written it.
+  it('corrects static markup after it is rendered', function () {
+    var s = new _static["default"]({
+      latex: '5\\longdiv{144}'
+    });
+    var holder = document.createElement('span');
+    s.holderRef = {
+      current: holder
+    };
+    s.state = {
+      markup: '<span>new</span>'
+    };
+    s.componentDidUpdate({
+      latex: '5\\longdiv{144}'
+    }, {
+      markup: ''
+    });
+    expect(_longdiv.fixLongDivisionWhenReady).toHaveBeenCalledWith(holder);
+  });
+  it('does not redo it when the markup did not change', function () {
+    var s = new _static["default"]({
+      latex: 'x'
+    });
+    s.holderRef = {
+      current: document.createElement('span')
+    };
+    s.state = {
+      markup: '<span>same</span>'
+    };
+    s.componentDidUpdate({
+      latex: 'x'
+    }, {
+      markup: '<span>same</span>'
+    });
+    expect(_longdiv.fixLongDivisionWhenReady).not.toHaveBeenCalled();
+  });
+  it('leaves a live field to the tracker', function () {
+    var s = new _static["default"]({
+      latex: 'x'
+    });
+    s.holderRef = {
+      current: document.createElement('span')
+    };
+    s.mathField = document.createElement('math-field');
+    s.state = {
+      markup: '<span>new</span>'
+    };
+    s.componentDidUpdate({
+      latex: 'x'
+    }, {
+      markup: ''
+    });
+    expect(_longdiv.fixLongDivisionWhenReady).not.toHaveBeenCalled();
+  });
+});
+describe('keypad label', function () {
+  it('corrects the label once mounted', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+    var label, el;
+    return _regenerator["default"].wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          label = new _keypad.LatexLabel({
+            latex: '\\longdiv{}'
+          });
+          el = document.createElement('span');
+          label.labelRef = {
+            current: el
+          };
+          _context3.next = 1;
+          return label.componentDidMount();
+        case 1:
+          expect(_longdiv.fixLongDivisionWhenReady).toHaveBeenCalledWith(el);
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('corrects it again when the label changes', function () {
+    var label = new _keypad.LatexLabel({
+      latex: '\\longdiv{}'
+    });
+    var el = document.createElement('span');
+    label.labelRef = {
+      current: el
+    };
+    label.setState = function () {};
+    label.state = {
+      markup: '<span>other</span>'
+    };
+    label.componentDidUpdate({
+      latex: '\\longdiv{}'
+    }, {
+      markup: '<span>first</span>'
+    });
+    expect(_longdiv.fixLongDivisionWhenReady).toHaveBeenCalledWith(el);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_input","_interopRequireDefault","require","_static","_keypad","_longdiv","jest","mock","FakeMathfieldElement","_createClass2","_classCallCheck2","el","global","document","createElement","value","getValue","loadMathLive","Promise","resolve","MathfieldElement","getMacros","MATH_MODE_SPACE","applyShadowStyles","trackPlaceholderCaret","latexToMarkup","l","concat","mockUntrack","fn","trackLongDivision","fixLongDivisionWhenReady","fixLongDivision","beforeEach","mockClear","describe","it","_asyncToGenerator2","_regenerator","mark","_callee","input","wrap","_context","prev","next","Input","holderRef","current","componentDidMount","expect","toHaveBeenCalledWith","mathField","componentWillUnmount","toHaveBeenCalledTimes","untrackLongDivision","toBeUndefined","stop","_callee2","s","_context2","Static","latex","createLiveRegion","holder","state","markup","componentDidUpdate","not","toHaveBeenCalled","_callee3","label","_context3","LatexLabel","labelRef","setState"],"sources":["../../src/__tests__/longdiv-wiring.test.jsx"],"sourcesContent":["/**\n * Every place that draws MathLive output must apply the long-division\n * correction (see longdiv.js): live fields after every render, static markup\n * after it is written into the DOM.\n */\njest.mock('../mathlive-instance', () => {\n  class FakeMathfieldElement {\n    constructor() {\n      const el = global.document.createElement('math-field');\n\n      el.value = '';\n      el.getValue = () => el.value;\n\n      return el;\n    }\n  }\n\n  return {\n    loadMathLive: () => Promise.resolve({ MathfieldElement: FakeMathfieldElement }),\n    getMacros: () => ({}),\n    MATH_MODE_SPACE: '\\\\ ',\n    applyShadowStyles: () => {},\n    trackPlaceholderCaret: () => () => {},\n    latexToMarkup: (l) => `<span>${l}</span>`,\n  };\n});\n\nconst mockUntrack = jest.fn();\n\njest.mock('../longdiv', () => ({\n  trackLongDivision: jest.fn(() => mockUntrack),\n  fixLongDivisionWhenReady: jest.fn(),\n  fixLongDivision: jest.fn(),\n}));\n\n/* eslint-disable import/first */\nimport Input from '../mf/input';\nimport Static from '../mf/static';\nimport { LatexLabel } from '../keypad';\nimport { trackLongDivision, fixLongDivisionWhenReady } from '../longdiv';\n/* eslint-enable import/first */\n\nbeforeEach(() => {\n  trackLongDivision.mockClear();\n  fixLongDivisionWhenReady.mockClear();\n  mockUntrack.mockClear();\n});\n\ndescribe('Input (the editor)', () => {\n  it('tracks the mathfield on mount and stops on unmount', async () => {\n    const input = new Input({});\n\n    input.holderRef = { current: document.createElement('span') };\n    await input.componentDidMount();\n\n    expect(trackLongDivision).toHaveBeenCalledWith(input.mathField);\n\n    input.componentWillUnmount();\n\n    expect(mockUntrack).toHaveBeenCalledTimes(1);\n    expect(input.untrackLongDivision).toBeUndefined();\n  });\n});\n\ndescribe('Static', () => {\n  it('tracks the answer-block field on mount and stops on unmount', async () => {\n    const s = new Static({ latex: 'x=\\\\MathQuillMathField[r1]{}' });\n\n    s.holderRef = { current: document.createElement('span') };\n    s.createLiveRegion = () => {};\n    await s.componentDidMount();\n\n    expect(trackLongDivision).toHaveBeenCalledWith(s.mathField);\n\n    s.componentWillUnmount();\n\n    expect(mockUntrack).toHaveBeenCalledTimes(1);\n  });\n\n  // Display mode: the markup reaches the DOM through state, so it is corrected\n  // once React has written it.\n  it('corrects static markup after it is rendered', () => {\n    const s = new Static({ latex: '5\\\\longdiv{144}' });\n    const holder = document.createElement('span');\n\n    s.holderRef = { current: holder };\n    s.state = { markup: '<span>new</span>' };\n    s.componentDidUpdate({ latex: '5\\\\longdiv{144}' }, { markup: '' });\n\n    expect(fixLongDivisionWhenReady).toHaveBeenCalledWith(holder);\n  });\n\n  it('does not redo it when the markup did not change', () => {\n    const s = new Static({ latex: 'x' });\n\n    s.holderRef = { current: document.createElement('span') };\n    s.state = { markup: '<span>same</span>' };\n    s.componentDidUpdate({ latex: 'x' }, { markup: '<span>same</span>' });\n\n    expect(fixLongDivisionWhenReady).not.toHaveBeenCalled();\n  });\n\n  it('leaves a live field to the tracker', () => {\n    const s = new Static({ latex: 'x' });\n\n    s.holderRef = { current: document.createElement('span') };\n    s.mathField = document.createElement('math-field');\n    s.state = { markup: '<span>new</span>' };\n    s.componentDidUpdate({ latex: 'x' }, { markup: '' });\n\n    expect(fixLongDivisionWhenReady).not.toHaveBeenCalled();\n  });\n});\n\ndescribe('keypad label', () => {\n  it('corrects the label once mounted', async () => {\n    const label = new LatexLabel({ latex: '\\\\longdiv{}' });\n    const el = document.createElement('span');\n\n    label.labelRef = { current: el };\n    await label.componentDidMount();\n\n    expect(fixLongDivisionWhenReady).toHaveBeenCalledWith(el);\n  });\n\n  it('corrects it again when the label changes', () => {\n    const label = new LatexLabel({ latex: '\\\\longdiv{}' });\n    const el = document.createElement('span');\n\n    label.labelRef = { current: el };\n    label.setState = () => {};\n    label.state = { markup: '<span>other</span>' };\n    label.componentDidUpdate({ latex: '\\\\longdiv{}' }, { markup: '<span>first</span>' });\n\n    expect(fixLongDivisionWhenReady).toHaveBeenCalledWith(el);\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/__tests__/longdiv.test.js

@@ -0,0 +1,281 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _longdiv = require("../longdiv");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Markup captured verbatim from MathLive 0.110.0 `convertLatexToMarkup` in
+ * Chrome. In `12\enclose{longdiv}{144}` MathLive drops the dividend 0.45em
+ * (`top:0.45em`), sizes the box 2.1em wide while the viewBox is 2.54 wide, and
+ * ends the bar at 1.8 although the dividend runs to 0.3 + 0.45 + 1.5 = 2.25.
+ */
+var LONGDIV = '<span class="ML__latex"><span class="ML__strut" style="height:0.8em"></span><span class="ML__strut--bottom" style="height:1.25em;vertical-align:-0.44em"></span><span class="ML__base"><span class="ML__cmr">12</span><span style="position:relative;height:1.24em;display:inline-block;margin-left:0.3em;margin-right:0.3em;width:1.95em"><span class="ML__notation" style="box-sizing:border-box;left:calc(-1 * 1px - 0.3em);height:calc( 1.24444em + 1px);top:0em;width:calc(2.1em + 1px);background-color:transparent"><span style="display: inline-block;height:1.24em;vertical-align:0.44em;"></span><svg style="position:absolute;overflow:visible;height:1.24em;top:0;left:0;width:100%;z-index:2;" stroke-width="0.06em" stroke="currentColor" stroke-linecap="round" viewBox="0 0 2.54 1.24"><line x1="0.3"  y1="0.3" x2="1.8" y2="0.3" vector-effect="non-scaling-stroke"></line><path d="M 0.3 0.3  a0.3 0.46997, 0, 1, 1, 0 0.93994 " stroke-width="0.004em" stroke="currentColor" fill="none"/></svg></span><span style="position:relative;display:inline-block;height:0.65em;width:1.5em;margin-left:0.45em;top:0.45em"><span class="ML__cmr">144</span></span></span></span></span>';
+
+// \enclose{box}{x}: another notation, which must be left alone
+var BOX = '<span class="ML__latex"><span class="ML__strut" style="height:1.04em"></span><span class="ML__base"><span style="position:relative;height:1.03em;display:inline-block;margin-left:0.3em;margin-right:0.3em;width:0.58em"><span class="ML__notation" style="box-sizing:border-box;left:calc(-1 * 1px - 0.3em);height:calc( 1.03056em + 1px);top:0em;width:calc(1.17153em + 1px);background-color:transparent;border:1px solid red"></span><span style="position:relative;display:inline-block;height:0.44em;width:0.58em"><span class="ML__mathit">x</span></span></span></span></span>';
+var mount = function mount(html) {
+  var el = document.createElement('div');
+  el.innerHTML = html;
+  document.body.appendChild(el);
+  return el;
+};
+var parts = function parts(el) {
+  var notation = el.querySelector('.ML__notation');
+  return {
+    notation: notation,
+    box: notation.parentElement,
+    dividend: notation.nextElementSibling,
+    line: notation.querySelector('line')
+  };
+};
+afterEach(function () {
+  document.body.innerHTML = '';
+});
+describe('fixLongDivision', function () {
+  it('puts the dividend back on the baseline', function () {
+    var el = mount(LONGDIV);
+    (0, _longdiv.fixLongDivision)(el);
+    var _parts = parts(el),
+      dividend = _parts.dividend,
+      box = _parts.box;
+    expect(dividend.style.top).toEqual('0px');
+    // the drawing keeps its place relative to the dividend, and the line grows
+    // so the field does not clip the bar
+    expect(box.style.paddingTop).toEqual('0.45em');
+  });
+  it('sizes the box to the viewBox, so the drawing is not scaled down', function () {
+    var el = mount(LONGDIV);
+    (0, _longdiv.fixLongDivision)(el);
+    expect(parts(el).notation.style.width).toEqual('calc(2.54em + 1px)');
+  });
+  it('runs the bar to the end of the dividend', function () {
+    var el = mount(LONGDIV);
+    (0, _longdiv.fixLongDivision)(el);
+
+    // no layout under jsdom, so from MathLive's numbers: start + gap + width
+    expect(parseFloat(parts(el).line.getAttribute('x2'))).toBeCloseTo(0.3 + 0.45 + 1.5, 6);
+  });
+
+  // MathLive's width leaves out the spacing around `,` and `+`, so when the
+  // markup is laid out the end is measured instead.
+  it('measures the bar end from the rendered dividend when laid out', function () {
+    var el = mount(LONGDIV);
+    var _parts2 = parts(el),
+      notation = _parts2.notation,
+      dividend = _parts2.dividend;
+    var svg = notation.querySelector('svg');
+    var glyph = dividend.querySelector('.ML__cmr');
+
+    // the svg is 254px wide for a 2.54-unit viewBox: 100px per unit
+    svg.getBoundingClientRect = function () {
+      return {
+        left: 100,
+        width: 254,
+        right: 354
+      };
+    };
+    glyph.getBoundingClientRect = function () {
+      return {
+        left: 145,
+        right: 340,
+        width: 195
+      };
+    };
+    (0, _longdiv.fixLongDivision)(el);
+    expect(parseFloat(parts(el).line.getAttribute('x2'))).toBeCloseTo(2.4, 6);
+  });
+  it('ignores the caret when measuring', function () {
+    var el = mount(LONGDIV);
+    var _parts3 = parts(el),
+      notation = _parts3.notation,
+      dividend = _parts3.dividend;
+    var caret = document.createElement('span');
+    caret.className = 'ML__caret';
+    dividend.appendChild(caret);
+    notation.querySelector('svg').getBoundingClientRect = function () {
+      return {
+        left: 100,
+        width: 254,
+        right: 354
+      };
+    };
+    dividend.querySelector('.ML__cmr').getBoundingClientRect = function () {
+      return {
+        left: 145,
+        right: 340,
+        width: 195
+      };
+    };
+    caret.getBoundingClientRect = function () {
+      return {
+        left: 400,
+        right: 402,
+        width: 2
+      };
+    };
+    (0, _longdiv.fixLongDivision)(el);
+    expect(parseFloat(parts(el).line.getAttribute('x2'))).toBeCloseTo(2.4, 6);
+  });
+  it('can run again without drifting', function () {
+    var el = mount(LONGDIV);
+    (0, _longdiv.fixLongDivision)(el);
+    var first = _objectSpread(_objectSpread({}, parts(el)), {}, {
+      x2: parts(el).line.getAttribute('x2')
+    });
+    (0, _longdiv.fixLongDivision)(el);
+    var second = parts(el);
+    expect(second.line.getAttribute('x2')).toEqual(first.x2);
+    expect(second.box.style.paddingTop).toEqual('0.45em');
+    expect(second.notation.style.width).toEqual('calc(2.54em + 1px)');
+  });
+  it('leaves other enclose notations alone', function () {
+    var el = mount(BOX);
+    var before = el.innerHTML;
+    expect((0, _longdiv.fixLongDivision)(el)).toBe(0);
+    expect(el.innerHTML).toEqual(before);
+  });
+  it('counts what it corrected', function () {
+    expect((0, _longdiv.fixLongDivision)(mount(LONGDIV + LONGDIV))).toBe(2);
+  });
+  it('is safe on nothing', function () {
+    expect((0, _longdiv.fixLongDivision)(null)).toBe(0);
+    expect((0, _longdiv.fixLongDivision)(mount('<span>plain</span>'))).toBe(0);
+  });
+});
+describe('fixLongDivisionWhenReady', function () {
+  it('corrects now, and again once the fonts have loaded', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var fontsLoaded, original, el;
+    return _regenerator["default"].wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          original = document.fonts;
+          Object.defineProperty(document, 'fonts', {
+            configurable: true,
+            value: {
+              ready: new Promise(function (resolve) {
+                return fontsLoaded = resolve;
+              })
+            }
+          });
+          _context.prev = 1;
+          el = mount(LONGDIV);
+          (0, _longdiv.fixLongDivisionWhenReady)(el);
+          expect(parts(el).dividend.style.top).toEqual('0px');
+
+          // a re-render before the fonts arrive...
+          el.innerHTML = LONGDIV;
+          fontsLoaded();
+          _context.next = 2;
+          return Promise.resolve();
+        case 2:
+          _context.next = 3;
+          return Promise.resolve();
+        case 3:
+          // ...is corrected once they do
+          expect(parts(el).dividend.style.top).toEqual('0px');
+        case 4:
+          _context.prev = 4;
+          Object.defineProperty(document, 'fonts', {
+            configurable: true,
+            value: original
+          });
+          return _context.finish(4);
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[1,, 4, 5]]);
+  })));
+});
+describe('trackLongDivision', function () {
+  var field = function field() {
+    var host = document.createElement('div');
+    host.attachShadow({
+      mode: 'open'
+    });
+    host.shadowRoot.innerHTML = LONGDIV;
+    document.body.appendChild(host);
+    return host;
+  };
+  it('corrects the field straight away', function () {
+    var host = field();
+    (0, _longdiv.trackLongDivision)(host);
+    expect(parts(host.shadowRoot).dividend.style.top).toEqual('0px');
+  });
+
+  // jest.setup.js replaces MutationObserver with a no-op for every test, so this
+  // installs one that records what it was asked to observe and can be fired.
+  describe('re-rendering', function () {
+    var observers;
+    var RealObserver = global.MutationObserver;
+    beforeEach(function () {
+      observers = [];
+      global.MutationObserver = /*#__PURE__*/function () {
+        function _class(callback) {
+          (0, _classCallCheck2["default"])(this, _class);
+          this.callback = callback;
+          this.disconnected = false;
+          observers.push(this);
+        }
+        return (0, _createClass2["default"])(_class, [{
+          key: "observe",
+          value: function observe(target, options) {
+            this.target = target;
+            this.options = options;
+          }
+        }, {
+          key: "disconnect",
+          value: function disconnect() {
+            this.disconnected = true;
+          }
+        }]);
+      }();
+    });
+    afterEach(function () {
+      global.MutationObserver = RealObserver;
+    });
+    it('watches the whole shadow tree for MathLive rebuilding it', function () {
+      var host = field();
+      (0, _longdiv.trackLongDivision)(host);
+      expect(observers).toHaveLength(1);
+      expect(observers[0].target).toBe(host.shadowRoot);
+      expect(observers[0].options).toEqual({
+        childList: true,
+        subtree: true
+      });
+    });
+
+    // MathLive rebuilds its shadow DOM on every keystroke, resize and font load.
+    it('re-corrects after MathLive re-renders', function () {
+      var host = field();
+      (0, _longdiv.trackLongDivision)(host);
+      host.shadowRoot.innerHTML = LONGDIV;
+      expect(parts(host.shadowRoot).dividend.style.top).toEqual('0.45em');
+      observers[0].callback([]);
+      expect(parts(host.shadowRoot).dividend.style.top).toEqual('0px');
+    });
+
+    // The corrections change attributes only, so observing childList alone
+    // cannot loop.
+    it('does not observe attributes', function () {
+      (0, _longdiv.trackLongDivision)(field());
+      expect(observers[0].options.attributes).toBeUndefined();
+    });
+    it('stops after teardown', function () {
+      var untrack = (0, _longdiv.trackLongDivision)(field());
+      untrack();
+      expect(observers[0].disconnected).toBe(true);
+    });
+  });
+  it('is a no-op without a shadow root', function () {
+    expect((0, _longdiv.trackLongDivision)(undefined)).toBeUndefined();
+    expect((0, _longdiv.trackLongDivision)(document.createElement('div'))).toBeUndefined();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_longdiv","require","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","LONGDIV","BOX","mount","html","el","document","createElement","innerHTML","body","appendChild","parts","notation","querySelector","box","parentElement","dividend","nextElementSibling","line","afterEach","describe","it","fixLongDivision","_parts","expect","style","top","toEqual","paddingTop","width","parseFloat","getAttribute","toBeCloseTo","_parts2","svg","glyph","getBoundingClientRect","left","right","_parts3","caret","className","first","x2","second","before","toBe","_asyncToGenerator2","_regenerator","mark","_callee","fontsLoaded","original","wrap","_context","prev","next","fonts","configurable","value","ready","Promise","resolve","fixLongDivisionWhenReady","finish","stop","field","host","attachShadow","mode","shadowRoot","trackLongDivision","observers","RealObserver","global","MutationObserver","beforeEach","_class","callback","_classCallCheck2","disconnected","_createClass2","key","observe","target","options","disconnect","toHaveLength","childList","subtree","attributes","toBeUndefined","untrack","undefined"],"sources":["../../src/__tests__/longdiv.test.js"],"sourcesContent":["import { fixLongDivision, fixLongDivisionWhenReady, trackLongDivision } from '../longdiv';\n\n/**\n * Markup captured verbatim from MathLive 0.110.0 `convertLatexToMarkup` in\n * Chrome. In `12\\enclose{longdiv}{144}` MathLive drops the dividend 0.45em\n * (`top:0.45em`), sizes the box 2.1em wide while the viewBox is 2.54 wide, and\n * ends the bar at 1.8 although the dividend runs to 0.3 + 0.45 + 1.5 = 2.25.\n */\nconst LONGDIV =\n  '<span class=\"ML__latex\"><span class=\"ML__strut\" style=\"height:0.8em\"></span><span class=\"ML__strut--bottom\" style=\"height:1.25em;vertical-align:-0.44em\"></span><span class=\"ML__base\"><span class=\"ML__cmr\">12</span><span style=\"position:relative;height:1.24em;display:inline-block;margin-left:0.3em;margin-right:0.3em;width:1.95em\"><span class=\"ML__notation\" style=\"box-sizing:border-box;left:calc(-1 * 1px - 0.3em);height:calc( 1.24444em + 1px);top:0em;width:calc(2.1em + 1px);background-color:transparent\"><span style=\"display: inline-block;height:1.24em;vertical-align:0.44em;\"></span><svg style=\"position:absolute;overflow:visible;height:1.24em;top:0;left:0;width:100%;z-index:2;\" stroke-width=\"0.06em\" stroke=\"currentColor\" stroke-linecap=\"round\" viewBox=\"0 0 2.54 1.24\"><line x1=\"0.3\"  y1=\"0.3\" x2=\"1.8\" y2=\"0.3\" vector-effect=\"non-scaling-stroke\"></line><path d=\"M 0.3 0.3  a0.3 0.46997, 0, 1, 1, 0 0.93994 \" stroke-width=\"0.004em\" stroke=\"currentColor\" fill=\"none\"/></svg></span><span style=\"position:relative;display:inline-block;height:0.65em;width:1.5em;margin-left:0.45em;top:0.45em\"><span class=\"ML__cmr\">144</span></span></span></span></span>';\n\n// \\enclose{box}{x}: another notation, which must be left alone\nconst BOX =\n  '<span class=\"ML__latex\"><span class=\"ML__strut\" style=\"height:1.04em\"></span><span class=\"ML__base\"><span style=\"position:relative;height:1.03em;display:inline-block;margin-left:0.3em;margin-right:0.3em;width:0.58em\"><span class=\"ML__notation\" style=\"box-sizing:border-box;left:calc(-1 * 1px - 0.3em);height:calc( 1.03056em + 1px);top:0em;width:calc(1.17153em + 1px);background-color:transparent;border:1px solid red\"></span><span style=\"position:relative;display:inline-block;height:0.44em;width:0.58em\"><span class=\"ML__mathit\">x</span></span></span></span></span>';\n\nconst mount = (html) => {\n  const el = document.createElement('div');\n\n  el.innerHTML = html;\n  document.body.appendChild(el);\n\n  return el;\n};\n\nconst parts = (el) => {\n  const notation = el.querySelector('.ML__notation');\n\n  return {\n    notation,\n    box: notation.parentElement,\n    dividend: notation.nextElementSibling,\n    line: notation.querySelector('line'),\n  };\n};\n\nafterEach(() => {\n  document.body.innerHTML = '';\n});\n\ndescribe('fixLongDivision', () => {\n  it('puts the dividend back on the baseline', () => {\n    const el = mount(LONGDIV);\n\n    fixLongDivision(el);\n\n    const { dividend, box } = parts(el);\n\n    expect(dividend.style.top).toEqual('0px');\n    // the drawing keeps its place relative to the dividend, and the line grows\n    // so the field does not clip the bar\n    expect(box.style.paddingTop).toEqual('0.45em');\n  });\n\n  it('sizes the box to the viewBox, so the drawing is not scaled down', () => {\n    const el = mount(LONGDIV);\n\n    fixLongDivision(el);\n\n    expect(parts(el).notation.style.width).toEqual('calc(2.54em + 1px)');\n  });\n\n  it('runs the bar to the end of the dividend', () => {\n    const el = mount(LONGDIV);\n\n    fixLongDivision(el);\n\n    // no layout under jsdom, so from MathLive's numbers: start + gap + width\n    expect(parseFloat(parts(el).line.getAttribute('x2'))).toBeCloseTo(0.3 + 0.45 + 1.5, 6);\n  });\n\n  // MathLive's width leaves out the spacing around `,` and `+`, so when the\n  // markup is laid out the end is measured instead.\n  it('measures the bar end from the rendered dividend when laid out', () => {\n    const el = mount(LONGDIV);\n    const { notation, dividend } = parts(el);\n    const svg = notation.querySelector('svg');\n    const glyph = dividend.querySelector('.ML__cmr');\n\n    // the svg is 254px wide for a 2.54-unit viewBox: 100px per unit\n    svg.getBoundingClientRect = () => ({ left: 100, width: 254, right: 354 });\n    glyph.getBoundingClientRect = () => ({ left: 145, right: 340, width: 195 });\n\n    fixLongDivision(el);\n\n    expect(parseFloat(parts(el).line.getAttribute('x2'))).toBeCloseTo(2.4, 6);\n  });\n\n  it('ignores the caret when measuring', () => {\n    const el = mount(LONGDIV);\n    const { notation, dividend } = parts(el);\n    const caret = document.createElement('span');\n\n    caret.className = 'ML__caret';\n    dividend.appendChild(caret);\n    notation.querySelector('svg').getBoundingClientRect = () => ({ left: 100, width: 254, right: 354 });\n    dividend.querySelector('.ML__cmr').getBoundingClientRect = () => ({ left: 145, right: 340, width: 195 });\n    caret.getBoundingClientRect = () => ({ left: 400, right: 402, width: 2 });\n\n    fixLongDivision(el);\n\n    expect(parseFloat(parts(el).line.getAttribute('x2'))).toBeCloseTo(2.4, 6);\n  });\n\n  it('can run again without drifting', () => {\n    const el = mount(LONGDIV);\n\n    fixLongDivision(el);\n    const first = { ...parts(el), x2: parts(el).line.getAttribute('x2') };\n\n    fixLongDivision(el);\n    const second = parts(el);\n\n    expect(second.line.getAttribute('x2')).toEqual(first.x2);\n    expect(second.box.style.paddingTop).toEqual('0.45em');\n    expect(second.notation.style.width).toEqual('calc(2.54em + 1px)');\n  });\n\n  it('leaves other enclose notations alone', () => {\n    const el = mount(BOX);\n    const before = el.innerHTML;\n\n    expect(fixLongDivision(el)).toBe(0);\n    expect(el.innerHTML).toEqual(before);\n  });\n\n  it('counts what it corrected', () => {\n    expect(fixLongDivision(mount(LONGDIV + LONGDIV))).toBe(2);\n  });\n\n  it('is safe on nothing', () => {\n    expect(fixLongDivision(null)).toBe(0);\n    expect(fixLongDivision(mount('<span>plain</span>'))).toBe(0);\n  });\n});\n\ndescribe('fixLongDivisionWhenReady', () => {\n  it('corrects now, and again once the fonts have loaded', async () => {\n    let fontsLoaded;\n    const original = document.fonts;\n\n    Object.defineProperty(document, 'fonts', {\n      configurable: true,\n      value: { ready: new Promise((resolve) => (fontsLoaded = resolve)) },\n    });\n\n    try {\n      const el = mount(LONGDIV);\n\n      fixLongDivisionWhenReady(el);\n      expect(parts(el).dividend.style.top).toEqual('0px');\n\n      // a re-render before the fonts arrive...\n      el.innerHTML = LONGDIV;\n      fontsLoaded();\n      await Promise.resolve();\n      await Promise.resolve();\n\n      // ...is corrected once they do\n      expect(parts(el).dividend.style.top).toEqual('0px');\n    } finally {\n      Object.defineProperty(document, 'fonts', { configurable: true, value: original });\n    }\n  });\n});\n\ndescribe('trackLongDivision', () => {\n  const field = () => {\n    const host = document.createElement('div');\n\n    host.attachShadow({ mode: 'open' });\n    host.shadowRoot.innerHTML = LONGDIV;\n    document.body.appendChild(host);\n\n    return host;\n  };\n\n  it('corrects the field straight away', () => {\n    const host = field();\n\n    trackLongDivision(host);\n\n    expect(parts(host.shadowRoot).dividend.style.top).toEqual('0px');\n  });\n\n  // jest.setup.js replaces MutationObserver with a no-op for every test, so this\n  // installs one that records what it was asked to observe and can be fired.\n  describe('re-rendering', () => {\n    let observers;\n    const RealObserver = global.MutationObserver;\n\n    beforeEach(() => {\n      observers = [];\n      global.MutationObserver = class {\n        constructor(callback) {\n          this.callback = callback;\n          this.disconnected = false;\n          observers.push(this);\n        }\n\n        observe(target, options) {\n          this.target = target;\n          this.options = options;\n        }\n\n        disconnect() {\n          this.disconnected = true;\n        }\n      };\n    });\n\n    afterEach(() => {\n      global.MutationObserver = RealObserver;\n    });\n\n    it('watches the whole shadow tree for MathLive rebuilding it', () => {\n      const host = field();\n\n      trackLongDivision(host);\n\n      expect(observers).toHaveLength(1);\n      expect(observers[0].target).toBe(host.shadowRoot);\n      expect(observers[0].options).toEqual({ childList: true, subtree: true });\n    });\n\n    // MathLive rebuilds its shadow DOM on every keystroke, resize and font load.\n    it('re-corrects after MathLive re-renders', () => {\n      const host = field();\n\n      trackLongDivision(host);\n      host.shadowRoot.innerHTML = LONGDIV;\n      expect(parts(host.shadowRoot).dividend.style.top).toEqual('0.45em');\n\n      observers[0].callback([]);\n\n      expect(parts(host.shadowRoot).dividend.style.top).toEqual('0px');\n    });\n\n    // The corrections change attributes only, so observing childList alone\n    // cannot loop.\n    it('does not observe attributes', () => {\n      trackLongDivision(field());\n\n      expect(observers[0].options.attributes).toBeUndefined();\n    });\n\n    it('stops after teardown', () => {\n      const untrack = trackLongDivision(field());\n\n      untrack();\n\n      expect(observers[0].disconnected).toBe(true);\n    });\n  });\n\n  it('is a no-op without a shadow root', () => {\n    expect(trackLongDivision(undefined)).toBeUndefined();\n    expect(trackLongDivision(document.createElement('div'))).toBeUndefined();\n  });\n});\n"],"mappings":"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","ignoreList":[]}