@pie-lib/charting 6.1.1-next.1 → 6.2.0-next.2

package/lib/__tests__/chart-setup.test.js

@@ -0,0 +1,796 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _styles = require("@mui/material/styles");
+var _chartSetup = _interopRequireWildcard(require("../chart-setup"));
+var _excluded = ["label", "value", "onChange"];
+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" != _typeof(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); }
+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('../chart-type', function () {
+  return function ChartType(_ref) {
+    var value = _ref.value,
+      onChange = _ref.onChange;
+    return /*#__PURE__*/_react["default"].createElement("select", {
+      "data-testid": "chart-type-select",
+      value: value,
+      onChange: onChange
+    }, /*#__PURE__*/_react["default"].createElement("option", {
+      value: "bar"
+    }, "Bar"), /*#__PURE__*/_react["default"].createElement("option", {
+      value: "line"
+    }, "Line"), /*#__PURE__*/_react["default"].createElement("option", {
+      value: "linePlot"
+    }, "Line Plot"), /*#__PURE__*/_react["default"].createElement("option", {
+      value: "dotPlot"
+    }, "Dot Plot"));
+  };
+});
+jest.mock('@pie-lib/config-ui', function () {
+  return {
+    NumberTextFieldCustom: function NumberTextFieldCustom(_ref2) {
+      var label = _ref2.label,
+        value = _ref2.value,
+        _onChange = _ref2.onChange,
+        props = (0, _objectWithoutProperties2["default"])(_ref2, _excluded);
+      return /*#__PURE__*/_react["default"].createElement("input", (0, _extends2["default"])({
+        "data-testid": "number-field-".concat(label.toLowerCase().replace(/\s+/g, '-')),
+        type: "number",
+        value: value,
+        onChange: function onChange(e) {
+          return _onChange(e, parseFloat(e.target.value) || 0);
+        },
+        "aria-label": label
+      }, props));
+    },
+    AlertDialog: function AlertDialog(_ref3) {
+      var open = _ref3.open,
+        title = _ref3.title,
+        text = _ref3.text,
+        onClose = _ref3.onClose,
+        onConfirm = _ref3.onConfirm;
+      return open ? /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "alert-dialog"
+      }, /*#__PURE__*/_react["default"].createElement("h2", null, title), /*#__PURE__*/_react["default"].createElement("p", null, text), /*#__PURE__*/_react["default"].createElement("button", {
+        "data-testid": "alert-cancel",
+        onClick: onClose
+      }, "Cancel"), /*#__PURE__*/_react["default"].createElement("button", {
+        "data-testid": "alert-confirm",
+        onClick: onConfirm
+      }, "Confirm")) : null;
+    }
+  };
+});
+var theme;
+beforeAll(function () {
+  theme = (0, _styles.createTheme)();
+});
+describe('resetValues', function () {
+  var data;
+  var range;
+  var model;
+  var onChange;
+  beforeEach(function () {
+    range = {
+      min: 0,
+      max: 10,
+      step: 1
+    };
+    data = [{
+      value: 2
+    }, {
+      value: 11
+    }, {
+      value: 5.5
+    }, {
+      value: 2.0000000001
+    }, {
+      value: 2.9999999999
+    }];
+    model = {
+      someField: 'someValue',
+      data: data
+    };
+    onChange = jest.fn();
+  });
+  it('should reset values greater than range.max to zero', function () {
+    (0, _chartSetup.resetValues)(data, true, range, onChange, model);
+    expect(data[1].value).toBe(0);
+  });
+  it('should reset values that are not multiples of range.step to zero', function () {
+    (0, _chartSetup.resetValues)(data, true, range, onChange, model);
+    expect(data[2].value).toBe(0);
+  });
+  it('should not reset values that are within range and multiples of range.step', function () {
+    (0, _chartSetup.resetValues)(data, true, range, onChange, model);
+    expect(data[0].value).toBe(2);
+  });
+  it('should not reset floating point values that are close to multiples of range.step', function () {
+    (0, _chartSetup.resetValues)(data, true, range, onChange, model);
+    expect(data[3].value).toBe(2.0000000001);
+    expect(data[4].value).toBe(2.9999999999);
+  });
+  it('should not call onChange when updateModel is false', function () {
+    (0, _chartSetup.resetValues)(data, false, range, onChange, model);
+    expect(onChange).not.toHaveBeenCalled();
+  });
+  it('should handle null or undefined data array', function () {
+    expect(function () {
+      return (0, _chartSetup.resetValues)(null, true, range, onChange, model);
+    }).not.toThrow();
+    expect(function () {
+      return (0, _chartSetup.resetValues)(undefined, true, range, onChange, model);
+    }).not.toThrow();
+  });
+  it('should handle empty data array', function () {
+    (0, _chartSetup.resetValues)([], true, range, onChange, model);
+    expect(onChange).toHaveBeenCalledWith(_objectSpread(_objectSpread({}, model), {}, {
+      data: []
+    }));
+  });
+  it('should reset multiple invalid values', function () {
+    var multiData = [{
+      value: 11
+    }, {
+      value: 12
+    }, {
+      value: 5.5
+    }, {
+      value: 3.7
+    }];
+    (0, _chartSetup.resetValues)(multiData, true, range, onChange, _objectSpread(_objectSpread({}, model), {}, {
+      data: multiData
+    }));
+    expect(multiData.every(function (d) {
+      return d.value === 0;
+    })).toBe(true);
+  });
+  it('should handle decimal step values', function () {
+    var decimalRange = {
+      min: 0,
+      max: 10,
+      step: 0.5
+    };
+    var decimalData = [{
+      value: 1.5
+    }, {
+      value: 2.3
+    }, {
+      value: 3.0
+    }];
+    (0, _chartSetup.resetValues)(decimalData, true, decimalRange, onChange, model);
+    expect(decimalData[0].value).toBe(1.5);
+    expect(decimalData[1].value).toBe(0);
+    expect(decimalData[2].value).toBe(3.0);
+  });
+});
+describe('ConfigureChartPanel', function () {
+  var defaultModel = {
+    chartType: 'bar',
+    range: {
+      min: 0,
+      max: 10,
+      step: 1,
+      labelStep: 1
+    },
+    graph: {
+      width: 400,
+      height: 500
+    },
+    data: [{
+      value: 5
+    }],
+    correctAnswer: {
+      data: [{
+        value: 3
+      }]
+    },
+    changeInteractiveEnabled: true,
+    changeEditableEnabled: true
+  };
+  var defaultProps = {
+    model: defaultModel,
+    onChange: jest.fn(),
+    chartDimensions: {
+      showInConfigPanel: true,
+      width: {
+        min: 50,
+        max: 700,
+        step: 20
+      },
+      height: {
+        min: 400,
+        max: 700,
+        step: 20
+      }
+    },
+    gridValues: {
+      range: {
+        min: 0,
+        max: 10000
+      }
+    },
+    labelValues: {
+      range: {
+        min: 0,
+        max: 10000
+      }
+    },
+    studentNewCategoryDefaultLabel: {
+      label: 'Category'
+    },
+    availableChartTypes: {},
+    chartTypeLabel: 'Chart Type'
+  };
+  beforeEach(function () {
+    jest.clearAllMocks();
+  });
+  var renderComponent = function renderComponent() {
+    var extras = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var props = _objectSpread(_objectSpread({}, defaultProps), extras);
+    return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_styles.ThemeProvider, {
+      theme: theme
+    }, /*#__PURE__*/_react["default"].createElement(_chartSetup["default"], props)));
+  };
+  describe('rendering', function () {
+    it('should render without crashing', function () {
+      var _renderComponent = renderComponent(),
+        container = _renderComponent.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('should render "Configure Chart" title', function () {
+      var _renderComponent2 = renderComponent(),
+        getByText = _renderComponent2.getByText;
+      expect(getByText('Configure Chart')).toBeInTheDocument();
+    });
+    it('should render chart type selector', function () {
+      var _renderComponent3 = renderComponent(),
+        getByTestId = _renderComponent3.getByTestId;
+      expect(getByTestId('chart-type-select')).toBeInTheDocument();
+    });
+    it('should render max value field', function () {
+      var _renderComponent4 = renderComponent(),
+        getByLabelText = _renderComponent4.getByLabelText;
+      expect(getByLabelText('Max Value')).toBeInTheDocument();
+    });
+    it('should render grid interval field for non-plot charts', function () {
+      var _renderComponent5 = renderComponent({
+          model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+            chartType: 'bar'
+          })
+        }),
+        getByLabelText = _renderComponent5.getByLabelText;
+      expect(getByLabelText('Grid Interval')).toBeInTheDocument();
+    });
+    it('should render label interval field for non-plot charts', function () {
+      var _renderComponent6 = renderComponent({
+          model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+            chartType: 'bar'
+          })
+        }),
+        getByLabelText = _renderComponent6.getByLabelText;
+      expect(getByLabelText('Label Interval')).toBeInTheDocument();
+    });
+    it('should not render step config for plot charts', function () {
+      var _renderComponent7 = renderComponent({
+          model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+            chartType: 'linePlot'
+          })
+        }),
+        queryByLabelText = _renderComponent7.queryByLabelText;
+      expect(queryByLabelText('Grid Interval')).not.toBeInTheDocument();
+      expect(queryByLabelText('Label Interval')).not.toBeInTheDocument();
+    });
+    it('should render dimensions section when showInConfigPanel is true', function () {
+      var _renderComponent8 = renderComponent({
+          chartDimensions: {
+            showInConfigPanel: true,
+            width: {
+              min: 50,
+              max: 700,
+              step: 20
+            },
+            height: {
+              min: 400,
+              max: 700,
+              step: 20
+            }
+          }
+        }),
+        getByText = _renderComponent8.getByText;
+      expect(getByText('Dimensions(px)')).toBeInTheDocument();
+    });
+    it('should not render dimensions section when showInConfigPanel is false', function () {
+      var _renderComponent9 = renderComponent({
+          chartDimensions: {
+            showInConfigPanel: false,
+            width: {
+              min: 50,
+              max: 700,
+              step: 20
+            },
+            height: {
+              min: 400,
+              max: 700,
+              step: 20
+            }
+          }
+        }),
+        queryByText = _renderComponent9.queryByText;
+      expect(queryByText('Dimensions(px)')).not.toBeInTheDocument();
+    });
+    it('should render width field when dimensions are shown', function () {
+      var _renderComponent0 = renderComponent(),
+        getByLabelText = _renderComponent0.getByLabelText;
+      expect(getByLabelText('Width')).toBeInTheDocument();
+    });
+    it('should render height field when dimensions are shown', function () {
+      var _renderComponent1 = renderComponent(),
+        getByLabelText = _renderComponent1.getByLabelText;
+      expect(getByLabelText('Height')).toBeInTheDocument();
+    });
+    it('should display width constraints', function () {
+      var _renderComponent10 = renderComponent(),
+        getByText = _renderComponent10.getByText;
+      expect(getByText('Min 50, Max 700')).toBeInTheDocument();
+    });
+    it('should display height constraints', function () {
+      var _renderComponent11 = renderComponent(),
+        getAllByText = _renderComponent11.getAllByText;
+      var constraints = getAllByText('Min 400, Max 700');
+      expect(constraints.length).toBeGreaterThan(0);
+    });
+  });
+  describe('chart type changes', function () {
+    it('should call onChange when chart type is changed to non-plot', function () {
+      var onChange = jest.fn();
+      var _renderComponent12 = renderComponent({
+          onChange: onChange
+        }),
+        getByTestId = _renderComponent12.getByTestId;
+      _react2.fireEvent.change(getByTestId('chart-type-select'), {
+        target: {
+          value: 'line'
+        }
+      });
+      expect(onChange).toHaveBeenCalled();
+    });
+    it('should show warning when switching to plot with invalid config', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var _renderComponent13, getByTestId, getByText;
+      return _regenerator["default"].wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _renderComponent13 = renderComponent({
+              model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+                range: {
+                  max: 20,
+                  step: 2,
+                  labelStep: 2
+                }
+              })
+            }), getByTestId = _renderComponent13.getByTestId, getByText = _renderComponent13.getByText;
+            _react2.fireEvent.change(getByTestId('chart-type-select'), {
+              target: {
+                value: 'linePlot'
+              }
+            });
+            _context.next = 1;
+            return (0, _react2.waitFor)(function () {
+              expect(getByText('Warning')).toBeInTheDocument();
+            });
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('should allow switching to plot with valid config', function () {
+      var onChange = jest.fn();
+      var _renderComponent14 = renderComponent({
+          onChange: onChange,
+          model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+            range: {
+              max: 10,
+              step: 1,
+              labelStep: 1
+            }
+          })
+        }),
+        getByTestId = _renderComponent14.getByTestId;
+      _react2.fireEvent.change(getByTestId('chart-type-select'), {
+        target: {
+          value: 'dotPlot'
+        }
+      });
+      expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+        chartType: 'dotPlot'
+      }));
+    });
+  });
+  describe('range changes', function () {
+    it('should update max value', function () {
+      var onChange = jest.fn();
+      var _renderComponent15 = renderComponent({
+          onChange: onChange
+        }),
+        getByLabelText = _renderComponent15.getByLabelText;
+      var maxInput = getByLabelText('Max Value');
+      _react2.fireEvent.change(maxInput, {
+        target: {
+          value: '15'
+        }
+      });
+      expect(onChange).toHaveBeenCalled();
+    });
+    it('should update step value', function () {
+      var onChange = jest.fn();
+      var _renderComponent16 = renderComponent({
+          onChange: onChange
+        }),
+        getByLabelText = _renderComponent16.getByLabelText;
+      var stepInput = getByLabelText('Grid Interval');
+      _react2.fireEvent.change(stepInput, {
+        target: {
+          value: '2'
+        }
+      });
+      expect(onChange).toHaveBeenCalled();
+    });
+    it('should update label step value', function () {
+      var onChange = jest.fn();
+      var _renderComponent17 = renderComponent({
+          onChange: onChange
+        }),
+        getByLabelText = _renderComponent17.getByLabelText;
+      var labelStepInput = getByLabelText('Label Interval');
+      _react2.fireEvent.change(labelStepInput, {
+        target: {
+          value: '2'
+        }
+      });
+      expect(onChange).toHaveBeenCalled();
+    });
+    it('should show alert when changing max causes data to be out of range', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      var onChange, _renderComponent18, getByLabelText, queryByTestId, maxInput;
+      return _regenerator["default"].wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            onChange = jest.fn();
+            _renderComponent18 = renderComponent({
+              onChange: onChange,
+              model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+                range: {
+                  min: 0,
+                  max: 10,
+                  step: 1,
+                  labelStep: 1
+                },
+                data: [{
+                  value: 8
+                }],
+                correctAnswer: {
+                  data: []
+                }
+              })
+            }), getByLabelText = _renderComponent18.getByLabelText, queryByTestId = _renderComponent18.queryByTestId;
+            maxInput = getByLabelText('Max Value');
+            _react2.fireEvent.change(maxInput, {
+              target: {
+                value: '5'
+              }
+            });
+            _context2.next = 1;
+            return (0, _react2.waitFor)(function () {
+              expect(onChange).toHaveBeenCalled();
+            });
+          case 1:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+    it('should show alert when changing step causes data to be out of range', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+      var onChange, _renderComponent19, getByLabelText, stepInput;
+      return _regenerator["default"].wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            onChange = jest.fn();
+            _renderComponent19 = renderComponent({
+              onChange: onChange,
+              model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+                range: {
+                  min: 0,
+                  max: 10,
+                  step: 1,
+                  labelStep: 1
+                },
+                data: [{
+                  value: 5
+                }],
+                correctAnswer: {
+                  data: []
+                }
+              })
+            }), getByLabelText = _renderComponent19.getByLabelText;
+            stepInput = getByLabelText('Grid Interval');
+            _react2.fireEvent.change(stepInput, {
+              target: {
+                value: '3'
+              }
+            });
+            _context3.next = 1;
+            return (0, _react2.waitFor)(function () {
+              expect(onChange).toHaveBeenCalled();
+            });
+          case 1:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+  });
+  describe('dimensions changes', function () {
+    it('should update width', function () {
+      var onChange = jest.fn();
+      var _renderComponent20 = renderComponent({
+          onChange: onChange
+        }),
+        getByLabelText = _renderComponent20.getByLabelText;
+      var widthInput = getByLabelText('Width');
+      _react2.fireEvent.change(widthInput, {
+        target: {
+          value: '500'
+        }
+      });
+      expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+        graph: expect.objectContaining({
+          width: 500
+        })
+      }));
+    });
+    it('should update height', function () {
+      var onChange = jest.fn();
+      var _renderComponent21 = renderComponent({
+          onChange: onChange
+        }),
+        getByLabelText = _renderComponent21.getByLabelText;
+      var heightInput = getByLabelText('Height');
+      _react2.fireEvent.change(heightInput, {
+        target: {
+          value: '600'
+        }
+      });
+      expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+        graph: expect.objectContaining({
+          height: 600
+        })
+      }));
+    });
+  });
+  describe('alert dialog', function () {
+    it('should reset range on cancel', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+      var onChange, _renderComponent22, getByLabelText, queryByTestId, maxInput, event;
+      return _regenerator["default"].wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            onChange = jest.fn();
+            _renderComponent22 = renderComponent({
+              onChange: onChange,
+              model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+                range: {
+                  min: 0,
+                  max: 10,
+                  step: 1,
+                  labelStep: 1
+                },
+                data: [{
+                  value: 8
+                }],
+                correctAnswer: {
+                  data: []
+                }
+              })
+            }), getByLabelText = _renderComponent22.getByLabelText, queryByTestId = _renderComponent22.queryByTestId;
+            maxInput = getByLabelText('Max Value');
+            event = {
+              target: maxInput
+            };
+            _react2.fireEvent.change(maxInput, {
+              target: {
+                value: '5'
+              }
+            });
+            _context4.next = 1;
+            return (0, _react2.waitFor)(function () {
+              var dialog = queryByTestId('alert-dialog');
+              if (dialog) {
+                _react2.fireEvent.click(queryByTestId('alert-cancel'));
+              }
+            }, {
+              timeout: 100
+            })["catch"](function () {});
+          case 1:
+            expect(onChange).toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    })));
+    it('should apply changes and reset data on confirm', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+      var onChange, _renderComponent23, getByLabelText, queryByTestId, maxInput;
+      return _regenerator["default"].wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            onChange = jest.fn();
+            _renderComponent23 = renderComponent({
+              onChange: onChange,
+              model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+                range: {
+                  min: 0,
+                  max: 10,
+                  step: 1,
+                  labelStep: 1
+                },
+                data: [{
+                  value: 8
+                }],
+                correctAnswer: {
+                  data: []
+                }
+              })
+            }), getByLabelText = _renderComponent23.getByLabelText, queryByTestId = _renderComponent23.queryByTestId;
+            maxInput = getByLabelText('Max Value');
+            _react2.fireEvent.change(maxInput, {
+              target: {
+                value: '5'
+              }
+            });
+            _context5.next = 1;
+            return (0, _react2.waitFor)(function () {
+              var dialog = queryByTestId('alert-dialog');
+              if (dialog) {
+                _react2.fireEvent.click(queryByTestId('alert-confirm'));
+              }
+            }, {
+              timeout: 100
+            })["catch"](function () {});
+          case 1:
+            expect(onChange).toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    })));
+  });
+  describe('edge cases', function () {
+    it('should handle missing chartDimensions', function () {
+      var _renderComponent24 = renderComponent({
+          chartDimensions: undefined
+        }),
+        container = _renderComponent24.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('should handle missing gridValues', function () {
+      var _renderComponent25 = renderComponent({
+          gridValues: undefined
+        }),
+        container = _renderComponent25.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('should handle missing labelValues', function () {
+      var _renderComponent26 = renderComponent({
+          labelValues: undefined
+        }),
+        container = _renderComponent26.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('should handle empty model data', function () {
+      var _renderComponent27 = renderComponent({
+          model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+            data: [],
+            correctAnswer: {
+              data: []
+            }
+          })
+        }),
+        container = _renderComponent27.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('should handle empty range object', function () {
+      var _renderComponent28 = renderComponent({
+          model: _objectSpread(_objectSpread({}, defaultModel), {}, {
+            range: {}
+          })
+        }),
+        container = _renderComponent28.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('should apply width constraints correctly', function () {
+      var _renderComponent29 = renderComponent({
+          chartDimensions: {
+            showInConfigPanel: true,
+            width: {
+              min: 100,
+              max: 600,
+              step: 50
+            },
+            height: {
+              min: 400,
+              max: 700,
+              step: 20
+            }
+          }
+        }),
+        container = _renderComponent29.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('should apply height constraints correctly', function () {
+      var _renderComponent30 = renderComponent({
+          chartDimensions: {
+            showInConfigPanel: true,
+            width: {
+              min: 50,
+              max: 700,
+              step: 20
+            },
+            height: {
+              min: 450,
+              max: 650,
+              step: 30
+            }
+          }
+        }),
+        container = _renderComponent30.container;
+      expect(container).toBeInTheDocument();
+    });
+    it('should handle very small step values', function () {
+      var _renderComponent31 = renderComponent({
+          chartDimensions: {
+            showInConfigPanel: true,
+            width: {
+              min: 50,
+              max: 700,
+              step: 0.5
+            },
+            height: {
+              min: 400,
+              max: 700,
+              step: 0.5
+            }
+          }
+        }),
+        container = _renderComponent31.container;
+      expect(container).toBeInTheDocument();
+    });
+  });
+  describe('useEffect lifecycle', function () {
+    it('should call onChange on mount', function () {
+      var onChange = jest.fn();
+      renderComponent({
+        onChange: onChange
+      });
+      expect(onChange).toHaveBeenCalled();
+    });
+    it('should set category default label on mount', function () {
+      var onChange = jest.fn();
+      renderComponent({
+        onChange: onChange,
+        studentNewCategoryDefaultLabel: {
+          label: 'Test Category'
+        }
+      });
+      expect(onChange).toHaveBeenCalled();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_styles","_chartSetup","_interopRequireWildcard","_excluded","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","_typeof","has","get","set","_t","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ownKeys","keys","getOwnPropertySymbols","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","jest","mock","ChartType","_ref","value","onChange","createElement","NumberTextFieldCustom","_ref2","label","props","_objectWithoutProperties2","_extends2","concat","toLowerCase","replace","type","parseFloat","target","AlertDialog","_ref3","open","title","text","onClose","onConfirm","onClick","theme","beforeAll","createTheme","describe","data","range","model","beforeEach","min","max","step","someField","fn","it","resetValues","expect","toBe","not","toHaveBeenCalled","toThrow","undefined","toHaveBeenCalledWith","multiData","every","d","decimalRange","decimalData","defaultModel","chartType","labelStep","graph","width","height","correctAnswer","changeInteractiveEnabled","changeEditableEnabled","defaultProps","chartDimensions","showInConfigPanel","gridValues","labelValues","studentNewCategoryDefaultLabel","availableChartTypes","chartTypeLabel","clearAllMocks","renderComponent","extras","render","ThemeProvider","_renderComponent","container","toBeInTheDocument","_renderComponent2","getByText","_renderComponent3","getByTestId","_renderComponent4","getByLabelText","_renderComponent5","_renderComponent6","_renderComponent7","queryByLabelText","_renderComponent8","_renderComponent9","queryByText","_renderComponent0","_renderComponent1","_renderComponent10","_renderComponent11","getAllByText","constraints","toBeGreaterThan","_renderComponent12","fireEvent","change","_asyncToGenerator2","_regenerator","mark","_callee","_renderComponent13","wrap","_context","prev","next","waitFor","stop","_renderComponent14","objectContaining","_renderComponent15","maxInput","_renderComponent16","stepInput","_renderComponent17","labelStepInput","_callee2","_renderComponent18","queryByTestId","_context2","_callee3","_renderComponent19","_context3","_renderComponent20","widthInput","_renderComponent21","heightInput","_callee4","_renderComponent22","event","_context4","dialog","click","timeout","_callee5","_renderComponent23","_context5","_renderComponent24","_renderComponent25","_renderComponent26","_renderComponent27","_renderComponent28","_renderComponent29","_renderComponent30","_renderComponent31"],"sources":["../../src/__tests__/chart-setup.test.jsx"],"sourcesContent":["import React from 'react';\nimport { fireEvent, render, waitFor } from '@testing-library/react';\nimport { createTheme, ThemeProvider } from '@mui/material/styles';\nimport ConfigureChartPanel, { resetValues } from '../chart-setup';\n\njest.mock('../chart-type', () => {\n  return function ChartType({ value, onChange }) {\n    return (\n      <select data-testid=\"chart-type-select\" value={value} onChange={onChange}>\n        <option value=\"bar\">Bar</option>\n        <option value=\"line\">Line</option>\n        <option value=\"linePlot\">Line Plot</option>\n        <option value=\"dotPlot\">Dot Plot</option>\n      </select>\n    );\n  };\n});\n\njest.mock('@pie-lib/config-ui', () => ({\n  NumberTextFieldCustom: ({ label, value, onChange, ...props }) => (\n    <input\n      data-testid={`number-field-${label.toLowerCase().replace(/\\s+/g, '-')}`}\n      type=\"number\"\n      value={value}\n      onChange={(e) => onChange(e, parseFloat(e.target.value) || 0)}\n      aria-label={label}\n      {...props}\n    />\n  ),\n  AlertDialog: ({ open, title, text, onClose, onConfirm }) =>\n    open ? (\n      <div data-testid=\"alert-dialog\">\n        <h2>{title}</h2>\n        <p>{text}</p>\n        <button data-testid=\"alert-cancel\" onClick={onClose}>\n          Cancel\n        </button>\n        <button data-testid=\"alert-confirm\" onClick={onConfirm}>\n          Confirm\n        </button>\n      </div>\n    ) : null,\n}));\n\nlet theme;\n\nbeforeAll(() => {\n  theme = createTheme();\n});\n\ndescribe('resetValues', () => {\n  let data;\n  let range;\n  let model;\n  let onChange;\n\n  beforeEach(() => {\n    range = { min: 0, max: 10, step: 1 };\n    data = [{ value: 2 }, { value: 11 }, { value: 5.5 }, { value: 2.0000000001 }, { value: 2.9999999999 }];\n    model = { someField: 'someValue', data };\n    onChange = jest.fn();\n  });\n\n  it('should reset values greater than range.max to zero', () => {\n    resetValues(data, true, range, onChange, model);\n    expect(data[1].value).toBe(0);\n  });\n\n  it('should reset values that are not multiples of range.step to zero', () => {\n    resetValues(data, true, range, onChange, model);\n    expect(data[2].value).toBe(0);\n  });\n\n  it('should not reset values that are within range and multiples of range.step', () => {\n    resetValues(data, true, range, onChange, model);\n    expect(data[0].value).toBe(2);\n  });\n\n  it('should not reset floating point values that are close to multiples of range.step', () => {\n    resetValues(data, true, range, onChange, model);\n    expect(data[3].value).toBe(2.0000000001);\n    expect(data[4].value).toBe(2.9999999999);\n  });\n\n  it('should not call onChange when updateModel is false', () => {\n    resetValues(data, false, range, onChange, model);\n    expect(onChange).not.toHaveBeenCalled();\n  });\n\n  it('should handle null or undefined data array', () => {\n    expect(() => resetValues(null, true, range, onChange, model)).not.toThrow();\n    expect(() => resetValues(undefined, true, range, onChange, model)).not.toThrow();\n  });\n\n  it('should handle empty data array', () => {\n    resetValues([], true, range, onChange, model);\n    expect(onChange).toHaveBeenCalledWith({ ...model, data: [] });\n  });\n\n  it('should reset multiple invalid values', () => {\n    const multiData = [{ value: 11 }, { value: 12 }, { value: 5.5 }, { value: 3.7 }];\n    resetValues(multiData, true, range, onChange, { ...model, data: multiData });\n    expect(multiData.every((d) => d.value === 0)).toBe(true);\n  });\n\n  it('should handle decimal step values', () => {\n    const decimalRange = { min: 0, max: 10, step: 0.5 };\n    const decimalData = [{ value: 1.5 }, { value: 2.3 }, { value: 3.0 }];\n    resetValues(decimalData, true, decimalRange, onChange, model);\n    expect(decimalData[0].value).toBe(1.5);\n    expect(decimalData[1].value).toBe(0);\n    expect(decimalData[2].value).toBe(3.0);\n  });\n});\n\ndescribe('ConfigureChartPanel', () => {\n  const defaultModel = {\n    chartType: 'bar',\n    range: { min: 0, max: 10, step: 1, labelStep: 1 },\n    graph: { width: 400, height: 500 },\n    data: [{ value: 5 }],\n    correctAnswer: { data: [{ value: 3 }] },\n    changeInteractiveEnabled: true,\n    changeEditableEnabled: true,\n  };\n\n  const defaultProps = {\n    model: defaultModel,\n    onChange: jest.fn(),\n    chartDimensions: {\n      showInConfigPanel: true,\n      width: { min: 50, max: 700, step: 20 },\n      height: { min: 400, max: 700, step: 20 },\n    },\n    gridValues: { range: { min: 0, max: 10000 } },\n    labelValues: { range: { min: 0, max: 10000 } },\n    studentNewCategoryDefaultLabel: { label: 'Category' },\n    availableChartTypes: {},\n    chartTypeLabel: 'Chart Type',\n  };\n\n  beforeEach(() => {\n    jest.clearAllMocks();\n  });\n\n  const renderComponent = (extras = {}) => {\n    const props = { ...defaultProps, ...extras };\n    return render(\n      <ThemeProvider theme={theme}>\n        <ConfigureChartPanel {...props} />\n      </ThemeProvider>,\n    );\n  };\n\n  describe('rendering', () => {\n    it('should render without crashing', () => {\n      const { container } = renderComponent();\n      expect(container).toBeInTheDocument();\n    });\n\n    it('should render \"Configure Chart\" title', () => {\n      const { getByText } = renderComponent();\n      expect(getByText('Configure Chart')).toBeInTheDocument();\n    });\n\n    it('should render chart type selector', () => {\n      const { getByTestId } = renderComponent();\n      expect(getByTestId('chart-type-select')).toBeInTheDocument();\n    });\n\n    it('should render max value field', () => {\n      const { getByLabelText } = renderComponent();\n      expect(getByLabelText('Max Value')).toBeInTheDocument();\n    });\n\n    it('should render grid interval field for non-plot charts', () => {\n      const { getByLabelText } = renderComponent({\n        model: { ...defaultModel, chartType: 'bar' },\n      });\n      expect(getByLabelText('Grid Interval')).toBeInTheDocument();\n    });\n\n    it('should render label interval field for non-plot charts', () => {\n      const { getByLabelText } = renderComponent({\n        model: { ...defaultModel, chartType: 'bar' },\n      });\n      expect(getByLabelText('Label Interval')).toBeInTheDocument();\n    });\n\n    it('should not render step config for plot charts', () => {\n      const { queryByLabelText } = renderComponent({\n        model: { ...defaultModel, chartType: 'linePlot' },\n      });\n      expect(queryByLabelText('Grid Interval')).not.toBeInTheDocument();\n      expect(queryByLabelText('Label Interval')).not.toBeInTheDocument();\n    });\n\n    it('should render dimensions section when showInConfigPanel is true', () => {\n      const { getByText } = renderComponent({\n        chartDimensions: {\n          showInConfigPanel: true,\n          width: { min: 50, max: 700, step: 20 },\n          height: { min: 400, max: 700, step: 20 },\n        },\n      });\n      expect(getByText('Dimensions(px)')).toBeInTheDocument();\n    });\n\n    it('should not render dimensions section when showInConfigPanel is false', () => {\n      const { queryByText } = renderComponent({\n        chartDimensions: {\n          showInConfigPanel: false,\n          width: { min: 50, max: 700, step: 20 },\n          height: { min: 400, max: 700, step: 20 },\n        },\n      });\n      expect(queryByText('Dimensions(px)')).not.toBeInTheDocument();\n    });\n\n    it('should render width field when dimensions are shown', () => {\n      const { getByLabelText } = renderComponent();\n      expect(getByLabelText('Width')).toBeInTheDocument();\n    });\n\n    it('should render height field when dimensions are shown', () => {\n      const { getByLabelText } = renderComponent();\n      expect(getByLabelText('Height')).toBeInTheDocument();\n    });\n\n    it('should display width constraints', () => {\n      const { getByText } = renderComponent();\n      expect(getByText('Min 50, Max 700')).toBeInTheDocument();\n    });\n\n    it('should display height constraints', () => {\n      const { getAllByText } = renderComponent();\n      const constraints = getAllByText('Min 400, Max 700');\n      expect(constraints.length).toBeGreaterThan(0);\n    });\n  });\n\n  describe('chart type changes', () => {\n    it('should call onChange when chart type is changed to non-plot', () => {\n      const onChange = jest.fn();\n      const { getByTestId } = renderComponent({ onChange });\n\n      fireEvent.change(getByTestId('chart-type-select'), { target: { value: 'line' } });\n\n      expect(onChange).toHaveBeenCalled();\n    });\n\n    it('should show warning when switching to plot with invalid config', async () => {\n      const { getByTestId, getByText } = renderComponent({\n        model: { ...defaultModel, range: { max: 20, step: 2, labelStep: 2 } },\n      });\n\n      fireEvent.change(getByTestId('chart-type-select'), { target: { value: 'linePlot' } });\n\n      await waitFor(() => {\n        expect(getByText('Warning')).toBeInTheDocument();\n      });\n    });\n\n    it('should allow switching to plot with valid config', () => {\n      const onChange = jest.fn();\n      const { getByTestId } = renderComponent({\n        onChange,\n        model: { ...defaultModel, range: { max: 10, step: 1, labelStep: 1 } },\n      });\n\n      fireEvent.change(getByTestId('chart-type-select'), { target: { value: 'dotPlot' } });\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          chartType: 'dotPlot',\n        }),\n      );\n    });\n  });\n\n  describe('range changes', () => {\n    it('should update max value', () => {\n      const onChange = jest.fn();\n      const { getByLabelText } = renderComponent({ onChange });\n\n      const maxInput = getByLabelText('Max Value');\n      fireEvent.change(maxInput, { target: { value: '15' } });\n\n      expect(onChange).toHaveBeenCalled();\n    });\n\n    it('should update step value', () => {\n      const onChange = jest.fn();\n      const { getByLabelText } = renderComponent({ onChange });\n\n      const stepInput = getByLabelText('Grid Interval');\n      fireEvent.change(stepInput, { target: { value: '2' } });\n\n      expect(onChange).toHaveBeenCalled();\n    });\n\n    it('should update label step value', () => {\n      const onChange = jest.fn();\n      const { getByLabelText } = renderComponent({ onChange });\n\n      const labelStepInput = getByLabelText('Label Interval');\n      fireEvent.change(labelStepInput, { target: { value: '2' } });\n\n      expect(onChange).toHaveBeenCalled();\n    });\n\n    it('should show alert when changing max causes data to be out of range', async () => {\n      const onChange = jest.fn();\n      const { getByLabelText, queryByTestId } = renderComponent({\n        onChange,\n        model: {\n          ...defaultModel,\n          range: { min: 0, max: 10, step: 1, labelStep: 1 },\n          data: [{ value: 8 }],\n          correctAnswer: { data: [] },\n        },\n      });\n\n      const maxInput = getByLabelText('Max Value');\n      fireEvent.change(maxInput, { target: { value: '5' } });\n\n      await waitFor(() => {\n        expect(onChange).toHaveBeenCalled();\n      });\n    });\n\n    it('should show alert when changing step causes data to be out of range', async () => {\n      const onChange = jest.fn();\n      const { getByLabelText } = renderComponent({\n        onChange,\n        model: {\n          ...defaultModel,\n          range: { min: 0, max: 10, step: 1, labelStep: 1 },\n          data: [{ value: 5 }],\n          correctAnswer: { data: [] },\n        },\n      });\n\n      const stepInput = getByLabelText('Grid Interval');\n      fireEvent.change(stepInput, { target: { value: '3' } });\n\n      await waitFor(() => {\n        expect(onChange).toHaveBeenCalled();\n      });\n    });\n  });\n\n  describe('dimensions changes', () => {\n    it('should update width', () => {\n      const onChange = jest.fn();\n      const { getByLabelText } = renderComponent({ onChange });\n\n      const widthInput = getByLabelText('Width');\n      fireEvent.change(widthInput, { target: { value: '500' } });\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          graph: expect.objectContaining({ width: 500 }),\n        }),\n      );\n    });\n\n    it('should update height', () => {\n      const onChange = jest.fn();\n      const { getByLabelText } = renderComponent({ onChange });\n\n      const heightInput = getByLabelText('Height');\n      fireEvent.change(heightInput, { target: { value: '600' } });\n\n      expect(onChange).toHaveBeenCalledWith(\n        expect.objectContaining({\n          graph: expect.objectContaining({ height: 600 }),\n        }),\n      );\n    });\n  });\n\n  describe('alert dialog', () => {\n    it('should reset range on cancel', async () => {\n      const onChange = jest.fn();\n      const { getByLabelText, queryByTestId } = renderComponent({\n        onChange,\n        model: {\n          ...defaultModel,\n          range: { min: 0, max: 10, step: 1, labelStep: 1 },\n          data: [{ value: 8 }],\n          correctAnswer: { data: [] },\n        },\n      });\n\n      const maxInput = getByLabelText('Max Value');\n\n      const event = { target: maxInput };\n      fireEvent.change(maxInput, { target: { value: '5' } });\n\n      await waitFor(\n        () => {\n          const dialog = queryByTestId('alert-dialog');\n          if (dialog) {\n            fireEvent.click(queryByTestId('alert-cancel'));\n          }\n        },\n        { timeout: 100 },\n      ).catch(() => {});\n\n      expect(onChange).toHaveBeenCalled();\n    });\n\n    it('should apply changes and reset data on confirm', async () => {\n      const onChange = jest.fn();\n      const { getByLabelText, queryByTestId } = renderComponent({\n        onChange,\n        model: {\n          ...defaultModel,\n          range: { min: 0, max: 10, step: 1, labelStep: 1 },\n          data: [{ value: 8 }],\n          correctAnswer: { data: [] },\n        },\n      });\n\n      const maxInput = getByLabelText('Max Value');\n      fireEvent.change(maxInput, { target: { value: '5' } });\n\n      await waitFor(\n        () => {\n          const dialog = queryByTestId('alert-dialog');\n          if (dialog) {\n            fireEvent.click(queryByTestId('alert-confirm'));\n          }\n        },\n        { timeout: 100 },\n      ).catch(() => {});\n\n      expect(onChange).toHaveBeenCalled();\n    });\n  });\n\n  describe('edge cases', () => {\n    it('should handle missing chartDimensions', () => {\n      const { container } = renderComponent({ chartDimensions: undefined });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('should handle missing gridValues', () => {\n      const { container } = renderComponent({ gridValues: undefined });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('should handle missing labelValues', () => {\n      const { container } = renderComponent({ labelValues: undefined });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('should handle empty model data', () => {\n      const { container } = renderComponent({\n        model: {\n          ...defaultModel,\n          data: [],\n          correctAnswer: { data: [] },\n        },\n      });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('should handle empty range object', () => {\n      const { container } = renderComponent({\n        model: {\n          ...defaultModel,\n          range: {},\n        },\n      });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('should apply width constraints correctly', () => {\n      const { container } = renderComponent({\n        chartDimensions: {\n          showInConfigPanel: true,\n          width: { min: 100, max: 600, step: 50 },\n          height: { min: 400, max: 700, step: 20 },\n        },\n      });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('should apply height constraints correctly', () => {\n      const { container } = renderComponent({\n        chartDimensions: {\n          showInConfigPanel: true,\n          width: { min: 50, max: 700, step: 20 },\n          height: { min: 450, max: 650, step: 30 },\n        },\n      });\n      expect(container).toBeInTheDocument();\n    });\n\n    it('should handle very small step values', () => {\n      const { container } = renderComponent({\n        chartDimensions: {\n          showInConfigPanel: true,\n          width: { min: 50, max: 700, step: 0.5 },\n          height: { min: 400, max: 700, step: 0.5 },\n        },\n      });\n      expect(container).toBeInTheDocument();\n    });\n  });\n\n  describe('useEffect lifecycle', () => {\n    it('should call onChange on mount', () => {\n      const onChange = jest.fn();\n      renderComponent({ onChange });\n\n      expect(onChange).toHaveBeenCalled();\n    });\n\n    it('should set category default label on mount', () => {\n      const onChange = jest.fn();\n      renderComponent({\n        onChange,\n        studentNewCategoryDefaultLabel: { label: 'Test Category' },\n      });\n\n      expect(onChange).toHaveBeenCalled();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}