@pie-lib/plot 4.1.0-beta.8 → 4.1.0-beta.9

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "4.1.0-beta.8",
+  "version": "4.1.0-beta.9",
   "description": "Some underlying components for building charts/graphs",
   "keywords": [
     "react",
@@ -21,7 +21,7 @@
     "@mapbox/point-geometry": "^1.1.0",
     "@mui/icons-material": "^7.3.4",
     "@mui/material": "^7.3.4",
-    "@pie-lib/editable-html-tip-tap": "^2.2.0-beta.8",
+    "@pie-lib/editable-html-tip-tap": "^2.2.0-beta.9",
     "@pie-lib/render-ui": "^6.1.0",
     "assert": "^1.4.1",
     "d3-scale": "^4.0.2",

package/src/__tests__/draggable.test.jsx

@@ -1,41 +0,0 @@
-import React from 'react';
-import { render } from '@testing-library/react';
-import Draggable from '../draggable';
-
-describe('draggable', () => {
-  it('renders with children', () => {
-    const { container } = render(
-      <Draggable>
-        <div>hellow</div>
-      </Draggable>,
-    );
-    expect(container.firstChild).toBeInTheDocument();
-  });
-
-  describe('local', () => {
-    it('resets position state when receiving new props', () => {
-      // Render with initial props
-      const { rerender, container } = render(
-        <Draggable position={{ x: 100, y: 100 }}>
-          <div data-testid="draggable-child">content</div>
-        </Draggable>,
-      );
-
-      // Verify initial render
-      expect(container.firstChild).toBeInTheDocument();
-
-      // Update props - this triggers componentWillReceiveProps
-      // which should reset internal x/y state to 0
-      rerender(
-        <Draggable position={{ x: 200, y: 200 }}>
-          <div data-testid="draggable-child">content</div>
-        </Draggable>,
-      );
-
-      // The component should still render correctly after prop change
-      // The internal state reset is tested by ensuring no errors occur
-      // and the component continues to function properly
-      expect(container.firstChild).toBeInTheDocument();
-    });
-  });
-});

package/src/__tests__/grid-draggable.test.jsx

@@ -1,487 +0,0 @@
-import { render } from '@testing-library/react';
-import React from 'react';
-import { gridDraggable } from '../grid-draggable';
-import { getDelta } from '../utils';
-import { pointer } from 'd3-selection';
-
-jest.mock('d3-selection', () => ({
-  pointer: jest.fn().mockReturnValue([0, 0]),
-}));
-
-let mockDraggableCoreProps;
-jest.mock('../draggable', () => ({
-  DraggableCore: (props) => {
-    // Store the props so tests can call the handlers
-    mockDraggableCoreProps = props;
-    return props.children;
-  },
-}));
-
-// Reusable mock start event with a target that supports addEventListener/removeEventListener
-const mockStartEvent = (overrides = {}) => ({
-  clientX: 0,
-  clientY: 0,
-  target: { addEventListener: jest.fn(), removeEventListener: jest.fn() },
-  ...overrides,
-});
-
-jest.mock('../utils', () => ({
-  getDelta: jest.fn(),
-}));
-
-const xyFn = () => {
-  const out = jest.fn((n) => n);
-  out.invert = jest.fn((n) => n);
-  return out;
-};
-
-const getGraphProps = () => ({
-  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: () => ({
-    ownerSVGElement: null,
-    getBoundingClientRect: () => ({
-      left: 0,
-      top: 0,
-      right: 100,
-      bottom: 100,
-    }),
-  }),
-});
-
-describe('gridDraggable', () => {
-  let defaultOptions;
-  let defaultProps;
-
-  beforeEach(() => {
-    mockDraggableCoreProps = null;
-    defaultOptions = {
-      anchorPoint: jest.fn().mockReturnValue({ x: 0, y: 0 }),
-      bounds: jest.fn().mockReturnValue({ left: 0, top: 0, bottom: 0, right: 0 }),
-      fromDelta: jest.fn(),
-    };
-
-    defaultProps = {
-      graphProps: getGraphProps(),
-    };
-  });
-
-  it('renders regular component', () => {
-    const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);
-    const { container } = render(<Comp {...defaultProps} />);
-    expect(container.firstChild).toBeInTheDocument();
-  });
-
-  it('renders with decimal domain and range', () => {
-    const props = {
-      ...defaultProps,
-      graphProps: {
-        ...getGraphProps(),
-        domain: {
-          min: -1.5,
-          max: 1.6,
-          step: 0.3,
-        },
-        range: {
-          min: -2,
-          max: 3,
-          step: 0.2,
-        },
-      },
-    };
-    const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);
-    const { container } = render(<Comp {...props} />);
-    expect(container.firstChild).toBeInTheDocument();
-  });
-
-  describe('logic', () => {
-    describe('grid calculation', () => {
-      it('passes correct grid to DraggableCore based on domain and range step', () => {
-        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);
-        render(<Comp {...defaultProps} />);
-
-        // Grid is calculated as: scale.x(domain.step) - scale.x(0)
-        // With our mock xyFn that returns n, this is: step - 0 = step
-        expect(mockDraggableCoreProps.grid).toEqual([1, 1]);
-      });
-
-      it('calculates grid with decimal steps', () => {
-        const props = {
-          ...defaultProps,
-          graphProps: {
-            ...getGraphProps(),
-            domain: { min: -1.5, max: 1.6, step: 0.3 },
-            range: { min: -2, max: 3, step: 0.2 },
-          },
-        };
-        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);
-        render(<Comp {...props} />);
-
-        expect(mockDraggableCoreProps.grid).toEqual([0.3, 0.2]);
-      });
-    });
-
-    describe('onStart', () => {
-      it('calls onDragStart handler when drag starts', () => {
-        const onDragStart = jest.fn();
-        const props = { ...defaultProps, onDragStart };
-        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);
-        render(<Comp {...props} />);
-
-        // Simulate drag start
-        mockDraggableCoreProps.onStart(mockStartEvent({ clientX: 100, clientY: 100 }));
-
-        expect(onDragStart).toHaveBeenCalled();
-      });
-    });
-
-    describe('onDrag', () => {
-      it('calls onDrag callback with result from fromDelta', () => {
-        const onDrag = jest.fn();
-        const fromDelta = jest.fn().mockReturnValue('delta-result');
-        const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 100, right: 100 });
-        const options = { ...defaultOptions, fromDelta, bounds };
-        const props = { ...defaultProps, onDrag };
-
-        const Comp = gridDraggable(options)(() => <div>Test</div>);
-        render(<Comp {...props} />);
-
-        // Set up drag start state
-        mockDraggableCoreProps.onStart(mockStartEvent());
-
-        // Simulate drag
-        mockDraggableCoreProps.onDrag({}, { deltaX: 10, deltaY: 10 });
-
-        expect(fromDelta).toHaveBeenCalled();
-        expect(onDrag).toHaveBeenCalledWith('delta-result');
-      });
-
-      it('does not call onDrag when no onDrag handler is provided', () => {
-        const fromDelta = jest.fn();
-        const options = { ...defaultOptions, fromDelta };
-        const Comp = gridDraggable(options)(() => <div>Test</div>);
-        render(<Comp {...defaultProps} />);
-
-        mockDraggableCoreProps.onStart(mockStartEvent());
-        mockDraggableCoreProps.onDrag({}, { deltaX: 10, deltaY: 10 });
-
-        expect(fromDelta).not.toHaveBeenCalled();
-      });
-
-      describe('bounds checking', () => {
-        it('does not call onDrag when dragging left beyond left bound', () => {
-          const onDrag = jest.fn();
-          const bounds = jest.fn().mockReturnValue({ left: 0, top: 0, bottom: 0, right: 0 });
-          const fromDelta = jest.fn().mockReturnValue('result');
-          const options = { ...defaultOptions, bounds, fromDelta };
-          const props = { ...defaultProps, onDrag };
-
-          const Comp = gridDraggable(options)(() => <div>Test</div>);
-          render(<Comp {...props} />);
-
-          mockDraggableCoreProps.onStart(mockStartEvent());
-          // deltaX < 0 and deltaX < scaled bounds.left (0), so -10 < 0 triggers early return
-          mockDraggableCoreProps.onDrag({}, { deltaX: -10, deltaY: 0 });
-
-          expect(onDrag).not.toHaveBeenCalled();
-        });
-
-        it('does not call onDrag when dragging right beyond right bound', () => {
-          const onDrag = jest.fn();
-          const bounds = jest.fn().mockReturnValue({ left: 0, top: 0, bottom: 0, right: 0 });
-          const fromDelta = jest.fn().mockReturnValue('result');
-          const options = { ...defaultOptions, bounds, fromDelta };
-          const props = { ...defaultProps, onDrag };
-
-          const Comp = gridDraggable(options)(() => <div>Test</div>);
-          render(<Comp {...props} />);
-
-          mockDraggableCoreProps.onStart(mockStartEvent());
-          // deltaX > 0 and deltaX > scaled bounds.right (0), so 10 > 0 triggers early return
-          mockDraggableCoreProps.onDrag({}, { deltaX: 10, deltaY: 0 });
-
-          expect(onDrag).not.toHaveBeenCalled();
-        });
-
-        it('does not call onDrag when dragging up beyond top bound', () => {
-          const onDrag = jest.fn();
-          const bounds = jest.fn().mockReturnValue({ left: -100, top: 0, bottom: 0, right: 100 });
-          const fromDelta = jest.fn().mockReturnValue('result');
-          const options = { ...defaultOptions, bounds, fromDelta };
-          const props = { ...defaultProps, onDrag };
-
-          const Comp = gridDraggable(options)(() => <div>Test</div>);
-          render(<Comp {...props} />);
-
-          mockDraggableCoreProps.onStart(mockStartEvent());
-          // deltaY < 0 and deltaY < scaled bounds.top (0), so -10 < 0 triggers early return
-          mockDraggableCoreProps.onDrag({}, { deltaX: 0, deltaY: -10 });
-
-          expect(onDrag).not.toHaveBeenCalled();
-        });
-
-        it('does not call onDrag when dragging down beyond bottom bound', () => {
-          const onDrag = jest.fn();
-          const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 0, right: 100 });
-          const fromDelta = jest.fn().mockReturnValue('result');
-          const options = { ...defaultOptions, bounds, fromDelta };
-          const props = { ...defaultProps, onDrag };
-
-          const Comp = gridDraggable(options)(() => <div>Test</div>);
-          render(<Comp {...props} />);
-
-          mockDraggableCoreProps.onStart(mockStartEvent());
-          // deltaY > 0 and deltaY > scaled bounds.bottom (0), so 10 > 0 triggers early return
-          mockDraggableCoreProps.onDrag({}, { deltaX: 0, deltaY: 10 });
-
-          expect(onDrag).not.toHaveBeenCalled();
-        });
-
-        it('calls onDrag when dragging within bounds', () => {
-          const onDrag = jest.fn();
-          const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 100, right: 100 });
-          const fromDelta = jest.fn().mockReturnValue('result');
-          const options = { ...defaultOptions, bounds, fromDelta };
-          const props = { ...defaultProps, onDrag };
-
-          const Comp = gridDraggable(options)(() => <div>Test</div>);
-          render(<Comp {...props} />);
-
-          mockDraggableCoreProps.onStart(mockStartEvent());
-          // All bound checks pass: deltaX (-10) is NOT < bounds.left (-100) and NOT > bounds.right (100)
-          // Similarly for deltaY
-          mockDraggableCoreProps.onDrag({}, { deltaX: -10, deltaY: 10 });
-
-          expect(onDrag).toHaveBeenCalled();
-        });
-      });
-
-      describe('skipDragOutsideOfBounds', () => {
-        it('skips drag when moving left and x is below domain.min', () => {
-          const onDrag = jest.fn();
-          const graphProps = {
-            ...getGraphProps(),
-            domain: { min: -5, max: 5, step: 1 },
-            range: { min: -5, max: 5, step: 1 },
-          };
-          graphProps.scale.x.invert = jest.fn().mockReturnValue(-6); // Below min
-
-          const props = { ...defaultProps, graphProps, onDrag };
-          const bounds = jest.fn().mockReturnValue({ left: 100, top: 100, bottom: 100, right: 100 });
-          const options = { ...defaultOptions, bounds };
-
-          const Comp = gridDraggable(options)(() => <div>Test</div>);
-          render(<Comp {...props} />);
-
-          mockDraggableCoreProps.onStart(mockStartEvent());
-          mockDraggableCoreProps.onDrag({}, { deltaX: 1, deltaY: 0 });
-
-          expect(onDrag).not.toHaveBeenCalled();
-        });
-
-        it('skips drag when moving right and x is above domain.max', () => {
-          const onDrag = jest.fn();
-          const graphProps = {
-            ...getGraphProps(),
-            domain: { min: -5, max: 5, step: 1 },
-            range: { min: -5, max: 5, step: 1 },
-          };
-          graphProps.scale.x.invert = jest.fn().mockReturnValue(6); // Above max
-
-          const props = { ...defaultProps, graphProps, onDrag };
-          const bounds = jest.fn().mockReturnValue({ left: 100, top: 100, bottom: 100, right: 100 });
-          const options = { ...defaultOptions, bounds };
-
-          const Comp = gridDraggable(options)(() => <div>Test</div>);
-          render(<Comp {...props} />);
-
-          mockDraggableCoreProps.onStart(mockStartEvent());
-          mockDraggableCoreProps.onDrag({}, { deltaX: -1, deltaY: 0 });
-
-          expect(onDrag).not.toHaveBeenCalled();
-        });
-
-        it('skips drag when moving up and y is above range.max', () => {
-          const onDrag = jest.fn();
-          const graphProps = {
-            ...getGraphProps(),
-            domain: { min: -5, max: 5, step: 1 },
-            range: { min: -5, max: 5, step: 1 },
-          };
-          graphProps.scale.y.invert = jest.fn().mockReturnValue(6); // Above max
-
-          const props = { ...defaultProps, graphProps, onDrag };
-          const bounds = jest.fn().mockReturnValue({ left: 100, top: 100, bottom: 100, right: 100 });
-          const options = { ...defaultOptions, bounds };
-
-          const Comp = gridDraggable(options)(() => <div>Test</div>);
-          render(<Comp {...props} />);
-
-          mockDraggableCoreProps.onStart(mockStartEvent());
-          mockDraggableCoreProps.onDrag({}, { deltaX: 0, deltaY: 1 });
-
-          expect(onDrag).not.toHaveBeenCalled();
-        });
-
-        it('skips drag when moving down and y is below range.min', () => {
-          const onDrag = jest.fn();
-          const graphProps = {
-            ...getGraphProps(),
-            domain: { min: -5, max: 5, step: 1 },
-            range: { min: -5, max: 5, step: 1 },
-          };
-          graphProps.scale.y.invert = jest.fn().mockReturnValue(-6); // Below min
-
-          const props = { ...defaultProps, graphProps, onDrag };
-          const bounds = jest.fn().mockReturnValue({ left: 100, top: 100, bottom: 100, right: 100 });
-          const options = { ...defaultOptions, bounds };
-
-          const Comp = gridDraggable(options)(() => <div>Test</div>);
-          render(<Comp {...props} />);
-
-          mockDraggableCoreProps.onStart(mockStartEvent());
-          mockDraggableCoreProps.onDrag({}, { deltaX: 0, deltaY: -1 });
-
-          expect(onDrag).not.toHaveBeenCalled();
-        });
-
-        it('allows drag when within domain and range', () => {
-          const onDrag = jest.fn();
-          const graphProps = {
-            ...getGraphProps(),
-            domain: { min: -5, max: 5, step: 1 },
-            range: { min: -5, max: 5, step: 1 },
-          };
-          graphProps.scale.x.invert = jest.fn().mockReturnValue(3); // Within bounds
-          graphProps.scale.y.invert = jest.fn().mockReturnValue(2); // Within bounds
-
-          const props = { ...defaultProps, graphProps, onDrag };
-          const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 100, right: 100 });
-          const options = { ...defaultOptions, bounds };
-
-          const Comp = gridDraggable(options)(() => <div>Test</div>);
-          render(<Comp {...props} />);
-
-          mockDraggableCoreProps.onStart(mockStartEvent());
-          mockDraggableCoreProps.onDrag({}, { deltaX: 1, deltaY: -1 });
-
-          expect(onDrag).toHaveBeenCalled();
-        });
-      });
-    });
-
-    describe('getDelta and applyDelta', () => {
-      it('calls utils.getDelta when processing drag', () => {
-        getDelta.mockClear();
-        const onDrag = jest.fn();
-        const props = { ...defaultProps, onDrag };
-        const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 100, right: 100 });
-        const options = { ...defaultOptions, bounds };
-
-        const Comp = gridDraggable(options)(() => <div>Test</div>);
-        render(<Comp {...props} />);
-
-        mockDraggableCoreProps.onStart(mockStartEvent());
-        mockDraggableCoreProps.onDrag({}, { deltaX: 10, deltaY: 10 });
-
-        expect(getDelta).toHaveBeenCalled();
-      });
-
-      it('calls fromDelta with result from getDelta', () => {
-        const fromDelta = jest.fn();
-        getDelta.mockReturnValue({ x: 5, y: 5 });
-        const bounds = jest.fn().mockReturnValue({ left: -100, top: -100, bottom: 100, right: 100 });
-        const options = { ...defaultOptions, fromDelta, bounds };
-        const props = { ...defaultProps, onDrag: jest.fn() };
-
-        const Comp = gridDraggable(options)(() => <div>Test</div>);
-        render(<Comp {...props} />);
-
-        mockDraggableCoreProps.onStart(mockStartEvent());
-        mockDraggableCoreProps.onDrag({}, { deltaX: 10, deltaY: 10 });
-
-        expect(fromDelta).toHaveBeenCalled();
-      });
-    });
-
-    describe('onStop', () => {
-      it('calls onDragStop when drag stops', () => {
-        const onDragStop = jest.fn();
-        const props = { ...defaultProps, onDragStop };
-
-        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);
-        render(<Comp {...props} />);
-
-        // Start to set up state
-        mockDraggableCoreProps.onStart(mockStartEvent());
-
-        // Stop with large movement (not tiny)
-        mockDraggableCoreProps.onStop({ clientX: 100, clientY: 100, stopPropagation: jest.fn() }, {});
-
-        expect(onDragStop).toHaveBeenCalled();
-      });
-
-      it('calls onClick instead of onDragStop when movement is tiny', () => {
-        const onClick = jest.fn();
-        const onDragStop = jest.fn();
-        const props = { ...defaultProps, onClick, onDragStop };
-
-        pointer.mockReturnValue([0, 0]);
-
-        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);
-        render(<Comp {...props} />);
-
-        // Start and stop at almost the same position (tiny movement)
-        // Grid is 1x1, tiny threshold is grid/10 = 0.1
-        mockDraggableCoreProps.onStart(mockStartEvent());
-        mockDraggableCoreProps.onStop({ clientX: 0.05, clientY: 0.05, target: {}, stopPropagation: jest.fn() }, {});
-
-        expect(onClick).toHaveBeenCalledWith({ x: 0, y: 0 });
-      });
-
-      it('calls onClick with snapped coordinates', () => {
-        const onClick = jest.fn();
-        const props = { ...defaultProps, onClick };
-        const graphProps = getGraphProps();
-        graphProps.scale.x.invert = jest.fn().mockReturnValue(1.7);
-        graphProps.scale.y.invert = jest.fn().mockReturnValue(2.3);
-        graphProps.snap.x = jest.fn().mockReturnValue(2);
-        graphProps.snap.y = jest.fn().mockReturnValue(2);
-
-        pointer.mockReturnValue([1.7, 2.3]);
-
-        const propsWithGraphProps = { ...props, graphProps };
-        const Comp = gridDraggable(defaultOptions)(() => <div>Test</div>);
-        render(<Comp {...propsWithGraphProps} />);
-
-        // Start and stop at almost the same position (tiny movement)
-        mockDraggableCoreProps.onStart(mockStartEvent());
-        mockDraggableCoreProps.onStop({ clientX: 0.05, clientY: 0.05, target: {}, stopPropagation: jest.fn() }, {});
-
-        expect(graphProps.snap.x).toHaveBeenCalledWith(1.7);
-        expect(graphProps.snap.y).toHaveBeenCalledWith(2.3);
-        expect(onClick).toHaveBeenCalledWith({ x: 2, y: 2 });
-      });
-    });
-  });
-});

