@pie-lib/graphing 4.0.5-next.30 → 4.0.5-next.34

package/src/tools/parabola/__tests__/index.test.js

@@ -0,0 +1,470 @@
+import { tool } from '../index';
+import Parabola from '../component';
+
+describe('parabola tool', () => {
+  let parabolaTool;
+
+  beforeEach(() => {
+    parabolaTool = tool();
+  });
+
+  describe('tool structure', () => {
+    it('returns an object with required properties', () => {
+      expect(parabolaTool).toHaveProperty('type', 'parabola');
+      expect(parabolaTool).toHaveProperty('Component', Parabola);
+      expect(parabolaTool).toHaveProperty('complete');
+      expect(parabolaTool).toHaveProperty('addPoint');
+    });
+
+    it('has correct type', () => {
+      expect(parabolaTool.type).toBe('parabola');
+    });
+
+    it('uses Parabola component', () => {
+      expect(parabolaTool.Component).toBe(Parabola);
+    });
+  });
+
+  describe('addPoint', () => {
+    describe('no existing mark', () => {
+      it('creates new parabola with root point', () => {
+        const point = { x: 1, y: 2 };
+        const result = parabolaTool.addPoint(point, null);
+
+        expect(result).toEqual({
+          type: 'parabola',
+          root: point,
+          edge: undefined,
+          closed: false,
+          building: true,
+        });
+      });
+
+      it('creates parabola with undefined argument', () => {
+        const point = { x: 3, y: 4 };
+        const result = parabolaTool.addPoint(point);
+
+        expect(result).toEqual({
+          type: 'parabola',
+          root: point,
+          edge: undefined,
+          closed: false,
+          building: true,
+        });
+      });
+
+      it('marks parabola as building', () => {
+        const result = parabolaTool.addPoint({ x: 0, y: 0 });
+
+        expect(result.building).toBe(true);
+        expect(result.closed).toBe(false);
+      });
+
+      it('initializes with undefined edge', () => {
+        const result = parabolaTool.addPoint({ x: 1, y: 1 });
+
+        expect(result.edge).toBeUndefined();
+      });
+    });
+
+    describe('existing mark with root', () => {
+      it('adds edge point to complete parabola', () => {
+        const root = { x: 1, y: 2 };
+        const edge = { x: 3, y: 4 };
+        const mark = {
+          type: 'parabola',
+          root,
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        const result = parabolaTool.addPoint(edge, mark);
+
+        expect(result).toEqual({
+          type: 'parabola',
+          root,
+          edge,
+          closed: true,
+          building: false,
+        });
+      });
+
+      it('closes parabola when edge is added', () => {
+        const mark = {
+          type: 'parabola',
+          root: { x: 0, y: 0 },
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        const result = parabolaTool.addPoint({ x: 1, y: 1 }, mark);
+
+        expect(result.closed).toBe(true);
+        expect(result.building).toBe(false);
+      });
+
+      it('preserves other mark properties when adding edge', () => {
+        const mark = {
+          type: 'parabola',
+          root: { x: 1, y: 2 },
+          edge: undefined,
+          closed: false,
+          building: true,
+          label: 'My Parabola',
+          color: 'blue',
+        };
+
+        const result = parabolaTool.addPoint({ x: 3, y: 4 }, mark);
+
+        expect(result.label).toBe('My Parabola');
+        expect(result.color).toBe('blue');
+      });
+    });
+
+    describe('duplicate points', () => {
+      it('returns same mark when clicking root point again', () => {
+        const root = { x: 1, y: 2 };
+        const mark = {
+          type: 'parabola',
+          root,
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        const result = parabolaTool.addPoint(root, mark);
+
+        expect(result).toBe(mark);
+      });
+
+      it('returns same mark when clicking near root point', () => {
+        const root = { x: 1.00001, y: 2.00001 };
+        const nearRoot = { x: 1.00002, y: 2.00002 };
+        const mark = {
+          type: 'parabola',
+          root,
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        const result = parabolaTool.addPoint(nearRoot, mark);
+
+        expect(result).toBe(mark);
+      });
+    });
+
+    describe('same axes constraint', () => {
+      it('returns same mark when clicking on same x-axis as root', () => {
+        const root = { x: 5, y: 3 };
+        const sameXPoint = { x: 5, y: 7 };
+        const mark = {
+          type: 'parabola',
+          root,
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        const result = parabolaTool.addPoint(sameXPoint, mark);
+
+        expect(result).toBe(mark);
+      });
+
+      it('returns same mark when clicking on same y-axis as root', () => {
+        const root = { x: 3, y: 5 };
+        const sameYPoint = { x: 7, y: 5 };
+        const mark = {
+          type: 'parabola',
+          root,
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        const result = parabolaTool.addPoint(sameYPoint, mark);
+
+        expect(result).toBe(mark);
+      });
+
+      it('allows edge point on different axes', () => {
+        const root = { x: 3, y: 5 };
+        const edge = { x: 7, y: 9 };
+        const mark = {
+          type: 'parabola',
+          root,
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        const result = parabolaTool.addPoint(edge, mark);
+
+        expect(result).not.toBe(mark);
+        expect(result.edge).toEqual(edge);
+      });
+
+      it('handles points within rounding tolerance on same x-axis', () => {
+        const root = { x: 5.00001, y: 3 };
+        const nearSameX = { x: 5.00002, y: 7 };
+        const mark = {
+          type: 'parabola',
+          root,
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        const result = parabolaTool.addPoint(nearSameX, mark);
+
+        expect(result).toBe(mark);
+      });
+
+      it('handles points within rounding tolerance on same y-axis', () => {
+        const root = { x: 3, y: 5.00001 };
+        const nearSameY = { x: 7, y: 5.00002 };
+        const mark = {
+          type: 'parabola',
+          root,
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        const result = parabolaTool.addPoint(nearSameY, mark);
+
+        expect(result).toBe(mark);
+      });
+    });
+
+    describe('error handling', () => {
+      it('throws error when mark exists but has no root', () => {
+        const mark = {
+          type: 'parabola',
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        expect(() => {
+          parabolaTool.addPoint({ x: 1, y: 2 }, mark);
+        }).toThrow('no root - should never happen');
+      });
+
+      it('throws error when mark has null root', () => {
+        const mark = {
+          type: 'parabola',
+          root: null,
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        expect(() => {
+          parabolaTool.addPoint({ x: 1, y: 2 }, mark);
+        }).toThrow('no root - should never happen');
+      });
+
+      it('throws error when mark has undefined root', () => {
+        const mark = {
+          type: 'parabola',
+          root: undefined,
+          edge: undefined,
+          closed: false,
+          building: true,
+        };
+
+        expect(() => {
+          parabolaTool.addPoint({ x: 1, y: 2 }, mark);
+        }).toThrow('no root - should never happen');
+      });
+    });
+
+    describe('coordinates', () => {
+      it('handles negative coordinates', () => {
+        const root = { x: -3, y: -5 };
+        const result = parabolaTool.addPoint(root);
+
+        expect(result.root).toEqual(root);
+      });
+
+      it('handles zero coordinates', () => {
+        const root = { x: 0, y: 0 };
+        const result = parabolaTool.addPoint(root);
+
+        expect(result.root).toEqual(root);
+      });
+
+      it('handles decimal coordinates', () => {
+        const root = { x: 1.5, y: 2.75 };
+        const result = parabolaTool.addPoint(root);
+
+        expect(result.root).toEqual(root);
+      });
+
+      it('creates parabola with negative root and positive edge', () => {
+        const mark = parabolaTool.addPoint({ x: -2, y: -3 });
+        const result = parabolaTool.addPoint({ x: 1, y: 2 }, mark);
+
+        expect(result.root).toEqual({ x: -2, y: -3 });
+        expect(result.edge).toEqual({ x: 1, y: 2 });
+      });
+    });
+  });
+
+  describe('complete', () => {
+    it('marks parabola as complete and closed', () => {
+      const mark = {
+        type: 'parabola',
+        root: { x: 1, y: 2 },
+        edge: { x: 3, y: 4 },
+        closed: false,
+        building: true,
+      };
+
+      const result = parabolaTool.complete(null, mark);
+
+      expect(result).toEqual({
+        type: 'parabola',
+        root: mark.root,
+        edge: mark.edge,
+        closed: true,
+        building: false,
+      });
+    });
+
+    it('sets building to false', () => {
+      const mark = {
+        type: 'parabola',
+        root: { x: 0, y: 0 },
+        edge: undefined,
+        closed: false,
+        building: true,
+      };
+
+      const result = parabolaTool.complete(null, mark);
+
+      expect(result.building).toBe(false);
+    });
+
+    it('sets closed to true', () => {
+      const mark = {
+        type: 'parabola',
+        root: { x: 0, y: 0 },
+        edge: undefined,
+        closed: false,
+        building: true,
+      };
+
+      const result = parabolaTool.complete(null, mark);
+
+      expect(result.closed).toBe(true);
+    });
+
+    it('preserves all mark properties', () => {
+      const mark = {
+        type: 'parabola',
+        root: { x: 1, y: 2 },
+        edge: { x: 3, y: 4 },
+        closed: false,
+        building: true,
+        label: 'Test Parabola',
+        color: 'green',
+        id: 456,
+      };
+
+      const result = parabolaTool.complete(null, mark);
+
+      expect(result.label).toBe('Test Parabola');
+      expect(result.color).toBe('green');
+      expect(result.id).toBe(456);
+    });
+
+    it('can force complete parabola with only root', () => {
+      const mark = {
+        type: 'parabola',
+        root: { x: 1, y: 2 },
+        edge: undefined,
+        closed: false,
+        building: true,
+      };
+
+      const result = parabolaTool.complete(null, mark);
+
+      expect(result.closed).toBe(true);
+      expect(result.building).toBe(false);
+      expect(result.edge).toBeUndefined();
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('creates complete parabola with two clicks', () => {
+      const root = { x: 0, y: 0 };
+      const edge = { x: 2, y: 4 };
+
+      let mark = parabolaTool.addPoint(root);
+      expect(mark.building).toBe(true);
+      expect(mark.closed).toBe(false);
+
+      mark = parabolaTool.addPoint(edge, mark);
+      expect(mark.root).toEqual(root);
+      expect(mark.edge).toEqual(edge);
+      expect(mark.building).toBe(false);
+      expect(mark.closed).toBe(true);
+    });
+
+    it('ignores clicks on same axis during construction', () => {
+      const root = { x: 0, y: 0 };
+      let mark = parabolaTool.addPoint(root);
+
+      // Try to add point on same x-axis
+      const sameXMark = parabolaTool.addPoint({ x: 0, y: 5 }, mark);
+      expect(sameXMark).toBe(mark);
+      expect(sameXMark.edge).toBeUndefined();
+
+      // Try to add point on same y-axis
+      const sameYMark = parabolaTool.addPoint({ x: 5, y: 0 }, mark);
+      expect(sameYMark).toBe(mark);
+      expect(sameYMark.edge).toBeUndefined();
+
+      // Add valid edge point
+      const finalMark = parabolaTool.addPoint({ x: 2, y: 4 }, mark);
+      expect(finalMark.edge).toEqual({ x: 2, y: 4 });
+      expect(finalMark.closed).toBe(true);
+    });
+
+    it('ignores duplicate clicks on root', () => {
+      const root = { x: 1, y: 2 };
+      let mark = parabolaTool.addPoint(root);
+
+      // Click root again
+      const sameMark = parabolaTool.addPoint(root, mark);
+      expect(sameMark).toBe(mark);
+      expect(sameMark.edge).toBeUndefined();
+    });
+
+    it('handles typical parabola in different quadrants', () => {
+      // Quadrant 1
+      let mark1 = parabolaTool.addPoint({ x: 1, y: 1 });
+      mark1 = parabolaTool.addPoint({ x: 2, y: 3 }, mark1);
+      expect(mark1.closed).toBe(true);
+
+      // Quadrant 2
+      let mark2 = parabolaTool.addPoint({ x: -1, y: 1 });
+      mark2 = parabolaTool.addPoint({ x: -2, y: 3 }, mark2);
+      expect(mark2.closed).toBe(true);
+
+      // Quadrant 3
+      let mark3 = parabolaTool.addPoint({ x: -1, y: -1 });
+      mark3 = parabolaTool.addPoint({ x: -2, y: -3 }, mark3);
+      expect(mark3.closed).toBe(true);
+
+      // Quadrant 4
+      let mark4 = parabolaTool.addPoint({ x: 1, y: -1 });
+      mark4 = parabolaTool.addPoint({ x: 2, y: -3 }, mark4);
+      expect(mark4.closed).toBe(true);
+    });
+  });
+});

package/src/tools/parabola/component.jsx

@@ -0,0 +1,23 @@
+import debug from 'debug';
+import { buildDataPoints, parabolaFromTwoPoints } from '@pie-lib/graphing-utils';
+import { rootEdgeComponent, withRootEdge } from '../shared/line/with-root-edge';
+
+const log = debug('pie-lib:graphing:parabola');
+
+const Parabola = withRootEdge((props) => {
+  const { root, edge, graphProps } = props;
+  const { domain, range } = graphProps;
+
+  const dataPoints =
+    edge && edge.x === root.x
+      ? []
+      : buildDataPoints(domain, range, root, edge, parabolaFromTwoPoints(root, edge), true);
+
+  log('dataPoints:', dataPoints);
+
+  return { root: props.root, edge: props.edge, dataPoints };
+});
+
+const Component = rootEdgeComponent(Parabola);
+
+export default Component;

package/src/tools/parabola/index.js

@@ -0,0 +1,31 @@
+import Parabola from './component';
+import debug from 'debug';
+import { equalPoints, sameAxes } from '../../utils';
+
+const log = debug('pie-lib:graphing:parabola');
+
+export const tool = () => ({
+  type: 'parabola',
+  Component: Parabola,
+  complete: (data, mark) => ({ ...mark, building: false, closed: true }),
+  addPoint: (point, mark) => {
+    log('add point to parabola model: ', point, 'mark: ', mark);
+    if (mark && (equalPoints(mark.root, point) || sameAxes(mark.root, point))) {
+      return mark;
+    }
+
+    if (!mark) {
+      return {
+        type: 'parabola',
+        root: point,
+        edge: undefined,
+        closed: false,
+        building: true,
+      };
+    } else if (mark && !mark.root) {
+      throw new Error('no root - should never happen');
+    } else {
+      return { ...mark, edge: point, closed: true, building: false };
+    }
+  },
+});