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

package/lib/container/__tests__/index.test.js

@@ -0,0 +1,503 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _react = _interopRequireDefault(require("react"));
+var _testUtils = require("@pie-lib/test-utils");
+var _index = _interopRequireWildcard(require("../index"));
+var _actions = require("../actions");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof3(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+jest.mock('../../graph-with-controls', function () {
+  return function GraphWithControls(_ref) {
+    var marks = _ref.marks,
+      onChangeMarks = _ref.onChangeMarks,
+      onUndo = _ref.onUndo,
+      onRedo = _ref.onRedo,
+      onReset = _ref.onReset,
+      disabled = _ref.disabled;
+    return /*#__PURE__*/_react["default"].createElement("div", {
+      "data-testid": "graph-with-controls"
+    }, /*#__PURE__*/_react["default"].createElement("div", {
+      "data-testid": "marks-count"
+    }, (marks === null || marks === void 0 ? void 0 : marks.length) || 0), disabled && /*#__PURE__*/_react["default"].createElement("div", {
+      "data-testid": "disabled-indicator"
+    }, "Disabled"), /*#__PURE__*/_react["default"].createElement("button", {
+      "data-testid": "change-marks",
+      onClick: function onClick() {
+        return onChangeMarks && onChangeMarks([{
+          id: 1
+        }]);
+      }
+    }, "Change"), /*#__PURE__*/_react["default"].createElement("button", {
+      "data-testid": "undo",
+      onClick: onUndo
+    }, "Undo"), /*#__PURE__*/_react["default"].createElement("button", {
+      "data-testid": "redo",
+      onClick: onRedo
+    }, "Redo"), /*#__PURE__*/_react["default"].createElement("button", {
+      "data-testid": "reset",
+      onClick: onReset
+    }, "Reset"));
+  };
+});
+jest.mock('@pie-lib/drag', function () {
+  return {
+    DragProvider: function DragProvider(_ref2) {
+      var children = _ref2.children;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "drag-provider"
+      }, children);
+    }
+  };
+});
+describe('Container Root Component', function () {
+  var defaultProps = {
+    marks: [],
+    onChangeMarks: jest.fn()
+  };
+  var renderComponent = function renderComponent() {
+    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_index["default"], (0, _extends2["default"])({}, defaultProps, props)));
+  };
+  describe('rendering', function () {
+    it('renders without crashing', function () {
+      var _renderComponent = renderComponent(),
+        container = _renderComponent.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('renders GraphWithControls', function () {
+      var _renderComponent2 = renderComponent(),
+        getByTestId = _renderComponent2.getByTestId;
+      expect(getByTestId('graph-with-controls')).toBeInTheDocument();
+    });
+    it('renders with Provider when no correctness set', function () {
+      var _renderComponent3 = renderComponent({
+          marks: [{
+            id: 1,
+            type: 'point'
+          }]
+        }),
+        container = _renderComponent3.container;
+      expect(container.querySelector('[data-testid="graph-with-controls"]')).toBeInTheDocument();
+    });
+    it('renders directly when correctness is set', function () {
+      var marks = [{
+        id: 1,
+        type: 'point',
+        correctness: {
+          value: 'correct'
+        }
+      }];
+      var _renderComponent4 = renderComponent({
+          marks: marks
+        }),
+        getByTestId = _renderComponent4.getByTestId;
+      expect(getByTestId('graph-with-controls')).toBeInTheDocument();
+      expect(getByTestId('disabled-indicator')).toBeInTheDocument();
+    });
+    it('passes marks to GraphWithControls', function () {
+      var marks = [{
+        id: 1
+      }, {
+        id: 2
+      }];
+      var _renderComponent5 = renderComponent({
+          marks: marks
+        }),
+        getByTestId = _renderComponent5.getByTestId;
+      expect(getByTestId('marks-count')).toHaveTextContent('2');
+    });
+  });
+  describe('Redux store', function () {
+    it('creates Redux store on mount', function () {
+      var component = new _index["default"]({
+        marks: [],
+        onChangeMarks: jest.fn()
+      });
+      expect(component.store).toBeDefined();
+      expect((0, _typeof2["default"])(component.store.getState)).toBe('function');
+      expect((0, _typeof2["default"])(component.store.dispatch)).toBe('function');
+    });
+    it('initializes store with marks from props', function () {
+      var marks = [{
+        id: 1,
+        type: 'point'
+      }];
+      var component = new _index["default"]({
+        marks: marks,
+        onChangeMarks: jest.fn()
+      });
+      var state = component.store.getState();
+      expect(state.marks.present).toEqual(marks);
+    });
+    it('initializes store with empty marks', function () {
+      var component = new _index["default"]({
+        marks: [],
+        onChangeMarks: jest.fn()
+      });
+      var state = component.store.getState();
+      expect(state.marks.present).toEqual([]);
+    });
+    it('subscribes to store changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var onChangeMarks, component, newMarks;
+      return _regenerator["default"].wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            onChangeMarks = jest.fn();
+            component = new _index["default"]({
+              marks: [],
+              onChangeMarks: onChangeMarks
+            });
+            newMarks = [{
+              id: 1
+            }];
+            component.store.dispatch((0, _actions.changeMarks)(newMarks));
+            _context.next = 1;
+            return (0, _testUtils.waitFor)(function () {
+              expect(onChangeMarks).toHaveBeenCalledWith(newMarks);
+            });
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+  });
+  describe('componentDidUpdate', function () {
+    it('updates store when marks prop changes', function () {
+      var onChangeMarks = jest.fn();
+      var _render = (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+          marks: [],
+          onChangeMarks: onChangeMarks
+        })),
+        rerender = _render.rerender;
+      var newMarks = [{
+        id: 1,
+        type: 'point'
+      }];
+      rerender(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+        marks: newMarks,
+        onChangeMarks: onChangeMarks
+      }));
+      expect(onChangeMarks).not.toHaveBeenCalled();
+    });
+    it('does not update when marks are equal', function () {
+      var marks = [{
+        id: 1,
+        type: 'point'
+      }];
+      var onChangeMarks = jest.fn();
+      var _render2 = (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+          marks: marks,
+          onChangeMarks: onChangeMarks
+        })),
+        rerender = _render2.rerender;
+      onChangeMarks.mockClear();
+      rerender(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+        marks: marks,
+        onChangeMarks: onChangeMarks
+      }));
+      expect(onChangeMarks).not.toHaveBeenCalled();
+    });
+    it('handles marks changing from empty to non-empty', function () {
+      var onChangeMarks = jest.fn();
+      var _render3 = (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+          marks: [],
+          onChangeMarks: onChangeMarks
+        })),
+        rerender = _render3.rerender;
+      var newMarks = [{
+        id: 1
+      }];
+      expect(function () {
+        rerender(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+          marks: newMarks,
+          onChangeMarks: onChangeMarks
+        }));
+      }).not.toThrow();
+    });
+    it('handles marks changing from non-empty to empty', function () {
+      var onChangeMarks = jest.fn();
+      var _render4 = (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+          marks: [{
+            id: 1
+          }],
+          onChangeMarks: onChangeMarks
+        })),
+        rerender = _render4.rerender;
+      expect(function () {
+        rerender(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+          marks: [],
+          onChangeMarks: onChangeMarks
+        }));
+      }).not.toThrow();
+    });
+  });
+  describe('onStoreChange', function () {
+    it('calls onChangeMarks when store state changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      var onChangeMarks, component, newMarks;
+      return _regenerator["default"].wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            onChangeMarks = jest.fn();
+            component = new _index["default"]({
+              marks: [],
+              onChangeMarks: onChangeMarks
+            });
+            newMarks = [{
+              id: 1,
+              type: 'point'
+            }];
+            component.store.dispatch((0, _actions.changeMarks)(newMarks));
+            _context2.next = 1;
+            return (0, _testUtils.waitFor)(function () {
+              expect(onChangeMarks).toHaveBeenCalledWith(newMarks);
+            });
+          case 1:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+    it('does not call onChangeMarks when marks are equal', function () {
+      var marks = [{
+        id: 1,
+        type: 'point'
+      }];
+      var onChangeMarks = jest.fn();
+      var component = new _index["default"]({
+        marks: marks,
+        onChangeMarks: onChangeMarks
+      });
+      onChangeMarks.mockClear();
+      component.store.dispatch((0, _actions.changeMarks)(marks));
+      expect(onChangeMarks).not.toHaveBeenCalled();
+    });
+    it('handles multiple store changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+      var onChangeMarks, component;
+      return _regenerator["default"].wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            onChangeMarks = jest.fn();
+            component = new _index["default"]({
+              marks: [],
+              onChangeMarks: onChangeMarks
+            });
+            component.store.dispatch((0, _actions.changeMarks)([{
+              id: 1
+            }]));
+            component.store.dispatch((0, _actions.changeMarks)([{
+              id: 2
+            }]));
+            component.store.dispatch((0, _actions.changeMarks)([{
+              id: 3
+            }]));
+            _context3.next = 1;
+            return (0, _testUtils.waitFor)(function () {
+              expect(onChangeMarks).toHaveBeenCalledTimes(3);
+            });
+          case 1:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+  });
+  describe('correctness handling', function () {
+    it('disables when any mark has correctness', function () {
+      var marks = [{
+        id: 1,
+        type: 'point'
+      }, {
+        id: 2,
+        type: 'point',
+        correctness: {
+          value: 'correct'
+        }
+      }];
+      var _renderComponent6 = renderComponent({
+          marks: marks
+        }),
+        getByTestId = _renderComponent6.getByTestId;
+      expect(getByTestId('disabled-indicator')).toBeInTheDocument();
+    });
+    it('renders without Provider when correctness is set', function () {
+      var marks = [{
+        id: 1,
+        correctness: {
+          value: 'correct'
+        }
+      }];
+      var _renderComponent7 = renderComponent({
+          marks: marks
+        }),
+        container = _renderComponent7.container;
+      expect(container.querySelector('[data-testid="graph-with-controls"]')).toBeInTheDocument();
+    });
+    it('does not disable when no correctness is set', function () {
+      var marks = [{
+        id: 1,
+        type: 'point'
+      }, {
+        id: 2,
+        type: 'line'
+      }];
+      var _renderComponent8 = renderComponent({
+          marks: marks
+        }),
+        queryByTestId = _renderComponent8.queryByTestId;
+      expect(queryByTestId('disabled-indicator')).not.toBeInTheDocument();
+    });
+    it('handles correctness with different values', function () {
+      var marks = [{
+        id: 1,
+        correctness: {
+          value: 'incorrect'
+        }
+      }];
+      var _renderComponent9 = renderComponent({
+          marks: marks
+        }),
+        getByTestId = _renderComponent9.getByTestId;
+      expect(getByTestId('disabled-indicator')).toBeInTheDocument();
+    });
+    it('handles empty correctness object', function () {
+      var marks = [{
+        id: 1,
+        correctness: {}
+      }];
+      var _renderComponent0 = renderComponent({
+          marks: marks
+        }),
+        getByTestId = _renderComponent0.getByTestId;
+      expect(getByTestId('disabled-indicator')).toBeInTheDocument();
+    });
+  });
+  describe('props forwarding', function () {
+    it('forwards additional props to GraphWithControls', function () {
+      var _renderComponent1 = renderComponent({
+          className: 'custom-class',
+          size: {
+            width: 500,
+            height: 500
+          }
+        }),
+        container = _renderComponent1.container;
+      expect(container.querySelector('[data-testid="graph-with-controls"]')).toBeInTheDocument();
+    });
+    it('does not forward onChangeMarks and marks to GraphWithControls', function () {
+      var _renderComponent10 = renderComponent({
+          marks: [{
+            id: 1
+          }],
+          onChangeMarks: jest.fn(),
+          otherProp: 'test'
+        }),
+        getByTestId = _renderComponent10.getByTestId;
+      expect(getByTestId('graph-with-controls')).toBeInTheDocument();
+    });
+  });
+  describe('edge cases', function () {
+    it('handles empty marks array', function () {
+      var _renderComponent11 = renderComponent({
+          marks: []
+        }),
+        container = _renderComponent11.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('handles marks with complex structure', function () {
+      var marks = [{
+        id: 1,
+        type: 'line',
+        from: {
+          x: 0,
+          y: 0
+        },
+        to: {
+          x: 10,
+          y: 10
+        },
+        label: 'Line A',
+        correctness: {
+          value: 'correct',
+          label: 'Correct!'
+        }
+      }];
+      var _renderComponent12 = renderComponent({
+          marks: marks
+        }),
+        getByTestId = _renderComponent12.getByTestId;
+      expect(getByTestId('graph-with-controls')).toBeInTheDocument();
+    });
+    it('handles switching between correctness states', function () {
+      var _render5 = (0, _testUtils.render)(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+          marks: [{
+            id: 1
+          }],
+          onChangeMarks: jest.fn()
+        })),
+        rerender = _render5.rerender;
+      rerender(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+        marks: [{
+          id: 1,
+          correctness: {
+            value: 'correct'
+          }
+        }],
+        onChangeMarks: jest.fn()
+      }));
+      rerender(/*#__PURE__*/_react["default"].createElement(_index["default"], {
+        marks: [{
+          id: 1
+        }],
+        onChangeMarks: jest.fn()
+      }));
+      expect(document.querySelector('[data-testid="graph-with-controls"]')).toBeInTheDocument();
+    });
+  });
+  describe('store synchronization', function () {
+    it('keeps store and props in sync', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+      var onChangeMarks, component, newMarks;
+      return _regenerator["default"].wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            onChangeMarks = jest.fn();
+            component = new _index["default"]({
+              marks: [],
+              onChangeMarks: onChangeMarks
+            });
+            newMarks = [{
+              id: 1
+            }];
+            component.store.dispatch((0, _actions.changeMarks)(newMarks));
+            _context4.next = 1;
+            return (0, _testUtils.waitFor)(function () {
+              var state = component.store.getState();
+              expect(state.marks.present).toEqual(newMarks);
+              expect(onChangeMarks).toHaveBeenCalledWith(newMarks);
+            });
+          case 1:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    })));
+  });
+});
+describe('GraphContainer (connected component)', function () {
+  it('is a connected component', function () {
+    expect(_index.GraphContainer).toBeDefined();
+    expect(_index.GraphContainer.displayName).toContain('Connect');
+  });
+  it('maps state to props', function () {
+    expect(_index.GraphContainer).toBeDefined();
+  });
+  it('maps dispatch to props', function () {
+    expect(_index.GraphContainer).toBeDefined();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_testUtils","_index","_interopRequireWildcard","_actions","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","_typeof3","has","get","set","_t","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","jest","mock","GraphWithControls","_ref","marks","onChangeMarks","onUndo","onRedo","onReset","disabled","createElement","length","onClick","id","DragProvider","_ref2","children","describe","defaultProps","fn","renderComponent","props","arguments","undefined","render","_extends2","it","_renderComponent","container","expect","toBeInTheDocument","_renderComponent2","getByTestId","_renderComponent3","type","querySelector","correctness","value","_renderComponent4","_renderComponent5","toHaveTextContent","component","Root","store","toBeDefined","_typeof2","getState","toBe","dispatch","state","present","toEqual","_asyncToGenerator2","_regenerator","mark","_callee","newMarks","wrap","_context","prev","next","changeMarks","waitFor","toHaveBeenCalledWith","stop","_render","rerender","not","toHaveBeenCalled","_render2","mockClear","_render3","toThrow","_render4","_callee2","_context2","_callee3","_context3","toHaveBeenCalledTimes","_renderComponent6","_renderComponent7","_renderComponent8","queryByTestId","_renderComponent9","_renderComponent0","_renderComponent1","className","size","width","height","_renderComponent10","otherProp","_renderComponent11","from","x","y","to","label","_renderComponent12","_render5","document","_callee4","_context4","GraphContainer","displayName","toContain"],"sources":["../../../src/container/__tests__/index.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render, waitFor } from '@pie-lib/test-utils';\nimport Root, { GraphContainer } from '../index';\nimport { changeMarks } from '../actions';\n\njest.mock('../../graph-with-controls', () => {\n  return function GraphWithControls({ marks, onChangeMarks, onUndo, onRedo, onReset, disabled }) {\n    return (\n      <div data-testid=\"graph-with-controls\">\n        <div data-testid=\"marks-count\">{marks?.length || 0}</div>\n        {disabled && <div data-testid=\"disabled-indicator\">Disabled</div>}\n        <button data-testid=\"change-marks\" onClick={() => onChangeMarks && onChangeMarks([{ id: 1 }])}>\n          Change\n        </button>\n        <button data-testid=\"undo\" onClick={onUndo}>\n          Undo\n        </button>\n        <button data-testid=\"redo\" onClick={onRedo}>\n          Redo\n        </button>\n        <button data-testid=\"reset\" onClick={onReset}>\n          Reset\n        </button>\n      </div>\n    );\n  };\n});\n\njest.mock('@pie-lib/drag', () => ({\n  DragProvider: ({ children }) => <div data-testid=\"drag-provider\">{children}</div>,\n}));\n\ndescribe('Container Root Component', () => {\n  const defaultProps = {\n    marks: [],\n    onChangeMarks: jest.fn(),\n  };\n\n  const renderComponent = (props = {}) => {\n    return render(<Root {...defaultProps} {...props} />);\n  };\n\n  describe('rendering', () => {\n    it('renders without crashing', () => {\n      const { container } = renderComponent();\n      expect(container).toBeInTheDocument();\n    });\n\n    it('renders GraphWithControls', () => {\n      const { getByTestId } = renderComponent();\n      expect(getByTestId('graph-with-controls')).toBeInTheDocument();\n    });\n\n    it('renders with Provider when no correctness set', () => {\n      const { container } = renderComponent({ marks: [{ id: 1, type: 'point' }] });\n      expect(container.querySelector('[data-testid=\"graph-with-controls\"]')).toBeInTheDocument();\n    });\n\n    it('renders directly when correctness is set', () => {\n      const marks = [{ id: 1, type: 'point', correctness: { value: 'correct' } }];\n      const { getByTestId } = renderComponent({ marks });\n\n      expect(getByTestId('graph-with-controls')).toBeInTheDocument();\n      expect(getByTestId('disabled-indicator')).toBeInTheDocument();\n    });\n\n    it('passes marks to GraphWithControls', () => {\n      const marks = [{ id: 1 }, { id: 2 }];\n      const { getByTestId } = renderComponent({ marks });\n      expect(getByTestId('marks-count')).toHaveTextContent('2');\n    });\n  });\n\n  describe('Redux store', () => {\n    it('creates Redux store on mount', () => {\n      const component = new Root({ marks: [], onChangeMarks: jest.fn() });\n      expect(component.store).toBeDefined();\n      expect(typeof component.store.getState).toBe('function');\n      expect(typeof component.store.dispatch).toBe('function');\n    });\n\n    it('initializes store with marks from props', () => {\n      const marks = [{ id: 1, type: 'point' }];\n      const component = new Root({ marks, onChangeMarks: jest.fn() });\n\n      const state = component.store.getState();\n      expect(state.marks.present).toEqual(marks);\n    });\n\n    it('initializes store with empty marks', () => {\n      const component = new Root({ marks: [], onChangeMarks: jest.fn() });\n\n      const state = component.store.getState();\n      expect(state.marks.present).toEqual([]);\n    });\n\n    it('subscribes to store changes', async () => {\n      const onChangeMarks = jest.fn();\n      const component = new Root({ marks: [], onChangeMarks });\n\n      const newMarks = [{ id: 1 }];\n      component.store.dispatch(changeMarks(newMarks));\n\n      await waitFor(() => {\n        expect(onChangeMarks).toHaveBeenCalledWith(newMarks);\n      });\n    });\n  });\n\n  describe('componentDidUpdate', () => {\n    it('updates store when marks prop changes', () => {\n      const onChangeMarks = jest.fn();\n      const { rerender } = render(<Root marks={[]} onChangeMarks={onChangeMarks} />);\n\n      const newMarks = [{ id: 1, type: 'point' }];\n      rerender(<Root marks={newMarks} onChangeMarks={onChangeMarks} />);\n\n      expect(onChangeMarks).not.toHaveBeenCalled();\n    });\n\n    it('does not update when marks are equal', () => {\n      const marks = [{ id: 1, type: 'point' }];\n      const onChangeMarks = jest.fn();\n      const { rerender } = render(<Root marks={marks} onChangeMarks={onChangeMarks} />);\n\n      onChangeMarks.mockClear();\n\n      rerender(<Root marks={marks} onChangeMarks={onChangeMarks} />);\n\n      expect(onChangeMarks).not.toHaveBeenCalled();\n    });\n\n    it('handles marks changing from empty to non-empty', () => {\n      const onChangeMarks = jest.fn();\n      const { rerender } = render(<Root marks={[]} onChangeMarks={onChangeMarks} />);\n\n      const newMarks = [{ id: 1 }];\n\n      expect(() => {\n        rerender(<Root marks={newMarks} onChangeMarks={onChangeMarks} />);\n      }).not.toThrow();\n    });\n\n    it('handles marks changing from non-empty to empty', () => {\n      const onChangeMarks = jest.fn();\n      const { rerender } = render(<Root marks={[{ id: 1 }]} onChangeMarks={onChangeMarks} />);\n\n      expect(() => {\n        rerender(<Root marks={[]} onChangeMarks={onChangeMarks} />);\n      }).not.toThrow();\n    });\n  });\n\n  describe('onStoreChange', () => {\n    it('calls onChangeMarks when store state changes', async () => {\n      const onChangeMarks = jest.fn();\n      const component = new Root({ marks: [], onChangeMarks });\n\n      const newMarks = [{ id: 1, type: 'point' }];\n      component.store.dispatch(changeMarks(newMarks));\n\n      await waitFor(() => {\n        expect(onChangeMarks).toHaveBeenCalledWith(newMarks);\n      });\n    });\n\n    it('does not call onChangeMarks when marks are equal', () => {\n      const marks = [{ id: 1, type: 'point' }];\n      const onChangeMarks = jest.fn();\n      const component = new Root({ marks, onChangeMarks });\n\n      onChangeMarks.mockClear();\n\n      component.store.dispatch(changeMarks(marks));\n\n      expect(onChangeMarks).not.toHaveBeenCalled();\n    });\n\n    it('handles multiple store changes', async () => {\n      const onChangeMarks = jest.fn();\n      const component = new Root({ marks: [], onChangeMarks });\n\n      component.store.dispatch(changeMarks([{ id: 1 }]));\n      component.store.dispatch(changeMarks([{ id: 2 }]));\n      component.store.dispatch(changeMarks([{ id: 3 }]));\n\n      await waitFor(() => {\n        expect(onChangeMarks).toHaveBeenCalledTimes(3);\n      });\n    });\n  });\n\n  describe('correctness handling', () => {\n    it('disables when any mark has correctness', () => {\n      const marks = [\n        { id: 1, type: 'point' },\n        { id: 2, type: 'point', correctness: { value: 'correct' } },\n      ];\n      const { getByTestId } = renderComponent({ marks });\n\n      expect(getByTestId('disabled-indicator')).toBeInTheDocument();\n    });\n\n    it('renders without Provider when correctness is set', () => {\n      const marks = [{ id: 1, correctness: { value: 'correct' } }];\n      const { container } = renderComponent({ marks });\n\n      expect(container.querySelector('[data-testid=\"graph-with-controls\"]')).toBeInTheDocument();\n    });\n\n    it('does not disable when no correctness is set', () => {\n      const marks = [\n        { id: 1, type: 'point' },\n        { id: 2, type: 'line' },\n      ];\n      const { queryByTestId } = renderComponent({ marks });\n\n      expect(queryByTestId('disabled-indicator')).not.toBeInTheDocument();\n    });\n\n    it('handles correctness with different values', () => {\n      const marks = [{ id: 1, correctness: { value: 'incorrect' } }];\n      const { getByTestId } = renderComponent({ marks });\n\n      expect(getByTestId('disabled-indicator')).toBeInTheDocument();\n    });\n\n    it('handles empty correctness object', () => {\n      const marks = [{ id: 1, correctness: {} }];\n      const { getByTestId } = renderComponent({ marks });\n\n      expect(getByTestId('disabled-indicator')).toBeInTheDocument();\n    });\n  });\n\n  describe('props forwarding', () => {\n    it('forwards additional props to GraphWithControls', () => {\n      const { container } = renderComponent({\n        className: 'custom-class',\n        size: { width: 500, height: 500 },\n      });\n\n      expect(container.querySelector('[data-testid=\"graph-with-controls\"]')).toBeInTheDocument();\n    });\n\n    it('does not forward onChangeMarks and marks to GraphWithControls', () => {\n      const { getByTestId } = renderComponent({\n        marks: [{ id: 1 }],\n        onChangeMarks: jest.fn(),\n        otherProp: 'test',\n      });\n\n      expect(getByTestId('graph-with-controls')).toBeInTheDocument();\n    });\n  });\n\n  describe('edge cases', () => {\n    it('handles empty marks array', () => {\n      const { container } = renderComponent({ marks: [] });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('handles marks with complex structure', () => {\n      const marks = [\n        {\n          id: 1,\n          type: 'line',\n          from: { x: 0, y: 0 },\n          to: { x: 10, y: 10 },\n          label: 'Line A',\n          correctness: { value: 'correct', label: 'Correct!' },\n        },\n      ];\n      const { getByTestId } = renderComponent({ marks });\n      expect(getByTestId('graph-with-controls')).toBeInTheDocument();\n    });\n\n    it('handles switching between correctness states', () => {\n      const { rerender } = render(<Root marks={[{ id: 1 }]} onChangeMarks={jest.fn()} />);\n\n      rerender(<Root marks={[{ id: 1, correctness: { value: 'correct' } }]} onChangeMarks={jest.fn()} />);\n\n      rerender(<Root marks={[{ id: 1 }]} onChangeMarks={jest.fn()} />);\n\n      expect(document.querySelector('[data-testid=\"graph-with-controls\"]')).toBeInTheDocument();\n    });\n  });\n\n  describe('store synchronization', () => {\n    it('keeps store and props in sync', async () => {\n      const onChangeMarks = jest.fn();\n      const component = new Root({ marks: [], onChangeMarks });\n\n      const newMarks = [{ id: 1 }];\n      component.store.dispatch(changeMarks(newMarks));\n\n      await waitFor(() => {\n        const state = component.store.getState();\n        expect(state.marks.present).toEqual(newMarks);\n        expect(onChangeMarks).toHaveBeenCalledWith(newMarks);\n      });\n    });\n  });\n});\n\ndescribe('GraphContainer (connected component)', () => {\n  it('is a connected component', () => {\n    expect(GraphContainer).toBeDefined();\n    expect(GraphContainer.displayName).toContain('Connect');\n  });\n\n  it('maps state to props', () => {\n    expect(GraphContainer).toBeDefined();\n  });\n\n  it('maps dispatch to props', () => {\n    expect(GraphContainer).toBeDefined();\n  });\n});\n"],"mappings":"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","ignoreList":[]}