package/src/__tests__/root.test.jsx

@@ -1,277 +0,0 @@
-import { cleanup, render } from '@testing-library/react';
-import React from 'react';
-import { Root } from '../root';
-import { pointer, select } from 'd3-selection';
-
-jest.mock('d3-selection', () => ({
-  select: jest.fn(),
-  pointer: jest.fn(),
-}));
-
-const scaleMock = () => {
-  const fn = jest.fn((n) => n);
-  fn.invert = jest.fn((n) => n);
-  return fn;
-};
-
-const graphProps = () => ({
-  scale: {
-    x: scaleMock(),
-    y: scaleMock(),
-  },
-  snap: {
-    x: jest.fn((n) => n),
-    y: jest.fn((n) => n),
-  },
-  domain: {
-    min: 0,
-    max: 1,
-    step: 1,
-  },
-  range: {
-    min: 0,
-    max: 1,
-    step: 1,
-  },
-  size: {
-    width: 400,
-    height: 400,
-  },
-});
-
-describe('root', () => {
-  let mockOn;
-  let defaultProps;
-
-  beforeEach(() => {
-    mockOn = jest.fn();
-    select.mockReturnValue({
-      on: mockOn,
-    });
-    pointer.mockReturnValue([0, 0]);
-
-    defaultProps = {
-      classes: {},
-      graphProps: graphProps(),
-    };
-  });
-
-  afterEach(() => {
-    cleanup();
-    jest.clearAllMocks();
-  });
-
-  it('renders with children', () => {
-    const { container, getByText } = render(<Root {...defaultProps}>hi</Root>);
-    expect(container.firstChild).toBeInTheDocument();
-    expect(getByText('hi')).toBeInTheDocument();
-  });
-
-  describe('logic', () => {
-    describe('mousemove', () => {
-      describe('mount/unmount', () => {
-        it('adds mousemove listener on componentDidMount', () => {
-          render(<Root {...defaultProps}>hi</Root>);
-
-          // Verify that select was called with the g element
-          expect(select).toHaveBeenCalled();
-
-          // Verify that on() was called with 'mousemove' and a function
-          expect(mockOn).toHaveBeenCalledWith('mousemove', expect.any(Function));
-        });
-
-        it('removes mousemove listener on componentWillUnmount', () => {
-          const { unmount } = render(<Root {...defaultProps}>hi</Root>);
-
-          // Clear previous calls to isolate unmount behavior
-          mockOn.mockClear();
-          select.mockClear();
-
-          unmount();
-
-          // Verify that select was called during unmount
-          expect(select).toHaveBeenCalled();
-
-          // Verify that on() was called with 'mousemove' and null to remove the listener
-          expect(mockOn).toHaveBeenCalledWith('mousemove', null);
-        });
-      });
-
-      describe('mouseMove function', () => {
-        it('calls pointer with correct arguments', () => {
-          const onMouseMove = jest.fn();
-          const gp = graphProps();
-          const props = {
-            ...defaultProps,
-            onMouseMove,
-            graphProps: gp,
-          };
-
-          const mockNode = document.createElement('div');
-          const mockEvent = { clientX: 10, clientY: 20 };
-          const mockSelection = {
-            _groups: [[mockNode]],
-            node: () => mockNode,
-          };
-
-          // Mock select to return our mockSelection
-          select.mockReturnValue({
-            ...mockSelection,
-            on: (event, handler) => {
-              mockOn(event, handler);
-              // When 'mousemove' is registered, immediately test it
-              if (event === 'mousemove' && handler) {
-                pointer.mockReturnValue([10, 20]);
-                // Handler is bound with mockSelection as first arg, so call with event
-                handler(mockEvent);
-              }
-            },
-          });
-
-          render(<Root {...props}>hi</Root>);
-
-          // Verify pointer was called with the event and correct node
-          expect(pointer).toHaveBeenCalledWith(mockEvent, mockNode);
-        });
-
-        it('calls scale.x.invert and scale.y.invert', () => {
-          const onMouseMove = jest.fn();
-          const gp = graphProps();
-          const props = {
-            ...defaultProps,
-            onMouseMove,
-            graphProps: gp,
-          };
-
-          const mockNode = document.createElement('div');
-          const mockEvent = { clientX: 15, clientY: 25 };
-          const mockSelection = {
-            _groups: [[mockNode]],
-            node: () => mockNode,
-          };
-
-          select.mockReturnValue({
-            ...mockSelection,
-            on: (event, handler) => {
-              mockOn(event, handler);
-              if (event === 'mousemove' && handler) {
-                pointer.mockReturnValue([15, 25]);
-                handler(mockEvent);
-              }
-            },
-          });
-
-          render(<Root {...props}>hi</Root>);
-
-          expect(gp.scale.x.invert).toHaveBeenCalledWith(15);
-          expect(gp.scale.y.invert).toHaveBeenCalledWith(25);
-        });
-
-        it('calls snap.x and snap.y with inverted coordinates', () => {
-          const onMouseMove = jest.fn();
-          const gp = graphProps();
-          gp.scale.x.invert = jest.fn().mockReturnValue(5);
-          gp.scale.y.invert = jest.fn().mockReturnValue(10);
-          const props = {
-            ...defaultProps,
-            onMouseMove,
-            graphProps: gp,
-          };
-
-          const mockNode = document.createElement('div');
-          const mockEvent = { clientX: 100, clientY: 200 };
-          const mockSelection = {
-            _groups: [[mockNode]],
-            node: () => mockNode,
-          };
-
-          select.mockReturnValue({
-            ...mockSelection,
-            on: (event, handler) => {
-              mockOn(event, handler);
-              if (event === 'mousemove' && handler) {
-                pointer.mockReturnValue([100, 200]);
-                handler();
-              }
-            },
-          });
-
-          render(<Root {...props}>hi</Root>);
-
-          expect(gp.snap.x).toHaveBeenCalledWith(5);
-          expect(gp.snap.y).toHaveBeenCalledWith(10);
-        });
-
-        it('calls onMouseMove handler with snapped coordinates', () => {
-          const onMouseMove = jest.fn();
-          const gp = graphProps();
-          gp.scale.x.invert = jest.fn().mockReturnValue(7);
-          gp.scale.y.invert = jest.fn().mockReturnValue(14);
-          gp.snap.x = jest.fn().mockReturnValue(10);
-          gp.snap.y = jest.fn().mockReturnValue(15);
-
-          const props = {
-            ...defaultProps,
-            onMouseMove,
-            graphProps: gp,
-          };
-
-          const mockNode = document.createElement('div');
-          const mockEvent = { clientX: 100, clientY: 200 };
-          const mockSelection = {
-            _groups: [[mockNode]],
-            node: () => mockNode,
-          };
-
-          select.mockReturnValue({
-            ...mockSelection,
-            on: (event, handler) => {
-              mockOn(event, handler);
-              if (event === 'mousemove' && handler) {
-                pointer.mockReturnValue([100, 200]);
-                handler(mockEvent);
-              }
-            },
-          });
-
-          render(<Root {...props}>hi</Root>);
-
-          expect(onMouseMove).toHaveBeenCalledWith({ x: 10, y: 15 });
-        });
-
-        it('does not call onMouseMove when handler is not provided', () => {
-          const gp = graphProps();
-          const props = {
-            ...defaultProps,
-            graphProps: gp,
-          };
-
-          const mockNode = document.createElement('div');
-          const mockEvent = { clientX: 100, clientY: 200 };
-          const mockSelection = {
-            _groups: [[mockNode]],
-            node: () => mockNode,
-          };
-
-          select.mockReturnValue({
-            ...mockSelection,
-            on: (event, handler) => {
-              mockOn(event, handler);
-              if (event === 'mousemove' && handler) {
-                pointer.mockReturnValue([100, 200]);
-                // Should not throw error when onMouseMove is not provided
-                expect(() => handler(mockEvent)).not.toThrow();
-              }
-            },
-          });
-
-          render(<Root {...props}>hi</Root>);
-
-          // Verify scale methods were not called (early return in mouseMove)
-          expect(gp.scale.x.invert).not.toHaveBeenCalled();
-          expect(gp.scale.y.invert).not.toHaveBeenCalled();
-        });
-      });
-    });
-  });
-});

