@1money/react-ui 1.16.0 → 1.17.1-alpha.0

package/AGENTS.md

@@ -102,3 +102,396 @@ import '@1money/react-ui/index.css';
 - Font assets (Aeonik, Inter, Outfit) are included in `public/fonts/`
 - Lottie animations are used in Loading component
 - Pre-commit hooks enforce code quality via husky and lint-staged
+
+## Commit Convention
+
+This project follows the [Conventional Commits](https://www.conventionalcommits.org/) specification.
+
+### Commit Message Format
+
+```
+<type>(<scope>): <subject>
+
+[optional body]
+
+[optional footer]
+```
+
+### Types
+
+| Type | Description |
+|------|-------------|
+| `feat` | New feature |
+| `fix` | Bug fix |
+| `docs` | Documentation changes only |
+| `style` | Code style changes (formatting, missing semicolons, etc.) — no logic change |
+| `refactor` | Code refactoring — no feature addition or bug fix |
+| `perf` | Performance improvements |
+| `test` | Adding or updating tests |
+| `chore` | Build process, tooling, or dependency changes |
+| `revert` | Revert a previous commit |
+| `ci` | CI/CD configuration changes |
+
+### Scope
+
+The scope should be the name of the component or module affected:
+
+```
+feat(Button): add loading state support
+fix(Input): correct placeholder color in dark mode
+docs(ProForm): update usage examples
+refactor(utils): simplify classnames helper
+```
+
+Omit scope when the change is global or cross-cutting:
+
+```
+chore: upgrade PrimeReact to v11
+ci: add lint check to PR workflow
+```
+
+### Subject Rules
+
+- ✅ Use imperative mood: "add feature" not "added feature" or "adds feature"
+- ✅ Start with a lowercase letter
+- ✅ No period at the end
+- ✅ Keep under 72 characters
+- ❌ Do not use vague messages like "fix bug", "update code", "WIP"
+
+### Examples
+
+```bash
+# ✅ Good
+feat(ProForm): add StepsForm component with validation support
+fix(Select): prevent dropdown from closing on internal scroll
+refactor(Button): extract size constants to avoid magic strings
+test(Input): add snapshot tests for controlled mode
+docs(README): add installation and usage guide
+chore: update pnpm lockfile after dependency upgrade
+
+# ❌ Bad
+fix bug
+update
+WIP
+feat: add stuff
+```
+
+### Breaking Changes
+
+Breaking changes must be noted in the footer with `BREAKING CHANGE:`:
+
+```
+feat(ProForm): change onSubmit callback signature
+
+BREAKING CHANGE: onSubmit now receives (values, form) instead of (values).
+Consumers must update their onSubmit handlers accordingly.
+```
+
+### Multi-line Body
+
+Use the body to explain *why* a change was made, not *what* was changed (the diff shows that):
+
+```
+fix(StepsForm): clear downstream step values on backward navigation
+
+When a user navigates backward in a multi-step form, previously entered
+values in later steps should be cleared to prevent stale data from
+being submitted. This matches the expected UX behavior.
+```
+
+## TypeScript Standards
+
+### Core Principles
+
+- ✅ All components and functions must provide accurate type definitions
+- ✅ Avoid using `any`; define types as precisely as possible
+- ✅ Use interfaces (`interface`) instead of type aliases (`type`) for object structures
+- ✅ Export all public interface types for easier consumer usage
+- ✅ Follow TypeScript type design principles strictly to ensure type safety
+- ✅ Ensure compilation has no type errors or warnings
+
+### Component Type Definitions
+
+```tsx
+// ✅ Correct: use interface to define Props
+interface ButtonProps {
+  type?: 'primary' | 'secondary' | 'warning';
+  onClick?: (e: React.MouseEvent) => void;
+}
+
+// ❌ Incorrect: avoid using type to define object structures
+type ButtonProps = {
+  type?: 'primary' | 'secondary';
+};
+
+// ✅ Correct: component Props interface naming
+interface ComponentNameProps {
+  // ...
+}
+
+// ✅ Correct: component state interface naming
+interface ComponentNameState {
+  // ...
+}
+
+// ✅ Correct: use ForwardRefRenderFunction to define ref
+const Component = React.forwardRef<ComponentRef, ComponentProps>((props, ref) => {
+  // ...
+});
+```
+
+### Type Usage Best Practices
+
+- ✅ Use generics where appropriate to improve type flexibility
+- ✅ Use intersection types (`&`) to combine multiple types
+- ✅ Use literal union types to define a limited set of options
+- ✅ Avoid `enum`; prefer union types and `as const`
+- ✅ Rely on TypeScript type inference as much as possible
+- ✅ Use type assertions (`as`) only when necessary
+
+```tsx
+// ✅ Recommended: use union types and as const
+const ButtonTypes = ['primary', 'secondary', 'warning'] as const;
+type ButtonType = (typeof ButtonTypes)[number];
+
+// ❌ Not recommended: use enum
+enum ButtonType {
+  Primary = 'primary',
+  Default = 'secondary',
+}
+```
+
+### Avoid Magic Strings
+
+- ✅ Define string constants or use `as const` arrays for repeated string values
+- ✅ Use constants for event names, action types, storage keys, and API endpoints
+- ✅ Extract hardcoded strings into named constants with descriptive names
+- ✅ Keep constants close to their usage or in a dedicated constants file
+
+```tsx
+// ✅ Correct: define constants
+const STORAGE_KEY = 'user_preferences';
+const EVENT_SUBMIT = 'submit';
+
+localStorage.setItem(STORAGE_KEY, value);
+element.addEventListener(EVENT_SUBMIT, handler);
+
+// ✅ Correct: use as const for related values
+const ToastTypes = ['success', 'error', 'warning', 'info'] as const;
+type ToastType = (typeof ToastTypes)[number];
+
+// ❌ Incorrect: magic strings scattered in code
+localStorage.setItem('user_preferences', value);
+element.addEventListener('submit', handler);
+if (status === 'success') { ... }
+```
+
+## Custom Hooks Usage Guide
+
+This library provides 11 custom hooks for common React patterns. Use these hooks to improve code quality and consistency.
+
+### useControlledState
+
+**When to use**: Building components that support both controlled and uncontrolled modes.
+
+```tsx
+// ✅ Use for form components that can be controlled or uncontrolled
+function Input({ value, defaultValue, onChange }: InputProps) {
+  const [innerValue, setInnerValue] = useControlledState(defaultValue ?? '', value);
+
+  const handleChange = (e: ChangeEvent<HTMLInputElement>) => {
+    setInnerValue(e.target.value);
+    onChange?.(e);
+  };
+
+  return <input value={innerValue} onChange={handleChange} />;
+}
+```
+
+### useEventCallback
+
+**When to use**: When you need a stable callback reference that always invokes the latest function version. Similar to React's `useEvent` RFC.
+
+```tsx
+// ✅ Use when passing callbacks to optimized child components
+function Parent() {
+  const [count, setCount] = useState(0);
+
+  // Stable reference, always calls latest function
+  const handleClick = useEventCallback(() => {
+    console.log('Current count:', count); // Always gets latest count
+  });
+
+  return <MemoizedChild onClick={handleClick} />;
+}
+```
+
+### useLatest
+
+**When to use**: When you need to access the latest value in callbacks without causing re-renders or stale closures.
+
+```tsx
+// ✅ Use to avoid stale closures in timers or event handlers
+function Timer({ delay, callback }: TimerProps) {
+  const callbackRef = useLatest(callback);
+
+  useEffect(() => {
+    const id = setInterval(() => {
+      callbackRef.current(); // Always calls the latest callback
+    }, delay);
+    return () => clearInterval(id);
+  }, [delay]); // No need to include callback in deps
+}
+```
+
+### useLayoutEffect
+
+**When to use**: When you need to know if the effect is running on initial mount or subsequent updates.
+
+```tsx
+// ✅ Use when behavior differs between mount and update
+function AnimatedComponent({ value }: Props) {
+  useLayoutEffect((mount) => {
+    if (mount) {
+      // Initial mount - setup without animation
+      element.style.opacity = '1';
+    } else {
+      // Update - animate the change
+      animateOpacity(element);
+    }
+  }, [value]);
+}
+```
+
+### useMemoizedFn
+
+**When to use**: When you need a stable function reference without managing a dependency array, while always calling the latest version.
+
+```tsx
+// ✅ Use for event handlers passed to child components
+function Form({ onSubmit }: FormProps) {
+  const [data, setData] = useState({});
+
+  // Stable reference, no deps needed, always uses latest data
+  const handleSubmit = useMemoizedFn(() => {
+    onSubmit(data);
+  });
+
+  return <ExpensiveChild onSubmit={handleSubmit} />;
+}
+```
+
+### usePrevious
+
+**When to use**: When you need to compare current value with the previous render's value.
+
+```tsx
+// ✅ Use for detecting value changes
+function Counter({ count }: Props) {
+  const prevCount = usePrevious(count);
+
+  useEffect(() => {
+    if (prevCount !== undefined && count > prevCount) {
+      console.log('Count increased!');
+    }
+  }, [count, prevCount]);
+}
+```
+
+### useSafeState
+
+**When to use**: When setting state in async callbacks where the component might unmount before completion.
+
+```tsx
+// ✅ Use for async operations to prevent memory leaks
+function AsyncComponent() {
+  const [data, setData] = useSafeState<Data | null>(null);
+
+  useEffect(() => {
+    fetchData().then((result) => {
+      setData(result); // Safe: won't update if unmounted
+    });
+  }, []);
+}
+```
+
+### useSyncState
+
+**When to use**: When React batches multiple state updates but you need to read the latest value synchronously.
+
+```tsx
+// ✅ Use when multiple events fire simultaneously (e.g., onTransitionEnd)
+function AnimatedList() {
+  const [getCompletedCount, setCompletedCount] = useSyncState(0);
+
+  const handleTransitionEnd = () => {
+    // Multiple transitions may end at once, React batches them
+    // getCompletedCount() always returns the latest value
+    setCompletedCount(getCompletedCount() + 1);
+  };
+}
+```
+
+### useUpdateEffect
+
+**When to use**: When you want an effect to run only on updates, skipping the initial mount.
+
+```tsx
+// ✅ Use when initial render shouldn't trigger the effect
+function SearchInput({ query, onSearch }: Props) {
+  useUpdateEffect(() => {
+    // Only runs when query changes, not on initial mount
+    onSearch(query);
+  }, [query]);
+}
+```
+
+### useLayoutState
+
+**When to use**: When you need to batch multiple synchronous state updates into a single microtask to reduce unnecessary re-renders. Updates are collected and applied together via `Promise.resolve`, triggering only one render.
+
+```tsx
+// ✅ Use when multiple state updates happen synchronously and should be batched
+function VirtualTable({ columns }: Props) {
+  const [colWidths, setColWidths] = useLayoutState<Map<string, number>>(new Map());
+
+  const handleResize = (key: string, width: number) => {
+    // Multiple columns may resize at once; updates are batched into one render
+    setColWidths(prev => new Map(prev).set(key, width));
+  };
+
+  return <ResizableColumns widths={colWidths} onResize={handleResize} />;
+}
+```
+
+### useTimeoutLock
+
+**When to use**: When you need a short-lived lock that auto-resets after a timeout (100ms). Useful for preventing duplicate actions or debouncing rapid state changes.
+
+```tsx
+// ✅ Use to prevent rapid duplicate submissions
+function SubmitButton() {
+  const [setLock, getLock] = useTimeoutLock<string>();
+
+  const handleClick = () => {
+    if (getLock()) return; // Already locked
+    setLock('submitting');
+    submitForm();
+  };
+}
+```
+
+### Hook Selection Guide
+
+| Scenario | Recommended Hook |
+|----------|------------------|
+| Controlled/uncontrolled component | `useControlledState` |
+| Stable callback for memoized children | `useEventCallback` or `useMemoizedFn` |
+| Access latest value without re-render | `useLatest` |
+| Different logic for mount vs update | `useLayoutEffect` |
+| Compare with previous value | `usePrevious` |
+| Async state updates after unmount | `useSafeState` |
+| Read latest state synchronously | `useSyncState` |
+| Skip effect on initial mount | `useUpdateEffect` |
+| Batch synchronous state updates | `useLayoutState` |
+| Short-lived lock with auto-reset | `useTimeoutLock` |

package/es/components/CheckboxGroup/CheckboxGroup.d.ts

@@ -1,5 +1,5 @@
-import type { FC, PropsWithChildren } from 'react';
+import type { FC } from 'react';
 import type { CheckboxGroupProps } from './interface';
-export declare const CheckboxGroup: FC<PropsWithChildren<CheckboxGroupProps>>;
-declare const _default: import("react").NamedExoticComponent<PropsWithChildren<CheckboxGroupProps>>;
+export declare const CheckboxGroup: FC<CheckboxGroupProps>;
+declare const _default: import("react").NamedExoticComponent<CheckboxGroupProps>;
 export default _default;

package/es/components/CheckboxGroup/CheckboxGroup.js

@@ -9,11 +9,14 @@ var __rest = this && this.__rest || function (s, e) {
   }
   return t;
 };
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { memo, useState, useMemo, useCallback } from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo, useMemo } from 'react';
 import { Checkbox as PrimeCheckbox } from 'primereact/checkbox';
 import { TriStateCheckbox } from 'primereact/tristatecheckbox';
 import { default as classnames, joinCls } from '../../utils/classnames';
