@pie-lib/graphing-solution-set 2.16.0-beta.0

package/lib/tools/shared/line/line-path.js

@@ -0,0 +1,145 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RawLinePath = exports.LinePath = void 0;
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _styles = require("@material-ui/core/styles");
+
+var _plot = require("@pie-lib/plot");
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _styles2 = require("../styles");
+
+var vx = _interopRequireWildcard(require("@vx/shape"));
+
+var _renderUi = require("@pie-lib/render-ui");
+
+var _excluded = ["data", "classes", "className", "disabled", "correctness", "from", "to", "graphProps", "isDragging"];
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var RawLinePath = /*#__PURE__*/function (_React$Component) {
+  (0, _inherits2["default"])(RawLinePath, _React$Component);
+
+  var _super = _createSuper(RawLinePath);
+
+  function RawLinePath() {
+    (0, _classCallCheck2["default"])(this, RawLinePath);
+    return _super.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(RawLinePath, [{
+    key: "render",
+    value: function render() {
+      /* eslint-disable no-unused-vars */
+      var _this$props = this.props,
+          data = _this$props.data,
+          classes = _this$props.classes,
+          className = _this$props.className,
+          disabled = _this$props.disabled,
+          correctness = _this$props.correctness,
+          from = _this$props.from,
+          to = _this$props.to,
+          graphProps = _this$props.graphProps,
+          isDragging = _this$props.isDragging,
+          rest = (0, _objectWithoutProperties2["default"])(_this$props, _excluded);
+      /* eslint-enable */
+
+      return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(vx.LinePath, (0, _extends2["default"])({
+        data: data,
+        className: (0, _classnames["default"])(classes.drawLine, disabled && classes.disabled, classes[correctness], className)
+      }, rest)), /*#__PURE__*/_react["default"].createElement(vx.LinePath, (0, _extends2["default"])({
+        data: data,
+        className: (0, _classnames["default"])(classes.line, isDragging && classes.dragging, disabled && classes.disabled, classes[correctness], className)
+      }, rest)));
+    }
+  }]);
+  return RawLinePath;
+}(_react["default"].Component);
+
+exports.RawLinePath = RawLinePath;
+(0, _defineProperty2["default"])(RawLinePath, "propTypes", {
+  className: _propTypes["default"].string,
+  classes: _propTypes["default"].object,
+  data: _propTypes["default"].arrayOf(_propTypes["default"].arrayOf(_propTypes["default"].number)),
+  graphProps: _plot.types.GraphPropsType.isRequired,
+  disabled: _propTypes["default"].bool,
+  correctness: _propTypes["default"].string,
+  from: _plot.types.PointType,
+  to: _plot.types.PointType,
+  isDragging: _propTypes["default"].bool
+});
+(0, _defineProperty2["default"])(RawLinePath, "defaultProps", {
+  from: {},
+  to: {}
+});
+
+var dragging = function dragging() {
+  return {
+    strokeWidth: 7,
+    stroke: _renderUi.color.defaults.BLACK
+  };
+};
+
+var LinePath = (0, _styles.withStyles)(function (theme) {
+  return {
+    drawLine: {
+      fill: 'none',
+      strokeWidth: 2,
+      stroke: _renderUi.color.secondaryLight()
+    },
+    line: {
+      strokeWidth: 6,
+      fill: 'none',
+      transition: 'stroke-width 200ms ease-in, stroke 200ms ease-in',
+      stroke: 'transparent',
+      '&:hover': dragging(theme)
+    },
+    dragging: dragging(theme),
+    disabled: _objectSpread(_objectSpread({}, (0, _styles2.disabled)('stroke')), {}, {
+      strokeWidth: 2
+    }),
+    correct: _objectSpread({}, (0, _styles2.correct)('stroke')),
+    incorrect: _objectSpread({}, (0, _styles2.incorrect)('stroke')),
+    missing: _objectSpread({}, (0, _styles2.missing)('stroke'))
+  };
+})(RawLinePath);
+exports.LinePath = LinePath;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/tools/shared/line/with-root-edge.js

