@pie-lib/graphing 3.2.0-next.0 → 3.2.0-next.2

package/lib/tools/exponential/__tests__/index.test.js

@@ -0,0 +1,828 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _index = require("../index");
+var _utils = require("../../../utils");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+jest.mock('../../../utils', function () {
+  return {
+    equalPoints: jest.fn(),
+    sameAxes: jest.fn()
+  };
+});
+jest.mock('debug', function () {
+  return jest.fn(function () {
+    return jest.fn();
+  });
+});
+describe('exponential tool', function () {
+  var exponentialTool;
+  beforeEach(function () {
+    jest.clearAllMocks();
+    exponentialTool = (0, _index.tool)();
+  });
+  describe('tool configuration', function () {
+    it('creates a tool object', function () {
+      expect(exponentialTool).toBeDefined();
+      expect((0, _typeof2["default"])(exponentialTool)).toBe('object');
+    });
+    it('has type exponential', function () {
+      expect(exponentialTool.type).toBe('exponential');
+    });
+    it('has a Component', function () {
+      expect(exponentialTool.Component).toBeDefined();
+    });
+    it('has complete function', function () {
+      expect((0, _typeof2["default"])(exponentialTool.complete)).toBe('function');
+    });
+    it('has addPoint function', function () {
+      expect((0, _typeof2["default"])(exponentialTool.addPoint)).toBe('function');
+    });
+    it('does not have hover function', function () {
+      expect(exponentialTool.hover).toBeUndefined();
+    });
+  });
+  describe('complete', function () {
+    it('marks exponential as complete', function () {
+      var data = {
+        x: 5,
+        y: 10
+      };
+      var mark = {
+        type: 'exponential',
+        root: {
+          x: 0,
+          y: 1
+        },
+        edge: {
+          x: 5,
+          y: 10
+        },
+        building: true,
+        closed: false
+      };
+      var result = exponentialTool.complete(data, mark);
+      expect(result).toEqual(_objectSpread(_objectSpread({}, mark), {}, {
+        building: false,
+        closed: true
+      }));
+    });
+    it('sets building to false', function () {
+      var mark = {
+        type: 'exponential',
+        root: {
+          x: 0,
+          y: 1
+        },
+        building: true
+      };
+      var result = exponentialTool.complete({}, mark);
+      expect(result.building).toBe(false);
+    });
+    it('sets closed to true', function () {
+      var mark = {
+        type: 'exponential',
+        root: {
+          x: 0,
+          y: 1
+        },
+        closed: false
+      };
+      var result = exponentialTool.complete({}, mark);
+      expect(result.closed).toBe(true);
+    });
+    it('preserves mark properties', function () {
+      var mark = {
+        type: 'exponential',
+        root: {
+          x: 0,
+          y: 1
+        },
+        edge: {
+          x: 5,
+          y: 10
+        },
+        label: 'Exp A',
+        correctness: {
+          value: 'correct'
+        }
+      };
+      var result = exponentialTool.complete({}, mark);
+      expect(result.label).toBe('Exp A');
+      expect(result.correctness).toEqual({
+        value: 'correct'
+      });
+      expect(result.root).toEqual(mark.root);
+      expect(result.edge).toEqual(mark.edge);
+    });
+    it('does not mutate original mark', function () {
+      var mark = {
+        type: 'exponential',
+        root: {
+          x: 0,
+          y: 1
+        },
+        building: true,
+        closed: false
+      };
+      var originalMark = _objectSpread({}, mark);
+      exponentialTool.complete({}, mark);
+      expect(mark).toEqual(originalMark);
+    });
+  });
+  describe('addPoint', function () {
+    describe('first point (creating root)', function () {
+      it('creates new exponential mark when no mark exists', function () {
+        var point = {
+          x: 0,
+          y: 5
+        };
+        var mark = null;
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result).toEqual({
+          type: 'exponential',
+          root: point,
+          edge: undefined,
+          closed: false,
+          building: true
+        });
+      });
+      it('creates mark with building true', function () {
+        var point = {
+          x: 2,
+          y: 3
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.building).toBe(true);
+      });
+      it('creates mark with closed false', function () {
+        var point = {
+          x: 2,
+          y: 3
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.closed).toBe(false);
+      });
+      it('creates mark with undefined edge', function () {
+        var point = {
+          x: 2,
+          y: 3
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.edge).toBeUndefined();
+      });
+      it('works with positive coordinates', function () {
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.root).toEqual(point);
+      });
+      it('works with negative y coordinate', function () {
+        var point = {
+          x: 5,
+          y: -10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.root).toEqual(point);
+      });
+      it('works with decimal coordinates', function () {
+        var point = {
+          x: 3.5,
+          y: 7.25
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.root).toEqual(point);
+      });
+    });
+    describe('second point (completing exponential)', function () {
+      it('completes exponential when adding edge point', function () {
+        var root = {
+          x: 0,
+          y: 1
+        };
+        var edge = {
+          x: 5,
+          y: 10
+        };
+        var mark = {
+          type: 'exponential',
+          root: root,
+          edge: undefined,
+          closed: false,
+          building: true
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(edge, mark);
+        expect(result).toEqual(_objectSpread(_objectSpread({}, mark), {}, {
+          edge: edge,
+          closed: true,
+          building: false
+        }));
+      });
+      it('sets building to false', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 0,
+            y: 1
+          },
+          building: true
+        };
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result.building).toBe(false);
+      });
+      it('sets closed to true', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 0,
+            y: 1
+          },
+          closed: false
+        };
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result.closed).toBe(true);
+      });
+      it('preserves root when adding edge', function () {
+        var root = {
+          x: 1,
+          y: 2
+        };
+        var mark = {
+          type: 'exponential',
+          root: root,
+          building: true
+        };
+        var edge = {
+          x: 5,
+          y: 8
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(edge, mark);
+        expect(result.root).toEqual(root);
+        expect(result.edge).toEqual(edge);
+      });
+      it('preserves mark properties', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 0,
+            y: 1
+          },
+          label: 'Exp 1',
+          correctness: {
+            value: 'correct'
+          }
+        };
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result.label).toBe('Exp 1');
+        expect(result.correctness).toEqual({
+          value: 'correct'
+        });
+      });
+    });
+    describe('same point handling', function () {
+      it('returns same mark when clicking equal point', function () {
+        var point = {
+          x: 5,
+          y: 10
+        };
+        var mark = {
+          type: 'exponential',
+          root: point,
+          building: true
+        };
+        _utils.equalPoints.mockReturnValue(true);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result).toBe(mark);
+      });
+      it('returns same mark when clicking point on same axis', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 5,
+            y: 10
+          },
+          building: true
+        };
+        var point = {
+          x: 8,
+          y: 10
+        }; // same y
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(true);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result).toBe(mark);
+      });
+      it('calls equalPoints with correct arguments', function () {
+        var point = {
+          x: 5,
+          y: 10
+        };
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 5,
+            y: 10
+          },
+          building: true
+        };
+        _utils.equalPoints.mockReturnValue(true);
+        exponentialTool.addPoint(point, mark);
+        expect(_utils.equalPoints).toHaveBeenCalledWith(mark.root, point);
+      });
+      it('calls sameAxes with correct arguments', function () {
+        var point = {
+          x: 8,
+          y: 10
+        };
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 5,
+            y: 10
+          },
+          building: true
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(true);
+        exponentialTool.addPoint(point, mark);
+        expect(_utils.sameAxes).toHaveBeenCalledWith(mark.root, point);
+      });
+    });
+    describe('opposite sign y-coordinates', function () {
+      it('returns same mark when root and point have opposite sign y', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 0,
+            y: 5
+          },
+          // positive y
+          building: true
+        };
+        var point = {
+          x: 5,
+          y: -10
+        }; // negative y
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result).toBe(mark);
+      });
+      it('returns same mark when root is negative and point is positive', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 0,
+            y: -5
+          },
+          // negative y
+          building: true
+        };
+        var point = {
+          x: 5,
+          y: 10
+        }; // positive y
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result).toBe(mark);
+      });
+      it('allows points with same sign y (both positive)', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 0,
+            y: 5
+          },
+          building: true
+        };
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result.edge).toEqual(point);
+        expect(result.building).toBe(false);
+      });
+      it('allows points with same sign y (both negative)', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 0,
+            y: -5
+          },
+          building: true
+        };
+        var point = {
+          x: 5,
+          y: -10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result.edge).toEqual(point);
+        expect(result.building).toBe(false);
+      });
+    });
+    describe('zero y-coordinate handling', function () {
+      it('returns same mark when point has y = 0', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 0,
+            y: 5
+          },
+          building: true
+        };
+        var point = {
+          x: 5,
+          y: 0
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result).toBe(mark);
+      });
+      it('prevents adding point with zero y', function () {
+        var point = {
+          x: 5,
+          y: 0
+        };
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 1,
+            y: 2
+          },
+          building: true
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result).toBe(mark);
+        expect(result.edge).toBeUndefined();
+      });
+      it('prevents creating root with zero y', function () {
+        var point = {
+          x: 5,
+          y: 0
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result).toBeNull();
+      });
+      it('allows positive y values close to zero', function () {
+        var point = {
+          x: 5,
+          y: 0.001
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.root).toEqual(point);
+      });
+      it('allows negative y values close to zero', function () {
+        var point = {
+          x: 5,
+          y: -0.001
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.root).toEqual(point);
+      });
+    });
+    describe('error handling', function () {
+      it('throws error when mark has no root', function () {
+        var mark = {
+          type: 'exponential',
+          building: true
+          // root is missing
+        };
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        expect(function () {
+          exponentialTool.addPoint(point, mark);
+        }).toThrow(); // Will throw TypeError when accessing undefined.y
+      });
+      it('throws error when mark root is null', function () {
+        var mark = {
+          type: 'exponential',
+          root: null,
+          building: true
+        };
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        expect(function () {
+          exponentialTool.addPoint(point, mark);
+        }).toThrow(); // Will throw TypeError when accessing null.y
+      });
+      it('throws error when mark root is undefined', function () {
+        var mark = {
+          type: 'exponential',
+          root: undefined,
+          building: true
+        };
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        expect(function () {
+          exponentialTool.addPoint(point, mark);
+        }).toThrow(); // Will throw TypeError when accessing undefined.y
+      });
+    });
+    describe('edge cases', function () {
+      it('handles undefined mark on first click', function () {
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, undefined);
+        expect(result.type).toBe('exponential');
+        expect(result.root).toEqual(point);
+        expect(result.building).toBe(true);
+      });
+      it('handles very large positive y', function () {
+        var point = {
+          x: 5,
+          y: 10000
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.root).toEqual(point);
+      });
+      it('handles very large negative y', function () {
+        var point = {
+          x: 5,
+          y: -10000
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.root).toEqual(point);
+      });
+      it('handles negative x coordinates', function () {
+        var point = {
+          x: -5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, null);
+        expect(result.root).toEqual(point);
+      });
+      it('handles mark with existing edge', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 0,
+            y: 1
+          },
+          edge: {
+            x: 3,
+            y: 3
+          },
+          building: false,
+          closed: true
+        };
+        var newEdge = {
+          x: 5,
+          y: 5
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(newEdge, mark);
+        expect(result.edge).toEqual(newEdge);
+        expect(result.closed).toBe(true);
+        expect(result.building).toBe(false);
+      });
+    });
+    describe('immutability', function () {
+      it('does not mutate original mark when adding edge', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 0,
+            y: 1
+          },
+          building: true
+        };
+        var originalMark = _objectSpread({}, mark);
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(false);
+        _utils.sameAxes.mockReturnValue(false);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(mark).toEqual(originalMark);
+        expect(result).not.toBe(mark);
+      });
+      it('does not mutate original mark when returning same', function () {
+        var mark = {
+          type: 'exponential',
+          root: {
+            x: 5,
+            y: 10
+          },
+          building: true
+        };
+        var point = {
+          x: 5,
+          y: 10
+        };
+        _utils.equalPoints.mockReturnValue(true);
+        var result = exponentialTool.addPoint(point, mark);
+        expect(result).toBe(mark);
+      });
+    });
+  });
+  describe('integration scenarios', function () {
+    it('handles full exponential creation flow', function () {
+      _utils.equalPoints.mockReturnValue(false);
+      _utils.sameAxes.mockReturnValue(false);
+
+      // First click - create root
+      var firstPoint = {
+        x: 0,
+        y: 1
+      };
+      var mark1 = exponentialTool.addPoint(firstPoint, null);
+      expect(mark1.root).toEqual(firstPoint);
+      expect(mark1.building).toBe(true);
+      expect(mark1.closed).toBe(false);
+
+      // Second click - complete exponential
+      var secondPoint = {
+        x: 5,
+        y: 10
+      };
+      var mark2 = exponentialTool.addPoint(secondPoint, mark1);
+      expect(mark2.root).toEqual(firstPoint);
+      expect(mark2.edge).toEqual(secondPoint);
+      expect(mark2.building).toBe(false);
+      expect(mark2.closed).toBe(true);
+
+      // Complete
+      var mark3 = exponentialTool.complete({}, mark2);
+      expect(mark3.building).toBe(false);
+      expect(mark3.closed).toBe(true);
+    });
+    it('handles rejected second point (zero y)', function () {
+      _utils.equalPoints.mockReturnValue(false);
+      _utils.sameAxes.mockReturnValue(false);
+      var firstPoint = {
+        x: 0,
+        y: 1
+      };
+      var mark1 = exponentialTool.addPoint(firstPoint, null);
+      var secondPoint = {
+        x: 5,
+        y: 0
+      };
+      var mark2 = exponentialTool.addPoint(secondPoint, mark1);
+
+      // Should return unchanged mark
+      expect(mark2).toBe(mark1);
+      expect(mark2.edge).toBeUndefined();
+    });
+    it('handles rejected second point (opposite sign)', function () {
+      _utils.equalPoints.mockReturnValue(false);
+      _utils.sameAxes.mockReturnValue(false);
+      var firstPoint = {
+        x: 0,
+        y: 5
+      };
+      var mark1 = exponentialTool.addPoint(firstPoint, null);
+      var secondPoint = {
+        x: 5,
+        y: -10
+      };
+      var mark2 = exponentialTool.addPoint(secondPoint, mark1);
+
+      // Should return unchanged mark
+      expect(mark2).toBe(mark1);
+      expect(mark2.edge).toBeUndefined();
+    });
+    it('handles rejected second point (same axes)', function () {
+      _utils.equalPoints.mockReturnValue(false);
+      _utils.sameAxes.mockReturnValue(true);
+      var firstPoint = {
+        x: 0,
+        y: 5
+      };
+      var mark1 = exponentialTool.addPoint(firstPoint, null);
+      var secondPoint = {
+        x: 10,
+        y: 5
+      }; // same y
+      var mark2 = exponentialTool.addPoint(secondPoint, mark1);
+
+      // Should return unchanged mark
+      expect(mark2).toBe(mark1);
+    });
+    it('handles exponential with negative y values', function () {
+      _utils.equalPoints.mockReturnValue(false);
+      _utils.sameAxes.mockReturnValue(false);
+      var firstPoint = {
+        x: 0,
+        y: -1
+      };
+      var mark1 = exponentialTool.addPoint(firstPoint, null);
+      var secondPoint = {
+        x: 5,
+        y: -10
+      };
+      var mark2 = exponentialTool.addPoint(secondPoint, mark1);
+      expect(mark2.root).toEqual(firstPoint);
+      expect(mark2.edge).toEqual(secondPoint);
+      expect(mark2.building).toBe(false);
+      expect(mark2.closed).toBe(true);
+    });
+    it('handles exponential with properties', function () {
+      _utils.equalPoints.mockReturnValue(false);
+      _utils.sameAxes.mockReturnValue(false);
+      var firstPoint = {
+        x: 0,
+        y: 1,
+        label: 'Start'
+      };
+      var mark1 = exponentialTool.addPoint(firstPoint, null);
+
+      // Add properties
+      mark1.label = 'Exp A';
+      mark1.correctness = {
+        value: 'correct'
+      };
+      var secondPoint = {
+        x: 5,
+        y: 10
+      };
+      var mark2 = exponentialTool.addPoint(secondPoint, mark1);
+      expect(mark2.label).toBe('Exp A');
+      expect(mark2.correctness).toEqual({
+        value: 'correct'
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_index","require","_utils","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","equalPoints","fn","sameAxes","describe","exponentialTool","beforeEach","clearAllMocks","tool","it","expect","toBeDefined","_typeof2","toBe","type","Component","complete","addPoint","hover","toBeUndefined","data","x","y","mark","root","edge","building","closed","result","toEqual","label","correctness","value","originalMark","point","mockReturnValue","undefined","toHaveBeenCalledWith","toBeNull","toThrow","newEdge","not","firstPoint","mark1","secondPoint","mark2","mark3"],"sources":["../../../../src/tools/exponential/__tests__/index.test.js"],"sourcesContent":["import { tool } from '../index';\nimport { equalPoints, sameAxes } from '../../../utils';\n\njest.mock('../../../utils', () => ({\n  equalPoints: jest.fn(),\n  sameAxes: jest.fn(),\n}));\n\njest.mock('debug', () => {\n  return jest.fn(() => jest.fn());\n});\n\ndescribe('exponential tool', () => {\n  let exponentialTool;\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n    exponentialTool = tool();\n  });\n\n  describe('tool configuration', () => {\n    it('creates a tool object', () => {\n      expect(exponentialTool).toBeDefined();\n      expect(typeof exponentialTool).toBe('object');\n    });\n\n    it('has type exponential', () => {\n      expect(exponentialTool.type).toBe('exponential');\n    });\n\n    it('has a Component', () => {\n      expect(exponentialTool.Component).toBeDefined();\n    });\n\n    it('has complete function', () => {\n      expect(typeof exponentialTool.complete).toBe('function');\n    });\n\n    it('has addPoint function', () => {\n      expect(typeof exponentialTool.addPoint).toBe('function');\n    });\n\n    it('does not have hover function', () => {\n      expect(exponentialTool.hover).toBeUndefined();\n    });\n  });\n\n  describe('complete', () => {\n    it('marks exponential as complete', () => {\n      const data = { x: 5, y: 10 };\n      const mark = {\n        type: 'exponential',\n        root: { x: 0, y: 1 },\n        edge: { x: 5, y: 10 },\n        building: true,\n        closed: false,\n      };\n\n      const result = exponentialTool.complete(data, mark);\n\n      expect(result).toEqual({\n        ...mark,\n        building: false,\n        closed: true,\n      });\n    });\n\n    it('sets building to false', () => {\n      const mark = {\n        type: 'exponential',\n        root: { x: 0, y: 1 },\n        building: true,\n      };\n\n      const result = exponentialTool.complete({}, mark);\n\n      expect(result.building).toBe(false);\n    });\n\n    it('sets closed to true', () => {\n      const mark = {\n        type: 'exponential',\n        root: { x: 0, y: 1 },\n        closed: false,\n      };\n\n      const result = exponentialTool.complete({}, mark);\n\n      expect(result.closed).toBe(true);\n    });\n\n    it('preserves mark properties', () => {\n      const mark = {\n        type: 'exponential',\n        root: { x: 0, y: 1 },\n        edge: { x: 5, y: 10 },\n        label: 'Exp A',\n        correctness: { value: 'correct' },\n      };\n\n      const result = exponentialTool.complete({}, mark);\n\n      expect(result.label).toBe('Exp A');\n      expect(result.correctness).toEqual({ value: 'correct' });\n      expect(result.root).toEqual(mark.root);\n      expect(result.edge).toEqual(mark.edge);\n    });\n\n    it('does not mutate original mark', () => {\n      const mark = {\n        type: 'exponential',\n        root: { x: 0, y: 1 },\n        building: true,\n        closed: false,\n      };\n      const originalMark = { ...mark };\n\n      exponentialTool.complete({}, mark);\n\n      expect(mark).toEqual(originalMark);\n    });\n  });\n\n  describe('addPoint', () => {\n    describe('first point (creating root)', () => {\n      it('creates new exponential mark when no mark exists', () => {\n        const point = { x: 0, y: 5 };\n        const mark = null;\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result).toEqual({\n          type: 'exponential',\n          root: point,\n          edge: undefined,\n          closed: false,\n          building: true,\n        });\n      });\n\n      it('creates mark with building true', () => {\n        const point = { x: 2, y: 3 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.building).toBe(true);\n      });\n\n      it('creates mark with closed false', () => {\n        const point = { x: 2, y: 3 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.closed).toBe(false);\n      });\n\n      it('creates mark with undefined edge', () => {\n        const point = { x: 2, y: 3 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.edge).toBeUndefined();\n      });\n\n      it('works with positive coordinates', () => {\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.root).toEqual(point);\n      });\n\n      it('works with negative y coordinate', () => {\n        const point = { x: 5, y: -10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.root).toEqual(point);\n      });\n\n      it('works with decimal coordinates', () => {\n        const point = { x: 3.5, y: 7.25 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.root).toEqual(point);\n      });\n    });\n\n    describe('second point (completing exponential)', () => {\n      it('completes exponential when adding edge point', () => {\n        const root = { x: 0, y: 1 };\n        const edge = { x: 5, y: 10 };\n        const mark = {\n          type: 'exponential',\n          root,\n          edge: undefined,\n          closed: false,\n          building: true,\n        };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(edge, mark);\n\n        expect(result).toEqual({\n          ...mark,\n          edge,\n          closed: true,\n          building: false,\n        });\n      });\n\n      it('sets building to false', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 0, y: 1 },\n          building: true,\n        };\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result.building).toBe(false);\n      });\n\n      it('sets closed to true', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 0, y: 1 },\n          closed: false,\n        };\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result.closed).toBe(true);\n      });\n\n      it('preserves root when adding edge', () => {\n        const root = { x: 1, y: 2 };\n        const mark = {\n          type: 'exponential',\n          root,\n          building: true,\n        };\n        const edge = { x: 5, y: 8 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(edge, mark);\n\n        expect(result.root).toEqual(root);\n        expect(result.edge).toEqual(edge);\n      });\n\n      it('preserves mark properties', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 0, y: 1 },\n          label: 'Exp 1',\n          correctness: { value: 'correct' },\n        };\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result.label).toBe('Exp 1');\n        expect(result.correctness).toEqual({ value: 'correct' });\n      });\n    });\n\n    describe('same point handling', () => {\n      it('returns same mark when clicking equal point', () => {\n        const point = { x: 5, y: 10 };\n        const mark = {\n          type: 'exponential',\n          root: point,\n          building: true,\n        };\n        equalPoints.mockReturnValue(true);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result).toBe(mark);\n      });\n\n      it('returns same mark when clicking point on same axis', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 5, y: 10 },\n          building: true,\n        };\n        const point = { x: 8, y: 10 }; // same y\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(true);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result).toBe(mark);\n      });\n\n      it('calls equalPoints with correct arguments', () => {\n        const point = { x: 5, y: 10 };\n        const mark = {\n          type: 'exponential',\n          root: { x: 5, y: 10 },\n          building: true,\n        };\n        equalPoints.mockReturnValue(true);\n\n        exponentialTool.addPoint(point, mark);\n\n        expect(equalPoints).toHaveBeenCalledWith(mark.root, point);\n      });\n\n      it('calls sameAxes with correct arguments', () => {\n        const point = { x: 8, y: 10 };\n        const mark = {\n          type: 'exponential',\n          root: { x: 5, y: 10 },\n          building: true,\n        };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(true);\n\n        exponentialTool.addPoint(point, mark);\n\n        expect(sameAxes).toHaveBeenCalledWith(mark.root, point);\n      });\n    });\n\n    describe('opposite sign y-coordinates', () => {\n      it('returns same mark when root and point have opposite sign y', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 0, y: 5 }, // positive y\n          building: true,\n        };\n        const point = { x: 5, y: -10 }; // negative y\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result).toBe(mark);\n      });\n\n      it('returns same mark when root is negative and point is positive', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 0, y: -5 }, // negative y\n          building: true,\n        };\n        const point = { x: 5, y: 10 }; // positive y\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result).toBe(mark);\n      });\n\n      it('allows points with same sign y (both positive)', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 0, y: 5 },\n          building: true,\n        };\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result.edge).toEqual(point);\n        expect(result.building).toBe(false);\n      });\n\n      it('allows points with same sign y (both negative)', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 0, y: -5 },\n          building: true,\n        };\n        const point = { x: 5, y: -10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result.edge).toEqual(point);\n        expect(result.building).toBe(false);\n      });\n    });\n\n    describe('zero y-coordinate handling', () => {\n      it('returns same mark when point has y = 0', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 0, y: 5 },\n          building: true,\n        };\n        const point = { x: 5, y: 0 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result).toBe(mark);\n      });\n\n      it('prevents adding point with zero y', () => {\n        const point = { x: 5, y: 0 };\n        const mark = {\n          type: 'exponential',\n          root: { x: 1, y: 2 },\n          building: true,\n        };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result).toBe(mark);\n        expect(result.edge).toBeUndefined();\n      });\n\n      it('prevents creating root with zero y', () => {\n        const point = { x: 5, y: 0 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result).toBeNull();\n      });\n\n      it('allows positive y values close to zero', () => {\n        const point = { x: 5, y: 0.001 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.root).toEqual(point);\n      });\n\n      it('allows negative y values close to zero', () => {\n        const point = { x: 5, y: -0.001 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.root).toEqual(point);\n      });\n    });\n\n    describe('error handling', () => {\n      it('throws error when mark has no root', () => {\n        const mark = {\n          type: 'exponential',\n          building: true,\n          // root is missing\n        };\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        expect(() => {\n          exponentialTool.addPoint(point, mark);\n        }).toThrow(); // Will throw TypeError when accessing undefined.y\n      });\n\n      it('throws error when mark root is null', () => {\n        const mark = {\n          type: 'exponential',\n          root: null,\n          building: true,\n        };\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        expect(() => {\n          exponentialTool.addPoint(point, mark);\n        }).toThrow(); // Will throw TypeError when accessing null.y\n      });\n\n      it('throws error when mark root is undefined', () => {\n        const mark = {\n          type: 'exponential',\n          root: undefined,\n          building: true,\n        };\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        expect(() => {\n          exponentialTool.addPoint(point, mark);\n        }).toThrow(); // Will throw TypeError when accessing undefined.y\n      });\n    });\n\n    describe('edge cases', () => {\n      it('handles undefined mark on first click', () => {\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, undefined);\n\n        expect(result.type).toBe('exponential');\n        expect(result.root).toEqual(point);\n        expect(result.building).toBe(true);\n      });\n\n      it('handles very large positive y', () => {\n        const point = { x: 5, y: 10000 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.root).toEqual(point);\n      });\n\n      it('handles very large negative y', () => {\n        const point = { x: 5, y: -10000 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.root).toEqual(point);\n      });\n\n      it('handles negative x coordinates', () => {\n        const point = { x: -5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, null);\n\n        expect(result.root).toEqual(point);\n      });\n\n      it('handles mark with existing edge', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 0, y: 1 },\n          edge: { x: 3, y: 3 },\n          building: false,\n          closed: true,\n        };\n        const newEdge = { x: 5, y: 5 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(newEdge, mark);\n\n        expect(result.edge).toEqual(newEdge);\n        expect(result.closed).toBe(true);\n        expect(result.building).toBe(false);\n      });\n    });\n\n    describe('immutability', () => {\n      it('does not mutate original mark when adding edge', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 0, y: 1 },\n          building: true,\n        };\n        const originalMark = { ...mark };\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(false);\n        sameAxes.mockReturnValue(false);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(mark).toEqual(originalMark);\n        expect(result).not.toBe(mark);\n      });\n\n      it('does not mutate original mark when returning same', () => {\n        const mark = {\n          type: 'exponential',\n          root: { x: 5, y: 10 },\n          building: true,\n        };\n        const point = { x: 5, y: 10 };\n        equalPoints.mockReturnValue(true);\n\n        const result = exponentialTool.addPoint(point, mark);\n\n        expect(result).toBe(mark);\n      });\n    });\n  });\n\n  describe('integration scenarios', () => {\n    it('handles full exponential creation flow', () => {\n      equalPoints.mockReturnValue(false);\n      sameAxes.mockReturnValue(false);\n\n      // First click - create root\n      const firstPoint = { x: 0, y: 1 };\n      const mark1 = exponentialTool.addPoint(firstPoint, null);\n      expect(mark1.root).toEqual(firstPoint);\n      expect(mark1.building).toBe(true);\n      expect(mark1.closed).toBe(false);\n\n      // Second click - complete exponential\n      const secondPoint = { x: 5, y: 10 };\n      const mark2 = exponentialTool.addPoint(secondPoint, mark1);\n      expect(mark2.root).toEqual(firstPoint);\n      expect(mark2.edge).toEqual(secondPoint);\n      expect(mark2.building).toBe(false);\n      expect(mark2.closed).toBe(true);\n\n      // Complete\n      const mark3 = exponentialTool.complete({}, mark2);\n      expect(mark3.building).toBe(false);\n      expect(mark3.closed).toBe(true);\n    });\n\n    it('handles rejected second point (zero y)', () => {\n      equalPoints.mockReturnValue(false);\n      sameAxes.mockReturnValue(false);\n\n      const firstPoint = { x: 0, y: 1 };\n      const mark1 = exponentialTool.addPoint(firstPoint, null);\n\n      const secondPoint = { x: 5, y: 0 };\n      const mark2 = exponentialTool.addPoint(secondPoint, mark1);\n\n      // Should return unchanged mark\n      expect(mark2).toBe(mark1);\n      expect(mark2.edge).toBeUndefined();\n    });\n\n    it('handles rejected second point (opposite sign)', () => {\n      equalPoints.mockReturnValue(false);\n      sameAxes.mockReturnValue(false);\n\n      const firstPoint = { x: 0, y: 5 };\n      const mark1 = exponentialTool.addPoint(firstPoint, null);\n\n      const secondPoint = { x: 5, y: -10 };\n      const mark2 = exponentialTool.addPoint(secondPoint, mark1);\n\n      // Should return unchanged mark\n      expect(mark2).toBe(mark1);\n      expect(mark2.edge).toBeUndefined();\n    });\n\n    it('handles rejected second point (same axes)', () => {\n      equalPoints.mockReturnValue(false);\n      sameAxes.mockReturnValue(true);\n\n      const firstPoint = { x: 0, y: 5 };\n      const mark1 = exponentialTool.addPoint(firstPoint, null);\n\n      const secondPoint = { x: 10, y: 5 }; // same y\n      const mark2 = exponentialTool.addPoint(secondPoint, mark1);\n\n      // Should return unchanged mark\n      expect(mark2).toBe(mark1);\n    });\n\n    it('handles exponential with negative y values', () => {\n      equalPoints.mockReturnValue(false);\n      sameAxes.mockReturnValue(false);\n\n      const firstPoint = { x: 0, y: -1 };\n      const mark1 = exponentialTool.addPoint(firstPoint, null);\n\n      const secondPoint = { x: 5, y: -10 };\n      const mark2 = exponentialTool.addPoint(secondPoint, mark1);\n\n      expect(mark2.root).toEqual(firstPoint);\n      expect(mark2.edge).toEqual(secondPoint);\n      expect(mark2.building).toBe(false);\n      expect(mark2.closed).toBe(true);\n    });\n\n    it('handles exponential with properties', () => {\n      equalPoints.mockReturnValue(false);\n      sameAxes.mockReturnValue(false);\n\n      const firstPoint = { x: 0, y: 1, label: 'Start' };\n      const mark1 = exponentialTool.addPoint(firstPoint, null);\n\n      // Add properties\n      mark1.label = 'Exp A';\n      mark1.correctness = { value: 'correct' };\n\n      const secondPoint = { x: 5, y: 10 };\n      const mark2 = exponentialTool.addPoint(secondPoint, mark1);\n\n      expect(mark2.label).toBe('Exp A');\n      expect(mark2.correctness).toEqual({ value: 'correct' });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}