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

package/lib/__tests__/alert-dialog.test.js

@@ -0,0 +1,267 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.array.slice.js");
+require("core-js/modules/es.regexp.constructor.js");
+require("core-js/modules/es.regexp.exec.js");
+require("core-js/modules/es.regexp.to-string.js");
+require("core-js/modules/es.string.repeat.js");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+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 _alertDialog = _interopRequireDefault(require("../alert-dialog"));
+describe('AlertDialog Component', function () {
+  var onClose = jest.fn();
+  var onConfirm = jest.fn();
+  beforeEach(function () {
+    onClose.mockClear();
+    onConfirm.mockClear();
+  });
+  describe('Rendering when open', function () {
+    it('should render dialog when open is true', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Confirm",
+        text: "Are you sure?",
+        onClose: onClose,
+        onConfirm: onConfirm
+      }));
+      expect(_react2.screen.getByText('Confirm')).toBeInTheDocument();
+      expect(_react2.screen.getByText('Are you sure?')).toBeInTheDocument();
+    });
+    it('should not render dialog when open is false', function () {
+      var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+          open: false,
+          title: "Confirm",
+          text: "Are you sure?",
+          onClose: onClose,
+          onConfirm: onConfirm
+        })),
+        container = _render.container;
+      var dialogs = container.querySelectorAll('[role="dialog"]');
+      expect(dialogs.length).toBe(0);
+    });
+  });
+  describe('Title and Text', function () {
+    it('should handle both title and text', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Important",
+        text: "This is an important message",
+        onClose: onClose,
+        onConfirm: onConfirm
+      }));
+      expect(_react2.screen.getByText('Important')).toBeInTheDocument();
+      expect(_react2.screen.getByText('This is an important message')).toBeInTheDocument();
+    });
+    it('should handle text as object', function () {
+      var textObj = /*#__PURE__*/_react["default"].createElement("div", null, "Rich text content");
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Rich Content",
+        text: textObj,
+        onClose: onClose,
+        onConfirm: onConfirm
+      }));
+      expect(_react2.screen.getByText('Rich text content')).toBeInTheDocument();
+    });
+  });
+  describe('Buttons', function () {
+    it('should render close button when onClose is provided', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Dialog",
+        text: "Content",
+        onClose: onClose,
+        onConfirm: onConfirm
+      }));
+      expect(_react2.screen.getByRole('button', {
+        name: 'CANCEL'
+      })).toBeInTheDocument();
+    });
+    it('should render confirm button when onConfirm is provided', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Dialog",
+        text: "Content",
+        onClose: onClose,
+        onConfirm: onConfirm
+      }));
+      expect(_react2.screen.getByRole('button', {
+        name: 'OK'
+      })).toBeInTheDocument();
+    });
+    it('should have default button text', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Dialog",
+        text: "Content",
+        onClose: onClose,
+        onConfirm: onConfirm
+      }));
+      expect(_react2.screen.getByRole('button', {
+        name: 'CANCEL'
+      })).toBeInTheDocument();
+      expect(_react2.screen.getByRole('button', {
+        name: 'OK'
+      })).toBeInTheDocument();
+    });
+  });
+  describe('User interactions', function () {
+    it('should call onClose when close button is clicked', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var user, closeButton;
+      return _regenerator["default"].wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+              open: true,
+              title: "Dialog",
+              text: "Content",
+              onClose: onClose,
+              onConfirm: onConfirm
+            }));
+            closeButton = _react2.screen.getByRole('button', {
+              name: 'CANCEL'
+            });
+            _context.next = 1;
+            return user.click(closeButton);
+          case 1:
+            expect(onClose).toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('should call onConfirm when confirm button is clicked', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      var user, confirmButton;
+      return _regenerator["default"].wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+              open: true,
+              title: "Dialog",
+              text: "Content",
+              onClose: onClose,
+              onConfirm: onConfirm
+            }));
+            confirmButton = _react2.screen.getByRole('button', {
+              name: 'OK'
+            });
+            _context2.next = 1;
+            return user.click(confirmButton);
+          case 1:
+            expect(onConfirm).toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+  });
+  describe('Focus management', function () {
+    it('should have autoFocus on confirm button by default', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Dialog",
+        text: "Content",
+        onClose: onClose,
+        onConfirm: onConfirm
+      }));
+      var confirmButton = _react2.screen.getByRole('button', {
+        name: 'OK'
+      });
+      expect(confirmButton).toBeInTheDocument();
+    });
+    it('should disable auto focus when disableAutoFocus is true', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Dialog",
+        text: "Content",
+        onClose: onClose,
+        onConfirm: onConfirm,
+        disableAutoFocus: true
+      }));
+      expect(_react2.screen.getByText('Dialog')).toBeInTheDocument();
+    });
+    it('should disable enforce focus when disableEnforceFocus is true', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Dialog",
+        text: "Content",
+        onClose: onClose,
+        onConfirm: onConfirm,
+        disableEnforceFocus: true
+      }));
+      expect(_react2.screen.getByText('Dialog')).toBeInTheDocument();
+    });
+    it('should disable restore focus when disableRestoreFocus is true', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Dialog",
+        text: "Content",
+        onClose: onClose,
+        onConfirm: onConfirm,
+        disableRestoreFocus: true
+      }));
+      expect(_react2.screen.getByText('Dialog')).toBeInTheDocument();
+    });
+  });
+  describe('Edge cases', function () {
+    it('should handle very long title', function () {
+      var longTitle = 'This is a very long title that should wrap properly in the dialog';
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: longTitle,
+        text: "Content",
+        onClose: onClose,
+        onConfirm: onConfirm
+      }));
+      expect(_react2.screen.getByText(longTitle)).toBeInTheDocument();
+    });
+    it('should handle very long text', function () {
+      var longText = 'This is a very long text that should wrap properly in the dialog. '.repeat(10);
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Dialog",
+        text: longText,
+        onClose: onClose,
+        onConfirm: onConfirm
+      }));
+      expect(_react2.screen.getByText(new RegExp(longText.slice(0, 50)))).toBeInTheDocument();
+    });
+    it('should handle only close callback', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Close Only",
+        text: "Content",
+        onClose: onClose
+      }));
+      expect(_react2.screen.getByRole('button', {
+        name: 'CANCEL'
+      })).toBeInTheDocument();
+      expect(_react2.screen.queryByRole('button', {
+        name: 'OK'
+      })).not.toBeInTheDocument();
+    });
+    it('should handle only confirm callback', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_alertDialog["default"], {
+        open: true,
+        title: "Confirm Only",
+        text: "Content",
+        onConfirm: onConfirm
+      }));
+      expect(_react2.screen.getByRole('button', {
+        name: 'OK'
+      })).toBeInTheDocument();
+      expect(_react2.screen.queryByRole('button', {
+        name: 'CANCEL'
+      })).not.toBeInTheDocument();
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_userEvent","_alertDialog","describe","onClose","jest","fn","onConfirm","beforeEach","mockClear","it","render","createElement","open","title","text","expect","screen","getByText","toBeInTheDocument","_render","container","dialogs","querySelectorAll","length","toBe","textObj","getByRole","name","_asyncToGenerator2","_regenerator","mark","_callee","user","closeButton","wrap","_context","prev","next","userEvent","setup","click","toHaveBeenCalled","stop","_callee2","confirmButton","_context2","disableAutoFocus","disableEnforceFocus","disableRestoreFocus","longTitle","longText","repeat","RegExp","slice","queryByRole","not"],"sources":["../../src/__tests__/alert-dialog.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render, screen } from '@testing-library/react';\nimport userEvent from '@testing-library/user-event';\nimport AlertDialog from '../alert-dialog';\n\ndescribe('AlertDialog Component', () => {\n  const onClose = jest.fn();\n  const onConfirm = jest.fn();\n\n  beforeEach(() => {\n    onClose.mockClear();\n    onConfirm.mockClear();\n  });\n\n  describe('Rendering when open', () => {\n    it('should render dialog when open is true', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Confirm\"\n          text=\"Are you sure?\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      expect(screen.getByText('Confirm')).toBeInTheDocument();\n      expect(screen.getByText('Are you sure?')).toBeInTheDocument();\n    });\n\n    it('should not render dialog when open is false', () => {\n      const { container } = render(\n        <AlertDialog\n          open={false}\n          title=\"Confirm\"\n          text=\"Are you sure?\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      const dialogs = container.querySelectorAll('[role=\"dialog\"]');\n      expect(dialogs.length).toBe(0);\n    });\n  });\n\n  describe('Title and Text', () => {\n    it('should handle both title and text', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Important\"\n          text=\"This is an important message\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      expect(screen.getByText('Important')).toBeInTheDocument();\n      expect(screen.getByText('This is an important message')).toBeInTheDocument();\n    });\n\n    it('should handle text as object', () => {\n      const textObj = <div>Rich text content</div>;\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Rich Content\"\n          text={textObj}\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      expect(screen.getByText('Rich text content')).toBeInTheDocument();\n    });\n  });\n\n  describe('Buttons', () => {\n    it('should render close button when onClose is provided', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Dialog\"\n          text=\"Content\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      expect(screen.getByRole('button', { name: 'CANCEL' })).toBeInTheDocument();\n    });\n\n    it('should render confirm button when onConfirm is provided', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Dialog\"\n          text=\"Content\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      expect(screen.getByRole('button', { name: 'OK' })).toBeInTheDocument();\n    });\n\n    it('should have default button text', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Dialog\"\n          text=\"Content\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      expect(screen.getByRole('button', { name: 'CANCEL' })).toBeInTheDocument();\n      expect(screen.getByRole('button', { name: 'OK' })).toBeInTheDocument();\n    });\n  });\n\n  describe('User interactions', () => {\n    it('should call onClose when close button is clicked', async () => {\n      const user = userEvent.setup();\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Dialog\"\n          text=\"Content\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      const closeButton = screen.getByRole('button', { name: 'CANCEL' });\n      await user.click(closeButton);\n\n      expect(onClose).toHaveBeenCalled();\n    });\n\n    it('should call onConfirm when confirm button is clicked', async () => {\n      const user = userEvent.setup();\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Dialog\"\n          text=\"Content\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      const confirmButton = screen.getByRole('button', { name: 'OK' });\n      await user.click(confirmButton);\n\n      expect(onConfirm).toHaveBeenCalled();\n    });\n  });\n\n  describe('Focus management', () => {\n    it('should have autoFocus on confirm button by default', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Dialog\"\n          text=\"Content\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      const confirmButton = screen.getByRole('button', { name: 'OK' });\n      expect(confirmButton).toBeInTheDocument();\n    });\n\n    it('should disable auto focus when disableAutoFocus is true', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Dialog\"\n          text=\"Content\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n          disableAutoFocus={true}\n        />,\n      );\n\n      expect(screen.getByText('Dialog')).toBeInTheDocument();\n    });\n\n    it('should disable enforce focus when disableEnforceFocus is true', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Dialog\"\n          text=\"Content\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n          disableEnforceFocus={true}\n        />,\n      );\n\n      expect(screen.getByText('Dialog')).toBeInTheDocument();\n    });\n\n    it('should disable restore focus when disableRestoreFocus is true', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Dialog\"\n          text=\"Content\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n          disableRestoreFocus={true}\n        />,\n      );\n\n      expect(screen.getByText('Dialog')).toBeInTheDocument();\n    });\n  });\n\n  describe('Edge cases', () => {\n    it('should handle very long title', () => {\n      const longTitle = 'This is a very long title that should wrap properly in the dialog';\n      render(\n        <AlertDialog\n          open={true}\n          title={longTitle}\n          text=\"Content\"\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      expect(screen.getByText(longTitle)).toBeInTheDocument();\n    });\n\n    it('should handle very long text', () => {\n      const longText = 'This is a very long text that should wrap properly in the dialog. '.repeat(10);\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Dialog\"\n          text={longText}\n          onClose={onClose}\n          onConfirm={onConfirm}\n        />,\n      );\n\n      expect(screen.getByText(new RegExp(longText.slice(0, 50)))).toBeInTheDocument();\n    });\n\n    it('should handle only close callback', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Close Only\"\n          text=\"Content\"\n          onClose={onClose}\n        />,\n      );\n\n      expect(screen.getByRole('button', { name: 'CANCEL' })).toBeInTheDocument();\n      expect(screen.queryByRole('button', { name: 'OK' })).not.toBeInTheDocument();\n    });\n\n    it('should handle only confirm callback', () => {\n      render(\n        <AlertDialog\n          open={true}\n          title=\"Confirm Only\"\n          text=\"Content\"\n          onConfirm={onConfirm}\n        />,\n      );\n\n      expect(screen.getByRole('button', { name: 'OK' })).toBeInTheDocument();\n      expect(screen.queryByRole('button', { name: 'CANCEL' })).not.toBeInTheDocument();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/__tests__/checkbox.test.js

@@ -0,0 +1,227 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+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 _checkbox = _interopRequireDefault(require("../checkbox"));
+describe('Checkbox Component', function () {
+  var onChange = jest.fn();
+  beforeEach(function () {
+    onChange.mockClear();
+  });
+  describe('Rendering', function () {
+    it('should render checkbox with label', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: false,
+        onChange: onChange,
+        label: "Accept terms"
+      }));
+      expect(_react2.screen.getByText('Accept terms')).toBeInTheDocument();
+      expect(_react2.screen.getByRole('checkbox')).toBeInTheDocument();
+    });
+    it('should render checkbox in checked state', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: true,
+        onChange: onChange,
+        label: "Accept terms"
+      }));
+      expect(_react2.screen.getByRole('checkbox')).toBeChecked();
+    });
+    it('should render checkbox in unchecked state', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: false,
+        onChange: onChange,
+        label: "Accept terms"
+      }));
+      expect(_react2.screen.getByRole('checkbox')).not.toBeChecked();
+    });
+    it('should render mini checkbox with reduced styling', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: false,
+        onChange: onChange,
+        label: "Mini",
+        mini: true
+      }));
+      expect(_react2.screen.getByRole('checkbox')).toBeInTheDocument();
+      expect(_react2.screen.getByText('Mini')).toBeInTheDocument();
+    });
+  });
+  describe('User interaction', function () {
+    it('should call onChange when checkbox is clicked', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+      var user, checkbox;
+      return _regenerator["default"].wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+              checked: false,
+              onChange: onChange,
+              label: "Accept"
+            }));
+            checkbox = _react2.screen.getByRole('checkbox');
+            _context.next = 1;
+            return user.click(checkbox);
+          case 1:
+            expect(onChange).toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('should call onChange when label is clicked', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+      var user, label;
+      return _regenerator["default"].wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+              checked: false,
+              onChange: onChange,
+              label: "Click label"
+            }));
+            label = _react2.screen.getByText('Click label');
+            _context2.next = 1;
+            return user.click(label);
+          case 1:
+            expect(onChange).toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+  });
+  describe('Props', function () {
+    it('should handle value prop', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: true,
+        onChange: onChange,
+        label: "With value",
+        value: "option1"
+      }));
+      expect(_react2.screen.getByRole('checkbox')).toBeInTheDocument();
+    });
+    it('should display error styling when error is true', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: false,
+        onChange: onChange,
+        label: "Error state",
+        error: true
+      }));
+      expect(_react2.screen.getByRole('checkbox')).toBeInTheDocument();
+      expect(_react2.screen.getByText('Error state')).toBeInTheDocument();
+    });
+  });
+  describe('Default props', function () {
+    it('should have mini default to false', function () {
+      var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+          checked: true,
+          onChange: onChange,
+          label: "Test"
+        })),
+        container = _render.container;
+      expect(_react2.screen.getByRole('checkbox')).toBeInTheDocument();
+    });
+    it('should have error default to false', function () {
+      var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+          checked: true,
+          onChange: onChange,
+          label: "Test"
+        })),
+        container = _render2.container;
+      expect(_react2.screen.getByRole('checkbox')).toBeInTheDocument();
+    });
+    it('should have value default to empty string', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: true,
+        onChange: onChange,
+        label: "Test"
+      }));
+      expect(_react2.screen.getByRole('checkbox')).toBeInTheDocument();
+    });
+  });
+  describe('Accessibility', function () {
+    it('should have proper label association', function () {
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: false,
+        onChange: onChange,
+        label: "Accessible label"
+      }));
+      expect(_react2.screen.getByLabelText('Accessible label')).toBeInTheDocument();
+    });
+    it('should be keyboard accessible', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+      var user, checkbox;
+      return _regenerator["default"].wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+              checked: false,
+              onChange: onChange,
+              label: "Keyboard test"
+            }));
+            checkbox = _react2.screen.getByRole('checkbox');
+            checkbox.focus();
+            expect(checkbox).toHaveFocus();
+            _context3.next = 1;
+            return user.keyboard(' ');
+          case 1:
+            expect(onChange).toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+  });
+  describe('Multiple checkboxes', function () {
+    it('should render multiple independent checkboxes', function () {
+      var onChange1 = jest.fn();
+      var onChange2 = jest.fn();
+      (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: true,
+        onChange: onChange1,
+        label: "Option 1"
+      }), /*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+        checked: false,
+        onChange: onChange2,
+        label: "Option 2"
+      })));
+      expect(_react2.screen.getByLabelText('Option 1')).toBeChecked();
+      expect(_react2.screen.getByLabelText('Option 2')).not.toBeChecked();
+    });
+    it('should handle independent onChange callbacks', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+      var user, onChange1, onChange2;
+      return _regenerator["default"].wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            user = _userEvent["default"].setup();
+            onChange1 = jest.fn();
+            onChange2 = jest.fn();
+            (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+              checked: true,
+              onChange: onChange1,
+              label: "Option 1"
+            }), /*#__PURE__*/_react["default"].createElement(_checkbox["default"], {
+              checked: false,
+              onChange: onChange2,
+              label: "Option 2"
+            })));
+            _context4.next = 1;
+            return user.click(_react2.screen.getByLabelText('Option 2'));
+          case 1:
+            expect(onChange2).toHaveBeenCalled();
+            expect(onChange1).not.toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    })));
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_userEvent","_checkbox","describe","onChange","jest","fn","beforeEach","mockClear","it","render","createElement","checked","label","expect","screen","getByText","toBeInTheDocument","getByRole","toBeChecked","not","mini","_asyncToGenerator2","_regenerator","mark","_callee","user","checkbox","wrap","_context","prev","next","userEvent","setup","click","toHaveBeenCalled","stop","_callee2","_context2","value","error","_render","container","_render2","getByLabelText","_callee3","_context3","focus","toHaveFocus","keyboard","onChange1","onChange2","Fragment","_callee4","_context4"],"sources":["../../src/__tests__/checkbox.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render, screen } from '@testing-library/react';\nimport userEvent from '@testing-library/user-event';\nimport Checkbox from '../checkbox';\n\ndescribe('Checkbox Component', () => {\n  const onChange = jest.fn();\n\n  beforeEach(() => {\n    onChange.mockClear();\n  });\n\n  describe('Rendering', () => {\n    it('should render checkbox with label', () => {\n      render(\n        <Checkbox \n          checked={false} \n          onChange={onChange} \n          label=\"Accept terms\" \n        />,\n      );\n\n      expect(screen.getByText('Accept terms')).toBeInTheDocument();\n      expect(screen.getByRole('checkbox')).toBeInTheDocument();\n    });\n\n    it('should render checkbox in checked state', () => {\n      render(\n        <Checkbox \n          checked={true} \n          onChange={onChange} \n          label=\"Accept terms\" \n        />,\n      );\n\n      expect(screen.getByRole('checkbox')).toBeChecked();\n    });\n\n    it('should render checkbox in unchecked state', () => {\n      render(\n        <Checkbox \n          checked={false} \n          onChange={onChange} \n          label=\"Accept terms\" \n        />,\n      );\n\n      expect(screen.getByRole('checkbox')).not.toBeChecked();\n    });\n\n    it('should render mini checkbox with reduced styling', () => {\n      render(\n        <Checkbox \n          checked={false} \n          onChange={onChange} \n          label=\"Mini\" \n          mini={true}\n        />,\n      );\n\n      expect(screen.getByRole('checkbox')).toBeInTheDocument();\n      expect(screen.getByText('Mini')).toBeInTheDocument();\n    });\n  });\n\n  describe('User interaction', () => {\n    it('should call onChange when checkbox is clicked', async () => {\n      const user = userEvent.setup();\n      render(\n        <Checkbox \n          checked={false} \n          onChange={onChange} \n          label=\"Accept\" \n        />,\n      );\n\n      const checkbox = screen.getByRole('checkbox');\n      await user.click(checkbox);\n\n      expect(onChange).toHaveBeenCalled();\n    });\n\n    it('should call onChange when label is clicked', async () => {\n      const user = userEvent.setup();\n      render(\n        <Checkbox \n          checked={false} \n          onChange={onChange} \n          label=\"Click label\" \n        />,\n      );\n\n      const label = screen.getByText('Click label');\n      await user.click(label);\n\n      expect(onChange).toHaveBeenCalled();\n    });\n  });\n\n  describe('Props', () => {\n    it('should handle value prop', () => {\n      render(\n        <Checkbox \n          checked={true} \n          onChange={onChange} \n          label=\"With value\"\n          value=\"option1\"\n        />,\n      );\n\n      expect(screen.getByRole('checkbox')).toBeInTheDocument();\n    });\n\n    it('should display error styling when error is true', () => {\n      render(\n        <Checkbox \n          checked={false} \n          onChange={onChange} \n          label=\"Error state\"\n          error={true}\n        />,\n      );\n\n      expect(screen.getByRole('checkbox')).toBeInTheDocument();\n      expect(screen.getByText('Error state')).toBeInTheDocument();\n    });\n  });\n\n  describe('Default props', () => {\n    it('should have mini default to false', () => {\n      const { container } = render(\n        <Checkbox \n          checked={true} \n          onChange={onChange} \n          label=\"Test\"\n        />,\n      );\n\n      expect(screen.getByRole('checkbox')).toBeInTheDocument();\n    });\n\n    it('should have error default to false', () => {\n      const { container } = render(\n        <Checkbox \n          checked={true} \n          onChange={onChange} \n          label=\"Test\"\n        />,\n      );\n\n      expect(screen.getByRole('checkbox')).toBeInTheDocument();\n    });\n\n    it('should have value default to empty string', () => {\n      render(\n        <Checkbox \n          checked={true} \n          onChange={onChange} \n          label=\"Test\"\n        />,\n      );\n\n      expect(screen.getByRole('checkbox')).toBeInTheDocument();\n    });\n  });\n\n  describe('Accessibility', () => {\n    it('should have proper label association', () => {\n      render(\n        <Checkbox \n          checked={false} \n          onChange={onChange} \n          label=\"Accessible label\"\n        />,\n      );\n\n      expect(screen.getByLabelText('Accessible label')).toBeInTheDocument();\n    });\n\n    it('should be keyboard accessible', async () => {\n      const user = userEvent.setup();\n      render(\n        <Checkbox \n          checked={false} \n          onChange={onChange} \n          label=\"Keyboard test\"\n        />,\n      );\n\n      const checkbox = screen.getByRole('checkbox');\n      checkbox.focus();\n      expect(checkbox).toHaveFocus();\n\n      await user.keyboard(' ');\n      expect(onChange).toHaveBeenCalled();\n    });\n  });\n\n  describe('Multiple checkboxes', () => {\n    it('should render multiple independent checkboxes', () => {\n      const onChange1 = jest.fn();\n      const onChange2 = jest.fn();\n\n      render(\n        <>\n          <Checkbox \n            checked={true} \n            onChange={onChange1} \n            label=\"Option 1\"\n          />\n          <Checkbox \n            checked={false} \n            onChange={onChange2} \n            label=\"Option 2\"\n          />\n        </>,\n      );\n\n      expect(screen.getByLabelText('Option 1')).toBeChecked();\n      expect(screen.getByLabelText('Option 2')).not.toBeChecked();\n    });\n\n    it('should handle independent onChange callbacks', async () => {\n      const user = userEvent.setup();\n      const onChange1 = jest.fn();\n      const onChange2 = jest.fn();\n\n      render(\n        <>\n          <Checkbox \n            checked={true} \n            onChange={onChange1} \n            label=\"Option 1\"\n          />\n          <Checkbox \n            checked={false} \n            onChange={onChange2} \n            label=\"Option 2\"\n          />\n        </>,\n      );\n\n      await user.click(screen.getByLabelText('Option 2'));\n\n      expect(onChange2).toHaveBeenCalled();\n      expect(onChange1).not.toHaveBeenCalled();\n    });\n  });\n});\n"],"mappings":";;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,UAAA,GAAAH,sBAAA,CAAAC,OAAA;AACA,IAAAG,SAAA,GAAAJ,sBAAA,CAAAC,OAAA;AAEAI,QAAQ,CAAC,oBAAoB,EAAE,YAAM;EACnC,IAAMC,QAAQ,GAAGC,IAAI,CAACC,EAAE,CAAC,CAAC;EAE1BC,UAAU,CAAC,YAAM;IACfH,QAAQ,CAACI,SAAS,CAAC,CAAC;EACtB,CAAC,CAAC;EAEFL,QAAQ,CAAC,WAAW,EAAE,YAAM;IAC1BM,EAAE,CAAC,mCAAmC,EAAE,YAAM;MAC5C,IAAAC,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;QACPU,OAAO,EAAE,KAAM;QACfR,QAAQ,EAAEA,QAAS;QACnBS,KAAK,EAAC;MAAc,CACrB,CACH,CAAC;MAEDC,MAAM,CAACC,cAAM,CAACC,SAAS,CAAC,cAAc,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;MAC5DH,MAAM,CAACC,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC,CAAC,CAACD,iBAAiB,CAAC,CAAC;IAC1D,CAAC,CAAC;IAEFR,EAAE,CAAC,yCAAyC,EAAE,YAAM;MAClD,IAAAC,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;QACPU,OAAO,EAAE,IAAK;QACdR,QAAQ,EAAEA,QAAS;QACnBS,KAAK,EAAC;MAAc,CACrB,CACH,CAAC;MAEDC,MAAM,CAACC,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC,CAAC,CAACC,WAAW,CAAC,CAAC;IACpD,CAAC,CAAC;IAEFV,EAAE,CAAC,2CAA2C,EAAE,YAAM;MACpD,IAAAC,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;QACPU,OAAO,EAAE,KAAM;QACfR,QAAQ,EAAEA,QAAS;QACnBS,KAAK,EAAC;MAAc,CACrB,CACH,CAAC;MAEDC,MAAM,CAACC,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC,CAAC,CAACE,GAAG,CAACD,WAAW,CAAC,CAAC;IACxD,CAAC,CAAC;IAEFV,EAAE,CAAC,kDAAkD,EAAE,YAAM;MAC3D,IAAAC,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;QACPU,OAAO,EAAE,KAAM;QACfR,QAAQ,EAAEA,QAAS;QACnBS,KAAK,EAAC,MAAM;QACZQ,IAAI,EAAE;MAAK,CACZ,CACH,CAAC;MAEDP,MAAM,CAACC,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC,CAAC,CAACD,iBAAiB,CAAC,CAAC;MACxDH,MAAM,CAACC,cAAM,CAACC,SAAS,CAAC,MAAM,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;IACtD,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFd,QAAQ,CAAC,kBAAkB,EAAE,YAAM;IACjCM,EAAE,CAAC,+CAA+C,mBAAAa,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAAC,QAAA;MAAA,IAAAC,IAAA,EAAAC,QAAA;MAAA,OAAAJ,YAAA,YAAAK,IAAA,WAAAC,QAAA;QAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;UAAA;YAC5CL,IAAI,GAAGM,qBAAS,CAACC,KAAK,CAAC,CAAC;YAC9B,IAAAvB,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;cACPU,OAAO,EAAE,KAAM;cACfR,QAAQ,EAAEA,QAAS;cACnBS,KAAK,EAAC;YAAQ,CACf,CACH,CAAC;YAEKc,QAAQ,GAAGZ,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC;YAAAW,QAAA,CAAAE,IAAA;YAAA,OACvCL,IAAI,CAACQ,KAAK,CAACP,QAAQ,CAAC;UAAA;YAE1Bb,MAAM,CAACV,QAAQ,CAAC,CAAC+B,gBAAgB,CAAC,CAAC;UAAC;UAAA;YAAA,OAAAN,QAAA,CAAAO,IAAA;QAAA;MAAA,GAAAX,OAAA;IAAA,CACrC,GAAC;IAEFhB,EAAE,CAAC,4CAA4C,mBAAAa,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAAa,SAAA;MAAA,IAAAX,IAAA,EAAAb,KAAA;MAAA,OAAAU,YAAA,YAAAK,IAAA,WAAAU,SAAA;QAAA,kBAAAA,SAAA,CAAAR,IAAA,GAAAQ,SAAA,CAAAP,IAAA;UAAA;YACzCL,IAAI,GAAGM,qBAAS,CAACC,KAAK,CAAC,CAAC;YAC9B,IAAAvB,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;cACPU,OAAO,EAAE,KAAM;cACfR,QAAQ,EAAEA,QAAS;cACnBS,KAAK,EAAC;YAAa,CACpB,CACH,CAAC;YAEKA,KAAK,GAAGE,cAAM,CAACC,SAAS,CAAC,aAAa,CAAC;YAAAsB,SAAA,CAAAP,IAAA;YAAA,OACvCL,IAAI,CAACQ,KAAK,CAACrB,KAAK,CAAC;UAAA;YAEvBC,MAAM,CAACV,QAAQ,CAAC,CAAC+B,gBAAgB,CAAC,CAAC;UAAC;UAAA;YAAA,OAAAG,SAAA,CAAAF,IAAA;QAAA;MAAA,GAAAC,QAAA;IAAA,CACrC,GAAC;EACJ,CAAC,CAAC;EAEFlC,QAAQ,CAAC,OAAO,EAAE,YAAM;IACtBM,EAAE,CAAC,0BAA0B,EAAE,YAAM;MACnC,IAAAC,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;QACPU,OAAO,EAAE,IAAK;QACdR,QAAQ,EAAEA,QAAS;QACnBS,KAAK,EAAC,YAAY;QAClB0B,KAAK,EAAC;MAAS,CAChB,CACH,CAAC;MAEDzB,MAAM,CAACC,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC,CAAC,CAACD,iBAAiB,CAAC,CAAC;IAC1D,CAAC,CAAC;IAEFR,EAAE,CAAC,iDAAiD,EAAE,YAAM;MAC1D,IAAAC,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;QACPU,OAAO,EAAE,KAAM;QACfR,QAAQ,EAAEA,QAAS;QACnBS,KAAK,EAAC,aAAa;QACnB2B,KAAK,EAAE;MAAK,CACb,CACH,CAAC;MAED1B,MAAM,CAACC,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC,CAAC,CAACD,iBAAiB,CAAC,CAAC;MACxDH,MAAM,CAACC,cAAM,CAACC,SAAS,CAAC,aAAa,CAAC,CAAC,CAACC,iBAAiB,CAAC,CAAC;IAC7D,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFd,QAAQ,CAAC,eAAe,EAAE,YAAM;IAC9BM,EAAE,CAAC,mCAAmC,EAAE,YAAM;MAC5C,IAAAgC,OAAA,GAAsB,IAAA/B,cAAM,eAC1Bb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;UACPU,OAAO,EAAE,IAAK;UACdR,QAAQ,EAAEA,QAAS;UACnBS,KAAK,EAAC;QAAM,CACb,CACH,CAAC;QANO6B,SAAS,GAAAD,OAAA,CAATC,SAAS;MAQjB5B,MAAM,CAACC,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC,CAAC,CAACD,iBAAiB,CAAC,CAAC;IAC1D,CAAC,CAAC;IAEFR,EAAE,CAAC,oCAAoC,EAAE,YAAM;MAC7C,IAAAkC,QAAA,GAAsB,IAAAjC,cAAM,eAC1Bb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;UACPU,OAAO,EAAE,IAAK;UACdR,QAAQ,EAAEA,QAAS;UACnBS,KAAK,EAAC;QAAM,CACb,CACH,CAAC;QANO6B,SAAS,GAAAC,QAAA,CAATD,SAAS;MAQjB5B,MAAM,CAACC,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC,CAAC,CAACD,iBAAiB,CAAC,CAAC;IAC1D,CAAC,CAAC;IAEFR,EAAE,CAAC,2CAA2C,EAAE,YAAM;MACpD,IAAAC,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;QACPU,OAAO,EAAE,IAAK;QACdR,QAAQ,EAAEA,QAAS;QACnBS,KAAK,EAAC;MAAM,CACb,CACH,CAAC;MAEDC,MAAM,CAACC,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC,CAAC,CAACD,iBAAiB,CAAC,CAAC;IAC1D,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFd,QAAQ,CAAC,eAAe,EAAE,YAAM;IAC9BM,EAAE,CAAC,sCAAsC,EAAE,YAAM;MAC/C,IAAAC,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;QACPU,OAAO,EAAE,KAAM;QACfR,QAAQ,EAAEA,QAAS;QACnBS,KAAK,EAAC;MAAkB,CACzB,CACH,CAAC;MAEDC,MAAM,CAACC,cAAM,CAAC6B,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC3B,iBAAiB,CAAC,CAAC;IACvE,CAAC,CAAC;IAEFR,EAAE,CAAC,+BAA+B,mBAAAa,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAAqB,SAAA;MAAA,IAAAnB,IAAA,EAAAC,QAAA;MAAA,OAAAJ,YAAA,YAAAK,IAAA,WAAAkB,SAAA;QAAA,kBAAAA,SAAA,CAAAhB,IAAA,GAAAgB,SAAA,CAAAf,IAAA;UAAA;YAC5BL,IAAI,GAAGM,qBAAS,CAACC,KAAK,CAAC,CAAC;YAC9B,IAAAvB,cAAM,eACJb,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;cACPU,OAAO,EAAE,KAAM;cACfR,QAAQ,EAAEA,QAAS;cACnBS,KAAK,EAAC;YAAe,CACtB,CACH,CAAC;YAEKc,QAAQ,GAAGZ,cAAM,CAACG,SAAS,CAAC,UAAU,CAAC;YAC7CS,QAAQ,CAACoB,KAAK,CAAC,CAAC;YAChBjC,MAAM,CAACa,QAAQ,CAAC,CAACqB,WAAW,CAAC,CAAC;YAACF,SAAA,CAAAf,IAAA;YAAA,OAEzBL,IAAI,CAACuB,QAAQ,CAAC,GAAG,CAAC;UAAA;YACxBnC,MAAM,CAACV,QAAQ,CAAC,CAAC+B,gBAAgB,CAAC,CAAC;UAAC;UAAA;YAAA,OAAAW,SAAA,CAAAV,IAAA;QAAA;MAAA,GAAAS,QAAA;IAAA,CACrC,GAAC;EACJ,CAAC,CAAC;EAEF1C,QAAQ,CAAC,qBAAqB,EAAE,YAAM;IACpCM,EAAE,CAAC,+CAA+C,EAAE,YAAM;MACxD,IAAMyC,SAAS,GAAG7C,IAAI,CAACC,EAAE,CAAC,CAAC;MAC3B,IAAM6C,SAAS,GAAG9C,IAAI,CAACC,EAAE,CAAC,CAAC;MAE3B,IAAAI,cAAM,eACJb,MAAA,YAAAc,aAAA,CAAAd,MAAA,YAAAuD,QAAA,qBACEvD,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;QACPU,OAAO,EAAE,IAAK;QACdR,QAAQ,EAAE8C,SAAU;QACpBrC,KAAK,EAAC;MAAU,CACjB,CAAC,eACFhB,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;QACPU,OAAO,EAAE,KAAM;QACfR,QAAQ,EAAE+C,SAAU;QACpBtC,KAAK,EAAC;MAAU,CACjB,CACD,CACJ,CAAC;MAEDC,MAAM,CAACC,cAAM,CAAC6B,cAAc,CAAC,UAAU,CAAC,CAAC,CAACzB,WAAW,CAAC,CAAC;MACvDL,MAAM,CAACC,cAAM,CAAC6B,cAAc,CAAC,UAAU,CAAC,CAAC,CAACxB,GAAG,CAACD,WAAW,CAAC,CAAC;IAC7D,CAAC,CAAC;IAEFV,EAAE,CAAC,8CAA8C,mBAAAa,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAA6B,SAAA;MAAA,IAAA3B,IAAA,EAAAwB,SAAA,EAAAC,SAAA;MAAA,OAAA5B,YAAA,YAAAK,IAAA,WAAA0B,SAAA;QAAA,kBAAAA,SAAA,CAAAxB,IAAA,GAAAwB,SAAA,CAAAvB,IAAA;UAAA;YAC3CL,IAAI,GAAGM,qBAAS,CAACC,KAAK,CAAC,CAAC;YACxBiB,SAAS,GAAG7C,IAAI,CAACC,EAAE,CAAC,CAAC;YACrB6C,SAAS,GAAG9C,IAAI,CAACC,EAAE,CAAC,CAAC;YAE3B,IAAAI,cAAM,eACJb,MAAA,YAAAc,aAAA,CAAAd,MAAA,YAAAuD,QAAA,qBACEvD,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;cACPU,OAAO,EAAE,IAAK;cACdR,QAAQ,EAAE8C,SAAU;cACpBrC,KAAK,EAAC;YAAU,CACjB,CAAC,eACFhB,MAAA,YAAAc,aAAA,CAACT,SAAA,WAAQ;cACPU,OAAO,EAAE,KAAM;cACfR,QAAQ,EAAE+C,SAAU;cACpBtC,KAAK,EAAC;YAAU,CACjB,CACD,CACJ,CAAC;YAACyC,SAAA,CAAAvB,IAAA;YAAA,OAEIL,IAAI,CAACQ,KAAK,CAACnB,cAAM,CAAC6B,cAAc,CAAC,UAAU,CAAC,CAAC;UAAA;YAEnD9B,MAAM,CAACqC,SAAS,CAAC,CAAChB,gBAAgB,CAAC,CAAC;YACpCrB,MAAM,CAACoC,SAAS,CAAC,CAAC9B,GAAG,CAACe,gBAAgB,CAAC,CAAC;UAAC;UAAA;YAAA,OAAAmB,SAAA,CAAAlB,IAAA;QAAA;MAAA,GAAAiB,QAAA;IAAA,CAC1C,GAAC;EACJ,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}

package/lib/__tests__/choice-utils.test.js

@@ -0,0 +1,16 @@
+"use strict";
+
+require("core-js/modules/es.array.concat.js");
+require("core-js/modules/es.array.join.js");
+var _choiceUtils = require("../choice-utils");
+describe('firstAvailableIndex', function () {
+  var assert = function assert(values, index, expected) {
+    it("[".concat(values.join(','), "], ").concat(index, " ==> ").concat(expected), function () {
+      expect((0, _choiceUtils.firstAvailableIndex)(['0'], 0)).toEqual('1');
+    });
+  };
+  assert(['0'], 0, '1');
+  assert(['0', '1', '2'], 0, '3');
+  assert(['0', '1', '2'], 100, '100');
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfY2hvaWNlVXRpbHMiLCJyZXF1aXJlIiwiZGVzY3JpYmUiLCJhc3NlcnQiLCJ2YWx1ZXMiLCJpbmRleCIsImV4cGVjdGVkIiwiaXQiLCJjb25jYXQiLCJqb2luIiwiZXhwZWN0IiwiZmlyc3RBdmFpbGFibGVJbmRleCIsInRvRXF1YWwiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvX190ZXN0c19fL2Nob2ljZS11dGlscy50ZXN0LmpzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGZpcnN0QXZhaWxhYmxlSW5kZXggfSBmcm9tICcuLi9jaG9pY2UtdXRpbHMnO1xuXG5kZXNjcmliZSgnZmlyc3RBdmFpbGFibGVJbmRleCcsICgpID0+IHtcbiAgY29uc3QgYXNzZXJ0ID0gKHZhbHVlcywgaW5kZXgsIGV4cGVjdGVkKSA9PiB7XG4gICAgaXQoYFske3ZhbHVlcy5qb2luKCcsJyl9XSwgJHtpbmRleH0gPT0+ICR7ZXhwZWN0ZWR9YCwgKCkgPT4ge1xuICAgICAgZXhwZWN0KGZpcnN0QXZhaWxhYmxlSW5kZXgoWycwJ10sIDApKS50b0VxdWFsKCcxJyk7XG4gICAgfSk7XG4gIH07XG4gIGFzc2VydChbJzAnXSwgMCwgJzEnKTtcbiAgYXNzZXJ0KFsnMCcsICcxJywgJzInXSwgMCwgJzMnKTtcbiAgYXNzZXJ0KFsnMCcsICcxJywgJzInXSwgMTAwLCAnMTAwJyk7XG59KTtcbiJdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLElBQUFBLFlBQUEsR0FBQUMsT0FBQTtBQUVBQyxRQUFRLENBQUMscUJBQXFCLEVBQUUsWUFBTTtFQUNwQyxJQUFNQyxNQUFNLEdBQUcsU0FBVEEsTUFBTUEsQ0FBSUMsTUFBTSxFQUFFQyxLQUFLLEVBQUVDLFFBQVEsRUFBSztJQUMxQ0MsRUFBRSxLQUFBQyxNQUFBLENBQUtKLE1BQU0sQ0FBQ0ssSUFBSSxDQUFDLEdBQUcsQ0FBQyxTQUFBRCxNQUFBLENBQU1ILEtBQUssV0FBQUcsTUFBQSxDQUFRRixRQUFRLEdBQUksWUFBTTtNQUMxREksTUFBTSxDQUFDLElBQUFDLGdDQUFtQixFQUFDLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQ0MsT0FBTyxDQUFDLEdBQUcsQ0FBQztJQUNwRCxDQUFDLENBQUM7RUFDSixDQUFDO0VBQ0RULE1BQU0sQ0FBQyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsRUFBRSxHQUFHLENBQUM7RUFDckJBLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEdBQUcsQ0FBQztFQUMvQkEsTUFBTSxDQUFDLENBQUMsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUMsRUFBRSxHQUFHLEVBQUUsS0FBSyxDQUFDO0FBQ3JDLENBQUMsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==