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

package/lib/tools/shared/point/__tests__/arrow.test.js

@@ -0,0 +1,619 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _testUtils = require("@pie-lib/test-utils");
+var _react = _interopRequireDefault(require("react"));
+var _arrow = _interopRequireDefault(require("../arrow"));
+var _utils = require("../../../../__tests__/utils");
+var _utils2 = 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 _objectSpread(_objectSpread({}, jest.requireActual('../../../../utils')), {}, {
+    thinnerShapesNeeded: jest.fn(function () {
+      return false;
+    })
+  });
+});
+describe('Arrow', function () {
+  var onChange = jest.fn();
+  var renderComponent = function renderComponent(extras) {
+    var defaults = {
+      classes: {},
+      className: 'arrow-class',
+      onChange: onChange,
+      graphProps: (0, _utils.graphProps)(),
+      x: 5,
+      y: 10,
+      angle: 45
+    };
+    var props = _objectSpread(_objectSpread({}, defaults), extras);
+    return (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_arrow["default"], props));
+  };
+  beforeEach(function () {
+    onChange = jest.fn();
+    _utils2.thinnerShapesNeeded.mockReturnValue(false);
+  });
+  describe('rendering', function () {
+    it('renders without crashing', function () {
+      var _renderComponent = renderComponent(),
+        container = _renderComponent.container;
+      expect(container.firstChild).toBeInTheDocument();
+    });
+    it('renders a g element with correct class names', function () {
+      var _renderComponent2 = renderComponent({
+          classes: {
+            point: 'point-class'
+          },
+          className: 'custom-class'
+        }),
+        container = _renderComponent2.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toBeInTheDocument();
+      expect(gElement).toHaveClass('point-class');
+      expect(gElement).toHaveClass('custom-class');
+    });
+    it('renders ArrowHead component', function () {
+      var _renderComponent3 = renderComponent(),
+        container = _renderComponent3.container;
+      var polygon = container.querySelector('polygon');
+      expect(polygon).toBeInTheDocument();
+    });
+    it('applies disabled class when disabled is true', function () {
+      var _renderComponent4 = renderComponent({
+          classes: {
+            point: 'point-class',
+            disabled: 'disabled-class'
+          },
+          disabled: true
+        }),
+        container = _renderComponent4.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toHaveClass('disabled-class');
+    });
+    it('does not apply disabled class when disabled is false', function () {
+      var _renderComponent5 = renderComponent({
+          classes: {
+            point: 'point-class',
+            disabled: 'disabled-class'
+          },
+          disabled: false
+        }),
+        container = _renderComponent5.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).not.toHaveClass('disabled-class');
+    });
+    it('applies correctness class when provided', function () {
+      var _renderComponent6 = renderComponent({
+          classes: {
+            point: 'point-class',
+            correct: 'correct-class'
+          },
+          correctness: 'correct'
+        }),
+        container = _renderComponent6.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toHaveClass('correct-class');
+    });
+    it('applies incorrect correctness class', function () {
+      var _renderComponent7 = renderComponent({
+          classes: {
+            point: 'point-class',
+            incorrect: 'incorrect-class'
+          },
+          correctness: 'incorrect'
+        }),
+        container = _renderComponent7.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toHaveClass('incorrect-class');
+    });
+  });
+  describe('size calculation', function () {
+    it('uses size 14 when thinnerShapesNeeded returns false', function () {
+      _utils2.thinnerShapesNeeded.mockReturnValue(false);
+      var _renderComponent8 = renderComponent({
+          x: 0,
+          y: 0
+        }),
+        container = _renderComponent8.container;
+      var polygon = container.querySelector('polygon');
+
+      // Expected points: "0,0 -14,-7 -14,7"
+      expect(polygon).toHaveAttribute('points');
+      var points = polygon.getAttribute('points');
+      expect(points).toContain('-14');
+    });
+    it('uses size 12 when thinnerShapesNeeded returns true', function () {
+      _utils2.thinnerShapesNeeded.mockReturnValue(true);
+      var _renderComponent9 = renderComponent({
+          x: 0,
+          y: 0
+        }),
+        container = _renderComponent9.container;
+      var polygon = container.querySelector('polygon');
+
+      // Expected points: "0,0 -12,-6 -12,6"
+      expect(polygon).toHaveAttribute('points');
+      var points = polygon.getAttribute('points');
+      expect(points).toContain('-12');
+    });
+    it('calls thinnerShapesNeeded with graphProps', function () {
+      var gp = (0, _utils.graphProps)();
+      renderComponent({
+        graphProps: gp
+      });
+      expect(_utils2.thinnerShapesNeeded).toHaveBeenCalledWith(gp);
+    });
+  });
+  describe('coordinate scaling', function () {
+    it('scales x and y coordinates using graphProps.scale', function () {
+      var mockScale = {
+        x: jest.fn(function (n) {
+          return n * 10;
+        }),
+        y: jest.fn(function (n) {
+          return n * 20;
+        })
+      };
+      var gp = _objectSpread(_objectSpread({}, (0, _utils.graphProps)()), {}, {
+        scale: mockScale
+      });
+      renderComponent({
+        x: 5,
+        y: 10,
+        graphProps: gp
+      });
+      expect(mockScale.x).toHaveBeenCalledWith(5);
+      expect(mockScale.y).toHaveBeenCalledWith(10);
+    });
+    it('renders arrow with scaled coordinates', function () {
+      var mockScale = {
+        x: jest.fn(function (n) {
+          return n * 2;
+        }),
+        y: jest.fn(function (n) {
+          return n * 3;
+        })
+      };
+      var gp = _objectSpread(_objectSpread({}, (0, _utils.graphProps)()), {}, {
+        scale: mockScale
+      });
+      var _renderComponent0 = renderComponent({
+          x: 5,
+          y: 10,
+          graphProps: gp,
+          angle: 0
+        }),
+        container = _renderComponent0.container;
+      var polygon = container.querySelector('polygon');
+
+      // scaledX = 5 * 2 = 10, scaledY = 10 * 3 = 30
+      // Expected points: "10,30 -4,23 -4,37" (with size 14)
+      var points = polygon.getAttribute('points');
+      expect(points).toContain('10');
+      expect(points).toContain('30');
+    });
+  });
+  describe('angle rotation', function () {
+    it('applies rotation transform with negative angle', function () {
+      var _renderComponent1 = renderComponent({
+          x: 5,
+          y: 10,
+          angle: 45
+        }),
+        container = _renderComponent1.container;
+      var polygon = container.querySelector('polygon');
+      var transform = polygon.getAttribute('transform');
+
+      // Angle should be negated: rotate(-45, 5, 10)
+      expect(transform).toContain('rotate(-45');
+      expect(transform).toContain('5');
+      expect(transform).toContain('10');
+    });
+    it('handles zero angle', function () {
+      var _renderComponent10 = renderComponent({
+          x: 3,
+          y: 7,
+          angle: 0
+        }),
+        container = _renderComponent10.container;
+      var polygon = container.querySelector('polygon');
+      var transform = polygon.getAttribute('transform');
+
+      // will convert -0 to 0
+      expect(transform).toMatch(/rotate\((-)?0/);
+      expect(transform).toContain('3');
+      expect(transform).toContain('7');
+    });
+    it('handles negative angle', function () {
+      var _renderComponent11 = renderComponent({
+          x: 2,
+          y: 4,
+          angle: -30
+        }),
+        container = _renderComponent11.container;
+      var polygon = container.querySelector('polygon');
+      var transform = polygon.getAttribute('transform');
+
+      // -(-30) = 30
+      expect(transform).toContain('rotate(30');
+      expect(transform).toContain('2');
+      expect(transform).toContain('4');
+    });
+    it('handles 360 degree angle', function () {
+      var _renderComponent12 = renderComponent({
+          x: 1,
+          y: 1,
+          angle: 360
+        }),
+        container = _renderComponent12.container;
+      var polygon = container.querySelector('polygon');
+      var transform = polygon.getAttribute('transform');
+      expect(transform).toContain('rotate(-360');
+    });
+  });
+  describe('arrow points calculation', function () {
+    it('calculates correct points for arrow head', function () {
+      _utils2.thinnerShapesNeeded.mockReturnValue(false);
+      var _renderComponent13 = renderComponent({
+          x: 0,
+          y: 0,
+          angle: 0
+        }),
+        container = _renderComponent13.container;
+      var polygon = container.querySelector('polygon');
+
+      // size = 14
+      // points = "0,0 -14,-7 -14, 7" (note the space after comma in the template literal)
+      var points = polygon.getAttribute('points');
+      expect(points).toContain('0,0');
+      expect(points).toContain('-14,-7');
+      expect(points).toMatch(/-14,\s*7/);
+    });
+    it('calculates points with scaled coordinates', function () {
+      _utils2.thinnerShapesNeeded.mockReturnValue(false);
+      var mockScale = {
+        x: jest.fn(function (n) {
+          return n;
+        }),
+        y: jest.fn(function (n) {
+          return n;
+        })
+      };
+      var gp = _objectSpread(_objectSpread({}, (0, _utils.graphProps)()), {}, {
+        scale: mockScale
+      });
+      var _renderComponent14 = renderComponent({
+          x: 10,
+          y: 20,
+          graphProps: gp
+        }),
+        container = _renderComponent14.container;
+      var polygon = container.querySelector('polygon');
+
+      // scaledX = 10, scaledY = 20, size = 14
+      // points = "10,20 -4,13 -4, 27" (note the space after comma in the template literal)
+      var points = polygon.getAttribute('points');
+      expect(points).toContain('10,20');
+      expect(points).toContain('-4,13');
+      expect(points).toMatch(/-4,\s*27/);
+    });
+  });
+  describe('props handling', function () {
+    it('passes through additional props to g element', function () {
+      var _renderComponent15 = renderComponent({
+          'data-test': 'arrow-test',
+          role: 'graphics-symbol'
+        }),
+        container = _renderComponent15.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toHaveAttribute('data-test', 'arrow-test');
+      expect(gElement).toHaveAttribute('role', 'graphics-symbol');
+    });
+    it('excludes filtered props from g element', function () {
+      var _renderComponent16 = renderComponent({
+          x: 5,
+          y: 10,
+          angle: 45,
+          disabled: false,
+          correctness: 'correct',
+          graphProps: (0, _utils.graphProps)()
+        }),
+        container = _renderComponent16.container;
+      var gElement = container.querySelector('g');
+
+      // These props should not be passed to the g element
+      expect(gElement).not.toHaveAttribute('x');
+      expect(gElement).not.toHaveAttribute('y');
+      expect(gElement).not.toHaveAttribute('angle');
+      expect(gElement).not.toHaveAttribute('disabled');
+      expect(gElement).not.toHaveAttribute('correctness');
+      expect(gElement).not.toHaveAttribute('graphProps');
+    });
+  });
+  describe('edge cases', function () {
+    it('handles zero coordinates', function () {
+      var _renderComponent17 = renderComponent({
+          x: 0,
+          y: 0,
+          angle: 0
+        }),
+        container = _renderComponent17.container;
+      var polygon = container.querySelector('polygon');
+      expect(polygon).toBeInTheDocument();
+      expect(polygon.getAttribute('points')).toBeTruthy();
+      expect(polygon.getAttribute('transform')).toBeTruthy();
+    });
+    it('handles negative coordinates', function () {
+      var _renderComponent18 = renderComponent({
+          x: -5,
+          y: -10,
+          angle: 0
+        }),
+        container = _renderComponent18.container;
+      var polygon = container.querySelector('polygon');
+      expect(polygon).toBeInTheDocument();
+      expect(polygon.getAttribute('points')).toBeTruthy();
+      expect(polygon.getAttribute('transform')).toBeTruthy();
+    });
+    it('handles large coordinates', function () {
+      var _renderComponent19 = renderComponent({
+          x: 1000,
+          y: 2000,
+          angle: 0
+        }),
+        container = _renderComponent19.container;
+      var polygon = container.querySelector('polygon');
+      expect(polygon).toBeInTheDocument();
+    });
+    it('handles fractional coordinates', function () {
+      var _renderComponent20 = renderComponent({
+          x: 3.5,
+          y: 7.25,
+          angle: 22.5
+        }),
+        container = _renderComponent20.container;
+      var polygon = container.querySelector('polygon');
+      expect(polygon).toBeInTheDocument();
+      expect(polygon.getAttribute('transform')).toContain('rotate(-22.5');
+    });
+    it('renders with empty classes prop', function () {
+      var _render = (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_arrow["default"], {
+          x: 5,
+          y: 10,
+          angle: 45,
+          graphProps: (0, _utils.graphProps)(),
+          classes: {}
+        })),
+        container = _render.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toBeInTheDocument();
+    });
+    it('renders without className prop', function () {
+      var _render2 = (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_arrow["default"], {
+          x: 5,
+          y: 10,
+          angle: 45,
+          graphProps: (0, _utils.graphProps)(),
+          classes: {}
+        })),
+        container = _render2.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toBeInTheDocument();
+    });
+  });
+  describe('graphProps integration', function () {
+    it('works with different domain and range values', function () {
+      var gp = (0, _utils.graphProps)(-10, 10, -20, 20);
+      var _renderComponent21 = renderComponent({
+          graphProps: gp
+        }),
+        container = _renderComponent21.container;
+      expect(container.querySelector('polygon')).toBeInTheDocument();
+      expect(_utils2.thinnerShapesNeeded).toHaveBeenCalledWith(gp);
+    });
+    it('works with custom size in graphProps', function () {
+      var gp = _objectSpread(_objectSpread({}, (0, _utils.graphProps)()), {}, {
+        size: {
+          width: 800,
+          height: 600
+        }
+      });
+      var _renderComponent22 = renderComponent({
+          graphProps: gp
+        }),
+        container = _renderComponent22.container;
+      expect(container.querySelector('polygon')).toBeInTheDocument();
+    });
+    it('handles graphProps with small step values', function () {
+      var gp = _objectSpread(_objectSpread({}, (0, _utils.graphProps)()), {}, {
+        domain: {
+          min: 0,
+          max: 10,
+          step: 0.1
+        },
+        range: {
+          min: 0,
+          max: 10,
+          step: 0.1
+        }
+      });
+      _utils2.thinnerShapesNeeded.mockReturnValue(true);
+      var _renderComponent23 = renderComponent({
+          graphProps: gp
+        }),
+        container = _renderComponent23.container;
+      var polygon = container.querySelector('polygon');
+
+      // Should use size 12 for thinner shapes
+      expect(polygon).toBeInTheDocument();
+      expect(_utils2.thinnerShapesNeeded).toHaveBeenCalledWith(gp);
+    });
+  });
+  describe('multiple correctness states', function () {
+    it('handles partial correctness', function () {
+      var _renderComponent24 = renderComponent({
+          classes: {
+            point: 'point-class',
+            partial: 'partial-class'
+          },
+          correctness: 'partial'
+        }),
+        container = _renderComponent24.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toHaveClass('partial-class');
+    });
+    it('handles undefined correctness', function () {
+      var _renderComponent25 = renderComponent({
+          classes: {
+            point: 'point-class'
+          },
+          correctness: undefined
+        }),
+        container = _renderComponent25.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toHaveClass('point-class');
+    });
+    it('handles null correctness', function () {
+      var _renderComponent26 = renderComponent({
+          classes: {
+            point: 'point-class'
+          },
+          correctness: null
+        }),
+        container = _renderComponent26.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toHaveClass('point-class');
+    });
+  });
+  describe('combined states', function () {
+    it('handles disabled and correct states together', function () {
+      var _renderComponent27 = renderComponent({
+          classes: {
+            point: 'point-class',
+            disabled: 'disabled-class',
+            correct: 'correct-class'
+          },
+          disabled: true,
+          correctness: 'correct'
+        }),
+        container = _renderComponent27.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toHaveClass('point-class');
+      expect(gElement).toHaveClass('disabled-class');
+      expect(gElement).toHaveClass('correct-class');
+    });
+    it('handles disabled and incorrect states together', function () {
+      var _renderComponent28 = renderComponent({
+          classes: {
+            point: 'point-class',
+            disabled: 'disabled-class',
+            incorrect: 'incorrect-class'
+          },
+          disabled: true,
+          correctness: 'incorrect'
+        }),
+        container = _renderComponent28.container;
+      var gElement = container.querySelector('g');
+      expect(gElement).toHaveClass('point-class');
+      expect(gElement).toHaveClass('disabled-class');
+      expect(gElement).toHaveClass('incorrect-class');
+    });
+  });
+  describe('re-rendering', function () {
+    it('updates when x coordinate changes', function () {
+      var _renderComponent29 = renderComponent({
+          x: 5,
+          y: 10,
+          angle: 0
+        }),
+        container = _renderComponent29.container,
+        rerender = _renderComponent29.rerender;
+      var polygon = container.querySelector('polygon');
+      var initialPoints = polygon.getAttribute('points');
+      rerender(/*#__PURE__*/_react["default"].createElement(_arrow["default"], {
+        x: 15,
+        y: 10,
+        angle: 0,
+        graphProps: (0, _utils.graphProps)(),
+        classes: {},
+        className: "arrow-class"
+      }));
+      polygon = container.querySelector('polygon');
+      var newPoints = polygon.getAttribute('points');
+      expect(newPoints).not.toBe(initialPoints);
+    });
+    it('updates when y coordinate changes', function () {
+      var _renderComponent30 = renderComponent({
+          x: 5,
+          y: 10,
+          angle: 0
+        }),
+        container = _renderComponent30.container,
+        rerender = _renderComponent30.rerender;
+      var polygon = container.querySelector('polygon');
+      var initialPoints = polygon.getAttribute('points');
+      rerender(/*#__PURE__*/_react["default"].createElement(_arrow["default"], {
+        x: 5,
+        y: 20,
+        angle: 0,
+        graphProps: (0, _utils.graphProps)(),
+        classes: {},
+        className: "arrow-class"
+      }));
+      polygon = container.querySelector('polygon');
+      var newPoints = polygon.getAttribute('points');
+      expect(newPoints).not.toBe(initialPoints);
+    });
+    it('updates when angle changes', function () {
+      var _renderComponent31 = renderComponent({
+          x: 5,
+          y: 10,
+          angle: 0
+        }),
+        container = _renderComponent31.container,
+        rerender = _renderComponent31.rerender;
+      var polygon = container.querySelector('polygon');
+      var initialTransform = polygon.getAttribute('transform');
+      rerender(/*#__PURE__*/_react["default"].createElement(_arrow["default"], {
+        x: 5,
+        y: 10,
+        angle: 90,
+        graphProps: (0, _utils.graphProps)(),
+        classes: {},
+        className: "arrow-class"
+      }));
+      polygon = container.querySelector('polygon');
+      var newTransform = polygon.getAttribute('transform');
+      expect(newTransform).not.toBe(initialTransform);
+      expect(newTransform).toContain('rotate(-90');
+    });
+    it('updates when thinnerShapesNeeded result changes', function () {
+      _utils2.thinnerShapesNeeded.mockReturnValue(false);
+      var _renderComponent32 = renderComponent({
+          x: 0,
+          y: 0,
+          angle: 0
+        }),
+        container = _renderComponent32.container,
+        rerender = _renderComponent32.rerender;
+      var polygon = container.querySelector('polygon');
+      var initialPoints = polygon.getAttribute('points');
+      _utils2.thinnerShapesNeeded.mockReturnValue(true);
+      rerender(/*#__PURE__*/_react["default"].createElement(_arrow["default"], {
+        x: 0,
+        y: 0,
+        angle: 0,
+        graphProps: (0, _utils.graphProps)(),
+        classes: {},
+        className: "arrow-class"
+      }));
+      polygon = container.querySelector('polygon');
+      var newPoints = polygon.getAttribute('points');
+      // Points should change due to size change (14 vs 12)
+      expect(newPoints).not.toBe(initialPoints);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_testUtils","require","_react","_interopRequireDefault","_arrow","_utils","_utils2","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","requireActual","thinnerShapesNeeded","fn","describe","onChange","renderComponent","extras","defaults","classes","className","graphProps","x","y","angle","props","render","createElement","beforeEach","mockReturnValue","it","_renderComponent","container","expect","firstChild","toBeInTheDocument","_renderComponent2","point","gElement","querySelector","toHaveClass","_renderComponent3","polygon","_renderComponent4","disabled","_renderComponent5","not","_renderComponent6","correct","correctness","_renderComponent7","incorrect","_renderComponent8","toHaveAttribute","points","getAttribute","toContain","_renderComponent9","gp","toHaveBeenCalledWith","mockScale","n","scale","_renderComponent0","_renderComponent1","transform","_renderComponent10","toMatch","_renderComponent11","_renderComponent12","_renderComponent13","_renderComponent14","_renderComponent15","role","_renderComponent16","_renderComponent17","toBeTruthy","_renderComponent18","_renderComponent19","_renderComponent20","_render","_render2","_renderComponent21","size","width","height","_renderComponent22","domain","min","max","step","range","_renderComponent23","_renderComponent24","partial","_renderComponent25","undefined","_renderComponent26","_renderComponent27","_renderComponent28","_renderComponent29","rerender","initialPoints","newPoints","toBe","_renderComponent30","_renderComponent31","initialTransform","newTransform","_renderComponent32"],"sources":["../../../../../src/tools/shared/point/__tests__/arrow.test.jsx"],"sourcesContent":["import { render } from '@pie-lib/test-utils';\nimport React from 'react';\nimport Arrow from '../arrow';\nimport { graphProps } from '../../../../__tests__/utils';\nimport { thinnerShapesNeeded } from '../../../../utils';\n\njest.mock('../../../../utils', () => ({\n  ...jest.requireActual('../../../../utils'),\n  thinnerShapesNeeded: jest.fn(() => false),\n}));\n\ndescribe('Arrow', () => {\n  let onChange = jest.fn();\n\n  const renderComponent = (extras) => {\n    const defaults = {\n      classes: {},\n      className: 'arrow-class',\n      onChange,\n      graphProps: graphProps(),\n      x: 5,\n      y: 10,\n      angle: 45,\n    };\n    const props = { ...defaults, ...extras };\n    return render(<Arrow {...props} />);\n  };\n\n  beforeEach(() => {\n    onChange = jest.fn();\n    thinnerShapesNeeded.mockReturnValue(false);\n  });\n\n  describe('rendering', () => {\n    it('renders without crashing', () => {\n      const { container } = renderComponent();\n      expect(container.firstChild).toBeInTheDocument();\n    });\n\n    it('renders a g element with correct class names', () => {\n      const { container } = renderComponent({\n        classes: { point: 'point-class' },\n        className: 'custom-class',\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).toBeInTheDocument();\n      expect(gElement).toHaveClass('point-class');\n      expect(gElement).toHaveClass('custom-class');\n    });\n\n    it('renders ArrowHead component', () => {\n      const { container } = renderComponent();\n      const polygon = container.querySelector('polygon');\n      expect(polygon).toBeInTheDocument();\n    });\n\n    it('applies disabled class when disabled is true', () => {\n      const { container } = renderComponent({\n        classes: { point: 'point-class', disabled: 'disabled-class' },\n        disabled: true,\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).toHaveClass('disabled-class');\n    });\n\n    it('does not apply disabled class when disabled is false', () => {\n      const { container } = renderComponent({\n        classes: { point: 'point-class', disabled: 'disabled-class' },\n        disabled: false,\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).not.toHaveClass('disabled-class');\n    });\n\n    it('applies correctness class when provided', () => {\n      const { container } = renderComponent({\n        classes: { point: 'point-class', correct: 'correct-class' },\n        correctness: 'correct',\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).toHaveClass('correct-class');\n    });\n\n    it('applies incorrect correctness class', () => {\n      const { container } = renderComponent({\n        classes: { point: 'point-class', incorrect: 'incorrect-class' },\n        correctness: 'incorrect',\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).toHaveClass('incorrect-class');\n    });\n  });\n\n  describe('size calculation', () => {\n    it('uses size 14 when thinnerShapesNeeded returns false', () => {\n      thinnerShapesNeeded.mockReturnValue(false);\n      const { container } = renderComponent({ x: 0, y: 0 });\n      const polygon = container.querySelector('polygon');\n\n      // Expected points: \"0,0 -14,-7 -14,7\"\n      expect(polygon).toHaveAttribute('points');\n      const points = polygon.getAttribute('points');\n      expect(points).toContain('-14');\n    });\n\n    it('uses size 12 when thinnerShapesNeeded returns true', () => {\n      thinnerShapesNeeded.mockReturnValue(true);\n      const { container } = renderComponent({ x: 0, y: 0 });\n      const polygon = container.querySelector('polygon');\n\n      // Expected points: \"0,0 -12,-6 -12,6\"\n      expect(polygon).toHaveAttribute('points');\n      const points = polygon.getAttribute('points');\n      expect(points).toContain('-12');\n    });\n\n    it('calls thinnerShapesNeeded with graphProps', () => {\n      const gp = graphProps();\n      renderComponent({ graphProps: gp });\n      expect(thinnerShapesNeeded).toHaveBeenCalledWith(gp);\n    });\n  });\n\n  describe('coordinate scaling', () => {\n    it('scales x and y coordinates using graphProps.scale', () => {\n      const mockScale = {\n        x: jest.fn((n) => n * 10),\n        y: jest.fn((n) => n * 20),\n      };\n      const gp = {\n        ...graphProps(),\n        scale: mockScale,\n      };\n\n      renderComponent({ x: 5, y: 10, graphProps: gp });\n\n      expect(mockScale.x).toHaveBeenCalledWith(5);\n      expect(mockScale.y).toHaveBeenCalledWith(10);\n    });\n\n    it('renders arrow with scaled coordinates', () => {\n      const mockScale = {\n        x: jest.fn((n) => n * 2),\n        y: jest.fn((n) => n * 3),\n      };\n      const gp = {\n        ...graphProps(),\n        scale: mockScale,\n      };\n\n      const { container } = renderComponent({ x: 5, y: 10, graphProps: gp, angle: 0 });\n      const polygon = container.querySelector('polygon');\n\n      // scaledX = 5 * 2 = 10, scaledY = 10 * 3 = 30\n      // Expected points: \"10,30 -4,23 -4,37\" (with size 14)\n      const points = polygon.getAttribute('points');\n      expect(points).toContain('10');\n      expect(points).toContain('30');\n    });\n  });\n\n  describe('angle rotation', () => {\n    it('applies rotation transform with negative angle', () => {\n      const { container } = renderComponent({ x: 5, y: 10, angle: 45 });\n      const polygon = container.querySelector('polygon');\n      const transform = polygon.getAttribute('transform');\n\n      // Angle should be negated: rotate(-45, 5, 10)\n      expect(transform).toContain('rotate(-45');\n      expect(transform).toContain('5');\n      expect(transform).toContain('10');\n    });\n\n    it('handles zero angle', () => {\n      const { container } = renderComponent({ x: 3, y: 7, angle: 0 });\n      const polygon = container.querySelector('polygon');\n      const transform = polygon.getAttribute('transform');\n\n      // will convert -0 to 0\n      expect(transform).toMatch(/rotate\\((-)?0/);\n      expect(transform).toContain('3');\n      expect(transform).toContain('7');\n    });\n\n    it('handles negative angle', () => {\n      const { container } = renderComponent({ x: 2, y: 4, angle: -30 });\n      const polygon = container.querySelector('polygon');\n      const transform = polygon.getAttribute('transform');\n\n      // -(-30) = 30\n      expect(transform).toContain('rotate(30');\n      expect(transform).toContain('2');\n      expect(transform).toContain('4');\n    });\n\n    it('handles 360 degree angle', () => {\n      const { container } = renderComponent({ x: 1, y: 1, angle: 360 });\n      const polygon = container.querySelector('polygon');\n      const transform = polygon.getAttribute('transform');\n\n      expect(transform).toContain('rotate(-360');\n    });\n  });\n\n  describe('arrow points calculation', () => {\n    it('calculates correct points for arrow head', () => {\n      thinnerShapesNeeded.mockReturnValue(false);\n      const { container } = renderComponent({ x: 0, y: 0, angle: 0 });\n      const polygon = container.querySelector('polygon');\n\n      // size = 14\n      // points = \"0,0 -14,-7 -14, 7\" (note the space after comma in the template literal)\n      const points = polygon.getAttribute('points');\n      expect(points).toContain('0,0');\n      expect(points).toContain('-14,-7');\n      expect(points).toMatch(/-14,\\s*7/);\n    });\n\n    it('calculates points with scaled coordinates', () => {\n      thinnerShapesNeeded.mockReturnValue(false);\n      const mockScale = {\n        x: jest.fn((n) => n),\n        y: jest.fn((n) => n),\n      };\n      const gp = {\n        ...graphProps(),\n        scale: mockScale,\n      };\n\n      const { container } = renderComponent({ x: 10, y: 20, graphProps: gp });\n      const polygon = container.querySelector('polygon');\n\n      // scaledX = 10, scaledY = 20, size = 14\n      // points = \"10,20 -4,13 -4, 27\" (note the space after comma in the template literal)\n      const points = polygon.getAttribute('points');\n      expect(points).toContain('10,20');\n      expect(points).toContain('-4,13');\n      expect(points).toMatch(/-4,\\s*27/);\n    });\n  });\n\n  describe('props handling', () => {\n    it('passes through additional props to g element', () => {\n      const { container } = renderComponent({\n        'data-test': 'arrow-test',\n        role: 'graphics-symbol',\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).toHaveAttribute('data-test', 'arrow-test');\n      expect(gElement).toHaveAttribute('role', 'graphics-symbol');\n    });\n\n    it('excludes filtered props from g element', () => {\n      const { container } = renderComponent({\n        x: 5,\n        y: 10,\n        angle: 45,\n        disabled: false,\n        correctness: 'correct',\n        graphProps: graphProps(),\n      });\n      const gElement = container.querySelector('g');\n\n      // These props should not be passed to the g element\n      expect(gElement).not.toHaveAttribute('x');\n      expect(gElement).not.toHaveAttribute('y');\n      expect(gElement).not.toHaveAttribute('angle');\n      expect(gElement).not.toHaveAttribute('disabled');\n      expect(gElement).not.toHaveAttribute('correctness');\n      expect(gElement).not.toHaveAttribute('graphProps');\n    });\n  });\n\n  describe('edge cases', () => {\n    it('handles zero coordinates', () => {\n      const { container } = renderComponent({ x: 0, y: 0, angle: 0 });\n      const polygon = container.querySelector('polygon');\n      expect(polygon).toBeInTheDocument();\n      expect(polygon.getAttribute('points')).toBeTruthy();\n      expect(polygon.getAttribute('transform')).toBeTruthy();\n    });\n\n    it('handles negative coordinates', () => {\n      const { container } = renderComponent({ x: -5, y: -10, angle: 0 });\n      const polygon = container.querySelector('polygon');\n      expect(polygon).toBeInTheDocument();\n      expect(polygon.getAttribute('points')).toBeTruthy();\n      expect(polygon.getAttribute('transform')).toBeTruthy();\n    });\n\n    it('handles large coordinates', () => {\n      const { container } = renderComponent({ x: 1000, y: 2000, angle: 0 });\n      const polygon = container.querySelector('polygon');\n      expect(polygon).toBeInTheDocument();\n    });\n\n    it('handles fractional coordinates', () => {\n      const { container } = renderComponent({ x: 3.5, y: 7.25, angle: 22.5 });\n      const polygon = container.querySelector('polygon');\n      expect(polygon).toBeInTheDocument();\n      expect(polygon.getAttribute('transform')).toContain('rotate(-22.5');\n    });\n\n    it('renders with empty classes prop', () => {\n      const { container } = render(<Arrow x={5} y={10} angle={45} graphProps={graphProps()} classes={{}} />);\n      const gElement = container.querySelector('g');\n      expect(gElement).toBeInTheDocument();\n    });\n\n    it('renders without className prop', () => {\n      const { container } = render(<Arrow x={5} y={10} angle={45} graphProps={graphProps()} classes={{}} />);\n      const gElement = container.querySelector('g');\n      expect(gElement).toBeInTheDocument();\n    });\n  });\n\n  describe('graphProps integration', () => {\n    it('works with different domain and range values', () => {\n      const gp = graphProps(-10, 10, -20, 20);\n      const { container } = renderComponent({ graphProps: gp });\n      expect(container.querySelector('polygon')).toBeInTheDocument();\n      expect(thinnerShapesNeeded).toHaveBeenCalledWith(gp);\n    });\n\n    it('works with custom size in graphProps', () => {\n      const gp = {\n        ...graphProps(),\n        size: {\n          width: 800,\n          height: 600,\n        },\n      };\n      const { container } = renderComponent({ graphProps: gp });\n      expect(container.querySelector('polygon')).toBeInTheDocument();\n    });\n\n    it('handles graphProps with small step values', () => {\n      const gp = {\n        ...graphProps(),\n        domain: { min: 0, max: 10, step: 0.1 },\n        range: { min: 0, max: 10, step: 0.1 },\n      };\n      thinnerShapesNeeded.mockReturnValue(true);\n      const { container } = renderComponent({ graphProps: gp });\n      const polygon = container.querySelector('polygon');\n\n      // Should use size 12 for thinner shapes\n      expect(polygon).toBeInTheDocument();\n      expect(thinnerShapesNeeded).toHaveBeenCalledWith(gp);\n    });\n  });\n\n  describe('multiple correctness states', () => {\n    it('handles partial correctness', () => {\n      const { container } = renderComponent({\n        classes: { point: 'point-class', partial: 'partial-class' },\n        correctness: 'partial',\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).toHaveClass('partial-class');\n    });\n\n    it('handles undefined correctness', () => {\n      const { container } = renderComponent({\n        classes: { point: 'point-class' },\n        correctness: undefined,\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).toHaveClass('point-class');\n    });\n\n    it('handles null correctness', () => {\n      const { container } = renderComponent({\n        classes: { point: 'point-class' },\n        correctness: null,\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).toHaveClass('point-class');\n    });\n  });\n\n  describe('combined states', () => {\n    it('handles disabled and correct states together', () => {\n      const { container } = renderComponent({\n        classes: {\n          point: 'point-class',\n          disabled: 'disabled-class',\n          correct: 'correct-class',\n        },\n        disabled: true,\n        correctness: 'correct',\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).toHaveClass('point-class');\n      expect(gElement).toHaveClass('disabled-class');\n      expect(gElement).toHaveClass('correct-class');\n    });\n\n    it('handles disabled and incorrect states together', () => {\n      const { container } = renderComponent({\n        classes: {\n          point: 'point-class',\n          disabled: 'disabled-class',\n          incorrect: 'incorrect-class',\n        },\n        disabled: true,\n        correctness: 'incorrect',\n      });\n      const gElement = container.querySelector('g');\n      expect(gElement).toHaveClass('point-class');\n      expect(gElement).toHaveClass('disabled-class');\n      expect(gElement).toHaveClass('incorrect-class');\n    });\n  });\n\n  describe('re-rendering', () => {\n    it('updates when x coordinate changes', () => {\n      const { container, rerender } = renderComponent({ x: 5, y: 10, angle: 0 });\n      let polygon = container.querySelector('polygon');\n      const initialPoints = polygon.getAttribute('points');\n\n      rerender(<Arrow x={15} y={10} angle={0} graphProps={graphProps()} classes={{}} className=\"arrow-class\" />);\n\n      polygon = container.querySelector('polygon');\n      const newPoints = polygon.getAttribute('points');\n      expect(newPoints).not.toBe(initialPoints);\n    });\n\n    it('updates when y coordinate changes', () => {\n      const { container, rerender } = renderComponent({ x: 5, y: 10, angle: 0 });\n      let polygon = container.querySelector('polygon');\n      const initialPoints = polygon.getAttribute('points');\n\n      rerender(<Arrow x={5} y={20} angle={0} graphProps={graphProps()} classes={{}} className=\"arrow-class\" />);\n\n      polygon = container.querySelector('polygon');\n      const newPoints = polygon.getAttribute('points');\n      expect(newPoints).not.toBe(initialPoints);\n    });\n\n    it('updates when angle changes', () => {\n      const { container, rerender } = renderComponent({ x: 5, y: 10, angle: 0 });\n      let polygon = container.querySelector('polygon');\n      const initialTransform = polygon.getAttribute('transform');\n\n      rerender(<Arrow x={5} y={10} angle={90} graphProps={graphProps()} classes={{}} className=\"arrow-class\" />);\n\n      polygon = container.querySelector('polygon');\n      const newTransform = polygon.getAttribute('transform');\n      expect(newTransform).not.toBe(initialTransform);\n      expect(newTransform).toContain('rotate(-90');\n    });\n\n    it('updates when thinnerShapesNeeded result changes', () => {\n      thinnerShapesNeeded.mockReturnValue(false);\n      const { container, rerender } = renderComponent({ x: 0, y: 0, angle: 0 });\n      let polygon = container.querySelector('polygon');\n      const initialPoints = polygon.getAttribute('points');\n\n      thinnerShapesNeeded.mockReturnValue(true);\n      rerender(<Arrow x={0} y={0} angle={0} graphProps={graphProps()} classes={{}} className=\"arrow-class\" />);\n\n      polygon = container.querySelector('polygon');\n      const newPoints = polygon.getAttribute('points');\n      // Points should change due to size change (14 vs 12)\n      expect(newPoints).not.toBe(initialPoints);\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}