@pie-lib/plot 2.7.4-next.0 → 2.9.0-beta.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.9.0-beta.0](https://github.com/pie-framework/pie-lib/compare/@pie-lib/plot@2.7.3...@pie-lib/plot@2.9.0-beta.0) (2025-07-15)
+
+**Note:** Version bump only for package @pie-lib/plot
+
+
+
+
+
+# [2.8.0-beta.0](https://github.com/pie-framework/pie-lib/compare/@pie-lib/plot@2.7.3...@pie-lib/plot@2.8.0-beta.0) (2025-07-15)
+
+**Note:** Version bump only for package @pie-lib/plot
+
+
+
+
+
 ## [2.7.3](https://github.com/pie-framework/pie-lib/compare/@pie-lib/plot@2.7.2...@pie-lib/plot@2.7.3) (2023-10-16)
 
 

package/NEXT.CHANGELOG.json

@@ -0,0 +1 @@
+[]

package/lib/__tests__/draggable.test.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _react = _interopRequireDefault(require("react"));
+
+var _enzyme = require("enzyme");
+
+var _draggable = _interopRequireDefault(require("../draggable"));
+
+var wrapper = function wrapper() {
+  return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(_draggable["default"], null, /*#__PURE__*/_react["default"].createElement("div", null, "hellow")), {
+    disableLifecycleMethods: true
+  });
+};
+
+describe('draggable', function () {
+  describe('local', function () {
+    it('resets x/y in state', function () {
+      var w = wrapper();
+      w.setState({
+        x: 1,
+        y: 1
+      });
+      w.instance().componentWillReceiveProps({});
+      expect(w.state()).toMatchObject({
+        x: 0,
+        y: 0
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9fX3Rlc3RzX18vZHJhZ2dhYmxlLnRlc3QuanN4Il0sIm5hbWVzIjpbIndyYXBwZXIiLCJkaXNhYmxlTGlmZWN5Y2xlTWV0aG9kcyIsImRlc2NyaWJlIiwiaXQiLCJ3Iiwic2V0U3RhdGUiLCJ4IiwieSIsImluc3RhbmNlIiwiY29tcG9uZW50V2lsbFJlY2VpdmVQcm9wcyIsImV4cGVjdCIsInN0YXRlIiwidG9NYXRjaE9iamVjdCJdLCJtYXBwaW5ncyI6Ijs7OztBQUFBOztBQUNBOztBQUNBOztBQUVBLElBQU1BLE9BQU8sR0FBRyxTQUFWQSxPQUFVLEdBQU07QUFDcEIsU0FBTyxtQ0FDTCxnQ0FBQyxxQkFBRCxxQkFDRSxzREFERixDQURLLEVBSUw7QUFBRUMsSUFBQUEsdUJBQXVCLEVBQUU7QUFBM0IsR0FKSyxDQUFQO0FBTUQsQ0FQRDs7QUFTQUMsUUFBUSxDQUFDLFdBQUQsRUFBYyxZQUFNO0FBQzFCQSxFQUFBQSxRQUFRLENBQUMsT0FBRCxFQUFVLFlBQU07QUFDdEJDLElBQUFBLEVBQUUsQ0FBQyxxQkFBRCxFQUF3QixZQUFNO0FBQzlCLFVBQU1DLENBQUMsR0FBR0osT0FBTyxFQUFqQjtBQUNBSSxNQUFBQSxDQUFDLENBQUNDLFFBQUYsQ0FBVztBQUFFQyxRQUFBQSxDQUFDLEVBQUUsQ0FBTDtBQUFRQyxRQUFBQSxDQUFDLEVBQUU7QUFBWCxPQUFYO0FBQ0FILE1BQUFBLENBQUMsQ0FBQ0ksUUFBRixHQUFhQyx5QkFBYixDQUF1QyxFQUF2QztBQUNBQyxNQUFBQSxNQUFNLENBQUNOLENBQUMsQ0FBQ08sS0FBRixFQUFELENBQU4sQ0FBa0JDLGFBQWxCLENBQWdDO0FBQUVOLFFBQUFBLENBQUMsRUFBRSxDQUFMO0FBQVFDLFFBQUFBLENBQUMsRUFBRTtBQUFYLE9BQWhDO0FBQ0QsS0FMQyxDQUFGO0FBTUQsR0FQTyxDQUFSO0FBUUQsQ0FUTyxDQUFSIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0JztcbmltcG9ydCB7IHNoYWxsb3cgfSBmcm9tICdlbnp5bWUnO1xuaW1wb3J0IERyYWdnYWJsZSBmcm9tICcuLi9kcmFnZ2FibGUnO1xuXG5jb25zdCB3cmFwcGVyID0gKCkgPT4ge1xuICByZXR1cm4gc2hhbGxvdyhcbiAgICA8RHJhZ2dhYmxlPlxuICAgICAgPGRpdj5oZWxsb3c8L2Rpdj5cbiAgICA8L0RyYWdnYWJsZT4sXG4gICAgeyBkaXNhYmxlTGlmZWN5Y2xlTWV0aG9kczogdHJ1ZSB9LFxuICApO1xufTtcblxuZGVzY3JpYmUoJ2RyYWdnYWJsZScsICgpID0+IHtcbiAgZGVzY3JpYmUoJ2xvY2FsJywgKCkgPT4ge1xuICAgIGl0KCdyZXNldHMgeC95IGluIHN0YXRlJywgKCkgPT4ge1xuICAgICAgY29uc3QgdyA9IHdyYXBwZXIoKTtcbiAgICAgIHcuc2V0U3RhdGUoeyB4OiAxLCB5OiAxIH0pO1xuICAgICAgdy5pbnN0YW5jZSgpLmNvbXBvbmVudFdpbGxSZWNlaXZlUHJvcHMoe30pO1xuICAgICAgZXhwZWN0KHcuc3RhdGUoKSkudG9NYXRjaE9iamVjdCh7IHg6IDAsIHk6IDAgfSk7XG4gICAgfSk7XG4gIH0pO1xufSk7XG4iXX0=

package/lib/__tests__/grid-draggable.test.js

@@ -0,0 +1,438 @@
+"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 _gridDraggable = require("../grid-draggable");
+
+var _utils = require("../utils");
+
+var _d3Selection = require("d3-selection");
+
+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('d3-selection', function () {
+  return {
+    clientPoint: jest.fn().mockReturnValue([0, 0])
+  };
+});
+jest.mock('../draggable', function () {
+  return {
+    DraggableCore: jest.fn(function (type, props, children) {
+      return children;
+    })
+  };
+});
+jest.mock('../utils', function () {
+  return {
+    getDelta: jest.fn()
+  };
+});
+
+var xyFn = function xyFn() {
+  var out = jest.fn(function (n) {
+    return n;
+  });
+  out.invert = jest.fn(function (n) {
+    return n;
+  });
+  return out;
+};
+
+var getGraphProps = function getGraphProps() {
+  return {
+    scale: {
+      x: xyFn(),
+      y: xyFn()
+    },
+    snap: {
+      x: xyFn(),
+      y: xyFn()
+    },
+    domain: {
+      min: 0,
+      max: 1,
+      step: 1
+    },
+    range: {
+      min: 0,
+      max: 1,
+      step: 1
+    },
+    size: {
+      width: 500,
+      height: 500
+    },
+    getRootNode: function getRootNode() {
+      return {};
+    }
+  };
+};
+
+describe('gridDraggable', function () {
+  var wrapper = function wrapper(opts, extras) {
+    var defaults = {
+      graphProps: getGraphProps()
+    };
+    defaults.graphProps.scale.x.invert = jest.fn(function (x) {
+      return x;
+    });
+    defaults.graphProps.scale.y.invert = jest.fn(function (x) {
+      return x;
+    });
+
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+
+    opts = _objectSpread({
+      anchorPoint: jest.fn().mockReturnValue({
+        x: 0,
+        y: 0
+      }),
+      bounds: jest.fn().mockReturnValue({
+        left: 0,
+        top: 0,
+        bottom: 0,
+        right: 0
+      }),
+      fromDelta: jest.fn()
+    }, opts);
+    var Comp = (0, _gridDraggable.gridDraggable)(opts)(function () {
+      return /*#__PURE__*/_react["default"].createElement("div", null);
+    });
+    return (0, _enzyme.shallow)( /*#__PURE__*/_react["default"].createElement(Comp, props));
+  };
+
+  describe('snapshot', function () {
+    it('reqular', function () {
+      var w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+    it('render with decimals', function () {
+      var w = wrapper({}, {
+        domain: {
+          min: -1.5,
+          max: 1.6,
+          step: 0.3
+        },
+        range: {
+          min: -2,
+          max: 3,
+          step: 0.2
+        }
+      });
+      expect(w).toMatchSnapshot();
+    });
+  });
+  describe('logic', function () {
+    describe('grid', function () {
+      it('returns the grid', function () {
+        var w = wrapper();
+        var g = w.instance().grid();
+        expect(g).toEqual({
+          x: 1,
+          y: 1
+        });
+      });
+    });
+    describe('onStart', function () {
+      it('sets the drag state', function () {
+        var w = wrapper();
+        w.instance().onStart({
+          clientX: 100,
+          clientY: 100
+        });
+        expect(w.state().startX).toEqual(100);
+        expect(w.state().startY).toEqual(100);
+      });
+      it('calls the handler', function () {
+        var onDragStart = jest.fn();
+        var w = wrapper({}, {
+          onDragStart: onDragStart
+        });
+        w.instance().onStart({
+          clientX: 100,
+          clientY: 100
+        });
+        expect(onDragStart).toHaveBeenCalled();
+      });
+    });
+    describe('position', function () {
+      it('returns position object', function () {
+        var w = wrapper();
+        var pos = w.instance().position();
+        var anchorPoint = {
+          x: 0,
+          y: 0
+        };
+        expect(pos).toEqual({
+          anchorPoint: anchorPoint,
+          x: expect.any(Function),
+          y: expect.any(Function)
+        });
+      });
+    });
+    describe('tiny', function () {
+      it('returns true for 10 ', function () {
+        var w = wrapper();
+        w.setState({
+          startX: 0
+        });
+        var result = w.instance().tiny('x', {
+          clientX: 10
+        });
+        expect(result).toBe(false);
+      });
+      it('returns true for 0.01', function () {
+        var w = wrapper();
+        w.setState({
+          startX: 0
+        });
+        var result = w.instance().tiny('x', {
+          clientX: 0.01
+        });
+        expect(result).toBe(true);
+      });
+    });
+    describe('onDrag', function () {
+      var onDrag, w;
+      beforeEach(function () {
+        onDrag = jest.fn();
+        w = wrapper({}, {
+          onDrag: onDrag
+        });
+        w.instance().applyDelta = jest.fn().mockReturnValue(0);
+        w.instance().props.graphProps.getRootNode = jest.fn().mockReturnValue({
+          ownerSVGElement: null,
+          getBoundingClientRect: jest.fn(function () {
+            return {
+              left: 0,
+              top: 0,
+              right: 100,
+              bottom: 100
+            };
+          })
+        });
+        w.instance().getClientPoint = jest.fn().mockReturnValue([50, 50]); // Mocking getClientPoint
+
+        w.instance().onDrag({}, {
+          x: 1,
+          y: 1
+        });
+      });
+      it('calls applyDelta', function () {
+        expect(w.instance().applyDelta).toHaveBeenCalled();
+      });
+      it('calls callback', function () {
+        expect(onDrag).toHaveBeenCalledWith(0);
+      });
+
+      var bounds = function bounds(left, right, top, bottom) {
+        return {
+          left: left,
+          right: right,
+          top: top,
+          bottom: bottom
+        };
+      };
+
+      describe('bounds', function () {
+        var assertEarlyExit = function assertEarlyExit(bounds, dd) {
+          it("".concat(JSON.stringify(bounds), ", ").concat(dd.deltaX, ", ").concat(dd.deltaY, " "), function () {
+            w = wrapper({}, {
+              onDrag: onDrag
+            });
+            w.instance().getScaledBounds = jest.fn().mockReturnValue(bounds);
+            w.instance().getClientPoint = jest.fn().mockReturnValue([50, 50]);
+            w.instance().onDrag({}, dd);
+            expect(w.instance().getClientPoint).not.toHaveBeenCalled();
+          });
+        };
+
+        assertEarlyExit(bounds(0, 0, 0, 0), {
+          deltaX: -10
+        });
+        assertEarlyExit(bounds(0, 0, 0, 0), {
+          deltaX: 10
+        });
+        assertEarlyExit(bounds(-100, 100, 0, 0), {
+          deltaY: -10
+        });
+        assertEarlyExit(bounds(-100, 100, -100, 0), {
+          deltaY: 10
+        });
+        it('calls client point if it doesnt exit early bounds', function () {
+          w = wrapper({}, {
+            onDrag: onDrag
+          });
+          w.instance().getScaledBounds = jest.fn().mockReturnValue(bounds(100, 100, 100, 100));
+          w.instance().getClientPoint = jest.fn().mockReturnValue([50, 50]);
+          w.instance().onDrag({}, {
+            deltaX: 10
+          });
+          expect(w.instance().getClientPoint).toHaveBeenCalled(); // Asserting that getClientPoint is called
+        });
+      });
+    });
+    describe('skipDragOutsideOfBounds', function () {
+      var w;
+
+      var assertSkipDrag = function assertSkipDrag(dd, rawXFn, rawYFn, expected) {
+        rawXFn = rawXFn || function (x) {
+          return x;
+        };
+
+        rawYFn = rawYFn || function (y) {
+          return y;
+        };
+
+        it("".concat(dd.deltaX, ", ").concat(dd.deltaY, ", ").concat(expected), function () {
+          w = wrapper({});
+          var gp = getGraphProps();
+          var mockGetBoundingClientRect = jest.fn(function () {
+            return {
+              left: 0,
+              top: 0,
+              right: 100,
+              bottom: 100
+            };
+          });
+          w.instance().getClientPoint = jest.fn(function () {
+            return [rawXFn(gp.domain.min, gp.domain.max), rawYFn(gp.range.min, gp.range.max)];
+          });
+          var rootNode = {
+            ownerSVGElement: null,
+            getBoundingClientRect: mockGetBoundingClientRect
+          };
+          var result = w.instance().skipDragOutsideOfBounds(dd, {}, _objectSpread(_objectSpread({}, gp), {}, {
+            getRootNode: function getRootNode() {
+              return rootNode;
+            }
+          }));
+          expect(result).toEqual(expected);
+        });
+      };
+
+      assertSkipDrag({
+        deltaX: 1
+      }, function (min, max) {
+        return min - 1;
+      }, function (min, max) {
+        return min;
+      }, true);
+      assertSkipDrag({
+        deltaX: -1
+      }, function (min, max) {
+        return max + 1;
+      }, function (min, max) {
+        return min;
+      }, true);
+      assertSkipDrag({
+        deltaY: 1
+      }, function (min, max) {
+        return max;
+      }, function (min, max) {
+        return max + 1;
+      }, true);
+      assertSkipDrag({
+        deltaY: -1
+      }, function (min, max) {
+        return max;
+      }, function (min, max) {
+        return min - 1;
+      }, true);
+      assertSkipDrag({
+        deltaY: 1
+      }, function (min, max) {
+        return max;
+      }, function (min, max) {
+        return max;
+      }, false);
+      assertSkipDrag({
+        deltaY: -1
+      }, function (min, max) {
+        return max;
+      }, function (min, max) {
+        return min;
+      }, false);
+    });
+    describe('getDelta', function () {
+      it('calls utils.getDelta', function () {
+        var w = wrapper();
+        w.instance().position = jest.fn().mockReturnValue({
+          anchorPoint: {
+            x: 0,
+            y: 0
+          },
+          x: jest.fn(function (x) {
+            return x;
+          }),
+          y: jest.fn(function (y) {
+            return y;
+          })
+        });
+        w.instance().getDelta({
+          x: 1,
+          y: 1
+        });
+        expect(_utils.getDelta).toHaveBeenCalledWith({
+          x: 0,
+          y: 0
+        }, {
+          x: 1,
+          y: 1
+        });
+      });
+    });
+    describe('applyDelta', function () {
+      it('calls fromDelta', function () {
+        var fromDelta = jest.fn();
+        var w = wrapper({
+          fromDelta: fromDelta
+        });
+        w.instance().getDelta = jest.fn();
+        w.instance().applyDelta({
+          x: 1,
+          y: 1
+        });
+        expect(fromDelta).toHaveBeenCalledWith(expect.anything(), undefined);
+      });
+    });
+    describe('onStop', function () {
+      it('calls onDragStop', function () {
+        var onDragStop = jest.fn();
+        var w = wrapper({}, {
+          onDragStop: onDragStop
+        });
+        w.setState({
+          startX: 0,
+          startY: 0
+        });
+        w.instance().onStop({}, {});
+        expect(onDragStop).toHaveBeenCalled();
+      });
+      it('calls onClick if tiny', function () {
+        var onClick = jest.fn();
+        var w = wrapper({}, {
+          onClick: onClick
+        });
+        w.instance().tiny = jest.fn().mockReturnValue(true);
+
+        _d3Selection.clientPoint.mockReturnValue([0, 0]);
+
+        w.instance().onStop({}, {});
+        expect(onClick).toHaveBeenCalledWith({
+          x: 0,
+          y: 0
+        });
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/__tests__/grid-draggable.test.jsx"],"names":["jest","mock","clientPoint","fn","mockReturnValue","DraggableCore","type","props","children","getDelta","xyFn","out","n","invert","getGraphProps","scale","x","y","snap","domain","min","max","step","range","size","width","height","getRootNode","describe","wrapper","opts","extras","defaults","graphProps","anchorPoint","bounds","left","top","bottom","right","fromDelta","Comp","it","w","expect","toMatchSnapshot","g","instance","grid","toEqual","onStart","clientX","clientY","state","startX","startY","onDragStart","toHaveBeenCalled","pos","position","any","Function","setState","result","tiny","toBe","onDrag","beforeEach","applyDelta","ownerSVGElement","getBoundingClientRect","getClientPoint","toHaveBeenCalledWith","assertEarlyExit","dd","JSON","stringify","deltaX","deltaY","getScaledBounds","not","assertSkipDrag","rawXFn","rawYFn","expected","gp","mockGetBoundingClientRect","rootNode","skipDragOutsideOfBounds","anything","undefined","onDragStop","onStop","onClick"],"mappings":"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","sourcesContent":["import { shallow } from 'enzyme';\nimport React from 'react';\nimport { gridDraggable } from '../grid-draggable';\nimport { getDelta } from '../utils';\n\nimport { clientPoint } from 'd3-selection';\n\njest.mock('d3-selection', () => ({\n  clientPoint: jest.fn().mockReturnValue([0, 0]),\n}));\n\njest.mock('../draggable', () => ({\n  DraggableCore: jest.fn((type, props, children) => children),\n}));\n\njest.mock('../utils', () => ({\n  getDelta: jest.fn(),\n}));\n\nconst xyFn = () => {\n  const out = jest.fn((n) => n);\n  out.invert = jest.fn((n) => n);\n  return out;\n};\nconst getGraphProps = () => ({\n  scale: {\n    x: xyFn(),\n    y: xyFn(),\n  },\n  snap: {\n    x: xyFn(),\n    y: xyFn(),\n  },\n  domain: {\n    min: 0,\n    max: 1,\n    step: 1,\n  },\n  range: {\n    min: 0,\n    max: 1,\n    step: 1,\n  },\n  size: {\n    width: 500,\n    height: 500,\n  },\n  getRootNode: () => ({}),\n});\n\ndescribe('gridDraggable', () => {\n  const wrapper = (opts, extras) => {\n    const defaults = {\n      graphProps: getGraphProps(),\n    };\n\n    defaults.graphProps.scale.x.invert = jest.fn((x) => x);\n    defaults.graphProps.scale.y.invert = jest.fn((x) => x);\n\n    const props = { ...defaults, ...extras };\n\n    opts = {\n      anchorPoint: jest.fn().mockReturnValue({ x: 0, y: 0 }),\n      bounds: jest.fn().mockReturnValue({ left: 0, top: 0, bottom: 0, right: 0 }),\n      fromDelta: jest.fn(),\n      ...opts,\n    };\n\n    const Comp = gridDraggable(opts)(() => <div />);\n    return shallow(<Comp {...props} />);\n  };\n\n  describe('snapshot', () => {\n    it('reqular', () => {\n      const w = wrapper();\n      expect(w).toMatchSnapshot();\n    });\n\n    it('render with decimals', () => {\n      const w = wrapper(\n        {},\n        {\n          domain: {\n            min: -1.5,\n            max: 1.6,\n            step: 0.3,\n          },\n          range: {\n            min: -2,\n            max: 3,\n            step: 0.2,\n          },\n        },\n      );\n      expect(w).toMatchSnapshot();\n    });\n  });\n\n  describe('logic', () => {\n    describe('grid', () => {\n      it('returns the grid', () => {\n        const w = wrapper();\n        const g = w.instance().grid();\n        expect(g).toEqual({ x: 1, y: 1 });\n      });\n    });\n\n    describe('onStart', () => {\n      it('sets the drag state', () => {\n        const w = wrapper();\n        w.instance().onStart({ clientX: 100, clientY: 100 });\n        expect(w.state().startX).toEqual(100);\n        expect(w.state().startY).toEqual(100);\n      });\n\n      it('calls the handler', () => {\n        const onDragStart = jest.fn();\n        const w = wrapper(\n          {},\n          {\n            onDragStart,\n          },\n        );\n        w.instance().onStart({ clientX: 100, clientY: 100 });\n        expect(onDragStart).toHaveBeenCalled();\n      });\n    });\n\n    describe('position', () => {\n      it('returns position object', () => {\n        const w = wrapper();\n        const pos = w.instance().position();\n\n        const anchorPoint = {\n          x: 0,\n          y: 0,\n        };\n        expect(pos).toEqual({\n          anchorPoint,\n          x: expect.any(Function),\n          y: expect.any(Function),\n        });\n      });\n    });\n\n    describe('tiny', () => {\n      it('returns true for 10 ', () => {\n        const w = wrapper();\n        w.setState({ startX: 0 });\n        const result = w.instance().tiny('x', { clientX: 10 });\n        expect(result).toBe(false);\n      });\n      it('returns true for 0.01', () => {\n        const w = wrapper();\n        w.setState({ startX: 0 });\n        const result = w.instance().tiny('x', { clientX: 0.01 });\n        expect(result).toBe(true);\n      });\n    });\n\n    describe('onDrag', () => {\n      let onDrag, w;\n\n      beforeEach(() => {\n        onDrag = jest.fn();\n        w = wrapper({}, { onDrag });\n        w.instance().applyDelta = jest.fn().mockReturnValue(0);\n        w.instance().props.graphProps.getRootNode = jest.fn().mockReturnValue({\n          ownerSVGElement: null,\n          getBoundingClientRect: jest.fn(() => ({\n            left: 0,\n            top: 0,\n            right: 100,\n            bottom: 100,\n          })),\n        });\n        w.instance().getClientPoint = jest.fn().mockReturnValue([50, 50]); // Mocking getClientPoint\n        w.instance().onDrag({}, { x: 1, y: 1 });\n      });\n\n      it('calls applyDelta', () => {\n        expect(w.instance().applyDelta).toHaveBeenCalled();\n      });\n\n      it('calls callback', () => {\n        expect(onDrag).toHaveBeenCalledWith(0);\n      });\n\n      const bounds = (left, right, top, bottom) => ({ left, right, top, bottom });\n      describe('bounds', () => {\n        const assertEarlyExit = (bounds, dd) => {\n          it(`${JSON.stringify(bounds)}, ${dd.deltaX}, ${dd.deltaY} `, () => {\n            w = wrapper({}, { onDrag });\n            w.instance().getScaledBounds = jest.fn().mockReturnValue(bounds);\n            w.instance().getClientPoint = jest.fn().mockReturnValue([50, 50]);\n            w.instance().onDrag({}, dd);\n            expect(w.instance().getClientPoint).not.toHaveBeenCalled();\n          });\n        };\n        assertEarlyExit(bounds(0, 0, 0, 0), { deltaX: -10 });\n        assertEarlyExit(bounds(0, 0, 0, 0), { deltaX: 10 });\n        assertEarlyExit(bounds(-100, 100, 0, 0), { deltaY: -10 });\n        assertEarlyExit(bounds(-100, 100, -100, 0), { deltaY: 10 });\n        it('calls client point if it doesnt exit early bounds', () => {\n          w = wrapper({}, { onDrag });\n          w.instance().getScaledBounds = jest.fn().mockReturnValue(bounds(100, 100, 100, 100));\n          w.instance().getClientPoint = jest.fn().mockReturnValue([50, 50]);\n          w.instance().onDrag({}, { deltaX: 10 });\n          expect(w.instance().getClientPoint).toHaveBeenCalled(); // Asserting that getClientPoint is called\n        });\n      });\n    });\n\n    describe('skipDragOutsideOfBounds', () => {\n      let w;\n      const assertSkipDrag = (dd, rawXFn, rawYFn, expected) => {\n        rawXFn = rawXFn || ((x) => x);\n        rawYFn = rawYFn || ((y) => y);\n\n        it(`${dd.deltaX}, ${dd.deltaY}, ${expected}`, () => {\n          w = wrapper({});\n          const gp = getGraphProps();\n\n          const mockGetBoundingClientRect = jest.fn(() => ({\n            left: 0,\n            top: 0,\n            right: 100,\n            bottom: 100,\n          }));\n\n          w.instance().getClientPoint = jest.fn(() => [\n            rawXFn(gp.domain.min, gp.domain.max),\n            rawYFn(gp.range.min, gp.range.max),\n          ]);\n\n          const rootNode = {\n            ownerSVGElement: null,\n            getBoundingClientRect: mockGetBoundingClientRect,\n          };\n\n          const result = w.instance().skipDragOutsideOfBounds(dd, {}, { ...gp, getRootNode: () => rootNode });\n          expect(result).toEqual(expected);\n        });\n      };\n      assertSkipDrag(\n        { deltaX: 1 },\n        (min, max) => min - 1,\n        (min, max) => min,\n        true,\n      );\n      assertSkipDrag(\n        { deltaX: -1 },\n        (min, max) => max + 1,\n        (min, max) => min,\n        true,\n      );\n      assertSkipDrag(\n        { deltaY: 1 },\n        (min, max) => max,\n        (min, max) => max + 1,\n        true,\n      );\n      assertSkipDrag(\n        { deltaY: -1 },\n        (min, max) => max,\n        (min, max) => min - 1,\n        true,\n      );\n      assertSkipDrag(\n        { deltaY: 1 },\n        (min, max) => max,\n        (min, max) => max,\n        false,\n      );\n      assertSkipDrag(\n        { deltaY: -1 },\n        (min, max) => max,\n        (min, max) => min,\n        false,\n      );\n    });\n\n    describe('getDelta', () => {\n      it('calls utils.getDelta', () => {\n        const w = wrapper();\n        w.instance().position = jest.fn().mockReturnValue({\n          anchorPoint: {\n            x: 0,\n            y: 0,\n          },\n          x: jest.fn((x) => x),\n          y: jest.fn((y) => y),\n        });\n        w.instance().getDelta({ x: 1, y: 1 });\n        expect(getDelta).toHaveBeenCalledWith({ x: 0, y: 0 }, { x: 1, y: 1 });\n      });\n    });\n    describe('applyDelta', () => {\n      it('calls fromDelta', () => {\n        const fromDelta = jest.fn();\n        const w = wrapper({ fromDelta });\n        w.instance().getDelta = jest.fn();\n        w.instance().applyDelta({ x: 1, y: 1 });\n        expect(fromDelta).toHaveBeenCalledWith(expect.anything(), undefined);\n      });\n    });\n    describe('onStop', () => {\n      it('calls onDragStop', () => {\n        const onDragStop = jest.fn();\n        const w = wrapper({}, { onDragStop });\n        w.setState({ startX: 0, startY: 0 });\n        w.instance().onStop({}, {});\n        expect(onDragStop).toHaveBeenCalled();\n      });\n\n      it('calls onClick if tiny', () => {\n        const onClick = jest.fn();\n        const w = wrapper({}, { onClick });\n        w.instance().tiny = jest.fn().mockReturnValue(true);\n        clientPoint.mockReturnValue([0, 0]);\n        w.instance().onStop({}, {});\n        expect(onClick).toHaveBeenCalledWith({ x: 0, y: 0 });\n      });\n    });\n  });\n});\n"]}