@pie-lib/config-ui 12.2.0-next.0 → 12.2.0-next.2

package/lib/__tests__/settings.test.js

@@ -0,0 +1,653 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _userEvent = _interopRequireDefault(require("@testing-library/user-event"));
+var _toggle = _interopRequireDefault(require("../settings/toggle"));
+var _displaySize = _interopRequireDefault(require("../settings/display-size"));
+var _settingsRadioLabel = _interopRequireDefault(require("../settings/settings-radio-label"));
+var _panel = require("../settings/panel");
+describe('Settings Components', function () {
+  describe('Toggle', function () {
+    it('renders toggle with label', function () {
+      var toggle = jest.fn();
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_toggle["default"], {
+        label: "Enable Feature",
+        checked: false,
+        toggle: toggle
+      }));
+      expect(_react2.screen.getByText('Enable Feature')).toBeInTheDocument();
+    });
+  });
+  describe('DisplaySize', function () {
+    var defaultProps = {
+      size: {
+        width: 500,
+        height: 400
+      },
+      label: 'Display Size',
+      onChange: jest.fn()
+    };
+    beforeEach(function () {
+      jest.clearAllMocks();
+    });
+    it('renders label and input fields', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], defaultProps));
+      expect(_react2.screen.getByText('Display Size')).toBeInTheDocument();
+      expect(_react2.screen.getByLabelText('Width')).toBeInTheDocument();
+      expect(_react2.screen.getByLabelText('Height')).toBeInTheDocument();
+    });
+    it('displays width and height values', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], defaultProps));
+      var widthInput = _react2.screen.getByLabelText('Width');
+      var heightInput = _react2.screen.getByLabelText('Height');
+      expect(widthInput).toHaveValue(500);
+      expect(heightInput).toHaveValue(400);
+    });
+    it('calls onChange when width changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var user, onChange, widthInput;
+      return _regenerator["default"].wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            widthInput = _react2.screen.getByLabelText('Width');
+            _context.next = 1;
+            return user.clear(widthInput);
+          case 1:
+            _context.next = 2;
+            return user.type(widthInput, '600');
+          case 2:
+            _react2.fireEvent.blur(widthInput);
+            expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+              width: 600
+            }));
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('calls onChange when height changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      var user, onChange, heightInput;
+      return _regenerator["default"].wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            heightInput = _react2.screen.getByLabelText('Height');
+            _context2.next = 1;
+            return user.clear(heightInput);
+          case 1:
+            _context2.next = 2;
+            return user.type(heightInput, '500');
+          case 2:
+            _react2.fireEvent.blur(heightInput);
+            expect(onChange).toHaveBeenCalledWith(expect.objectContaining({
+              height: 500
+            }));
+          case 3:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+    it('maintains other dimension when one changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+      var user, onChange, widthInput;
+      return _regenerator["default"].wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            widthInput = _react2.screen.getByLabelText('Width');
+            _context3.next = 1;
+            return user.clear(widthInput);
+          case 1:
+            _context3.next = 2;
+            return user.type(widthInput, '700');
+          case 2:
+            _react2.fireEvent.blur(widthInput);
+            expect(onChange).toHaveBeenCalledWith({
+              width: 700,
+              height: 400
+            });
+          case 3:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+    it('enforces min value constraint', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+      var user, onChange, widthInput;
+      return _regenerator["default"].wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            widthInput = _react2.screen.getByLabelText('Width');
+            _context4.next = 1;
+            return user.clear(widthInput);
+          case 1:
+            _context4.next = 2;
+            return user.type(widthInput, '100');
+          case 2:
+            _react2.fireEvent.blur(widthInput);
+
+            // Should clamp to minimum 150
+            expect(widthInput).toHaveValue(150);
+          case 3:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    })));
+    it('enforces max value constraint', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+      var user, onChange, widthInput;
+      return _regenerator["default"].wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            widthInput = _react2.screen.getByLabelText('Width');
+            _context5.next = 1;
+            return user.clear(widthInput);
+          case 1:
+            _context5.next = 2;
+            return user.type(widthInput, '2000');
+          case 2:
+            _react2.fireEvent.blur(widthInput);
+
+            // Should clamp to maximum 1000
+            expect(widthInput).toHaveValue(1000);
+          case 3:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    })));
+    it('updates when size prop changes', function () {
+      var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], defaultProps)),
+        rerender = _render.rerender;
+      var widthInput = _react2.screen.getByLabelText('Width');
+      expect(widthInput).toHaveValue(500);
+      rerender(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+        size: {
+          width: 800,
+          height: 600
+        }
+      })));
+      widthInput = _react2.screen.getByLabelText('Width');
+      expect(widthInput).toHaveValue(800);
+    });
+    it('handles boundary values at minimum', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+      var user, onChange, widthInput, heightInput;
+      return _regenerator["default"].wrap(function (_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            widthInput = _react2.screen.getByLabelText('Width');
+            heightInput = _react2.screen.getByLabelText('Height');
+            _context6.next = 1;
+            return user.clear(widthInput);
+          case 1:
+            _context6.next = 2;
+            return user.type(widthInput, '150');
+          case 2:
+            _react2.fireEvent.blur(widthInput);
+            _context6.next = 3;
+            return user.clear(heightInput);
+          case 3:
+            _context6.next = 4;
+            return user.type(heightInput, '150');
+          case 4:
+            _react2.fireEvent.blur(heightInput);
+            expect(widthInput).toHaveValue(150);
+            expect(heightInput).toHaveValue(150);
+          case 5:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    })));
+    it('handles boundary values at maximum', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+      var user, onChange, widthInput, heightInput;
+      return _regenerator["default"].wrap(function (_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            widthInput = _react2.screen.getByLabelText('Width');
+            heightInput = _react2.screen.getByLabelText('Height');
+            _context7.next = 1;
+            return user.clear(widthInput);
+          case 1:
+            _context7.next = 2;
+            return user.type(widthInput, '1000');
+          case 2:
+            _react2.fireEvent.blur(widthInput);
+            _context7.next = 3;
+            return user.clear(heightInput);
+          case 3:
+            _context7.next = 4;
+            return user.type(heightInput, '1000');
+          case 4:
+            _react2.fireEvent.blur(heightInput);
+            expect(widthInput).toHaveValue(1000);
+            expect(heightInput).toHaveValue(1000);
+          case 5:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7);
+    })));
+    it('handles decimal input values', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee8() {
+      var user, onChange, widthInput;
+      return _regenerator["default"].wrap(function (_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            widthInput = _react2.screen.getByLabelText('Width');
+            _context8.next = 1;
+            return user.clear(widthInput);
+          case 1:
+            _context8.next = 2;
+            return user.type(widthInput, '500.5');
+          case 2:
+            _react2.fireEvent.blur(widthInput);
+            expect(widthInput).toBeInTheDocument();
+          case 3:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    })));
+    it('handles empty input and resets to min', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee9() {
+      var user, onChange, widthInput;
+      return _regenerator["default"].wrap(function (_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            widthInput = _react2.screen.getByLabelText('Width');
+            _context9.next = 1;
+            return user.clear(widthInput);
+          case 1:
+            _react2.fireEvent.blur(widthInput);
+
+            // Should reset to minimum value
+            expect(widthInput).toHaveValue(150);
+          case 2:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    })));
+    it('handles rapid width and height changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee0() {
+      var user, onChange, widthInput;
+      return _regenerator["default"].wrap(function (_context0) {
+        while (1) switch (_context0.prev = _context0.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            widthInput = _react2.screen.getByLabelText('Width');
+            _context0.next = 1;
+            return user.clear(widthInput);
+          case 1:
+            _context0.next = 2;
+            return user.type(widthInput, '6');
+          case 2:
+            _context0.next = 3;
+            return user.type(widthInput, '0');
+          case 3:
+            _context0.next = 4;
+            return user.type(widthInput, '0');
+          case 4:
+            _react2.fireEvent.blur(widthInput);
+            expect(onChange).toHaveBeenCalled();
+          case 5:
+          case "end":
+            return _context0.stop();
+        }
+      }, _callee0);
+    })));
+    it('clamps height at both boundaries', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee1() {
+      var user, onChange, heightInput;
+      return _regenerator["default"].wrap(function (_context1) {
+        while (1) switch (_context1.prev = _context1.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], (0, _extends2["default"])({}, defaultProps, {
+              onChange: onChange
+            })));
+            heightInput = _react2.screen.getByLabelText('Height'); // Test below min
+            _context1.next = 1;
+            return user.clear(heightInput);
+          case 1:
+            _context1.next = 2;
+            return user.type(heightInput, '50');
+          case 2:
+            _react2.fireEvent.blur(heightInput);
+            expect(heightInput).toHaveValue(150);
+
+            // Test above max
+            _context1.next = 3;
+            return user.clear(heightInput);
+          case 3:
+            _context1.next = 4;
+            return user.type(heightInput, '2500');
+          case 4:
+            _react2.fireEvent.blur(heightInput);
+            expect(heightInput).toHaveValue(1000);
+          case 5:
+          case "end":
+            return _context1.stop();
+        }
+      }, _callee1);
+    })));
+    it('displays custom label text', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], {
+        size: {
+          width: 500,
+          height: 400
+        },
+        label: "Custom Size Settings",
+        onChange: jest.fn()
+      }));
+      expect(_react2.screen.getByText('Custom Size Settings')).toBeInTheDocument();
+    });
+    it('renders with variant outlined', function () {
+      var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_displaySize["default"], defaultProps)),
+        container = _render2.container;
+      var inputs = container.querySelectorAll('input');
+      expect(inputs.length).toBe(2);
+    });
+  });
+  describe('SettingsRadioLabel', function () {
+    it('renders radio label', function () {
+      var onChange = jest.fn();
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_settingsRadioLabel["default"], {
+        label: "Option 1",
+        value: "option1",
+        checked: false,
+        onChange: onChange
+      }));
+      expect(_react2.screen.getByText('Option 1')).toBeInTheDocument();
+      expect(_react2.screen.getByRole('radio')).toBeInTheDocument();
+    });
+    it('renders checked state', function () {
+      var onChange = jest.fn();
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_settingsRadioLabel["default"], {
+        label: "Option 1",
+        value: "option1",
+        checked: true,
+        onChange: onChange
+      }));
+      var radio = _react2.screen.getByRole('radio');
+      expect(radio).toBeChecked();
+    });
+    it('renders unchecked state', function () {
+      var onChange = jest.fn();
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_settingsRadioLabel["default"], {
+        label: "Option 1",
+        value: "option1",
+        checked: false,
+        onChange: onChange
+      }));
+      var radio = _react2.screen.getByRole('radio');
+      expect(radio).not.toBeChecked();
+    });
+    it('calls onChange when radio is clicked', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+      var user, onChange, radio;
+      return _regenerator["default"].wrap(function (_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_settingsRadioLabel["default"], {
+              label: "Option 1",
+              value: "option1",
+              checked: false,
+              onChange: onChange
+            }));
+            radio = _react2.screen.getByRole('radio');
+            _context10.next = 1;
+            return user.click(radio);
+          case 1:
+            expect(onChange).toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10);
+    })));
+    it('displays label text correctly', function () {
+      var onChange = jest.fn();
+      var labelText = 'Custom Option Label';
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_settingsRadioLabel["default"], {
+        label: labelText,
+        value: "custom",
+        checked: false,
+        onChange: onChange
+      }));
+      expect(_react2.screen.getByText(labelText)).toBeInTheDocument();
+    });
+  });
+  describe('Panel', function () {
+    var defaultProps = {
+      model: {
+        toggleSetting: true,
+        numberValue: 5
+      },
+      configuration: {
+        configValue: 'test'
+      },
+      groups: {
+        'General Settings': {
+          toggleSetting: {
+            type: 'toggle',
+            label: 'Enable Feature'
+          }
+        }
+      },
+      onChangeModel: jest.fn(),
+      onChangeConfiguration: jest.fn()
+    };
+    beforeEach(function () {
+      jest.clearAllMocks();
+    });
+    it('renders panel with group label', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_panel.Panel, defaultProps));
+      expect(_react2.screen.getByText('General Settings')).toBeInTheDocument();
+    });
+    it('renders empty when groups is undefined', function () {
+      var _render3 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_panel.Panel, (0, _extends2["default"])({}, defaultProps, {
+          groups: undefined
+        }))),
+        container = _render3.container;
+      expect(container.firstChild.children.length).toBe(0);
+    });
+    it('renders empty when groups is empty', function () {
+      var _render4 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_panel.Panel, (0, _extends2["default"])({}, defaultProps, {
+          groups: {}
+        }))),
+        container = _render4.container;
+      expect(container.firstChild.children.length).toBe(0);
+    });
+    it('calls onChangeModel when model changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee11() {
+      var user, onChangeModel, _render5, container, switchElement;
+      return _regenerator["default"].wrap(function (_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChangeModel = jest.fn();
+            _render5 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_panel.Panel, (0, _extends2["default"])({}, defaultProps, {
+              onChangeModel: onChangeModel
+            }))), container = _render5.container;
+            switchElement = container.querySelector('input[type="checkbox"]');
+            _context11.next = 1;
+            return user.click(switchElement);
+          case 1:
+            expect(onChangeModel).toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11);
+    })));
+    it('calls onChangeConfiguration when configuration changes', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee12() {
+      var user, onChangeConfiguration, _render6, container, switchElement;
+      return _regenerator["default"].wrap(function (_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChangeConfiguration = jest.fn();
+            _render6 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_panel.Panel, (0, _extends2["default"])({}, defaultProps, {
+              groups: {
+                'Config Group': {
+                  configValue: {
+                    type: 'toggle',
+                    label: 'Config Toggle',
+                    isConfigProperty: true
+                  }
+                }
+              },
+              onChangeConfiguration: onChangeConfiguration
+            }))), container = _render6.container;
+            switchElement = container.querySelector('input[type="checkbox"]');
+            _context12.next = 1;
+            return user.click(switchElement);
+          case 1:
+            expect(onChangeConfiguration).toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12);
+    })));
+    it('renders with modal when provided', function () {
+      var modal = /*#__PURE__*/_react["default"].createElement("div", {
+        "data-testid": "test-modal"
+      }, "Modal Content");
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_panel.Panel, (0, _extends2["default"])({}, defaultProps, {
+        modal: modal
+      })));
+      expect(_react2.screen.getByTestId('test-modal')).toBeInTheDocument();
+      expect(_react2.screen.getByText('Modal Content')).toBeInTheDocument();
+    });
+    it('renders multiple groups', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_panel.Panel, (0, _extends2["default"])({}, defaultProps, {
+        groups: {
+          'Group One': {
+            setting1: {
+              type: 'toggle',
+              label: 'Setting One'
+            }
+          },
+          'Group Two': {
+            setting2: {
+              type: 'toggle',
+              label: 'Setting Two'
+            }
+          }
+        },
+        model: {
+          setting1: true,
+          setting2: false
+        }
+      })));
+      expect(_react2.screen.getByText('Group One')).toBeInTheDocument();
+      expect(_react2.screen.getByText('Group Two')).toBeInTheDocument();
+    });
+    it('uses default callbacks when not provided', function () {
+      var _render7 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_panel.Panel, {
+          model: {
+            test: true
+          },
+          groups: {
+            'Test Group': {
+              test: {
+                type: 'toggle',
+                label: 'Test'
+              }
+            }
+          }
+        })),
+        container = _render7.container;
+      expect(container.firstChild).toBeInTheDocument();
+    });
+    it('filters out empty groups', function () {
+      var _render8 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_panel.Panel, (0, _extends2["default"])({}, defaultProps, {
+          groups: {
+            'Empty Group': {},
+            'General Settings': {
+              toggleSetting: {
+                type: 'toggle',
+                label: 'Enable Feature'
+              }
+            }
+          },
+          model: {
+            toggleSetting: true
+          }
+        }))),
+        container = _render8.container;
+      expect(_react2.screen.getByText('General Settings')).toBeInTheDocument();
+      expect(_react2.screen.queryByText('Empty Group')).not.toBeInTheDocument();
+    });
+    it('renders with null model', function () {
+      var _render9 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_panel.Panel, {
+          model: null,
+          configuration: {},
+          groups: {
+            'General Settings': {
+              toggleSetting: {
+                type: 'toggle',
+                label: 'Enable Feature'
+              }
+            }
+          },
+          onChangeModel: jest.fn()
+        })),
+        container = _render9.container;
+      expect(_react2.screen.getByText('General Settings')).toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_userEvent","_toggle","_displaySize","_settingsRadioLabel","_panel","describe","it","toggle","jest","fn","render","createElement","label","checked","expect","screen","getByText","toBeInTheDocument","defaultProps","size","width","height","onChange","beforeEach","clearAllMocks","getByLabelText","widthInput","heightInput","toHaveValue","_asyncToGenerator2","_regenerator","mark","_callee","user","wrap","_context","prev","next","userEvent","setup","_extends2","clear","type","fireEvent","blur","toHaveBeenCalledWith","objectContaining","stop","_callee2","_context2","_callee3","_context3","_callee4","_context4","_callee5","_context5","_render","rerender","_callee6","_context6","_callee7","_context7","_callee8","_context8","_callee9","_context9","_callee0","_context0","toHaveBeenCalled","_callee1","_context1","_render2","container","inputs","querySelectorAll","length","toBe","value","getByRole","radio","toBeChecked","not","_callee10","_context10","click","labelText","model","toggleSetting","numberValue","configuration","configValue","groups","onChangeModel","onChangeConfiguration","Panel","_render3","undefined","firstChild","children","_render4","_callee11","_render5","switchElement","_context11","querySelector","_callee12","_render6","_context12","isConfigProperty","modal","getByTestId","setting1","setting2","_render7","test","_render8","queryByText","_render9"],"sources":["../../src/__tests__/settings.test.jsx"],"sourcesContent":["import React from 'react';\nimport { fireEvent, render, screen } from '@testing-library/react';\nimport userEvent from '@testing-library/user-event';\nimport Toggle from '../settings/toggle';\nimport DisplaySize from '../settings/display-size';\nimport SettingsRadioLabel from '../settings/settings-radio-label';\nimport { Panel } from '../settings/panel';\n\ndescribe('Settings Components', () => {\n  describe('Toggle', () => {\n    it('renders toggle with label', () => {\n      const toggle = jest.fn();\n      render(<Toggle label=\"Enable Feature\" checked={false} toggle={toggle} />);\n\n      expect(screen.getByText('Enable Feature')).toBeInTheDocument();\n    });\n  });\n\n  describe('DisplaySize', () => {\n    const defaultProps = {\n      size: { width: 500, height: 400 },\n      label: 'Display Size',\n      onChange: jest.fn(),\n    };\n\n    beforeEach(() => {\n      jest.clearAllMocks();\n    });\n\n    it('renders label and input fields', () => {\n      render(<DisplaySize {...defaultProps} />);\n\n      expect(screen.getByText('Display Size')).toBeInTheDocument();\n      expect(screen.getByLabelText('Width')).toBeInTheDocument();\n      expect(screen.getByLabelText('Height')).toBeInTheDocument();\n    });\n\n    it('displays width and height values', () => {\n      render(<DisplaySize {...defaultProps} />);\n\n      const widthInput = screen.getByLabelText('Width');\n      const heightInput = screen.getByLabelText('Height');\n\n      expect(widthInput).toHaveValue(500);\n      expect(heightInput).toHaveValue(400);\n    });\n\n    it('calls onChange when width changes', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const widthInput = screen.getByLabelText('Width');\n      await user.clear(widthInput);\n      await user.type(widthInput, '600');\n      fireEvent.blur(widthInput);\n\n      expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ width: 600 }));\n    });\n\n    it('calls onChange when height changes', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const heightInput = screen.getByLabelText('Height');\n      await user.clear(heightInput);\n      await user.type(heightInput, '500');\n      fireEvent.blur(heightInput);\n\n      expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ height: 500 }));\n    });\n\n    it('maintains other dimension when one changes', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const widthInput = screen.getByLabelText('Width');\n      await user.clear(widthInput);\n      await user.type(widthInput, '700');\n      fireEvent.blur(widthInput);\n\n      expect(onChange).toHaveBeenCalledWith({\n        width: 700,\n        height: 400,\n      });\n    });\n\n    it('enforces min value constraint', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const widthInput = screen.getByLabelText('Width');\n      await user.clear(widthInput);\n      await user.type(widthInput, '100');\n      fireEvent.blur(widthInput);\n\n      // Should clamp to minimum 150\n      expect(widthInput).toHaveValue(150);\n    });\n\n    it('enforces max value constraint', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const widthInput = screen.getByLabelText('Width');\n      await user.clear(widthInput);\n      await user.type(widthInput, '2000');\n      fireEvent.blur(widthInput);\n\n      // Should clamp to maximum 1000\n      expect(widthInput).toHaveValue(1000);\n    });\n\n    it('updates when size prop changes', () => {\n      const { rerender } = render(<DisplaySize {...defaultProps} />);\n\n      let widthInput = screen.getByLabelText('Width');\n      expect(widthInput).toHaveValue(500);\n\n      rerender(<DisplaySize {...defaultProps} size={{ width: 800, height: 600 }} />);\n\n      widthInput = screen.getByLabelText('Width');\n      expect(widthInput).toHaveValue(800);\n    });\n\n    it('handles boundary values at minimum', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const widthInput = screen.getByLabelText('Width');\n      const heightInput = screen.getByLabelText('Height');\n\n      await user.clear(widthInput);\n      await user.type(widthInput, '150');\n      fireEvent.blur(widthInput);\n\n      await user.clear(heightInput);\n      await user.type(heightInput, '150');\n      fireEvent.blur(heightInput);\n\n      expect(widthInput).toHaveValue(150);\n      expect(heightInput).toHaveValue(150);\n    });\n\n    it('handles boundary values at maximum', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const widthInput = screen.getByLabelText('Width');\n      const heightInput = screen.getByLabelText('Height');\n\n      await user.clear(widthInput);\n      await user.type(widthInput, '1000');\n      fireEvent.blur(widthInput);\n\n      await user.clear(heightInput);\n      await user.type(heightInput, '1000');\n      fireEvent.blur(heightInput);\n\n      expect(widthInput).toHaveValue(1000);\n      expect(heightInput).toHaveValue(1000);\n    });\n\n    it('handles decimal input values', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const widthInput = screen.getByLabelText('Width');\n      await user.clear(widthInput);\n      await user.type(widthInput, '500.5');\n      fireEvent.blur(widthInput);\n\n      expect(widthInput).toBeInTheDocument();\n    });\n\n    it('handles empty input and resets to min', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const widthInput = screen.getByLabelText('Width');\n      await user.clear(widthInput);\n      fireEvent.blur(widthInput);\n\n      // Should reset to minimum value\n      expect(widthInput).toHaveValue(150);\n    });\n\n    it('handles rapid width and height changes', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const widthInput = screen.getByLabelText('Width');\n\n      await user.clear(widthInput);\n      await user.type(widthInput, '6');\n      await user.type(widthInput, '0');\n      await user.type(widthInput, '0');\n      fireEvent.blur(widthInput);\n\n      expect(onChange).toHaveBeenCalled();\n    });\n\n    it('clamps height at both boundaries', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<DisplaySize {...defaultProps} onChange={onChange} />);\n\n      const heightInput = screen.getByLabelText('Height');\n\n      // Test below min\n      await user.clear(heightInput);\n      await user.type(heightInput, '50');\n      fireEvent.blur(heightInput);\n      expect(heightInput).toHaveValue(150);\n\n      // Test above max\n      await user.clear(heightInput);\n      await user.type(heightInput, '2500');\n      fireEvent.blur(heightInput);\n      expect(heightInput).toHaveValue(1000);\n    });\n\n    it('displays custom label text', () => {\n      render(<DisplaySize size={{ width: 500, height: 400 }} label=\"Custom Size Settings\" onChange={jest.fn()} />);\n\n      expect(screen.getByText('Custom Size Settings')).toBeInTheDocument();\n    });\n\n    it('renders with variant outlined', () => {\n      const { container } = render(<DisplaySize {...defaultProps} />);\n\n      const inputs = container.querySelectorAll('input');\n      expect(inputs.length).toBe(2);\n    });\n  });\n\n  describe('SettingsRadioLabel', () => {\n    it('renders radio label', () => {\n      const onChange = jest.fn();\n      render(<SettingsRadioLabel label=\"Option 1\" value=\"option1\" checked={false} onChange={onChange} />);\n\n      expect(screen.getByText('Option 1')).toBeInTheDocument();\n      expect(screen.getByRole('radio')).toBeInTheDocument();\n    });\n\n    it('renders checked state', () => {\n      const onChange = jest.fn();\n      render(<SettingsRadioLabel label=\"Option 1\" value=\"option1\" checked={true} onChange={onChange} />);\n\n      const radio = screen.getByRole('radio');\n      expect(radio).toBeChecked();\n    });\n\n    it('renders unchecked state', () => {\n      const onChange = jest.fn();\n      render(<SettingsRadioLabel label=\"Option 1\" value=\"option1\" checked={false} onChange={onChange} />);\n\n      const radio = screen.getByRole('radio');\n      expect(radio).not.toBeChecked();\n    });\n\n    it('calls onChange when radio is clicked', async () => {\n      const user = userEvent.setup();\n      const onChange = jest.fn();\n      render(<SettingsRadioLabel label=\"Option 1\" value=\"option1\" checked={false} onChange={onChange} />);\n\n      const radio = screen.getByRole('radio');\n      await user.click(radio);\n\n      expect(onChange).toHaveBeenCalled();\n    });\n\n    it('displays label text correctly', () => {\n      const onChange = jest.fn();\n      const labelText = 'Custom Option Label';\n      render(<SettingsRadioLabel label={labelText} value=\"custom\" checked={false} onChange={onChange} />);\n\n      expect(screen.getByText(labelText)).toBeInTheDocument();\n    });\n  });\n\n  describe('Panel', () => {\n    const defaultProps = {\n      model: { toggleSetting: true, numberValue: 5 },\n      configuration: { configValue: 'test' },\n      groups: {\n        'General Settings': {\n          toggleSetting: {\n            type: 'toggle',\n            label: 'Enable Feature',\n          },\n        },\n      },\n      onChangeModel: jest.fn(),\n      onChangeConfiguration: jest.fn(),\n    };\n\n    beforeEach(() => {\n      jest.clearAllMocks();\n    });\n\n    it('renders panel with group label', () => {\n      render(<Panel {...defaultProps} />);\n      expect(screen.getByText('General Settings')).toBeInTheDocument();\n    });\n\n    it('renders empty when groups is undefined', () => {\n      const { container } = render(<Panel {...defaultProps} groups={undefined} />);\n      expect(container.firstChild.children.length).toBe(0);\n    });\n\n    it('renders empty when groups is empty', () => {\n      const { container } = render(<Panel {...defaultProps} groups={{}} />);\n      expect(container.firstChild.children.length).toBe(0);\n    });\n\n    it('calls onChangeModel when model changes', async () => {\n      const user = userEvent.setup();\n      const onChangeModel = jest.fn();\n      const { container } = render(<Panel {...defaultProps} onChangeModel={onChangeModel} />);\n\n      const switchElement = container.querySelector('input[type=\"checkbox\"]');\n      await user.click(switchElement);\n\n      expect(onChangeModel).toHaveBeenCalled();\n    });\n\n    it('calls onChangeConfiguration when configuration changes', async () => {\n      const user = userEvent.setup();\n      const onChangeConfiguration = jest.fn();\n      const { container } = render(\n        <Panel\n          {...defaultProps}\n          groups={{\n            'Config Group': {\n              configValue: {\n                type: 'toggle',\n                label: 'Config Toggle',\n                isConfigProperty: true,\n              },\n            },\n          }}\n          onChangeConfiguration={onChangeConfiguration}\n        />,\n      );\n\n      const switchElement = container.querySelector('input[type=\"checkbox\"]');\n      await user.click(switchElement);\n\n      expect(onChangeConfiguration).toHaveBeenCalled();\n    });\n\n    it('renders with modal when provided', () => {\n      const modal = <div data-testid=\"test-modal\">Modal Content</div>;\n      render(<Panel {...defaultProps} modal={modal} />);\n\n      expect(screen.getByTestId('test-modal')).toBeInTheDocument();\n      expect(screen.getByText('Modal Content')).toBeInTheDocument();\n    });\n\n    it('renders multiple groups', () => {\n      render(\n        <Panel\n          {...defaultProps}\n          groups={{\n            'Group One': {\n              setting1: {\n                type: 'toggle',\n                label: 'Setting One',\n              },\n            },\n            'Group Two': {\n              setting2: {\n                type: 'toggle',\n                label: 'Setting Two',\n              },\n            },\n          }}\n          model={{ setting1: true, setting2: false }}\n        />,\n      );\n\n      expect(screen.getByText('Group One')).toBeInTheDocument();\n      expect(screen.getByText('Group Two')).toBeInTheDocument();\n    });\n\n    it('uses default callbacks when not provided', () => {\n      const { container } = render(\n        <Panel\n          model={{ test: true }}\n          groups={{\n            'Test Group': {\n              test: { type: 'toggle', label: 'Test' },\n            },\n          }}\n        />,\n      );\n\n      expect(container.firstChild).toBeInTheDocument();\n    });\n\n    it('filters out empty groups', () => {\n      const { container } = render(\n        <Panel\n          {...defaultProps}\n          groups={{\n            'Empty Group': {},\n            'General Settings': {\n              toggleSetting: {\n                type: 'toggle',\n                label: 'Enable Feature',\n              },\n            },\n          }}\n          model={{ toggleSetting: true }}\n        />,\n      );\n\n      expect(screen.getByText('General Settings')).toBeInTheDocument();\n      expect(screen.queryByText('Empty Group')).not.toBeInTheDocument();\n    });\n\n    it('renders with null model', () => {\n      const { container } = render(\n        <Panel\n          model={null}\n          configuration={{}}\n          groups={{\n            'General Settings': {\n              toggleSetting: {\n                type: 'toggle',\n                label: 'Enable Feature',\n              },\n            },\n          }}\n          onChangeModel={jest.fn()}\n        />,\n      );\n\n      expect(screen.getByText('General Settings')).toBeInTheDocument();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}