package/src/__tests__/trig.test.js

@@ -1,163 +0,0 @@
-import { acuteXAngle, acuteYAngle, angle, diffEdge, edges, getOpposingSide, toDegrees, toRadians } from '../trig';
-import { xy } from '../utils';
-import debug from 'debug';
-
-const log = debug('pie-lib:plot:trig:test');
-
-const vs = (v) => {
-  if (!v) {
-    return '';
-  }
-
-  if (Number.isFinite(v.x) && Number.isFinite(v.y)) {
-    return `[${v.x},${v.y}]`;
-  }
-  return JSON.stringify(v);
-};
-const p = (strings, ...values) => {
-  return strings.reduce((acc, s, index) => {
-    return `${acc}${s}${vs(values[index])}`;
-  }, '');
-};
-describe('trig', () => {
-  describe('angle', () => {
-    const assertAngle = (a, b, expected) => {
-      it(p`${a}, ${b} => ${toDegrees(expected)}`, () => {
-        const result = angle(a, b);
-        expect(result).toBeCloseTo(expected);
-      });
-    };
-
-    assertAngle(xy(0, 0), xy(1, 1), toRadians(45));
-    assertAngle(xy(0, 0), xy(0, 1), toRadians(90));
-    assertAngle(xy(0, 0), xy(-1, 1), toRadians(135));
-    assertAngle(xy(0, 0), xy(-1, 0), toRadians(180));
-    assertAngle(xy(0, 0), xy(-1, -1), toRadians(225));
-    assertAngle(xy(0, 0), xy(0, -1), toRadians(270));
-    assertAngle(xy(0, 0), xy(1, -1), toRadians(315));
-    assertAngle(xy(1, 1), xy(0, 0), toRadians(225));
-    assertAngle(xy(0, 0), xy(1, 1), toRadians(45));
-    assertAngle(xy(0, 0), xy(2, 1), toRadians(26.565));
-    assertAngle(xy(0, 0), xy(3, 1), toRadians(18.434));
-    assertAngle(xy(0, 0), xy(4, 1), toRadians(14.036));
-    assertAngle(xy(0, 0), xy(5, 1), toRadians(11.309));
-  });
-
-  describe('acuteXAngle', () => {
-    const assertAcute = (input, expected) => {
-      it(`${toDegrees(input)} => ${toDegrees(expected)}`, () => {
-        const result = acuteXAngle(input);
-        log(`result: ${toDegrees(result)}`);
-        expect(result).toBeCloseTo(expected);
-      });
-    };
-
-    assertAcute(toRadians(45), toRadians(45));
-    assertAcute(toRadians(100), toRadians(80));
-    assertAcute(toRadians(190), toRadians(10));
-    assertAcute(toRadians(350), toRadians(10));
-  });
-
-  describe('acuteYAngle', () => {
-    const assertAcute = (input, expected) => {
-      it(`${toDegrees(input)} => ${toDegrees(expected)}`, () => {
-        const result = acuteYAngle(input);
-        log(`result: ${toDegrees(result)}`);
-        expect(result).toBeCloseTo(expected);
-      });
-    };
-
-    assertAcute(toRadians(45), toRadians(45));
-    assertAcute(toRadians(100), toRadians(10));
-    assertAcute(toRadians(190), toRadians(80));
-    assertAcute(toRadians(350), toRadians(80));
-  });
-
-  describe('edges', () => {
-    const assertEdges = (domain, range) => (from, to, expected) => {
-      it(p`${domain}, ${range} + ${from} -> ${to} => ${expected[0]}${expected[1]}`, () => {
-        const result = edges(domain, range)(from, to);
-        expect(result[0].x).toBeCloseTo(expected[0].x);
-        expect(result[0].y).toBeCloseTo(expected[0].y);
-        expect(result[1].x).toBeCloseTo(expected[1].x);
-        expect(result[1].y).toBeCloseTo(expected[1].y);
-      });
-    };
-
-    const one = assertEdges({ min: -4, max: 4 }, { min: -4, max: 4 });
-    one(xy(0, 0), xy(1, 1), [xy(4, 4), xy(-4, -4)]);
-    one(xy(0, 0), xy(2, 1), [xy(4, 2), xy(-4, -2)]);
-    one(xy(1, 1), xy(2, 2), [xy(4, 4), xy(-4, -4)]);
-    one(xy(1, 0), xy(2, 0), [xy(4, 0), xy(-4, 0)]);
-    one(xy(1, 0), xy(-2, 0), [xy(-4, 0), xy(4, 0)]);
-
-    /**
-     * domain {min: -5, max: 5, padding: 0, step: 1, labelStep: 1}labelStep: 1max: 5min: -5padding: 0step: 1__proto__: Object range:  {min: -5, max: 5, padding: 0, step: 1, labelStep: 1} a: {x: -5, y: 0} b: {x: -5, y: 2} edges: Point {x: -5, y: 5} Point {x: -5, y: 2}
-     */
-    const lineIssue = assertEdges({ min: -5, max: 5 }, { min: -5, max: 5 });
-    lineIssue(xy(-5, -0), xy(-5, 2), [xy(-5, 5), xy(-5, -5)]);
-  });
-
-  describe('diffEdge', () => {
-    const assertDiffEdge = (bounds, from, to, expected) => {
-      it(p`<${bounds}> ${from} -> ${to} => ${expected}`, () => {
-        const result = diffEdge(bounds, from, to);
-        expect(result.x).toBeCloseTo(expected.x);
-        expect(result.y).toBeCloseTo(expected.y);
-      });
-    };
-
-    const twoTwo = assertDiffEdge.bind(null, xy(2, 2));
-    twoTwo(xy(0, 0), xy(1, 1), xy(2, 2));
-    twoTwo(xy(0, 0), xy(1, 2), xy(1, 2));
-    twoTwo(xy(0, 0), xy(2, 2), xy(2, 2));
-    twoTwo(xy(0, 0), xy(2, 2), xy(2, 2));
-    twoTwo(xy(0, 0), xy(-1, 1), xy(-2, 2));
-    twoTwo(xy(0, 0), xy(-1, -1), xy(-2, -2));
-    const fourFour = assertDiffEdge.bind(null, xy(4, 4));
-
-    fourFour(xy(0, 0), xy(1, 1), xy(4, 4));
-    fourFour(xy(0, 0), xy(1, 2), xy(2, 4));
-    fourFour(xy(0, 0), xy(2, 1), xy(4, 2));
-    fourFour(xy(0, 0), xy(-1, 1), xy(-4, 4));
-    fourFour(xy(0, 0), xy(-1, 1), xy(-4, 4));
-
-    assertDiffEdge(xy(-4, -4), xy(0, 0), xy(-1, -1), xy(-4, -4));
-    assertDiffEdge(xy(4, 4), xy(1, 1), xy(2, 2), xy(4, 4));
-    assertDiffEdge(xy(4, 4), xy(2, 2), xy(3, 3), xy(4, 4));
-    assertDiffEdge(xy(-4, -4), xy(-1, -1), xy(-2, -2), xy(-4, -4));
-    assertDiffEdge(xy(-4, 4), xy(-1, -1), xy(-2, 0), xy(-4, 2));
-
-    const lineIssue = assertDiffEdge.bind(null, xy(-5, -5));
-
-    lineIssue(xy(-5, 2), xy(-5, 0), xy(-5, -5));
-    //Top Right
-    assertDiffEdge(xy(5, 5), xy(0, 5), xy(2, 5), xy(5, 5));
-    assertDiffEdge(xy(5, 5), xy(5, 0), xy(5, 1), xy(5, 5));
-
-    // //Bottom Right
-    assertDiffEdge(xy(5, -5), xy(5, 0), xy(5, -0.1), xy(5, -5));
-    assertDiffEdge(xy(5, -5), xy(0, -5), xy(1, -5), xy(5, -5));
-
-    //Top Left
-    assertDiffEdge(xy(-5, 5), xy(-5, 0), xy(-5, 0.1), xy(-5, 5));
-    assertDiffEdge(xy(-5, 5), xy(0, 5), xy(-1, 5), xy(-5, 5));
-
-    //Bottom Left
-    assertDiffEdge(xy(-5, -5), xy(-5, 0), xy(-5, -0.1), xy(-5, -5));
-    assertDiffEdge(xy(-5, -5), xy(0, -5), xy(-1, -5), xy(-5, -5));
-  });
-
-  describe('getOpposingSide', () => {
-    const assertOpposingSide = (hyp, angle, expected) => {
-      it(`${hyp}, ${angle} = ${expected}`, () => {
-        const radians = toRadians(angle);
-        const result = getOpposingSide(hyp, radians);
-        expect(result).toBeCloseTo(expected);
-      });
-    };
-
-    assertOpposingSide(1, 45, 0.707);
-    assertOpposingSide(1.25, 45, 0.88);
-  });
-});