+import useControlledState from '../useControlledState';
+import useMemoizedFn from '../useMemoizedFn';
+var TriStateCheckboxWithInputId = TriStateCheckbox;
 export var CheckboxGroup = function CheckboxGroup(props) {
   var tristate = props.tristate,
     _props$items = props.items,
@@ -29,104 +32,104 @@ export var CheckboxGroup = function CheckboxGroup(props) {
     size = _props$size === void 0 ? 'md' : _props$size;
   var classes = classnames(prefixCls);
   var sizeClass = "ckbg-".concat(size);
-  var CheckBoxComponent = useMemo(function () {
-    return tristate ? TriStateCheckbox : PrimeCheckbox;
-  }, [tristate]);
+  // Normal mode: controlled/uncontrolled string[] state
   var defaultChecked = useMemo(function () {
     return items.filter(function (item) {
-      return !!item.autoFocus;
+      return item.defaultChecked;
     }).map(function (v) {
       return v.key;
     });
   }, [items]);
-  var _useState = useState(defaultChecked),
-    _useState2 = _slicedToArray(_useState, 2),
-    checkedItems = _useState2[0],
-    setCheckedItems = _useState2[1];
-  var _useState3 = useState(Object.assign.apply(Object, [{}].concat(_toConsumableArray(items.map(function (v) {
+  var normalValue = tristate ? undefined : props.value;
+  var _useControlledState = useControlledState(normalValue !== null && normalValue !== void 0 ? normalValue : defaultChecked, normalValue),
+    _useControlledState2 = _slicedToArray(_useControlledState, 2),
+    checkedItems = _useControlledState2[0],
+    setCheckedItems = _useControlledState2[1];
+  // Tristate mode: controlled/uncontrolled Record<string, boolean | null> state
+  var defaultItemsState = useMemo(function () {
+    return Object.fromEntries(items.map(function (v) {
       var _a;
-      return _defineProperty({}, v.key, (_a = v.defaultValue) !== null && _a !== void 0 ? _a : null);
-    }))))),
-    _useState4 = _slicedToArray(_useState3, 2),
-    itemsState = _useState4[0],
-    setItemsState = _useState4[1];
-  var handleOnChange = useCallback(function (e) {
-    var _state;
-    if (tristate) {
-      _state = Object.assign({}, itemsState);
-      _state[e.target.id] = e.value;
-      setItemsState(_state);
-    } else {
-      _state = _toConsumableArray(checkedItems);
-      e.checked ? _state.push(e.value) : _state.splice(_state.indexOf(e.value), 1);
-      setCheckedItems(_state);
-    }
-    onChange === null || onChange === void 0 ? void 0 : onChange(_state);
-  }, [onChange, tristate, itemsState, checkedItems]);
+      return [v.key, (_a = 'defaultValue' in v ? v.defaultValue : null) !== null && _a !== void 0 ? _a : null];
+    }));
+  }, [items]);
+  var tristateValue = tristate ? props.value : undefined;
+  var _useControlledState3 = useControlledState(tristateValue !== null && tristateValue !== void 0 ? tristateValue : defaultItemsState, tristateValue),
+    _useControlledState4 = _slicedToArray(_useControlledState3, 2),
+    itemsState = _useControlledState4[0],
+    setItemsState = _useControlledState4[1];
+  var handleNormalChange = useMemoizedFn(function (e, itemOnChange) {
+    itemOnChange === null || itemOnChange === void 0 ? void 0 : itemOnChange(!!e.checked);
+    var next = e.checked ? [].concat(_toConsumableArray(checkedItems), [e.value]) : checkedItems.filter(function (k) {
+      return k !== e.value;
+    });
+    setCheckedItems(next);
+    onChange === null || onChange === void 0 ? void 0 : onChange(next);
+  });
+  var handleTristateChange = useMemoizedFn(function (e, itemOnChange) {
+    itemOnChange === null || itemOnChange === void 0 ? void 0 : itemOnChange(e.value);
+    var next = Object.assign(Object.assign({}, itemsState), _defineProperty({}, e.target.id, e.value));
+    setItemsState(next);
+    onChange === null || onChange === void 0 ? void 0 : onChange(next);
+  });
+  var renderItem = function renderItem(item) {
+    var _a;
+    var key = item.key,
+      required = item.required,
+      disabled = item.disabled,
+      label = item.label,
+      itemOnChange = item.onChange,
+      rest = __rest(item, ["key", "required", "disabled", "label", "onChange"]);
+    // Strip defaultValue from rest to avoid passing it to DOM
+    var _b = rest,
+      _ = _b.defaultValue,
+      __ = _b.defaultChecked,
+      checkboxRest = __rest(_b, ["defaultValue", "defaultChecked"]);
+    var innerClassName = classes('inner-checkbox', checkboxGroupCls);
+    var checkboxEl = tristate ? _jsx(TriStateCheckboxWithInputId, Object.assign({}, checkboxRest, {
+      id: key,
+      inputId: key,
+      value: (_a = itemsState[key]) !== null && _a !== void 0 ? _a : null,
+      required: required,
+      disabled: disabled,
+      className: innerClassName,
+      uncheckIcon: _jsx("i", {
+        className: "pi pi-minus"
+      }),
+      checkIcon: _jsx("i", {
+        className: "pi pi-check"
+      }),
+      onChange: function onChange(e) {
+        if (!disabled) handleTristateChange(e, itemOnChange);
+      }
+    })) : _jsx(PrimeCheckbox, Object.assign({}, checkboxRest, {
+      inputId: key,
+      value: key,
+      required: required,
+      disabled: disabled,
+      checked: checkedItems.includes(key),
+      className: innerClassName,
+      icon: _jsx("i", {
+        className: "pi pi-check"
+      }),
+      onChange: function onChange(e) {
+        if (!disabled) handleNormalChange(e, itemOnChange);
+      }
+    }));
+    return _jsx("div", {
+      className: joinCls(classes('inner', innerCls), sizeClass),
+      children: label ? _jsxs("label", {
+        htmlFor: key,
+        className: labelCls,
+        children: [checkboxEl, tristate ? _jsx("span", {
+          children: label
+        }) : label]
+      }) : checkboxEl
+    }, key);
+  };
   return _jsx("div", {
     className: classes('wrapper', wrapperCls),
-    children: items.map(function (item) {
-      var key = item.key,
-        required = item.required,
-        disabled = item.disabled,
-        _item$defaultValue = item.defaultValue,
-        defaultValue = _item$defaultValue === void 0 ? null : _item$defaultValue,
-        label = item.label,
-        _onChange = item.onChange,
-        rest = __rest(item, ["key", "required", "disabled", "defaultValue", "label", "onChange"]);
-      var _useState5 = useState(defaultValue),
-        _useState6 = _slicedToArray(_useState5, 2),
-        trivalue = _useState6[0],
-        setTrivalue = _useState6[1];
-      var handleLabelClick = useCallback(function () {
-        if (!tristate || disabled) return;
-        setTrivalue(function (curr) {
-          return curr === null ? true : curr === true ? false : null;
-        });
-      }, [tristate, disabled]);
-      var LabelWrapper = useCallback(function (_ref2) {
-        var children = _ref2.children;
-        if (!label) return children;
-        return _jsxs("label", {
-          className: labelCls,
-          onClick: handleLabelClick,
-          children: [children, label]
-        });
-      }, [label, labelCls, handleLabelClick]);
-      return _jsx("div", {
-        className: joinCls(classes('inner', innerCls), sizeClass),
-        children: _jsx(LabelWrapper, {
-          children: _jsx(CheckBoxComponent, Object.assign({}, rest, {
-            id: tristate ? key : void 0,
-            value: tristate ? trivalue : key,
-            required: required,
-            disabled: disabled,
-            checked: tristate ? void 0 : checkedItems.includes(key),
-            className: classes('inner-checkbox', checkboxGroupCls)
-          }, tristate ? {
-            uncheckIcon: _jsx("i", {
-              className: "pi pi-minus"
-            })
-          } : {}, tristate ? {
-            checkIcon: _jsx("i", {
-              className: "pi pi-check"
-            })
-          } : {
-            icon: _jsx("i", {
-              className: "pi pi-check"
-            })
-          }, {
-            onChange: function onChange(e) {
-              if (disabled) return;
-              tristate && setTrivalue(e.value);
-              _onChange === null || _onChange === void 0 ? void 0 : _onChange(tristate ? e.value : !!e.checked);
-              handleOnChange(e);
-            }
-          }))
-        })
-      }, key);
-    })
+    children: items.map(renderItem)
   });
 };
 export default /*#__PURE__*/memo(CheckboxGroup);
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/CheckboxGroup/CheckboxGroup.js","components/src/components/CheckboxGroup/CheckboxGroup.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsxs","_jsxs","jsx","_jsx","memo","useState","useMemo","useCallback","Checkbox","PrimeCheckbox","TriStateCheckbox","default","classnames","joinCls","CheckboxGroup","props","tristate","_props$items","items","onChange","wrapperCls","innerCls","checkboxGroupCls","labelCls","_props$prefixCls","prefixCls","_props$size","size","classes","sizeClass","concat","CheckBoxComponent","defaultChecked","filter","item","autoFocus","map","v","key","_useState","_useState2","_slicedToArray","checkedItems","setCheckedItems","_useState3","assign","apply","_toConsumableArray","_a","_defineProperty","defaultValue","_useState4","itemsState","setItemsState","handleOnChange","_state","target","id","value","checked","push","splice","className","children","required","disabled","_item$defaultValue","label","rest","_useState5","_useState6","trivalue","setTrivalue","handleLabelClick","curr","LabelWrapper","_ref2","onClick","includes","uncheckIcon","checkIcon","icon"],"mappings":"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","file":"components/CheckboxGroup/CheckboxGroup.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsxs as _jsxs, jsx as _jsx } from \"react/jsx-runtime\";\nimport { memo, useState, useMemo, useCallback } from 'react';\nimport { Checkbox as PrimeCheckbox } from 'primereact/checkbox';\nimport { TriStateCheckbox } from 'primereact/tristatecheckbox';\nimport { default as classnames, joinCls } from '../../utils/classnames';\nexport const CheckboxGroup = props => {\n    const { tristate, items = [], onChange, wrapperCls, innerCls, checkboxGroupCls, labelCls, prefixCls = 'checkboxgroup', size = 'md' } = props;\n    const classes = classnames(prefixCls);\n    const sizeClass = `ckbg-${size}`;\n    const CheckBoxComponent = useMemo(() => tristate ? TriStateCheckbox : PrimeCheckbox, [tristate]);\n    const defaultChecked = useMemo(() => items.filter(item => !!item.autoFocus).map(v => v.key), [items]);\n    const [checkedItems, setCheckedItems] = useState(defaultChecked);\n    const [itemsState, setItemsState] = useState(Object.assign({}, ...items.map(v => { var _a; return ({ [v.key]: (_a = v.defaultValue) !== null && _a !== void 0 ? _a : null }); })));\n    const handleOnChange = useCallback((e) => {\n        let _state;\n        if (tristate) {\n            _state = Object.assign({}, itemsState);\n            _state[e.target.id] = e.value;\n            setItemsState(_state);\n        }\n        else {\n            _state = [...checkedItems];\n            e.checked ? _state.push(e.value) : _state.splice(_state.indexOf(e.value), 1);\n            setCheckedItems(_state);\n        }\n        onChange === null || onChange === void 0 ? void 0 : onChange(_state);\n    }, [onChange, tristate, itemsState, checkedItems]);\n    return _jsx(\"div\", { className: classes('wrapper', wrapperCls), children: items.map(item => {\n            const { key, required, disabled, defaultValue = null, label, onChange } = item, rest = __rest(item, [\"key\", \"required\", \"disabled\", \"defaultValue\", \"label\", \"onChange\"]);\n            const [trivalue, setTrivalue] = useState(defaultValue);\n            const handleLabelClick = useCallback(() => {\n                if (!tristate || disabled)\n                    return;\n                setTrivalue(curr => curr === null ? true : curr === true ? false : null);\n            }, [tristate, disabled]);\n            const LabelWrapper = useCallback(({ children }) => {\n                if (!label)\n                    return children;\n                return _jsxs(\"label\", { className: labelCls, onClick: handleLabelClick, children: [children, label] });\n            }, [label, labelCls, handleLabelClick]);\n            return _jsx(\"div\", { className: joinCls(classes('inner', innerCls), sizeClass), children: _jsx(LabelWrapper, { children: _jsx(CheckBoxComponent, Object.assign({}, rest, { id: tristate ? key : void 0, value: tristate ? trivalue : key, required: required, disabled: disabled, checked: tristate ? void 0 : checkedItems.includes(key), className: classes('inner-checkbox', checkboxGroupCls) }, (tristate ? { uncheckIcon: _jsx(\"i\", { className: \"pi pi-minus\" }) } : {}), (tristate ? { checkIcon: _jsx(\"i\", { className: \"pi pi-check\" }) } : {\n                        icon: _jsx(\"i\", { className: \"pi pi-check\" })\n                    }), { onChange: e => {\n                            if (disabled)\n                                return;\n                            tristate && setTrivalue(e.value);\n                            onChange === null || onChange === void 0 ? void 0 : onChange(tristate ? e.value : !!e.checked);\n                            handleOnChange(e);\n                        } })) }) }, key);\n        }) });\n};\nexport default memo(CheckboxGroup);",null],"sourceRoot":"../../../../../../../../../src"}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/CheckboxGroup/CheckboxGroup.js","components/src/components/CheckboxGroup/CheckboxGroup.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","memo","useMemo","Checkbox","PrimeCheckbox","TriStateCheckbox","default","classnames","joinCls","useControlledState","useMemoizedFn","TriStateCheckboxWithInputId","CheckboxGroup","props","tristate","_props$items","items","onChange","wrapperCls","innerCls","checkboxGroupCls","labelCls","_props$prefixCls","prefixCls","_props$size","size","classes","sizeClass","concat","defaultChecked","filter","item","map","v","key","normalValue","undefined","value","_useControlledState","_useControlledState2","_slicedToArray","checkedItems","setCheckedItems","defaultItemsState","fromEntries","_a","defaultValue","tristateValue","_useControlledState3","_useControlledState4","itemsState","setItemsState","handleNormalChange","itemOnChange","checked","next","_toConsumableArray","k","handleTristateChange","assign","_defineProperty","target","id","renderItem","required","disabled","label","rest","_b","_","__","checkboxRest","innerClassName","checkboxEl","inputId","className","uncheckIcon","checkIcon","includes","icon","children","htmlFor"],"mappings":"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","file":"components/CheckboxGroup/CheckboxGroup.js","sourcesContent":["var __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { memo, useMemo } from 'react';\nimport { Checkbox as PrimeCheckbox } from 'primereact/checkbox';\nimport { TriStateCheckbox } from 'primereact/tristatecheckbox';\nimport { default as classnames, joinCls } from '../../utils/classnames';\nimport useControlledState from '../useControlledState';\nimport useMemoizedFn from '../useMemoizedFn';\nconst TriStateCheckboxWithInputId = TriStateCheckbox;\nexport const CheckboxGroup = props => {\n    const { tristate, items = [], onChange, wrapperCls, innerCls, checkboxGroupCls, labelCls, prefixCls = 'checkboxgroup', size = 'md' } = props;\n    const classes = classnames(prefixCls);\n    const sizeClass = `ckbg-${size}`;\n    // Normal mode: controlled/uncontrolled string[] state\n    const defaultChecked = useMemo(() => items.filter(item => item.defaultChecked).map(v => v.key), [items]);\n    const normalValue = tristate ? undefined : props.value;\n    const [checkedItems, setCheckedItems] = useControlledState(normalValue !== null && normalValue !== void 0 ? normalValue : defaultChecked, normalValue);\n    // Tristate mode: controlled/uncontrolled Record<string, boolean | null> state\n    const defaultItemsState = useMemo(() => Object.fromEntries(items.map(v => { var _a; return [v.key, (_a = ('defaultValue' in v ? v.defaultValue : null)) !== null && _a !== void 0 ? _a : null]; })), [items]);\n    const tristateValue = tristate ? props.value : undefined;\n    const [itemsState, setItemsState] = useControlledState(tristateValue !== null && tristateValue !== void 0 ? tristateValue : defaultItemsState, tristateValue);\n    const handleNormalChange = useMemoizedFn((e, itemOnChange) => {\n        itemOnChange === null || itemOnChange === void 0 ? void 0 : itemOnChange(!!e.checked);\n        const next = e.checked\n            ? [...checkedItems, e.value]\n            : checkedItems.filter(k => k !== e.value);\n        setCheckedItems(next);\n        onChange === null || onChange === void 0 ? void 0 : onChange(next);\n    });\n    const handleTristateChange = useMemoizedFn((e, itemOnChange) => {\n        itemOnChange === null || itemOnChange === void 0 ? void 0 : itemOnChange(e.value);\n        const next = Object.assign(Object.assign({}, itemsState), { [e.target.id]: e.value });\n        setItemsState(next);\n        onChange === null || onChange === void 0 ? void 0 : onChange(next);\n    });\n    const renderItem = (item) => {\n        var _a;\n        const { key, required, disabled, label, onChange: itemOnChange } = item, rest = __rest(item, [\"key\", \"required\", \"disabled\", \"label\", \"onChange\"]);\n        // Strip defaultValue from rest to avoid passing it to DOM\n        const _b = rest, { defaultValue: _, defaultChecked: __ } = _b, checkboxRest = __rest(_b, [\"defaultValue\", \"defaultChecked\"]);\n        const innerClassName = classes('inner-checkbox', checkboxGroupCls);\n        const checkboxEl = tristate\n            ? _jsx(TriStateCheckboxWithInputId, Object.assign({}, checkboxRest, { id: key, inputId: key, value: (_a = itemsState[key]) !== null && _a !== void 0 ? _a : null, required: required, disabled: disabled, className: innerClassName, uncheckIcon: _jsx(\"i\", { className: \"pi pi-minus\" }), checkIcon: _jsx(\"i\", { className: \"pi pi-check\" }), onChange: (e) => { if (!disabled)\n                    handleTristateChange(e, itemOnChange); } }))\n            : _jsx(PrimeCheckbox, Object.assign({}, checkboxRest, { inputId: key, value: key, required: required, disabled: disabled, checked: checkedItems.includes(key), className: innerClassName, icon: _jsx(\"i\", { className: \"pi pi-check\" }), onChange: (e) => { if (!disabled)\n                    handleNormalChange(e, itemOnChange); } }));\n        return (_jsx(\"div\", { className: joinCls(classes('inner', innerCls), sizeClass), children: label\n                ? _jsxs(\"label\", { htmlFor: key, className: labelCls, children: [checkboxEl, tristate ? _jsx(\"span\", { children: label }) : label] })\n                : checkboxEl }, key));\n    };\n    return (_jsx(\"div\", { className: classes('wrapper', wrapperCls), children: items.map(renderItem) }));\n};\nexport default memo(CheckboxGroup);",null],"sourceRoot":"../../../../../../../../../src"}