@pie-lib/graphing 4.1.0-beta.7 → 5.0.0-next.36

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

@@ -1,828 +0,0 @@
-"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=index.test.js.map