package/src/__tests__/utils.test.js

@@ -1,229 +0,0 @@
-import * as utils from '../utils';
-
-const xy = utils.xy;
-
-const tick = (isMajor, v) => ({
-  major: isMajor,
-  value: v,
-  x: v,
-});
-
-const major = tick.bind(null, true);
-const minor = tick.bind(null, false);
-
-describe('utils', () => {
-  describe('getDelta', () => {
-    const assertDelta = (from, to, delta) => {
-      it(`returns a delta of: ${delta} for ${from} -> ${to}`, () => {
-        const d = utils.getDelta(from, to);
-        expect(d.x).toEqual(delta.x);
-        expect(d.y).toEqual(delta.y);
-      });
-    };
-    assertDelta(xy(0, 0), xy(0, 1), xy(0, 1));
-    assertDelta(xy(0, 1), xy(0, 0), xy(0, -1));
-    assertDelta(xy(1, 1), xy(3, 3), xy(2, 2));
-    assertDelta(xy(-1, -1), xy(3, 3), xy(4, 4));
-    assertDelta(xy(-1, -1), xy(-2, -5), xy(-1, -4));
-  });
-
-  describe('polygonToArea', () => {
-    const assertPolygon = (points, area) => {
-      it(`converts ${points} -> ${area}`, () => {
-        const result = utils.polygonToArea(points);
-        expect(result).toEqual(area);
-      });
-    };
-    assertPolygon([xy(0, 0), xy(1, 1), xy(1, -1)], {
-      left: 0,
-      top: 1,
-      bottom: -1,
-      right: 1,
-    });
-    assertPolygon([xy(0, 0), xy(3, 0), xy(2, -1), xy(4, -3), xy(1, -4), xy(2, -2)], {
-      left: 0,
-      top: 0,
-      bottom: -4,
-      right: 4,
-    });
-  });
-
-  describe('buildTickModel', () => {
-    let scaleFn;
-
-    beforeEach(() => {
-      scaleFn = jest.fn(function (v) {
-        return v;
-      });
-    });
-
-    it('builds major only ticks', () => {
-      let result = utils.buildTickModel({ min: 0, max: 2 }, { minor: 0 }, 1, scaleFn);
-      expect(result).toEqual([major(0), major(1), major(2)]);
-    });
-
-    it('builds minor + major ticks', () => {
-      let result = utils.buildTickModel({ min: 0, max: 2 }, { minor: 1 }, 0.5, scaleFn);
-      expect(result).toEqual([major(0), minor(0.5), major(1), minor(1.5), major(2)]);
-    });
-  });
-
-  describe('snapTo', () => {
-    let assertSnapTo = (min, max, interval, value, expected) => {
-      it(`snaps ${value} to ${expected} with domain ${min}<->${max} with interval: ${interval} `, () => {
-        let result = utils.snapTo(min, max, interval, value);
-        expect(result).toEqual(expected);
-      });
-    };
-
-    describe('with 0, 10, 0.25', () => {
-      let a = assertSnapTo.bind(null, 0, 10, 0.25);
-      a(1, 1);
-      a(1.2, 1.25);
-      a(0.2, 0.25);
-      a(5.2, 5.25);
-      a(5.125, 5.25);
-      a(5.124, 5);
-    });
-
-    describe('with 0, 10, 1', () => {
-      let a = assertSnapTo.bind(null, 0, 10, 1);
-      a(0, 0);
-      a(10, 10);
-      a(100, 10);
-      a(1, 1);
-      a(1.2, 1);
-      a(0.2, 0);
-      a(5.2, 5);
-      a(5.001, 5);
-    });
-  });
-
-  describe('getInterval', () => {
-    let assertGetInterval = (min, max, ticks, expected) => {
-      let paramsDescription = JSON.stringify(ticks);
-      it(`converts: ${paramsDescription} to ${JSON.stringify(expected)}`, () => {
-        let result = utils.getInterval({ min: min, max: max }, ticks);
-        expect(result).toEqual(expected);
-      });
-    };
-
-    describe('with bad params', () => {
-      it('throws an error if min > max', () => {
-        expect(() => {
-          let result = utils.convertFrequencyToInterval(
-            { min: 11, max: 10, tickFrequency: 1, betweenTickCount: 0 },
-            { interval: 10, major: 10 },
-          );
-        }).toThrow(Error);
-      });
-
-      it('throws an error if min = max', () => {
-        expect(() => {
-          let result = utils.convertFrequencyToInterval(
-            { min: 10, max: 10, tickFrequency: 1, betweenTickCount: 0 },
-            { interval: 10, major: 10 },
-          );
-        }).toThrow(Error);
-      });
-    });
-
-    describe('with domain 0 -> 1', () => {
-      let a = assertGetInterval.bind(null, 0, 1);
-      a({ major: 2, minor: 0 }, 1);
-      a({ major: 2, minor: 1 }, 0.5);
-    });
-
-    describe('with domain 0 -> 10', () => {
-      let a = assertGetInterval.bind(null, 0, 10);
-
-      it('throws an error if the tick frequency is less than 2', () => {
-        expect(() => {
-          let result = utils.convertFrequencyToInterval(
-            { min: 0, max: 10, tickFrequency: 1, betweenTickCount: 0 },
-            { interval: 10, major: 10 },
-          );
-        }).toThrow(Error);
-      });
-
-      a({ major: 2, minor: 9 }, 1);
-      a({ major: 2, minor: 0 }, 10);
-      a({ major: 3, minor: 0 }, 5);
-      a({ major: 3, minor: 1 }, 2.5);
-      a({ major: 4, minor: 0 }, 3.3333);
-      a({ major: 5, minor: 0 }, 2.5);
-      a({ major: 6, minor: 0 }, 2);
-      a({ major: 7, minor: 0 }, 1.6667);
-      a({ major: 8, minor: 0 }, 1.4286);
-      a({ major: 9, minor: 0 }, 1.25);
-      a({ major: 10, minor: 0 }, 1.1111);
-      a({ major: 11, minor: 0 }, 1);
-      a({ major: 11, minor: 1 }, 0.5);
-      a({ major: 11, minor: 2 }, 0.3333);
-    });
-
-    describe('with domain 0 -> 100', () => {
-      let a = assertGetInterval.bind(null, 0, 100);
-      a({ major: 11, minor: 1 }, 5);
-      a({ major: 101, minor: 0 }, 1);
-    });
-
-    describe('with domain -5 - 5', () => {
-      let a = assertGetInterval.bind(null, -5, 5);
-      a({ major: 11, minor: 0 }, 1);
-    });
-
-    describe('with domain 0 - 5', () => {
-      let a = assertGetInterval.bind(null, 0, 5);
-      a({ major: 11, minor: 0 }, 0.5);
-      a({ major: 11, minor: 2 }, 0.1667);
-      a({ major: 11, minor: 1 }, 0.25);
-    });
-  });
-
-  describe('findLongestWord', () => {
-    it('should return 0 if label is undefined', () => {
-      const label = undefined;
-      const result = utils.findLongestWord(label);
-
-      expect(result).toEqual(0);
-    });
-
-    it('should return 0 if label is null', () => {
-      const label = null;
-      const result = utils.findLongestWord(label);
-
-      expect(result).toEqual(0);
-    });
-
-    it('should return 6 if the longest word from label has 6 letters', () => {
-      const label = 'Number of months';
-      const result = utils.findLongestWord(label);
-
-      expect(result).toEqual(6);
-    });
-  });
-
-  describe('amountToIncreaseWidth', () => {
-    it('should return 0 if longestWord is undefined', () => {
-      const longestWord = undefined;
-      const result = utils.amountToIncreaseWidth(longestWord);
-
-      expect(result).toEqual(0);
-    });
-
-    it('should return 0 if longestWord is null', () => {
-      const longestWord = null;
-      const result = utils.amountToIncreaseWidth(longestWord);
-
-      expect(result).toEqual(0);
-    });
-
-    it('should return 150 if longestWord is 10', () => {
-      const longestWord = 10;
-      const result = utils.amountToIncreaseWidth(longestWord);
-
-      expect(result).toEqual(200);
-    });
-  });
-});