@@ -0,0 +1,155 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.withRootEdge = exports.rootEdgeToFromToWrapper = exports.rootEdgeComponent = void 0;
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _plot = require("@pie-lib/plot");
+
+var _linePath = require("./line-path");
+
+var _curve = require("@vx/curve");
+
+var _index = require("./index");
+
+var _excluded = ["graphProps", "from", "to", "onClick", "onDragStart", "onDragStop", "onChange", "disabled", "correctness"];
+
+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 toRootEdge = function toRootEdge(m) {
+  var out = _objectSpread({}, m);
+
+  out.root = _objectSpread({}, m.from);
+  out.edge = m.to ? _objectSpread({}, m.to) : undefined;
+  delete out.from;
+  delete out.to;
+  return out;
+};
+
+var toFromTo = function toFromTo(m) {
+  var out = _objectSpread({}, m);
+
+  out.from = _objectSpread({}, m.root);
+  out.to = m.edge ? _objectSpread({}, m.edge) : undefined;
+  delete out.root;
+  delete out.edge;
+  return out;
+};
+
+var rootEdgeToFromToWrapper = function rootEdgeToFromToWrapper(BaseComp) {
+  var Wrapper = function Wrapper(props) {
+    var m = toFromTo(props.mark);
+
+    var onChange = function onChange(current, next) {
+      props.onChange(toRootEdge(current), toRootEdge(next));
+    };
+
+    return /*#__PURE__*/_react["default"].createElement(BaseComp, (0, _extends2["default"])({}, props, {
+      mark: m,
+      onChange: onChange
+    }));
+  };
+
+  Wrapper.propTypes = {
+    onChange: _propTypes["default"].func,
+    mark: _propTypes["default"].object
+  };
+  return Wrapper;
+};
+
+exports.rootEdgeToFromToWrapper = rootEdgeToFromToWrapper;
+
+var rootEdgeComponent = function rootEdgeComponent(RootEdgeComp) {
+  var BaseComponent = (0, _index.lineToolComponent)(RootEdgeComp);
+  return rootEdgeToFromToWrapper(BaseComponent);
+};
+
+exports.rootEdgeComponent = rootEdgeComponent;
+
+var withPointsGenerationLinePath = function withPointsGenerationLinePath(getPoints) {
+  var LinePathComponent = function LinePathComponent(props) {
+    var graphProps = props.graphProps,
+        from = props.from,
+        to = props.to,
+        onClick = props.onClick,
+        onDragStart = props.onDragStart,
+        onDragStop = props.onDragStop,
+        onChange = props.onChange,
+        disabled = props.disabled,
+        correctness = props.correctness,
+        rest = (0, _objectWithoutProperties2["default"])(props, _excluded);
+
+    var _getPoints = getPoints({
+      graphProps: props.graphProps,
+      root: from,
+      edge: to
+    }),
+        dataPoints = _getPoints.dataPoints,
+        _getPoints$enableCurv = _getPoints.enableCurve,
+        enableCurve = _getPoints$enableCurv === void 0 ? true : _getPoints$enableCurv;
+
+    var raw = dataPoints.map(function (d) {
+      return [graphProps.scale.x(d.x), graphProps.scale.y(d.y)];
+    });
+    var common = {
+      onClick: onClick,
+      graphProps: graphProps,
+      onDragStart: onDragStart,
+      onDragStop: onDragStop,
+      onChange: onChange,
+      disabled: disabled,
+      correctness: correctness
+    };
+
+    if (!enableCurve) {
+      return /*#__PURE__*/_react["default"].createElement(_linePath.LinePath, (0, _extends2["default"])({
+        data: raw,
+        from: from,
+        to: to
+      }, common, rest));
+    } else {
+      return /*#__PURE__*/_react["default"].createElement(_linePath.LinePath, (0, _extends2["default"])({
+        data: raw,
+        from: from,
+        to: to,
+        curve: _curve.curveMonotoneX
+      }, common, rest));
+    }
+  };
+
+  LinePathComponent.propTypes = {
+    graphProps: _plot.types.GraphPropsType.isRequired,
+    from: _plot.types.PointType.isRequired,
+    to: _plot.types.PointType,
+    onClick: _propTypes["default"].func,
+    onDragStart: _propTypes["default"].func,
+    onDragStop: _propTypes["default"].func,
+    onChange: _propTypes["default"].func,
+    disabled: _propTypes["default"].bool,
+    correctness: _propTypes["default"].string
+  };
+  return LinePathComponent;
+};
+
+var withRootEdge = function withRootEdge(getPoints) {
+  var LinePathComp = withPointsGenerationLinePath(getPoints);
+  return (0, _index.lineBase)(LinePathComp);
+};
+
+exports.withRootEdge = withRootEdge;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/tools/shared/line/with-root-edge.jsx"],"names":["toRootEdge","m","out","root","from","edge","to","undefined","toFromTo","rootEdgeToFromToWrapper","BaseComp","Wrapper","props","mark","onChange","current","next","propTypes","PropTypes","func","object","rootEdgeComponent","RootEdgeComp","BaseComponent","withPointsGenerationLinePath","getPoints","LinePathComponent","graphProps","onClick","onDragStart","onDragStop","disabled","correctness","rest","dataPoints","enableCurve","raw","map","d","scale","x","y","common","curveMonotoneX","types","GraphPropsType","isRequired","PointType","bool","string","withRootEdge","LinePathComp"],"mappings":"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","sourcesContent":["import React from 'react';\nimport PropTypes from 'prop-types';\nimport { types } from '@pie-lib/plot';\nimport { LinePath } from './line-path';\nimport { curveMonotoneX } from '@vx/curve';\nimport { lineBase, lineToolComponent } from './index';\n\nconst toRootEdge = (m) => {\n  const out = { ...m };\n  out.root = { ...m.from };\n  out.edge = m.to ? { ...m.to } : undefined;\n  delete out.from;\n  delete out.to;\n  return out;\n};\n\nconst toFromTo = (m) => {\n  const out = { ...m };\n  out.from = { ...m.root };\n  out.to = m.edge ? { ...m.edge } : undefined;\n  delete out.root;\n  delete out.edge;\n  return out;\n};\n\nexport const rootEdgeToFromToWrapper = (BaseComp) => {\n  const Wrapper = (props) => {\n    const m = toFromTo(props.mark);\n\n    const onChange = (current, next) => {\n      props.onChange(toRootEdge(current), toRootEdge(next));\n    };\n\n    return <BaseComp {...props} mark={m} onChange={onChange} />;\n  };\n\n  Wrapper.propTypes = {\n    onChange: PropTypes.func,\n    mark: PropTypes.object,\n  };\n\n  return Wrapper;\n};\n\nexport const rootEdgeComponent = (RootEdgeComp) => {\n  const BaseComponent = lineToolComponent(RootEdgeComp);\n  return rootEdgeToFromToWrapper(BaseComponent);\n};\n\nconst withPointsGenerationLinePath = (getPoints) => {\n  const LinePathComponent = (props) => {\n    const { graphProps, from, to, onClick, onDragStart, onDragStop, onChange, disabled, correctness, ...rest } = props;\n\n    const { dataPoints, enableCurve = true } = getPoints({\n      graphProps: props.graphProps,\n      root: from,\n      edge: to,\n    });\n\n    const raw = dataPoints.map((d) => [graphProps.scale.x(d.x), graphProps.scale.y(d.y)]);\n\n    const common = {\n      onClick,\n      graphProps,\n      onDragStart,\n      onDragStop,\n      onChange,\n      disabled,\n      correctness,\n    };\n\n    if (!enableCurve) {\n      return <LinePath data={raw} from={from} to={to} {...common} {...rest} />;\n    } else {\n      return <LinePath data={raw} from={from} to={to} curve={curveMonotoneX} {...common} {...rest} />;\n    }\n  };\n\n  LinePathComponent.propTypes = {\n    graphProps: types.GraphPropsType.isRequired,\n    from: types.PointType.isRequired,\n    to: types.PointType,\n    onClick: PropTypes.func,\n    onDragStart: PropTypes.func,\n    onDragStop: PropTypes.func,\n    onChange: PropTypes.func,\n    disabled: PropTypes.bool,\n    correctness: PropTypes.string,\n  };\n\n  return LinePathComponent;\n};\n\nexport const withRootEdge = (getPoints) => {\n  const LinePathComp = withPointsGenerationLinePath(getPoints);\n  return lineBase(LinePathComp);\n};\n"]}

