@pie-lib/graphing 4.0.24-beta.13 → 4.0.24-beta.15

package/lib/__tests__/mark-label.test.js

@@ -1,6 +1,7 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _testUtils = require("@pie-lib/test-utils");
 var _react = _interopRequireDefault(require("react"));
@@ -44,6 +45,613 @@ describe('MarkLabel', function () {
     });
   });
 });
+describe('MarkLabel - editing', function () {
+  var onChange;
+  var onBlur;
+  beforeEach(function () {
+    onChange = jest.fn();
+    onBlur = jest.fn();
+  });
+
+  // the label input is the only input MarkLabel renders (react-input-autosize)
+  var input = function input(container) {
+    return container.querySelector('input');
+  };
+  var renderComponent = function renderComponent(extras) {
+    var defaults = {
+      onChange: onChange,
+      onBlur: onBlur,
+      inputRef: jest.fn(),
+      mark: {
+        x: 1,
+        y: 1,
+        label: ''
+      },
+      graphProps: (0, _utils.graphProps)(0, 10, 0, 10)
+    };
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+    var result = (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_markLabel.MarkLabel, props));
+    return _objectSpread(_objectSpread({}, result), {}, {
+      input: input(result.container),
+      rerenderWith: function rerenderWith(next) {
+        return result.rerender(/*#__PURE__*/_react["default"].createElement(_markLabel.MarkLabel, (0, _extends2["default"])({}, props, next)));
+      }
+    });
+  };
+  describe('autoFocus', function () {
+    it('focuses the input so a new label can be typed into right away', function () {
+      var _renderComponent3 = renderComponent({
+          autoFocus: true
+        }),
+        input = _renderComponent3.input;
+      expect(document.activeElement).toBe(input);
+    });
+    it('leaves the caret at the end of an existing label', function () {
+      var _renderComponent4 = renderComponent({
+          autoFocus: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'AB'
+          }
+        }),
+        input = _renderComponent4.input;
+      expect(document.activeElement).toBe(input);
+      expect(input.selectionStart).toBe(2);
+      expect(input.selectionEnd).toBe(2);
+    });
+    it('does not focus the input of an existing label when autoFocus is not set', function () {
+      var _renderComponent5 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'A'
+          }
+        }),
+        input = _renderComponent5.input;
+      expect(document.activeElement).not.toBe(input);
+    });
+    it('does not focus the input when disabled', function () {
+      var _renderComponent6 = renderComponent({
+          autoFocus: true,
+          disabled: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'A'
+          }
+        }),
+        input = _renderComponent6.input;
+      expect(document.activeElement).not.toBe(input);
+    });
+    it('does not focus the input of a disabled mark', function () {
+      var _renderComponent7 = renderComponent({
+          autoFocus: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'A',
+            disabled: true
+          }
+        }),
+        input = _renderComponent7.input;
+      expect(document.activeElement).not.toBe(input);
+    });
+
+    // the focus can go away without this component hearing about it - the input node gets replaced
+    // by a render higher up, so no blur is fired and autoFocus is still on
+    it('takes the focus back on the next render while it is still being edited', function () {
+      var _renderComponent8 = renderComponent({
+          autoFocus: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'A'
+          }
+        }),
+        input = _renderComponent8.input,
+        rerenderWith = _renderComponent8.rerenderWith;
+      expect(document.activeElement).toBe(input);
+      input.blur();
+      expect(document.activeElement).not.toBe(input);
+      rerenderWith({
+        mark: {
+          x: 1,
+          y: 1,
+          label: 'A'
+        }
+      });
+      expect(document.activeElement).toBe(input);
+    });
+    it('leaves the caret where the user put it while the input has the focus', function () {
+      var _renderComponent9 = renderComponent({
+          autoFocus: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'ABC'
+          }
+        }),
+        input = _renderComponent9.input,
+        rerenderWith = _renderComponent9.rerenderWith;
+      input.setSelectionRange(1, 1);
+      rerenderWith({
+        mark: {
+          x: 1,
+          y: 1,
+          label: 'ABC'
+        }
+      });
+      expect(document.activeElement).toBe(input);
+      expect(input.selectionStart).toBe(1);
+    });
+    it('focuses the input once it is no longer disabled', function () {
+      var _renderComponent0 = renderComponent({
+          autoFocus: true,
+          disabled: true
+        }),
+        rerenderWith = _renderComponent0.rerenderWith,
+        container = _renderComponent0.container;
+      rerenderWith({
+        disabled: false
+      });
+      expect(document.activeElement).toBe(input(container));
+    });
+
+    // the host saves the model with an api call and the model that comes back can replace the
+    // input node - the label has to keep the focus across that remount
+    it('re-focuses the input when it is remounted while being edited', function () {
+      var props = {
+        autoFocus: true,
+        onChange: onChange,
+        inputRef: jest.fn(),
+        mark: {
+          x: 1,
+          y: 1,
+          label: 'A'
+        },
+        graphProps: (0, _utils.graphProps)(0, 10, 0, 10)
+      };
+      var _render = (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_markLabel.MarkLabel, (0, _extends2["default"])({
+          key: "first"
+        }, props))),
+        container = _render.container,
+        rerender = _render.rerender;
+      var first = input(container);
+      expect(document.activeElement).toBe(first);
+      rerender(/*#__PURE__*/_react["default"].createElement(_markLabel.MarkLabel, (0, _extends2["default"])({
+        key: "second"
+      }, props)));
+      var second = input(container);
+      expect(second).not.toBe(first);
+      expect(document.activeElement).toBe(second);
+    });
+  });
+
+  // the tool asks for the focus with autoFocus, but its state can be gone before the input renders:
+  // the marks come back from the host asynchronously and can remount the tool. An empty label in
+  // label mode is a label the user has just added, so the input can tell on its own.
+  describe('a label that was just added', function () {
+    it('focuses itself without the tool asking', function () {
+      var _renderComponent1 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        input = _renderComponent1.input;
+      expect(document.activeElement).toBe(input);
+    });
+    it('focuses itself again when it is remounted before it was typed into', function () {
+      var props = {
+        onChange: onChange,
+        onBlur: onBlur,
+        inputRef: jest.fn(),
+        mark: {
+          x: 1,
+          y: 1,
+          label: ''
+        },
+        graphProps: (0, _utils.graphProps)(0, 10, 0, 10)
+      };
+      var _render2 = (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_markLabel.MarkLabel, (0, _extends2["default"])({
+          key: "first"
+        }, props))),
+        container = _render2.container,
+        rerender = _render2.rerender;
+      var first = input(container);
+      rerender(/*#__PURE__*/_react["default"].createElement(_markLabel.MarkLabel, (0, _extends2["default"])({
+        key: "second"
+      }, props)));
+      var second = input(container);
+      expect(second).not.toBe(first);
+      expect(document.activeElement).toBe(second);
+    });
+    it('stops chasing the focus once it has been left', function () {
+      var _renderComponent10 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        input = _renderComponent10.input,
+        rerenderWith = _renderComponent10.rerenderWith;
+      expect(document.activeElement).toBe(input);
+      input.blur();
+      rerenderWith({
+        mark: {
+          x: 1,
+          y: 1,
+          label: ''
+        }
+      });
+      expect(document.activeElement).not.toBe(input);
+    });
+
+    // outside of label mode the input is disabled, which is how an empty label that was loaded with
+    // the item is told apart from one the user has just added - label mode always starts off
+    // the config draws the background marks into the correct answer graphs as disabled marks
+    it('is not rendered at all while it cannot be edited', function () {
+      var _renderComponent11 = renderComponent({
+          disabled: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        container = _renderComponent11.container;
+      expect(container.querySelector('input')).toBe(null);
+    });
+    it('is still rendered uneditable once it has text', function () {
+      var _renderComponent12 = renderComponent({
+          disabled: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'A'
+          }
+        }),
+        container = _renderComponent12.container;
+      expect(container.querySelector('input').value).toBe('A');
+    });
+    it('is not focused when label mode is turned on afterwards', function () {
+      var _renderComponent13 = renderComponent({
+          disabled: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        rerenderWith = _renderComponent13.rerenderWith,
+        container = _renderComponent13.container;
+      rerenderWith({
+        disabled: false
+      });
+      expect(input(container)).not.toBe(null);
+      expect(document.activeElement).not.toBe(input(container));
+    });
+    it('is not rendered for a disabled mark while it is empty', function () {
+      var _renderComponent14 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: '',
+            disabled: true
+          }
+        }),
+        container = _renderComponent14.container;
+      expect(container.querySelector('input')).toBe(null);
+    });
+
+    // an input sized to its content is 2px wide while it is empty, and chrome paints the caret of
+    // an input inside an svg foreignObject as a hairline that never blinks - so an empty label that
+    // has the focus has to be wide enough to be seen as a box waiting for text
+    it('is wide enough to be seen while it is empty', function () {
+      var _renderComponent15 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        input = _renderComponent15.input;
+      expect(parseInt(input.style.width, 10)).toBeGreaterThanOrEqual(30);
+    });
+    it('is only as wide as its text once it cannot be edited', function () {
+      var _renderComponent16 = renderComponent({
+          disabled: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'A'
+          }
+        }),
+        container = _renderComponent16.container;
+      expect(parseInt(container.querySelector('input').style.width, 10)).toBeLessThan(30);
+    });
+  });
+  describe('syncing mark.label into the input', function () {
+    it('picks up a new mark.label while the input does not have the focus', function () {
+      var _renderComponent17 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'A'
+          }
+        }),
+        rerenderWith = _renderComponent17.rerenderWith,
+        container = _renderComponent17.container;
+      rerenderWith({
+        mark: {
+          x: 1,
+          y: 1,
+          label: 'updated'
+        }
+      });
+      expect(input(container).value).toBe('updated');
+    });
+
+    // a mark coming back from an (async) model save can carry an older label - applying it would
+    // wipe out the characters typed in the meantime
+    it('keeps what the user typed while the input has the focus', function () {
+      var _renderComponent18 = renderComponent({
+          autoFocus: true
+        }),
+        input = _renderComponent18.input,
+        rerenderWith = _renderComponent18.rerenderWith;
+      expect(document.activeElement).toBe(input);
+      _testUtils.fireEvent.change(input, {
+        target: {
+          value: 'AB'
+        }
+      });
+      expect(input.value).toBe('AB');
+
+      // the host echoes back the label as it was one keystroke ago
+      rerenderWith({
+        mark: {
+          x: 1,
+          y: 1,
+          label: 'A'
+        }
+      });
+      expect(input.value).toBe('AB');
+    });
+  });
+
+  // the characters land at the document's caret, not at the focused node. In the authoring
+  // environment the input ends up focused with no caret anywhere: keypress fires and nothing is
+  // inserted. jsdom never reports a caret either, so this is that state - the focus cycle that
+  // repairs it must not hand the label over to the blur handling.
+  describe('a focused input with no caret', function () {
+    it('is repaired without reporting the label as removed', function () {
+      var _renderComponent19 = renderComponent({
+          autoFocus: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        input = _renderComponent19.input;
+      expect(document.activeElement).toBe(input);
+      expect(onChange).not.toHaveBeenCalled();
+      expect(onBlur).not.toHaveBeenCalled();
+    });
+    it('leaves the caret at the end of a label that already has text', function () {
+      var _renderComponent20 = renderComponent({
+          autoFocus: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'AB'
+          }
+        }),
+        input = _renderComponent20.input;
+      expect(document.activeElement).toBe(input);
+      expect(input.selectionStart).toBe(2);
+      expect(onChange).not.toHaveBeenCalled();
+    });
+  });
+
+  // clicking another window, the devtools, or the host moving the focus while it saves the model:
+  // the label is not being left, so it must survive and take the focus back
+  describe('while the window is away', function () {
+    var windowGoesAway = function windowGoesAway() {
+      return window.dispatchEvent(new Event('blur'));
+    };
+    var windowComesBack = function windowComesBack() {
+      return window.dispatchEvent(new Event('focus'));
+    };
+    it('keeps an empty label instead of reporting it as removed', function () {
+      var _renderComponent21 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        input = _renderComponent21.input;
+      windowGoesAway();
+      _testUtils.fireEvent.blur(input);
+      expect(onChange).not.toHaveBeenCalled();
+      expect(onBlur).not.toHaveBeenCalled();
+    });
+    it('takes the focus back when the window comes back', function () {
+      var _renderComponent22 = renderComponent({
+          autoFocus: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        input = _renderComponent22.input;
+
+      // the focus is moved to another input rather than with input.blur(): jsdom fires a window
+      // focus event as part of blur(), which is the very thing being tested here
+      var elsewhere = document.createElement('input');
+      document.body.appendChild(elsewhere);
+      windowGoesAway();
+      elsewhere.focus();
+      expect(document.activeElement).toBe(elsewhere);
+      windowComesBack();
+      expect(document.activeElement).toBe(input);
+      elsewhere.remove();
+    });
+    it('still reports a label the user leaves once the window is back', function () {
+      var _renderComponent23 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        input = _renderComponent23.input;
+      windowGoesAway();
+      windowComesBack();
+      _testUtils.fireEvent.blur(input);
+      expect(onChange).toHaveBeenCalledWith('');
+    });
+  });
+  describe('onBlur', function () {
+    it('is called so the tool stops auto focusing the label', function () {
+      var _renderComponent24 = renderComponent({
+          autoFocus: true,
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'A'
+          }
+        }),
+        input = _renderComponent24.input;
+      _testUtils.fireEvent.blur(input);
+      expect(onBlur).toHaveBeenCalled();
+    });
+
+    // clicking a button or anything else interactive blurs the label while the debounce is pending
+    it('saves what was typed straight away', function () {
+      var _renderComponent25 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        input = _renderComponent25.input;
+      _testUtils.fireEvent.change(input, {
+        target: {
+          value: 'AB'
+        }
+      });
+      _testUtils.fireEvent.blur(input);
+      expect(onChange).toHaveBeenCalledWith('AB');
+    });
+    it('does not save it twice when the debounce catches up', function () {
+      jest.useFakeTimers();
+      var _renderComponent26 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: ''
+          }
+        }),
+        input = _renderComponent26.input;
+      _testUtils.fireEvent.change(input, {
+        target: {
+          value: 'AB'
+        }
+      });
+      _testUtils.fireEvent.blur(input);
+      (0, _testUtils.act)(function () {
+        return jest.advanceTimersByTime(1000);
+      });
+      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledWith('AB');
+      jest.useRealTimers();
+    });
+    it('reports an empty label on blur', function () {
+      var _renderComponent27 = renderComponent({
+          mark: {
+            x: 1,
+            y: 1,
+            label: 'A'
+          }
+        }),
+        input = _renderComponent27.input;
+      _testUtils.fireEvent.change(input, {
+        target: {
+          value: ''
+        }
+      });
+      _testUtils.fireEvent.blur(input);
+      expect(onChange).toHaveBeenCalledWith('');
+    });
+  });
+  describe('debounce', function () {
+    beforeEach(function () {
+      return jest.useFakeTimers();
+    });
+    afterEach(function () {
+      return jest.useRealTimers();
+    });
+    it('does not report the typed label before the debounce delay elapses', function () {
+      var _renderComponent28 = renderComponent({
+          autoFocus: true
+        }),
+        input = _renderComponent28.input;
+      _testUtils.fireEvent.change(input, {
+        target: {
+          value: 'A'
+        }
+      });
+      (0, _testUtils.act)(function () {
+        return jest.advanceTimersByTime(499);
+      });
+      expect(onChange).not.toHaveBeenCalled();
+      (0, _testUtils.act)(function () {
+        return jest.advanceTimersByTime(1);
+      });
+      expect(onChange).toHaveBeenCalledWith('A');
+    });
+    it('reports the label once for a burst of keystrokes', function () {
+      var _renderComponent29 = renderComponent({
+          autoFocus: true
+        }),
+        input = _renderComponent29.input;
+      _testUtils.fireEvent.change(input, {
+        target: {
+          value: 'A'
+        }
+      });
+      (0, _testUtils.act)(function () {
+        return jest.advanceTimersByTime(300);
+      });
+      _testUtils.fireEvent.change(input, {
+        target: {
+          value: 'AB'
+        }
+      });
+      (0, _testUtils.act)(function () {
+        return jest.advanceTimersByTime(300);
+      });
+      _testUtils.fireEvent.change(input, {
+        target: {
+          value: 'ABC'
+        }
+      });
+      (0, _testUtils.act)(function () {
+        return jest.advanceTimersByTime(500);
+      });
+      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledWith('ABC');
+    });
+  });
+});
 describe('position', function () {
   var assertPosition = function assertPosition(mark, rect, expected) {
     it("".concat(mark.x, ",").concat(mark.y, " + ").concat(rect.width, ",").concat(rect.height, " => ").concat(expected), function () {
@@ -130,4 +738,4 @@ describe('coordinates', function () {
     top: 5
   });
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_testUtils","require","_react","_interopRequireDefault","_markLabel","_utils","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","describe","onChange","jest","fn","inputRef","renderComponent","extras","defaults","classes","className","mark","x","y","graphProps","getGraphProps","props","render","createElement","MarkLabel","it","_renderComponent","container","expect","firstChild","toBeInTheDocument","_renderComponent2","assertPosition","rect","expected","concat","width","height","result","position","toEqual","assertCoordinates","pos","left","top","coordinates"],"sources":["../../src/__tests__/mark-label.test.jsx"],"sourcesContent":["import { render } from '@pie-lib/test-utils';\nimport React from 'react';\nimport { coordinates, MarkLabel, position } from '../mark-label';\nimport { graphProps as getGraphProps } from './utils';\n\ndescribe('MarkLabel', () => {\n  let onChange = jest.fn();\n  let inputRef = jest.fn();\n  const renderComponent = (extras) => {\n    const defaults = {\n      classes: {},\n      className: 'className',\n      onChange,\n      inputRef,\n      mark: { x: 1, y: 1 },\n      graphProps: getGraphProps(0, 10, 0, 10),\n    };\n    const props = { ...defaults, ...extras };\n    return render(<MarkLabel {...props} />);\n  };\n  describe('rendering', () => {\n    it('renders without crashing', () => {\n      const { container } = renderComponent();\n      expect(container.firstChild).toBeInTheDocument();\n    });\n    it('renders with different mark position', () => {\n      const { container } = renderComponent({ mark: { x: 10, y: 10 } });\n      expect(container.firstChild).toBeInTheDocument();\n    });\n  });\n});\n\ndescribe('position', () => {\n  const assertPosition = (mark, rect, expected) => {\n    it(`${mark.x},${mark.y} + ${rect.width},${rect.height} => ${expected}`, () => {\n      // we set range.min to a value because in pixels - the greater the Y the lower down on the screen.\n      const graphProps = getGraphProps(0, 12, 12, 0);\n      const result = position(graphProps, mark, rect);\n      expect(result).toEqual(expected);\n    });\n  };\n\n  assertPosition({ x: 0, y: 0 }, { width: 10, height: 10 }, 'top-left');\n  assertPosition({ x: 0, y: 0 }, { width: 1, height: 1 }, 'bottom-right');\n  assertPosition({ x: 0, y: 0 }, { width: 10, height: 0 }, 'bottom-left');\n  assertPosition({ x: 0, y: 0 }, { width: 0, height: 10 }, 'top-right');\n});\n\ndescribe('coordinates', () => {\n  const assertCoordinates = (mark, rect, pos, expected) => {\n    it(`${mark.x}, ${mark.y} -> ${pos} = ${expected.left}, ${expected.top}`, () => {\n      const result = coordinates(getGraphProps(), mark, rect, pos);\n      expect(result).toEqual(expected);\n    });\n  };\n  assertCoordinates({ x: 0, y: 0 }, { width: 0, height: 0 }, 'top-left', { left: -5, top: -5 });\n  assertCoordinates({ x: 0, y: 0 }, { width: 0, height: 0 }, 'bottom-left', { left: -5, top: 5 });\n  assertCoordinates({ x: 0, y: 0 }, { width: 0, height: 0 }, 'top-right', { left: 5, top: -5 });\n  assertCoordinates({ x: 0, y: 0 }, { width: 0, height: 0 }, 'bottom-right', {\n    left: 5,\n    top: 5,\n  });\n});\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_testUtils","require","_react","_interopRequireDefault","_markLabel","_utils","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","describe","onChange","jest","fn","inputRef","renderComponent","extras","defaults","classes","className","mark","x","y","graphProps","getGraphProps","props","render","createElement","MarkLabel","it","_renderComponent","container","expect","firstChild","toBeInTheDocument","_renderComponent2","onBlur","beforeEach","input","querySelector","label","result","rerenderWith","next","rerender","_extends2","_renderComponent3","autoFocus","document","activeElement","toBe","_renderComponent4","selectionStart","selectionEnd","_renderComponent5","not","_renderComponent6","disabled","_renderComponent7","_renderComponent8","blur","_renderComponent9","setSelectionRange","_renderComponent0","_render","key","first","second","_renderComponent1","_render2","_renderComponent10","_renderComponent11","_renderComponent12","value","_renderComponent13","_renderComponent14","_renderComponent15","parseInt","style","width","toBeGreaterThanOrEqual","_renderComponent16","toBeLessThan","_renderComponent17","_renderComponent18","fireEvent","change","target","_renderComponent19","toHaveBeenCalled","_renderComponent20","windowGoesAway","window","dispatchEvent","Event","windowComesBack","_renderComponent21","_renderComponent22","elsewhere","body","appendChild","focus","remove","_renderComponent23","toHaveBeenCalledWith","_renderComponent24","_renderComponent25","useFakeTimers","_renderComponent26","act","advanceTimersByTime","toHaveBeenCalledTimes","useRealTimers","_renderComponent27","afterEach","_renderComponent28","_renderComponent29","assertPosition","rect","expected","concat","height","position","toEqual","assertCoordinates","pos","left","top","coordinates"],"sources":["../../src/__tests__/mark-label.test.jsx"],"sourcesContent":["import { act, fireEvent, render } from '@pie-lib/test-utils';\nimport React from 'react';\nimport { coordinates, MarkLabel, position } from '../mark-label';\nimport { graphProps as getGraphProps } from './utils';\n\ndescribe('MarkLabel', () => {\n  let onChange = jest.fn();\n  let inputRef = jest.fn();\n  const renderComponent = (extras) => {\n    const defaults = {\n      classes: {},\n      className: 'className',\n      onChange,\n      inputRef,\n      mark: { x: 1, y: 1 },\n      graphProps: getGraphProps(0, 10, 0, 10),\n    };\n    const props = { ...defaults, ...extras };\n    return render(<MarkLabel {...props} />);\n  };\n  describe('rendering', () => {\n    it('renders without crashing', () => {\n      const { container } = renderComponent();\n      expect(container.firstChild).toBeInTheDocument();\n    });\n    it('renders with different mark position', () => {\n      const { container } = renderComponent({ mark: { x: 10, y: 10 } });\n      expect(container.firstChild).toBeInTheDocument();\n    });\n  });\n});\n\ndescribe('MarkLabel - editing', () => {\n  let onChange;\n  let onBlur;\n\n  beforeEach(() => {\n    onChange = jest.fn();\n    onBlur = jest.fn();\n  });\n\n  // the label input is the only input MarkLabel renders (react-input-autosize)\n  const input = (container) => container.querySelector('input');\n\n  const renderComponent = (extras) => {\n    const defaults = {\n      onChange,\n      onBlur,\n      inputRef: jest.fn(),\n      mark: { x: 1, y: 1, label: '' },\n      graphProps: getGraphProps(0, 10, 0, 10),\n    };\n    const props = { ...defaults, ...extras };\n    const result = render(<MarkLabel {...props} />);\n\n    return {\n      ...result,\n      input: input(result.container),\n      rerenderWith: (next) => result.rerender(<MarkLabel {...props} {...next} />),\n    };\n  };\n\n  describe('autoFocus', () => {\n    it('focuses the input so a new label can be typed into right away', () => {\n      const { input } = renderComponent({ autoFocus: true });\n\n      expect(document.activeElement).toBe(input);\n    });\n\n    it('leaves the caret at the end of an existing label', () => {\n      const { input } = renderComponent({ autoFocus: true, mark: { x: 1, y: 1, label: 'AB' } });\n\n      expect(document.activeElement).toBe(input);\n      expect(input.selectionStart).toBe(2);\n      expect(input.selectionEnd).toBe(2);\n    });\n\n    it('does not focus the input of an existing label when autoFocus is not set', () => {\n      const { input } = renderComponent({ mark: { x: 1, y: 1, label: 'A' } });\n\n      expect(document.activeElement).not.toBe(input);\n    });\n\n    it('does not focus the input when disabled', () => {\n      const { input } = renderComponent({ autoFocus: true, disabled: true, mark: { x: 1, y: 1, label: 'A' } });\n\n      expect(document.activeElement).not.toBe(input);\n    });\n\n    it('does not focus the input of a disabled mark', () => {\n      const { input } = renderComponent({ autoFocus: true, mark: { x: 1, y: 1, label: 'A', disabled: true } });\n\n      expect(document.activeElement).not.toBe(input);\n    });\n\n    // the focus can go away without this component hearing about it - the input node gets replaced\n    // by a render higher up, so no blur is fired and autoFocus is still on\n    it('takes the focus back on the next render while it is still being edited', () => {\n      const { input, rerenderWith } = renderComponent({ autoFocus: true, mark: { x: 1, y: 1, label: 'A' } });\n\n      expect(document.activeElement).toBe(input);\n\n      input.blur();\n      expect(document.activeElement).not.toBe(input);\n\n      rerenderWith({ mark: { x: 1, y: 1, label: 'A' } });\n\n      expect(document.activeElement).toBe(input);\n    });\n\n    it('leaves the caret where the user put it while the input has the focus', () => {\n      const { input, rerenderWith } = renderComponent({ autoFocus: true, mark: { x: 1, y: 1, label: 'ABC' } });\n\n      input.setSelectionRange(1, 1);\n\n      rerenderWith({ mark: { x: 1, y: 1, label: 'ABC' } });\n\n      expect(document.activeElement).toBe(input);\n      expect(input.selectionStart).toBe(1);\n    });\n\n    it('focuses the input once it is no longer disabled', () => {\n      const { rerenderWith, container } = renderComponent({ autoFocus: true, disabled: true });\n\n      rerenderWith({ disabled: false });\n\n      expect(document.activeElement).toBe(input(container));\n    });\n\n    // the host saves the model with an api call and the model that comes back can replace the\n    // input node - the label has to keep the focus across that remount\n    it('re-focuses the input when it is remounted while being edited', () => {\n      const props = {\n        autoFocus: true,\n        onChange,\n        inputRef: jest.fn(),\n        mark: { x: 1, y: 1, label: 'A' },\n        graphProps: getGraphProps(0, 10, 0, 10),\n      };\n      const { container, rerender } = render(<MarkLabel key=\"first\" {...props} />);\n      const first = input(container);\n\n      expect(document.activeElement).toBe(first);\n\n      rerender(<MarkLabel key=\"second\" {...props} />);\n      const second = input(container);\n\n      expect(second).not.toBe(first);\n      expect(document.activeElement).toBe(second);\n    });\n  });\n\n  // the tool asks for the focus with autoFocus, but its state can be gone before the input renders:\n  // the marks come back from the host asynchronously and can remount the tool. An empty label in\n  // label mode is a label the user has just added, so the input can tell on its own.\n  describe('a label that was just added', () => {\n    it('focuses itself without the tool asking', () => {\n      const { input } = renderComponent({ mark: { x: 1, y: 1, label: '' } });\n\n      expect(document.activeElement).toBe(input);\n    });\n\n    it('focuses itself again when it is remounted before it was typed into', () => {\n      const props = {\n        onChange,\n        onBlur,\n        inputRef: jest.fn(),\n        mark: { x: 1, y: 1, label: '' },\n        graphProps: getGraphProps(0, 10, 0, 10),\n      };\n      const { container, rerender } = render(<MarkLabel key=\"first\" {...props} />);\n      const first = input(container);\n\n      rerender(<MarkLabel key=\"second\" {...props} />);\n      const second = input(container);\n\n      expect(second).not.toBe(first);\n      expect(document.activeElement).toBe(second);\n    });\n\n    it('stops chasing the focus once it has been left', () => {\n      const { input, rerenderWith } = renderComponent({ mark: { x: 1, y: 1, label: '' } });\n\n      expect(document.activeElement).toBe(input);\n\n      input.blur();\n      rerenderWith({ mark: { x: 1, y: 1, label: '' } });\n\n      expect(document.activeElement).not.toBe(input);\n    });\n\n    // outside of label mode the input is disabled, which is how an empty label that was loaded with\n    // the item is told apart from one the user has just added - label mode always starts off\n    // the config draws the background marks into the correct answer graphs as disabled marks\n    it('is not rendered at all while it cannot be edited', () => {\n      const { container } = renderComponent({ disabled: true, mark: { x: 1, y: 1, label: '' } });\n\n      expect(container.querySelector('input')).toBe(null);\n    });\n\n    it('is still rendered uneditable once it has text', () => {\n      const { container } = renderComponent({ disabled: true, mark: { x: 1, y: 1, label: 'A' } });\n\n      expect(container.querySelector('input').value).toBe('A');\n    });\n\n    it('is not focused when label mode is turned on afterwards', () => {\n      const { rerenderWith, container } = renderComponent({ disabled: true, mark: { x: 1, y: 1, label: '' } });\n\n      rerenderWith({ disabled: false });\n\n      expect(input(container)).not.toBe(null);\n      expect(document.activeElement).not.toBe(input(container));\n    });\n\n    it('is not rendered for a disabled mark while it is empty', () => {\n      const { container } = renderComponent({ mark: { x: 1, y: 1, label: '', disabled: true } });\n\n      expect(container.querySelector('input')).toBe(null);\n    });\n\n    // an input sized to its content is 2px wide while it is empty, and chrome paints the caret of\n    // an input inside an svg foreignObject as a hairline that never blinks - so an empty label that\n    // has the focus has to be wide enough to be seen as a box waiting for text\n    it('is wide enough to be seen while it is empty', () => {\n      const { input } = renderComponent({ mark: { x: 1, y: 1, label: '' } });\n\n      expect(parseInt(input.style.width, 10)).toBeGreaterThanOrEqual(30);\n    });\n\n    it('is only as wide as its text once it cannot be edited', () => {\n      const { container } = renderComponent({ disabled: true, mark: { x: 1, y: 1, label: 'A' } });\n\n      expect(parseInt(container.querySelector('input').style.width, 10)).toBeLessThan(30);\n    });\n  });\n\n  describe('syncing mark.label into the input', () => {\n    it('picks up a new mark.label while the input does not have the focus', () => {\n      const { rerenderWith, container } = renderComponent({ mark: { x: 1, y: 1, label: 'A' } });\n\n      rerenderWith({ mark: { x: 1, y: 1, label: 'updated' } });\n\n      expect(input(container).value).toBe('updated');\n    });\n\n    // a mark coming back from an (async) model save can carry an older label - applying it would\n    // wipe out the characters typed in the meantime\n    it('keeps what the user typed while the input has the focus', () => {\n      const { input, rerenderWith } = renderComponent({ autoFocus: true });\n\n      expect(document.activeElement).toBe(input);\n\n      fireEvent.change(input, { target: { value: 'AB' } });\n      expect(input.value).toBe('AB');\n\n      // the host echoes back the label as it was one keystroke ago\n      rerenderWith({ mark: { x: 1, y: 1, label: 'A' } });\n\n      expect(input.value).toBe('AB');\n    });\n  });\n\n  // the characters land at the document's caret, not at the focused node. In the authoring\n  // environment the input ends up focused with no caret anywhere: keypress fires and nothing is\n  // inserted. jsdom never reports a caret either, so this is that state - the focus cycle that\n  // repairs it must not hand the label over to the blur handling.\n  describe('a focused input with no caret', () => {\n    it('is repaired without reporting the label as removed', () => {\n      const { input } = renderComponent({ autoFocus: true, mark: { x: 1, y: 1, label: '' } });\n\n      expect(document.activeElement).toBe(input);\n      expect(onChange).not.toHaveBeenCalled();\n      expect(onBlur).not.toHaveBeenCalled();\n    });\n\n    it('leaves the caret at the end of a label that already has text', () => {\n      const { input } = renderComponent({ autoFocus: true, mark: { x: 1, y: 1, label: 'AB' } });\n\n      expect(document.activeElement).toBe(input);\n      expect(input.selectionStart).toBe(2);\n      expect(onChange).not.toHaveBeenCalled();\n    });\n  });\n\n  // clicking another window, the devtools, or the host moving the focus while it saves the model:\n  // the label is not being left, so it must survive and take the focus back\n  describe('while the window is away', () => {\n    const windowGoesAway = () => window.dispatchEvent(new Event('blur'));\n    const windowComesBack = () => window.dispatchEvent(new Event('focus'));\n\n    it('keeps an empty label instead of reporting it as removed', () => {\n      const { input } = renderComponent({ mark: { x: 1, y: 1, label: '' } });\n\n      windowGoesAway();\n      fireEvent.blur(input);\n\n      expect(onChange).not.toHaveBeenCalled();\n      expect(onBlur).not.toHaveBeenCalled();\n    });\n\n    it('takes the focus back when the window comes back', () => {\n      const { input } = renderComponent({ autoFocus: true, mark: { x: 1, y: 1, label: '' } });\n\n      // the focus is moved to another input rather than with input.blur(): jsdom fires a window\n      // focus event as part of blur(), which is the very thing being tested here\n      const elsewhere = document.createElement('input');\n\n      document.body.appendChild(elsewhere);\n\n      windowGoesAway();\n      elsewhere.focus();\n      expect(document.activeElement).toBe(elsewhere);\n\n      windowComesBack();\n\n      expect(document.activeElement).toBe(input);\n\n      elsewhere.remove();\n    });\n\n    it('still reports a label the user leaves once the window is back', () => {\n      const { input } = renderComponent({ mark: { x: 1, y: 1, label: '' } });\n\n      windowGoesAway();\n      windowComesBack();\n      fireEvent.blur(input);\n\n      expect(onChange).toHaveBeenCalledWith('');\n    });\n  });\n\n  describe('onBlur', () => {\n    it('is called so the tool stops auto focusing the label', () => {\n      const { input } = renderComponent({ autoFocus: true, mark: { x: 1, y: 1, label: 'A' } });\n\n      fireEvent.blur(input);\n\n      expect(onBlur).toHaveBeenCalled();\n    });\n\n    // clicking a button or anything else interactive blurs the label while the debounce is pending\n    it('saves what was typed straight away', () => {\n      const { input } = renderComponent({ mark: { x: 1, y: 1, label: '' } });\n\n      fireEvent.change(input, { target: { value: 'AB' } });\n      fireEvent.blur(input);\n\n      expect(onChange).toHaveBeenCalledWith('AB');\n    });\n\n    it('does not save it twice when the debounce catches up', () => {\n      jest.useFakeTimers();\n      const { input } = renderComponent({ mark: { x: 1, y: 1, label: '' } });\n\n      fireEvent.change(input, { target: { value: 'AB' } });\n      fireEvent.blur(input);\n      act(() => jest.advanceTimersByTime(1000));\n\n      expect(onChange).toHaveBeenCalledTimes(1);\n      expect(onChange).toHaveBeenCalledWith('AB');\n      jest.useRealTimers();\n    });\n\n    it('reports an empty label on blur', () => {\n      const { input } = renderComponent({ mark: { x: 1, y: 1, label: 'A' } });\n\n      fireEvent.change(input, { target: { value: '' } });\n      fireEvent.blur(input);\n\n      expect(onChange).toHaveBeenCalledWith('');\n    });\n  });\n\n  describe('debounce', () => {\n    beforeEach(() => jest.useFakeTimers());\n    afterEach(() => jest.useRealTimers());\n\n    it('does not report the typed label before the debounce delay elapses', () => {\n      const { input } = renderComponent({ autoFocus: true });\n\n      fireEvent.change(input, { target: { value: 'A' } });\n\n      act(() => jest.advanceTimersByTime(499));\n      expect(onChange).not.toHaveBeenCalled();\n\n      act(() => jest.advanceTimersByTime(1));\n      expect(onChange).toHaveBeenCalledWith('A');\n    });\n\n    it('reports the label once for a burst of keystrokes', () => {\n      const { input } = renderComponent({ autoFocus: true });\n\n      fireEvent.change(input, { target: { value: 'A' } });\n      act(() => jest.advanceTimersByTime(300));\n      fireEvent.change(input, { target: { value: 'AB' } });\n      act(() => jest.advanceTimersByTime(300));\n      fireEvent.change(input, { target: { value: 'ABC' } });\n      act(() => jest.advanceTimersByTime(500));\n\n      expect(onChange).toHaveBeenCalledTimes(1);\n      expect(onChange).toHaveBeenCalledWith('ABC');\n    });\n  });\n});\n\ndescribe('position', () => {\n  const assertPosition = (mark, rect, expected) => {\n    it(`${mark.x},${mark.y} + ${rect.width},${rect.height} => ${expected}`, () => {\n      // we set range.min to a value because in pixels - the greater the Y the lower down on the screen.\n      const graphProps = getGraphProps(0, 12, 12, 0);\n      const result = position(graphProps, mark, rect);\n      expect(result).toEqual(expected);\n    });\n  };\n\n  assertPosition({ x: 0, y: 0 }, { width: 10, height: 10 }, 'top-left');\n  assertPosition({ x: 0, y: 0 }, { width: 1, height: 1 }, 'bottom-right');\n  assertPosition({ x: 0, y: 0 }, { width: 10, height: 0 }, 'bottom-left');\n  assertPosition({ x: 0, y: 0 }, { width: 0, height: 10 }, 'top-right');\n});\n\ndescribe('coordinates', () => {\n  const assertCoordinates = (mark, rect, pos, expected) => {\n    it(`${mark.x}, ${mark.y} -> ${pos} = ${expected.left}, ${expected.top}`, () => {\n      const result = coordinates(getGraphProps(), mark, rect, pos);\n      expect(result).toEqual(expected);\n    });\n  };\n  assertCoordinates({ x: 0, y: 0 }, { width: 0, height: 0 }, 'top-left', { left: -5, top: -5 });\n  assertCoordinates({ x: 0, y: 0 }, { width: 0, height: 0 }, 'bottom-left', { left: -5, top: 5 });\n  assertCoordinates({ x: 0, y: 0 }, { width: 0, height: 0 }, 'top-right', { left: 5, top: -5 });\n  assertCoordinates({ x: 0, y: 0 }, { width: 0, height: 0 }, 'bottom-right', {\n    left: 5,\n    top: 5,\n  });\n});\n"],"mappings":"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","ignoreList":[]}