@1money/react-ui 1.15.3 → 1.17.0

package/es/components/Space/Space.d.ts

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

package/es/components/Space/Space.js

@@ -0,0 +1,71 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo, Fragment, Children } from 'react';
+import classnames, { joinCls } from '../../utils/classnames';
+import { SPACE_CLASS, SPACE_CSS_VARS, SPACE_DIRECTION, SPACE_PREFIX, SPACE_SIZE_DEFAULT, SPACE_SIZE_MAP } from './constants';
+var resolveSize = function resolveSize(value) {
+  var _a;
+  if (value === undefined || value === null) return SPACE_SIZE_DEFAULT;
+  if (typeof value === 'number') return value;
+  return (_a = SPACE_SIZE_MAP[value]) !== null && _a !== void 0 ? _a : SPACE_SIZE_DEFAULT;
+};
+var normalizeSize = function normalizeSize(size) {
+  if (Array.isArray(size)) {
+    return [resolveSize(size[0]), resolveSize(size[1])];
+  }
+  var resolved = resolveSize(size);
+  return [resolved, resolved];
+};
+export var Space = function Space(props) {
+  var children = props.children,
+    align = props.align,
+    _props$direction = props.direction,
+    direction = _props$direction === void 0 ? SPACE_DIRECTION.horizontal : _props$direction,
+    size = props.size,
+    split = props.split,
+    _props$wrap = props.wrap,
+    wrap = _props$wrap === void 0 ? false : _props$wrap,
+    className = props.className,
+    style = props.style,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? SPACE_PREFIX : _props$prefixCls,
+    rest = __rest(props, ["children", "align", "direction", "size", "split", "wrap", "className", "style", "prefixCls"]);
+  var classes = classnames(prefixCls);
+  var isVertical = direction === SPACE_DIRECTION.vertical;
+  var _normalizeSize = normalizeSize(size),
+    _normalizeSize2 = _slicedToArray(_normalizeSize, 2),
+    gapX = _normalizeSize2[0],
+    gapY = _normalizeSize2[1];
+  var shouldWrap = wrap && !isVertical;
+  var classNameValue = classes(void 0, joinCls(isVertical && classes(SPACE_CLASS.vertical), align && classes("".concat(SPACE_CLASS.align, "-").concat(align)), shouldWrap && classes(SPACE_CLASS.wrap), className));
+  var mergedStyle = Object.assign(Object.assign({}, style), _defineProperty(_defineProperty({}, SPACE_CSS_VARS.gapX, "".concat(gapX, "px")), SPACE_CSS_VARS.gapY, "".concat(gapY, "px")));
+  var childrenArray = Children.toArray(children);
+  var content = childrenArray.map(function (child, index) {
+    var isLast = index === childrenArray.length - 1;
+    return _jsxs(Fragment, {
+      children: [_jsx("div", {
+        className: classes(SPACE_CLASS.item),
+        children: child
+      }), !isLast && split ? _jsx("span", {
+        className: classes(SPACE_CLASS.split),
+        children: split
+      }) : null]
+    }, "space-item-".concat(index));
+  });
+  return _jsx("div", Object.assign({}, rest, {
+    style: mergedStyle,
+    className: classNameValue,
+    children: content
+  }));
+};
+export default /*#__PURE__*/memo(Space);
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/Space/Space.js","components/src/components/Space/Space.tsx"],"names":["__rest","s","e","t","p","Object","prototype","hasOwnProperty","call","indexOf","getOwnPropertySymbols","i","length","propertyIsEnumerable","jsx","_jsx","jsxs","_jsxs","memo","Fragment","Children","classnames","joinCls","SPACE_CLASS","SPACE_CSS_VARS","SPACE_DIRECTION","SPACE_PREFIX","SPACE_SIZE_DEFAULT","SPACE_SIZE_MAP","resolveSize","value","_a","undefined","normalizeSize","size","Array","isArray","resolved","Space","props","children","align","_props$direction","direction","horizontal","split","_props$wrap","wrap","className","style","_props$prefixCls","prefixCls","rest","classes","isVertical","vertical","_normalizeSize","_normalizeSize2","_slicedToArray","gapX","gapY","shouldWrap","classNameValue","concat","mergedStyle","assign","_defineProperty","childrenArray","toArray","content","map","child","index","isLast","item"],"mappings":"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","file":"components/Space/Space.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, Fragment, Children } from 'react';\nimport classnames, { joinCls } from '../../utils/classnames';\nimport { SPACE_CLASS, SPACE_CSS_VARS, SPACE_DIRECTION, SPACE_PREFIX, SPACE_SIZE_DEFAULT, SPACE_SIZE_MAP } from './constants';\nconst resolveSize = (value) => {\n    var _a;\n    if (value === undefined || value === null)\n        return SPACE_SIZE_DEFAULT;\n    if (typeof value === 'number')\n        return value;\n    return (_a = SPACE_SIZE_MAP[value]) !== null && _a !== void 0 ? _a : SPACE_SIZE_DEFAULT;\n};\nconst normalizeSize = (size) => {\n    if (Array.isArray(size)) {\n        return [resolveSize(size[0]), resolveSize(size[1])];\n    }\n    const resolved = resolveSize(size);\n    return [resolved, resolved];\n};\nexport const Space = props => {\n    const { children, align, direction = SPACE_DIRECTION.horizontal, size, split, wrap = false, className, style, prefixCls = SPACE_PREFIX } = props, rest = __rest(props, [\"children\", \"align\", \"direction\", \"size\", \"split\", \"wrap\", \"className\", \"style\", \"prefixCls\"]);\n    const classes = classnames(prefixCls);\n    const isVertical = direction === SPACE_DIRECTION.vertical;\n    const [gapX, gapY] = normalizeSize(size);\n    const shouldWrap = wrap && !isVertical;\n    const classNameValue = classes(void 0, joinCls(isVertical && classes(SPACE_CLASS.vertical), align && classes(`${SPACE_CLASS.align}-${align}`), shouldWrap && classes(SPACE_CLASS.wrap), className));\n    const mergedStyle = Object.assign(Object.assign({}, style), { [SPACE_CSS_VARS.gapX]: `${gapX}px`, [SPACE_CSS_VARS.gapY]: `${gapY}px` });\n    const childrenArray = Children.toArray(children);\n    const content = childrenArray.map((child, index) => {\n        const isLast = index === childrenArray.length - 1;\n        return (_jsxs(Fragment, { children: [_jsx(\"div\", { className: classes(SPACE_CLASS.item), children: child }), !isLast && split ? (_jsx(\"span\", { className: classes(SPACE_CLASS.split), children: split })) : null] }, `space-item-${index}`));\n    });\n    return (_jsx(\"div\", Object.assign({}, rest, { style: mergedStyle, className: classNameValue, children: content })));\n};\nexport default memo(Space);",null],"sourceRoot":"../../../../../../../../../src"}

package/es/components/Space/constants.d.ts

@@ -0,0 +1,33 @@
+import type { SpaceSize } from './interface';
+export declare const SPACE_ALIGN: {
+    readonly start: "start";
+    readonly end: "end";
+    readonly center: "center";
+    readonly baseline: "baseline";
+};
+export declare const SPACE_DIRECTION: {
+    readonly horizontal: "horizontal";
+    readonly vertical: "vertical";
+};
+export declare const SPACE_SIZE: {
+    readonly small: "small";
+    readonly middle: "middle";
+    readonly large: "large";
+};
+export declare const SPACE_PREFIX = "space";
+export declare const SPACE_SIZE_SMALL = 8;
+export declare const SPACE_SIZE_MIDDLE = 16;
+export declare const SPACE_SIZE_LARGE = 24;
+export declare const SPACE_SIZE_DEFAULT = 8;
+export declare const SPACE_CSS_VARS: {
+    readonly gapX: "--om-space-gap-x";
+    readonly gapY: "--om-space-gap-y";
+};
+export declare const SPACE_CLASS: {
+    readonly vertical: "vertical";
+    readonly align: "align";
+    readonly wrap: "wrap";
+    readonly item: "item";
+    readonly split: "split";
+};
+export declare const SPACE_SIZE_MAP: Record<Exclude<SpaceSize, number>, number>;

package/es/components/Space/constants.js

@@ -0,0 +1,37 @@
+export var SPACE_ALIGN = {
+  start: 'start',
+  end: 'end',
+  center: 'center',
+  baseline: 'baseline'
+};
+export var SPACE_DIRECTION = {
+  horizontal: 'horizontal',
+  vertical: 'vertical'
+};
+export var SPACE_SIZE = {
+  small: 'small',
+  middle: 'middle',
+  large: 'large'
+};
+export var SPACE_PREFIX = 'space';
+export var SPACE_SIZE_SMALL = 8;
+export var SPACE_SIZE_MIDDLE = 16;
+export var SPACE_SIZE_LARGE = 24;
+export var SPACE_SIZE_DEFAULT = SPACE_SIZE_SMALL;
+export var SPACE_CSS_VARS = {
+  gapX: '--om-space-gap-x',
+  gapY: '--om-space-gap-y'
+};
+export var SPACE_CLASS = {
+  vertical: 'vertical',
+  align: 'align',
+  wrap: 'wrap',
+  item: 'item',
+  split: 'split'
+};
+export var SPACE_SIZE_MAP = {
+  small: SPACE_SIZE_SMALL,
+  middle: SPACE_SIZE_MIDDLE,
+  large: SPACE_SIZE_LARGE
+};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/Space/index.d.ts

@@ -0,0 +1,5 @@
+import Space from './Space';
+export { Space };
+export default Space;
+export * from './interface';
+export { SPACE_ALIGN, SPACE_DIRECTION, SPACE_SIZE } from './constants';

package/es/components/Space/index.js

@@ -0,0 +1,6 @@
+import Space from './Space';
+export { Space };
+export default Space;
+export * from './interface';
+export { SPACE_ALIGN, SPACE_DIRECTION, SPACE_SIZE } from './constants';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvU3BhY2UvaW5kZXgudHMiXSwibmFtZXMiOlsiU3BhY2UiLCJTUEFDRV9BTElHTiIsIlNQQUNFX0RJUkVDVElPTiIsIlNQQUNFX1NJWkUiXSwibWFwcGluZ3MiOiJBQUFBLE9BQU9BLEtBQUssTUFBTSxTQUFTO0FBRTNCLFNBQVNBLEtBQUs7QUFDZCxlQUFlQSxLQUFLO0FBQ3BCLGNBQWMsYUFBYTtBQUMzQixTQUFTQyxXQUFXLEVBQUVDLGVBQWUsRUFBRUMsVUFBVSxRQUFRLGFBQWEiLCJmaWxlIjoiY29tcG9uZW50cy9TcGFjZS9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbF0sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMifQ==

package/es/components/Space/interface.d.ts

@@ -0,0 +1,12 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export type SpaceAlign = 'start' | 'end' | 'center' | 'baseline';
+export type SpaceDirection = 'horizontal' | 'vertical';
+export type SpaceSize = 'small' | 'middle' | 'large' | number;
+export interface SpaceProps extends HTMLAttributes<HTMLDivElement> {
+    align?: SpaceAlign;
+    direction?: SpaceDirection;
+    size?: SpaceSize | [SpaceSize, SpaceSize];
+    split?: ReactNode;
+    wrap?: boolean;
+    prefixCls?: string;
+}

package/es/components/Space/interface.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50cy9TcGFjZS9pbnRlcmZhY2UuanMiLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMiLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvU3BhY2UvaW50ZXJmYWNlLmpzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7fTsiXSwibWFwcGluZ3MiOiJBQUFBIiwiaWdub3JlTGlzdCI6W119

package/es/components/Space/style/Space.css

@@ -0,0 +1 @@
+.om-react-ui-space{display:inline-flex;gap:var(--om-space-gap-y,8px) var(--om-space-gap-x,8px)}.om-react-ui-space-vertical{flex-direction:column}.om-react-ui-space-wrap{flex-wrap:wrap}.om-react-ui-space-align-start{align-items:flex-start}.om-react-ui-space-align-end{align-items:flex-end}.om-react-ui-space-align-center{align-items:center}.om-react-ui-space-align-baseline{align-items:baseline}.om-react-ui-space-item,.om-react-ui-space-split{display:inline-flex}

package/es/components/Space/style/Space.scss

@@ -0,0 +1,40 @@
+@use '../../../variable.scss' as *;
+
+$component: 'space';
+$space-gap-x: '--om-space-gap-x';
+$space-gap-y: '--om-space-gap-y';
+$space-gap-fallback: 8px;
+
+.#{$prefix}-#{$component} {
+  display: inline-flex;
+  gap: var(#{$space-gap-y}, #{$space-gap-fallback}) var(#{$space-gap-x}, #{$space-gap-fallback});
+
+  &-vertical {
+    flex-direction: column;
+  }
+
+  &-wrap {
+    flex-wrap: wrap;
+  }
+
+  &-align-start {
+    align-items: flex-start;
+  }
+
+  &-align-end {
+    align-items: flex-end;
+  }
+
+  &-align-center {
+    align-items: center;
+  }
+
+  &-align-baseline {
+    align-items: baseline;
+  }
+
+  &-item,
+  &-split {
+    display: inline-flex;
+  }
+}

package/es/components/Space/style/css.js

@@ -0,0 +1,2 @@
+import './Space.css';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvU3BhY2Uvc3JjL2NvbXBvbmVudHMvU3BhY2Uvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxjQUFjIiwiZmlsZSI6ImNvbXBvbmVudHMvU3BhY2Uvc3R5bGUvY3NzLmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/es/components/Space/style/index.d.ts

@@ -0,0 +1 @@
+import './Space.scss';

package/es/components/Space/style/index.js

@@ -0,0 +1,2 @@
+import './Space.scss';
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvU3BhY2Uvc3JjL2NvbXBvbmVudHMvU3BhY2Uvc3R5bGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxjQUFjIiwiZmlsZSI6ImNvbXBvbmVudHMvU3BhY2Uvc3R5bGUvaW5kZXguanMiLCJzb3VyY2VzQ29udGVudCI6W251bGxdLCJzb3VyY2VSb290IjoiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjIn0=

package/es/components/Switch/Switch.js

@@ -8,41 +8,44 @@ var __rest = this && this.__rest || function (s, e) {
   return t;
 };
 import { jsx as _jsx } from "react/jsx-runtime";
-import { memo, useMemo, useState } from 'react';
+import { memo } from 'react';
 import { InputSwitch } from 'primereact/inputswitch';
 import { ToggleButton } from 'primereact/togglebutton';
 import { default as classnames, joinCls } from '../../utils/classnames';
+import useControlledState from '../useControlledState';
+import useEventCallback from '../useEventCallback';
 export var Switch = function Switch(props) {
   var type = props.type,
-    defaultChecked = props.defaultChecked,
+    checkedProp = props.checked,
+    _props$defaultChecked = props.defaultChecked,
+    defaultChecked = _props$defaultChecked === void 0 ? false : _props$defaultChecked,
     className = props.className,
-    _onChange = props.onChange,
+    onChange = props.onChange,
     _props$prefixCls = props.prefixCls,
     prefixCls = _props$prefixCls === void 0 ? 'switch' : _props$prefixCls,
-    rest = __rest(props, ["type", "defaultChecked", "className", "onChange", "prefixCls"]);
+    rest = __rest(props, ["type", "checked", "defaultChecked", "className", "onChange", "prefixCls"]);
   var classes = classnames(prefixCls);
-  var _useState = useState(defaultChecked || false),
-    _useState2 = _slicedToArray(_useState, 2),
-    checked = _useState2[0],
-    setChecked = _useState2[1];
-  var SwitchComponent = useMemo(function () {
-    switch (type) {
-      case 'normal':
-        return InputSwitch;
-      case 'button':
-        return ToggleButton;
-      default:
-        return InputSwitch;
-    }
-  }, [type]);
-  return _jsx(SwitchComponent, Object.assign({}, rest, {
-    className: classes(void 0, joinCls(classes(type), className)),
+  var _useControlledState = useControlledState(defaultChecked, checkedProp),
+    _useControlledState2 = _slicedToArray(_useControlledState, 2),
+    checked = _useControlledState2[0],
+    setChecked = _useControlledState2[1];
+  var handleChange = useEventCallback(function (e) {
+    setChecked(e.value);
+    onChange === null || onChange === void 0 ? void 0 : onChange(e);
+  });
+  var cls = classes(undefined, joinCls(classes(type), className));
+  if (type === 'button') {
+    return _jsx(ToggleButton, Object.assign({}, rest, {
+      className: cls,
+      checked: checked,
+      onChange: handleChange
+    }));
+  }
+  return _jsx(InputSwitch, Object.assign({}, rest, {
+    className: cls,
     checked: checked,
-    onChange: function onChange(e) {
-      setChecked(e.value);
-      _onChange === null || _onChange === void 0 ? void 0 : _onChange(e);
-    }
+    onChange: handleChange
   }));
 };
 export default /*#__PURE__*/memo(Switch);
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/Switch/interface.d.ts

@@ -1,12 +1,17 @@
-import type { InputSwitchProps } from 'primereact/inputswitch';
-import type { ToggleButtonProps } from 'primereact/togglebutton';
+import type { InputSwitchChangeEvent, InputSwitchProps } from 'primereact/inputswitch';
+import type { ToggleButtonChangeEvent, ToggleButtonProps } from 'primereact/togglebutton';
+export type SwitchChangeEvent = InputSwitchChangeEvent | ToggleButtonChangeEvent;
+type OmitKeys = 'checked' | 'onChange';
 interface SwitchBaseProps {
     prefixCls?: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?(event: SwitchChangeEvent): void;
 }
-interface NormalSwitchProps extends Omit<InputSwitchProps, 'checked'>, SwitchBaseProps {
+interface NormalSwitchProps extends Omit<InputSwitchProps, OmitKeys>, SwitchBaseProps {
     type?: 'normal';
 }
-interface ButtonSwitchProps extends Omit<ToggleButtonProps, 'checked'>, SwitchBaseProps {
+interface ButtonSwitchProps extends Omit<ToggleButtonProps, OmitKeys>, SwitchBaseProps {
     type: 'button';
 }
 export type SwitchProps = NormalSwitchProps | ButtonSwitchProps;

package/es/components/useControlledState/index.d.ts

@@ -0,0 +1,14 @@
+type Updater<T> = (updater: T | ((origin: T) => T)) => void;
+/**
+ * Similar to `useState` but will use props value if provided.
+ * From React 18, we do not need safe `useState` since it will not throw for unmounted update.
+ * This hook removes the `onChange` & `postState` logic since we only need basic merged state logic.
+ *
+ * The `mergedValue` return already reflects the latest controlled `value` without
+ * the layout effect. The effect exists to sync `innerValue` for the edge case where
+ * the component starts in uncontrolled mode (calling `setInnerValue` directly) and
+ * then transitions to controlled mode (parent starts providing `value`). Without this
+ * sync, reverting back to uncontrolled mode would show the stale `innerValue`.
+ */
+export default function useControlledState<T>(defaultStateValue: T | (() => T), value?: T): [T, Updater<T>];
+export {};

package/es/components/useControlledState/index.js

@@ -0,0 +1,32 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useState } from 'react';
+import useLayoutEffect from '../useLayoutEffect';
+/**
+ * Similar to `useState` but will use props value if provided.
+ * From React 18, we do not need safe `useState` since it will not throw for unmounted update.
+ * This hook removes the `onChange` & `postState` logic since we only need basic merged state logic.
+ *
+ * The `mergedValue` return already reflects the latest controlled `value` without
+ * the layout effect. The effect exists to sync `innerValue` for the edge case where
+ * the component starts in uncontrolled mode (calling `setInnerValue` directly) and
+ * then transitions to controlled mode (parent starts providing `value`). Without this
+ * sync, reverting back to uncontrolled mode would show the stale `innerValue`.
+ */
+export default function useControlledState(defaultStateValue, value) {
+  var _useState = useState(defaultStateValue),
+    _useState2 = _slicedToArray(_useState, 2),
+    innerValue = _useState2[0],
+    setInnerValue = _useState2[1];
+  var mergedValue = value !== undefined ? value : innerValue;
+  useLayoutEffect(function (mount) {
+    if (!mount && value !== undefined) {
+      setInnerValue(value);
+    }
+  }, [value]);
+  return [
+  // Value
+  mergedValue,
+  // Update function
+  setInnerValue];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/useEventCallback/index.d.ts

@@ -0,0 +1,11 @@
+type Fn<T extends unknown[], R> = (...args: T) => R;
+/**
+ * A hook that returns a stable callback reference that always invokes
+ * the latest version of the provided function. Similar to the React
+ * useEvent RFC proposal.
+ *
+ * @param fn The function to wrap
+ * @returns A stable callback that always calls the latest fn
+ */
+export default function useEventCallback<T extends unknown[], R>(fn: Fn<T, R>): Fn<T, R>;
+export {};

package/es/components/useEventCallback/index.js

@@ -0,0 +1,17 @@
+import { useCallback } from 'react';
+import useLatest from '../useLatest';
+/**
+ * A hook that returns a stable callback reference that always invokes
+ * the latest version of the provided function. Similar to the React
+ * useEvent RFC proposal.
+ *
+ * @param fn The function to wrap
+ * @returns A stable callback that always calls the latest fn
+ */
+export default function useEventCallback(fn) {
+  var fnRef = useLatest(fn);
+  return useCallback(function () {
+    return fnRef.current.apply(fnRef, arguments);
+  }, []);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlRXZlbnRDYWxsYmFjay9pbmRleC50cyIsImNvbXBvbmVudHMvdXNlRXZlbnRDYWxsYmFjay9pbmRleC5qcyJdLCJuYW1lcyI6WyJ1c2VDYWxsYmFjayIsInVzZUxhdGVzdCIsInVzZUV2ZW50Q2FsbGJhY2siLCJmbiIsImZuUmVmIiwiY3VycmVudCIsImFwcGx5IiwiYXJndW1lbnRzIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxXQUFXLFFBQVEsT0FBTztBQUNuQyxPQUFPQyxTQUFTLE1BQU0sY0FBYztBQUlwQztBQ0ZBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FESUEsZUFBYyxTQUFVQyxnQkFBZ0JBLENBQXlCQyxFQUFZLEVBQUE7RUFDM0UsSUFBTUMsS0FBSyxHQUFHSCxTQUFTLENBQUNFLEVBQUUsQ0FBQztFQUUzQixPQUFPSCxXQUFXLENBQUMsWUFBZTtJQUNoQyxPQUFPSSxLQUFLLENBQUNDLE9BQU8sQ0FBQUMsS0FBQSxDQUFiRixLQUFLLEVBQUFHLFNBQWdCLENBQUM7RUFDL0IsQ0FBQyxFQUFFLEVBQUUsQ0FBQztBQUNSIiwiZmlsZSI6ImNvbXBvbmVudHMvdXNlRXZlbnRDYWxsYmFjay9pbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbbnVsbCwiaW1wb3J0IHsgdXNlQ2FsbGJhY2sgfSBmcm9tICdyZWFjdCc7XG5pbXBvcnQgdXNlTGF0ZXN0IGZyb20gJy4uL3VzZUxhdGVzdCc7XG4vKipcbiAqIEEgaG9vayB0aGF0IHJldHVybnMgYSBzdGFibGUgY2FsbGJhY2sgcmVmZXJlbmNlIHRoYXQgYWx3YXlzIGludm9rZXNcbiAqIHRoZSBsYXRlc3QgdmVyc2lvbiBvZiB0aGUgcHJvdmlkZWQgZnVuY3Rpb24uIFNpbWlsYXIgdG8gdGhlIFJlYWN0XG4gKiB1c2VFdmVudCBSRkMgcHJvcG9zYWwuXG4gKlxuICogQHBhcmFtIGZuIFRoZSBmdW5jdGlvbiB0byB3cmFwXG4gKiBAcmV0dXJucyBBIHN0YWJsZSBjYWxsYmFjayB0aGF0IGFsd2F5cyBjYWxscyB0aGUgbGF0ZXN0IGZuXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHVzZUV2ZW50Q2FsbGJhY2soZm4pIHtcbiAgICBjb25zdCBmblJlZiA9IHVzZUxhdGVzdChmbik7XG4gICAgcmV0dXJuIHVzZUNhbGxiYWNrKCguLi5hcmdzKSA9PiB7XG4gICAgICAgIHJldHVybiBmblJlZi5jdXJyZW50KC4uLmFyZ3MpO1xuICAgIH0sIFtdKTtcbn0iXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/es/components/useLayoutEffect/index.d.ts

@@ -0,0 +1,11 @@
+import { type DependencyList } from 'react';
+type EffectCallback = (mount: boolean) => void | (() => void);
+/**
+ * A custom `useLayoutEffect` that passes a boolean indicating whether
+ * it's the initial mount (`true`) or a subsequent update (`false`).
+ *
+ * @param effect The effect callback that receives a `mount` parameter
+ * @param deps The dependency array
+ */
+export default function useLayoutEffect(effect: EffectCallback, deps?: DependencyList): void;
+export {};

package/es/components/useLayoutEffect/index.js

@@ -0,0 +1,17 @@
+import { useLayoutEffect as reactUseLayoutEffect, useRef } from 'react';
+/**
+ * A custom `useLayoutEffect` that passes a boolean indicating whether
+ * it's the initial mount (`true`) or a subsequent update (`false`).
+ *
+ * @param effect The effect callback that receives a `mount` parameter
+ * @param deps The dependency array
+ */
+export default function useLayoutEffect(effect, deps) {
+  var isMounted = useRef(false);
+  reactUseLayoutEffect(function () {
+    var mount = !isMounted.current;
+    isMounted.current = true;
+    return effect(mount);
+  }, deps);
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvc3JjL2NvbXBvbmVudHMvdXNlTGF5b3V0RWZmZWN0L2luZGV4LnRzIiwiY29tcG9uZW50cy91c2VMYXlvdXRFZmZlY3QvaW5kZXguanMiXSwibmFtZXMiOlsidXNlTGF5b3V0RWZmZWN0IiwicmVhY3RVc2VMYXlvdXRFZmZlY3QiLCJ1c2VSZWYiLCJlZmZlY3QiLCJkZXBzIiwiaXNNb3VudGVkIiwibW91bnQiLCJjdXJyZW50Il0sIm1hcHBpbmdzIjoiQUFBQSxTQUNFQSxlQUFlLElBQUlDLG9CQUFvQixFQUN2Q0MsTUFBTSxRQUVELE9BQU87QUFJZDtBQ05BO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBRFFBLGVBQWMsU0FBVUYsZUFBZUEsQ0FBQ0csTUFBc0IsRUFBRUMsSUFBcUIsRUFBQTtFQUNuRixJQUFNQyxTQUFTLEdBQUdILE1BQU0sQ0FBQyxLQUFLLENBQUM7RUFFL0JELG9CQUFvQixDQUFDLFlBQUs7SUFDeEIsSUFBTUssS0FBSyxHQUFHLENBQUNELFNBQVMsQ0FBQ0UsT0FBTztJQUNoQ0YsU0FBUyxDQUFDRSxPQUFPLEdBQUcsSUFBSTtJQUN4QixPQUFPSixNQUFNLENBQUNHLEtBQUssQ0FBQztFQUN0QixDQUFDLEVBQUVGLElBQUksQ0FBQztBQUNWIiwiZmlsZSI6ImNvbXBvbmVudHMvdXNlTGF5b3V0RWZmZWN0L2luZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOltudWxsLCJpbXBvcnQgeyB1c2VMYXlvdXRFZmZlY3QgYXMgcmVhY3RVc2VMYXlvdXRFZmZlY3QsIHVzZVJlZiwgfSBmcm9tICdyZWFjdCc7XG4vKipcbiAqIEEgY3VzdG9tIGB1c2VMYXlvdXRFZmZlY3RgIHRoYXQgcGFzc2VzIGEgYm9vbGVhbiBpbmRpY2F0aW5nIHdoZXRoZXJcbiAqIGl0J3MgdGhlIGluaXRpYWwgbW91bnQgKGB0cnVlYCkgb3IgYSBzdWJzZXF1ZW50IHVwZGF0ZSAoYGZhbHNlYCkuXG4gKlxuICogQHBhcmFtIGVmZmVjdCBUaGUgZWZmZWN0IGNhbGxiYWNrIHRoYXQgcmVjZWl2ZXMgYSBgbW91bnRgIHBhcmFtZXRlclxuICogQHBhcmFtIGRlcHMgVGhlIGRlcGVuZGVuY3kgYXJyYXlcbiAqL1xuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdXNlTGF5b3V0RWZmZWN0KGVmZmVjdCwgZGVwcykge1xuICAgIGNvbnN0IGlzTW91bnRlZCA9IHVzZVJlZihmYWxzZSk7XG4gICAgcmVhY3RVc2VMYXlvdXRFZmZlY3QoKCkgPT4ge1xuICAgICAgICBjb25zdCBtb3VudCA9ICFpc01vdW50ZWQuY3VycmVudDtcbiAgICAgICAgaXNNb3VudGVkLmN1cnJlbnQgPSB0cnVlO1xuICAgICAgICByZXR1cm4gZWZmZWN0KG1vdW50KTtcbiAgICB9LCBkZXBzKTtcbn0iXSwic291cmNlUm9vdCI6Ii4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYyJ9

package/es/components/useLayoutState/index.d.ts

@@ -0,0 +1,13 @@
+export type Updater<State> = (prev: State) => State;
+/**
+ * Execute code before next frame but async.
+ *
+ * Batches multiple state updates into a single microtask (via `Promise.resolve`),
+ * reducing unnecessary re-renders when multiple updates happen synchronously.
+ *
+ * @param defaultState The initial state value
+ * @returns A tuple of `[state, setFrameState]`
+ */
+export default function useLayoutState<State>(defaultState: State): [State, (updater: Updater<State>) => void];
+/** Lock frame, when frame pass reset the lock. */
+export declare function useTimeoutLock<State>(defaultState?: State): [(state: State) => void, () => State | null];

package/es/components/useLayoutState/index.js

@@ -0,0 +1,71 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import { useRef, useState, useEffect, useCallback } from 'react';
+/**
+ * Execute code before next frame but async.
+ *
+ * Batches multiple state updates into a single microtask (via `Promise.resolve`),
+ * reducing unnecessary re-renders when multiple updates happen synchronously.
+ *
+ * @param defaultState The initial state value
+ * @returns A tuple of `[state, setFrameState]`
+ */
+export default function useLayoutState(defaultState) {
+  var stateRef = useRef(defaultState);
+  var _useState = useState({}),
+    _useState2 = _slicedToArray(_useState, 2),
+    forceUpdate = _useState2[1];
+  var lastPromiseRef = useRef(null);
+  var updateBatchRef = useRef([]);
+  var setFrameState = useCallback(function (updater) {
+    updateBatchRef.current.push(updater);
+    var promise = Promise.resolve();
+    lastPromiseRef.current = promise;
+    promise.then(function () {
+      if (lastPromiseRef.current === promise) {
+        var prevBatch = updateBatchRef.current;
+        var prevState = stateRef.current;
+        updateBatchRef.current = [];
+        prevBatch.forEach(function (batchUpdater) {
+          stateRef.current = batchUpdater(stateRef.current);
+        });
+        lastPromiseRef.current = null;
+        if (prevState !== stateRef.current) {
+          forceUpdate({});
+        }
+      }
+    });
+  }, []);
+  useEffect(function () {
+    return function () {
+      lastPromiseRef.current = null;
+    };
+  }, []);
+  return [stateRef.current, setFrameState];
+}
+/** Lock frame, when frame pass reset the lock. */
+export function useTimeoutLock(defaultState) {
+  var frameRef = useRef(defaultState !== null && defaultState !== void 0 ? defaultState : null);
+  var timeoutRef = useRef(null);
+  function cleanUp() {
+    if (timeoutRef.current != null) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }
+  function setState(newState) {
+    frameRef.current = newState;
+    cleanUp();
+    timeoutRef.current = setTimeout(function () {
+      frameRef.current = null;
+      timeoutRef.current = null;
+    }, 100);
+  }
+  function getState() {
+    return frameRef.current;
+  }
+  useEffect(function () {
+    return cleanUp;
+  }, []);
+  return [setState, getState];
+}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/useMemoizedFn/index.d.ts

@@ -0,0 +1,12 @@
+type Fn<T extends unknown[], R> = (...args: T) => R;
+/**
+ * A hook that returns a memoized version of a callback function.
+ * Unlike `useCallback`, it maintains referential equality across renders
+ * without requiring a dependency array, while always calling the latest
+ * version of the function.
+ *
+ * @param fn The function to memoize
+ * @returns A memoized function with stable reference
+ */
+export default function useMemoizedFn<T extends unknown[], R>(fn: Fn<T, R>): Fn<T, R>;
+export {};