@ringcentral/spring-base 1.7.0

package/src/hooks/useHover/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useHover';
+export * from './useHoverDirty';

package/src/hooks/useHover/useHover.d.ts

@@ -0,0 +1,17 @@
+import { MouseEvent, MouseEventHandler } from 'react';
+export declare type UseHoverOptions<E = HTMLElement> = {
+    onMouseEnter?: MouseEventHandler<E>;
+    onMouseLeave?: MouseEventHandler<E>;
+    disabled?: boolean;
+    /**
+     * @default true
+     */
+    disableReactTree?: boolean;
+};
+export declare const useHover: <E = HTMLElement>({ onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, disabled, disableReactTree, }?: UseHoverOptions<E>) => {
+    hoverHandlers: {
+        onMouseEnter: (event: MouseEvent<E, globalThis.MouseEvent>) => void;
+        onMouseLeave: (event: MouseEvent<E, globalThis.MouseEvent>) => void;
+    };
+    hover: boolean;
+};

package/src/hooks/useHover/useHoverDirty.d.ts

@@ -0,0 +1,8 @@
+import { RefOrElementOrCallback } from '../../utils';
+export declare type UseHoverDirtyOptions = {
+    target: RefOrElementOrCallback | EventTarget | null | undefined;
+    disabled?: boolean;
+};
+export declare const useHoverDirty: ({ target, disabled, }: UseHoverDirtyOptions) => {
+    hover: boolean;
+};

package/src/hooks/useId/index.d.ts

@@ -0,0 +1 @@
+export * from './useId';

package/src/hooks/useId/useId.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Generates a unique ID.
+ *
+ * @param id - Default component id or prefix id.
+ * @param prefixMode Whether enable prefix the ID with.
+ * @returns unique ID
+ * @example
+ * useId() => 'spring-id-xxxx'
+ * useId('') => 'spring-id-xxxx'
+ * useId(null) => 'spring-id-xxxx'
+ * useId(undefined) => 'spring-id-xxxx'
+ * useId('nameId') => 'nameId'
+ * useId('nameId', true) => 'nameId-xxxx'
+ */
+export declare function useId(id?: string, prefixMode?: boolean): string;

package/src/hooks/useImgLoaded/index.d.ts

@@ -0,0 +1 @@
+export * from './useImgLoaded';

package/src/hooks/useImgLoaded/useImgLoaded.d.ts

@@ -0,0 +1,24 @@
+import { ComponentProps } from 'react';
+declare type UseImgLoadedProps = {
+    src?: string;
+    srcSet?: string;
+    crossOrigin?: ComponentProps<'img'>['crossOrigin'];
+    referrerPolicy?: ComponentProps<'img'>['referrerPolicy'];
+};
+declare type LoadedState = false | 'loaded' | 'error';
+/**
+ * get load state of an image by passing src or srcSet
+ * - false: not load yet
+ * - 'loaded': successfully loaded
+ * - 'error': fail to load
+ *
+ * @example
+ * ```ts
+ * const loaded = useImgLoaded({
+ *   src,
+ *   srcSet,
+ * });
+ * ```
+ */
+export declare const useImgLoaded: ({ crossOrigin, referrerPolicy, src, srcSet, }: UseImgLoadedProps) => LoadedState;
+export {};

package/src/hooks/useInterval/index.d.ts

@@ -0,0 +1 @@
+export * from './useInterval';

package/src/hooks/useInterval/useInterval.d.ts

@@ -0,0 +1,43 @@
+/**
+ * controllable interval, provide easy way to control interval
+ *
+ * - cancel: cancel current interval
+ * - pause: pause current interval
+ * - play: play current interval
+ * - getRunning: return current interval running state
+ *
+ *  @example
+ * ```ts
+ * const { cancel, play, pause } = useInterval(() => {
+ *    console.log('interval be triggered');
+ * }, 1000)
+ *
+ * // get current run times
+ * useInterval((times) => {
+ *    console.log('current times start from 1', times);
+ * }, 2000)
+ *
+ * // not start interval immediately
+ * useInterval((times) => {
+ *    console.log('current times start from 1', times);
+ * }, 2000, false)
+ * ```
+ */
+export declare const useInterval: (callback: (times: number) => void, delay?: number, startImmediately?: boolean) => {
+    /**
+     * cancel current interval
+     */
+    cancel: () => void;
+    /**
+     * pause current interval
+     */
+    pause: () => void;
+    /**
+     * play current interval
+     */
+    play: () => void;
+    /**
+     * return current interval running state
+     */
+    getRunning: () => boolean;
+};

