@pie-element/extended-text-entry 15.2.1 → 15.2.2-beta.2

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":[]}

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

@@ -0,0 +1,136 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = require("@testing-library/react");
+var _styles = require("@mui/material/styles");
+var _react2 = _interopRequireDefault(require("react"));
+var _freeformEditor = _interopRequireDefault(require("../freeform-editor"));
+const theme = (0, _styles.createTheme)();
+describe('freeform editor', () => {
+  const defaultProps = {
+    classes: {},
+    anchorEl: {},
+    open: false,
+    offset: 10,
+    value: 'note',
+    type: 'positive'
+  };
+  let onClose;
+  let onDelete;
+  let onSave;
+  let onTypeChange;
+  beforeEach(() => {
+    onClose = jest.fn();
+    onDelete = jest.fn();
+    onSave = jest.fn();
+    onTypeChange = jest.fn();
+  });
+  const wrapper = extras => {
+    const defaults = {
+      ...defaultProps,
+      onClose,
+      onDelete,
+      onSave,
+      onTypeChange
+    };
+    const props = {
+      ...defaults,
+      ...extras
+    };
+    return (0, _react.render)(/*#__PURE__*/_react2.default.createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react2.default.createElement(_freeformEditor.default, props)));
+  };
+  describe('logic', () => {
+    describe('save or autosave', () => {
+      it('calls onSave', () => {
+        const testInstance = new _freeformEditor.default({
+          ...defaultProps,
+          onClose,
+          onDelete,
+          onSave,
+          onTypeChange
+        });
+        testInstance.state = {
+          value: 'good'
+        };
+        testInstance.handleSave();
+        expect(onSave).toBeCalled();
+      });
+      it('calls onDelete', () => {
+        const testInstance = new _freeformEditor.default({
+          ...defaultProps,
+          onClose,
+          onDelete,
+          onSave,
+          onTypeChange
+        });
+        testInstance.state = {
+          value: ''
+        };
+        testInstance.handleSave();
+        expect(onDelete).toBeCalled();
+      });
+      it('calls onClose', () => {
+        const testInstance = new _freeformEditor.default({
+          ...defaultProps,
+          onClose,
+          onDelete,
+          onSave,
+          onTypeChange
+        });
+        testInstance.state = {
+          value: 'note'
+        };
+        testInstance.handleSave();
+        expect(onClose).toBeCalled();
+      });
+    });
+    describe('type change', () => {
+      it('calls onTypeChange', () => {
+        const testInstance = new _freeformEditor.default({
+          ...defaultProps,
+          onClose,
+          onDelete,
+          onSave,
+          onTypeChange,
+          value: 'note'
+        });
+        testInstance.state = {
+          value: 'note'
+        };
+        testInstance.handleTypeChange();
+        expect(onTypeChange).toBeCalledWith('note');
+      });
+      it('calls onTypeChange with changed value', () => {
+        const testInstance = new _freeformEditor.default({
+          ...defaultProps,
+          onClose,
+          onDelete,
+          onSave,
+          onTypeChange
+        });
+        testInstance.state = {
+          value: 'good'
+        };
+        testInstance.handleTypeChange();
+        expect(onTypeChange).toBeCalledWith('good');
+      });
+      it('calls onDelete', () => {
+        const testInstance = new _freeformEditor.default({
+          ...defaultProps,
+          onClose,
+          onDelete,
+          onSave,
+          onTypeChange
+        });
+        testInstance.state = {
+          value: ''
+        };
+        testInstance.handleTypeChange();
+        expect(onDelete).toBeCalled();
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","require","_styles","_react2","_interopRequireDefault","_freeformEditor","theme","createTheme","describe","defaultProps","classes","anchorEl","open","offset","value","type","onClose","onDelete","onSave","onTypeChange","beforeEach","jest","fn","wrapper","extras","defaults","props","render","default","createElement","ThemeProvider","it","testInstance","FreeformEditor","state","handleSave","expect","toBeCalled","handleTypeChange","toBeCalledWith"],"sources":["../../../src/annotation/__tests__/freeform-editor.test.jsx"],"sourcesContent":["import { render } from '@testing-library/react';\nimport { ThemeProvider, createTheme } from '@mui/material/styles';\nimport React from 'react';\nimport FreeformEditor from '../freeform-editor';\n\nconst theme = createTheme();\n\ndescribe('freeform editor', () => {\n  const defaultProps = {\n    classes: {},\n    anchorEl: {},\n    open: false,\n    offset: 10,\n    value: 'note',\n    type: 'positive'\n  };\n  let onClose;\n  let onDelete;\n  let onSave;\n  let onTypeChange;\n\n  beforeEach(() => {\n    onClose = jest.fn();\n    onDelete = jest.fn();\n    onSave = jest.fn();\n    onTypeChange = jest.fn();\n  });\n\n  const wrapper = extras => {\n    const defaults = {\n      ...defaultProps,\n      onClose,\n      onDelete,\n      onSave,\n      onTypeChange\n    };\n    const props = { ...defaults, ...extras };\n\n    return render(\n      <ThemeProvider theme={theme}>\n        <FreeformEditor { ...props } />\n      </ThemeProvider>\n    );\n  };\n\n  describe('logic', () => {\n    describe('save or autosave', () => {\n      it('calls onSave',  () => {\n        const testInstance = new FreeformEditor({\n          ...defaultProps,\n          onClose,\n          onDelete,\n          onSave,\n          onTypeChange\n        });\n\n        testInstance.state = { value: 'good' };\n        testInstance.handleSave();\n        expect(onSave).toBeCalled();\n      });\n\n      it('calls onDelete', () => {\n        const testInstance = new FreeformEditor({\n          ...defaultProps,\n          onClose,\n          onDelete,\n          onSave,\n          onTypeChange\n        });\n\n        testInstance.state = { value: '' };\n        testInstance.handleSave();\n        expect(onDelete).toBeCalled();\n      });\n\n      it('calls onClose', () => {\n        const testInstance = new FreeformEditor({\n          ...defaultProps,\n          onClose,\n          onDelete,\n          onSave,\n          onTypeChange\n        });\n\n        testInstance.state = { value: 'note' };\n        testInstance.handleSave();\n        expect(onClose).toBeCalled();\n      });\n    });\n\n    describe('type change', () => {\n      it('calls onTypeChange',  () => {\n        const testInstance = new FreeformEditor({\n          ...defaultProps,\n          onClose,\n          onDelete,\n          onSave,\n          onTypeChange,\n          value: 'note'\n        });\n\n        testInstance.state = { value: 'note' };\n        testInstance.handleTypeChange();\n        expect(onTypeChange).toBeCalledWith('note');\n      });\n\n      it('calls onTypeChange with changed value',  () => {\n        const testInstance = new FreeformEditor({\n          ...defaultProps,\n          onClose,\n          onDelete,\n          onSave,\n          onTypeChange\n        });\n\n        testInstance.state = { value: 'good' };\n        testInstance.handleTypeChange();\n        expect(onTypeChange).toBeCalledWith('good');\n      });\n\n      it('calls onDelete', () => {\n        const testInstance = new FreeformEditor({\n          ...defaultProps,\n          onClose,\n          onDelete,\n          onSave,\n          onTypeChange\n        });\n\n        testInstance.state = { value: '' };\n        testInstance.handleTypeChange();\n        expect(onDelete).toBeCalled();\n      });\n    });\n  });\n});\n"],"mappings":";;;AAAA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAC,sBAAA,CAAAH,OAAA;AACA,IAAAI,eAAA,GAAAD,sBAAA,CAAAH,OAAA;AAEA,MAAMK,KAAK,GAAG,IAAAC,mBAAW,EAAC,CAAC;AAE3BC,QAAQ,CAAC,iBAAiB,EAAE,MAAM;EAChC,MAAMC,YAAY,GAAG;IACnBC,OAAO,EAAE,CAAC,CAAC;IACXC,QAAQ,EAAE,CAAC,CAAC;IACZC,IAAI,EAAE,KAAK;IACXC,MAAM,EAAE,EAAE;IACVC,KAAK,EAAE,MAAM;IACbC,IAAI,EAAE;EACR,CAAC;EACD,IAAIC,OAAO;EACX,IAAIC,QAAQ;EACZ,IAAIC,MAAM;EACV,IAAIC,YAAY;EAEhBC,UAAU,CAAC,MAAM;IACfJ,OAAO,GAAGK,IAAI,CAACC,EAAE,CAAC,CAAC;IACnBL,QAAQ,GAAGI,IAAI,CAACC,EAAE,CAAC,CAAC;IACpBJ,MAAM,GAAGG,IAAI,CAACC,EAAE,CAAC,CAAC;IAClBH,YAAY,GAAGE,IAAI,CAACC,EAAE,CAAC,CAAC;EAC1B,CAAC,CAAC;EAEF,MAAMC,OAAO,GAAGC,MAAM,IAAI;IACxB,MAAMC,QAAQ,GAAG;MACf,GAAGhB,YAAY;MACfO,OAAO;MACPC,QAAQ;MACRC,MAAM;MACNC;IACF,CAAC;IACD,MAAMO,KAAK,GAAG;MAAE,GAAGD,QAAQ;MAAE,GAAGD;IAAO,CAAC;IAExC,OAAO,IAAAG,aAAM,eACXxB,OAAA,CAAAyB,OAAA,CAAAC,aAAA,CAAC3B,OAAA,CAAA4B,aAAa;MAACxB,KAAK,EAAEA;IAAM,gBAC1BH,OAAA,CAAAyB,OAAA,CAAAC,aAAA,CAACxB,eAAA,CAAAuB,OAAc,EAAMF,KAAS,CACjB,CACjB,CAAC;EACH,CAAC;EAEDlB,QAAQ,CAAC,OAAO,EAAE,MAAM;IACtBA,QAAQ,CAAC,kBAAkB,EAAE,MAAM;MACjCuB,EAAE,CAAC,cAAc,EAAG,MAAM;QACxB,MAAMC,YAAY,GAAG,IAAIC,uBAAc,CAAC;UACtC,GAAGxB,YAAY;UACfO,OAAO;UACPC,QAAQ;UACRC,MAAM;UACNC;QACF,CAAC,CAAC;QAEFa,YAAY,CAACE,KAAK,GAAG;UAAEpB,KAAK,EAAE;QAAO,CAAC;QACtCkB,YAAY,CAACG,UAAU,CAAC,CAAC;QACzBC,MAAM,CAAClB,MAAM,CAAC,CAACmB,UAAU,CAAC,CAAC;MAC7B,CAAC,CAAC;MAEFN,EAAE,CAAC,gBAAgB,EAAE,MAAM;QACzB,MAAMC,YAAY,GAAG,IAAIC,uBAAc,CAAC;UACtC,GAAGxB,YAAY;UACfO,OAAO;UACPC,QAAQ;UACRC,MAAM;UACNC;QACF,CAAC,CAAC;QAEFa,YAAY,CAACE,KAAK,GAAG;UAAEpB,KAAK,EAAE;QAAG,CAAC;QAClCkB,YAAY,CAACG,UAAU,CAAC,CAAC;QACzBC,MAAM,CAACnB,QAAQ,CAAC,CAACoB,UAAU,CAAC,CAAC;MAC/B,CAAC,CAAC;MAEFN,EAAE,CAAC,eAAe,EAAE,MAAM;QACxB,MAAMC,YAAY,GAAG,IAAIC,uBAAc,CAAC;UACtC,GAAGxB,YAAY;UACfO,OAAO;UACPC,QAAQ;UACRC,MAAM;UACNC;QACF,CAAC,CAAC;QAEFa,YAAY,CAACE,KAAK,GAAG;UAAEpB,KAAK,EAAE;QAAO,CAAC;QACtCkB,YAAY,CAACG,UAAU,CAAC,CAAC;QACzBC,MAAM,CAACpB,OAAO,CAAC,CAACqB,UAAU,CAAC,CAAC;MAC9B,CAAC,CAAC;IACJ,CAAC,CAAC;IAEF7B,QAAQ,CAAC,aAAa,EAAE,MAAM;MAC5BuB,EAAE,CAAC,oBAAoB,EAAG,MAAM;QAC9B,MAAMC,YAAY,GAAG,IAAIC,uBAAc,CAAC;UACtC,GAAGxB,YAAY;UACfO,OAAO;UACPC,QAAQ;UACRC,MAAM;UACNC,YAAY;UACZL,KAAK,EAAE;QACT,CAAC,CAAC;QAEFkB,YAAY,CAACE,KAAK,GAAG;UAAEpB,KAAK,EAAE;QAAO,CAAC;QACtCkB,YAAY,CAACM,gBAAgB,CAAC,CAAC;QAC/BF,MAAM,CAACjB,YAAY,CAAC,CAACoB,cAAc,CAAC,MAAM,CAAC;MAC7C,CAAC,CAAC;MAEFR,EAAE,CAAC,uCAAuC,EAAG,MAAM;QACjD,MAAMC,YAAY,GAAG,IAAIC,uBAAc,CAAC;UACtC,GAAGxB,YAAY;UACfO,OAAO;UACPC,QAAQ;UACRC,MAAM;UACNC;QACF,CAAC,CAAC;QAEFa,YAAY,CAACE,KAAK,GAAG;UAAEpB,KAAK,EAAE;QAAO,CAAC;QACtCkB,YAAY,CAACM,gBAAgB,CAAC,CAAC;QAC/BF,MAAM,CAACjB,YAAY,CAAC,CAACoB,cAAc,CAAC,MAAM,CAAC;MAC7C,CAAC,CAAC;MAEFR,EAAE,CAAC,gBAAgB,EAAE,MAAM;QACzB,MAAMC,YAAY,GAAG,IAAIC,uBAAc,CAAC;UACtC,GAAGxB,YAAY;UACfO,OAAO;UACPC,QAAQ;UACRC,MAAM;UACNC;QACF,CAAC,CAAC;QAEFa,YAAY,CAACE,KAAK,GAAG;UAAEpB,KAAK,EAAE;QAAG,CAAC;QAClCkB,YAAY,CAACM,gBAAgB,CAAC,CAAC;QAC/BF,MAAM,CAACnB,QAAQ,CAAC,CAACoB,UAAU,CAAC,CAAC;MAC/B,CAAC,CAAC;IACJ,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}

package/lib/annotation/annotation-menu.js

@@ -10,7 +10,6 @@ var _react = _interopRequireDefault(require("react"));
 var _propTypes = _interopRequireDefault(require("prop-types"));
 var _styles = require("@mui/material/styles");
 var _material = require("@mui/material");
-var _renderUi = require("@pie-lib/render-ui");
 const StyledPopover = (0, _styles.styled)(_material.Popover)({
   '& .MuiPaper-root': {
     overflowX: 'unset',
@@ -25,49 +24,47 @@ const StyledPopover = (0, _styles.styled)(_material.Popover)({
       width: 0,
       pointerEvents: 'none',
       borderWidth: '7px',
-      borderTopColor: _renderUi.color.border()
+      borderTopColor: 'black'
     }
   }
 });
-
-/*
- * Surface and stroke move together. Tokenising the border alone would put a scheme's
- * border colour on a fixed white popover -- under white-on-black, `--pie-border` is
- * #ffffff, so the outline would vanish. `--pie-white` inverts with the scheme, which
- * is what `common.white` was standing in for.
- */
-const MainWrapper = (0, _styles.styled)('div')(() => ({
+const MainWrapper = (0, _styles.styled)('div')(({
+  theme
+}) => ({
   width: '300px',
   overflow: 'hidden',
   borderRadius: '4px',
-  backgroundColor: _renderUi.color.white(),
-  border: `2px solid ${_renderUi.color.border()}`
+  backgroundColor: theme.palette.common.white,
+  border: `2px solid ${theme.palette.grey[100]}`
 }));
 const AnnotationsWrapper = (0, _styles.styled)('div')({
   display: 'flex',
   flexWrap: 'wrap'
 });
-const ControlsWrapper = (0, _styles.styled)('div')(() => ({
+const ControlsWrapper = (0, _styles.styled)('div')(({
+  theme
+}) => ({
   display: 'flex',
   flexWrap: 'wrap',
-  borderTop: `2px solid ${_renderUi.color.border()}`
+  borderTop: `2px solid ${theme.palette.grey[100]}`
 }));
 const Button = (0, _styles.styled)('div')(({
+  theme,
   variant
 }) => ({
   width: '22%',
   textAlign: 'center',
   padding: '4px',
   cursor: 'pointer',
-  borderBottom: `1px solid ${_renderUi.color.border()}`,
+  borderBottom: `1px solid ${theme.palette.grey[100]}`,
   '&:not(:nth-child(4n))': {
-    borderRight: `1px solid ${_renderUi.color.border()}`
+    borderRight: `1px solid ${theme.palette.grey[100]}`
   },
   '&:nth-child(4n)': {
     flexGrow: 1
   },
   '&:hover': {
-    backgroundColor: _renderUi.color.backgroundDark()
+    backgroundColor: theme.palette.grey[100]
   },
   ...(variant === 'positive' && {
     backgroundColor: 'rgb(153, 255, 153) !important',