@pie-element/extended-text-entry 6.7.0-annotations → 6.7.0-annotations.1

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

@@ -0,0 +1,373 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _annotationEditor = _interopRequireDefault(require("../annotation-editor"));
+
+var _testUtils = require("@material-ui/core/test-utils");
+
+var utils = _interopRequireWildcard(require("../annotation-utils"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var Editor = (0, _testUtils.unwrap)(_annotationEditor["default"]);
+var predefinedAnnotations = [{
+  label: 'good',
+  text: 'good',
+  type: 'positive'
+}, {
+  label: '★',
+  text: '★',
+  type: 'positive'
+}, {
+  label: 'cut',
+  text: 'cut',
+  type: 'negative'
+}, {
+  label: 'sp',
+  text: 'spelling',
+  type: 'negative'
+}];
+var mockedElementDOM = {
+  removeChild: jest.fn(),
+  classList: {
+    remove: jest.fn(),
+    add: jest.fn()
+  }
+};
+jest.spyOn(utils, 'removeElemsWrapping').mockImplementation(function () {});
+describe('freeform editor', function () {
+  var defaultProps = {
+    classes: {},
+    text: '',
+    annotations: [],
+    comment: '',
+    predefinedAnnotations: [],
+    width: 500,
+    height: 100,
+    maxHeight: '40vh',
+    disabled: false,
+    disabledMath: false,
+    customKeys: [],
+    keypadMode: 'miscellaneous'
+  };
+  var onChange;
+  var onCommentChange;
+  beforeEach(function () {
+    onChange = jest.fn();
+    onCommentChange = jest.fn();
+
+    global.document.createRange = function () {
+      return {
+        setStart: function setStart() {},
+        setEnd: function setEnd() {},
+        commonAncestorContainer: {
+          nodeName: 'BODY',
+          ownerDocument: document
+        }
+      };
+    };
+  });
+
+  var wrapper = function wrapper(extras) {
+    var defaults = _objectSpread(_objectSpread({}, defaultProps), {}, {
+      onChange: onChange,
+      onCommentChange: onCommentChange
+    });
+
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(Editor, props));
+  };
+
+  describe('snapshots', function () {
+    it('renders', function () {
+      expect(wrapper()).toMatchSnapshot();
+    });
+    it('renders disabled', function () {
+      expect(wrapper({
+        disabled: true
+      })).toMatchSnapshot();
+    });
+    it('renders with predefined annotations', function () {
+      expect(wrapper({
+        predefinedAnnotations: predefinedAnnotations
+      })).toMatchSnapshot();
+    });
+    it('renders with text and annotations', function () {
+      expect(wrapper({
+        text: '<div>This is an example.</div>',
+        annotations: [{
+          'id': '1',
+          'label': 'good',
+          'type': 'positive',
+          'quote': 'This',
+          'start': 0,
+          'end': 4
+        }]
+      })).toMatchSnapshot();
+    });
+    it('renders with complex text and nested annotations', function () {
+      expect(wrapper({
+        text: '<div>This is <b>a complex </b><em>example</em><br/>This is a new line.</div>',
+        annotations: [{
+          'id': '1',
+          'label': 'creative',
+          'type': 'positive',
+          'quote': 'This is a complex exam',
+          'start': 0,
+          'end': 22
+        }, {
+          'id': '2',
+          'label': 'punctuation',
+          'type': 'negative',
+          'quote': 'exampleThis is',
+          'start': 18,
+          'end': 32
+        }, {
+          'id': '3',
+          'label': 'cut',
+          'type': 'negative',
+          'quote': 'a comp',
+          'start': 8,
+          'end': 14
+        }]
+      })).toMatchSnapshot();
+    });
+    it('renders with text and comment', function () {
+      expect(wrapper({
+        text: '<div>This is an example.</div>',
+        comment: '<div>Very good</div>'
+      })).toMatchSnapshot();
+    });
+  });
+  describe('logic', function () {
+    describe('select a predefined annotation', function () {
+      it('calls onChange when new annotation selected', function () {
+        var w = wrapper({
+          text: '<div>This is an example.</div>'
+        });
+        w.instance().createDOMAnnotation = jest.fn();
+        w.instance().handleClose = jest.fn();
+        w.update();
+        w.setState({
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          selectionDetails: {
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }
+        });
+        w.instance().handleMenuClick({
+          type: 'positive',
+          text: 'good'
+        });
+        expect(w.instance().createDOMAnnotation).toBeCalled();
+        expect(onChange).toBeCalled();
+        expect(w.instance().handleClose).toBeCalled();
+      });
+      it('calls onChange when old annotation selected', function () {
+        var w = wrapper({
+          text: '<div>This is an example.</div>',
+          annotations: [{
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }]
+        });
+        w.instance().updateLabel = jest.fn();
+        w.instance().handleClose = jest.fn();
+        w.update();
+        w.setState({
+          annotation: {
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          },
+          labelElem: mockedElementDOM,
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          annotationIndex: 0
+        });
+        w.instance().handleMenuClick({
+          type: 'negative',
+          text: 'wrong'
+        });
+        expect(w.instance().updateLabel).toBeCalled();
+        expect(onChange).toBeCalled();
+        expect(w.instance().handleClose).toBeCalled();
+      });
+    });
+    describe('write new annotation', function () {
+      it('calls onChange', function () {
+        var w = wrapper({
+          text: '<div>This is an example.</div>'
+        });
+        w.instance().createDOMAnnotation = jest.fn();
+        w.update();
+        w.setState({
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          selectionDetails: {
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }
+        });
+        w.instance().addAnnotation('positive');
+        expect(w.instance().createDOMAnnotation).toBeCalled();
+        expect(onChange).toBeCalled();
+      });
+    });
+    describe('edit annotation', function () {
+      it('updates state', function () {
+        var w = wrapper();
+        w.setState({
+          openedMenu: true,
+          openedEditor: false
+        });
+        w.instance().editAnnotation();
+        expect(w.state().openedMenu).toEqual(false);
+        expect(w.state().openedEditor).toEqual(true);
+      });
+    });
+    describe('delete annotation', function () {
+      it('calls onChange', function () {
+        var w = wrapper({
+          text: '<div>This is an example.</div>'
+        });
+        w.instance().handleClose = jest.fn();
+        w.update();
+        w.setState({
+          annotation: {
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          },
+          labelElem: mockedElementDOM,
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          annotationIndex: 0
+        });
+        w.instance().deleteAnnotation();
+        expect(utils.removeElemsWrapping).toBeCalled();
+        expect(onChange).toBeCalled();
+        expect(w.instance().handleClose).toBeCalled();
+      });
+    });
+    describe('update annotation', function () {
+      it('calls onChange', function () {
+        var w = wrapper({
+          text: '<div>This is an example.</div>',
+          annotations: [{
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }]
+        });
+        w.instance().updateLabel = jest.fn();
+        w.update();
+        w.setState({
+          annotationIndex: 0
+        });
+        w.instance().updateAnnotation();
+        expect(w.instance().updateLabel).toBeCalled();
+        expect(onChange).toBeCalled();
+      });
+    });
+    describe('change annotation type', function () {
+      it('calls onChange', function () {
+        var w = wrapper({
+          text: '<div>This is an example.</div>',
+          annotations: [{
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }]
+        });
+        w.instance().updateLabel = jest.fn();
+        w.instance().handleClose = jest.fn();
+        w.update();
+        w.setState({
+          annotation: {
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          },
+          labelElem: mockedElementDOM,
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          annotationIndex: 0
+        });
+        w.instance().changeAnnotationType('very good');
+        expect(w.instance().updateLabel).toBeCalled();
+        expect(onChange).toBeCalled();
+        expect(w.instance().handleClose).toBeCalled();
+      });
+    });
+    describe('update annotation label', function () {
+      it('calls createDOMAnnotation', function () {
+        var w = wrapper({
+          text: '<div>This is an example.</div>',
+          annotations: [{
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          }]
+        });
+        w.instance().updateLabel = jest.fn();
+        w.instance().handleClose = jest.fn();
+        w.update();
+        w.setState({
+          annotation: {
+            'id': '1',
+            'label': 'good',
+            'type': 'positive',
+            'quote': 'This',
+            'start': 0,
+            'end': 4
+          },
+          labelElem: mockedElementDOM,
+          selectedElems: [mockedElementDOM, mockedElementDOM],
+          annotationIndex: 0
+        });
+        w.instance().changeAnnotationType('very good');
+        expect(w.instance().updateLabel).toBeCalled();
+        expect(onChange).toBeCalled();
+        expect(w.instance().handleClose).toBeCalled();
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/annotation/__tests__/annotation-editor.test.jsx"],"names":["Editor","AnnotationEditor","predefinedAnnotations","label","text","type","mockedElementDOM","removeChild","jest","fn","classList","remove","add","spyOn","utils","mockImplementation","describe","defaultProps","classes","annotations","comment","width","height","maxHeight","disabled","disabledMath","customKeys","keypadMode","onChange","onCommentChange","beforeEach","global","document","createRange","setStart","setEnd","commonAncestorContainer","nodeName","ownerDocument","wrapper","extras","defaults","props","it","expect","toMatchSnapshot","w","instance","createDOMAnnotation","handleClose","update","setState","selectedElems","selectionDetails","handleMenuClick","toBeCalled","updateLabel","annotation","labelElem","annotationIndex","addAnnotation","openedMenu","openedEditor","editAnnotation","state","toEqual","deleteAnnotation","removeElemsWrapping","updateAnnotation","changeAnnotationType"],"mappings":";;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;;;;;;;;;AAEA,IAAMA,MAAM,GAAG,uBAAOC,4BAAP,CAAf;AACA,IAAMC,qBAAqB,GAAG,CAC5B;AACEC,EAAAA,KAAK,EAAE,MADT;AAEEC,EAAAA,IAAI,EAAE,MAFR;AAGEC,EAAAA,IAAI,EAAE;AAHR,CAD4B,EAKzB;AACDF,EAAAA,KAAK,EAAE,GADN;AAEDC,EAAAA,IAAI,EAAE,GAFL;AAGDC,EAAAA,IAAI,EAAE;AAHL,CALyB,EASzB;AACDF,EAAAA,KAAK,EAAE,KADN;AAEDC,EAAAA,IAAI,EAAE,KAFL;AAGDC,EAAAA,IAAI,EAAE;AAHL,CATyB,EAazB;AACDF,EAAAA,KAAK,EAAE,IADN;AAEDC,EAAAA,IAAI,EAAE,UAFL;AAGDC,EAAAA,IAAI,EAAE;AAHL,CAbyB,CAA9B;AAmBA,IAAMC,gBAAgB,GAAG;AACvBC,EAAAA,WAAW,EAAEC,IAAI,CAACC,EAAL,EADU;AAEvBC,EAAAA,SAAS,EAAE;AACTC,IAAAA,MAAM,EAAEH,IAAI,CAACC,EAAL,EADC;AAETG,IAAAA,GAAG,EAAEJ,IAAI,CAACC,EAAL;AAFI;AAFY,CAAzB;AAQAD,IAAI,CAACK,KAAL,CAAWC,KAAX,EAAkB,qBAAlB,EAAyCC,kBAAzC,CAA4D,YAAM,CAAE,CAApE;AAEAC,QAAQ,CAAC,iBAAD,EAAoB,YAAM;AAChC,MAAMC,YAAY,GAAG;AACnBC,IAAAA,OAAO,EAAE,EADU;AAEnBd,IAAAA,IAAI,EAAE,EAFa;AAGnBe,IAAAA,WAAW,EAAE,EAHM;AAInBC,IAAAA,OAAO,EAAE,EAJU;AAKnBlB,IAAAA,qBAAqB,EAAE,EALJ;AAMnBmB,IAAAA,KAAK,EAAE,GANY;AAOnBC,IAAAA,MAAM,EAAE,GAPW;AAQnBC,IAAAA,SAAS,EAAE,MARQ;AASnBC,IAAAA,QAAQ,EAAE,KATS;AAUnBC,IAAAA,YAAY,EAAE,KAVK;AAWnBC,IAAAA,UAAU,EAAE,EAXO;AAYnBC,IAAAA,UAAU,EAAE;AAZO,GAArB;AAcA,MAAIC,QAAJ;AACA,MAAIC,eAAJ;AAEAC,EAAAA,UAAU,CAAC,YAAM;AACfF,IAAAA,QAAQ,GAAGpB,IAAI,CAACC,EAAL,EAAX;AACAoB,IAAAA,eAAe,GAAGrB,IAAI,CAACC,EAAL,EAAlB;;AAEAsB,IAAAA,MAAM,CAACC,QAAP,CAAgBC,WAAhB,GAA8B;AAAA,aAAO;AACnCC,QAAAA,QAAQ,EAAE,oBAAM,CAAE,CADiB;AAEnCC,QAAAA,MAAM,EAAE,kBAAM,CAAE,CAFmB;AAGnCC,QAAAA,uBAAuB,EAAE;AACvBC,UAAAA,QAAQ,EAAE,MADa;AAEvBC,UAAAA,aAAa,EAAEN;AAFQ;AAHU,OAAP;AAAA,KAA9B;AAQD,GAZS,CAAV;;AAcA,MAAMO,OAAO,GAAG,SAAVA,OAAU,CAAAC,MAAM,EAAI;AACxB,QAAMC,QAAQ,mCACTxB,YADS;AAEZW,MAAAA,QAAQ,EAARA,QAFY;AAGZC,MAAAA,eAAe,EAAfA;AAHY,MAAd;;AAKA,QAAMa,KAAK,mCAAQD,QAAR,GAAqBD,MAArB,CAAX;;AAEA,WAAO,mCAAQ,gCAAC,MAAD,EAAaE,KAAb,CAAR,CAAP;AACD,GATD;;AAWA1B,EAAAA,QAAQ,CAAC,WAAD,EAAc,YAAM;AAC1B2B,IAAAA,EAAE,CAAC,SAAD,EAAY,YAAM;AAClBC,MAAAA,MAAM,CAACL,OAAO,EAAR,CAAN,CAAkBM,eAAlB;AACD,KAFC,CAAF;AAIAF,IAAAA,EAAE,CAAC,kBAAD,EAAqB,YAAM;AAC3BC,MAAAA,MAAM,CAACL,OAAO,CAAC;AAAEf,QAAAA,QAAQ,EAAE;AAAZ,OAAD,CAAR,CAAN,CAAoCqB,eAApC;AACD,KAFC,CAAF;AAIAF,IAAAA,EAAE,CAAC,qCAAD,EAAwC,YAAM;AAC9CC,MAAAA,MAAM,CAACL,OAAO,CAAC;AAAErC,QAAAA,qBAAqB,EAArBA;AAAF,OAAD,CAAR,CAAN,CAA2C2C,eAA3C;AACD,KAFC,CAAF;AAIAF,IAAAA,EAAE,CAAC,mCAAD,EAAsC,YAAM;AAC5CC,MAAAA,MAAM,CACJL,OAAO,CAAC;AACNnC,QAAAA,IAAI,EAAE,gCADA;AAENe,QAAAA,WAAW,EAAE,CACX;AACE,gBAAM,GADR;AAEE,mBAAS,MAFX;AAGE,kBAAQ,UAHV;AAIE,mBAAS,MAJX;AAKE,mBAAS,CALX;AAME,iBAAO;AANT,SADW;AAFP,OAAD,CADH,CAAN,CAcE0B,eAdF;AAeD,KAhBC,CAAF;AAkBAF,IAAAA,EAAE,CAAC,kDAAD,EAAqD,YAAM;AAC3DC,MAAAA,MAAM,CACJL,OAAO,CAAC;AACNnC,QAAAA,IAAI,EAAE,8EADA;AAENe,QAAAA,WAAW,EAAE,CACX;AACE,gBAAM,GADR;AAEE,mBAAS,UAFX;AAGE,kBAAQ,UAHV;AAIE,mBAAS,wBAJX;AAKE,mBAAS,CALX;AAME,iBAAO;AANT,SADW,EASX;AACE,gBAAM,GADR;AAEE,mBAAS,aAFX;AAGE,kBAAQ,UAHV;AAIE,mBAAS,gBAJX;AAKE,mBAAS,EALX;AAME,iBAAO;AANT,SATW,EAiBX;AACE,gBAAM,GADR;AAEE,mBAAS,KAFX;AAGE,kBAAQ,UAHV;AAIE,mBAAS,QAJX;AAKE,mBAAS,CALX;AAME,iBAAO;AANT,SAjBW;AAFP,OAAD,CADH,CAAN,CA8BE0B,eA9BF;AA+BD,KAhCC,CAAF;AAkCAF,IAAAA,EAAE,CAAC,+BAAD,EAAkC,YAAM;AACxCC,MAAAA,MAAM,CACJL,OAAO,CAAC;AACNnC,QAAAA,IAAI,EAAE,gCADA;AAENgB,QAAAA,OAAO,EAAE;AAFH,OAAD,CADH,CAAN,CAKEyB,eALF;AAMD,KAPC,CAAF;AAQD,GAzEO,CAAR;AA2EA7B,EAAAA,QAAQ,CAAC,OAAD,EAAU,YAAM;AACtBA,IAAAA,QAAQ,CAAC,gCAAD,EAAmC,YAAM;AAC/C2B,MAAAA,EAAE,CAAC,6CAAD,EAAiD,YAAM;AACvD,YAAMG,CAAC,GAAGP,OAAO,CAAC;AAChBnC,UAAAA,IAAI,EAAE;AADU,SAAD,CAAjB;AAIA0C,QAAAA,CAAC,CAACC,QAAF,GAAaC,mBAAb,GAAmCxC,IAAI,CAACC,EAAL,EAAnC;AACAqC,QAAAA,CAAC,CAACC,QAAF,GAAaE,WAAb,GAA2BzC,IAAI,CAACC,EAAL,EAA3B;AACAqC,QAAAA,CAAC,CAACI,MAAF;AAEAJ,QAAAA,CAAC,CAACK,QAAF,CAAW;AACTC,UAAAA,aAAa,EAAE,CAAC9C,gBAAD,EAAmBA,gBAAnB,CADN;AAET+C,UAAAA,gBAAgB,EAAE;AAChB,qBAAS,MADO;AAEhB,qBAAS,CAFO;AAGhB,mBAAO;AAHS;AAFT,SAAX;AAQAP,QAAAA,CAAC,CAACC,QAAF,GAAaO,eAAb,CAA6B;AAC3BjD,UAAAA,IAAI,EAAE,UADqB;AAE3BD,UAAAA,IAAI,EAAE;AAFqB,SAA7B;AAKAwC,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaC,mBAAd,CAAN,CAAyCO,UAAzC;AACAX,QAAAA,MAAM,CAAChB,QAAD,CAAN,CAAiB2B,UAAjB;AACAX,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaE,WAAd,CAAN,CAAiCM,UAAjC;AACD,OAzBC,CAAF;AA2BAZ,MAAAA,EAAE,CAAC,6CAAD,EAAiD,YAAM;AACvD,YAAMG,CAAC,GAAGP,OAAO,CAAC;AAChBnC,UAAAA,IAAI,EAAE,gCADU;AAEhBe,UAAAA,WAAW,EAAE,CACX;AACE,kBAAM,GADR;AAEE,qBAAS,MAFX;AAGE,oBAAQ,UAHV;AAIE,qBAAS,MAJX;AAKE,qBAAS,CALX;AAME,mBAAO;AANT,WADW;AAFG,SAAD,CAAjB;AAcA2B,QAAAA,CAAC,CAACC,QAAF,GAAaS,WAAb,GAA2BhD,IAAI,CAACC,EAAL,EAA3B;AACAqC,QAAAA,CAAC,CAACC,QAAF,GAAaE,WAAb,GAA2BzC,IAAI,CAACC,EAAL,EAA3B;AACAqC,QAAAA,CAAC,CAACI,MAAF;AAEAJ,QAAAA,CAAC,CAACK,QAAF,CAAW;AACTM,UAAAA,UAAU,EAAE;AACV,kBAAM,GADI;AAEV,qBAAS,MAFC;AAGV,oBAAQ,UAHE;AAIV,qBAAS,MAJC;AAKV,qBAAS,CALC;AAMV,mBAAO;AANG,WADH;AASTC,UAAAA,SAAS,EAAEpD,gBATF;AAUT8C,UAAAA,aAAa,EAAE,CAAC9C,gBAAD,EAAmBA,gBAAnB,CAVN;AAWTqD,UAAAA,eAAe,EAAE;AAXR,SAAX;AAaAb,QAAAA,CAAC,CAACC,QAAF,GAAaO,eAAb,CAA6B;AAC3BjD,UAAAA,IAAI,EAAE,UADqB;AAE3BD,UAAAA,IAAI,EAAE;AAFqB,SAA7B;AAIAwC,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaS,WAAd,CAAN,CAAiCD,UAAjC;AACAX,QAAAA,MAAM,CAAChB,QAAD,CAAN,CAAiB2B,UAAjB;AACAX,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaE,WAAd,CAAN,CAAiCM,UAAjC;AACD,OAvCC,CAAF;AAwCD,KApEO,CAAR;AAsEAvC,IAAAA,QAAQ,CAAC,sBAAD,EAAyB,YAAM;AACrC2B,MAAAA,EAAE,CAAC,gBAAD,EAAoB,YAAM;AAC1B,YAAMG,CAAC,GAAGP,OAAO,CAAC;AAChBnC,UAAAA,IAAI,EAAE;AADU,SAAD,CAAjB;AAIA0C,QAAAA,CAAC,CAACC,QAAF,GAAaC,mBAAb,GAAmCxC,IAAI,CAACC,EAAL,EAAnC;AACAqC,QAAAA,CAAC,CAACI,MAAF;AAEAJ,QAAAA,CAAC,CAACK,QAAF,CAAW;AACTC,UAAAA,aAAa,EAAE,CAAC9C,gBAAD,EAAmBA,gBAAnB,CADN;AAET+C,UAAAA,gBAAgB,EAAE;AAChB,qBAAS,MADO;AAEhB,qBAAS,CAFO;AAGhB,mBAAO;AAHS;AAFT,SAAX;AAQAP,QAAAA,CAAC,CAACC,QAAF,GAAaa,aAAb,CAA2B,UAA3B;AAEAhB,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaC,mBAAd,CAAN,CAAyCO,UAAzC;AACAX,QAAAA,MAAM,CAAChB,QAAD,CAAN,CAAiB2B,UAAjB;AACD,OApBC,CAAF;AAqBD,KAtBO,CAAR;AAwBAvC,IAAAA,QAAQ,CAAC,iBAAD,EAAoB,YAAM;AAChC2B,MAAAA,EAAE,CAAC,eAAD,EAAmB,YAAM;AACzB,YAAMG,CAAC,GAAGP,OAAO,EAAjB;AAEAO,QAAAA,CAAC,CAACK,QAAF,CAAW;AACTU,UAAAA,UAAU,EAAE,IADH;AAETC,UAAAA,YAAY,EAAE;AAFL,SAAX;AAIAhB,QAAAA,CAAC,CAACC,QAAF,GAAagB,cAAb;AACAnB,QAAAA,MAAM,CAACE,CAAC,CAACkB,KAAF,GAAUH,UAAX,CAAN,CAA6BI,OAA7B,CAAqC,KAArC;AACArB,QAAAA,MAAM,CAACE,CAAC,CAACkB,KAAF,GAAUF,YAAX,CAAN,CAA+BG,OAA/B,CAAuC,IAAvC;AACD,OAVC,CAAF;AAWD,KAZO,CAAR;AAcAjD,IAAAA,QAAQ,CAAC,mBAAD,EAAsB,YAAM;AAClC2B,MAAAA,EAAE,CAAC,gBAAD,EAAoB,YAAM;AAC1B,YAAMG,CAAC,GAAGP,OAAO,CAAC;AAChBnC,UAAAA,IAAI,EAAE;AADU,SAAD,CAAjB;AAIA0C,QAAAA,CAAC,CAACC,QAAF,GAAaE,WAAb,GAA2BzC,IAAI,CAACC,EAAL,EAA3B;AACAqC,QAAAA,CAAC,CAACI,MAAF;AAEAJ,QAAAA,CAAC,CAACK,QAAF,CAAW;AACTM,UAAAA,UAAU,EAAE;AACV,kBAAM,GADI;AAEV,qBAAS,MAFC;AAGV,oBAAQ,UAHE;AAIV,qBAAS,MAJC;AAKV,qBAAS,CALC;AAMV,mBAAO;AANG,WADH;AASTC,UAAAA,SAAS,EAAEpD,gBATF;AAUT8C,UAAAA,aAAa,EAAE,CAAC9C,gBAAD,EAAmBA,gBAAnB,CAVN;AAWTqD,UAAAA,eAAe,EAAE;AAXR,SAAX;AAaAb,QAAAA,CAAC,CAACC,QAAF,GAAamB,gBAAb;AAEAtB,QAAAA,MAAM,CAAC9B,KAAK,CAACqD,mBAAP,CAAN,CAAkCZ,UAAlC;AACAX,QAAAA,MAAM,CAAChB,QAAD,CAAN,CAAiB2B,UAAjB;AACAX,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaE,WAAd,CAAN,CAAiCM,UAAjC;AACD,OA1BC,CAAF;AA2BD,KA5BO,CAAR;AA8BAvC,IAAAA,QAAQ,CAAC,mBAAD,EAAsB,YAAM;AAClC2B,MAAAA,EAAE,CAAC,gBAAD,EAAoB,YAAM;AAC1B,YAAMG,CAAC,GAAGP,OAAO,CAAC;AAChBnC,UAAAA,IAAI,EAAE,gCADU;AAEhBe,UAAAA,WAAW,EAAE,CACX;AACE,kBAAM,GADR;AAEE,qBAAS,MAFX;AAGE,oBAAQ,UAHV;AAIE,qBAAS,MAJX;AAKE,qBAAS,CALX;AAME,mBAAO;AANT,WADW;AAFG,SAAD,CAAjB;AAcA2B,QAAAA,CAAC,CAACC,QAAF,GAAaS,WAAb,GAA2BhD,IAAI,CAACC,EAAL,EAA3B;AACAqC,QAAAA,CAAC,CAACI,MAAF;AAEAJ,QAAAA,CAAC,CAACK,QAAF,CAAW;AACTQ,UAAAA,eAAe,EAAE;AADR,SAAX;AAGAb,QAAAA,CAAC,CAACC,QAAF,GAAaqB,gBAAb;AAEAxB,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaS,WAAd,CAAN,CAAiCD,UAAjC;AACAX,QAAAA,MAAM,CAAChB,QAAD,CAAN,CAAiB2B,UAAjB;AACD,OAzBC,CAAF;AA0BD,KA3BO,CAAR;AA6BAvC,IAAAA,QAAQ,CAAC,wBAAD,EAA2B,YAAM;AACvC2B,MAAAA,EAAE,CAAC,gBAAD,EAAoB,YAAM;AAC1B,YAAMG,CAAC,GAAGP,OAAO,CAAC;AAChBnC,UAAAA,IAAI,EAAE,gCADU;AAEhBe,UAAAA,WAAW,EAAE,CACX;AACE,kBAAM,GADR;AAEE,qBAAS,MAFX;AAGE,oBAAQ,UAHV;AAIE,qBAAS,MAJX;AAKE,qBAAS,CALX;AAME,mBAAO;AANT,WADW;AAFG,SAAD,CAAjB;AAcA2B,QAAAA,CAAC,CAACC,QAAF,GAAaS,WAAb,GAA2BhD,IAAI,CAACC,EAAL,EAA3B;AACAqC,QAAAA,CAAC,CAACC,QAAF,GAAaE,WAAb,GAA2BzC,IAAI,CAACC,EAAL,EAA3B;AACAqC,QAAAA,CAAC,CAACI,MAAF;AAEAJ,QAAAA,CAAC,CAACK,QAAF,CAAW;AACTM,UAAAA,UAAU,EAAE;AACV,kBAAM,GADI;AAEV,qBAAS,MAFC;AAGV,oBAAQ,UAHE;AAIV,qBAAS,MAJC;AAKV,qBAAS,CALC;AAMV,mBAAO;AANG,WADH;AASTC,UAAAA,SAAS,EAAEpD,gBATF;AAUT8C,UAAAA,aAAa,EAAE,CAAC9C,gBAAD,EAAmBA,gBAAnB,CAVN;AAWTqD,UAAAA,eAAe,EAAE;AAXR,SAAX;AAaAb,QAAAA,CAAC,CAACC,QAAF,GAAasB,oBAAb,CAAkC,WAAlC;AACAzB,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaS,WAAd,CAAN,CAAiCD,UAAjC;AACAX,QAAAA,MAAM,CAAChB,QAAD,CAAN,CAAiB2B,UAAjB;AACAX,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaE,WAAd,CAAN,CAAiCM,UAAjC;AACD,OApCC,CAAF;AAqCD,KAtCO,CAAR;AAwCAvC,IAAAA,QAAQ,CAAC,yBAAD,EAA4B,YAAM;AACxC2B,MAAAA,EAAE,CAAC,2BAAD,EAA+B,YAAM;AACrC,YAAMG,CAAC,GAAGP,OAAO,CAAC;AAChBnC,UAAAA,IAAI,EAAE,gCADU;AAEhBe,UAAAA,WAAW,EAAE,CACX;AACE,kBAAM,GADR;AAEE,qBAAS,MAFX;AAGE,oBAAQ,UAHV;AAIE,qBAAS,MAJX;AAKE,qBAAS,CALX;AAME,mBAAO;AANT,WADW;AAFG,SAAD,CAAjB;AAcA2B,QAAAA,CAAC,CAACC,QAAF,GAAaS,WAAb,GAA2BhD,IAAI,CAACC,EAAL,EAA3B;AACAqC,QAAAA,CAAC,CAACC,QAAF,GAAaE,WAAb,GAA2BzC,IAAI,CAACC,EAAL,EAA3B;AACAqC,QAAAA,CAAC,CAACI,MAAF;AAEAJ,QAAAA,CAAC,CAACK,QAAF,CAAW;AACTM,UAAAA,UAAU,EAAE;AACV,kBAAM,GADI;AAEV,qBAAS,MAFC;AAGV,oBAAQ,UAHE;AAIV,qBAAS,MAJC;AAKV,qBAAS,CALC;AAMV,mBAAO;AANG,WADH;AASTC,UAAAA,SAAS,EAAEpD,gBATF;AAUT8C,UAAAA,aAAa,EAAE,CAAC9C,gBAAD,EAAmBA,gBAAnB,CAVN;AAWTqD,UAAAA,eAAe,EAAE;AAXR,SAAX;AAaAb,QAAAA,CAAC,CAACC,QAAF,GAAasB,oBAAb,CAAkC,WAAlC;AACAzB,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaS,WAAd,CAAN,CAAiCD,UAAjC;AACAX,QAAAA,MAAM,CAAChB,QAAD,CAAN,CAAiB2B,UAAjB;AACAX,QAAAA,MAAM,CAACE,CAAC,CAACC,QAAF,GAAaE,WAAd,CAAN,CAAiCM,UAAjC;AACD,OApCC,CAAF;AAqCD,KAtCO,CAAR;AAwCD,GAxPO,CAAR;AAyPD,CA/WO,CAAR","sourcesContent":["import { shallow } from 'enzyme';\nimport React from 'react';\nimport AnnotationEditor from '../annotation-editor';\nimport { unwrap } from \"@material-ui/core/test-utils\";\nimport * as utils from '../annotation-utils';\n\nconst Editor = unwrap(AnnotationEditor);\nconst predefinedAnnotations = [\n  {\n    label: 'good',\n    text: 'good',\n    type: 'positive'\n  }, {\n    label: '★',\n    text: '★',\n    type: 'positive'\n  }, {\n    label: 'cut',\n    text: 'cut',\n    type: 'negative'\n  }, {\n    label: 'sp',\n    text: 'spelling',\n    type: 'negative'\n  }\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\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  const wrapper = extras => {\n    const defaults = {\n      ...defaultProps,\n      onChange,\n      onCommentChange\n    };\n    const props = { ...defaults, ...extras };\n\n    return shallow(<Editor { ...props } />);\n  };\n\n  describe('snapshots', () => {\n    it('renders', () => {\n      expect(wrapper()).toMatchSnapshot();\n    });\n\n    it('renders disabled', () => {\n      expect(wrapper({ disabled: true })).toMatchSnapshot();\n    });\n\n    it('renders with predefined annotations', () => {\n      expect(wrapper({ predefinedAnnotations })).toMatchSnapshot();\n    });\n\n    it('renders with text and annotations', () => {\n      expect(\n        wrapper({\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      ).toMatchSnapshot();\n    });\n\n    it('renders with complex text and nested annotations', () => {\n      expect(\n        wrapper({\n          text: '<div>This is <b>a complex </b><em>example</em><br/>This is a new line.</div>',\n          annotations: [\n            {\n              'id': '1',\n              'label': 'creative',\n              'type': 'positive',\n              'quote': 'This is a complex exam',\n              'start': 0,\n              'end': 22\n            },\n            {\n              'id': '2',\n              'label': 'punctuation',\n              'type': 'negative',\n              'quote': 'exampleThis is',\n              'start': 18,\n              'end': 32\n            },\n            {\n              'id': '3',\n              'label': 'cut',\n              'type': 'negative',\n              'quote': 'a comp',\n              'start': 8,\n              'end': 14\n            }\n          ]\n        })\n      ).toMatchSnapshot();\n    });\n\n    it('renders with text and comment', () => {\n      expect(\n        wrapper({\n          text: '<div>This is an example.</div>',\n          comment: '<div>Very good</div>'\n        })\n      ).toMatchSnapshot();\n    });\n  });\n\n  describe('logic', () => {\n    describe('select a predefined annotation', () => {\n      it('calls onChange when new annotation selected',  () => {\n        const w = wrapper({\n          text: '<div>This is an example.</div>',\n        });\n\n        w.instance().createDOMAnnotation = jest.fn();\n        w.instance().handleClose = jest.fn();\n        w.update();\n\n        w.setState({\n          selectedElems: [mockedElementDOM, mockedElementDOM],\n          selectionDetails: {\n            'quote': 'This',\n            'start': 0,\n            'end': 4\n          },\n        });\n        w.instance().handleMenuClick({\n          type: 'positive',\n          text: 'good'\n        });\n\n        expect(w.instance().createDOMAnnotation).toBeCalled();\n        expect(onChange).toBeCalled();\n        expect(w.instance().handleClose).toBeCalled();\n      });\n\n      it('calls onChange when old annotation selected',  () => {\n        const w = wrapper({\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        w.instance().updateLabel = jest.fn();\n        w.instance().handleClose = jest.fn();\n        w.update();\n\n        w.setState({\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        w.instance().handleMenuClick({\n          type: 'negative',\n          text: 'wrong'\n        });\n        expect(w.instance().updateLabel).toBeCalled();\n        expect(onChange).toBeCalled();\n        expect(w.instance().handleClose).toBeCalled();\n      });\n    });\n\n    describe('write new annotation', () => {\n      it('calls onChange',  () => {\n        const w = wrapper({\n          text: '<div>This is an example.</div>',\n        });\n\n        w.instance().createDOMAnnotation = jest.fn();\n        w.update();\n\n        w.setState({\n          selectedElems: [mockedElementDOM, mockedElementDOM],\n          selectionDetails: {\n            'quote': 'This',\n            'start': 0,\n            'end': 4\n          },\n        });\n        w.instance().addAnnotation('positive');\n\n        expect(w.instance().createDOMAnnotation).toBeCalled();\n        expect(onChange).toBeCalled();\n      });\n    });\n\n    describe('edit annotation', () => {\n      it('updates state',  () => {\n        const w = wrapper();\n\n        w.setState({\n          openedMenu: true,\n          openedEditor: false\n        });\n        w.instance().editAnnotation();\n        expect(w.state().openedMenu).toEqual(false);\n        expect(w.state().openedEditor).toEqual(true);\n      });\n    });\n\n    describe('delete annotation', () => {\n      it('calls onChange',  () => {\n        const w = wrapper({\n          text: '<div>This is an example.</div>',\n        });\n\n        w.instance().handleClose = jest.fn();\n        w.update();\n\n        w.setState({\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        w.instance().deleteAnnotation();\n\n        expect(utils.removeElemsWrapping).toBeCalled();\n        expect(onChange).toBeCalled();\n        expect(w.instance().handleClose).toBeCalled();\n      });\n    });\n\n    describe('update annotation', () => {\n      it('calls onChange',  () => {\n        const w = wrapper({\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        w.instance().updateLabel = jest.fn();\n        w.update();\n\n        w.setState({\n          annotationIndex: 0\n        });\n        w.instance().updateAnnotation();\n\n        expect(w.instance().updateLabel).toBeCalled();\n        expect(onChange).toBeCalled();\n      });\n    });\n\n    describe('change annotation type', () => {\n      it('calls onChange',  () => {\n        const w = wrapper({\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        w.instance().updateLabel = jest.fn();\n        w.instance().handleClose = jest.fn();\n        w.update();\n\n        w.setState({\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        w.instance().changeAnnotationType('very good');\n        expect(w.instance().updateLabel).toBeCalled();\n        expect(onChange).toBeCalled();\n        expect(w.instance().handleClose).toBeCalled();\n      });\n    });\n\n    describe('update annotation label', () => {\n      it('calls createDOMAnnotation',  () => {\n        const w = wrapper({\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        w.instance().updateLabel = jest.fn();\n        w.instance().handleClose = jest.fn();\n        w.update();\n\n        w.setState({\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        w.instance().changeAnnotationType('very good');\n        expect(w.instance().updateLabel).toBeCalled();\n        expect(onChange).toBeCalled();\n        expect(w.instance().handleClose).toBeCalled();\n      });\n    });\n\n  });\n});\n"]}

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

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _annotationMenu = _interopRequireDefault(require("../annotation-menu"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+describe('freeform editor', function () {
+  var defaultProps = {
+    classes: {},
+    anchorEl: {},
+    open: false,
+    annotations: [],
+    isNewAnnotation: false
+  };
+  var onClose;
+  var onDelete;
+  var onEdit;
+  var onWrite;
+  var onAnnotate;
+  beforeEach(function () {
+    onClose = jest.fn();
+    onDelete = jest.fn();
+    onEdit = jest.fn();
+    onWrite = jest.fn();
+    onAnnotate = jest.fn();
+  });
+
+  var wrapper = function wrapper(extras) {
+    var defaults = _objectSpread(_objectSpread({}, defaultProps), {}, {
+      onClose: onClose,
+      onDelete: onDelete,
+      onEdit: onEdit,
+      onWrite: onWrite,
+      onAnnotate: onAnnotate
+    });
+
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_annotationMenu["default"], props));
+  };
+
+  describe('snapshots', function () {
+    it('renders', function () {
+      expect(wrapper()).toMatchSnapshot();
+    });
+    it('opened', function () {
+      expect(wrapper({
+        open: true
+      })).toMatchSnapshot();
+    });
+    it('opened and new annotation selected', function () {
+      expect(wrapper({
+        open: true,
+        isNewAnnotation: true
+      })).toMatchSnapshot();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _enzyme = require("enzyme");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _freeformEditor = _interopRequireDefault(require("../freeform-editor"));
+
+var _testUtils = require("@material-ui/core/test-utils");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var Editor = (0, _testUtils.unwrap)(_freeformEditor["default"]);
+describe('freeform editor', function () {
+  var defaultProps = {
+    classes: {},
+    anchorEl: {},
+    open: false,
+    offset: 10,
+    value: 'note',
+    type: 'positive'
+  };
+  var onClose;
+  var onDelete;
+  var onSave;
+  var onTypeChange;
+  beforeEach(function () {
+    onClose = jest.fn();
+    onDelete = jest.fn();
+    onSave = jest.fn();
+    onTypeChange = jest.fn();
+  });
+
+  var wrapper = function wrapper(extras) {
+    var defaults = _objectSpread(_objectSpread({}, defaultProps), {}, {
+      onClose: onClose,
+      onDelete: onDelete,
+      onSave: onSave,
+      onTypeChange: onTypeChange
+    });
+
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(Editor, props));
+  };
+
+  describe('snapshots', function () {
+    it('renders', function () {
+      expect(wrapper()).toMatchSnapshot();
+    });
+    it('opened', function () {
+      expect(wrapper({
+        open: true
+      })).toMatchSnapshot();
+    });
+    it('opened, negative type', function () {
+      expect(wrapper({
+        open: true,
+        type: 'negative'
+      })).toMatchSnapshot();
+    });
+  });
+  describe('logic', function () {
+    describe('save or autosave', function () {
+      it('calls onSave', function () {
+        var w = wrapper();
+        w.setState({
+          value: 'good'
+        });
+        w.instance().handleSave();
+        expect(onSave).toBeCalled();
+      });
+      it('calls onDelete', function () {
+        var w = wrapper();
+        w.setState({
+          value: ''
+        });
+        w.instance().handleSave();
+        expect(onDelete).toBeCalled();
+      });
+      it('calls onClose', function () {
+        var w = wrapper();
+        w.setState({
+          value: 'note'
+        });
+        w.instance().handleSave();
+        expect(onClose).toBeCalled();
+      });
+    });
+    describe('type change', function () {
+      it('calls onTypeChange', function () {
+        var w = wrapper();
+        w.instance().handleTypeChange();
+        expect(onTypeChange).toBeCalledWith('note');
+      });
+      it('calls onTypeChange with changed value', function () {
+        var w = wrapper();
+        w.setState({
+          value: 'good'
+        });
+        w.instance().handleTypeChange();
+        expect(onTypeChange).toBeCalledWith('good');
+      });
+      it('calls onDelete', function () {
+        var w = wrapper();
+        w.setState({
+          value: ''
+        });
+        w.instance().handleTypeChange();
+        expect(onDelete).toBeCalled();
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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