package/src/hooks/useIsFocusVisible/index.d.ts

@@ -0,0 +1,2 @@
+export { default as useIsFocusVisible } from './useIsFocusVisible';
+export * from './useIsFocusVisible';

package/src/hooks/useIsFocusVisible/useIsFocusVisible.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+export declare function teardown(doc: Document): void;
+export interface UseIsFocusVisibleResult {
+    isFocusVisibleRef: React.MutableRefObject<boolean>;
+    onBlur: (event: React.FocusEvent<any>) => void;
+    onFocus: (event: React.FocusEvent<any>) => void;
+    ref: React.RefCallback<Element>;
+}
+export default function useIsFocusVisible(): UseIsFocusVisibleResult;

package/src/hooks/useKeyDownOnce/index.d.ts

@@ -0,0 +1 @@
+export * from './useKeyDownOnce';

package/src/hooks/useKeyDownOnce/useKeyDownOnce.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+export declare type UseKeyDownOnce<T> = {
+    onKeyUp?: (e: React.KeyboardEvent<T>) => void;
+    onKeyDown?: (e: React.KeyboardEvent<T>) => void;
+};
+/**
+ * Provide user trigger `onKeyDown` only one time when hold press on key.
+ * @param includeKeys that check include keys
+ * @param methods trigger when first keydown or keyup
+ * @returns
+ */
+export declare const useKeyDownOnce: <T>(includeKeys: string[], { onKeyDown, onKeyUp }: UseKeyDownOnce<T>) => {
+    onKeyDown: (e: import("react").KeyboardEvent<T>) => void;
+    onKeyUp: (e: import("react").KeyboardEvent<T>) => void;
+};

package/src/hooks/useKeyboardMoveFocus/index.d.ts

@@ -0,0 +1,3 @@
+export * from './moveIndexInTwoDimension';
+export * from './useKeyboardMoveFocus';
+export * from './useOnlyOneFocusable';

package/src/hooks/useKeyboardMoveFocus/moveIndexInTwoDimension.d.ts

@@ -0,0 +1,18 @@
+export declare type MoveIndexInTwoDimensionalOptions = {
+    /** current index */
+    currIndex: number;
+    /** column number with that two dimensional */
+    columns: number;
+    /** total number of items */
+    total: number;
+    /**
+     * if that touch boundary, is that can move to next available infinite
+     *
+     * - when set value as `order`, that will increase or decrease when `ArrowLeft` or `ArrowRight` touch boundary
+     */
+    infinite?: boolean | 'order';
+};
+/**
+ * that can move index in column array
+ */
+export declare function moveIndexInTwoDimension(direction: string, options: MoveIndexInTwoDimensionalOptions): number;

package/src/hooks/useKeyboardMoveFocus/useKeyboardMoveFocus.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="react" />
+import { MoveIndexInTwoDimensionalOptions } from './moveIndexInTwoDimension';
+export declare type UseKeyboardMoveFocusParams<T> = {
+    /** current focused index `ref` */
+    focusedIndexRef: React.MutableRefObject<number>;
+    /** action when index change */
+    onFocusedIndexChange: (event: React.KeyboardEvent<HTMLElement>, index: number) => void;
+    /** children items */
+    options: T[];
+    /** column number with that move block, default is `1` */
+    columns?: number;
+    /**
+     * Used to determine the disabled state for a given option.
+     *
+     * @param {T} option The option to test.
+     * @returns {boolean}
+     */
+    getOptionDisabled?: (option: T) => boolean;
+    /**
+     * Used to get option text for search focus by other text.
+     *
+     * @param {T} option
+     * @returns {string} that string for search
+     */
+    getOptionSearchText?: (option: T) => string;
+    /**
+     * when typing search text, end this search debounce time
+     *
+     * @default 500
+     */
+    endSearchDebounceTime?: number;
+} & Pick<MoveIndexInTwoDimensionalOptions, 'infinite'>;
+/**
+ * use keyboard move index in two dimensional
+ */
+export declare const useKeyboardMoveFocus: <T>({ infinite, options, focusedIndexRef, onFocusedIndexChange, getOptionDisabled, getOptionSearchText, columns, endSearchDebounceTime, }: UseKeyboardMoveFocusParams<T>) => {
+    /**
+     * Get previous focusable option(include current index).
+     */
+    getPrevFocusableOption: (index?: number, isInfinite?: any) => number;
+    /**
+     * Get next focusable option(include current index).
+     */
+    getNextFocusableOption: (index?: number, isInfinite?: any) => number;
+    /**
+     * Use to handle keyboard event.
+     */
+    onKeyFocusedIndexHandle: (event: React.KeyboardEvent<any>) => void;
+};

