@pie-element/drawing-response 3.9.12 → 3.9.15-touch

package/lib/drawing-response/__tests__/drawing-main.test.js

@@ -0,0 +1,704 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _enzyme = require("enzyme");
+
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+
+var _drawableFreePath = _interopRequireDefault(require("../drawable-free-path"));
+
+var _drawableLine = _interopRequireDefault(require("../drawable-line"));
+
+var _drawableRectangle = _interopRequireDefault(require("../drawable-rectangle"));
+
+var _drawableCircle = _interopRequireDefault(require("../drawable-circle"));
+
+var _drawableEraser = _interopRequireDefault(require("../drawable-eraser"));
+
+var _drawableText = _interopRequireDefault(require("../drawable-text"));
+
+var _drawableMain = require("../drawable-main");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+var drawableClasses = {
+  FreePathDrawable: _drawableFreePath["default"],
+  LineDrawable: _drawableLine["default"],
+  RectangleDrawable: _drawableRectangle["default"],
+  CircleDrawable: _drawableCircle["default"],
+  EraserDrawable: _drawableEraser["default"],
+  DrawableText: _drawableText["default"]
+};
+describe('DrawingResponse', function () {
+  var element;
+  var wrapper;
+
+  var mkWrapper = function mkWrapper(type, props, WrapperEl) {
+    element = new drawableClasses[type](props);
+    var content = element.render(props);
+
+    if (WrapperEl) {
+      content = /*#__PURE__*/_react["default"].createElement(WrapperEl, null, content);
+    }
+
+    return (0, _enzyme.shallow)(content);
+  };
+
+  describe('DrawableMain', function () {
+    var onSessionChange = jest.fn();
+    var TextEntry = new _drawableText["default"]();
+
+    var wrapperMain = function wrapperMain(extras, renderOpts) {
+      var defaults = {
+        classes: {},
+        disabled: false,
+        className: 'className',
+        onSessionChange: onSessionChange,
+        imageDimensions: {},
+        imageUrl: 'url',
+        drawableDimensions: {
+          height: 350,
+          width: 353
+        },
+        fillColor: 'white',
+        outlineColor: 'black',
+        paintColor: 'red',
+        session: {},
+        toolActive: {
+          type: 'Select',
+          label: 'Select',
+          icon: 'mdiCursorDefault'
+        },
+        TextEntry: TextEntry
+      };
+
+      var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+      return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_drawableMain.DrawableMain, props), _objectSpread({}, renderOpts));
+    };
+
+    describe('snapshot', function () {
+      it('renders', function () {
+        var w = wrapperMain();
+        expect(w).toMatchSnapshot();
+      });
+      it('renders disabled', function () {
+        var w = wrapperMain({
+          disabled: true
+        });
+        expect(w).toMatchSnapshot();
+      });
+    });
+    describe('logic', function () {
+      var handleSessionChange = jest.fn();
+      var forceUpdate = jest.fn();
+      var props = {
+        handleSessionChange: handleSessionChange,
+        forceUpdate: forceUpdate,
+        paint: true,
+        paintColor: 'green',
+        startx: 200,
+        starty: 200,
+        x: 300,
+        y: 300,
+        createdAt: new Date()
+      };
+      it('handleUndo', function () {
+        var w = wrapperMain();
+        w.setState({
+          drawables: [new _drawableRectangle["default"](props), new _drawableRectangle["default"](props)]
+        });
+        w.instance().handleUndo();
+        expect(w.state('drawables').length).toEqual(1);
+        w.instance().handleUndo();
+        expect(w.state('drawables')).toEqual([]);
+      });
+      it('handleClearAll', function () {
+        var w = wrapperMain();
+        w.setState({
+          drawables: [new _drawableRectangle["default"](props), new _drawableRectangle["default"](props)]
+        });
+        w.instance().handleClearAll();
+        expect(w.state('drawables')).toEqual([]);
+      });
+    });
+  });
+  describe('CircleDrawable', function () {
+    var handleSessionChange = jest.fn();
+    var forceUpdate = jest.fn();
+    var props;
+    beforeEach(function () {
+      props = {
+        handleSessionChange: handleSessionChange,
+        forceUpdate: forceUpdate,
+        paint: true,
+        paintColor: 'green',
+        startx: 200,
+        starty: 200,
+        x: 300,
+        y: 200,
+        createdAt: new Date()
+      };
+      wrapper = mkWrapper('CircleDrawable', props);
+    });
+    describe('snapshot', function () {
+      it('renders', function () {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', function () {
+      it('calls forceUpdate', function () {
+        wrapper.simulate('click');
+        expect(forceUpdate).toHaveBeenCalled();
+      });
+      it('changes x and y', function () {
+        element.registerMovement(400, 400);
+        expect(element.x).toEqual(400);
+        expect(element.y).toEqual(400);
+      });
+      it('changes session when needed', function () {
+        var event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(event.target.getX).toHaveBeenCalled();
+        expect(event.target.getY).toHaveBeenCalled();
+        expect(handleSessionChange).toHaveBeenCalled();
+      });
+      it('changes startx and starty', function () {
+        var event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(element.startx).toEqual(300);
+        expect(element.starty).toEqual(300);
+        expect(element.x).toEqual(400);
+        expect(element.y).toEqual(300);
+      });
+    });
+  });
+  describe('EraserDrawable', function () {
+    var handleSessionChange = jest.fn();
+    var forceUpdate = jest.fn();
+    var props;
+    beforeEach(function () {
+      props = {
+        handleSessionChange: handleSessionChange,
+        forceUpdate: forceUpdate,
+        points: [200, 200, 300, 300],
+        posX: 200,
+        posY: 200,
+        startx: 200,
+        starty: 200,
+        createdAt: new Date()
+      };
+      wrapper = mkWrapper('EraserDrawable', props);
+    });
+    describe('snapshot', function () {
+      it('renders', function () {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', function () {
+      it('changes points', function () {
+        element.registerMovement(400, 400);
+        expect(element.points).toEqual([200, 200, 300, 300, 400, 400]);
+      });
+      it('changes session when needed', function () {
+        var event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(event.target.getX).toHaveBeenCalled();
+        expect(event.target.getY).toHaveBeenCalled();
+        expect(handleSessionChange).toHaveBeenCalled();
+      });
+      it('changes posX and posY', function () {
+        var event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(element.posX).toEqual(300);
+        expect(element.posY).toEqual(300);
+      });
+    });
+  });
+  describe('FreePathDrawable', function () {
+    var handleSessionChange = jest.fn();
+    var forceUpdate = jest.fn();
+    var props;
+    beforeEach(function () {
+      props = {
+        handleSessionChange: handleSessionChange,
+        forceUpdate: forceUpdate,
+        paint: true,
+        paintColor: 'green',
+        points: [200, 200, 300, 300],
+        posX: 200,
+        posY: 200,
+        startx: 200,
+        starty: 200,
+        createdAt: new Date()
+      };
+      wrapper = mkWrapper('FreePathDrawable', props);
+    });
+    describe('snapshot', function () {
+      it('renders', function () {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', function () {
+      it('calls forceUpdate', function () {
+        wrapper.simulate('click');
+        expect(forceUpdate).toHaveBeenCalled();
+      });
+      it('changes points', function () {
+        element.registerMovement(400, 400);
+        expect(element.points).toEqual([200, 200, 300, 300, 400, 400]);
+      });
+      it('changes session when needed', function () {
+        var spy = jest.spyOn(element, 'handleDragEnd');
+        var event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(event.target.getX).toHaveBeenCalled();
+        expect(event.target.getY).toHaveBeenCalled();
+        expect(handleSessionChange).toHaveBeenCalled();
+      });
+      it('changes posX and posY', function () {
+        var event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(element.posX).toEqual(300);
+        expect(element.posY).toEqual(300);
+      });
+    });
+  });
+  describe('LineDrawable', function () {
+    var handleSessionChange = jest.fn();
+    var forceUpdate = jest.fn();
+    var props;
+    beforeEach(function () {
+      props = {
+        handleSessionChange: handleSessionChange,
+        forceUpdate: forceUpdate,
+        paint: true,
+        paintColor: 'green',
+        startx: 200,
+        starty: 200,
+        posX: 200,
+        posY: 200,
+        x: 300,
+        y: 200,
+        createdAt: new Date()
+      };
+      wrapper = mkWrapper('LineDrawable', props);
+    });
+    describe('snapshot', function () {
+      it('renders', function () {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', function () {
+      it('calls forceUpdate', function () {
+        wrapper.simulate('click');
+        expect(forceUpdate).toHaveBeenCalled();
+      });
+      it('changes x and y', function () {
+        element.registerMovement(400, 400);
+        expect(element.x).toEqual(400);
+        expect(element.y).toEqual(400);
+      });
+      it('changes session when needed', function () {
+        var event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(event.target.getX).toHaveBeenCalled();
+        expect(event.target.getY).toHaveBeenCalled();
+        expect(handleSessionChange).toHaveBeenCalled();
+      });
+      it('changes posX and posY', function () {
+        var event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(element.posX).toEqual(300);
+        expect(element.posY).toEqual(300);
+      });
+    });
+  });
+  describe('RectangleDrawable', function () {
+    var handleSessionChange = jest.fn();
+    var forceUpdate = jest.fn();
+    var props;
+    beforeEach(function () {
+      props = {
+        handleSessionChange: handleSessionChange,
+        forceUpdate: forceUpdate,
+        paint: true,
+        paintColor: 'green',
+        startx: 200,
+        starty: 200,
+        x: 300,
+        y: 300,
+        createdAt: new Date()
+      };
+      wrapper = mkWrapper('RectangleDrawable', props);
+    });
+    describe('snapshot', function () {
+      it('renders', function () {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', function () {
+      it('calls forceUpdate', function () {
+        wrapper.simulate('click');
+        expect(forceUpdate).toHaveBeenCalled();
+      });
+      it('changes x and y', function () {
+        element.registerMovement(400, 400);
+        expect(element.x).toEqual(400);
+        expect(element.y).toEqual(400);
+      });
+      it('changes session when needed', function () {
+        var event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(event.target.getX).toHaveBeenCalled();
+        expect(event.target.getY).toHaveBeenCalled();
+        expect(handleSessionChange).toHaveBeenCalled();
+      });
+      it('changes posX and posY', function () {
+        var event = {
+          target: {
+            getX: jest.fn().mockReturnValue(300),
+            getY: jest.fn().mockReturnValue(300)
+          }
+        };
+        element.handleDragEnd(props, event);
+        expect(element.startx).toEqual(300);
+        expect(element.starty).toEqual(300);
+        expect(element.x).toEqual(400);
+        expect(element.y).toEqual(400);
+      });
+    });
+  });
+  describe('DrawableText', function () {
+    var all = [{
+      id: 'gcifqhhimf8k2d6g8hs',
+      isDefault: true,
+      label: 'Double click to edit this text. Press Enter to submit.',
+      value: 'This is what the user entered',
+      width: 200,
+      x: 2 * 5 + 50,
+      y: 2 * 5 + 50,
+      textVisible: true,
+      transformerVisible: true,
+      textareaVisible: false,
+      createdAt: new Date(),
+      type: 'text-entry'
+    }];
+    var handleSessionChange = jest.fn();
+    var forceUpdate = jest.fn();
+    var toggleTextSelected = jest.fn();
+    var props;
+    var stage;
+    beforeEach(function () {
+      stage = {
+        on: jest.fn(),
+        off: jest.fn()
+      };
+      props = {
+        all: all,
+        handleSessionChange: handleSessionChange,
+        forceUpdate: forceUpdate,
+        stage: stage,
+        toggleTextSelected: toggleTextSelected,
+        paint: true,
+        paintColor: 'green',
+        startx: 200,
+        starty: 200,
+        x: 300,
+        y: 300,
+        scale: 1
+      };
+      wrapper = mkWrapper('DrawableText', props, 'div');
+    });
+    describe('snapshot', function () {
+      it('renders', function () {
+        expect(wrapper).toMatchSnapshot();
+      });
+      it('renders textAreas', function () {
+        element = new drawableClasses['DrawableText'](props);
+        wrapper = (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement("div", null, element.renderTextareas()));
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('snapshot when there is no value', function () {
+      beforeEach(function () {
+        props.all.forEach(function (a) {
+          delete a.value;
+        });
+        wrapper = mkWrapper('DrawableText', props, 'div');
+      });
+      it('renders', function () {
+        expect(wrapper).toMatchSnapshot();
+      });
+    });
+    describe('logic', function () {
+      it('shoud change the all property and call forceUpdate', function () {
+        element.setAll([]);
+        expect(element.all).toEqual([]);
+        expect(forceUpdate).toHaveBeenCalled();
+      });
+      describe('addNewTextEntry', function () {
+        it('shoud add a new element and call the appropriate functions', function () {
+          element.addNewTextEntry();
+          expect(element.all.length).toEqual(2);
+          expect(element.all).toEqual(expect.arrayContaining([expect.objectContaining({
+            isDefault: true,
+            label: 'Double click to edit this text. Press Enter to submit.',
+            width: 200,
+            textVisible: true,
+            transformerVisible: true,
+            textareaVisible: false,
+            type: 'text-entry'
+          })]));
+          expect(stage.on).toHaveBeenCalled();
+          expect(handleSessionChange).toHaveBeenCalled();
+        });
+      });
+      describe('showOnlyTextNodes', function () {
+        it('should change properties for the "all" array', function () {
+          element.showOnlyTextNodes();
+          expect(element.all).toEqual(expect.arrayContaining([expect.objectContaining({
+            textVisible: true,
+            transformerVisible: false,
+            textareaVisible: false
+          })]));
+        });
+      });
+      describe('showOnltoggleTextareayTextNodes', function () {
+        it('should change the item with the right id in the "all" array and call forceUpdate', function () {
+          element.toggleTextarea('gcifqhhimf8k2d6g8hs', true);
+          expect(element.all[0]).toEqual(expect.objectContaining({
+            textVisible: false,
+            transformerVisible: false,
+            textareaVisible: true
+          }));
+          expect(forceUpdate).toHaveBeenCalled();
+          element.toggleTextarea('gcifqhhimf8k2d6g8hs', false);
+          expect(element.all[0]).toEqual(expect.objectContaining({
+            textVisible: true,
+            transformerVisible: true,
+            textareaVisible: false
+          }));
+          expect(forceUpdate).toHaveBeenCalled();
+        });
+      });
+      describe('initializeDefault', function () {
+        it('should make the item with the right id default', function () {
+          element.initializeDefault('gcifqhhimf8k2d6g8hs', true);
+          expect(element.all[0]).toEqual(expect.objectContaining({
+            isDefault: false
+          }));
+        });
+      });
+      describe('saveValue', function () {
+        it('should make the item with the right id default and call handleSessionChange', function () {
+          var textNode = {
+            text: jest.fn()
+          };
+          var textareaNode = {
+            value: 'Foo bar'
+          };
+          element.saveValue('gcifqhhimf8k2d6g8hs', textNode, textareaNode);
+          expect(textNode.text).toHaveBeenCalledWith('Foo bar');
+          expect(handleSessionChange).toHaveBeenCalled();
+          textareaNode.value = '';
+          element.saveValue('gcifqhhimf8k2d6g8hs', textNode, textareaNode);
+          expect(element.all).toEqual(expect.not.arrayContaining([expect.objectContaining({
+            id: 'gcifqhhimf8k2d6g8hs'
+          })]));
+          expect(forceUpdate).toHaveBeenCalled();
+          expect(handleSessionChange).toHaveBeenCalled();
+        });
+      });
+      describe('handleMouseEvents', function () {
+        it('should call the right functions on mouse down and up', function () {
+          element.handleMouseDown();
+          expect(toggleTextSelected).toHaveBeenCalledWith(true);
+          element.handleMouseUp();
+          expect(toggleTextSelected).toHaveBeenCalledWith(false);
+        });
+        it('should call the right functions onClick', function () {
+          element.handleClick(null, 'gcifqhhimf8k2d6g8hs');
+          expect(element.all).toEqual(expect.arrayContaining([expect.objectContaining({
+            transformerVisible: true
+          })]));
+          expect(forceUpdate).toHaveBeenCalled();
+        });
+        it('should call the right functions onDblClick', function () {
+          var text = {
+            id: 'gcifqhhimf8k2d6g8hs',
+            isDefault: false
+          };
+          var textNode = element["text_".concat(text.id)] = {
+            _lastPos: {
+              x: 200,
+              y: 200
+            },
+            align: jest.fn().mockReturnValue('center'),
+            fill: jest.fn().mockReturnValue('green'),
+            fontFamily: jest.fn().mockReturnValue('FooBarFamily'),
+            fontSize: jest.fn().mockReturnValue('16'),
+            height: jest.fn().mockReturnValue(40),
+            lineHeight: jest.fn().mockReturnValue('40px'),
+            padding: jest.fn().mockReturnValue(0),
+            rotation: jest.fn().mockReturnValue(0),
+            text: jest.fn().mockReturnValue('foo bar'),
+            width: jest.fn().mockReturnValue(200)
+          };
+          var textareaNode = element["textarea_".concat(text.id)] = {
+            focus: jest.fn(),
+            addEventListener: jest.fn(),
+            style: {},
+            scrollHeight: 205
+          };
+          var initSpy = jest.spyOn(element, 'initializeDefault');
+          var saveValueSpy = jest.spyOn(element, 'saveValue');
+          var toggleSpy = jest.spyOn(element, 'toggleTextarea');
+          element.handleDblClick(null, text);
+          expect(toggleSpy).toHaveBeenCalledWith(text.id, true);
+          expect(textareaNode.value).toEqual('foo bar');
+          expect(textareaNode.style).toEqual({
+            background: 'none',
+            border: 'none',
+            color: 'green',
+            fontFamily: 'FooBarFamily',
+            fontSize: '16px',
+            height: '208px',
+            left: '200px',
+            lineHeight: '40px',
+            margin: '0px',
+            outline: 'none',
+            overflow: 'hidden',
+            padding: '0px',
+            position: 'absolute',
+            resize: 'none',
+            top: '200px',
+            transformOrigin: 'left top',
+            textAlign: 'center',
+            transform: 'translateY(-0px)',
+            width: '200px'
+          });
+          expect(textareaNode.focus).toHaveBeenCalled();
+          expect(stage.on).toHaveBeenCalled();
+          expect(initSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);
+          expect(forceUpdate).toHaveBeenCalled();
+          expect(textareaNode.addEventListener.mock.calls[0][0]).toEqual('keydown');
+          expect(textareaNode.addEventListener.mock.calls[1][0]).toEqual('blur');
+          var event = {
+            keyCode: 13,
+            shiftKey: true
+          };
+          textareaNode.addEventListener.mock.calls[0][1](event); // Make sure it's not called the second time
+
+          expect(toggleSpy).toHaveBeenCalledTimes(1);
+          expect(saveValueSpy).not.toHaveBeenCalled();
+          event.shiftKey = false;
+          textareaNode.addEventListener.mock.calls[0][1](event);
+          expect(toggleSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);
+          expect(saveValueSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', textNode, textareaNode);
+          event.keyCode = 27;
+          textareaNode.addEventListener.mock.calls[0][1](event);
+          expect(toggleSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);
+          var showTextSpy = jest.spyOn(element, 'showOnlyTextNodes');
+          event.target = stage;
+          stage.on.mock.calls[0][1](event);
+          expect(showTextSpy).toHaveBeenCalled();
+          expect(saveValueSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', textNode, textareaNode);
+        });
+      });
+      describe('handleTransform', function () {
+        it('should change attrs when called', function () {
+          var textNode = element["text_gcifqhhimf8k2d6g8hs"] = {
+            setAttrs: jest.fn(),
+            width: jest.fn().mockReturnValue(100),
+            scaleX: jest.fn().mockReturnValue(1)
+          };
+          element.handleTransform(null, 'text_gcifqhhimf8k2d6g8hs');
+          expect(textNode.setAttrs).toHaveBeenCalledWith({
+            width: 100,
+            scaleX: 1
+          });
+        });
+      });
+      describe('setInitialProps', function () {
+        it('should set the props if not set already', function () {
+          element.props = undefined;
+          element.setInitialProps(props);
+          expect(element.props).toEqual(props);
+        });
+      });
+      describe('render', function () {
+        it('should set the stage listener only once', function () {
+          var separateStage = {
+            on: jest.fn(),
+            off: jest.fn()
+          };
+
+          var newProps = _objectSpread(_objectSpread({}, (0, _cloneDeep["default"])(props)), {}, {
+            stage: separateStage
+          });
+
+          var newElement = new drawableClasses['DrawableText'](newProps);
+          expect(newElement.stage).toEqual(undefined);
+          newElement.render(newProps);
+          expect(newElement.stage).toEqual(separateStage);
+          newElement.render(newProps);
+          expect(separateStage.on.mock.calls.length).toEqual(1);
+        });
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/drawing-response/__tests__/drawing-main.test.jsx"],"names":["drawableClasses","FreePathDrawable","LineDrawable","RectangleDrawable","CircleDrawable","EraserDrawable","DrawableText","describe","element","wrapper","mkWrapper","type","props","WrapperEl","content","render","onSessionChange","jest","fn","TextEntry","wrapperMain","extras","renderOpts","defaults","classes","disabled","className","imageDimensions","imageUrl","drawableDimensions","height","width","fillColor","outlineColor","paintColor","session","toolActive","label","icon","it","w","expect","toMatchSnapshot","handleSessionChange","forceUpdate","paint","startx","starty","x","y","createdAt","Date","setState","drawables","instance","handleUndo","state","length","toEqual","handleClearAll","beforeEach","simulate","toHaveBeenCalled","registerMovement","event","target","getX","mockReturnValue","getY","handleDragEnd","points","posX","posY","spy","spyOn","all","id","isDefault","value","textVisible","transformerVisible","textareaVisible","toggleTextSelected","stage","on","off","scale","renderTextareas","forEach","a","setAll","addNewTextEntry","arrayContaining","objectContaining","showOnlyTextNodes","toggleTextarea","initializeDefault","textNode","text","textareaNode","saveValue","toHaveBeenCalledWith","not","handleMouseDown","handleMouseUp","handleClick","_lastPos","align","fill","fontFamily","fontSize","lineHeight","padding","rotation","focus","addEventListener","style","scrollHeight","initSpy","saveValueSpy","toggleSpy","handleDblClick","background","border","color","left","margin","outline","overflow","position","resize","top","transformOrigin","textAlign","transform","mock","calls","keyCode","shiftKey","toHaveBeenCalledTimes","showTextSpy","setAttrs","scaleX","handleTransform","undefined","setInitialProps","separateStage","newProps","newElement"],"mappings":";;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;AAEA,IAAMA,eAAe,GAAG;AACtBC,EAAAA,gBAAgB,EAAhBA,4BADsB;AAEtBC,EAAAA,YAAY,EAAZA,wBAFsB;AAGtBC,EAAAA,iBAAiB,EAAjBA,6BAHsB;AAItBC,EAAAA,cAAc,EAAdA,0BAJsB;AAKtBC,EAAAA,cAAc,EAAdA,0BALsB;AAMtBC,EAAAA,YAAY,EAAZA;AANsB,CAAxB;AASAC,QAAQ,CAAC,iBAAD,EAAoB,YAAM;AAChC,MAAIC,OAAJ;AACA,MAAIC,OAAJ;;AAEA,MAAMC,SAAS,GAAG,SAAZA,SAAY,CAACC,IAAD,EAAOC,KAAP,EAAcC,SAAd,EAA4B;AAC5CL,IAAAA,OAAO,GAAG,IAAIR,eAAe,CAACW,IAAD,CAAnB,CAA0BC,KAA1B,CAAV;AAEA,QAAIE,OAAO,GAAGN,OAAO,CAACO,MAAR,CAAeH,KAAf,CAAd;;AAEA,QAAIC,SAAJ,EAAe;AACbC,MAAAA,OAAO,gBAAG,gCAAC,SAAD,QAAYA,OAAZ,CAAV;AACD;;AAED,WAAO,qBAAQA,OAAR,CAAP;AACD,GAVD;;AAYAP,EAAAA,QAAQ,CAAC,cAAD,EAAiB,YAAM;AAC7B,QAAIS,eAAe,GAAGC,IAAI,CAACC,EAAL,EAAtB;AACA,QAAMC,SAAS,GAAG,IAAIb,wBAAJ,EAAlB;;AAEA,QAAMc,WAAW,GAAG,SAAdA,WAAc,CAACC,MAAD,EAASC,UAAT,EAAwB;AAC1C,UAAMC,QAAQ,GAAG;AACfC,QAAAA,OAAO,EAAE,EADM;AAEfC,QAAAA,QAAQ,EAAE,KAFK;AAGfC,QAAAA,SAAS,EAAE,WAHI;AAIfV,QAAAA,eAAe,EAAfA,eAJe;AAKfW,QAAAA,eAAe,EAAE,EALF;AAMfC,QAAAA,QAAQ,EAAE,KANK;AAOfC,QAAAA,kBAAkB,EAAE;AAACC,UAAAA,MAAM,EAAE,GAAT;AAAcC,UAAAA,KAAK,EAAE;AAArB,SAPL;AAQfC,QAAAA,SAAS,EAAE,OARI;AASfC,QAAAA,YAAY,EAAE,OATC;AAUfC,QAAAA,UAAU,EAAE,KAVG;AAWfC,QAAAA,OAAO,EAAE,EAXM;AAYfC,QAAAA,UAAU,EAAE;AAACzB,UAAAA,IAAI,EAAE,QAAP;AAAiB0B,UAAAA,KAAK,EAAE,QAAxB;AAAkCC,UAAAA,IAAI,EAAE;AAAxC,SAZG;AAafnB,QAAAA,SAAS,EAATA;AAbe,OAAjB;;AAeA,UAAMP,KAAK,mCAAOW,QAAP,GAAoBF,MAApB,CAAX;;AACA,aAAO,mCAAQ,gCAAC,0BAAD,EAAkBT,KAAlB,CAAR,oBACFU,UADE,EAAP;AAGD,KApBD;;AAsBAf,IAAAA,QAAQ,CAAC,UAAD,EAAa,YAAM;AACzBgC,MAAAA,EAAE,CAAC,SAAD,EAAY,YAAM;AAClB,YAAMC,CAAC,GAAGpB,WAAW,EAArB;AACAqB,QAAAA,MAAM,CAACD,CAAD,CAAN,CAAUE,eAAV;AACD,OAHC,CAAF;AAKAH,MAAAA,EAAE,CAAC,kBAAD,EAAqB,YAAM;AAC3B,YAAMC,CAAC,GAAGpB,WAAW,CAAC;AAACK,UAAAA,QAAQ,EAAE;AAAX,SAAD,CAArB;AACAgB,QAAAA,MAAM,CAACD,CAAD,CAAN,CAAUE,eAAV;AACD,OAHC,CAAF;AAID,KAVO,CAAR;AAYAnC,IAAAA,QAAQ,CAAC,OAAD,EAAU,YAAM;AACtB,UAAMoC,mBAAmB,GAAG1B,IAAI,CAACC,EAAL,EAA5B;AACA,UAAM0B,WAAW,GAAG3B,IAAI,CAACC,EAAL,EAApB;AACA,UAAMN,KAAK,GAAG;AACZ+B,QAAAA,mBAAmB,EAAnBA,mBADY;AAEZC,QAAAA,WAAW,EAAXA,WAFY;AAGZC,QAAAA,KAAK,EAAE,IAHK;AAIZX,QAAAA,UAAU,EAAE,OAJA;AAKZY,QAAAA,MAAM,EAAE,GALI;AAMZC,QAAAA,MAAM,EAAE,GANI;AAOZC,QAAAA,CAAC,EAAE,GAPS;AAQZC,QAAAA,CAAC,EAAE,GARS;AASZC,QAAAA,SAAS,EAAE,IAAIC,IAAJ;AATC,OAAd;AAYAZ,MAAAA,EAAE,CAAC,YAAD,EAAe,YAAM;AACrB,YAAMC,CAAC,GAAGpB,WAAW,EAArB;AAEAoB,QAAAA,CAAC,CAACY,QAAF,CAAW;AAACC,UAAAA,SAAS,EAAE,CAAC,IAAIlD,6BAAJ,CAAsBS,KAAtB,CAAD,EAA+B,IAAIT,6BAAJ,CAAsBS,KAAtB,CAA/B;AAAZ,SAAX;AACA4B,QAAAA,CAAC,CAACc,QAAF,GAAaC,UAAb;AAEAd,QAAAA,MAAM,CAACD,CAAC,CAACgB,KAAF,CAAQ,WAAR,EAAqBC,MAAtB,CAAN,CAAoCC,OAApC,CAA4C,CAA5C;AAEAlB,QAAAA,CAAC,CAACc,QAAF,GAAaC,UAAb;AAEAd,QAAAA,MAAM,CAACD,CAAC,CAACgB,KAAF,CAAQ,WAAR,CAAD,CAAN,CAA6BE,OAA7B,CAAqC,EAArC;AACD,OAXC,CAAF;AAaAnB,MAAAA,EAAE,CAAC,gBAAD,EAAmB,YAAM;AACzB,YAAMC,CAAC,GAAGpB,WAAW,EAArB;AAEAoB,QAAAA,CAAC,CAACY,QAAF,CAAW;AAACC,UAAAA,SAAS,EAAE,CAAC,IAAIlD,6BAAJ,CAAsBS,KAAtB,CAAD,EAA+B,IAAIT,6BAAJ,CAAsBS,KAAtB,CAA/B;AAAZ,SAAX;AACA4B,QAAAA,CAAC,CAACc,QAAF,GAAaK,cAAb;AAEAlB,QAAAA,MAAM,CAACD,CAAC,CAACgB,KAAF,CAAQ,WAAR,CAAD,CAAN,CAA6BE,OAA7B,CAAqC,EAArC;AACD,OAPC,CAAF;AAQD,KApCO,CAAR;AAqCD,GA3EO,CAAR;AA6EAnD,EAAAA,QAAQ,CAAC,gBAAD,EAAmB,YAAM;AAC/B,QAAIoC,mBAAmB,GAAG1B,IAAI,CAACC,EAAL,EAA1B;AACA,QAAI0B,WAAW,GAAG3B,IAAI,CAACC,EAAL,EAAlB;AACA,QAAIN,KAAJ;AAEAgD,IAAAA,UAAU,CAAC,YAAM;AACfhD,MAAAA,KAAK,GAAG;AACN+B,QAAAA,mBAAmB,EAAnBA,mBADM;AAENC,QAAAA,WAAW,EAAXA,WAFM;AAGNC,QAAAA,KAAK,EAAE,IAHD;AAINX,QAAAA,UAAU,EAAE,OAJN;AAKNY,QAAAA,MAAM,EAAE,GALF;AAMNC,QAAAA,MAAM,EAAE,GANF;AAONC,QAAAA,CAAC,EAAE,GAPG;AAQNC,QAAAA,CAAC,EAAE,GARG;AASNC,QAAAA,SAAS,EAAE,IAAIC,IAAJ;AATL,OAAR;AAWA1C,MAAAA,OAAO,GAAGC,SAAS,CAAC,gBAAD,EAAmBE,KAAnB,CAAnB;AACD,KAbS,CAAV;AAeAL,IAAAA,QAAQ,CAAC,UAAD,EAAa,YAAM;AACzBgC,MAAAA,EAAE,CAAC,SAAD,EAAY,YAAM;AAClBE,QAAAA,MAAM,CAAChC,OAAD,CAAN,CAAgBiC,eAAhB;AACD,OAFC,CAAF;AAGD,KAJO,CAAR;AAMAnC,IAAAA,QAAQ,CAAC,OAAD,EAAU,YAAM;AACtBgC,MAAAA,EAAE,CAAC,mBAAD,EAAsB,YAAM;AAC5B9B,QAAAA,OAAO,CAACoD,QAAR,CAAiB,OAAjB;AACApB,QAAAA,MAAM,CAACG,WAAD,CAAN,CAAoBkB,gBAApB;AACD,OAHC,CAAF;AAKAvB,MAAAA,EAAE,CAAC,iBAAD,EAAoB,YAAM;AAC1B/B,QAAAA,OAAO,CAACuD,gBAAR,CAAyB,GAAzB,EAA8B,GAA9B;AAEAtB,QAAAA,MAAM,CAACjC,OAAO,CAACwC,CAAT,CAAN,CAAkBU,OAAlB,CAA0B,GAA1B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACyC,CAAT,CAAN,CAAkBS,OAAlB,CAA0B,GAA1B;AACD,OALC,CAAF;AAOAnB,MAAAA,EAAE,CAAC,6BAAD,EAAgC,YAAM;AACtC,YAAMyB,KAAK,GAAG;AACZC,UAAAA,MAAM,EAAE;AACNC,YAAAA,IAAI,EAAEjD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CADA;AAENC,YAAAA,IAAI,EAAEnD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAFA;AADI,SAAd;AAOA3D,QAAAA,OAAO,CAAC6D,aAAR,CAAsBzD,KAAtB,EAA6BoD,KAA7B;AAEAvB,QAAAA,MAAM,CAACuB,KAAK,CAACC,MAAN,CAAaC,IAAd,CAAN,CAA0BJ,gBAA1B;AACArB,QAAAA,MAAM,CAACuB,KAAK,CAACC,MAAN,CAAaG,IAAd,CAAN,CAA0BN,gBAA1B;AAEArB,QAAAA,MAAM,CAACE,mBAAD,CAAN,CAA4BmB,gBAA5B;AACD,OAdC,CAAF;AAgBAvB,MAAAA,EAAE,CAAC,2BAAD,EAA8B,YAAM;AACpC,YAAMyB,KAAK,GAAG;AACZC,UAAAA,MAAM,EAAE;AACNC,YAAAA,IAAI,EAAEjD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CADA;AAENC,YAAAA,IAAI,EAAEnD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAFA;AADI,SAAd;AAOA3D,QAAAA,OAAO,CAAC6D,aAAR,CAAsBzD,KAAtB,EAA6BoD,KAA7B;AAEAvB,QAAAA,MAAM,CAACjC,OAAO,CAACsC,MAAT,CAAN,CAAuBY,OAAvB,CAA+B,GAA/B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACuC,MAAT,CAAN,CAAuBW,OAAvB,CAA+B,GAA/B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACwC,CAAT,CAAN,CAAkBU,OAAlB,CAA0B,GAA1B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACyC,CAAT,CAAN,CAAkBS,OAAlB,CAA0B,GAA1B;AACD,OAdC,CAAF;AAeD,KA5CO,CAAR;AA6CD,GAvEO,CAAR;AAyEAnD,EAAAA,QAAQ,CAAC,gBAAD,EAAmB,YAAM;AAC/B,QAAIoC,mBAAmB,GAAG1B,IAAI,CAACC,EAAL,EAA1B;AACA,QAAI0B,WAAW,GAAG3B,IAAI,CAACC,EAAL,EAAlB;AACA,QAAIN,KAAJ;AAEAgD,IAAAA,UAAU,CAAC,YAAM;AACfhD,MAAAA,KAAK,GAAG;AACN+B,QAAAA,mBAAmB,EAAnBA,mBADM;AAENC,QAAAA,WAAW,EAAXA,WAFM;AAGN0B,QAAAA,MAAM,EAAE,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,EAAgB,GAAhB,CAHF;AAINC,QAAAA,IAAI,EAAE,GAJA;AAKNC,QAAAA,IAAI,EAAE,GALA;AAMN1B,QAAAA,MAAM,EAAE,GANF;AAONC,QAAAA,MAAM,EAAE,GAPF;AAQNG,QAAAA,SAAS,EAAE,IAAIC,IAAJ;AARL,OAAR;AAUA1C,MAAAA,OAAO,GAAGC,SAAS,CAAC,gBAAD,EAAmBE,KAAnB,CAAnB;AACD,KAZS,CAAV;AAcAL,IAAAA,QAAQ,CAAC,UAAD,EAAa,YAAM;AACzBgC,MAAAA,EAAE,CAAC,SAAD,EAAY,YAAM;AAClBE,QAAAA,MAAM,CAAChC,OAAD,CAAN,CAAgBiC,eAAhB;AACD,OAFC,CAAF;AAGD,KAJO,CAAR;AAMAnC,IAAAA,QAAQ,CAAC,OAAD,EAAU,YAAM;AACtBgC,MAAAA,EAAE,CAAC,gBAAD,EAAmB,YAAM;AACzB/B,QAAAA,OAAO,CAACuD,gBAAR,CAAyB,GAAzB,EAA8B,GAA9B;AAEAtB,QAAAA,MAAM,CAACjC,OAAO,CAAC8D,MAAT,CAAN,CAAuBZ,OAAvB,CAA+B,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,EAAgB,GAAhB,EAAqB,GAArB,EAA0B,GAA1B,CAA/B;AACD,OAJC,CAAF;AAMAnB,MAAAA,EAAE,CAAC,6BAAD,EAAgC,YAAM;AACtC,YAAMyB,KAAK,GAAG;AACZC,UAAAA,MAAM,EAAE;AACNC,YAAAA,IAAI,EAAEjD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CADA;AAENC,YAAAA,IAAI,EAAEnD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAFA;AADI,SAAd;AAOA3D,QAAAA,OAAO,CAAC6D,aAAR,CAAsBzD,KAAtB,EAA6BoD,KAA7B;AAEAvB,QAAAA,MAAM,CAACuB,KAAK,CAACC,MAAN,CAAaC,IAAd,CAAN,CAA0BJ,gBAA1B;AACArB,QAAAA,MAAM,CAACuB,KAAK,CAACC,MAAN,CAAaG,IAAd,CAAN,CAA0BN,gBAA1B;AAEArB,QAAAA,MAAM,CAACE,mBAAD,CAAN,CAA4BmB,gBAA5B;AACD,OAdC,CAAF;AAgBAvB,MAAAA,EAAE,CAAC,uBAAD,EAA0B,YAAM;AAChC,YAAMyB,KAAK,GAAG;AACZC,UAAAA,MAAM,EAAE;AACNC,YAAAA,IAAI,EAAEjD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CADA;AAENC,YAAAA,IAAI,EAAEnD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAFA;AADI,SAAd;AAOA3D,QAAAA,OAAO,CAAC6D,aAAR,CAAsBzD,KAAtB,EAA6BoD,KAA7B;AAEAvB,QAAAA,MAAM,CAACjC,OAAO,CAAC+D,IAAT,CAAN,CAAqBb,OAArB,CAA6B,GAA7B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACgE,IAAT,CAAN,CAAqBd,OAArB,CAA6B,GAA7B;AACD,OAZC,CAAF;AAaD,KApCO,CAAR;AAqCD,GA9DO,CAAR;AAgEAnD,EAAAA,QAAQ,CAAC,kBAAD,EAAqB,YAAM;AACjC,QAAIoC,mBAAmB,GAAG1B,IAAI,CAACC,EAAL,EAA1B;AACA,QAAI0B,WAAW,GAAG3B,IAAI,CAACC,EAAL,EAAlB;AACA,QAAIN,KAAJ;AAEAgD,IAAAA,UAAU,CAAC,YAAM;AACfhD,MAAAA,KAAK,GAAG;AACN+B,QAAAA,mBAAmB,EAAnBA,mBADM;AAENC,QAAAA,WAAW,EAAXA,WAFM;AAGNC,QAAAA,KAAK,EAAE,IAHD;AAINX,QAAAA,UAAU,EAAE,OAJN;AAKNoC,QAAAA,MAAM,EAAE,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,EAAgB,GAAhB,CALF;AAMNC,QAAAA,IAAI,EAAE,GANA;AAONC,QAAAA,IAAI,EAAE,GAPA;AAQN1B,QAAAA,MAAM,EAAE,GARF;AASNC,QAAAA,MAAM,EAAE,GATF;AAUNG,QAAAA,SAAS,EAAE,IAAIC,IAAJ;AAVL,OAAR;AAYA1C,MAAAA,OAAO,GAAGC,SAAS,CAAC,kBAAD,EAAqBE,KAArB,CAAnB;AACD,KAdS,CAAV;AAgBAL,IAAAA,QAAQ,CAAC,UAAD,EAAa,YAAM;AACzBgC,MAAAA,EAAE,CAAC,SAAD,EAAY,YAAM;AAClBE,QAAAA,MAAM,CAAChC,OAAD,CAAN,CAAgBiC,eAAhB;AACD,OAFC,CAAF;AAGD,KAJO,CAAR;AAMAnC,IAAAA,QAAQ,CAAC,OAAD,EAAU,YAAM;AACtBgC,MAAAA,EAAE,CAAC,mBAAD,EAAsB,YAAM;AAC5B9B,QAAAA,OAAO,CAACoD,QAAR,CAAiB,OAAjB;AACApB,QAAAA,MAAM,CAACG,WAAD,CAAN,CAAoBkB,gBAApB;AACD,OAHC,CAAF;AAKAvB,MAAAA,EAAE,CAAC,gBAAD,EAAmB,YAAM;AACzB/B,QAAAA,OAAO,CAACuD,gBAAR,CAAyB,GAAzB,EAA8B,GAA9B;AAEAtB,QAAAA,MAAM,CAACjC,OAAO,CAAC8D,MAAT,CAAN,CAAuBZ,OAAvB,CAA+B,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,EAAgB,GAAhB,EAAqB,GAArB,EAA0B,GAA1B,CAA/B;AACD,OAJC,CAAF;AAMAnB,MAAAA,EAAE,CAAC,6BAAD,EAAgC,YAAM;AACtC,YAAMkC,GAAG,GAAGxD,IAAI,CAACyD,KAAL,CAAWlE,OAAX,EAAoB,eAApB,CAAZ;AAEA,YAAMwD,KAAK,GAAG;AACZC,UAAAA,MAAM,EAAE;AACNC,YAAAA,IAAI,EAAEjD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CADA;AAENC,YAAAA,IAAI,EAAEnD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAFA;AADI,SAAd;AAOA3D,QAAAA,OAAO,CAAC6D,aAAR,CAAsBzD,KAAtB,EAA6BoD,KAA7B;AAEAvB,QAAAA,MAAM,CAACuB,KAAK,CAACC,MAAN,CAAaC,IAAd,CAAN,CAA0BJ,gBAA1B;AACArB,QAAAA,MAAM,CAACuB,KAAK,CAACC,MAAN,CAAaG,IAAd,CAAN,CAA0BN,gBAA1B;AAEArB,QAAAA,MAAM,CAACE,mBAAD,CAAN,CAA4BmB,gBAA5B;AACD,OAhBC,CAAF;AAkBAvB,MAAAA,EAAE,CAAC,uBAAD,EAA0B,YAAM;AAChC,YAAMyB,KAAK,GAAG;AACZC,UAAAA,MAAM,EAAE;AACNC,YAAAA,IAAI,EAAEjD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CADA;AAENC,YAAAA,IAAI,EAAEnD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAFA;AADI,SAAd;AAOA3D,QAAAA,OAAO,CAAC6D,aAAR,CAAsBzD,KAAtB,EAA6BoD,KAA7B;AAEAvB,QAAAA,MAAM,CAACjC,OAAO,CAAC+D,IAAT,CAAN,CAAqBb,OAArB,CAA6B,GAA7B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACgE,IAAT,CAAN,CAAqBd,OAArB,CAA6B,GAA7B;AACD,OAZC,CAAF;AAaD,KA3CO,CAAR;AA4CD,GAvEO,CAAR;AAyEAnD,EAAAA,QAAQ,CAAC,cAAD,EAAiB,YAAM;AAC7B,QAAIoC,mBAAmB,GAAG1B,IAAI,CAACC,EAAL,EAA1B;AACA,QAAI0B,WAAW,GAAG3B,IAAI,CAACC,EAAL,EAAlB;AACA,QAAIN,KAAJ;AAEAgD,IAAAA,UAAU,CAAC,YAAM;AACfhD,MAAAA,KAAK,GAAG;AACN+B,QAAAA,mBAAmB,EAAnBA,mBADM;AAENC,QAAAA,WAAW,EAAXA,WAFM;AAGNC,QAAAA,KAAK,EAAE,IAHD;AAINX,QAAAA,UAAU,EAAE,OAJN;AAKNY,QAAAA,MAAM,EAAE,GALF;AAMNC,QAAAA,MAAM,EAAE,GANF;AAONwB,QAAAA,IAAI,EAAE,GAPA;AAQNC,QAAAA,IAAI,EAAE,GARA;AASNxB,QAAAA,CAAC,EAAE,GATG;AAUNC,QAAAA,CAAC,EAAE,GAVG;AAWNC,QAAAA,SAAS,EAAE,IAAIC,IAAJ;AAXL,OAAR;AAaA1C,MAAAA,OAAO,GAAGC,SAAS,CAAC,cAAD,EAAiBE,KAAjB,CAAnB;AACD,KAfS,CAAV;AAiBAL,IAAAA,QAAQ,CAAC,UAAD,EAAa,YAAM;AACzBgC,MAAAA,EAAE,CAAC,SAAD,EAAY,YAAM;AAClBE,QAAAA,MAAM,CAAChC,OAAD,CAAN,CAAgBiC,eAAhB;AACD,OAFC,CAAF;AAGD,KAJO,CAAR;AAMAnC,IAAAA,QAAQ,CAAC,OAAD,EAAU,YAAM;AACtBgC,MAAAA,EAAE,CAAC,mBAAD,EAAsB,YAAM;AAC5B9B,QAAAA,OAAO,CAACoD,QAAR,CAAiB,OAAjB;AACApB,QAAAA,MAAM,CAACG,WAAD,CAAN,CAAoBkB,gBAApB;AACD,OAHC,CAAF;AAKAvB,MAAAA,EAAE,CAAC,iBAAD,EAAoB,YAAM;AAC1B/B,QAAAA,OAAO,CAACuD,gBAAR,CAAyB,GAAzB,EAA8B,GAA9B;AAEAtB,QAAAA,MAAM,CAACjC,OAAO,CAACwC,CAAT,CAAN,CAAkBU,OAAlB,CAA0B,GAA1B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACyC,CAAT,CAAN,CAAkBS,OAAlB,CAA0B,GAA1B;AACD,OALC,CAAF;AAOAnB,MAAAA,EAAE,CAAC,6BAAD,EAAgC,YAAM;AACtC,YAAMyB,KAAK,GAAG;AACZC,UAAAA,MAAM,EAAE;AACNC,YAAAA,IAAI,EAAEjD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CADA;AAENC,YAAAA,IAAI,EAAEnD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAFA;AADI,SAAd;AAOA3D,QAAAA,OAAO,CAAC6D,aAAR,CAAsBzD,KAAtB,EAA6BoD,KAA7B;AAEAvB,QAAAA,MAAM,CAACuB,KAAK,CAACC,MAAN,CAAaC,IAAd,CAAN,CAA0BJ,gBAA1B;AACArB,QAAAA,MAAM,CAACuB,KAAK,CAACC,MAAN,CAAaG,IAAd,CAAN,CAA0BN,gBAA1B;AAEArB,QAAAA,MAAM,CAACE,mBAAD,CAAN,CAA4BmB,gBAA5B;AACD,OAdC,CAAF;AAgBAvB,MAAAA,EAAE,CAAC,uBAAD,EAA0B,YAAM;AAChC,YAAMyB,KAAK,GAAG;AACZC,UAAAA,MAAM,EAAE;AACNC,YAAAA,IAAI,EAAEjD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CADA;AAENC,YAAAA,IAAI,EAAEnD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAFA;AADI,SAAd;AAOA3D,QAAAA,OAAO,CAAC6D,aAAR,CAAsBzD,KAAtB,EAA6BoD,KAA7B;AAEAvB,QAAAA,MAAM,CAACjC,OAAO,CAAC+D,IAAT,CAAN,CAAqBb,OAArB,CAA6B,GAA7B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACgE,IAAT,CAAN,CAAqBd,OAArB,CAA6B,GAA7B;AACD,OAZC,CAAF;AAaD,KA1CO,CAAR;AA2CD,GAvEO,CAAR;AAyEAnD,EAAAA,QAAQ,CAAC,mBAAD,EAAsB,YAAM;AAClC,QAAIoC,mBAAmB,GAAG1B,IAAI,CAACC,EAAL,EAA1B;AACA,QAAI0B,WAAW,GAAG3B,IAAI,CAACC,EAAL,EAAlB;AACA,QAAIN,KAAJ;AAEAgD,IAAAA,UAAU,CAAC,YAAM;AACfhD,MAAAA,KAAK,GAAG;AACN+B,QAAAA,mBAAmB,EAAnBA,mBADM;AAENC,QAAAA,WAAW,EAAXA,WAFM;AAGNC,QAAAA,KAAK,EAAE,IAHD;AAINX,QAAAA,UAAU,EAAE,OAJN;AAKNY,QAAAA,MAAM,EAAE,GALF;AAMNC,QAAAA,MAAM,EAAE,GANF;AAONC,QAAAA,CAAC,EAAE,GAPG;AAQNC,QAAAA,CAAC,EAAE,GARG;AASNC,QAAAA,SAAS,EAAE,IAAIC,IAAJ;AATL,OAAR;AAWA1C,MAAAA,OAAO,GAAGC,SAAS,CAAC,mBAAD,EAAsBE,KAAtB,CAAnB;AACD,KAbS,CAAV;AAeAL,IAAAA,QAAQ,CAAC,UAAD,EAAa,YAAM;AACzBgC,MAAAA,EAAE,CAAC,SAAD,EAAY,YAAM;AAClBE,QAAAA,MAAM,CAAChC,OAAD,CAAN,CAAgBiC,eAAhB;AACD,OAFC,CAAF;AAGD,KAJO,CAAR;AAMAnC,IAAAA,QAAQ,CAAC,OAAD,EAAU,YAAM;AACtBgC,MAAAA,EAAE,CAAC,mBAAD,EAAsB,YAAM;AAC5B9B,QAAAA,OAAO,CAACoD,QAAR,CAAiB,OAAjB;AACApB,QAAAA,MAAM,CAACG,WAAD,CAAN,CAAoBkB,gBAApB;AACD,OAHC,CAAF;AAKAvB,MAAAA,EAAE,CAAC,iBAAD,EAAoB,YAAM;AAC1B/B,QAAAA,OAAO,CAACuD,gBAAR,CAAyB,GAAzB,EAA8B,GAA9B;AAEAtB,QAAAA,MAAM,CAACjC,OAAO,CAACwC,CAAT,CAAN,CAAkBU,OAAlB,CAA0B,GAA1B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACyC,CAAT,CAAN,CAAkBS,OAAlB,CAA0B,GAA1B;AACD,OALC,CAAF;AAOAnB,MAAAA,EAAE,CAAC,6BAAD,EAAgC,YAAM;AACtC,YAAMyB,KAAK,GAAG;AACZC,UAAAA,MAAM,EAAE;AACNC,YAAAA,IAAI,EAAEjD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CADA;AAENC,YAAAA,IAAI,EAAEnD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAFA;AADI,SAAd;AAOA3D,QAAAA,OAAO,CAAC6D,aAAR,CAAsBzD,KAAtB,EAA6BoD,KAA7B;AAEAvB,QAAAA,MAAM,CAACuB,KAAK,CAACC,MAAN,CAAaC,IAAd,CAAN,CAA0BJ,gBAA1B;AACArB,QAAAA,MAAM,CAACuB,KAAK,CAACC,MAAN,CAAaG,IAAd,CAAN,CAA0BN,gBAA1B;AAEArB,QAAAA,MAAM,CAACE,mBAAD,CAAN,CAA4BmB,gBAA5B;AACD,OAdC,CAAF;AAgBAvB,MAAAA,EAAE,CAAC,uBAAD,EAA0B,YAAM;AAChC,YAAMyB,KAAK,GAAG;AACZC,UAAAA,MAAM,EAAE;AACNC,YAAAA,IAAI,EAAEjD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CADA;AAENC,YAAAA,IAAI,EAAEnD,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAFA;AADI,SAAd;AAOA3D,QAAAA,OAAO,CAAC6D,aAAR,CAAsBzD,KAAtB,EAA6BoD,KAA7B;AAEAvB,QAAAA,MAAM,CAACjC,OAAO,CAACsC,MAAT,CAAN,CAAuBY,OAAvB,CAA+B,GAA/B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACuC,MAAT,CAAN,CAAuBW,OAAvB,CAA+B,GAA/B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACwC,CAAT,CAAN,CAAkBU,OAAlB,CAA0B,GAA1B;AACAjB,QAAAA,MAAM,CAACjC,OAAO,CAACyC,CAAT,CAAN,CAAkBS,OAAlB,CAA0B,GAA1B;AACD,OAdC,CAAF;AAeD,KA5CO,CAAR;AA6CD,GAvEO,CAAR;AAyEAnD,EAAAA,QAAQ,CAAC,cAAD,EAAiB,YAAM;AAC7B,QAAMoE,GAAG,GAAG,CACV;AACEC,MAAAA,EAAE,EAAE,qBADN;AAEEC,MAAAA,SAAS,EAAE,IAFb;AAGExC,MAAAA,KAAK,EAAE,wDAHT;AAIEyC,MAAAA,KAAK,EAAE,+BAJT;AAKE/C,MAAAA,KAAK,EAAE,GALT;AAMEiB,MAAAA,CAAC,EAAE,IAAI,CAAJ,GAAQ,EANb;AAOEC,MAAAA,CAAC,EAAE,IAAI,CAAJ,GAAQ,EAPb;AAQE8B,MAAAA,WAAW,EAAE,IARf;AASEC,MAAAA,kBAAkB,EAAE,IATtB;AAUEC,MAAAA,eAAe,EAAE,KAVnB;AAWE/B,MAAAA,SAAS,EAAE,IAAIC,IAAJ,EAXb;AAYExC,MAAAA,IAAI,EAAE;AAZR,KADU,CAAZ;AAgBA,QAAIgC,mBAAmB,GAAG1B,IAAI,CAACC,EAAL,EAA1B;AACA,QAAI0B,WAAW,GAAG3B,IAAI,CAACC,EAAL,EAAlB;AACA,QAAIgE,kBAAkB,GAAGjE,IAAI,CAACC,EAAL,EAAzB;AACA,QAAIN,KAAJ;AACA,QAAIuE,KAAJ;AAEAvB,IAAAA,UAAU,CAAC,YAAM;AACfuB,MAAAA,KAAK,GAAG;AACNC,QAAAA,EAAE,EAAEnE,IAAI,CAACC,EAAL,EADE;AAENmE,QAAAA,GAAG,EAAEpE,IAAI,CAACC,EAAL;AAFC,OAAR;AAKAN,MAAAA,KAAK,GAAG;AACN+D,QAAAA,GAAG,EAAHA,GADM;AAENhC,QAAAA,mBAAmB,EAAnBA,mBAFM;AAGNC,QAAAA,WAAW,EAAXA,WAHM;AAINuC,QAAAA,KAAK,EAALA,KAJM;AAKND,QAAAA,kBAAkB,EAAlBA,kBALM;AAMNrC,QAAAA,KAAK,EAAE,IAND;AAONX,QAAAA,UAAU,EAAE,OAPN;AAQNY,QAAAA,MAAM,EAAE,GARF;AASNC,QAAAA,MAAM,EAAE,GATF;AAUNC,QAAAA,CAAC,EAAE,GAVG;AAWNC,QAAAA,CAAC,EAAE,GAXG;AAYNqC,QAAAA,KAAK,EAAE;AAZD,OAAR;AAcA7E,MAAAA,OAAO,GAAGC,SAAS,CAAC,cAAD,EAAiBE,KAAjB,EAAwB,KAAxB,CAAnB;AACD,KArBS,CAAV;AAuBAL,IAAAA,QAAQ,CAAC,UAAD,EAAa,YAAM;AACzBgC,MAAAA,EAAE,CAAC,SAAD,EAAY,YAAM;AAClBE,QAAAA,MAAM,CAAChC,OAAD,CAAN,CAAgBiC,eAAhB;AACD,OAFC,CAAF;AAIAH,MAAAA,EAAE,CAAC,mBAAD,EAAsB,YAAM;AAC5B/B,QAAAA,OAAO,GAAG,IAAIR,eAAe,CAAC,cAAD,CAAnB,CAAoCY,KAApC,CAAV;AAEAH,QAAAA,OAAO,GAAG,mCAAQ,6CAAMD,OAAO,CAAC+E,eAAR,EAAN,CAAR,CAAV;AAEA9C,QAAAA,MAAM,CAAChC,OAAD,CAAN,CAAgBiC,eAAhB;AACD,OANC,CAAF;AAOD,KAZO,CAAR;AAcAnC,IAAAA,QAAQ,CAAC,iCAAD,EAAoC,YAAM;AAChDqD,MAAAA,UAAU,CAAC,YAAM;AACfhD,QAAAA,KAAK,CAAC+D,GAAN,CAAUa,OAAV,CAAkB,UAAAC,CAAC,EAAI;AACrB,iBAAOA,CAAC,CAACX,KAAT;AACD,SAFD;AAGArE,QAAAA,OAAO,GAAGC,SAAS,CAAC,cAAD,EAAiBE,KAAjB,EAAwB,KAAxB,CAAnB;AACD,OALS,CAAV;AAMA2B,MAAAA,EAAE,CAAC,SAAD,EAAY,YAAM;AAClBE,QAAAA,MAAM,CAAChC,OAAD,CAAN,CAAgBiC,eAAhB;AACD,OAFC,CAAF;AAGD,KAVO,CAAR;AAYAnC,IAAAA,QAAQ,CAAC,OAAD,EAAU,YAAM;AACtBgC,MAAAA,EAAE,CAAC,oDAAD,EAAuD,YAAM;AAC7D/B,QAAAA,OAAO,CAACkF,MAAR,CAAe,EAAf;AAEAjD,QAAAA,MAAM,CAACjC,OAAO,CAACmE,GAAT,CAAN,CAAoBjB,OAApB,CAA4B,EAA5B;AACAjB,QAAAA,MAAM,CAACG,WAAD,CAAN,CAAoBkB,gBAApB;AACD,OALC,CAAF;AAOAvD,MAAAA,QAAQ,CAAC,iBAAD,EAAoB,YAAM;AAChCgC,QAAAA,EAAE,CAAC,4DAAD,EAA+D,YAAM;AACrE/B,UAAAA,OAAO,CAACmF,eAAR;AAEAlD,UAAAA,MAAM,CAACjC,OAAO,CAACmE,GAAR,CAAYlB,MAAb,CAAN,CAA2BC,OAA3B,CAAmC,CAAnC;AACAjB,UAAAA,MAAM,CAACjC,OAAO,CAACmE,GAAT,CAAN,CAAoBjB,OAApB,CACEjB,MAAM,CAACmD,eAAP,CAAuB,CACrBnD,MAAM,CAACoD,gBAAP,CAAwB;AACtBhB,YAAAA,SAAS,EAAE,IADW;AAEtBxC,YAAAA,KAAK,EAAE,wDAFe;AAGtBN,YAAAA,KAAK,EAAE,GAHe;AAItBgD,YAAAA,WAAW,EAAE,IAJS;AAKtBC,YAAAA,kBAAkB,EAAE,IALE;AAMtBC,YAAAA,eAAe,EAAE,KANK;AAOtBtE,YAAAA,IAAI,EAAE;AAPgB,WAAxB,CADqB,CAAvB,CADF;AAcA8B,UAAAA,MAAM,CAAC0C,KAAK,CAACC,EAAP,CAAN,CAAiBtB,gBAAjB;AACArB,UAAAA,MAAM,CAACE,mBAAD,CAAN,CAA4BmB,gBAA5B;AACD,SApBC,CAAF;AAqBD,OAtBO,CAAR;AAwBAvD,MAAAA,QAAQ,CAAC,mBAAD,EAAsB,YAAM;AAClCgC,QAAAA,EAAE,CAAC,8CAAD,EAAiD,YAAM;AACvD/B,UAAAA,OAAO,CAACsF,iBAAR;AAEArD,UAAAA,MAAM,CAACjC,OAAO,CAACmE,GAAT,CAAN,CAAoBjB,OAApB,CACEjB,MAAM,CAACmD,eAAP,CAAuB,CACrBnD,MAAM,CAACoD,gBAAP,CAAwB;AACtBd,YAAAA,WAAW,EAAE,IADS;AAEtBC,YAAAA,kBAAkB,EAAE,KAFE;AAGtBC,YAAAA,eAAe,EAAE;AAHK,WAAxB,CADqB,CAAvB,CADF;AASD,SAZC,CAAF;AAaD,OAdO,CAAR;AAgBA1E,MAAAA,QAAQ,CAAC,iCAAD,EAAoC,YAAM;AAChDgC,QAAAA,EAAE,CAAC,kFAAD,EAAqF,YAAM;AAC3F/B,UAAAA,OAAO,CAACuF,cAAR,CAAuB,qBAAvB,EAA8C,IAA9C;AAEAtD,UAAAA,MAAM,CAACjC,OAAO,CAACmE,GAAR,CAAY,CAAZ,CAAD,CAAN,CAAuBjB,OAAvB,CACEjB,MAAM,CAACoD,gBAAP,CAAwB;AACtBd,YAAAA,WAAW,EAAE,KADS;AAEtBC,YAAAA,kBAAkB,EAAE,KAFE;AAGtBC,YAAAA,eAAe,EAAE;AAHK,WAAxB,CADF;AAQAxC,UAAAA,MAAM,CAACG,WAAD,CAAN,CAAoBkB,gBAApB;AAEAtD,UAAAA,OAAO,CAACuF,cAAR,CAAuB,qBAAvB,EAA8C,KAA9C;AAEAtD,UAAAA,MAAM,CAACjC,OAAO,CAACmE,GAAR,CAAY,CAAZ,CAAD,CAAN,CAAuBjB,OAAvB,CACEjB,MAAM,CAACoD,gBAAP,CAAwB;AACtBd,YAAAA,WAAW,EAAE,IADS;AAEtBC,YAAAA,kBAAkB,EAAE,IAFE;AAGtBC,YAAAA,eAAe,EAAE;AAHK,WAAxB,CADF;AAQAxC,UAAAA,MAAM,CAACG,WAAD,CAAN,CAAoBkB,gBAApB;AACD,SAxBC,CAAF;AAyBD,OA1BO,CAAR;AA4BAvD,MAAAA,QAAQ,CAAC,mBAAD,EAAsB,YAAM;AAClCgC,QAAAA,EAAE,CAAC,gDAAD,EAAmD,YAAM;AACzD/B,UAAAA,OAAO,CAACwF,iBAAR,CAA0B,qBAA1B,EAAiD,IAAjD;AAEAvD,UAAAA,MAAM,CAACjC,OAAO,CAACmE,GAAR,CAAY,CAAZ,CAAD,CAAN,CAAuBjB,OAAvB,CACEjB,MAAM,CAACoD,gBAAP,CAAwB;AACtBhB,YAAAA,SAAS,EAAE;AADW,WAAxB,CADF;AAKD,SARC,CAAF;AASD,OAVO,CAAR;AAYAtE,MAAAA,QAAQ,CAAC,WAAD,EAAc,YAAM;AAC1BgC,QAAAA,EAAE,CAAC,6EAAD,EAAgF,YAAM;AACtF,cAAM0D,QAAQ,GAAG;AACfC,YAAAA,IAAI,EAAEjF,IAAI,CAACC,EAAL;AADS,WAAjB;AAGA,cAAMiF,YAAY,GAAG;AACnBrB,YAAAA,KAAK,EAAE;AADY,WAArB;AAIAtE,UAAAA,OAAO,CAAC4F,SAAR,CAAkB,qBAAlB,EAAyCH,QAAzC,EAAmDE,YAAnD;AAEA1D,UAAAA,MAAM,CAACwD,QAAQ,CAACC,IAAV,CAAN,CAAsBG,oBAAtB,CAA2C,SAA3C;AACA5D,UAAAA,MAAM,CAACE,mBAAD,CAAN,CAA4BmB,gBAA5B;AAEAqC,UAAAA,YAAY,CAACrB,KAAb,GAAqB,EAArB;AAEAtE,UAAAA,OAAO,CAAC4F,SAAR,CAAkB,qBAAlB,EAAyCH,QAAzC,EAAmDE,YAAnD;AAEA1D,UAAAA,MAAM,CAACjC,OAAO,CAACmE,GAAT,CAAN,CAAoBjB,OAApB,CACEjB,MAAM,CAAC6D,GAAP,CAAWV,eAAX,CAA2B,CACzBnD,MAAM,CAACoD,gBAAP,CAAwB;AACtBjB,YAAAA,EAAE,EAAE;AADkB,WAAxB,CADyB,CAA3B,CADF;AAOAnC,UAAAA,MAAM,CAACG,WAAD,CAAN,CAAoBkB,gBAApB;AACArB,UAAAA,MAAM,CAACE,mBAAD,CAAN,CAA4BmB,gBAA5B;AACD,SA1BC,CAAF;AA2BD,OA5BO,CAAR;AA8BAvD,MAAAA,QAAQ,CAAC,mBAAD,EAAsB,YAAM;AAClCgC,QAAAA,EAAE,CAAC,sDAAD,EAAyD,YAAM;AAC/D/B,UAAAA,OAAO,CAAC+F,eAAR;AACA9D,UAAAA,MAAM,CAACyC,kBAAD,CAAN,CAA2BmB,oBAA3B,CAAgD,IAAhD;AAEA7F,UAAAA,OAAO,CAACgG,aAAR;AACA/D,UAAAA,MAAM,CAACyC,kBAAD,CAAN,CAA2BmB,oBAA3B,CAAgD,KAAhD;AACD,SANC,CAAF;AAQA9D,QAAAA,EAAE,CAAC,yCAAD,EAA4C,YAAM;AAClD/B,UAAAA,OAAO,CAACiG,WAAR,CAAoB,IAApB,EAA0B,qBAA1B;AAEAhE,UAAAA,MAAM,CAACjC,OAAO,CAACmE,GAAT,CAAN,CAAoBjB,OAApB,CACEjB,MAAM,CAACmD,eAAP,CAAuB,CACrBnD,MAAM,CAACoD,gBAAP,CAAwB;AACtBb,YAAAA,kBAAkB,EAAE;AADE,WAAxB,CADqB,CAAvB,CADF;AAQAvC,UAAAA,MAAM,CAACG,WAAD,CAAN,CAAoBkB,gBAApB;AACD,SAZC,CAAF;AAcAvB,QAAAA,EAAE,CAAC,4CAAD,EAA+C,YAAM;AACrD,cAAM2D,IAAI,GAAG;AACXtB,YAAAA,EAAE,EAAE,qBADO;AAEXC,YAAAA,SAAS,EAAE;AAFA,WAAb;AAKA,cAAMoB,QAAQ,GAAIzF,OAAO,gBAAS0F,IAAI,CAACtB,EAAd,EAAP,GAA6B;AAC7C8B,YAAAA,QAAQ,EAAE;AACR1D,cAAAA,CAAC,EAAE,GADK;AAERC,cAAAA,CAAC,EAAE;AAFK,aADmC;AAK7C0D,YAAAA,KAAK,EAAE1F,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,QAA1B,CALsC;AAM7CyC,YAAAA,IAAI,EAAE3F,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,OAA1B,CANuC;AAO7C0C,YAAAA,UAAU,EAAE5F,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,cAA1B,CAPiC;AAQ7C2C,YAAAA,QAAQ,EAAE7F,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,IAA1B,CARmC;AAS7CrC,YAAAA,MAAM,EAAEb,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,EAA1B,CATqC;AAU7C4C,YAAAA,UAAU,EAAE9F,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,MAA1B,CAViC;AAW7C6C,YAAAA,OAAO,EAAE/F,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,CAA1B,CAXoC;AAY7C8C,YAAAA,QAAQ,EAAEhG,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,CAA1B,CAZmC;AAa7C+B,YAAAA,IAAI,EAAEjF,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,SAA1B,CAbuC;AAc7CpC,YAAAA,KAAK,EAAEd,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B;AAdsC,WAA/C;AAgBA,cAAMgC,YAAY,GAAI3F,OAAO,oBAAa0F,IAAI,CAACtB,EAAlB,EAAP,GAAiC;AACrDsC,YAAAA,KAAK,EAAEjG,IAAI,CAACC,EAAL,EAD8C;AAErDiG,YAAAA,gBAAgB,EAAElG,IAAI,CAACC,EAAL,EAFmC;AAGrDkG,YAAAA,KAAK,EAAE,EAH8C;AAIrDC,YAAAA,YAAY,EAAE;AAJuC,WAAvD;AAOA,cAAMC,OAAO,GAAGrG,IAAI,CAACyD,KAAL,CAAWlE,OAAX,EAAoB,mBAApB,CAAhB;AACA,cAAM+G,YAAY,GAAGtG,IAAI,CAACyD,KAAL,CAAWlE,OAAX,EAAoB,WAApB,CAArB;AACA,cAAMgH,SAAS,GAAGvG,IAAI,CAACyD,KAAL,CAAWlE,OAAX,EAAoB,gBAApB,CAAlB;AAEAA,UAAAA,OAAO,CAACiH,cAAR,CAAuB,IAAvB,EAA6BvB,IAA7B;AAEAzD,UAAAA,MAAM,CAAC+E,SAAD,CAAN,CAAkBnB,oBAAlB,CAAuCH,IAAI,CAACtB,EAA5C,EAAgD,IAAhD;AAEAnC,UAAAA,MAAM,CAAC0D,YAAY,CAACrB,KAAd,CAAN,CAA2BpB,OAA3B,CAAmC,SAAnC;AACAjB,UAAAA,MAAM,CAAC0D,YAAY,CAACiB,KAAd,CAAN,CAA2B1D,OAA3B,CAAmC;AACjCgE,YAAAA,UAAU,EAAE,MADqB;AAEjCC,YAAAA,MAAM,EAAE,MAFyB;AAGjCC,YAAAA,KAAK,EAAE,OAH0B;AAIjCf,YAAAA,UAAU,EAAE,cAJqB;AAKjCC,YAAAA,QAAQ,EAAE,MALuB;AAMjChF,YAAAA,MAAM,EAAE,OANyB;AAOjC+F,YAAAA,IAAI,EAAE,OAP2B;AAQjCd,YAAAA,UAAU,EAAE,MARqB;AASjCe,YAAAA,MAAM,EAAE,KATyB;AAUjCC,YAAAA,OAAO,EAAE,MAVwB;AAWjCC,YAAAA,QAAQ,EAAE,QAXuB;AAYjChB,YAAAA,OAAO,EAAE,KAZwB;AAajCiB,YAAAA,QAAQ,EAAE,UAbuB;AAcjCC,YAAAA,MAAM,EAAE,MAdyB;AAejCC,YAAAA,GAAG,EAAE,OAf4B;AAgBjCC,YAAAA,eAAe,EAAE,UAhBgB;AAiBjCC,YAAAA,SAAS,EAAE,QAjBsB;AAkBjCC,YAAAA,SAAS,EAAE,kBAlBsB;AAmBjCvG,YAAAA,KAAK,EAAE;AAnB0B,WAAnC;AAsBAU,UAAAA,MAAM,CAAC0D,YAAY,CAACe,KAAd,CAAN,CAA2BpD,gBAA3B;AACArB,UAAAA,MAAM,CAAC0C,KAAK,CAACC,EAAP,CAAN,CAAiBtB,gBAAjB;AACArB,UAAAA,MAAM,CAAC6E,OAAD,CAAN,CAAgBjB,oBAAhB,CAAqC,qBAArC,EAA4D,KAA5D;AACA5D,UAAAA,MAAM,CAACG,WAAD,CAAN,CAAoBkB,gBAApB;AACArB,UAAAA,MAAM,CAAC0D,YAAY,CAACgB,gBAAb,CAA8BoB,IAA9B,CAAmCC,KAAnC,CAAyC,CAAzC,EAA4C,CAA5C,CAAD,CAAN,CAAuD9E,OAAvD,CACE,SADF;AAGAjB,UAAAA,MAAM,CAAC0D,YAAY,CAACgB,gBAAb,CAA8BoB,IAA9B,CAAmCC,KAAnC,CAAyC,CAAzC,EAA4C,CAA5C,CAAD,CAAN,CAAuD9E,OAAvD,CACE,MADF;AAIA,cAAMM,KAAK,GAAG;AACZyE,YAAAA,OAAO,EAAE,EADG;AAEZC,YAAAA,QAAQ,EAAE;AAFE,WAAd;AAKAvC,UAAAA,YAAY,CAACgB,gBAAb,CAA8BoB,IAA9B,CAAmCC,KAAnC,CAAyC,CAAzC,EAA4C,CAA5C,EAA+CxE,KAA/C,EA5EqD,CA8ErD;;AACAvB,UAAAA,MAAM,CAAC+E,SAAD,CAAN,CAAkBmB,qBAAlB,CAAwC,CAAxC;AACAlG,UAAAA,MAAM,CAAC8E,YAAD,CAAN,CAAqBjB,GAArB,CAAyBxC,gBAAzB;AAEAE,UAAAA,KAAK,CAAC0E,QAAN,GAAiB,KAAjB;AAEAvC,UAAAA,YAAY,CAACgB,gBAAb,CAA8BoB,IAA9B,CAAmCC,KAAnC,CAAyC,CAAzC,EAA4C,CAA5C,EAA+CxE,KAA/C;AAEAvB,UAAAA,MAAM,CAAC+E,SAAD,CAAN,CAAkBnB,oBAAlB,CAAuC,qBAAvC,EAA8D,KAA9D;AACA5D,UAAAA,MAAM,CAAC8E,YAAD,CAAN,CAAqBlB,oBAArB,CACE,qBADF,EAEEJ,QAFF,EAGEE,YAHF;AAMAnC,UAAAA,KAAK,CAACyE,OAAN,GAAgB,EAAhB;AAEAtC,UAAAA,YAAY,CAACgB,gBAAb,CAA8BoB,IAA9B,CAAmCC,KAAnC,CAAyC,CAAzC,EAA4C,CAA5C,EAA+CxE,KAA/C;AAEAvB,UAAAA,MAAM,CAAC+E,SAAD,CAAN,CAAkBnB,oBAAlB,CAAuC,qBAAvC,EAA8D,KAA9D;AAEA,cAAMuC,WAAW,GAAG3H,IAAI,CAACyD,KAAL,CAAWlE,OAAX,EAAoB,mBAApB,CAApB;AAEAwD,UAAAA,KAAK,CAACC,MAAN,GAAekB,KAAf;AAEAA,UAAAA,KAAK,CAACC,EAAN,CAASmD,IAAT,CAAcC,KAAd,CAAoB,CAApB,EAAuB,CAAvB,EAA0BxE,KAA1B;AAEAvB,UAAAA,MAAM,CAACmG,WAAD,CAAN,CAAoB9E,gBAApB;AACArB,UAAAA,MAAM,CAAC8E,YAAD,CAAN,CAAqBlB,oBAArB,CACE,qBADF,EAEEJ,QAFF,EAGEE,YAHF;AAKD,SA/GC,CAAF;AAgHD,OAvIO,CAAR;AAyIA5F,MAAAA,QAAQ,CAAC,iBAAD,EAAoB,YAAM;AAChCgC,QAAAA,EAAE,CAAC,iCAAD,EAAoC,YAAM;AAC1C,cAAM0D,QAAQ,GAAIzF,OAAO,4BAAP,GAAsC;AACtDqI,YAAAA,QAAQ,EAAE5H,IAAI,CAACC,EAAL,EAD4C;AAEtDa,YAAAA,KAAK,EAAEd,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,GAA1B,CAF+C;AAGtD2E,YAAAA,MAAM,EAAE7H,IAAI,CAACC,EAAL,GAAUiD,eAAV,CAA0B,CAA1B;AAH8C,WAAxD;AAMA3D,UAAAA,OAAO,CAACuI,eAAR,CAAwB,IAAxB,EAA8B,0BAA9B;AAEAtG,UAAAA,MAAM,CAACwD,QAAQ,CAAC4C,QAAV,CAAN,CAA0BxC,oBAA1B,CAA+C;AAC7CtE,YAAAA,KAAK,EAAE,GADsC;AAE7C+G,YAAAA,MAAM,EAAE;AAFqC,WAA/C;AAID,SAbC,CAAF;AAcD,OAfO,CAAR;AAiBAvI,MAAAA,QAAQ,CAAC,iBAAD,EAAoB,YAAM;AAChCgC,QAAAA,EAAE,CAAC,yCAAD,EAA4C,YAAM;AAClD/B,UAAAA,OAAO,CAACI,KAAR,GAAgBoI,SAAhB;AAEAxI,UAAAA,OAAO,CAACyI,eAAR,CAAwBrI,KAAxB;AAEA6B,UAAAA,MAAM,CAACjC,OAAO,CAACI,KAAT,CAAN,CAAsB8C,OAAtB,CAA8B9C,KAA9B;AACD,SANC,CAAF;AAOD,OARO,CAAR;AAUAL,MAAAA,QAAQ,CAAC,QAAD,EAAW,YAAM;AACvBgC,QAAAA,EAAE,CAAC,yCAAD,EAA4C,YAAM;AAClD,cAAM2G,aAAa,GAAG;AACpB9D,YAAAA,EAAE,EAAEnE,IAAI,CAACC,EAAL,EADgB;AAEpBmE,YAAAA,GAAG,EAAEpE,IAAI,CAACC,EAAL;AAFe,WAAtB;;AAIA,cAAMiI,QAAQ,mCACT,2BAAUvI,KAAV,CADS;AAEZuE,YAAAA,KAAK,EAAE+D;AAFK,YAAd;;AAIA,cAAME,UAAU,GAAG,IAAIpJ,eAAe,CAAC,cAAD,CAAnB,CAAoCmJ,QAApC,CAAnB;AAEA1G,UAAAA,MAAM,CAAC2G,UAAU,CAACjE,KAAZ,CAAN,CAAyBzB,OAAzB,CAAiCsF,SAAjC;AAEAI,UAAAA,UAAU,CAACrI,MAAX,CAAkBoI,QAAlB;AACA1G,UAAAA,MAAM,CAAC2G,UAAU,CAACjE,KAAZ,CAAN,CAAyBzB,OAAzB,CAAiCwF,aAAjC;AAEAE,UAAAA,UAAU,CAACrI,MAAX,CAAkBoI,QAAlB;AAEA1G,UAAAA,MAAM,CAACyG,aAAa,CAAC9D,EAAd,CAAiBmD,IAAjB,CAAsBC,KAAtB,CAA4B/E,MAA7B,CAAN,CAA2CC,OAA3C,CAAmD,CAAnD;AACD,SAnBC,CAAF;AAoBD,OArBO,CAAR;AAsBD,KAhTO,CAAR;AAiTD,GAzXO,CAAR;AA0XD,CA3zBO,CAAR","sourcesContent":["import React from 'react';\nimport {shallow} from 'enzyme';\nimport cloneDeep from 'lodash/cloneDeep';\nimport FreePathDrawable from '../drawable-free-path';\nimport LineDrawable from '../drawable-line';\nimport RectangleDrawable from '../drawable-rectangle';\nimport CircleDrawable from '../drawable-circle';\nimport EraserDrawable from '../drawable-eraser';\nimport DrawableText from '../drawable-text';\nimport {DrawableMain} from '../drawable-main';\n\nconst drawableClasses = {\n  FreePathDrawable,\n  LineDrawable,\n  RectangleDrawable,\n  CircleDrawable,\n  EraserDrawable,\n  DrawableText\n};\n\ndescribe('DrawingResponse', () => {\n  let element;\n  let wrapper;\n\n  const mkWrapper = (type, props, WrapperEl) => {\n    element = new drawableClasses[type](props);\n\n    let content = element.render(props);\n\n    if (WrapperEl) {\n      content = <WrapperEl>{content}</WrapperEl>;\n    }\n\n    return shallow(content);\n  };\n\n  describe('DrawableMain', () => {\n    let onSessionChange = jest.fn();\n    const TextEntry = new DrawableText();\n\n    const wrapperMain = (extras, renderOpts) => {\n      const defaults = {\n        classes: {},\n        disabled: false,\n        className: 'className',\n        onSessionChange,\n        imageDimensions: {},\n        imageUrl: 'url',\n        drawableDimensions: {height: 350, width: 353},\n        fillColor: 'white',\n        outlineColor: 'black',\n        paintColor: 'red',\n        session: {},\n        toolActive: {type: 'Select', label: 'Select', icon: 'mdiCursorDefault'},\n        TextEntry\n      };\n      const props = {...defaults, ...extras};\n      return shallow(<DrawableMain {...props} />, {\n        ...renderOpts\n      });\n    }\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        const w = wrapperMain();\n        expect(w).toMatchSnapshot();\n      });\n\n      it('renders disabled', () => {\n        const w = wrapperMain({disabled: true});\n        expect(w).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      const handleSessionChange = jest.fn();\n      const forceUpdate = jest.fn();\n      const props = {\n        handleSessionChange,\n        forceUpdate,\n        paint: true,\n        paintColor: 'green',\n        startx: 200,\n        starty: 200,\n        x: 300,\n        y: 300,\n        createdAt: new Date(),\n      };\n\n      it('handleUndo', () => {\n        const w = wrapperMain();\n\n        w.setState({drawables: [new RectangleDrawable(props), new RectangleDrawable(props)]});\n        w.instance().handleUndo();\n\n        expect(w.state('drawables').length).toEqual(1);\n\n        w.instance().handleUndo();\n\n        expect(w.state('drawables')).toEqual([]);\n      });\n\n      it('handleClearAll', () => {\n        const w = wrapperMain();\n\n        w.setState({drawables: [new RectangleDrawable(props), new RectangleDrawable(props)]});\n        w.instance().handleClearAll();\n\n        expect(w.state('drawables')).toEqual([]);\n      });\n    })\n  });\n\n  describe('CircleDrawable', () => {\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let props;\n\n    beforeEach(() => {\n      props = {\n        handleSessionChange,\n        forceUpdate,\n        paint: true,\n        paintColor: 'green',\n        startx: 200,\n        starty: 200,\n        x: 300,\n        y: 200,\n        createdAt: new Date(),\n      };\n      wrapper = mkWrapper('CircleDrawable', props);\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('calls forceUpdate', () => {\n        wrapper.simulate('click');\n        expect(forceUpdate).toHaveBeenCalled();\n      });\n\n      it('changes x and y', () => {\n        element.registerMovement(400, 400);\n\n        expect(element.x).toEqual(400);\n        expect(element.y).toEqual(400);\n      });\n\n      it('changes session when needed', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300)\n          }\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(event.target.getX).toHaveBeenCalled();\n        expect(event.target.getY).toHaveBeenCalled();\n\n        expect(handleSessionChange).toHaveBeenCalled();\n      });\n\n      it('changes startx and starty', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300)\n          }\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(element.startx).toEqual(300);\n        expect(element.starty).toEqual(300);\n        expect(element.x).toEqual(400);\n        expect(element.y).toEqual(300);\n      });\n    });\n  });\n\n  describe('EraserDrawable', () => {\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let props;\n\n    beforeEach(() => {\n      props = {\n        handleSessionChange,\n        forceUpdate,\n        points: [200, 200, 300, 300],\n        posX: 200,\n        posY: 200,\n        startx: 200,\n        starty: 200,\n        createdAt: new Date(),\n      };\n      wrapper = mkWrapper('EraserDrawable', props);\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('changes points', () => {\n        element.registerMovement(400, 400);\n\n        expect(element.points).toEqual([200, 200, 300, 300, 400, 400]);\n      });\n\n      it('changes session when needed', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300)\n          }\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(event.target.getX).toHaveBeenCalled();\n        expect(event.target.getY).toHaveBeenCalled();\n\n        expect(handleSessionChange).toHaveBeenCalled();\n      });\n\n      it('changes posX and posY', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300)\n          }\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(element.posX).toEqual(300);\n        expect(element.posY).toEqual(300);\n      });\n    });\n  });\n\n  describe('FreePathDrawable', () => {\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let props;\n\n    beforeEach(() => {\n      props = {\n        handleSessionChange,\n        forceUpdate,\n        paint: true,\n        paintColor: 'green',\n        points: [200, 200, 300, 300],\n        posX: 200,\n        posY: 200,\n        startx: 200,\n        starty: 200,\n        createdAt: new Date(),\n      };\n      wrapper = mkWrapper('FreePathDrawable', props);\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('calls forceUpdate', () => {\n        wrapper.simulate('click');\n        expect(forceUpdate).toHaveBeenCalled();\n      });\n\n      it('changes points', () => {\n        element.registerMovement(400, 400);\n\n        expect(element.points).toEqual([200, 200, 300, 300, 400, 400]);\n      });\n\n      it('changes session when needed', () => {\n        const spy = jest.spyOn(element, 'handleDragEnd');\n\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300)\n          }\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(event.target.getX).toHaveBeenCalled();\n        expect(event.target.getY).toHaveBeenCalled();\n\n        expect(handleSessionChange).toHaveBeenCalled();\n      });\n\n      it('changes posX and posY', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300)\n          }\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(element.posX).toEqual(300);\n        expect(element.posY).toEqual(300);\n      });\n    });\n  });\n\n  describe('LineDrawable', () => {\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let props;\n\n    beforeEach(() => {\n      props = {\n        handleSessionChange,\n        forceUpdate,\n        paint: true,\n        paintColor: 'green',\n        startx: 200,\n        starty: 200,\n        posX: 200,\n        posY: 200,\n        x: 300,\n        y: 200,\n        createdAt: new Date(),\n      };\n      wrapper = mkWrapper('LineDrawable', props);\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('calls forceUpdate', () => {\n        wrapper.simulate('click');\n        expect(forceUpdate).toHaveBeenCalled();\n      });\n\n      it('changes x and y', () => {\n        element.registerMovement(400, 400);\n\n        expect(element.x).toEqual(400);\n        expect(element.y).toEqual(400);\n      });\n\n      it('changes session when needed', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300)\n          }\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(event.target.getX).toHaveBeenCalled();\n        expect(event.target.getY).toHaveBeenCalled();\n\n        expect(handleSessionChange).toHaveBeenCalled();\n      });\n\n      it('changes posX and posY', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300)\n          }\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(element.posX).toEqual(300);\n        expect(element.posY).toEqual(300);\n      });\n    });\n  });\n\n  describe('RectangleDrawable', () => {\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let props;\n\n    beforeEach(() => {\n      props = {\n        handleSessionChange,\n        forceUpdate,\n        paint: true,\n        paintColor: 'green',\n        startx: 200,\n        starty: 200,\n        x: 300,\n        y: 300,\n        createdAt: new Date(),\n      };\n      wrapper = mkWrapper('RectangleDrawable', props);\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('calls forceUpdate', () => {\n        wrapper.simulate('click');\n        expect(forceUpdate).toHaveBeenCalled();\n      });\n\n      it('changes x and y', () => {\n        element.registerMovement(400, 400);\n\n        expect(element.x).toEqual(400);\n        expect(element.y).toEqual(400);\n      });\n\n      it('changes session when needed', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300)\n          }\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(event.target.getX).toHaveBeenCalled();\n        expect(event.target.getY).toHaveBeenCalled();\n\n        expect(handleSessionChange).toHaveBeenCalled();\n      });\n\n      it('changes posX and posY', () => {\n        const event = {\n          target: {\n            getX: jest.fn().mockReturnValue(300),\n            getY: jest.fn().mockReturnValue(300)\n          }\n        };\n\n        element.handleDragEnd(props, event);\n\n        expect(element.startx).toEqual(300);\n        expect(element.starty).toEqual(300);\n        expect(element.x).toEqual(400);\n        expect(element.y).toEqual(400);\n      });\n    });\n  });\n\n  describe('DrawableText', () => {\n    const all = [\n      {\n        id: 'gcifqhhimf8k2d6g8hs',\n        isDefault: true,\n        label: 'Double click to edit this text. Press Enter to submit.',\n        value: 'This is what the user entered',\n        width: 200,\n        x: 2 * 5 + 50,\n        y: 2 * 5 + 50,\n        textVisible: true,\n        transformerVisible: true,\n        textareaVisible: false,\n        createdAt: new Date(),\n        type: 'text-entry'\n      }\n    ];\n    let handleSessionChange = jest.fn();\n    let forceUpdate = jest.fn();\n    let toggleTextSelected = jest.fn();\n    let props;\n    let stage;\n\n    beforeEach(() => {\n      stage = {\n        on: jest.fn(),\n        off: jest.fn()\n      };\n\n      props = {\n        all,\n        handleSessionChange,\n        forceUpdate,\n        stage,\n        toggleTextSelected,\n        paint: true,\n        paintColor: 'green',\n        startx: 200,\n        starty: 200,\n        x: 300,\n        y: 300,\n        scale: 1\n      };\n      wrapper = mkWrapper('DrawableText', props, 'div');\n    });\n\n    describe('snapshot', () => {\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n\n      it('renders textAreas', () => {\n        element = new drawableClasses['DrawableText'](props);\n\n        wrapper = shallow(<div>{element.renderTextareas()}</div>);\n\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('snapshot when there is no value', () => {\n      beforeEach(() => {\n        props.all.forEach(a => {\n          delete a.value;\n        });\n        wrapper = mkWrapper('DrawableText', props, 'div');\n      });\n      it('renders', () => {\n        expect(wrapper).toMatchSnapshot();\n      });\n    });\n\n    describe('logic', () => {\n      it('shoud change the all property and call forceUpdate', () => {\n        element.setAll([]);\n\n        expect(element.all).toEqual([]);\n        expect(forceUpdate).toHaveBeenCalled();\n      });\n\n      describe('addNewTextEntry', () => {\n        it('shoud add a new element and call the appropriate functions', () => {\n          element.addNewTextEntry();\n\n          expect(element.all.length).toEqual(2);\n          expect(element.all).toEqual(\n            expect.arrayContaining([\n              expect.objectContaining({\n                isDefault: true,\n                label: 'Double click to edit this text. Press Enter to submit.',\n                width: 200,\n                textVisible: true,\n                transformerVisible: true,\n                textareaVisible: false,\n                type: 'text-entry'\n              })\n            ])\n          );\n\n          expect(stage.on).toHaveBeenCalled();\n          expect(handleSessionChange).toHaveBeenCalled();\n        });\n      });\n\n      describe('showOnlyTextNodes', () => {\n        it('should change properties for the \"all\" array', () => {\n          element.showOnlyTextNodes();\n\n          expect(element.all).toEqual(\n            expect.arrayContaining([\n              expect.objectContaining({\n                textVisible: true,\n                transformerVisible: false,\n                textareaVisible: false\n              })\n            ])\n          );\n        });\n      });\n\n      describe('showOnltoggleTextareayTextNodes', () => {\n        it('should change the item with the right id in the \"all\" array and call forceUpdate', () => {\n          element.toggleTextarea('gcifqhhimf8k2d6g8hs', true);\n\n          expect(element.all[0]).toEqual(\n            expect.objectContaining({\n              textVisible: false,\n              transformerVisible: false,\n              textareaVisible: true\n            })\n          );\n\n          expect(forceUpdate).toHaveBeenCalled();\n\n          element.toggleTextarea('gcifqhhimf8k2d6g8hs', false);\n\n          expect(element.all[0]).toEqual(\n            expect.objectContaining({\n              textVisible: true,\n              transformerVisible: true,\n              textareaVisible: false\n            })\n          );\n\n          expect(forceUpdate).toHaveBeenCalled();\n        });\n      });\n\n      describe('initializeDefault', () => {\n        it('should make the item with the right id default', () => {\n          element.initializeDefault('gcifqhhimf8k2d6g8hs', true);\n\n          expect(element.all[0]).toEqual(\n            expect.objectContaining({\n              isDefault: false\n            })\n          );\n        });\n      });\n\n      describe('saveValue', () => {\n        it('should make the item with the right id default and call handleSessionChange', () => {\n          const textNode = {\n            text: jest.fn()\n          };\n          const textareaNode = {\n            value: 'Foo bar'\n          };\n\n          element.saveValue('gcifqhhimf8k2d6g8hs', textNode, textareaNode);\n\n          expect(textNode.text).toHaveBeenCalledWith('Foo bar');\n          expect(handleSessionChange).toHaveBeenCalled();\n\n          textareaNode.value = '';\n\n          element.saveValue('gcifqhhimf8k2d6g8hs', textNode, textareaNode);\n\n          expect(element.all).toEqual(\n            expect.not.arrayContaining([\n              expect.objectContaining({\n                id: 'gcifqhhimf8k2d6g8hs'\n              })\n            ])\n          );\n          expect(forceUpdate).toHaveBeenCalled();\n          expect(handleSessionChange).toHaveBeenCalled();\n        });\n      });\n\n      describe('handleMouseEvents', () => {\n        it('should call the right functions on mouse down and up', () => {\n          element.handleMouseDown();\n          expect(toggleTextSelected).toHaveBeenCalledWith(true);\n\n          element.handleMouseUp();\n          expect(toggleTextSelected).toHaveBeenCalledWith(false);\n        });\n\n        it('should call the right functions onClick', () => {\n          element.handleClick(null, 'gcifqhhimf8k2d6g8hs');\n\n          expect(element.all).toEqual(\n            expect.arrayContaining([\n              expect.objectContaining({\n                transformerVisible: true\n              })\n            ])\n          );\n\n          expect(forceUpdate).toHaveBeenCalled();\n        });\n\n        it('should call the right functions onDblClick', () => {\n          const text = {\n            id: 'gcifqhhimf8k2d6g8hs',\n            isDefault: false\n          };\n\n          const textNode = (element[`text_${text.id}`] = {\n            _lastPos: {\n              x: 200,\n              y: 200\n            },\n            align: jest.fn().mockReturnValue('center'),\n            fill: jest.fn().mockReturnValue('green'),\n            fontFamily: jest.fn().mockReturnValue('FooBarFamily'),\n            fontSize: jest.fn().mockReturnValue('16'),\n            height: jest.fn().mockReturnValue(40),\n            lineHeight: jest.fn().mockReturnValue('40px'),\n            padding: jest.fn().mockReturnValue(0),\n            rotation: jest.fn().mockReturnValue(0),\n            text: jest.fn().mockReturnValue('foo bar'),\n            width: jest.fn().mockReturnValue(200)\n          });\n          const textareaNode = (element[`textarea_${text.id}`] = {\n            focus: jest.fn(),\n            addEventListener: jest.fn(),\n            style: {},\n            scrollHeight: 205\n          });\n\n          const initSpy = jest.spyOn(element, 'initializeDefault');\n          const saveValueSpy = jest.spyOn(element, 'saveValue');\n          const toggleSpy = jest.spyOn(element, 'toggleTextarea');\n\n          element.handleDblClick(null, text);\n\n          expect(toggleSpy).toHaveBeenCalledWith(text.id, true);\n\n          expect(textareaNode.value).toEqual('foo bar');\n          expect(textareaNode.style).toEqual({\n            background: 'none',\n            border: 'none',\n            color: 'green',\n            fontFamily: 'FooBarFamily',\n            fontSize: '16px',\n            height: '208px',\n            left: '200px',\n            lineHeight: '40px',\n            margin: '0px',\n            outline: 'none',\n            overflow: 'hidden',\n            padding: '0px',\n            position: 'absolute',\n            resize: 'none',\n            top: '200px',\n            transformOrigin: 'left top',\n            textAlign: 'center',\n            transform: 'translateY(-0px)',\n            width: '200px'\n          });\n\n          expect(textareaNode.focus).toHaveBeenCalled();\n          expect(stage.on).toHaveBeenCalled();\n          expect(initSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);\n          expect(forceUpdate).toHaveBeenCalled();\n          expect(textareaNode.addEventListener.mock.calls[0][0]).toEqual(\n            'keydown'\n          );\n          expect(textareaNode.addEventListener.mock.calls[1][0]).toEqual(\n            'blur'\n          );\n\n          const event = {\n            keyCode: 13,\n            shiftKey: true\n          };\n\n          textareaNode.addEventListener.mock.calls[0][1](event);\n\n          // Make sure it's not called the second time\n          expect(toggleSpy).toHaveBeenCalledTimes(1);\n          expect(saveValueSpy).not.toHaveBeenCalled();\n\n          event.shiftKey = false;\n\n          textareaNode.addEventListener.mock.calls[0][1](event);\n\n          expect(toggleSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);\n          expect(saveValueSpy).toHaveBeenCalledWith(\n            'gcifqhhimf8k2d6g8hs',\n            textNode,\n            textareaNode\n          );\n\n          event.keyCode = 27;\n\n          textareaNode.addEventListener.mock.calls[0][1](event);\n\n          expect(toggleSpy).toHaveBeenCalledWith('gcifqhhimf8k2d6g8hs', false);\n\n          const showTextSpy = jest.spyOn(element, 'showOnlyTextNodes');\n\n          event.target = stage;\n\n          stage.on.mock.calls[0][1](event);\n\n          expect(showTextSpy).toHaveBeenCalled();\n          expect(saveValueSpy).toHaveBeenCalledWith(\n            'gcifqhhimf8k2d6g8hs',\n            textNode,\n            textareaNode\n          );\n        });\n      });\n\n      describe('handleTransform', () => {\n        it('should change attrs when called', () => {\n          const textNode = (element[`text_gcifqhhimf8k2d6g8hs`] = {\n            setAttrs: jest.fn(),\n            width: jest.fn().mockReturnValue(100),\n            scaleX: jest.fn().mockReturnValue(1)\n          });\n\n          element.handleTransform(null, 'text_gcifqhhimf8k2d6g8hs');\n\n          expect(textNode.setAttrs).toHaveBeenCalledWith({\n            width: 100,\n            scaleX: 1\n          });\n        });\n      });\n\n      describe('setInitialProps', () => {\n        it('should set the props if not set already', () => {\n          element.props = undefined;\n\n          element.setInitialProps(props);\n\n          expect(element.props).toEqual(props);\n        });\n      });\n\n      describe('render', () => {\n        it('should set the stage listener only once', () => {\n          const separateStage = {\n            on: jest.fn(),\n            off: jest.fn()\n          };\n          const newProps = {\n            ...cloneDeep(props),\n            stage: separateStage\n          };\n          const newElement = new drawableClasses['DrawableText'](newProps);\n\n          expect(newElement.stage).toEqual(undefined);\n\n          newElement.render(newProps);\n          expect(newElement.stage).toEqual(separateStage);\n\n          newElement.render(newProps);\n\n          expect(separateStage.on.mock.calls.length).toEqual(1);\n        });\n      });\n    });\n  });\n})\n;\n"]}