@pie-lib/math-input-mathlive 1.1.5-beta.1 → 1.1.5-beta.10

package/lib/__tests__/static-prompts.test.js

@@ -0,0 +1,405 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _static = _interopRequireDefault(require("../mf/static"));
+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; }
+/**
+ * The answer-block contract: `\MathQuillMathField[id]{}` in stored latex becomes
+ * a MathLive prompt, and sub-field values/focus are surfaced through the same
+ * callbacks @pie-lib/math-input exposed (`onSubFieldChange`, `onSubFieldFocus`,
+ * `getFieldName`, `setInput`).
+ *
+ * Driven against a stub mathfield: a real <math-field> needs a browser, and what
+ * matters here is the mapping, not MathLive's rendering.
+ */
+var stubField = function stubField() {
+  var values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var selection = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return {
+    values: _objectSpread({}, values),
+    getPrompts: function getPrompts() {
+      return Object.keys(this.values);
+    },
+    getPromptValue: function getPromptValue(id) {
+      return this.values[id];
+    },
+    setPromptValue: function setPromptValue(id, v) {
+      this.values[id] = v;
+    },
+    getPromptRange: function getPromptRange(id) {
+      var i = Object.keys(this.values).indexOf(id);
+      return [i * 10, i * 10 + 5];
+    },
+    selection: selection,
+    // Caret bookkeeping: MathLive exposes the caret offset as `position`, and any
+    // executeCommand triggers the render that reveals the caret.
+    position: undefined,
+    commands: [],
+    executeCommand: function executeCommand(name) {
+      this.commands.push(name);
+    },
+    addEventListener: function addEventListener() {},
+    removeEventListener: function removeEventListener() {},
+    focus: function focus() {
+      this.focused = true;
+    },
+    blur: function blur() {
+      this.blurred = true;
+    },
+    remove: function remove() {}
+  };
+};
+var make = function make() {
+  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new _static["default"](_objectSpread({
+    latex: 'x=\\MathQuillMathField[r1]{}',
+    getFieldName: function getFieldName() {}
+  }, props));
+};
+describe('Static: answer blocks / prompts', function () {
+  describe('isInteractive', function () {
+    it('is interactive when the latex has answer blocks', function () {
+      expect(make({
+        latex: 'x=\\MathQuillMathField[r1]{}'
+      }).isInteractive()).toBe(true);
+      expect(make({
+        latex: 'x=\\placeholder[r1]{}'
+      }).isInteractive()).toBe(true);
+    });
+    it('is display-only for plain latex', function () {
+      expect(make({
+        latex: '\\frac{1}{2}'
+      }).isInteractive()).toBe(false);
+      expect(make({
+        latex: ''
+      }).isInteractive()).toBe(false);
+    });
+  });
+  describe('values', function () {
+    it('returns {} before the field exists', function () {
+      expect(make().values()).toEqual({});
+    });
+    it('maps each prompt id to its stored-form latex', function () {
+      var s = make();
+      s.mathField = stubField({
+        r1: '7',
+        r2: '\\placeholder{}'
+      });
+
+      // \placeholder must not leak into stored values
+      expect(s.values()).toEqual({
+        r1: '7',
+        r2: ''
+      });
+    });
+  });
+  describe('promptHandle / innerFields', function () {
+    it('exposes a MathQuill-field-like handle with get/set latex', function () {
+      var s = make();
+      s.mathField = stubField({
+        r1: '7'
+      });
+      var h = s.promptHandle('r1');
+      expect(h.id).toEqual('r1');
+      expect(h.latex()).toEqual('7');
+      h.latex('9');
+      expect(s.mathField.values.r1).toEqual('9');
+    });
+    it('handle latex() is safe with no field', function () {
+      expect(make().promptHandle('r1').latex()).toEqual('');
+    });
+    it('innerFields returns one handle per prompt', function () {
+      var s = make();
+      s.mathField = stubField({
+        r1: '1',
+        r2: '2'
+      });
+      expect(s.innerFields.map(function (f) {
+        return f.id;
+      })).toEqual(['r1', 'r2']);
+      expect(make().innerFields).toEqual([]);
+    });
+  });
+  describe('onSubFieldChange', function () {
+    it('fires only for prompts whose value changed', function () {
+      var onSubFieldChange = jest.fn();
+      var s = make({
+        onSubFieldChange: onSubFieldChange
+      });
+      s.mathField = stubField({
+        r1: '1',
+        r2: '2'
+      });
+      s.promptValues = {
+        r1: '1',
+        r2: '2'
+      };
+      s.mathField.values.r2 = '5';
+      s.onPromptInput();
+      expect(onSubFieldChange).toHaveBeenCalledTimes(1);
+      expect(onSubFieldChange).toHaveBeenCalledWith('r2', '5');
+    });
+    it('uses getFieldName when it returns a name', function () {
+      var onSubFieldChange = jest.fn();
+      var s = make({
+        onSubFieldChange: onSubFieldChange,
+        getFieldName: function getFieldName(handle) {
+          return 'named-' + handle.id;
+        }
+      });
+      s.mathField = stubField({
+        r1: '1'
+      });
+      s.promptValues = {};
+      s.onPromptInput();
+      expect(onSubFieldChange).toHaveBeenCalledWith('named-r1', '1');
+    });
+    it('still tracks values when no callback is supplied', function () {
+      var s = make();
+      s.mathField = stubField({
+        r1: '3'
+      });
+      s.onPromptInput();
+      expect(s.promptValues).toEqual({
+        r1: '3'
+      });
+    });
+  });
+  describe('onSubFieldFocus', function () {
+    it('reports the prompt containing the selection, plus setInput', function () {
+      var onSubFieldFocus = jest.fn();
+      var setInput = jest.fn();
+      var s = make({
+        onSubFieldFocus: onSubFieldFocus,
+        setInput: setInput
+      });
+
+      // r2 occupies offsets 10..15
+      s.mathField = stubField({
+        r1: '',
+        r2: ''
+      }, {
+        ranges: [[11, 11]]
+      });
+      s.onPromptFocus();
+      expect(onSubFieldFocus).toHaveBeenCalledTimes(1);
+      expect(onSubFieldFocus.mock.calls[0][0]).toEqual('r2');
+      expect(onSubFieldFocus.mock.calls[0][1].id).toEqual('r2');
+      expect(setInput).toHaveBeenCalled();
+    });
+    it('does nothing without a selection', function () {
+      var onSubFieldFocus = jest.fn();
+      var s = make({
+        onSubFieldFocus: onSubFieldFocus
+      });
+      s.mathField = stubField({
+        r1: ''
+      }, null);
+      s.onPromptFocus();
+      expect(onSubFieldFocus).not.toHaveBeenCalled();
+    });
+    it('does not throw when the field is missing', function () {
+      var s = make({
+        onSubFieldFocus: jest.fn()
+      });
+      expect(function () {
+        return s.onPromptFocus();
+      }).not.toThrow();
+    });
+  });
+  describe('accessibility announcements', function () {
+    afterEach(function () {
+      document.body.innerHTML = '';
+    });
+    it('creates a polite off-screen live region', function () {
+      var s = make();
+      s.createLiveRegion();
+      expect(s.liveRegion.getAttribute('aria-live')).toEqual('polite');
+      expect(s.liveRegion.getAttribute('aria-atomic')).toEqual('true');
+      expect(document.body.contains(s.liveRegion)).toBe(true);
+      s.removeLiveRegion();
+      expect(s.liveRegion).toBeUndefined();
+    });
+    it('does not create a second region', function () {
+      var s = make();
+      s.createLiveRegion();
+      var first = s.liveRegion;
+      s.createLiveRegion();
+      expect(s.liveRegion).toBe(first);
+      s.removeLiveRegion();
+    });
+    it('announces when typed input expands into a command', function () {
+      var s = make();
+      s.createLiveRegion();
+      s.promptValues = {
+        r1: 'x'
+      };
+      // grew by more than one char AND gained a backslash => a conversion
+      s.announceConversion({
+        r1: 'x\\frac{}{}'
+      });
+      expect(s.liveRegion.textContent).toEqual('Converted to math symbol');
+      s.removeLiveRegion();
+    });
+    it('does not announce ordinary typing', function () {
+      var s = make();
+      s.createLiveRegion();
+      s.promptValues = {
+        r1: 'x'
+      };
+      s.announceConversion({
+        r1: 'xy'
+      });
+      expect(s.liveRegion.textContent).toEqual('');
+      s.removeLiveRegion();
+    });
+    it('does not announce a deletion', function () {
+      var s = make();
+      s.createLiveRegion();
+      s.promptValues = {
+        r1: 'x\\frac{}{}'
+      };
+      s.onKeyDown({
+        key: 'Backspace'
+      });
+      s.announceConversion({
+        r1: 'x'
+      });
+      expect(s.liveRegion.textContent).toEqual('');
+      s.removeLiveRegion();
+    });
+  });
+  describe('focus / blur', function () {
+    it('delegates to the field and is safe without one', function () {
+      var s = make();
+      expect(function () {
+        s.focus();
+        s.blur();
+      }).not.toThrow();
+      s.mathField = stubField();
+      s.focus();
+      s.blur();
+      expect(s.mathField.focused).toBe(true);
+      expect(s.mathField.blurred).toBe(true);
+    });
+  });
+
+  /**
+   * MathLive shows the caret only while the field carries `ML__focused`, which
+   * it adds during a render gated on `isSelectionEditable && hasFocus()`. In a
+   * read-only field only prompt interiors are editable, so after a bare
+   * `focus()` - whose selection sits outside every prompt - the answer block
+   * looked focused but had no blinking cursor. Verified in Chromium: the caret
+   * span goes from visibility:hidden to visible once the selection is inside a
+   * prompt AND a render has run.
+   */
+  describe('caret placement', function () {
+    it('puts a collapsed caret in the first prompt on focus', function () {
+      var s = make();
+      s.mathField = stubField({
+        r1: '',
+        r2: ''
+      });
+      s.focus();
+
+      // stub ranges are [0,5] for r1, [10,15] for r2
+      expect(s.mathField.selection).toEqual({
+        ranges: [[0, 0]]
+      });
+    });
+    it('forces the render that makes the caret visible', function () {
+      var s = make();
+      s.mathField = stubField({
+        r1: ''
+      });
+      s.focus();
+
+      // assigning `selection` alone updates the model without re-rendering, so
+      // ML__focused would never be added
+      expect(s.mathField.commands).toEqual(['scrollIntoView']);
+    });
+    it('does not move a caret that is already inside a prompt', function () {
+      var s = make();
+      s.mathField = stubField({
+        r1: '',
+        r2: ''
+      });
+      s.mathField.position = 12; // inside r2
+      s.focus();
+      expect(s.mathField.selection).toBe(null);
+      expect(s.mathField.commands).toEqual([]);
+    });
+    it('targets a specific prompt', function () {
+      var s = make();
+      s.mathField = stubField({
+        r1: '',
+        r2: ''
+      });
+      s.focusPrompt('r2');
+      expect(s.mathField.selection).toEqual({
+        ranges: [[10, 10]]
+      });
+    });
+    it('falls back to the first prompt for an unknown id', function () {
+      var s = make();
+      s.mathField = stubField({
+        r1: '',
+        r2: ''
+      });
+      s.focusPrompt('nope');
+      expect(s.mathField.selection).toEqual({
+        ranges: [[0, 0]]
+      });
+    });
+    it('is a no-op when there are no prompts', function () {
+      var s = make();
+      s.mathField = stubField({});
+      expect(function () {
+        return s.focusPrompt();
+      }).not.toThrow();
+      expect(s.mathField.selection).toBe(null);
+    });
+    it('is safe without a field', function () {
+      expect(function () {
+        return make().focusPrompt('r1');
+      }).not.toThrow();
+    });
+    describe('promptContaining', function () {
+      it('finds the prompt whose range holds the offset, inclusive', function () {
+        var s = make();
+        s.mathField = stubField({
+          r1: '',
+          r2: ''
+        });
+        expect(s.promptContaining(0)).toEqual('r1');
+        expect(s.promptContaining(5)).toEqual('r1');
+        expect(s.promptContaining(10)).toEqual('r2');
+        expect(s.promptContaining(7)).toBeUndefined();
+      });
+      it('treats a missing position as outside', function () {
+        var s = make();
+        s.mathField = stubField({
+          r1: ''
+        });
+        expect(s.promptContaining(undefined)).toBeUndefined();
+      });
+    });
+
+    // MathQuill's inner fields could be focused directly.
+    it('promptHandle exposes focus() for its own prompt', function () {
+      var s = make();
+      s.mathField = stubField({
+        r1: '',
+        r2: ''
+      });
+      s.promptHandle('r2').focus();
+      expect(s.mathField.focused).toBe(true);
+      expect(s.mathField.selection).toEqual({
+        ranges: [[10, 10]]
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_static","_interopRequireDefault","require","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","stubField","values","undefined","selection","getPrompts","getPromptValue","id","setPromptValue","v","getPromptRange","i","indexOf","position","commands","executeCommand","name","addEventListener","removeEventListener","focus","focused","blur","blurred","remove","make","props","Static","latex","getFieldName","describe","it","expect","isInteractive","toBe","toEqual","s","mathField","r1","r2","h","promptHandle","innerFields","map","f","onSubFieldChange","jest","fn","promptValues","onPromptInput","toHaveBeenCalledTimes","toHaveBeenCalledWith","handle","onSubFieldFocus","setInput","ranges","onPromptFocus","mock","calls","toHaveBeenCalled","not","toThrow","afterEach","document","body","innerHTML","createLiveRegion","liveRegion","getAttribute","contains","removeLiveRegion","toBeUndefined","first","announceConversion","textContent","onKeyDown","key","focusPrompt","promptContaining"],"sources":["../../src/__tests__/static-prompts.test.jsx"],"sourcesContent":["import Static from '../mf/static';\n\n/**\n * The answer-block contract: `\\MathQuillMathField[id]{}` in stored latex becomes\n * a MathLive prompt, and sub-field values/focus are surfaced through the same\n * callbacks @pie-lib/math-input exposed (`onSubFieldChange`, `onSubFieldFocus`,\n * `getFieldName`, `setInput`).\n *\n * Driven against a stub mathfield: a real <math-field> needs a browser, and what\n * matters here is the mapping, not MathLive's rendering.\n */\nconst stubField = (values = {}, selection = null) => ({\n  values: { ...values },\n  getPrompts() {\n    return Object.keys(this.values);\n  },\n  getPromptValue(id) {\n    return this.values[id];\n  },\n  setPromptValue(id, v) {\n    this.values[id] = v;\n  },\n  getPromptRange(id) {\n    const i = Object.keys(this.values).indexOf(id);\n\n    return [i * 10, i * 10 + 5];\n  },\n  selection,\n  // Caret bookkeeping: MathLive exposes the caret offset as `position`, and any\n  // executeCommand triggers the render that reveals the caret.\n  position: undefined,\n  commands: [],\n  executeCommand(name) {\n    this.commands.push(name);\n  },\n  addEventListener() {},\n  removeEventListener() {},\n  focus() {\n    this.focused = true;\n  },\n  blur() {\n    this.blurred = true;\n  },\n  remove() {},\n});\n\nconst make = (props = {}) => new Static({ latex: 'x=\\\\MathQuillMathField[r1]{}', getFieldName: () => {}, ...props });\n\ndescribe('Static: answer blocks / prompts', () => {\n  describe('isInteractive', () => {\n    it('is interactive when the latex has answer blocks', () => {\n      expect(make({ latex: 'x=\\\\MathQuillMathField[r1]{}' }).isInteractive()).toBe(true);\n      expect(make({ latex: 'x=\\\\placeholder[r1]{}' }).isInteractive()).toBe(true);\n    });\n\n    it('is display-only for plain latex', () => {\n      expect(make({ latex: '\\\\frac{1}{2}' }).isInteractive()).toBe(false);\n      expect(make({ latex: '' }).isInteractive()).toBe(false);\n    });\n  });\n\n  describe('values', () => {\n    it('returns {} before the field exists', () => {\n      expect(make().values()).toEqual({});\n    });\n\n    it('maps each prompt id to its stored-form latex', () => {\n      const s = make();\n\n      s.mathField = stubField({ r1: '7', r2: '\\\\placeholder{}' });\n\n      // \\placeholder must not leak into stored values\n      expect(s.values()).toEqual({ r1: '7', r2: '' });\n    });\n  });\n\n  describe('promptHandle / innerFields', () => {\n    it('exposes a MathQuill-field-like handle with get/set latex', () => {\n      const s = make();\n\n      s.mathField = stubField({ r1: '7' });\n\n      const h = s.promptHandle('r1');\n\n      expect(h.id).toEqual('r1');\n      expect(h.latex()).toEqual('7');\n\n      h.latex('9');\n      expect(s.mathField.values.r1).toEqual('9');\n    });\n\n    it('handle latex() is safe with no field', () => {\n      expect(make().promptHandle('r1').latex()).toEqual('');\n    });\n\n    it('innerFields returns one handle per prompt', () => {\n      const s = make();\n\n      s.mathField = stubField({ r1: '1', r2: '2' });\n\n      expect(s.innerFields.map((f) => f.id)).toEqual(['r1', 'r2']);\n      expect(make().innerFields).toEqual([]);\n    });\n  });\n\n  describe('onSubFieldChange', () => {\n    it('fires only for prompts whose value changed', () => {\n      const onSubFieldChange = jest.fn();\n      const s = make({ onSubFieldChange });\n\n      s.mathField = stubField({ r1: '1', r2: '2' });\n      s.promptValues = { r1: '1', r2: '2' };\n\n      s.mathField.values.r2 = '5';\n      s.onPromptInput();\n\n      expect(onSubFieldChange).toHaveBeenCalledTimes(1);\n      expect(onSubFieldChange).toHaveBeenCalledWith('r2', '5');\n    });\n\n    it('uses getFieldName when it returns a name', () => {\n      const onSubFieldChange = jest.fn();\n      const s = make({ onSubFieldChange, getFieldName: (handle) => 'named-' + handle.id });\n\n      s.mathField = stubField({ r1: '1' });\n      s.promptValues = {};\n\n      s.onPromptInput();\n\n      expect(onSubFieldChange).toHaveBeenCalledWith('named-r1', '1');\n    });\n\n    it('still tracks values when no callback is supplied', () => {\n      const s = make();\n\n      s.mathField = stubField({ r1: '3' });\n      s.onPromptInput();\n\n      expect(s.promptValues).toEqual({ r1: '3' });\n    });\n  });\n\n  describe('onSubFieldFocus', () => {\n    it('reports the prompt containing the selection, plus setInput', () => {\n      const onSubFieldFocus = jest.fn();\n      const setInput = jest.fn();\n      const s = make({ onSubFieldFocus, setInput });\n\n      // r2 occupies offsets 10..15\n      s.mathField = stubField({ r1: '', r2: '' }, { ranges: [[11, 11]] });\n      s.onPromptFocus();\n\n      expect(onSubFieldFocus).toHaveBeenCalledTimes(1);\n      expect(onSubFieldFocus.mock.calls[0][0]).toEqual('r2');\n      expect(onSubFieldFocus.mock.calls[0][1].id).toEqual('r2');\n      expect(setInput).toHaveBeenCalled();\n    });\n\n    it('does nothing without a selection', () => {\n      const onSubFieldFocus = jest.fn();\n      const s = make({ onSubFieldFocus });\n\n      s.mathField = stubField({ r1: '' }, null);\n      s.onPromptFocus();\n\n      expect(onSubFieldFocus).not.toHaveBeenCalled();\n    });\n\n    it('does not throw when the field is missing', () => {\n      const s = make({ onSubFieldFocus: jest.fn() });\n\n      expect(() => s.onPromptFocus()).not.toThrow();\n    });\n  });\n\n  describe('accessibility announcements', () => {\n    afterEach(() => {\n      document.body.innerHTML = '';\n    });\n\n    it('creates a polite off-screen live region', () => {\n      const s = make();\n\n      s.createLiveRegion();\n\n      expect(s.liveRegion.getAttribute('aria-live')).toEqual('polite');\n      expect(s.liveRegion.getAttribute('aria-atomic')).toEqual('true');\n      expect(document.body.contains(s.liveRegion)).toBe(true);\n\n      s.removeLiveRegion();\n      expect(s.liveRegion).toBeUndefined();\n    });\n\n    it('does not create a second region', () => {\n      const s = make();\n\n      s.createLiveRegion();\n      const first = s.liveRegion;\n\n      s.createLiveRegion();\n      expect(s.liveRegion).toBe(first);\n      s.removeLiveRegion();\n    });\n\n    it('announces when typed input expands into a command', () => {\n      const s = make();\n\n      s.createLiveRegion();\n      s.promptValues = { r1: 'x' };\n      // grew by more than one char AND gained a backslash => a conversion\n      s.announceConversion({ r1: 'x\\\\frac{}{}' });\n\n      expect(s.liveRegion.textContent).toEqual('Converted to math symbol');\n      s.removeLiveRegion();\n    });\n\n    it('does not announce ordinary typing', () => {\n      const s = make();\n\n      s.createLiveRegion();\n      s.promptValues = { r1: 'x' };\n      s.announceConversion({ r1: 'xy' });\n\n      expect(s.liveRegion.textContent).toEqual('');\n      s.removeLiveRegion();\n    });\n\n    it('does not announce a deletion', () => {\n      const s = make();\n\n      s.createLiveRegion();\n      s.promptValues = { r1: 'x\\\\frac{}{}' };\n      s.onKeyDown({ key: 'Backspace' });\n      s.announceConversion({ r1: 'x' });\n\n      expect(s.liveRegion.textContent).toEqual('');\n      s.removeLiveRegion();\n    });\n  });\n\n  describe('focus / blur', () => {\n    it('delegates to the field and is safe without one', () => {\n      const s = make();\n\n      expect(() => {\n        s.focus();\n        s.blur();\n      }).not.toThrow();\n\n      s.mathField = stubField();\n      s.focus();\n      s.blur();\n\n      expect(s.mathField.focused).toBe(true);\n      expect(s.mathField.blurred).toBe(true);\n    });\n  });\n\n  /**\n   * MathLive shows the caret only while the field carries `ML__focused`, which\n   * it adds during a render gated on `isSelectionEditable && hasFocus()`. In a\n   * read-only field only prompt interiors are editable, so after a bare\n   * `focus()` - whose selection sits outside every prompt - the answer block\n   * looked focused but had no blinking cursor. Verified in Chromium: the caret\n   * span goes from visibility:hidden to visible once the selection is inside a\n   * prompt AND a render has run.\n   */\n  describe('caret placement', () => {\n    it('puts a collapsed caret in the first prompt on focus', () => {\n      const s = make();\n\n      s.mathField = stubField({ r1: '', r2: '' });\n      s.focus();\n\n      // stub ranges are [0,5] for r1, [10,15] for r2\n      expect(s.mathField.selection).toEqual({ ranges: [[0, 0]] });\n    });\n\n    it('forces the render that makes the caret visible', () => {\n      const s = make();\n\n      s.mathField = stubField({ r1: '' });\n      s.focus();\n\n      // assigning `selection` alone updates the model without re-rendering, so\n      // ML__focused would never be added\n      expect(s.mathField.commands).toEqual(['scrollIntoView']);\n    });\n\n    it('does not move a caret that is already inside a prompt', () => {\n      const s = make();\n\n      s.mathField = stubField({ r1: '', r2: '' });\n      s.mathField.position = 12; // inside r2\n      s.focus();\n\n      expect(s.mathField.selection).toBe(null);\n      expect(s.mathField.commands).toEqual([]);\n    });\n\n    it('targets a specific prompt', () => {\n      const s = make();\n\n      s.mathField = stubField({ r1: '', r2: '' });\n      s.focusPrompt('r2');\n\n      expect(s.mathField.selection).toEqual({ ranges: [[10, 10]] });\n    });\n\n    it('falls back to the first prompt for an unknown id', () => {\n      const s = make();\n\n      s.mathField = stubField({ r1: '', r2: '' });\n      s.focusPrompt('nope');\n\n      expect(s.mathField.selection).toEqual({ ranges: [[0, 0]] });\n    });\n\n    it('is a no-op when there are no prompts', () => {\n      const s = make();\n\n      s.mathField = stubField({});\n\n      expect(() => s.focusPrompt()).not.toThrow();\n      expect(s.mathField.selection).toBe(null);\n    });\n\n    it('is safe without a field', () => {\n      expect(() => make().focusPrompt('r1')).not.toThrow();\n    });\n\n    describe('promptContaining', () => {\n      it('finds the prompt whose range holds the offset, inclusive', () => {\n        const s = make();\n\n        s.mathField = stubField({ r1: '', r2: '' });\n\n        expect(s.promptContaining(0)).toEqual('r1');\n        expect(s.promptContaining(5)).toEqual('r1');\n        expect(s.promptContaining(10)).toEqual('r2');\n        expect(s.promptContaining(7)).toBeUndefined();\n      });\n\n      it('treats a missing position as outside', () => {\n        const s = make();\n\n        s.mathField = stubField({ r1: '' });\n\n        expect(s.promptContaining(undefined)).toBeUndefined();\n      });\n    });\n\n    // MathQuill's inner fields could be focused directly.\n    it('promptHandle exposes focus() for its own prompt', () => {\n      const s = make();\n\n      s.mathField = stubField({ r1: '', r2: '' });\n      s.promptHandle('r2').focus();\n\n      expect(s.mathField.focused).toBe(true);\n      expect(s.mathField.selection).toEqual({ ranges: [[10, 10]] });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/__tests__/tmp-markup.test.js

@@ -0,0 +1,26 @@
+"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 _mathliveInstance = require("../mathlive-instance");
+describe('tmp', function () {
+  it('prints markup', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    return _regenerator["default"].wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 1;
+          return (0, _mathliveInstance.loadMathLive)();
+        case 1:
+          // eslint-disable-next-line no-console
+          console.log('SQRT1:', (0, _mathliveInstance.latexToMarkup)('\\sqrt[1]{2}'));
+          // eslint-disable-next-line no-console
+          console.log('NTHROOT:', (0, _mathliveInstance.latexToMarkup)('\\sqrt[{}]{}'));
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfbWF0aGxpdmVJbnN0YW5jZSIsInJlcXVpcmUiLCJkZXNjcmliZSIsIml0IiwiX2FzeW5jVG9HZW5lcmF0b3IyIiwiX3JlZ2VuZXJhdG9yIiwibWFyayIsIl9jYWxsZWUiLCJ3cmFwIiwiX2NvbnRleHQiLCJwcmV2IiwibmV4dCIsImxvYWRNYXRoTGl2ZSIsImNvbnNvbGUiLCJsb2ciLCJsYXRleFRvTWFya3VwIiwic3RvcCJdLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9fX3Rlc3RzX18vdG1wLW1hcmt1cC50ZXN0LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGxvYWRNYXRoTGl2ZSwgbGF0ZXhUb01hcmt1cCB9IGZyb20gJy4uL21hdGhsaXZlLWluc3RhbmNlJztcblxuZGVzY3JpYmUoJ3RtcCcsICgpID0+IHtcbiAgaXQoJ3ByaW50cyBtYXJrdXAnLCBhc3luYyAoKSA9PiB7XG4gICAgYXdhaXQgbG9hZE1hdGhMaXZlKCk7XG4gICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWNvbnNvbGVcbiAgICBjb25zb2xlLmxvZygnU1FSVDE6JywgbGF0ZXhUb01hcmt1cCgnXFxcXHNxcnRbMV17Mn0nKSk7XG4gICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLWNvbnNvbGVcbiAgICBjb25zb2xlLmxvZygnTlRIUk9PVDonLCBsYXRleFRvTWFya3VwKCdcXFxcc3FydFt7fV17fScpKTtcbiAgfSk7XG59KTtcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSxJQUFBQSxpQkFBQSxHQUFBQyxPQUFBO0FBRUFDLFFBQVEsQ0FBQyxLQUFLLEVBQUUsWUFBTTtFQUNwQkMsRUFBRSxDQUFDLGVBQWUsbUJBQUFDLGtCQUFBLDBCQUFBQyxZQUFBLFlBQUFDLElBQUEsQ0FBRSxTQUFBQyxRQUFBO0lBQUEsT0FBQUYsWUFBQSxZQUFBRyxJQUFBLFdBQUFDLFFBQUE7TUFBQSxrQkFBQUEsUUFBQSxDQUFBQyxJQUFBLEdBQUFELFFBQUEsQ0FBQUUsSUFBQTtRQUFBO1VBQUFGLFFBQUEsQ0FBQUUsSUFBQTtVQUFBLE9BQ1osSUFBQUMsOEJBQVksRUFBQyxDQUFDO1FBQUE7VUFDcEI7VUFDQUMsT0FBTyxDQUFDQyxHQUFHLENBQUMsUUFBUSxFQUFFLElBQUFDLCtCQUFhLEVBQUMsY0FBYyxDQUFDLENBQUM7VUFDcEQ7VUFDQUYsT0FBTyxDQUFDQyxHQUFHLENBQUMsVUFBVSxFQUFFLElBQUFDLCtCQUFhLEVBQUMsY0FBYyxDQUFDLENBQUM7UUFBQztRQUFBO1VBQUEsT0FBQU4sUUFBQSxDQUFBTyxJQUFBO01BQUE7SUFBQSxHQUFBVCxPQUFBO0VBQUEsQ0FDeEQsR0FBQztBQUNKLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==

package/lib/keypad/index.js

@@ -41,11 +41,32 @@ var log = (0, _debug["default"])('pie-lib:math-input-mathlive:keypad');
  * `convertLatexToMarkup`, so a 40-key keypad no longer creates 40 live math
  * instances.
  */
+// Labels that the legacy keypad drew slanted. MathQuill styled `\parallel` as
+// italic, which slants the two bars; MathLive draws it upright. A skew is used
+// rather than `font-style: italic` so the slant does not depend on the font
+// having an italic face for this glyph.
+var SLANTED_LABELS = ['\\parallel'];
+var SLANT = 'skewX(-15deg)';
+// MathLive's `∥` has hairline bars next to the radical sign and the other keys, so
+// they are thickened with a text stroke and stretched a little taller.
+var SLANTED_STROKE = '0.03em currentColor';
+var SLANTED_SCALE_Y = 1.25;
+
 // The `color.*()` helpers must be called lazily, inside the styled callback.
 // Evaluating them in a plain object literal runs them at module load, which
 // breaks any consumer that mocks a subset of @pie-lib/render-ui.
-var LabelHolder = (0, _styles.styled)('span')(function () {
-  return _objectSpread({
+var LabelHolder = (0, _styles.styled)('span', {
+  shouldForwardProp: function shouldForwardProp(prop) {
+    return prop !== 'slanted';
+  }
+})(function (_ref) {
+  var slanted = _ref.slanted;
+  return _objectSpread(_objectSpread({}, slanted && {
+    transform: "".concat(SLANT, " scaleY(").concat(SLANTED_SCALE_Y, ")"),
+    '& *': {
+      WebkitTextStroke: SLANTED_STROKE
+    }
+  }), {}, {
     pointerEvents: 'none',
     textTransform: 'none',
     color: _renderUi.color.text(),
@@ -161,10 +182,13 @@ var LatexLabel = exports.LatexLabel = /*#__PURE__*/function (_React$Component) {
       /*#__PURE__*/
       // eslint-disable-next-line react/no-danger
       _react["default"].createElement(LabelHolder, {
+        slanted: SLANTED_LABELS.includes(this.props.latex),
         dangerouslySetInnerHTML: {
           __html: markup
         }
-      }) : /*#__PURE__*/_react["default"].createElement(LabelHolder, null, this.props.latex);
+      }) : /*#__PURE__*/_react["default"].createElement(LabelHolder, {
+        slanted: SLANTED_LABELS.includes(this.props.latex)
+      }, this.props.latex);
     }
   }]);
 }(_react["default"].Component);
@@ -209,11 +233,11 @@ var buttonBackground = function buttonBackground(category) {
     }
   };
 };
-var StyledButton = (0, _styles.styled)(_Button["default"])(function (_ref) {
-  var category = _ref.category,
-    isDelete = _ref.isDelete,
-    isComma = _ref.isComma,
-    isDot = _ref.isDot;
+var StyledButton = (0, _styles.styled)(_Button["default"])(function (_ref2) {
+  var category = _ref2.category,
+    isDelete = _ref2.isDelete,
+    isComma = _ref2.isComma,
+    isDot = _ref2.isDot;
   return _objectSpread(_objectSpread({
     minWidth: 'auto',
     textTransform: 'none',
@@ -226,8 +250,8 @@ var StyledButton = (0, _styles.styled)(_Button["default"])(function (_ref) {
     fontFamily: 'Roboto, Helvetica, Arial, sans-serif !important'
   });
 });
-var StyledLatexButtonWrapper = (0, _styles.styled)(_Button["default"])(function (_ref2) {
-  var category = _ref2.category;
+var StyledLatexButtonWrapper = (0, _styles.styled)(_Button["default"])(function (_ref3) {
+  var category = _ref3.category;
   return _objectSpread({
     textTransform: 'none',
     padding: 0,
@@ -237,8 +261,8 @@ var StyledLatexButtonWrapper = (0, _styles.styled)(_Button["default"])(function
     borderRadius: 0
   }, buttonBackground(category));
 });
-var StyledIconButton = (0, _styles.styled)(_IconButton["default"])(function (_ref3) {
-  var category = _ref3.category;
+var StyledIconButton = (0, _styles.styled)(_IconButton["default"])(function (_ref4) {
+  var category = _ref4.category;
   return _objectSpread(_objectSpread({
     minWidth: 'auto'
   }, buttonBackground(category)), {}, {