package/src/hooks/useKeyboardMoveFocus/useOnlyOneFocusable.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+export declare type UseOnlyOneFocusableParams = {
+    /** current focused index `ref` */
+    focusedIndexRef: React.MutableRefObject<number>;
+    /** wrap container for below all only have one focusable */
+    containerRef: React.RefObject<HTMLElement>;
+};
+/**
+ * when focus in container below element with binding `getItemProps`,
+ * that will only have one element can be focusable.
+ */
+export declare const useOnlyOneFocusable: ({ focusedIndexRef, containerRef, }: UseOnlyOneFocusableParams) => {
+    moveFocusedId: string;
+    focusIndex: (toIndex: number) => void;
+    setIndexTabIndex: (toIndex: number) => void;
+    getItemProps: (index: number, options?: Omit<import("react").HTMLAttributes<HTMLElement>, "children"> | undefined) => Omit<import("react").HTMLAttributes<HTMLElement>, "children">;
+};

package/src/hooks/useLongPress/index.d.ts

@@ -0,0 +1 @@
+export * from './useLongPress';

package/src/hooks/useLongPress/useLongPress.d.ts

@@ -0,0 +1,39 @@
+import React from 'react';
+import { UseTouchMouseEvent } from '../useTouchMouseEvent';
+export declare const isTouchEvent: <T = unknown>(ev: React.MouseEvent<T, MouseEvent> | React.TouchEvent<T>) => ev is React.TouchEvent<T>;
+export interface UseLongPressOptions {
+    /**
+     * auto event.preventDefault for `mousedown`, `touchstart`, `touchend`
+     * always use for not leave that element
+     */
+    isPreventDefault?: boolean;
+    /** the longPress delay */
+    delay?: number;
+    /** for custom window */
+    externalWindow?: Window;
+}
+export declare type UseLongPressEventReason = 'keyboard' | 'click' | 'tap';
+export declare type UseLongPressOutput<T> = {
+    /** trigger when click or tab or keyboard */
+    onTap?: (e: React.MouseEvent<T, MouseEvent> | React.TouchEvent<T> | React.KeyboardEvent<T>, reason: UseLongPressEventReason) => void;
+    /** trigger when press or long click */
+    onPress?: (e: React.MouseEvent<T, MouseEvent> | React.TouchEvent<T> | React.KeyboardEvent<T>, reason: UseLongPressEventReason) => void;
+};
+export declare type UseLongPressInput<T> = {
+    onKeyUp?: (e: React.KeyboardEvent<T>) => void;
+    onKeyDown?: (e: React.KeyboardEvent<T>) => void;
+} & UseTouchMouseEvent<T>;
+/**
+ * Provide longPress helper, both `click`/`tab`/`keydown` will trigger event
+ *
+ * - Trigger `onTap` when user action leave small than delay time.
+ * - Trigger `onPress` when action time is long than delay time.
+ *
+ * @default UseLongPressOptions { delay = 300 }
+ */
+export declare const useLongPress: <T extends HTMLElement = HTMLElement>({ onTap, onPress }: UseLongPressOutput<T>, { onTouchStart: onTouchStartArg, onTouchEnd: onTouchEndArg, onMouseDown, onKeyDown, onKeyUp, onMouseUp: onMouseUpArg, }?: UseLongPressInput<T>, { isPreventDefault, delay, externalWindow, }?: UseLongPressOptions) => {
+    onMouseDown: React.MouseEventHandler<T>;
+    ref: React.MutableRefObject<T | null>;
+    onKeyDown: (e: any) => void;
+    onKeyUp: (e: any) => void;
+};

package/src/hooks/useMountState/index.d.ts

@@ -0,0 +1 @@
+export * from './useMountState';

package/src/hooks/useMountState/useMountState.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+/**
+ * get that component mounted state `ref`
+ *
+ * @example
+ *
+ * ```ts
+    const isMountedRef = useMountState();
+
+    if (isMountedRef.current) {
+      console.log('component mounted');
+    }
+ *
+ * ```
+ */
+export declare const useMountState: () => import("react").MutableRefObject<boolean>;

package/src/hooks/useOnLayoutReRender/index.d.ts

@@ -0,0 +1 @@
+export * from './useOnLayoutReRender';

