@pie-element/extended-text-entry 15.2.2-beta.19 → 15.2.2-beta.20

package/lib/__tests__/index.test.js

@@ -0,0 +1,115 @@
+"use strict";
+
+var _index = _interopRequireWildcard(require("../index"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+describe('textContent', () => {
+  const assertContent = function () {
+    const args = Array.prototype.slice.call(arguments);
+    const [input, expected] = args.length === 2 ? args : [args[0], args[0]];
+    it(`${input} => ${expected}`, () => {
+      const result = (0, _index.textContent)(input);
+      expect(result).toEqual(expected);
+    });
+  };
+  assertContent(undefined);
+  assertContent([], undefined);
+  assertContent({}, undefined);
+  assertContent('', '');
+  assertContent('<div></div>', '');
+  assertContent('< div ->/div>', '< div ->/div>');
+  assertContent('<foo', '');
+  assertContent('<foo/ >', '');
+  assertContent('<foo />', '');
+});
+describe('Completeness Checker', () => {
+  const assertIsComplete = (input, expected) => {
+    it(`${input}: ${expected}`, () => {
+      expect((0, _index.isComplete)(input)).toEqual(expected);
+    });
+  };
+  assertIsComplete('', false);
+  assertIsComplete('<div></div>', false);
+  assertIsComplete('<div><p></p><h1></h1></div>', false);
+  assertIsComplete('<div><p></p><h1</h1></div>', false);
+  assertIsComplete('<div>test</div>', true);
+  assertIsComplete('<div><p><a>test</a></p></div>', true);
+  assertIsComplete('foo', true);
+});
+describe('deferred session-changed', () => {
+  const TAG = 'ete-session-commit-test';
+  if (!window.customElements.get(TAG)) {
+    window.customElements.define(TAG, class extends _index.default {});
+  }
+  let element;
+  let documentEvents;
+  const onDocumentEvent = event => documentEvents.push(event);
+
+  // No model, so `render()` no-ops and the assertions stay on the element's
+  // event contract rather than on a React mount of the editor.
+  const mount = () => {
+    documentEvents = [];
+    document.addEventListener('session-changed', onDocumentEvent);
+    element = document.createElement(TAG);
+    document.body.appendChild(element);
+    element.session = {
+      id: '1',
+      element: TAG
+    };
+    return element;
+  };
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+  afterEach(() => {
+    document.removeEventListener('session-changed', onDocumentEvent);
+    jest.useRealTimers();
+    document.body.innerHTML = '';
+  });
+  it('writes the session synchronously and defers only the dispatch', () => {
+    mount();
+    element.valueChange('<div>answer</div>');
+    expect(element.session.value).toEqual('<div>answer</div>');
+    expect(documentEvents).toHaveLength(0);
+    jest.advanceTimersByTime(1500);
+    expect(documentEvents).toHaveLength(1);
+    expect(documentEvents[0].detail.complete).toEqual(true);
+  });
+  it('commitPendingSession dispatches while the element is still attached', () => {
+    mount();
+    element.valueChange('<div>answer</div>');
+    element.commitPendingSession();
+    expect(element.isConnected).toEqual(true);
+    expect(documentEvents).toHaveLength(1);
+    expect(documentEvents[0].detail.component).toEqual(TAG);
+  });
+  it('commitPendingSession is a no-op when nothing is pending', () => {
+    mount();
+    element.commitPendingSession();
+    jest.advanceTimersByTime(1500);
+    expect(documentEvents).toHaveLength(0);
+  });
+  it('keeps each session field on its own completeness', () => {
+    mount();
+    element.commentChange('');
+    jest.advanceTimersByTime(1500);
+    expect(documentEvents).toHaveLength(1);
+    expect(documentEvents[0].detail.complete).toEqual(false);
+  });
+  it('teardown commits the response but cannot reach a document listener', () => {
+    mount();
+    const localEvents = [];
+    element.addEventListener('session-changed', event => localEvents.push(event));
+    element.valueChange('<div>answer</div>');
+    element.remove();
+
+    // The response is on the session either way, which is what a player's
+    // synthesized commit reads.
+    expect(element.session.value).toEqual('<div>answer</div>');
+    // `disconnectedCallback` runs after removal, so the flushed event reaches a
+    // listener inside the removed subtree and nothing above it. This is why a
+    // player calls `commitPendingSession()` instead of relying on teardown.
+    expect(localEvents).toHaveLength(1);
+    expect(documentEvents).toHaveLength(0);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_index","_interopRequireWildcard","require","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","describe","assertContent","args","Array","prototype","slice","arguments","input","expected","length","it","result","textContent","expect","toEqual","undefined","assertIsComplete","isComplete","TAG","window","customElements","define","RootExtendedTextEntry","element","documentEvents","onDocumentEvent","event","push","mount","document","addEventListener","createElement","body","appendChild","session","id","beforeEach","jest","useFakeTimers","afterEach","removeEventListener","useRealTimers","innerHTML","valueChange","value","toHaveLength","advanceTimersByTime","detail","complete","commitPendingSession","isConnected","component","commentChange","localEvents","remove"],"sources":["../../src/__tests__/index.test.js"],"sourcesContent":["import RootExtendedTextEntry, { isComplete, textContent } from '../index';\n\ndescribe('textContent', () => {\n  const assertContent = function () {\n    const args = Array.prototype.slice.call(arguments);\n    const [input, expected] = args.length === 2 ? args : [args[0], args[0]];\n    it(`${input} => ${expected}`, () => {\n      const result = textContent(input);\n      expect(result).toEqual(expected);\n    });\n  };\n  assertContent(undefined);\n  assertContent([], undefined);\n  assertContent({}, undefined);\n  assertContent('', '');\n  assertContent('<div></div>', '');\n  assertContent('< div ->/div>', '< div ->/div>');\n  assertContent('<foo', '');\n  assertContent('<foo/ >', '');\n  assertContent('<foo />', '');\n});\n\ndescribe('Completeness Checker', () => {\n  const assertIsComplete = (input, expected) => {\n    it(`${input}: ${expected}`, () => {\n      expect(isComplete(input)).toEqual(expected);\n    });\n  };\n  assertIsComplete('', false);\n  assertIsComplete('<div></div>', false);\n  assertIsComplete('<div><p></p><h1></h1></div>', false);\n  assertIsComplete('<div><p></p><h1</h1></div>', false);\n  assertIsComplete('<div>test</div>', true);\n  assertIsComplete('<div><p><a>test</a></p></div>', true);\n  assertIsComplete('foo', true);\n});\n\ndescribe('deferred session-changed', () => {\n  const TAG = 'ete-session-commit-test';\n\n  if (!window.customElements.get(TAG)) {\n    window.customElements.define(TAG, class extends RootExtendedTextEntry {});\n  }\n\n  let element;\n  let documentEvents;\n\n  const onDocumentEvent = (event) => documentEvents.push(event);\n\n  // No model, so `render()` no-ops and the assertions stay on the element's\n  // event contract rather than on a React mount of the editor.\n  const mount = () => {\n    documentEvents = [];\n    document.addEventListener('session-changed', onDocumentEvent);\n    element = document.createElement(TAG);\n    document.body.appendChild(element);\n    element.session = { id: '1', element: TAG };\n    return element;\n  };\n\n  beforeEach(() => {\n    jest.useFakeTimers();\n  });\n\n  afterEach(() => {\n    document.removeEventListener('session-changed', onDocumentEvent);\n    jest.useRealTimers();\n    document.body.innerHTML = '';\n  });\n\n  it('writes the session synchronously and defers only the dispatch', () => {\n    mount();\n\n    element.valueChange('<div>answer</div>');\n\n    expect(element.session.value).toEqual('<div>answer</div>');\n    expect(documentEvents).toHaveLength(0);\n\n    jest.advanceTimersByTime(1500);\n\n    expect(documentEvents).toHaveLength(1);\n    expect(documentEvents[0].detail.complete).toEqual(true);\n  });\n\n  it('commitPendingSession dispatches while the element is still attached', () => {\n    mount();\n\n    element.valueChange('<div>answer</div>');\n    element.commitPendingSession();\n\n    expect(element.isConnected).toEqual(true);\n    expect(documentEvents).toHaveLength(1);\n    expect(documentEvents[0].detail.component).toEqual(TAG);\n  });\n\n  it('commitPendingSession is a no-op when nothing is pending', () => {\n    mount();\n\n    element.commitPendingSession();\n    jest.advanceTimersByTime(1500);\n\n    expect(documentEvents).toHaveLength(0);\n  });\n\n  it('keeps each session field on its own completeness', () => {\n    mount();\n\n    element.commentChange('');\n    jest.advanceTimersByTime(1500);\n\n    expect(documentEvents).toHaveLength(1);\n    expect(documentEvents[0].detail.complete).toEqual(false);\n  });\n\n  it('teardown commits the response but cannot reach a document listener', () => {\n    mount();\n    const localEvents = [];\n    element.addEventListener('session-changed', (event) => localEvents.push(event));\n\n    element.valueChange('<div>answer</div>');\n    element.remove();\n\n    // The response is on the session either way, which is what a player's\n    // synthesized commit reads.\n    expect(element.session.value).toEqual('<div>answer</div>');\n    // `disconnectedCallback` runs after removal, so the flushed event reaches a\n    // listener inside the removed subtree and nothing above it. This is why a\n    // player calls `commitPendingSession()` instead of relying on teardown.\n    expect(localEvents).toHaveLength(1);\n    expect(documentEvents).toHaveLength(0);\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/__tests__/main.test.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _main = require("../main");
+const editorProps = [];
+jest.mock('@pie-lib/editable-html-tip-tap', () => props => {
+  editorProps.push(props);
+  return /*#__PURE__*/_react.default.createElement("div", {
+    "data-testid": "editor"
+  });
+});
+describe('Main', () => {
+  const renderMain = model => {
+    editorProps.length = 0;
+    (0, _react2.render)(/*#__PURE__*/_react.default.createElement(_main.Main, {
+      model: {
+        dimensions: {},
+        ...model
+      },
+      session: {
+        value: ''
+      },
+      onValueChange: jest.fn(),
+      onAnnotationsChange: jest.fn(),
+      onCommentChange: jest.fn()
+    }));
+    return editorProps[editorProps.length - 1];
+  };
+
+  // The controller turns playerSpellCheckDisabled into spellCheckEnabled; the response area
+  // editor has to receive it so the browser spellchecker stays off for students. See PIE-978.
+  it('passes spellCheckEnabled: false to the response area editor', () => {
+    expect(renderMain({
+      spellCheckEnabled: false
+    }).spellCheck).toBe(false);
+  });
+  it('passes spellCheckEnabled: true to the response area editor', () => {
+    expect(renderMain({
+      spellCheckEnabled: true
+    }).spellCheck).toBe(true);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/annotation/__tests__/annotation-editor.test.js

@@ -0,0 +1,326 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _react = require("@testing-library/react");
+var _styles = require("@mui/material/styles");
+var _react2 = _interopRequireDefault(require("react"));
+var _annotationEditor = _interopRequireDefault(require("../annotation-editor"));
+var utils = _interopRequireWildcard(require("../annotation-utils"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+jest.mock('@pie-lib/editable-html-tip-tap', () => ({
+  __esModule: true,
+  default: ({
+    markup,
+    onChange,
+    disabled
+  }) => /*#__PURE__*/_react2.default.createElement("div", {
+    "data-testid": "editable-html",
+    onClick: () => !disabled && onChange && onChange('new value')
+  }, markup)
+}));
+jest.mock('@pie-lib/config-ui', () => ({
+  InputContainer: ({
+    children,
+    label
+  }) => /*#__PURE__*/_react2.default.createElement("div", {
+    compname: "InputContainer"
+  }, label || 'InputContainer')
+}));
+jest.mock('../freeform-editor', () => ({
+  __esModule: true,
+  default: props => /*#__PURE__*/_react2.default.createElement("div", (0, _extends2.default)({
+    "data-testid": "freeform-editor"
+  }, props))
+}));
+jest.mock('../annotation-menu', () => ({
+  __esModule: true,
+  default: props => /*#__PURE__*/_react2.default.createElement("div", (0, _extends2.default)({
+    "data-testid": "annotation-menu"
+  }, props))
+}));
+const theme = (0, _styles.createTheme)();
+const mockedElementDOM = {
+  removeChild: jest.fn(),
+  classList: {
+    remove: jest.fn(),
+    add: jest.fn()
+  }
+};
+jest.spyOn(utils, 'removeElemsWrapping').mockImplementation(() => {});
+
+// Store the original componentDidMount
+let originalComponentDidMount;
+beforeAll(() => {
+  // Save original componentDidMount
+  originalComponentDidMount = _annotationEditor.default.prototype.componentDidMount;
+});
+describe('freeform editor', () => {
+  const defaultProps = {
+    classes: {},
+    text: '',
+    annotations: [],
+    comment: '',
+    predefinedAnnotations: [],
+    width: 500,
+    height: 100,
+    maxHeight: '40vh',
+    disabled: false,
+    disabledMath: false,
+    customKeys: [],
+    keypadMode: 'miscellaneous'
+  };
+  let onChange;
+  let onCommentChange;
+  beforeEach(() => {
+    onChange = jest.fn();
+    onCommentChange = jest.fn();
+    global.document.createRange = () => ({
+      setStart: () => {},
+      setEnd: () => {},
+      commonAncestorContainer: {
+        nodeName: 'BODY',
+        ownerDocument: document
+      }
+    });
+  });
+  describe('logic', () => {
+    describe('select a predefined annotation', () => {
+      it('calls onChange when new annotation selected', () => {
+        const testInstance = new _annotationEditor.default({
+          ...defaultProps,
+          onChange,
+          onCommentChange,
+          text: '<div>This is an example.</div>'
+        });
+        testInstance.createDOMAnnotation = jest.fn();
+        testInstance.handleClose = jest.fn();
+        testInstance.state = {
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          selectionDetails: {
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }
+        };
+        testInstance.handleMenuClick({
+          type: 'positive',
+          text: 'good'
+        });
+        expect(testInstance.createDOMAnnotation).toBeCalled();
+        expect(onChange).toBeCalled();
+        expect(testInstance.handleClose).toBeCalled();
+      });
+      it('calls onChange when old annotation selected', () => {
+        const testInstance = new _annotationEditor.default({
+          ...defaultProps,
+          onChange,
+          onCommentChange,
+          text: '<div>This is an example.</div>',
+          annotations: [{
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }]
+        });
+        testInstance.updateLabel = jest.fn();
+        testInstance.handleClose = jest.fn();
+        testInstance.state = {
+          annotation: {
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          },
+          labelElem: mockedElementDOM,
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          annotationIndex: 0
+        };
+        testInstance.handleMenuClick({
+          type: 'negative',
+          text: 'wrong'
+        });
+        expect(testInstance.updateLabel).toBeCalled();
+        expect(onChange).toBeCalled();
+        expect(testInstance.handleClose).toBeCalled();
+      });
+    });
+    describe('write new annotation', () => {
+      it('calls onChange', () => {
+        const testInstance = new _annotationEditor.default({
+          ...defaultProps,
+          onChange,
+          onCommentChange,
+          text: '<div>This is an example.</div>'
+        });
+        testInstance.createDOMAnnotation = jest.fn();
+        testInstance.state = {
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          selectionDetails: {
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }
+        };
+        testInstance.addAnnotation('positive');
+        expect(testInstance.createDOMAnnotation).toBeCalled();
+        expect(onChange).toBeCalled();
+      });
+    });
+    describe('edit annotation', () => {
+      it('updates state', () => {
+        const testInstance = new _annotationEditor.default({
+          ...defaultProps,
+          onChange,
+          onCommentChange
+        });
+        testInstance.state = {
+          openedMenu: true,
+          openedEditor: false
+        };
+        testInstance.setState = jest.fn(newState => {
+          testInstance.state = {
+            ...testInstance.state,
+            ...newState
+          };
+        });
+        testInstance.editAnnotation();
+        expect(testInstance.state.openedMenu).toEqual(false);
+        expect(testInstance.state.openedEditor).toEqual(true);
+      });
+    });
+    describe('delete annotation', () => {
+      it('calls onChange', () => {
+        const testInstance = new _annotationEditor.default({
+          ...defaultProps,
+          onChange,
+          onCommentChange,
+          text: '<div>This is an example.</div>'
+        });
+        testInstance.handleClose = jest.fn();
+        testInstance.state = {
+          annotation: {
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          },
+          labelElem: mockedElementDOM,
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          annotationIndex: 0
+        };
+        testInstance.deleteAnnotation();
+        expect(utils.removeElemsWrapping).toBeCalled();
+        expect(onChange).toBeCalled();
+        expect(testInstance.handleClose).toBeCalled();
+      });
+    });
+    describe('update annotation', () => {
+      it('calls onChange', () => {
+        const testInstance = new _annotationEditor.default({
+          ...defaultProps,
+          onChange,
+          onCommentChange,
+          text: '<div>This is an example.</div>',
+          annotations: [{
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }]
+        });
+        testInstance.updateLabel = jest.fn();
+        testInstance.state = {
+          annotationIndex: 0
+        };
+        testInstance.updateAnnotation();
+        expect(testInstance.updateLabel).toBeCalled();
+        expect(onChange).toBeCalled();
+      });
+    });
+    describe('change annotation type', () => {
+      it('calls onChange', () => {
+        const testInstance = new _annotationEditor.default({
+          ...defaultProps,
+          onChange,
+          onCommentChange,
+          text: '<div>This is an example.</div>',
+          annotations: [{
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }]
+        });
+        testInstance.updateLabel = jest.fn();
+        testInstance.handleClose = jest.fn();
+        testInstance.state = {
+          annotation: {
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          },
+          labelElem: mockedElementDOM,
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          annotationIndex: 0
+        };
+        testInstance.changeAnnotationType('very good');
+        expect(testInstance.updateLabel).toBeCalled();
+        expect(onChange).toBeCalled();
+        expect(testInstance.handleClose).toBeCalled();
+      });
+    });
+    describe('update annotation label', () => {
+      it('calls createDOMAnnotation', () => {
+        const testInstance = new _annotationEditor.default({
+          ...defaultProps,
+          onChange,
+          onCommentChange,
+          text: '<div>This is an example.</div>',
+          annotations: [{
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }]
+        });
+        testInstance.updateLabel = jest.fn();
+        testInstance.handleClose = jest.fn();
+        testInstance.state = {
+          annotation: {
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          },
+          labelElem: mockedElementDOM,
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          annotationIndex: 0
+        };
+        testInstance.changeAnnotationType('very good');
+        expect(testInstance.updateLabel).toBeCalled();
+        expect(onChange).toBeCalled();
+        expect(testInstance.handleClose).toBeCalled();
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","_styles","_react2","_interopRequireDefault","_annotationEditor","utils","_interopRequireWildcard","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","jest","mock","markup","onChange","disabled","createElement","onClick","InputContainer","children","label","compname","props","_extends2","theme","createTheme","mockedElementDOM","removeChild","fn","classList","remove","add","spyOn","mockImplementation","originalComponentDidMount","beforeAll","AnnotationEditor","prototype","componentDidMount","describe","defaultProps","classes","text","annotations","comment","predefinedAnnotations","width","height","maxHeight","disabledMath","customKeys","keypadMode","onCommentChange","beforeEach","global","document","createRange","setStart","setEnd","commonAncestorContainer","nodeName","ownerDocument","it","testInstance","createDOMAnnotation","handleClose","state","selectedElems","selectionDetails","handleMenuClick","type","expect","toBeCalled","updateLabel","annotation","labelElem","annotationIndex","addAnnotation","openedMenu","openedEditor","setState","newState","editAnnotation","toEqual","deleteAnnotation","removeElemsWrapping","updateAnnotation","changeAnnotationType"],"sources":["../../../src/annotation/__tests__/annotation-editor.test.jsx"],"sourcesContent":["import { render } from '@testing-library/react';\nimport { ThemeProvider, createTheme } from '@mui/material/styles';\nimport React from 'react';\nimport AnnotationEditor from '../annotation-editor';\nimport * as utils from '../annotation-utils';\n\njest.mock('@pie-lib/editable-html-tip-tap', () => ({\n  __esModule: true,\n  default: ({ markup, onChange, disabled }) => (\n    <div data-testid=\"editable-html\" onClick={() => !disabled && onChange && onChange('new value')}>\n      {markup}\n    </div>\n  ),\n}));\n\njest.mock('@pie-lib/config-ui', () => ({\n  InputContainer: ({ children, label }) => (\n    <div compname=\"InputContainer\">{label || 'InputContainer'}</div>\n  ),\n}));\n\njest.mock('../freeform-editor', () => ({\n  __esModule: true,\n  default: (props) => <div data-testid=\"freeform-editor\" {...props} />,\n}));\n\njest.mock('../annotation-menu', () => ({\n  __esModule: true,\n  default: (props) => <div data-testid=\"annotation-menu\" {...props} />,\n}));\n\nconst theme = createTheme();\n\nconst mockedElementDOM = {\n  removeChild: jest.fn(),\n  classList: {\n    remove: jest.fn(),\n    add: jest.fn()\n  },\n};\n\njest.spyOn(utils, 'removeElemsWrapping').mockImplementation(() => {});\n\n// Store the original componentDidMount\nlet originalComponentDidMount;\n\nbeforeAll(() => {\n  // Save original componentDidMount\n  originalComponentDidMount = AnnotationEditor.prototype.componentDidMount;\n});\n\ndescribe('freeform editor', () => {\n  const defaultProps = {\n    classes: {},\n    text: '',\n    annotations: [],\n    comment: '',\n    predefinedAnnotations: [],\n    width: 500,\n    height: 100,\n    maxHeight: '40vh',\n    disabled: false,\n    disabledMath: false,\n    customKeys: [],\n    keypadMode: 'miscellaneous',\n  };\n  let onChange;\n  let onCommentChange;\n\n  beforeEach(() => {\n    onChange = jest.fn();\n    onCommentChange = jest.fn();\n\n    global.document.createRange = () => ({\n      setStart: () => {},\n      setEnd: () => {},\n      commonAncestorContainer: {\n        nodeName: 'BODY',\n        ownerDocument: document,\n      },\n    });\n  });\n\n  describe('logic', () => {\n    describe('select a predefined annotation', () => {\n      it('calls onChange when new annotation selected',  () => {\n        const testInstance = new AnnotationEditor({\n          ...defaultProps,\n          onChange,\n          onCommentChange,\n          text: '<div>This is an example.</div>',\n        });\n\n        testInstance.createDOMAnnotation = jest.fn();\n        testInstance.handleClose = jest.fn();\n\n        testInstance.state = {\n          selectedElems: [mockedElementDOM, mockedElementDOM],\n          selectionDetails: {\n            'quote': 'This',\n            'start': 0,\n            'end': 4\n          },\n        };\n\n        testInstance.handleMenuClick({\n          type: 'positive',\n          text: 'good'\n        });\n\n        expect(testInstance.createDOMAnnotation).toBeCalled();\n        expect(onChange).toBeCalled();\n        expect(testInstance.handleClose).toBeCalled();\n      });\n\n      it('calls onChange when old annotation selected',  () => {\n        const testInstance = new AnnotationEditor({\n          ...defaultProps,\n          onChange,\n          onCommentChange,\n          text: '<div>This is an example.</div>',\n          annotations: [\n            {\n              'id': '1',\n              'label': 'good',\n              'type': 'positive',\n              'quote': 'This',\n              'start': 0,\n              'end': 4\n            }\n          ]\n        });\n\n        testInstance.updateLabel = jest.fn();\n        testInstance.handleClose = jest.fn();\n\n        testInstance.state = {\n          annotation: {\n            'id': '1',\n            'label': 'good',\n            'type': 'positive',\n            'quote': 'This',\n            'start': 0,\n            'end': 4\n          },\n          labelElem: mockedElementDOM,\n          selectedElems: [mockedElementDOM, mockedElementDOM],\n          annotationIndex: 0\n        };\n\n        testInstance.handleMenuClick({\n          type: 'negative',\n          text: 'wrong'\n        });\n\n        expect(testInstance.updateLabel).toBeCalled();\n        expect(onChange).toBeCalled();\n        expect(testInstance.handleClose).toBeCalled();\n      });\n    });\n\n    describe('write new annotation', () => {\n      it('calls onChange',  () => {\n        const testInstance = new AnnotationEditor({\n          ...defaultProps,\n          onChange,\n          onCommentChange,\n          text: '<div>This is an example.</div>',\n        });\n\n        testInstance.createDOMAnnotation = jest.fn();\n\n        testInstance.state = {\n          selectedElems: [mockedElementDOM, mockedElementDOM],\n          selectionDetails: {\n            'quote': 'This',\n            'start': 0,\n            'end': 4\n          },\n        };\n\n        testInstance.addAnnotation('positive');\n\n        expect(testInstance.createDOMAnnotation).toBeCalled();\n        expect(onChange).toBeCalled();\n      });\n    });\n\n    describe('edit annotation', () => {\n      it('updates state',  () => {\n        const testInstance = new AnnotationEditor({\n          ...defaultProps,\n          onChange,\n          onCommentChange,\n        });\n\n        testInstance.state = {\n          openedMenu: true,\n          openedEditor: false\n        };\n\n        testInstance.setState = jest.fn((newState) => {\n          testInstance.state = { ...testInstance.state, ...newState };\n        });\n\n        testInstance.editAnnotation();\n\n        expect(testInstance.state.openedMenu).toEqual(false);\n        expect(testInstance.state.openedEditor).toEqual(true);\n      });\n    });\n\n    describe('delete annotation', () => {\n      it('calls onChange',  () => {\n        const testInstance = new AnnotationEditor({\n          ...defaultProps,\n          onChange,\n          onCommentChange,\n          text: '<div>This is an example.</div>',\n        });\n\n        testInstance.handleClose = jest.fn();\n\n        testInstance.state = {\n          annotation: {\n            'id': '1',\n            'label': 'good',\n            'type': 'positive',\n            'quote': 'This',\n            'start': 0,\n            'end': 4\n          },\n          labelElem: mockedElementDOM,\n          selectedElems: [mockedElementDOM, mockedElementDOM],\n          annotationIndex: 0\n        };\n\n        testInstance.deleteAnnotation();\n\n        expect(utils.removeElemsWrapping).toBeCalled();\n        expect(onChange).toBeCalled();\n        expect(testInstance.handleClose).toBeCalled();\n      });\n    });\n\n    describe('update annotation', () => {\n      it('calls onChange',  () => {\n        const testInstance = new AnnotationEditor({\n          ...defaultProps,\n          onChange,\n          onCommentChange,\n          text: '<div>This is an example.</div>',\n          annotations: [\n            {\n              'id': '1',\n              'label': 'good',\n              'type': 'positive',\n              'quote': 'This',\n              'start': 0,\n              'end': 4\n            }\n          ]\n        });\n\n        testInstance.updateLabel = jest.fn();\n\n        testInstance.state = {\n          annotationIndex: 0\n        };\n\n        testInstance.updateAnnotation();\n\n        expect(testInstance.updateLabel).toBeCalled();\n        expect(onChange).toBeCalled();\n      });\n    });\n\n    describe('change annotation type', () => {\n      it('calls onChange',  () => {\n        const testInstance = new AnnotationEditor({\n          ...defaultProps,\n          onChange,\n          onCommentChange,\n          text: '<div>This is an example.</div>',\n          annotations: [\n            {\n              'id': '1',\n              'label': 'good',\n              'type': 'positive',\n              'quote': 'This',\n              'start': 0,\n              'end': 4\n            }\n          ]\n        });\n\n        testInstance.updateLabel = jest.fn();\n        testInstance.handleClose = jest.fn();\n\n        testInstance.state = {\n          annotation: {\n            'id': '1',\n            'label': 'good',\n            'type': 'positive',\n            'quote': 'This',\n            'start': 0,\n            'end': 4\n          },\n          labelElem: mockedElementDOM,\n          selectedElems: [mockedElementDOM, mockedElementDOM],\n          annotationIndex: 0\n        };\n\n        testInstance.changeAnnotationType('very good');\n\n        expect(testInstance.updateLabel).toBeCalled();\n        expect(onChange).toBeCalled();\n        expect(testInstance.handleClose).toBeCalled();\n      });\n    });\n\n    describe('update annotation label', () => {\n      it('calls createDOMAnnotation',  () => {\n        const testInstance = new AnnotationEditor({\n          ...defaultProps,\n          onChange,\n          onCommentChange,\n          text: '<div>This is an example.</div>',\n          annotations: [\n            {\n              'id': '1',\n              'label': 'good',\n              'type': 'positive',\n              'quote': 'This',\n              'start': 0,\n              'end': 4\n            }\n          ]\n        });\n\n        testInstance.updateLabel = jest.fn();\n        testInstance.handleClose = jest.fn();\n\n        testInstance.state = {\n          annotation: {\n            'id': '1',\n            'label': 'good',\n            'type': 'positive',\n            'quote': 'This',\n            'start': 0,\n            'end': 4\n          },\n          labelElem: mockedElementDOM,\n          selectedElems: [mockedElementDOM, mockedElementDOM],\n          annotationIndex: 0\n        };\n\n        testInstance.changeAnnotationType('very good');\n\n        expect(testInstance.updateLabel).toBeCalled();\n        expect(onChange).toBeCalled();\n        expect(testInstance.handleClose).toBeCalled();\n      });\n    });\n\n  });\n});\n"],"mappings":"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","ignoreList":[]}