@pie-lib/plot 4.0.4-next.3 → 4.0.4-next.31

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);
-    });
-  });
-});

package/src/draggable.jsx

@@ -1,11 +0,0 @@
-import Draggable, { DraggableCore } from 'react-draggable';
-
-export default class LocalDraggable extends Draggable {
-  componentWillReceiveProps(next) {
-    super.componentWillReceiveProps(next);
-    //Remove the x/y state as these values have now been updated and will come through as props.
-    this.setState({ x: 0, y: 0 });
-  }
-}
-
-export { DraggableCore };