package/src/hooks/useOnLayoutReRender/useOnLayoutReRender.d.ts

@@ -0,0 +1,5 @@
+import { DependencyList } from 'react';
+/**
+ * only trigger when re-render (in useLayoutEffect), not trigger on component first render
+ */
+export declare const useOnLayoutReRender: (cb: () => any, deps?: DependencyList | undefined) => void;

package/src/hooks/useOnReRender/index.d.ts

@@ -0,0 +1 @@
+export * from './useOnReRender';

package/src/hooks/useOnReRender/useOnReRender.d.ts

@@ -0,0 +1,5 @@
+import { DependencyList } from 'react';
+/**
+ * only trigger when re-render, not trigger on component first render
+ */
+export declare const useOnReRender: (cb: () => any, deps?: DependencyList | undefined) => void;

package/src/hooks/useOverflow/index.d.ts

@@ -0,0 +1 @@
+export * from './useOverflow';

package/src/hooks/useOverflow/useOverflow.d.ts

@@ -0,0 +1,11 @@
+import { RefOrElementOrCallback } from '../../utils';
+import { PerformanceOptions } from '../useResizeObserver';
+/**
+ * trigger when overflow state change
+ */
+export declare const useOverflow: (target: RefOrElementOrCallback, cb: (state: boolean, value: {
+    scrollWidth: number;
+    clientWidth: number;
+    scrollHeight: number;
+    clientHeight: number;
+}) => void, performance?: PerformanceOptions) => ResizeObserver;

package/src/hooks/usePrevious/index.d.ts

@@ -0,0 +1 @@
+export * from './usePrevious';

package/src/hooks/usePrevious/usePrevious.d.ts

@@ -0,0 +1,7 @@
+/**
+ * get previous render value
+ * @param cb that get method of target value
+ * @param isDefault if set `true`, the first time will get value from `cb`
+ * @returns previous value get from `cb`
+ */
+export declare function usePrevious<T, K extends boolean>(cb: () => T, isDefault?: K): T | (K extends true ? never : undefined);

package/src/hooks/useRefState/index.d.ts

@@ -0,0 +1 @@
+export * from './useRefState';

package/src/hooks/useRefState/useRefState.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="react" />
+/**
+ * Returns a stateful like state with Ref, and a function to update it current value.
+ * can trigger update value without re-render
+ *
+ * @param value init value
+ * @param customUpdate you can custom you update method, or just set your `forceUpdate` to reuse same instance
+ * @returns an array with [ref, update]
+ *
+ * @example
+ * ```ts
+ * const [inputRef, updateInput] = useRefState(123);
+ *
+ * if(needReRender){
+ *   updateInput(456); // trigger re-render
+ * } else {
+ *   updateInput(456, false); // not trigger re-render
+ * }
+ * ```
+ */
+export declare const useRefState: <T>(value: T, customUpdate?: (() => void) | undefined) => readonly [import("react").MutableRefObject<T>, (toValue: T, isUpdate?: any) => void];

package/src/hooks/useResizeObserver/index.d.ts

@@ -0,0 +1 @@
+export * from './useResizeObserver';

package/src/hooks/useResizeObserver/useResizeObserver.d.ts

@@ -0,0 +1,24 @@
+import { type DebounceSettings, type ThrottleSettings } from 'lodash';
+import { RefOrElementOrCallback } from '../../utils';
+export declare type PerformanceOptions = {
+    /**
+     * mode that improve performance, default is debounce
+     *
+     * throttle is better than debounce when use for responsive UI
+     */
+    mode?: 'debounce' | 'throttle' | 'none';
+    /** debounce time or throttle time when resize, default is 200 */
+    time?: number;
+    /** ignore fire when observe */
+    ignoreFireWhenObserve?: boolean;
+    /** setting about debounce or throttle */
+    options?: ThrottleSettings | DebounceSettings;
+};
+/**
+ * get resize event with auto disconnect when layout destroy.
+ * bring with debounce for event not too many
+ * @param ref that ref for element
+ * @param callback callback when element resize
+ * @param performance options that improve performance
+ */
+export declare const useResizeObserver: <T extends HTMLElement = HTMLElement>(target: RefOrElementOrCallback<T>, callback: ResizeObserverCallback, performance?: PerformanceOptions) => ResizeObserver;

package/src/hooks/useResponsiveMatch/index.d.ts

@@ -0,0 +1 @@
+export * from './useResponsiveMatch';

package/src/hooks/useResponsiveMatch/useResponsiveMatch.d.ts