package/lib/tools/shared/point/__tests__/arrow-point.test.js

@@ -0,0 +1,137 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _build = require("enzyme/build");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _index = require("../index");
+
+var _utils = require("../../../../__tests__/utils");
+
+var _utils2 = require("../../../../utils");
+
+var _plot = require("@pie-lib/plot");
+
+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 xy = _plot.utils.xy;
+jest.mock('../../../../utils', function () {
+  var _jest$requireActual = jest.requireActual('../../../../utils'),
+      point = _jest$requireActual.point;
+
+  return {
+    bounds: jest.fn(),
+    point: point
+  };
+});
+jest.mock('@pie-lib/plot/index', function () {
+  var _jest$requireActual2 = jest.requireActual('@pie-lib/plot/index'),
+      types = _jest$requireActual2.types,
+      utils = _jest$requireActual2.utils;
+
+  return {
+    gridDraggable: jest.fn(function (opts) {
+      return function (Comp) {
+        return Comp;
+      };
+    }),
+    types: types,
+    utils: utils
+  };
+});
+describe('ArrowPoint', function () {
+  var w;
+  var onChange = jest.fn();
+
+  var wrapper = function wrapper(extras) {
+    var defaults = {
+      classes: {},
+      className: 'className',
+      onChange: onChange,
+      graphProps: (0, _utils.graphProps)(),
+      from: xy(0, 0),
+      to: xy(1, 1)
+    };
+
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+    return (0, _build.shallow)( /*#__PURE__*/_react["default"].createElement(_index.ArrowPoint, props));
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+  });
+  describe('gridDraggable options', function () {
+    var opts;
+    var domain;
+    var range;
+    beforeEach(function () {
+      domain = {
+        min: 0,
+        max: 1,
+        step: 1
+      };
+      range = {
+        min: 0,
+        max: 1,
+        step: 1
+      };
+      var w = wrapper();
+      opts = _plot.gridDraggable.mock.calls[0][0];
+    });
+    describe('bounds', function () {
+      it('calls utils.bounds with area', function () {
+        var result = opts.bounds({
+          x: 0,
+          y: 0
+        }, {
+          domain: domain,
+          range: range
+        });
+        expect(_utils2.bounds).toHaveBeenCalledWith({
+          left: 0,
+          top: 0,
+          bottom: 0,
+          right: 0
+        }, domain, range);
+      });
+    });
+    describe('anchorPoint', function () {
+      it('returns x/y', function () {
+        var result = opts.anchorPoint({
+          x: 0,
+          y: 0
+        });
+        expect(result).toEqual({
+          x: 0,
+          y: 0
+        });
+      });
+    });
+    describe('fromDelta', function () {
+      it('returns a new point from the x/y + delta', function () {
+        var result = opts.fromDelta({
+          x: -1,
+          y: 0
+        }, {
+          x: 1,
+          y: 3
+        });
+        expect(result).toEqual({
+          x: 0,
+          y: 3
+        });
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/tools/shared/point/__tests__/base-point.test.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _build = require("enzyme/build");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _index = require("../index");
+
+var _plot = require("@pie-lib/plot");
+
+var _utils = require("../../../../__tests__/utils");
+
+var _utils2 = require("../../../../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('../../../../utils', function () {
+  var _jest$requireActual = jest.requireActual('../../../../utils'),
+      point = _jest$requireActual.point;
+
+  return {
+    bounds: jest.fn(),
+    point: point
+  };
+});
+jest.mock('@pie-lib/plot/index', function () {
+  var _jest$requireActual2 = jest.requireActual('@pie-lib/plot/index'),
+      types = _jest$requireActual2.types,
+      utils = _jest$requireActual2.utils;
+
+  return {
+    gridDraggable: jest.fn(function (opts) {
+      return function (Comp) {
+        return Comp;
+      };
+    }),
+    types: types,
+    utils: utils
+  };
+});
+describe('BasePoint', function () {
+  var w;
+  var onChange = jest.fn();
+
+  var wrapper = function wrapper(extras) {
+    var defaults = {
+      classes: {},
+      className: 'className',
+      onChange: onChange,
+      graphProps: (0, _utils.graphProps)()
+    };
+
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+    return (0, _build.shallow)( /*#__PURE__*/_react["default"].createElement(_index.BasePoint, props));
+  };
+
+  describe('snapshot', function () {
+    it('renders', function () {
+      w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+  });
+  describe('gridDraggable options', function () {
+    var opts;
+    var domain;
+    var range;
+    beforeEach(function () {
+      domain = {
+        min: 0,
+        max: 1,
+        step: 1
+      };
+      range = {
+        min: 0,
+        max: 1,
+        step: 1
+      };
+      var w = wrapper();
+      opts = _plot.gridDraggable.mock.calls[0][0];
+    });
+    describe('bounds', function () {
+      it('calls utils.bounds with area', function () {
+        var result = opts.bounds({
+          x: 0,
+          y: 0
+        }, {
+          domain: domain,
+          range: range
+        });
+        expect(_utils2.bounds).toHaveBeenCalledWith({
+          left: 0,
+          top: 0,
+          bottom: 0,
+          right: 0
+        }, domain, range);
+      });
+    });
+    describe('anchorPoint', function () {
+      it('returns x/y', function () {
+        var result = opts.anchorPoint({
+          x: 0,
+          y: 0
+        });
+        expect(result).toEqual({
+          x: 0,
+          y: 0
+        });
+      });
+    });
+    describe('fromDelta', function () {
+      it('returns a new point from the x/y + delta', function () {
+        var result = opts.fromDelta({
+          x: -1,
+          y: 0
+        }, {
+          x: 1,
+          y: 3
+        });
+        expect(result).toEqual({
+          x: 0,
+          y: 3
+        });
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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