@yamada-ui/utils 0.1.1 → 0.1.3

package/dist/array.d.mts

@@ -0,0 +1,3 @@
+declare const filterEmpty: <T extends any[]>(array: T) => any[];
+
+export { filterEmpty };

package/dist/assertion.d.mts

@@ -0,0 +1,16 @@
+import { Dict } from './index.types.mjs';
+
+declare const isNumber: (value: any) => value is number;
+declare const isNotNumber: (value: any) => boolean;
+declare const isNumeric: (value: any) => boolean;
+declare const isString: (value: any) => value is string;
+declare const isUndefined: (value: any) => value is undefined;
+declare const isNull: (value: any) => value is null;
+declare const isObject: <T extends Dict>(value: any) => value is T;
+declare const isArray: <T extends any[]>(value: any) => value is T;
+declare const isEmpty: (value: any) => boolean;
+declare const isFunction: <T extends Function = Function>(value: any) => value is T;
+declare const isUnit: (value: any) => boolean;
+declare const cast: <T>(value: any) => T;
+
+export { cast, isArray, isEmpty, isFunction, isNotNumber, isNull, isNumber, isNumeric, isObject, isString, isUndefined, isUnit };

package/dist/assertion.d.ts

@@ -6,7 +6,7 @@ declare const isNumeric: (value: any) => boolean;
 declare const isString: (value: any) => value is string;
 declare const isUndefined: (value: any) => value is undefined;
 declare const isNull: (value: any) => value is null;
-declare const isObject: <T extends Dict<any>>(value: any) => value is T;
+declare const isObject: <T extends Dict>(value: any) => value is T;
 declare const isArray: <T extends any[]>(value: any) => value is T;
 declare const isEmpty: (value: any) => boolean;
 declare const isFunction: <T extends Function = Function>(value: any) => value is T;

package/dist/calc.d.mts

@@ -0,0 +1,17 @@
+type Operand = string | number;
+type Calc = {
+    add: (...args: Operand[]) => Calc;
+    subtract: (...args: Operand[]) => Calc;
+    multiply: (...args: Operand[]) => Calc;
+    divide: (...args: Operand[]) => Calc;
+    negate: () => Calc;
+};
+declare const calc: ((x: Operand) => Calc) & {
+    add: (...args: Operand[]) => string;
+    subtract: (...args: Operand[]) => string;
+    multiply: (...args: Operand[]) => string;
+    divide: (...args: Operand[]) => string;
+    negate: (value: Operand) => string;
+};
+
+export { Operand, calc };

package/dist/{chunk-HUEOJZVC.mjs → chunk-UUOSA3BW.mjs}

@@ -118,6 +118,47 @@ var useUpdateEffect = (callback, deps) => {
     };
   }, []);
 };
+var useAsync = (func, deps = []) => {
+  const [state, callback] = useAsyncFunc(func, deps, { loading: true });
+  React.useEffect(() => {
+    callback();
+  }, [callback]);
+  return state;
+};
+var useAsyncFunc = (func, deps = [], initialState = { loading: false }) => {
+  const lastCallId = React.useRef(0);
+  const isMounted = useIsMounted();
+  const [state, setState] = React.useState(initialState);
+  const callback = React.useCallback((...args) => {
+    const callId = ++lastCallId.current;
+    if (!state.loading)
+      setState((prevState) => ({ ...prevState, loading: true }));
+    return func(...args).then(
+      (value) => {
+        if (isMounted.current && callId === lastCallId.current)
+          setState({ value, loading: false });
+        return value;
+      },
+      (error) => {
+        if (isMounted.current && callId === lastCallId.current)
+          setState({ error, loading: false });
+        return error;
+      }
+    );
+  }, deps);
+  return [state, callback];
+};
+var useAsyncRetry = (func, deps = []) => {
+  const [attempt, setAttempt] = React.useState(0);
+  const state = useAsync(func, [...deps, attempt]);
+  const stateLoading = state.loading;
+  const retry = React.useCallback(() => {
+    if (stateLoading)
+      return;
+    setAttempt((currentAttempt) => currentAttempt + 1);
+  }, [...deps, stateLoading]);
+  return { ...state, retry };
+};
 
 // src/color.ts
 import { toHex, parseToRgba, transparentize, mix, darken, lighten } from "color2k";