@@ -0,0 +1,7 @@
+import { BreakpointMatchMap, MatchedBreakpoint } from '../../contexts';
+/**
+ * get all matched breakpoints
+ * @param defaultBreakpoint use defaultBreakpoint when Responsive init (will pass undefined)
+ */
+declare const useResponsiveMatch: (defaultBreakpoint?: MatchedBreakpoint | undefined) => BreakpointMatchMap;
+export { useResponsiveMatch };

package/src/hooks/useResultRef/index.d.ts

@@ -0,0 +1 @@
+export * from './useResultRef';

package/src/hooks/useResultRef/useResultRef.d.ts

@@ -0,0 +1,10 @@
+import { MutableRefObject } from 'react';
+/**
+ * provide a ref for only calculate `cb` once
+ * prevent `useRef(getValue())`, that `getValue` calculate every re-render
+ *
+ * @param cb that get method of get this ref init value, only calculate once
+ * @returns same as `useRef` result
+ *
+ */
+export declare function useResultRef<T>(cb: () => T): MutableRefObject<T>;

package/src/hooks/useRetry/index.d.ts

@@ -0,0 +1 @@
+export * from './useRetry';

package/src/hooks/useRetry/useRetry.d.ts

@@ -0,0 +1,35 @@
+export declare type UseRetryOptions = {
+    /** times count that retry when `cb` return `false` */
+    retryTimes: number;
+    /** retry interval time */
+    intervalTime: number;
+    /** trigger when retry start */
+    onStart?: () => void;
+    /** trigger when retry be cancel */
+    onSuccess?: (
+    /** retry times */
+    times?: number) => void;
+    /** trigger when retry complete */
+    onComplete?: (
+    /** retry times */
+    times?: number) => void;
+    /** trigger when retry be cancel */
+    onCancel?: () => void;
+};
+/**
+ * retry times when exec callback fail
+ *
+ * * `retry`: that will auto add `times` end of your call back
+ * * `cancel`: cancel that retry event, that only cancel inner interval promise, **if you need cancel your `cb` promise, you should handle by yourself.**
+ */
+export declare const useRetry: <T extends (...args: any[]) => boolean | Promise<boolean>>(cb: T, options?: UseRetryOptions | undefined) => {
+    /**
+     * retry method, that will be cancelable with `cancel`,
+     * and when trigger many time that will always clear previous retry
+     */
+    retry: (...args: Parameters<T>) => Promise<void>;
+    /**
+     * cancel current retry
+     */
+    cancel: () => void;
+};

package/src/hooks/useSleep/index.d.ts

@@ -0,0 +1 @@
+export * from './useSleep';

package/src/hooks/useSleep/useSleep.d.ts

@@ -0,0 +1,22 @@
+/**
+ * cancelable sleep method.
+ *
+ * - sleep: a promise sleep
+ * - cancel: cancel that sleep event
+ * - getSleeping: get current sleeping state
+ */
+export declare const useSleep: () => {
+    /**
+     * sleep method, that will be cancelable with `cancel`,
+     * and when trigger many time that will always clear previous sleep
+     */
+    sleep: (time: number) => Promise<void>;
+    /**
+     * cancel current sleep timer
+     */
+    cancel: () => void;
+    /**
+     * return is current is sleeping
+     */
+    getSleeping: () => boolean;
+};

package/src/hooks/useTabOut/index.d.ts

@@ -0,0 +1 @@
+export * from './useTabOut';

package/src/hooks/useTabOut/useTabOut.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param onTabOut Callback fired when a "tab out" event is detected.
+ */
+export declare const useTabOut: (onTabOut: (e: React.FocusEvent<HTMLDivElement>) => void) => {
+    tabOutHandler: {
+        onKeyDown: (e: React.KeyboardEvent<HTMLDivElement>) => void;
+        onKeyUp: (e: React.KeyboardEvent<HTMLDivElement>) => void;
+        onBlur: (e: React.FocusEvent<HTMLDivElement>) => void;
+    };
+};

package/src/hooks/useTestRunnerDetection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Internal hook to detect if the component is running in a test runner environment
+ * Used by Storybook stories to disable network requests and animations during testing
+ * @returns {boolean} true if running in test runner (headless browser), false otherwise
+ * @internal
+ */
+export declare const useTestRunnerDetection: () => boolean;

package/src/hooks/useThrottle/index.d.ts

@@ -0,0 +1 @@
+export * from './useThrottle';

package/src/hooks/useThrottle/useThrottle.d.ts

