@pie-lib/graphing 2.15.0-beta.4 → 2.15.0-beta.5

package/lib/tools/circle/__tests__/component.test.js

@@ -0,0 +1,259 @@
+"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 _utils = require("../../../__tests__/utils");
+
+var _component = require("../component");
+
+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 xyLabel = function xyLabel(x, y, label) {
+  return {
+    x: x,
+    y: y,
+    label: label
+  };
+};
+
+describe('Component', function () {
+  var w;
+  var onChange = jest.fn();
+  var changeMarkProps = jest.fn();
+
+  var wrapper = function wrapper(extras) {
+    var defaults = {
+      classes: {},
+      className: 'className',
+      onChange: onChange,
+      changeMarkProps: changeMarkProps,
+      graphProps: (0, _utils.graphProps)(),
+      from: (0, _utils.xy)(0, 0),
+      to: (0, _utils.xy)(1, 1)
+    };
+
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_component.RawBaseCircle, props));
+  }; // used to test items that have labels attached to points
+
+
+  var labelNode = document.createElement('foreignObject');
+  var fromWithLabel = {
+    x: 0,
+    y: 0,
+    label: 'A'
+  };
+  var toWithLabel = {
+    x: 1,
+    y: 1,
+    label: 'B'
+  };
+
+  var wrapperWithLabels = function wrapperWithLabels() {
+    var extras = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return wrapper(_objectSpread(_objectSpread({}, extras), {}, {
+      labelNode: labelNode,
+      from: fromWithLabel,
+      to: toWithLabel
+    }));
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+    it('renders with labels', function () {
+      w = wrapperWithLabels();
+      expect(w).toMatchSnapshot();
+    });
+  });
+  describe('logic', function () {
+    beforeEach(function () {
+      return w = wrapper();
+    });
+    describe('dragFrom', function () {
+      it('calls onChange', function () {
+        w = wrapper();
+        w.instance().dragFrom((0, _utils.xy)(1, 1));
+        expect(onChange).not.toHaveBeenCalledWith({
+          from: (0, _utils.xy)(1, 1),
+          to: (0, _utils.xy)(1, 1)
+        });
+        w.instance().dragFrom((0, _utils.xy)(2, 2));
+        expect(onChange).toHaveBeenCalledWith({
+          from: (0, _utils.xy)(2, 2),
+          to: (0, _utils.xy)(1, 1)
+        });
+      });
+    });
+    describe('dragFrom keeps labels on "from"', function () {
+      it('calls onChange', function () {
+        w = wrapperWithLabels(); // drag "from" to { x: 1, y: 1 }
+
+        w.instance().dragFrom({
+          x: 1,
+          y: 1
+        }); // won't change because points overlap
+
+        expect(onChange).not.toHaveBeenCalledWith({
+          from: xyLabel(1, 1, 'A'),
+          to: toWithLabel
+        }); // wil change and will keep labels
+
+        w.instance().dragFrom({
+          x: 2,
+          y: 2
+        });
+        expect(onChange).toHaveBeenCalledWith({
+          from: xyLabel(2, 2, 'A'),
+          to: toWithLabel
+        });
+      });
+    });
+    describe('dragTo', function () {
+      it('calls onChange', function () {
+        w.instance().dragTo((0, _utils.xy)(4, 4));
+        expect(onChange).toHaveBeenCalledWith({
+          from: (0, _utils.xy)(0, 0),
+          to: (0, _utils.xy)(4, 4)
+        });
+      });
+    });
+    describe('dragTo keeps labels on "to"', function () {
+      it('calls onChange', function () {
+        w = wrapperWithLabels(); // won't change because points overlap
+
+        w.instance().dragTo({
+          x: 0,
+          y: 0
+        });
+        expect(onChange).not.toHaveBeenCalledWith({
+          from: fromWithLabel,
+          to: xyLabel(1, 1, 'B')
+        }); // wil change and will keep labels
+
+        w.instance().dragTo({
+          x: 2,
+          y: 2
+        });
+        expect(onChange).toHaveBeenCalledWith({
+          from: fromWithLabel,
+          to: xyLabel(2, 2, 'B')
+        });
+      });
+    });
+    describe('dragCircle', function () {
+      it('calls onChange', function () {
+        w.instance().dragCircle((0, _utils.xy)(1, 1));
+        expect(onChange).toHaveBeenCalledWith({
+          from: (0, _utils.xy)(1, 1),
+          to: (0, _utils.xy)(2, 2)
+        });
+      });
+    });
+    describe('dragCircle keeps labels on both "from" and "to"', function () {
+      it('calls onChange', function () {
+        w = wrapperWithLabels(); // wil change and will keep labels
+
+        w.instance().dragCircle({
+          x: 10,
+          y: 10
+        });
+        expect(onChange).toHaveBeenCalledWith({
+          from: xyLabel(10, 10, 'A'),
+          to: xyLabel(11, 11, 'B')
+        }); // wil change and will keep labels
+
+        w.instance().dragCircle({
+          x: 2,
+          y: 2
+        });
+        expect(onChange).toHaveBeenCalledWith({
+          from: xyLabel(2, 2, 'A'),
+          to: xyLabel(3, 3, 'B')
+        });
+      });
+    });
+    describe('labelChange', function () {
+      it('updates "label" property for point', function () {
+        w = wrapperWithLabels({
+          labelModeEnabled: true
+        });
+        w.instance().labelChange(xyLabel(0, 0, 'Label A'), 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, 'Label A')
+        });
+        w.instance().labelChange(xyLabel(0, 0, 'Label B'), 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          to: xyLabel(0, 0, 'Label B')
+        });
+      });
+      it('removes "label" property if the field is empty', function () {
+        w = wrapperWithLabels({
+          labelModeEnabled: true
+        });
+        w.instance().labelChange(xyLabel(0, 0, ''), 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: (0, _utils.xy)(0, 0)
+        });
+        w.instance().labelChange(xyLabel(0, 0, ''), 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          to: (0, _utils.xy)(0, 0)
+        });
+      });
+    });
+    describe('clickPoint', function () {
+      it('adds "label" property to a point', function () {
+        w = wrapperWithLabels({
+          labelModeEnabled: true
+        });
+        w.instance().clickPoint((0, _utils.xy)(0, 0), 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, ''),
+          to: xyLabel(1, 1, 'B')
+        });
+        w.instance().clickPoint((0, _utils.xy)(1, 1), 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, 'A'),
+          to: xyLabel(1, 1, '')
+        });
+      });
+      it('adds "label" property to a point when limit labeling', function () {
+        var changeMarkProps = jest.fn();
+        w = wrapperWithLabels({
+          labelModeEnabled: true,
+          limitLabeling: true,
+          changeMarkProps: changeMarkProps
+        });
+        w.instance().clickPoint((0, _utils.xy)(0, 0), 'from');
+        expect(changeMarkProps).toHaveBeenCalledTimes(0);
+      });
+      it('if point already has label, keeps that value', function () {
+        w = wrapperWithLabels({
+          labelModeEnabled: true
+        });
+        w.instance().clickPoint(fromWithLabel, 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: fromWithLabel,
+          to: xyLabel(1, 1, 'B')
+        });
+        w.instance().clickPoint(toWithLabel, 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, 'A'),
+          to: toWithLabel
+        });
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/tools/circle/__tests__/component.test.jsx"],"names":["xyLabel","x","y","label","describe","w","onChange","jest","fn","changeMarkProps","wrapper","extras","defaults","classes","className","graphProps","from","to","props","labelNode","document","createElement","fromWithLabel","toWithLabel","wrapperWithLabels","it","expect","toMatchSnapshot","beforeEach","instance","dragFrom","not","toHaveBeenCalledWith","dragTo","dragCircle","labelModeEnabled","labelChange","toBeCalledWith","clickPoint","limitLabeling","toHaveBeenCalledTimes"],"mappings":";;;;;;AAAA;;AACA;;AACA;;AAEA;;;;;;AAEA,IAAMA,OAAO,GAAG,SAAVA,OAAU,CAACC,CAAD,EAAIC,CAAJ,EAAOC,KAAP;AAAA,SAAkB;AAAEF,IAAAA,CAAC,EAADA,CAAF;AAAKC,IAAAA,CAAC,EAADA,CAAL;AAAQC,IAAAA,KAAK,EAALA;AAAR,GAAlB;AAAA,CAAhB;;AAEAC,QAAQ,CAAC,WAAD,EAAc,YAAM;AAC1B,MAAIC,CAAJ;AACA,MAAIC,QAAQ,GAAGC,IAAI,CAACC,EAAL,EAAf;AACA,MAAIC,eAAe,GAAGF,IAAI,CAACC,EAAL,EAAtB;;AAEA,MAAME,OAAO,GAAG,SAAVA,OAAU,CAACC,MAAD,EAAY;AAC1B,QAAMC,QAAQ,GAAG;AACfC,MAAAA,OAAO,EAAE,EADM;AAEfC,MAAAA,SAAS,EAAE,WAFI;AAGfR,MAAAA,QAAQ,EAARA,QAHe;AAIfG,MAAAA,eAAe,EAAfA,eAJe;AAKfM,MAAAA,UAAU,EAAE,wBALG;AAMfC,MAAAA,IAAI,EAAE,eAAG,CAAH,EAAM,CAAN,CANS;AAOfC,MAAAA,EAAE,EAAE,eAAG,CAAH,EAAM,CAAN;AAPW,KAAjB;;AASA,QAAMC,KAAK,mCAAQN,QAAR,GAAqBD,MAArB,CAAX;;AAEA,WAAO,mCAAQ,gCAAC,wBAAD,EAAmBO,KAAnB,CAAR,CAAP;AACD,GAbD,CAL0B,CAoB1B;;;AACA,MAAMC,SAAS,GAAGC,QAAQ,CAACC,aAAT,CAAuB,eAAvB,CAAlB;AACA,MAAMC,aAAa,GAAG;AAAErB,IAAAA,CAAC,EAAE,CAAL;AAAQC,IAAAA,CAAC,EAAE,CAAX;AAAcC,IAAAA,KAAK,EAAE;AAArB,GAAtB;AACA,MAAMoB,WAAW,GAAG;AAAEtB,IAAAA,CAAC,EAAE,CAAL;AAAQC,IAAAA,CAAC,EAAE,CAAX;AAAcC,IAAAA,KAAK,EAAE;AAArB,GAApB;;AACA,MAAMqB,iBAAiB,GAAG,SAApBA,iBAAoB;AAAA,QAACb,MAAD,uEAAU,EAAV;AAAA,WACxBD,OAAO,iCACFC,MADE;AAELQ,MAAAA,SAAS,EAAEA,SAFN;AAGLH,MAAAA,IAAI,EAAEM,aAHD;AAILL,MAAAA,EAAE,EAAEM;AAJC,OADiB;AAAA,GAA1B;;AAQAnB,EAAAA,QAAQ,CAAC,UAAD,EAAa,YAAM;AACzBqB,IAAAA,EAAE,CAAC,SAAD,EAAY,YAAM;AAClBpB,MAAAA,CAAC,GAAGK,OAAO,EAAX;AACAgB,MAAAA,MAAM,CAACrB,CAAD,CAAN,CAAUsB,eAAV;AACD,KAHC,CAAF;AAKAF,IAAAA,EAAE,CAAC,qBAAD,EAAwB,YAAM;AAC9BpB,MAAAA,CAAC,GAAGmB,iBAAiB,EAArB;AAEAE,MAAAA,MAAM,CAACrB,CAAD,CAAN,CAAUsB,eAAV;AACD,KAJC,CAAF;AAKD,GAXO,CAAR;AAaAvB,EAAAA,QAAQ,CAAC,OAAD,EAAU,YAAM;AACtBwB,IAAAA,UAAU,CAAC;AAAA,aAAOvB,CAAC,GAAGK,OAAO,EAAlB;AAAA,KAAD,CAAV;AAEAN,IAAAA,QAAQ,CAAC,UAAD,EAAa,YAAM;AACzBqB,MAAAA,EAAE,CAAC,gBAAD,EAAmB,YAAM;AACzBpB,QAAAA,CAAC,GAAGK,OAAO,EAAX;AACAL,QAAAA,CAAC,CAACwB,QAAF,GAAaC,QAAb,CAAsB,eAAG,CAAH,EAAM,CAAN,CAAtB;AACAJ,QAAAA,MAAM,CAACpB,QAAD,CAAN,CAAiByB,GAAjB,CAAqBC,oBAArB,CAA0C;AACxChB,UAAAA,IAAI,EAAE,eAAG,CAAH,EAAM,CAAN,CADkC;AAExCC,UAAAA,EAAE,EAAE,eAAG,CAAH,EAAM,CAAN;AAFoC,SAA1C;AAKAZ,QAAAA,CAAC,CAACwB,QAAF,GAAaC,QAAb,CAAsB,eAAG,CAAH,EAAM,CAAN,CAAtB;AACAJ,QAAAA,MAAM,CAACpB,QAAD,CAAN,CAAiB0B,oBAAjB,CAAsC;AACpChB,UAAAA,IAAI,EAAE,eAAG,CAAH,EAAM,CAAN,CAD8B;AAEpCC,UAAAA,EAAE,EAAE,eAAG,CAAH,EAAM,CAAN;AAFgC,SAAtC;AAID,OAbC,CAAF;AAcD,KAfO,CAAR;AAiBAb,IAAAA,QAAQ,CAAC,iCAAD,EAAoC,YAAM;AAChDqB,MAAAA,EAAE,CAAC,gBAAD,EAAmB,YAAM;AACzBpB,QAAAA,CAAC,GAAGmB,iBAAiB,EAArB,CADyB,CAGzB;;AACAnB,QAAAA,CAAC,CAACwB,QAAF,GAAaC,QAAb,CAAsB;AAAE7B,UAAAA,CAAC,EAAE,CAAL;AAAQC,UAAAA,CAAC,EAAE;AAAX,SAAtB,EAJyB,CAMzB;;AACAwB,QAAAA,MAAM,CAACpB,QAAD,CAAN,CAAiByB,GAAjB,CAAqBC,oBAArB,CAA0C;AACxChB,UAAAA,IAAI,EAAEhB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,GAAP,CAD2B;AAExCiB,UAAAA,EAAE,EAAEM;AAFoC,SAA1C,EAPyB,CAYzB;;AACAlB,QAAAA,CAAC,CAACwB,QAAF,GAAaC,QAAb,CAAsB;AAAE7B,UAAAA,CAAC,EAAE,CAAL;AAAQC,UAAAA,CAAC,EAAE;AAAX,SAAtB;AACAwB,QAAAA,MAAM,CAACpB,QAAD,CAAN,CAAiB0B,oBAAjB,CAAsC;AACpChB,UAAAA,IAAI,EAAEhB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,GAAP,CADuB;AAEpCiB,UAAAA,EAAE,EAAEM;AAFgC,SAAtC;AAID,OAlBC,CAAF;AAmBD,KApBO,CAAR;AAsBAnB,IAAAA,QAAQ,CAAC,QAAD,EAAW,YAAM;AACvBqB,MAAAA,EAAE,CAAC,gBAAD,EAAmB,YAAM;AACzBpB,QAAAA,CAAC,CAACwB,QAAF,GAAaI,MAAb,CAAoB,eAAG,CAAH,EAAM,CAAN,CAApB;AACAP,QAAAA,MAAM,CAACpB,QAAD,CAAN,CAAiB0B,oBAAjB,CAAsC;AACpChB,UAAAA,IAAI,EAAE,eAAG,CAAH,EAAM,CAAN,CAD8B;AAEpCC,UAAAA,EAAE,EAAE,eAAG,CAAH,EAAM,CAAN;AAFgC,SAAtC;AAID,OANC,CAAF;AAOD,KARO,CAAR;AAUAb,IAAAA,QAAQ,CAAC,6BAAD,EAAgC,YAAM;AAC5CqB,MAAAA,EAAE,CAAC,gBAAD,EAAmB,YAAM;AACzBpB,QAAAA,CAAC,GAAGmB,iBAAiB,EAArB,CADyB,CAGzB;;AACAnB,QAAAA,CAAC,CAACwB,QAAF,GAAaI,MAAb,CAAoB;AAAEhC,UAAAA,CAAC,EAAE,CAAL;AAAQC,UAAAA,CAAC,EAAE;AAAX,SAApB;AACAwB,QAAAA,MAAM,CAACpB,QAAD,CAAN,CAAiByB,GAAjB,CAAqBC,oBAArB,CAA0C;AACxChB,UAAAA,IAAI,EAAEM,aADkC;AAExCL,UAAAA,EAAE,EAAEjB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,GAAP;AAF6B,SAA1C,EALyB,CAUzB;;AACAK,QAAAA,CAAC,CAACwB,QAAF,GAAaI,MAAb,CAAoB;AAAEhC,UAAAA,CAAC,EAAE,CAAL;AAAQC,UAAAA,CAAC,EAAE;AAAX,SAApB;AACAwB,QAAAA,MAAM,CAACpB,QAAD,CAAN,CAAiB0B,oBAAjB,CAAsC;AACpChB,UAAAA,IAAI,EAAEM,aAD8B;AAEpCL,UAAAA,EAAE,EAAEjB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,GAAP;AAFyB,SAAtC;AAID,OAhBC,CAAF;AAiBD,KAlBO,CAAR;AAoBAI,IAAAA,QAAQ,CAAC,YAAD,EAAe,YAAM;AAC3BqB,MAAAA,EAAE,CAAC,gBAAD,EAAmB,YAAM;AACzBpB,QAAAA,CAAC,CAACwB,QAAF,GAAaK,UAAb,CAAwB,eAAG,CAAH,EAAM,CAAN,CAAxB;AACAR,QAAAA,MAAM,CAACpB,QAAD,CAAN,CAAiB0B,oBAAjB,CAAsC;AACpChB,UAAAA,IAAI,EAAE,eAAG,CAAH,EAAM,CAAN,CAD8B;AAEpCC,UAAAA,EAAE,EAAE,eAAG,CAAH,EAAM,CAAN;AAFgC,SAAtC;AAID,OANC,CAAF;AAOD,KARO,CAAR;AAUAb,IAAAA,QAAQ,CAAC,iDAAD,EAAoD,YAAM;AAChEqB,MAAAA,EAAE,CAAC,gBAAD,EAAmB,YAAM;AACzBpB,QAAAA,CAAC,GAAGmB,iBAAiB,EAArB,CADyB,CAGzB;;AACAnB,QAAAA,CAAC,CAACwB,QAAF,GAAaK,UAAb,CAAwB;AAAEjC,UAAAA,CAAC,EAAE,EAAL;AAASC,UAAAA,CAAC,EAAE;AAAZ,SAAxB;AACAwB,QAAAA,MAAM,CAACpB,QAAD,CAAN,CAAiB0B,oBAAjB,CAAsC;AACpChB,UAAAA,IAAI,EAAEhB,OAAO,CAAC,EAAD,EAAK,EAAL,EAAS,GAAT,CADuB;AAEpCiB,UAAAA,EAAE,EAAEjB,OAAO,CAAC,EAAD,EAAK,EAAL,EAAS,GAAT;AAFyB,SAAtC,EALyB,CAUzB;;AACAK,QAAAA,CAAC,CAACwB,QAAF,GAAaK,UAAb,CAAwB;AAAEjC,UAAAA,CAAC,EAAE,CAAL;AAAQC,UAAAA,CAAC,EAAE;AAAX,SAAxB;AACAwB,QAAAA,MAAM,CAACpB,QAAD,CAAN,CAAiB0B,oBAAjB,CAAsC;AACpChB,UAAAA,IAAI,EAAEhB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,GAAP,CADuB;AAEpCiB,UAAAA,EAAE,EAAEjB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,GAAP;AAFyB,SAAtC;AAID,OAhBC,CAAF;AAiBD,KAlBO,CAAR;AAoBAI,IAAAA,QAAQ,CAAC,aAAD,EAAgB,YAAM;AAC5BqB,MAAAA,EAAE,CAAC,oCAAD,EAAuC,YAAM;AAC7CpB,QAAAA,CAAC,GAAGmB,iBAAiB,CAAC;AAAEW,UAAAA,gBAAgB,EAAE;AAApB,SAAD,CAArB;AAEA9B,QAAAA,CAAC,CAACwB,QAAF,GAAaO,WAAb,CAAyBpC,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,SAAP,CAAhC,EAAmD,MAAnD;AACA0B,QAAAA,MAAM,CAACjB,eAAD,CAAN,CAAwB4B,cAAxB,CAAuC;AACrCrB,UAAAA,IAAI,EAAEhB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,SAAP;AADwB,SAAvC;AAIAK,QAAAA,CAAC,CAACwB,QAAF,GAAaO,WAAb,CAAyBpC,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,SAAP,CAAhC,EAAmD,IAAnD;AACA0B,QAAAA,MAAM,CAACjB,eAAD,CAAN,CAAwB4B,cAAxB,CAAuC;AACrCpB,UAAAA,EAAE,EAAEjB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,SAAP;AAD0B,SAAvC;AAGD,OAZC,CAAF;AAcAyB,MAAAA,EAAE,CAAC,gDAAD,EAAmD,YAAM;AACzDpB,QAAAA,CAAC,GAAGmB,iBAAiB,CAAC;AAAEW,UAAAA,gBAAgB,EAAE;AAApB,SAAD,CAArB;AAEA9B,QAAAA,CAAC,CAACwB,QAAF,GAAaO,WAAb,CAAyBpC,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,EAAP,CAAhC,EAA4C,MAA5C;AACA0B,QAAAA,MAAM,CAACjB,eAAD,CAAN,CAAwB4B,cAAxB,CAAuC;AACrCrB,UAAAA,IAAI,EAAE,eAAG,CAAH,EAAM,CAAN;AAD+B,SAAvC;AAIAX,QAAAA,CAAC,CAACwB,QAAF,GAAaO,WAAb,CAAyBpC,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,EAAP,CAAhC,EAA4C,IAA5C;AACA0B,QAAAA,MAAM,CAACjB,eAAD,CAAN,CAAwB4B,cAAxB,CAAuC;AACrCpB,UAAAA,EAAE,EAAE,eAAG,CAAH,EAAM,CAAN;AADiC,SAAvC;AAGD,OAZC,CAAF;AAaD,KA5BO,CAAR;AA8BAb,IAAAA,QAAQ,CAAC,YAAD,EAAe,YAAM;AAC3BqB,MAAAA,EAAE,CAAC,kCAAD,EAAqC,YAAM;AAC3CpB,QAAAA,CAAC,GAAGmB,iBAAiB,CAAC;AAAEW,UAAAA,gBAAgB,EAAE;AAApB,SAAD,CAArB;AAEA9B,QAAAA,CAAC,CAACwB,QAAF,GAAaS,UAAb,CAAwB,eAAG,CAAH,EAAM,CAAN,CAAxB,EAAkC,MAAlC;AACAZ,QAAAA,MAAM,CAACjB,eAAD,CAAN,CAAwB4B,cAAxB,CAAuC;AACrCrB,UAAAA,IAAI,EAAEhB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,EAAP,CADwB;AAErCiB,UAAAA,EAAE,EAAEjB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,GAAP;AAF0B,SAAvC;AAKAK,QAAAA,CAAC,CAACwB,QAAF,GAAaS,UAAb,CAAwB,eAAG,CAAH,EAAM,CAAN,CAAxB,EAAkC,IAAlC;AACAZ,QAAAA,MAAM,CAACjB,eAAD,CAAN,CAAwB4B,cAAxB,CAAuC;AACrCrB,UAAAA,IAAI,EAAEhB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,GAAP,CADwB;AAErCiB,UAAAA,EAAE,EAAEjB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,EAAP;AAF0B,SAAvC;AAID,OAdC,CAAF;AAgBAyB,MAAAA,EAAE,CAAC,sDAAD,EAAyD,YAAM;AAC/D,YAAMhB,eAAe,GAAGF,IAAI,CAACC,EAAL,EAAxB;AACAH,QAAAA,CAAC,GAAGmB,iBAAiB,CAAC;AAAEW,UAAAA,gBAAgB,EAAE,IAApB;AAA0BI,UAAAA,aAAa,EAAE,IAAzC;AAA+C9B,UAAAA,eAAe,EAAfA;AAA/C,SAAD,CAArB;AAEAJ,QAAAA,CAAC,CAACwB,QAAF,GAAaS,UAAb,CAAwB,eAAG,CAAH,EAAM,CAAN,CAAxB,EAAkC,MAAlC;AACAZ,QAAAA,MAAM,CAACjB,eAAD,CAAN,CAAwB+B,qBAAxB,CAA8C,CAA9C;AACD,OANC,CAAF;AAQAf,MAAAA,EAAE,CAAC,8CAAD,EAAiD,YAAM;AACvDpB,QAAAA,CAAC,GAAGmB,iBAAiB,CAAC;AAAEW,UAAAA,gBAAgB,EAAE;AAApB,SAAD,CAArB;AAEA9B,QAAAA,CAAC,CAACwB,QAAF,GAAaS,UAAb,CAAwBhB,aAAxB,EAAuC,MAAvC;AACAI,QAAAA,MAAM,CAACjB,eAAD,CAAN,CAAwB4B,cAAxB,CAAuC;AACrCrB,UAAAA,IAAI,EAAEM,aAD+B;AAErCL,UAAAA,EAAE,EAAEjB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,GAAP;AAF0B,SAAvC;AAKAK,QAAAA,CAAC,CAACwB,QAAF,GAAaS,UAAb,CAAwBf,WAAxB,EAAqC,IAArC;AACAG,QAAAA,MAAM,CAACjB,eAAD,CAAN,CAAwB4B,cAAxB,CAAuC;AACrCrB,UAAAA,IAAI,EAAEhB,OAAO,CAAC,CAAD,EAAI,CAAJ,EAAO,GAAP,CADwB;AAErCiB,UAAAA,EAAE,EAAEM;AAFiC,SAAvC;AAID,OAdC,CAAF;AAeD,KAxCO,CAAR;AAyCD,GA7KO,CAAR;AA8KD,CA3NO,CAAR","sourcesContent":["import { shallow } from 'enzyme';\nimport React from 'react';\nimport { graphProps, xy } from '../../../__tests__/utils';\n\nimport { RawBaseCircle } from '../component';\n\nconst xyLabel = (x, y, label) => ({ x, y, label });\n\ndescribe('Component', () => {\n  let w;\n  let onChange = jest.fn();\n  let changeMarkProps = jest.fn();\n\n  const wrapper = (extras) => {\n    const defaults = {\n      classes: {},\n      className: 'className',\n      onChange,\n      changeMarkProps,\n      graphProps: graphProps(),\n      from: xy(0, 0),\n      to: xy(1, 1),\n    };\n    const props = { ...defaults, ...extras };\n\n    return shallow(<RawBaseCircle {...props} />);\n  };\n\n  // used to test items that have labels attached to points\n  const labelNode = document.createElement('foreignObject');\n  const fromWithLabel = { x: 0, y: 0, label: 'A' };\n  const toWithLabel = { x: 1, y: 1, label: 'B' };\n  const wrapperWithLabels = (extras = {}) =>\n    wrapper({\n      ...extras,\n      labelNode: labelNode,\n      from: fromWithLabel,\n      to: toWithLabel,\n    });\n\n  describe('snapshot', () => {\n    it('renders', () => {\n      w = wrapper();\n      expect(w).toMatchSnapshot();\n    });\n\n    it('renders with labels', () => {\n      w = wrapperWithLabels();\n\n      expect(w).toMatchSnapshot();\n    });\n  });\n\n  describe('logic', () => {\n    beforeEach(() => (w = wrapper()));\n\n    describe('dragFrom', () => {\n      it('calls onChange', () => {\n        w = wrapper();\n        w.instance().dragFrom(xy(1, 1));\n        expect(onChange).not.toHaveBeenCalledWith({\n          from: xy(1, 1),\n          to: xy(1, 1),\n        });\n\n        w.instance().dragFrom(xy(2, 2));\n        expect(onChange).toHaveBeenCalledWith({\n          from: xy(2, 2),\n          to: xy(1, 1),\n        });\n      });\n    });\n\n    describe('dragFrom keeps labels on \"from\"', () => {\n      it('calls onChange', () => {\n        w = wrapperWithLabels();\n\n        // drag \"from\" to { x: 1, y: 1 }\n        w.instance().dragFrom({ x: 1, y: 1 });\n\n        // won't change because points overlap\n        expect(onChange).not.toHaveBeenCalledWith({\n          from: xyLabel(1, 1, 'A'),\n          to: toWithLabel,\n        });\n\n        // wil change and will keep labels\n        w.instance().dragFrom({ x: 2, y: 2 });\n        expect(onChange).toHaveBeenCalledWith({\n          from: xyLabel(2, 2, 'A'),\n          to: toWithLabel,\n        });\n      });\n    });\n\n    describe('dragTo', () => {\n      it('calls onChange', () => {\n        w.instance().dragTo(xy(4, 4));\n        expect(onChange).toHaveBeenCalledWith({\n          from: xy(0, 0),\n          to: xy(4, 4),\n        });\n      });\n    });\n\n    describe('dragTo keeps labels on \"to\"', () => {\n      it('calls onChange', () => {\n        w = wrapperWithLabels();\n\n        // won't change because points overlap\n        w.instance().dragTo({ x: 0, y: 0 });\n        expect(onChange).not.toHaveBeenCalledWith({\n          from: fromWithLabel,\n          to: xyLabel(1, 1, 'B'),\n        });\n\n        // wil change and will keep labels\n        w.instance().dragTo({ x: 2, y: 2 });\n        expect(onChange).toHaveBeenCalledWith({\n          from: fromWithLabel,\n          to: xyLabel(2, 2, 'B'),\n        });\n      });\n    });\n\n    describe('dragCircle', () => {\n      it('calls onChange', () => {\n        w.instance().dragCircle(xy(1, 1));\n        expect(onChange).toHaveBeenCalledWith({\n          from: xy(1, 1),\n          to: xy(2, 2),\n        });\n      });\n    });\n\n    describe('dragCircle keeps labels on both \"from\" and \"to\"', () => {\n      it('calls onChange', () => {\n        w = wrapperWithLabels();\n\n        // wil change and will keep labels\n        w.instance().dragCircle({ x: 10, y: 10 });\n        expect(onChange).toHaveBeenCalledWith({\n          from: xyLabel(10, 10, 'A'),\n          to: xyLabel(11, 11, 'B'),\n        });\n\n        // wil change and will keep labels\n        w.instance().dragCircle({ x: 2, y: 2 });\n        expect(onChange).toHaveBeenCalledWith({\n          from: xyLabel(2, 2, 'A'),\n          to: xyLabel(3, 3, 'B'),\n        });\n      });\n    });\n\n    describe('labelChange', () => {\n      it('updates \"label\" property for point', () => {\n        w = wrapperWithLabels({ labelModeEnabled: true });\n\n        w.instance().labelChange(xyLabel(0, 0, 'Label A'), 'from');\n        expect(changeMarkProps).toBeCalledWith({\n          from: xyLabel(0, 0, 'Label A'),\n        });\n\n        w.instance().labelChange(xyLabel(0, 0, 'Label B'), 'to');\n        expect(changeMarkProps).toBeCalledWith({\n          to: xyLabel(0, 0, 'Label B'),\n        });\n      });\n\n      it('removes \"label\" property if the field is empty', () => {\n        w = wrapperWithLabels({ labelModeEnabled: true });\n\n        w.instance().labelChange(xyLabel(0, 0, ''), 'from');\n        expect(changeMarkProps).toBeCalledWith({\n          from: xy(0, 0),\n        });\n\n        w.instance().labelChange(xyLabel(0, 0, ''), 'to');\n        expect(changeMarkProps).toBeCalledWith({\n          to: xy(0, 0),\n        });\n      });\n    });\n\n    describe('clickPoint', () => {\n      it('adds \"label\" property to a point', () => {\n        w = wrapperWithLabels({ labelModeEnabled: true });\n\n        w.instance().clickPoint(xy(0, 0), 'from');\n        expect(changeMarkProps).toBeCalledWith({\n          from: xyLabel(0, 0, ''),\n          to: xyLabel(1, 1, 'B'),\n        });\n\n        w.instance().clickPoint(xy(1, 1), 'to');\n        expect(changeMarkProps).toBeCalledWith({\n          from: xyLabel(0, 0, 'A'),\n          to: xyLabel(1, 1, ''),\n        });\n      });\n\n      it('adds \"label\" property to a point when limit labeling', () => {\n        const changeMarkProps = jest.fn();\n        w = wrapperWithLabels({ labelModeEnabled: true, limitLabeling: true, changeMarkProps });\n\n        w.instance().clickPoint(xy(0, 0), 'from');\n        expect(changeMarkProps).toHaveBeenCalledTimes(0);\n      });\n\n      it('if point already has label, keeps that value', () => {\n        w = wrapperWithLabels({ labelModeEnabled: true });\n\n        w.instance().clickPoint(fromWithLabel, 'from');\n        expect(changeMarkProps).toBeCalledWith({\n          from: fromWithLabel,\n          to: xyLabel(1, 1, 'B'),\n        });\n\n        w.instance().clickPoint(toWithLabel, 'to');\n        expect(changeMarkProps).toBeCalledWith({\n          from: xyLabel(0, 0, 'A'),\n          to: toWithLabel,\n        });\n      });\n    });\n  });\n});\n"]}

package/lib/tools/exponential/__tests__/component.test.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _withRootEdge = require("../../shared/line/with-root-edge");
+
+var _graphingUtils = require("@pie-lib/graphing-utils");
+
+var _plot = require("@pie-lib/plot");
+
+var _utils = require("../../../__tests__/utils");
+
+var xy = _plot.utils.xy;
+jest.mock('@pie-lib/graphing-utils', function () {
+  return {
+    buildDataPoints: jest.fn().mockReturnValue([]),
+    exponentialFromTwoPoints: jest.fn(function () {
+      return jest.fn();
+    }),
+    getAmplitudeAndFreq: jest.fn().mockReturnValue({
+      freq: 4,
+      amplitude: 1
+    })
+  };
+});
+jest.mock("../../shared/line/with-root-edge", function () {
+  return {
+    withRootEdge: jest.fn(),
+    rootEdgeComponent: jest.fn()
+  };
+});
+describe('Exponential', function () {
+  var fnBody;
+  var graphProps;
+  var root;
+  var edge;
+  var result;
+  beforeEach(function () {
+    require("../component");
+
+    fnBody = _withRootEdge.withRootEdge.mock.calls[0][0];
+    graphProps = (0, _utils.graphProps)();
+    root = xy(1, 1);
+    edge = xy(2, 2);
+    result = fnBody({
+      graphProps: graphProps,
+      root: root,
+      edge: edge
+    });
+  });
+  it('fnBody is not null', function () {
+    expect(fnBody).toBeDefined();
+  });
+  it('calls buildDataPoints', function () {
+    var _graphProps = graphProps,
+        domain = _graphProps.domain,
+        range = _graphProps.range;
+    expect(_graphingUtils.buildDataPoints).toHaveBeenCalledWith(domain, range, root, edge, expect.anything(), true);
+  });
+  it('calls exponentialFromTwoPoints', function () {
+    expect(_graphingUtils.exponentialFromTwoPoints).toHaveBeenCalledWith(root, edge);
+  });
+  it('returns dataPoints', function () {
+    expect(result).toEqual({
+      root: root,
+      edge: edge,
+      dataPoints: []
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90b29scy9leHBvbmVudGlhbC9fX3Rlc3RzX18vY29tcG9uZW50LnRlc3QuanN4Il0sIm5hbWVzIjpbInh5IiwidXRpbHMiLCJqZXN0IiwibW9jayIsImJ1aWxkRGF0YVBvaW50cyIsImZuIiwibW9ja1JldHVyblZhbHVlIiwiZXhwb25lbnRpYWxGcm9tVHdvUG9pbnRzIiwiZ2V0QW1wbGl0dWRlQW5kRnJlcSIsImZyZXEiLCJhbXBsaXR1ZGUiLCJ3aXRoUm9vdEVkZ2UiLCJyb290RWRnZUNvbXBvbmVudCIsImRlc2NyaWJlIiwiZm5Cb2R5IiwiZ3JhcGhQcm9wcyIsInJvb3QiLCJlZGdlIiwicmVzdWx0IiwiYmVmb3JlRWFjaCIsInJlcXVpcmUiLCJjYWxscyIsIml0IiwiZXhwZWN0IiwidG9CZURlZmluZWQiLCJkb21haW4iLCJyYW5nZSIsInRvSGF2ZUJlZW5DYWxsZWRXaXRoIiwiYW55dGhpbmciLCJ0b0VxdWFsIiwiZGF0YVBvaW50cyJdLCJtYXBwaW5ncyI6Ijs7OztBQUFBOztBQUNBOztBQUNBOztBQUNBOztBQUVBOztBQUVBLElBQVFBLEVBQVIsR0FBZUMsV0FBZixDQUFRRCxFQUFSO0FBRUFFLElBQUksQ0FBQ0MsSUFBTCxDQUFVLHlCQUFWLEVBQXFDO0FBQUEsU0FBTztBQUMxQ0MsSUFBQUEsZUFBZSxFQUFFRixJQUFJLENBQUNHLEVBQUwsR0FBVUMsZUFBVixDQUEwQixFQUExQixDQUR5QjtBQUUxQ0MsSUFBQUEsd0JBQXdCLEVBQUVMLElBQUksQ0FBQ0csRUFBTCxDQUFRO0FBQUEsYUFBTUgsSUFBSSxDQUFDRyxFQUFMLEVBQU47QUFBQSxLQUFSLENBRmdCO0FBRzFDRyxJQUFBQSxtQkFBbUIsRUFBRU4sSUFBSSxDQUFDRyxFQUFMLEdBQVVDLGVBQVYsQ0FBMEI7QUFBRUcsTUFBQUEsSUFBSSxFQUFFLENBQVI7QUFBV0MsTUFBQUEsU0FBUyxFQUFFO0FBQXRCLEtBQTFCO0FBSHFCLEdBQVA7QUFBQSxDQUFyQztBQU1BUixJQUFJLENBQUNDLElBQUwscUNBQThDO0FBQUEsU0FBTztBQUNuRFEsSUFBQUEsWUFBWSxFQUFFVCxJQUFJLENBQUNHLEVBQUwsRUFEcUM7QUFFbkRPLElBQUFBLGlCQUFpQixFQUFFVixJQUFJLENBQUNHLEVBQUw7QUFGZ0MsR0FBUDtBQUFBLENBQTlDO0FBS0FRLFFBQVEsQ0FBQyxhQUFELEVBQWdCLFlBQU07QUFDNUIsTUFBSUMsTUFBSjtBQUNBLE1BQUlDLFVBQUo7QUFDQSxNQUFJQyxJQUFKO0FBQ0EsTUFBSUMsSUFBSjtBQUNBLE1BQUlDLE1BQUo7QUFFQUMsRUFBQUEsVUFBVSxDQUFDLFlBQU07QUFDZkMsSUFBQUEsT0FBTyxnQkFBUDs7QUFDQU4sSUFBQUEsTUFBTSxHQUFHSCwyQkFBYVIsSUFBYixDQUFrQmtCLEtBQWxCLENBQXdCLENBQXhCLEVBQTJCLENBQTNCLENBQVQ7QUFDQU4sSUFBQUEsVUFBVSxHQUFHLHdCQUFiO0FBQ0FDLElBQUFBLElBQUksR0FBR2hCLEVBQUUsQ0FBQyxDQUFELEVBQUksQ0FBSixDQUFUO0FBQ0FpQixJQUFBQSxJQUFJLEdBQUdqQixFQUFFLENBQUMsQ0FBRCxFQUFJLENBQUosQ0FBVDtBQUVBa0IsSUFBQUEsTUFBTSxHQUFHSixNQUFNLENBQUM7QUFBRUMsTUFBQUEsVUFBVSxFQUFWQSxVQUFGO0FBQWNDLE1BQUFBLElBQUksRUFBSkEsSUFBZDtBQUFvQkMsTUFBQUEsSUFBSSxFQUFKQTtBQUFwQixLQUFELENBQWY7QUFDRCxHQVJTLENBQVY7QUFVQUssRUFBQUEsRUFBRSxDQUFDLG9CQUFELEVBQXVCLFlBQU07QUFDN0JDLElBQUFBLE1BQU0sQ0FBQ1QsTUFBRCxDQUFOLENBQWVVLFdBQWY7QUFDRCxHQUZDLENBQUY7QUFJQUYsRUFBQUEsRUFBRSxDQUFDLHVCQUFELEVBQTBCLFlBQU07QUFDaEMsc0JBQTBCUCxVQUExQjtBQUFBLFFBQVFVLE1BQVIsZUFBUUEsTUFBUjtBQUFBLFFBQWdCQyxLQUFoQixlQUFnQkEsS0FBaEI7QUFDQUgsSUFBQUEsTUFBTSxDQUFDbkIsOEJBQUQsQ0FBTixDQUF3QnVCLG9CQUF4QixDQUE2Q0YsTUFBN0MsRUFBcURDLEtBQXJELEVBQTREVixJQUE1RCxFQUFrRUMsSUFBbEUsRUFBd0VNLE1BQU0sQ0FBQ0ssUUFBUCxFQUF4RSxFQUEyRixJQUEzRjtBQUNELEdBSEMsQ0FBRjtBQUtBTixFQUFBQSxFQUFFLENBQUMsZ0NBQUQsRUFBbUMsWUFBTTtBQUN6Q0MsSUFBQUEsTUFBTSxDQUFDaEIsdUNBQUQsQ0FBTixDQUFpQ29CLG9CQUFqQyxDQUFzRFgsSUFBdEQsRUFBNERDLElBQTVEO0FBQ0QsR0FGQyxDQUFGO0FBSUFLLEVBQUFBLEVBQUUsQ0FBQyxvQkFBRCxFQUF1QixZQUFNO0FBQzdCQyxJQUFBQSxNQUFNLENBQUNMLE1BQUQsQ0FBTixDQUFlVyxPQUFmLENBQXVCO0FBQUViLE1BQUFBLElBQUksRUFBSkEsSUFBRjtBQUFRQyxNQUFBQSxJQUFJLEVBQUpBLElBQVI7QUFBY2EsTUFBQUEsVUFBVSxFQUFFO0FBQTFCLEtBQXZCO0FBQ0QsR0FGQyxDQUFGO0FBR0QsQ0FqQ08sQ0FBUiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCBmcm9tICdyZWFjdCc7XG5pbXBvcnQgeyB3aXRoUm9vdEVkZ2UgfSBmcm9tICcuLi8uLi9zaGFyZWQvbGluZS93aXRoLXJvb3QtZWRnZSc7XG5pbXBvcnQgeyBidWlsZERhdGFQb2ludHMsIGV4cG9uZW50aWFsRnJvbVR3b1BvaW50cyB9IGZyb20gJ0BwaWUtbGliL2dyYXBoaW5nLXV0aWxzJztcbmltcG9ydCB7IHV0aWxzIH0gZnJvbSAnQHBpZS1saWIvcGxvdCc7XG5cbmltcG9ydCB7IGdyYXBoUHJvcHMgYXMgZ2V0R3JhcGhQcm9wcyB9IGZyb20gJy4uLy4uLy4uL19fdGVzdHNfXy91dGlscyc7XG5cbmNvbnN0IHsgeHkgfSA9IHV0aWxzO1xuXG5qZXN0Lm1vY2soJ0BwaWUtbGliL2dyYXBoaW5nLXV0aWxzJywgKCkgPT4gKHtcbiAgYnVpbGREYXRhUG9pbnRzOiBqZXN0LmZuKCkubW9ja1JldHVyblZhbHVlKFtdKSxcbiAgZXhwb25lbnRpYWxGcm9tVHdvUG9pbnRzOiBqZXN0LmZuKCgpID0+IGplc3QuZm4oKSksXG4gIGdldEFtcGxpdHVkZUFuZEZyZXE6IGplc3QuZm4oKS5tb2NrUmV0dXJuVmFsdWUoeyBmcmVxOiA0LCBhbXBsaXR1ZGU6IDEgfSksXG59KSk7XG5cbmplc3QubW9jaygnLi4vLi4vc2hhcmVkL2xpbmUvd2l0aC1yb290LWVkZ2UnLCAoKSA9PiAoe1xuICB3aXRoUm9vdEVkZ2U6IGplc3QuZm4oKSxcbiAgcm9vdEVkZ2VDb21wb25lbnQ6IGplc3QuZm4oKSxcbn0pKTtcblxuZGVzY3JpYmUoJ0V4cG9uZW50aWFsJywgKCkgPT4ge1xuICBsZXQgZm5Cb2R5O1xuICBsZXQgZ3JhcGhQcm9wcztcbiAgbGV0IHJvb3Q7XG4gIGxldCBlZGdlO1xuICBsZXQgcmVzdWx0O1xuXG4gIGJlZm9yZUVhY2goKCkgPT4ge1xuICAgIHJlcXVpcmUoJy4uL2NvbXBvbmVudCcpO1xuICAgIGZuQm9keSA9IHdpdGhSb290RWRnZS5tb2NrLmNhbGxzWzBdWzBdO1xuICAgIGdyYXBoUHJvcHMgPSBnZXRHcmFwaFByb3BzKCk7XG4gICAgcm9vdCA9IHh5KDEsIDEpO1xuICAgIGVkZ2UgPSB4eSgyLCAyKTtcblxuICAgIHJlc3VsdCA9IGZuQm9keSh7IGdyYXBoUHJvcHMsIHJvb3QsIGVkZ2UgfSk7XG4gIH0pO1xuXG4gIGl0KCdmbkJvZHkgaXMgbm90IG51bGwnLCAoKSA9PiB7XG4gICAgZXhwZWN0KGZuQm9keSkudG9CZURlZmluZWQoKTtcbiAgfSk7XG5cbiAgaXQoJ2NhbGxzIGJ1aWxkRGF0YVBvaW50cycsICgpID0+IHtcbiAgICBjb25zdCB7IGRvbWFpbiwgcmFuZ2UgfSA9IGdyYXBoUHJvcHM7XG4gICAgZXhwZWN0KGJ1aWxkRGF0YVBvaW50cykudG9IYXZlQmVlbkNhbGxlZFdpdGgoZG9tYWluLCByYW5nZSwgcm9vdCwgZWRnZSwgZXhwZWN0LmFueXRoaW5nKCksIHRydWUpO1xuICB9KTtcblxuICBpdCgnY2FsbHMgZXhwb25lbnRpYWxGcm9tVHdvUG9pbnRzJywgKCkgPT4ge1xuICAgIGV4cGVjdChleHBvbmVudGlhbEZyb21Ud29Qb2ludHMpLnRvSGF2ZUJlZW5DYWxsZWRXaXRoKHJvb3QsIGVkZ2UpO1xuICB9KTtcblxuICBpdCgncmV0dXJucyBkYXRhUG9pbnRzJywgKCkgPT4ge1xuICAgIGV4cGVjdChyZXN1bHQpLnRvRXF1YWwoeyByb290LCBlZGdlLCBkYXRhUG9pbnRzOiBbXSB9KTtcbiAgfSk7XG59KTtcbiJdfQ==

package/lib/tools/line/__tests__/component.test.js

@@ -0,0 +1,56 @@
+"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 _component = require("../component");
+
+var _utils = require("../../../__tests__/utils");
+
+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; }
+
+jest.mock('@pie-lib/plot/index', function () {
+  var a = jest.requireActual('@pie-lib/plot/index');
+  return {
+    types: a.types,
+    gridDraggable: a.gridDraggable,
+    utils: a.utils,
+    trig: {
+      edges: jest.fn(function () {
+        return jest.fn().mockReturnValue([0, 0]);
+      })
+    }
+  };
+});
+describe('ArrowedLine', function () {
+  var w;
+  var onChange = jest.fn();
+
+  var wrapper = function wrapper(extras) {
+    var defaults = {
+      classes: {},
+      className: 'className',
+      onChange: onChange,
+      markerId: '1',
+      graphProps: (0, _utils.graphProps)()
+    };
+
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_component.ArrowedLine, props));
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      expect(wrapper()).toMatchSnapshot();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/tools/parabola/__tests__/component.test.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _withRootEdge = require("../../shared/line/with-root-edge");
+
+var _graphingUtils = require("@pie-lib/graphing-utils");
+
+var _plot = require("@pie-lib/plot");
+
+var _utils = require("../../../__tests__/utils");
+
+var xy = _plot.utils.xy;
+jest.mock('@pie-lib/graphing-utils', function () {
+  return {
+    buildDataPoints: jest.fn().mockReturnValue([]),
+    parabolaFromTwoPoints: jest.fn(function () {
+      return jest.fn();
+    }),
+    getAmplitudeAndFreq: jest.fn().mockReturnValue({
+      freq: 4,
+      amplitude: 1
+    })
+  };
+});
+jest.mock("../../shared/line/with-root-edge", function () {
+  return {
+    withRootEdge: jest.fn(),
+    rootEdgeComponent: jest.fn()
+  };
+});
+describe('Parabola', function () {
+  var fnBody;
+  var graphProps;
+  var root;
+  var edge;
+  var result;
+  beforeEach(function () {
+    require("../component");
+
+    fnBody = _withRootEdge.withRootEdge.mock.calls[0][0];
+    graphProps = (0, _utils.graphProps)();
+    root = xy(0, 0);
+    edge = xy(1, 1);
+    result = fnBody({
+      graphProps: graphProps,
+      root: root,
+      edge: edge
+    });
+  });
+  it('fnBody is not null', function () {
+    expect(fnBody).toBeDefined();
+  });
+  it('calls buildDataPoints', function () {
+    var _graphProps = graphProps,
+        domain = _graphProps.domain,
+        range = _graphProps.range;
+    expect(_graphingUtils.buildDataPoints).toHaveBeenCalledWith(domain, range, root, edge, expect.anything(), true);
+  });
+  it('calls parabolaFromTwoPoints', function () {
+    expect(_graphingUtils.parabolaFromTwoPoints).toHaveBeenCalledWith(root, edge);
+  });
+  it('returns dataPoints', function () {
+    expect(result).toEqual({
+      root: root,
+      edge: edge,
+      dataPoints: []
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/tools/point/__tests__/component.test.js

@@ -0,0 +1,97 @@
+"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 _utils = require("../../../__tests__/utils");
+
+var _component = _interopRequireDefault(require("../component"));
+
+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; }
+
+describe('Component', function () {
+  var w;
+  var onChange = jest.fn();
+
+  var wrapper = function wrapper(extras, opts) {
+    var defaults = {
+      classes: {},
+      className: 'className',
+      onChange: onChange,
+      graphProps: (0, _utils.graphProps)()
+    };
+
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_component["default"], props), opts);
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+  });
+  describe('logic', function () {
+    describe('move', function () {
+      it('calls onChange', function () {
+        var w = wrapper({
+          mark: _objectSpread({}, (0, _utils.xy)(0, 0))
+        });
+        w.instance().move({
+          x: 1,
+          y: 1
+        });
+        expect(w.state('mark')).toMatchObject(_objectSpread({}, (0, _utils.xy)(1, 1)));
+      });
+    });
+    describe('labelChange', function () {
+      it('callsOnChange with label removed', function () {
+        var mark = {
+          label: 'foo'
+        };
+        var update = {};
+        var w = wrapper({
+          mark: mark
+        });
+        w.instance().labelChange(undefined);
+        expect(onChange).toHaveBeenCalledWith(mark, update);
+      });
+    });
+    describe('clickPoint', function () {
+      var mark;
+      var w;
+      beforeEach(function () {
+        mark = {
+          label: 'foo'
+        };
+        w = wrapper({
+          mark: mark,
+          labelModeEnabled: true
+        }, {
+          disableLifecycleMethods: true
+        });
+        w.instance().input = {
+          focus: jest.fn()
+        };
+        w.instance().clickPoint();
+      });
+      it('calls onChange if labelModeEnabeld', function () {
+        expect(onChange).toHaveBeenCalledWith(mark, _objectSpread({
+          label: ''
+        }, mark));
+      });
+      it('calls input.focus', function () {
+        expect(w.instance().input.focus).toHaveBeenCalled();
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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