@@ -389,6 +430,9 @@ export {
   useMergeRefs,
   useCallbackRef,
   useUpdateEffect,
+  useAsync,
+  useAsyncFunc,
+  useAsyncRetry,
   getColor,
   lightenColor,
   darkenColor,

package/dist/color.d.mts

@@ -0,0 +1,18 @@
+import { Dict } from './index.types.mjs';
+
+declare const getColor: (color: string, fallback?: string) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const lightenColor: (color: string, amount: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const darkenColor: (color: string, amount: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const tintColor: (color: string, amount: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const shadeColor: (color: string, amount: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const transparentizeColor: (color: string, alpha: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const toneColor: (color: string, l: number) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => string;
+declare const randomColor: ({ string, colors }?: {
+    string?: string | undefined;
+    colors?: string[] | undefined;
+}) => string;
+declare const isTone: (color: string) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => "light" | "dark";
+declare const isLight: (color: string) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => boolean;
+declare const isDark: (color: string) => (theme: Dict, colorMode: 'light' | 'dark' | undefined) => boolean;
+
+export { darkenColor, getColor, isDark, isLight, isTone, lightenColor, randomColor, shadeColor, tintColor, toneColor, transparentizeColor };

package/dist/color.mjs

@@ -10,7 +10,7 @@ import {
   tintColor,
   toneColor,
   transparentizeColor
-} from "./chunk-HUEOJZVC.mjs";
+} from "./chunk-UUOSA3BW.mjs";
 import "./chunk-SLJ4M7XC.mjs";
 import "./chunk-VYMGBE25.mjs";
 import "./chunk-BZAW2D6U.mjs";

package/dist/dom.d.mts

@@ -0,0 +1,33 @@
+import React__default from 'react';
+
+declare const createdDom: () => boolean;
+declare const getPlatform: () => string;
+declare const vendor: (v: RegExp) => boolean;
+declare const platform: (v: RegExp) => boolean;
+declare const isMac: () => boolean;
+declare const isApple: () => boolean;
+declare const isSafari: () => boolean;
+declare const isElement: (el: any) => el is Element;
+declare const isHTMLElement: (el: any) => el is HTMLElement;
+declare const isHidden: (el: HTMLElement) => boolean;
+declare const isDisabled: (el: HTMLElement) => boolean;
+declare const hasTabIndex: (el: HTMLElement) => boolean;
+declare const isContentEditable: (el: HTMLElement) => boolean;
+declare const isContains: (parent: HTMLElement | null, child: HTMLElement | null) => boolean | undefined;
+declare const getEventRelatedTarget: (ev: React__default.FocusEvent | React__default.MouseEvent) => HTMLElement | null;
+type Booleanish = boolean | 'true' | 'false';
+declare const dataAttr: (condition: boolean | undefined) => Booleanish;
+declare const ariaAttr: (condition: boolean | undefined) => boolean | undefined;
+type FocusableElement = {
+    focus: (options?: FocusOptions) => void;
+};
+declare const getAllFocusable: <T extends HTMLElement>(container: T) => T[];
+declare const isFocusable: (el: HTMLElement) => boolean;
+declare const hasNegativeTabIndex: (el: HTMLElement) => boolean;
+declare const isTabbable: (el?: HTMLElement | null) => boolean;
+declare const getOwnerWindow: (node?: Element | null) => Window & typeof globalThis;
+declare const getOwnerDocument: (el?: Element | null) => Document;
+declare const getActiveElement: (el?: HTMLElement) => HTMLElement;
+declare const isActiveElement: (el: HTMLElement) => boolean;
+
+export { FocusableElement, ariaAttr, createdDom, dataAttr, getActiveElement, getAllFocusable, getEventRelatedTarget, getOwnerDocument, getOwnerWindow, getPlatform, hasNegativeTabIndex, hasTabIndex, isActiveElement, isApple, isContains, isContentEditable, isDisabled, isElement, isFocusable, isHTMLElement, isHidden, isMac, isSafari, isTabbable, platform, vendor };

package/dist/event.d.mts

@@ -0,0 +1,30 @@
+type AnyPointerEvent = MouseEvent | TouchEvent | PointerEvent;
+type PointType = 'page' | 'client';
+type Point = {
+    x: number;
+    y: number;
+};
+type PointerEventInfo = {
+    point: Point;
+};
+type MixedEventListener = (e: AnyPointerEvent, info: PointerEventInfo) => void;
+declare const isMouseEvent: (ev: any) => ev is MouseEvent;
+declare const isTouchEvent: (ev: AnyPointerEvent) => ev is TouchEvent;
+declare const isMultiTouchEvent: (ev: AnyPointerEvent) => boolean;
+declare const getEventWindow: (ev: Event) => typeof globalThis;
+declare const pointFromTouch: (e: TouchEvent, type?: PointType) => {
+    x: number;
+    y: number;
+};
+declare const pointFromMouse: (point: MouseEvent | PointerEvent, type?: PointType) => {
+    x: number;
+    y: number;
+};
+declare const getEventPoint: (ev: AnyPointerEvent, type?: PointType) => {
+    x: number;
+    y: number;
+};
+declare const addDomEvent: (target: EventTarget, type: string, cb: EventListener, options?: AddEventListenerOptions) => () => void;
+declare const addPointerEvent: (target: EventTarget, type: string, cb: MixedEventListener, options?: AddEventListenerOptions) => () => void;
+
+export { AnyPointerEvent, MixedEventListener, Point, PointType, PointerEventInfo, addDomEvent, addPointerEvent, getEventPoint, getEventWindow, isMouseEvent, isMultiTouchEvent, isTouchEvent, pointFromMouse, pointFromTouch };

package/dist/function.d.mts

@@ -0,0 +1,6 @@
+declare const noop: () => void;
+declare const runIfFunc: <T, U extends any[]>(valOrFunc: T | ((...funcArgs: U) => T), ...args: U) => T;
+declare const handlerAll: <T extends (event: any) => void>(...funcs: (T | undefined)[]) => (event: (T extends (...args: infer R) => any ? R : never)[0]) => void;
+declare const funcAll: <T extends (...args: any[]) => any>(...funcs: (T | undefined)[]) => (arg: (T extends (...args: infer R) => any ? R : never)[0]) => void;
+
+export { funcAll, handlerAll, noop, runIfFunc };

package/dist/function.mjs

@@ -3,7 +3,7 @@ import {
   handlerAll,
   noop,
   runIfFunc
-} from "./chunk-HUEOJZVC.mjs";
+} from "./chunk-UUOSA3BW.mjs";
 import "./chunk-SLJ4M7XC.mjs";
 import "./chunk-VYMGBE25.mjs";
 import "./chunk-BZAW2D6U.mjs";

package/dist/index.d.mts

@@ -0,0 +1,13 @@
+export { Dict, DynamicRecord, Length, Path, StringLiteral, Union } from './index.types.mjs';
+export { cast, isArray, isEmpty, isFunction, isNotNumber, isNull, isNumber, isNumeric, isObject, isString, isUndefined, isUnit } from './assertion.mjs';
+export { assignAfter, filterObject, filterUndefined, flattenObject, getMemoizedObject, getObject, keysFormObject, memoizeObject, merge, objectFromEntries, omitObject, pickObject, replaceObject, splitObject } from './object.mjs';
+export { funcAll, handlerAll, noop, runIfFunc } from './function.mjs';
+export { AsyncFnReturn, AsyncState, AsyncStateRetry, DOMAttributes, FunctionReturningPromise, MaybeRenderProp, PromiseType, PropGetter, RequiredPropGetter, assignRef, createContext, cx, findChildren, getValidChildren, includesChildren, isRefObject, isValidElement, mergeRefs, omitChildren, pickChildren, useAsync, useAsyncFunc, useAsyncRetry, useCallbackRef, useIsMounted, useMergeRefs, useSafeLayoutEffect, useUnmountEffect, useUpdateEffect } from './react.mjs';
+export { FocusableElement, ariaAttr, createdDom, dataAttr, getActiveElement, getAllFocusable, getEventRelatedTarget, getOwnerDocument, getOwnerWindow, getPlatform, hasNegativeTabIndex, hasTabIndex, isActiveElement, isApple, isContains, isContentEditable, isDisabled, isElement, isFocusable, isHTMLElement, isHidden, isMac, isSafari, isTabbable, platform, vendor } from './dom.mjs';
+export { escape } from './string.mjs';
+export { Operand, calc } from './calc.mjs';
+export { darkenColor, getColor, isDark, isLight, isTone, lightenColor, randomColor, shadeColor, tintColor, toneColor, transparentizeColor } from './color.mjs';
+export { filterEmpty } from './array.mjs';
+export { clampNumber, countDecimal, percentToValue, roundNumberToStep, toPrecision, valueToPercent } from './number.mjs';
+export { AnyPointerEvent, MixedEventListener, Point, PointType, PointerEventInfo, addDomEvent, addPointerEvent, getEventPoint, getEventWindow, isMouseEvent, isMultiTouchEvent, isTouchEvent, pointFromMouse, pointFromTouch } from './event.mjs';
+import 'react';

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export { Dict, DynamicRecord, Length, Path, StringLiteral, Union } from './index
 export { cast, isArray, isEmpty, isFunction, isNotNumber, isNull, isNumber, isNumeric, isObject, isString, isUndefined, isUnit } from './assertion.js';
 export { assignAfter, filterObject, filterUndefined, flattenObject, getMemoizedObject, getObject, keysFormObject, memoizeObject, merge, objectFromEntries, omitObject, pickObject, replaceObject, splitObject } from './object.js';
 export { funcAll, handlerAll, noop, runIfFunc } from './function.js';
-export { DOMAttributes, MaybeRenderProp, PropGetter, RequiredPropGetter, assignRef, createContext, cx, findChildren, getValidChildren, includesChildren, isRefObject, isValidElement, mergeRefs, omitChildren, pickChildren, useCallbackRef, useIsMounted, useMergeRefs, useSafeLayoutEffect, useUnmountEffect, useUpdateEffect } from './react.js';
+export { AsyncFnReturn, AsyncState, AsyncStateRetry, DOMAttributes, FunctionReturningPromise, MaybeRenderProp, PromiseType, PropGetter, RequiredPropGetter, assignRef, createContext, cx, findChildren, getValidChildren, includesChildren, isRefObject, isValidElement, mergeRefs, omitChildren, pickChildren, useAsync, useAsyncFunc, useAsyncRetry, useCallbackRef, useIsMounted, useMergeRefs, useSafeLayoutEffect, useUnmountEffect, useUpdateEffect } from './react.js';
 export { FocusableElement, ariaAttr, createdDom, dataAttr, getActiveElement, getAllFocusable, getEventRelatedTarget, getOwnerDocument, getOwnerWindow, getPlatform, hasNegativeTabIndex, hasTabIndex, isActiveElement, isApple, isContains, isContentEditable, isDisabled, isElement, isFocusable, isHTMLElement, isHidden, isMac, isSafari, isTabbable, platform, vendor } from './dom.js';
 export { escape } from './string.js';
 export { Operand, calc } from './calc.js';

package/dist/index.js

@@ -123,6 +123,9 @@ __export(src_exports, {
   toPrecision: () => toPrecision,
   toneColor: () => toneColor,
   transparentizeColor: () => transparentizeColor,
+  useAsync: () => useAsync,
+  useAsyncFunc: () => useAsyncFunc,
+  useAsyncRetry: () => useAsyncRetry,
   useCallbackRef: () => useCallbackRef,
   useIsMounted: () => useIsMounted,
   useMergeRefs: () => useMergeRefs,
@@ -392,6 +395,47 @@ var useUpdateEffect = (callback, deps) => {
     };
   }, []);
 };
+var useAsync = (func, deps = []) => {
+  const [state, callback] = useAsyncFunc(func, deps, { loading: true });
+  React.useEffect(() => {
+    callback();
+  }, [callback]);
+  return state;
+};
+var useAsyncFunc = (func, deps = [], initialState = { loading: false }) => {
+  const lastCallId = React.useRef(0);
+  const isMounted = useIsMounted();
+  const [state, setState] = React.useState(initialState);
+  const callback = React.useCallback((...args) => {
+    const callId = ++lastCallId.current;
+    if (!state.loading)
+      setState((prevState) => ({ ...prevState, loading: true }));
+    return func(...args).then(
+      (value) => {
+        if (isMounted.current && callId === lastCallId.current)
+          setState({ value, loading: false });
+        return value;
+      },
+      (error) => {
+        if (isMounted.current && callId === lastCallId.current)
+          setState({ error, loading: false });
+        return error;
+      }
+    );
+  }, deps);
+  return [state, callback];
+};
+var useAsyncRetry = (func, deps = []) => {
+  const [attempt, setAttempt] = React.useState(0);
+  const state = useAsync(func, [...deps, attempt]);
+  const stateLoading = state.loading;
+  const retry = React.useCallback(() => {
+    if (stateLoading)
+      return;
+    setAttempt((currentAttempt) => currentAttempt + 1);
+  }, [...deps, stateLoading]);
+  return { ...state, retry };
+};
 
 // src/dom.ts
 var createdDom = () => !!(typeof window !== "undefined" && window.document && window.document.createElement);
@@ -787,6 +831,9 @@ var addPointerEvent = (target, type, cb, options) => addDomEvent(target, type, w
   toPrecision,
   toneColor,
   transparentizeColor,
+  useAsync,
+  useAsyncFunc,
+  useAsyncRetry,
   useCallbackRef,
   useIsMounted,
   useMergeRefs,

package/dist/index.mjs

@@ -39,13 +39,16 @@ import {
   tintColor,
   toneColor,
   transparentizeColor,
+  useAsync,
+  useAsyncFunc,
+  useAsyncRetry,
   useCallbackRef,
   useIsMounted,
   useMergeRefs,
   useSafeLayoutEffect,
   useUnmountEffect,
   useUpdateEffect
-} from "./chunk-HUEOJZVC.mjs";
+} from "./chunk-UUOSA3BW.mjs";
 import "./chunk-SLJ4M7XC.mjs";
 import {
   clampNumber,
@@ -210,6 +213,9 @@ export {
   toPrecision,
   toneColor,
   transparentizeColor,
+  useAsync,
+  useAsyncFunc,
+  useAsyncRetry,
   useCallbackRef,
   useIsMounted,
   useMergeRefs,

package/dist/index.types.d.mts

@@ -0,0 +1,14 @@
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type PathImpl<K extends string | number | symbol, V> = K extends string | number ? V extends Primitive ? `${K}` : `${K}.${Path<V>}` : ``;
+type Path<T> = {
+    [K in keyof T]-?: PathImpl<K, T[K]>;
+}[keyof T];
+type Dict<T = any> = Record<string, T>;
+type StringLiteral = string & {};
+type Union<T> = T | StringLiteral;
+type Length = string | 0 | number;
+type DynamicRecord<T> = {
+    [K in keyof T]-?: T[K] extends Primitive ? string | number : DynamicRecord<T[K]>;
+};
+
+export { Dict, DynamicRecord, Length, Path, StringLiteral, Union };

package/dist/number.d.mts

@@ -0,0 +1,8 @@
+declare const toPrecision: (n: number, precision?: number) => string;
+declare const countDecimal: (n: number) => number;
+declare const roundNumberToStep: (n: number, from: number, step: number) => string;
+declare const valueToPercent: (n: number, min: number, max: number) => number;
+declare const percentToValue: (n: number, min: number, max: number) => number;
+declare const clampNumber: (n: number, min: number, max: number) => number;
+
+export { clampNumber, countDecimal, percentToValue, roundNumberToStep, toPrecision, valueToPercent };

package/dist/object.d.mts

@@ -0,0 +1,18 @@
+import { Dict } from './index.types.mjs';
+
+declare const omitObject: <T extends Dict, K extends keyof T>(obj: T, keys: K[]) => Omit<T, K>;
+declare const pickObject: <T extends Dict, K extends keyof T>(obj: T, keys: K[]) => { [P in K]: T[P]; };
+declare const splitObject: <T extends Dict, K extends keyof T>(obj: T, keys: K[]) => [{ [P in K]: T[P]; }, Omit<T, K>];
+declare const filterObject: <T extends Dict, K extends Dict>(obj: T, func: (key: keyof T, value: T[keyof T], obj: T) => boolean) => K;
+declare const filterUndefined: <T extends Dict>(obj: T) => T;
+declare const merge: <T extends Dict>(target: any, source: any, overrideArray?: boolean) => T;
+declare const flattenObject: <T extends Dict>(obj: any, maxDepth?: number) => T;
+declare const objectFromEntries: <T extends Dict>(entries: any[][]) => T;
+declare const keysFormObject: <T extends Dict>(obj: T) => (keyof T)[];
+declare const replaceObject: <T extends unknown>(objOrArray: T, callBack: (value: any) => any) => T;
+declare const getObject: (obj: Dict, path: string | number, fallback?: any, i?: number) => any;
+declare const memoizeObject: (func: typeof getObject) => (obj: Dict, path: string | number, fallback?: any, i?: number) => any;
+declare const getMemoizedObject: (obj: Dict, path: string | number, fallback?: any, i?: number) => any;
+declare const assignAfter: (target: Record<string, any>, ...sources: any[]) => Record<string, unknown>;
+
+export { assignAfter, filterObject, filterUndefined, flattenObject, getMemoizedObject, getObject, keysFormObject, memoizeObject, merge, objectFromEntries, omitObject, pickObject, replaceObject, splitObject };

package/dist/object.d.ts

@@ -1,14 +1,14 @@
 import { Dict } from './index.types.js';
 
-declare const omitObject: <T extends Dict<any>, K extends keyof T>(obj: T, keys: K[]) => Omit<T, K>;
-declare const pickObject: <T extends Dict<any>, K extends keyof T>(obj: T, keys: K[]) => { [P in K]: T[P]; };
-declare const splitObject: <T extends Dict<any>, K extends keyof T>(obj: T, keys: K[]) => [{ [P in K]: T[P]; }, Omit<T, K>];
-declare const filterObject: <T extends Dict<any>, K extends Dict<any>>(obj: T, func: (key: keyof T, value: T[keyof T], obj: T) => boolean) => K;
-declare const filterUndefined: <T extends Dict<any>>(obj: T) => T;
-declare const merge: <T extends Dict<any>>(target: any, source: any, overrideArray?: boolean) => T;
-declare const flattenObject: <T extends Dict<any>>(obj: any, maxDepth?: number) => T;
-declare const objectFromEntries: <T extends Dict<any>>(entries: any[][]) => T;
-declare const keysFormObject: <T extends Dict<any>>(obj: T) => (keyof T)[];
+declare const omitObject: <T extends Dict, K extends keyof T>(obj: T, keys: K[]) => Omit<T, K>;
+declare const pickObject: <T extends Dict, K extends keyof T>(obj: T, keys: K[]) => { [P in K]: T[P]; };
+declare const splitObject: <T extends Dict, K extends keyof T>(obj: T, keys: K[]) => [{ [P in K]: T[P]; }, Omit<T, K>];
+declare const filterObject: <T extends Dict, K extends Dict>(obj: T, func: (key: keyof T, value: T[keyof T], obj: T) => boolean) => K;
+declare const filterUndefined: <T extends Dict>(obj: T) => T;
+declare const merge: <T extends Dict>(target: any, source: any, overrideArray?: boolean) => T;
+declare const flattenObject: <T extends Dict>(obj: any, maxDepth?: number) => T;
+declare const objectFromEntries: <T extends Dict>(entries: any[][]) => T;
+declare const keysFormObject: <T extends Dict>(obj: T) => (keyof T)[];
 declare const replaceObject: <T extends unknown>(objOrArray: T, callBack: (value: any) => any) => T;
 declare const getObject: (obj: Dict, path: string | number, fallback?: any, i?: number) => any;
 declare const memoizeObject: (func: typeof getObject) => (obj: Dict, path: string | number, fallback?: any, i?: number) => any;

package/dist/object.mjs

@@ -13,7 +13,7 @@ import {
   pickObject,
   replaceObject,
   splitObject
-} from "./chunk-HUEOJZVC.mjs";
+} from "./chunk-UUOSA3BW.mjs";
 import "./chunk-SLJ4M7XC.mjs";
 import "./chunk-VYMGBE25.mjs";
 import "./chunk-BZAW2D6U.mjs";

package/dist/react.d.mts

@@ -0,0 +1,94 @@
+import * as React from 'react';
+
+type DOMElement = Element & HTMLOrSVGElement;
+type DataAttributes = {
+    [dataAttr: string]: any;
+};
+type DOMAttributes<Y = DOMElement> = React.AriaAttributes & React.DOMAttributes<Y> & DataAttributes & {
+    id?: string;
+    role?: React.AriaRole;
+    tabIndex?: number;
+    style?: React.CSSProperties;
+};
+type Merge<Y, M> = M extends Record<string, unknown> ? Y : Omit<Y, keyof M> & M;
+type PropGetter<Y = Record<string, unknown>, M = DOMAttributes> = (props?: Merge<DOMAttributes, Y>, ref?: React.Ref<any>) => M & React.RefAttributes<any>;
+type RequiredPropGetter<Y = Record<string, unknown>, M = DOMAttributes> = (props: Merge<DOMAttributes, Y>, ref?: React.Ref<any>) => M & React.RefAttributes<any>;
+type MaybeRenderProp<Y> = React.ReactNode | ((props: Y) => React.ReactNode);
+type Options = {
+    strict?: boolean;
+    errorMessage?: string;
+    name?: string;
+};
+type CreateContextReturn<T> = [React.Provider<T>, () => T, React.Context<T>];
+declare const createContext: <ContextType extends unknown = any>({ strict, errorMessage, name, }?: Options) => CreateContextReturn<ContextType>;
+declare const useSafeLayoutEffect: typeof React.useLayoutEffect;
+declare const useUnmountEffect: (callback: () => void) => void;
+declare const useIsMounted: () => React.MutableRefObject<boolean>;
+declare const getValidChildren: (children: React.ReactNode) => React.ReactElement[];
+declare const isValidElement: (child: any) => child is React.ReactNode;
+declare const findChildren: (children: React.ReactElement<any, string | React.JSXElementConstructor<any>>[], ...types: React.JSXElementConstructor<any>[]) => [React.ReactElement | undefined, ...React.ReactElement[]];
+declare const includesChildren: (children: React.ReactElement<any, string | React.JSXElementConstructor<any>>[], ...types: React.JSXElementConstructor<any>[]) => boolean;
+declare const omitChildren: (children: React.ReactElement<any, string | React.JSXElementConstructor<any>>[], ...types: React.JSXElementConstructor<any>[]) => React.ReactElement[];
+declare const pickChildren: (children: React.ReactElement<any, string | React.JSXElementConstructor<any>>[], ...types: React.JSXElementConstructor<any>[]) => React.ReactElement[];
+declare const cx: (...classNames: (string | undefined)[]) => string;
+type ReactRef<T> = React.Ref<T> | React.MutableRefObject<T>;
+declare const isRefObject: (val: any) => val is {
+    current: any;
+};
+declare const assignRef: <T extends unknown = any>(ref: ReactRef<T> | undefined, value: T) => void;
+declare const mergeRefs: <T extends unknown = any>(...refs: (ReactRef<T> | undefined)[]) => (node: T | null) => void;
+declare const useMergeRefs: <T extends unknown = any>(...refs: (ReactRef<T> | undefined)[]) => (node: T | null) => void;
+declare const useCallbackRef: <T extends (...args: any[]) => any>(callback: T | undefined, deps?: React.DependencyList) => T;
+declare const useUpdateEffect: (callback: React.EffectCallback, deps: React.DependencyList) => void;
+type FunctionReturningPromise = (...args: any[]) => Promise<any>;
+declare const useAsync: <T extends FunctionReturningPromise>(func: T, deps?: React.DependencyList) => StateFromFunctionReturningPromise<T>;
+type AsyncState<T> = {
+    loading: boolean;
+    error?: undefined;
+    value?: undefined;
+} | {
+    loading: true;
+    error?: Error | undefined;
+    value?: T;
+} | {
+    loading: false;
+    error: Error;
+    value?: undefined;
+} | {
+    loading: false;
+    error?: undefined;
+    value: T;
+};
+type PromiseType<P extends Promise<any>> = P extends Promise<infer T> ? T : never;
+type StateFromFunctionReturningPromise<T extends FunctionReturningPromise> = AsyncState<PromiseType<ReturnType<T>>>;
+type AsyncFnReturn<T extends FunctionReturningPromise = FunctionReturningPromise> = [
+    StateFromFunctionReturningPromise<T>,
+    T
+];
+declare const useAsyncFunc: <T extends FunctionReturningPromise>(func: T, deps?: React.DependencyList, initialState?: StateFromFunctionReturningPromise<T>) => AsyncFnReturn<T>;
+type AsyncStateRetry<T> = AsyncState<T> & {
+    retry(): void;
+};
+declare const useAsyncRetry: <T>(func: () => Promise<T>, deps?: React.DependencyList) => {
+    retry: () => void;
+    loading: boolean;
+    error?: undefined;
+    value?: undefined;
+} | {
+    retry: () => void;
+    loading: false;
+    error: Error;
+    value?: undefined;
+} | {
+    retry: () => void;
+    loading: true;
+    error?: Error | undefined;
+    value?: T | undefined;
+} | {
+    retry: () => void;
+    loading: false;
+    error?: undefined;
+    value: T;
+};
+
+export { AsyncFnReturn, AsyncState, AsyncStateRetry, DOMAttributes, FunctionReturningPromise, MaybeRenderProp, PromiseType, PropGetter, RequiredPropGetter, assignRef, createContext, cx, findChildren, getValidChildren, includesChildren, isRefObject, isValidElement, mergeRefs, omitChildren, pickChildren, useAsync, useAsyncFunc, useAsyncRetry, useCallbackRef, useIsMounted, useMergeRefs, useSafeLayoutEffect, useUnmountEffect, useUpdateEffect };

package/dist/react.d.ts

@@ -40,5 +40,55 @@ declare const mergeRefs: <T extends unknown = any>(...refs: (ReactRef<T> | undef
 declare const useMergeRefs: <T extends unknown = any>(...refs: (ReactRef<T> | undefined)[]) => (node: T | null) => void;
 declare const useCallbackRef: <T extends (...args: any[]) => any>(callback: T | undefined, deps?: React.DependencyList) => T;
 declare const useUpdateEffect: (callback: React.EffectCallback, deps: React.DependencyList) => void;
+type FunctionReturningPromise = (...args: any[]) => Promise<any>;
+declare const useAsync: <T extends FunctionReturningPromise>(func: T, deps?: React.DependencyList) => StateFromFunctionReturningPromise<T>;
+type AsyncState<T> = {
+    loading: boolean;
+    error?: undefined;
+    value?: undefined;
+} | {
+    loading: true;
+    error?: Error | undefined;
+    value?: T;
+} | {
+    loading: false;
+    error: Error;
+    value?: undefined;
+} | {
+    loading: false;
+    error?: undefined;
+    value: T;
+};
+type PromiseType<P extends Promise<any>> = P extends Promise<infer T> ? T : never;
+type StateFromFunctionReturningPromise<T extends FunctionReturningPromise> = AsyncState<PromiseType<ReturnType<T>>>;
+type AsyncFnReturn<T extends FunctionReturningPromise = FunctionReturningPromise> = [
+    StateFromFunctionReturningPromise<T>,
+    T
+];
+declare const useAsyncFunc: <T extends FunctionReturningPromise>(func: T, deps?: React.DependencyList, initialState?: StateFromFunctionReturningPromise<T>) => AsyncFnReturn<T>;
+type AsyncStateRetry<T> = AsyncState<T> & {
+    retry(): void;
+};
+declare const useAsyncRetry: <T>(func: () => Promise<T>, deps?: React.DependencyList) => {
+    retry: () => void;
+    loading: boolean;
+    error?: undefined;
+    value?: undefined;
+} | {
+    retry: () => void;
+    loading: false;
+    error: Error;
+    value?: undefined;
+} | {
+    retry: () => void;
+    loading: true;
+    error?: Error | undefined;
+    value?: T | undefined;
+} | {
+    retry: () => void;
+    loading: false;
+    error?: undefined;
+    value: T;
+};
 
-export { DOMAttributes, MaybeRenderProp, PropGetter, RequiredPropGetter, assignRef, createContext, cx, findChildren, getValidChildren, includesChildren, isRefObject, isValidElement, mergeRefs, omitChildren, pickChildren, useCallbackRef, useIsMounted, useMergeRefs, useSafeLayoutEffect, useUnmountEffect, useUpdateEffect };
+export { AsyncFnReturn, AsyncState, AsyncStateRetry, DOMAttributes, FunctionReturningPromise, MaybeRenderProp, PromiseType, PropGetter, RequiredPropGetter, assignRef, createContext, cx, findChildren, getValidChildren, includesChildren, isRefObject, isValidElement, mergeRefs, omitChildren, pickChildren, useAsync, useAsyncFunc, useAsyncRetry, useCallbackRef, useIsMounted, useMergeRefs, useSafeLayoutEffect, useUnmountEffect, useUpdateEffect };

package/dist/react.js

@@ -41,6 +41,9 @@ __export(react_exports, {
   mergeRefs: () => mergeRefs,
   omitChildren: () => omitChildren,
   pickChildren: () => pickChildren,
+  useAsync: () => useAsync,
+  useAsyncFunc: () => useAsyncFunc,
+  useAsyncRetry: () => useAsyncRetry,
   useCallbackRef: () => useCallbackRef,
   useIsMounted: () => useIsMounted,
   useMergeRefs: () => useMergeRefs,
@@ -154,6 +157,47 @@ var useUpdateEffect = (callback, deps) => {
     };
   }, []);
 };
+var useAsync = (func, deps = []) => {
+  const [state, callback] = useAsyncFunc(func, deps, { loading: true });
+  React.useEffect(() => {
+    callback();
+  }, [callback]);
+  return state;
+};
+var useAsyncFunc = (func, deps = [], initialState = { loading: false }) => {
+  const lastCallId = React.useRef(0);
+  const isMounted = useIsMounted();
+  const [state, setState] = React.useState(initialState);
+  const callback = React.useCallback((...args) => {
+    const callId = ++lastCallId.current;
+    if (!state.loading)
+      setState((prevState) => ({ ...prevState, loading: true }));
+    return func(...args).then(
+      (value) => {
+        if (isMounted.current && callId === lastCallId.current)
+          setState({ value, loading: false });
+        return value;
+      },
+      (error) => {
+        if (isMounted.current && callId === lastCallId.current)
+          setState({ error, loading: false });
+        return error;
+      }
+    );
+  }, deps);
+  return [state, callback];
+};
+var useAsyncRetry = (func, deps = []) => {
+  const [attempt, setAttempt] = React.useState(0);
+  const state = useAsync(func, [...deps, attempt]);
+  const stateLoading = state.loading;
+  const retry = React.useCallback(() => {
+    if (stateLoading)
+      return;
+    setAttempt((currentAttempt) => currentAttempt + 1);
+  }, [...deps, stateLoading]);
+  return { ...state, retry };
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   assignRef,
@@ -167,6 +211,9 @@ var useUpdateEffect = (callback, deps) => {
   mergeRefs,
   omitChildren,
   pickChildren,
+  useAsync,
+  useAsyncFunc,
+  useAsyncRetry,
   useCallbackRef,
   useIsMounted,
   useMergeRefs,

package/dist/react.mjs

@@ -10,13 +10,16 @@ import {
   mergeRefs,
   omitChildren,
   pickChildren,
+  useAsync,
+  useAsyncFunc,
+  useAsyncRetry,
   useCallbackRef,
   useIsMounted,
   useMergeRefs,
   useSafeLayoutEffect,
   useUnmountEffect,
   useUpdateEffect
-} from "./chunk-HUEOJZVC.mjs";
+} from "./chunk-UUOSA3BW.mjs";
 import "./chunk-SLJ4M7XC.mjs";
 import "./chunk-VYMGBE25.mjs";
 import "./chunk-BZAW2D6U.mjs";
@@ -37,6 +40,9 @@ export {
   mergeRefs,
   omitChildren,
   pickChildren,
+  useAsync,
+  useAsyncFunc,
+  useAsyncRetry,
   useCallbackRef,
   useIsMounted,
   useMergeRefs,

package/dist/string.d.mts

@@ -0,0 +1,3 @@
+declare const escape: (value: string, replaceValue?: string) => string;
+
+export { escape };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yamada-ui/utils",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Yamada UI utils",
   "keywords": [
     "utils",