@@ -0,0 +1,8 @@
+import type { ThrottleSettings } from 'lodash';
+/**
+ * provide a throttle method for throttle method
+ * @param fn method for throttle
+ * @param throttleTime throttle timeout value, default is  `200`ms
+ * @param options throttle setting, default is  `{trailing: true, leading: true}`, detail see lodash
+ */
+export declare const useThrottle: <F extends (...args: any[]) => any>(fn: F, throttleTime?: number, options?: ThrottleSettings | undefined) => import("lodash").DebouncedFunc<F>;

package/src/hooks/useTimeout/index.d.ts

@@ -0,0 +1 @@
+export * from './useTimeout';

package/src/hooks/useTimeout/useTimeout.d.ts

@@ -0,0 +1,2 @@
+export declare function useTimeout(callback: () => void, delay: number | null): void;
+export default useTimeout;

package/src/hooks/useTouchMouseEvent/index.d.ts

@@ -0,0 +1 @@
+export * from './useTouchMouseEvent';

package/src/hooks/useTouchMouseEvent/useTouchMouseEvent.d.ts

@@ -0,0 +1,56 @@
+import { MouseEventHandler, TouchEventHandler } from 'react';
+import { RefOrElementOrCallback } from '../../utils';
+export interface UseTouchMouseEvent<T> extends Partial<UseTouchMouseOutputEvent<T>> {
+    onTouchEnd?: (event: React.TouchEvent<T>, 
+    /**
+     * when set insideRef, that will also emit the state of host reference contain pointer element when action stop
+     */
+    isInside?: boolean) => void;
+    onMouseUp?: (event: React.MouseEvent<T, globalThis.MouseEvent>, 
+    /**
+     * when set insideRef, that will also emit the state of host reference contain pointer element when action stop
+     */
+    isInside?: boolean) => void;
+}
+export interface UseTouchMouseOutputEvent<T> {
+    onMouseUp: MouseEventHandler<T>;
+    onMouseDown: MouseEventHandler<T>;
+    onTouchEnd: TouchEventHandler<T>;
+    onTouchStart: TouchEventHandler<T>;
+}
+export interface UseTouchMouseEventOptions<T extends HTMLElement> {
+    /**
+     * when set that elementRef, event will bring with leave state when `touchend` and `mouseup`
+     *
+     * stop action event in browser default can be trigger when `touchend`, `mouseup` outside target element,
+     * set that host ref to make sure `touchend`, `mouseup` event only trigger when release inside target element
+     */
+    actionRef?: RefOrElementOrCallback<T>;
+}
+/**
+ * Provide a utils for switch trigger touch event or mouse event between different device
+ *
+ * - Trigger `touch` event in `touch support` device
+ *   - onTouchStart
+ *   - onTouchEnd
+ * - Trigger `mouse` event in `non touch support` device
+ *   - onMouseDown
+ *   - onMouseUp
+ *
+ * ### Once that is touch support device, that mouse event will never can be trigger
+ * https://developer.mozilla.org/en-US/docs/Web/API/Touch_events/Supporting_both_TouchEvent_and_MouseEvent
+ *
+ * Event order:
+ * - touchstart
+ * - Zero or more touchmove events, depending on movement of the finger(s)
+ * - touchend
+ * - mousemove
+ * - mousedown
+ * - mouseup
+ * - click
+ */
+export declare const useTouchMouseEvent: <T extends HTMLElement = HTMLElement>({ onMouseDown: onMouseDownArg, onMouseUp: onMouseUpArg, onTouchStart: onTouchStartArg, onTouchEnd: onTouchEndArg, }: UseTouchMouseEvent<T>, { actionRef }?: UseTouchMouseEventOptions<T>) => UseTouchMouseOutputEvent<T>;
+/**
+ * check is element equal or contains target element
+ */
+export declare const isElmEqualOrContain: (sourceTarget: RefOrElementOrCallback, containTarget: RefOrElementOrCallback) => boolean;

package/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './config';
+export * from './contexts';
+export * from './hooks';
+export * from './typings';
+export * from './utils';

package/src/typings/BaseColor.d.ts

@@ -0,0 +1,14 @@
+declare type DefaultBaseColor = {
+    primary: any;
+    secondary: any;
+    inherit: any;
+    default: any;
+    error: any;
+    /**  */
+    positive: any;
+    negative: any;
+    action: any;
+    neutral: any;
+};
+export declare type BaseColor<T extends keyof DefaultBaseColor = 'primary' | 'secondary'> = keyof Pick<DefaultBaseColor, T>;
+export {};