@unicom-cloud/ui 0.8.108 → 0.8.110

package/types/common/hooks/src/create-use-storage-state/index.d.ts

@@ -0,0 +1,11 @@
+export declare const SYNC_STORAGE_EVENT_NAME = "HOOKS_SYNC_STORAGE_EVENT_NAME";
+export type SetState<S> = S | ((prevState?: S) => S);
+export interface Options<T> {
+    defaultValue?: T | (() => T);
+    listenStorageChange?: boolean;
+    serializer?: (value: T) => string;
+    deserializer?: (value: string) => T;
+    onError?: (error: unknown) => void;
+}
+declare function createUseStorageState(getStorage: () => Storage | undefined): <T>(key: string, options?: Options<T>) => readonly [T, (value: SetState<T>) => void];
+export default createUseStorageState;

package/types/common/hooks/src/index.d.ts

@@ -0,0 +1,74 @@
+import createUpdateEffect from './create-update-effect';
+import useAsyncEffect from './use-async-effect';
+import useBoolean from './use-boolean';
+import useClickAway from './use-click-away';
+import useControllableValue from './use-controllable-value';
+import useCookieState from './use-cookie-state';
+import useCountDown from './use-count-down';
+import useCounter from './use-counter';
+import useCreation from './use-creation';
+import useDebounce from './use-debounce';
+import useDebounceEffect from './use-debounce-effect';
+import useDebounceFn from './use-debounce-fn';
+import useDeepCompareEffect from './use-deep-compare-effect';
+import useDeepCompareLayoutEffect from './use-deep-compare-layout-effect';
+import useDocumentVisibility from './use-document-visibility';
+import useDrag from './use-drag';
+import useDrop from './use-drop';
+import useEventListener from './use-event-listener';
+import useEventTarget from './use-event-target';
+import useExternal from './use-external';
+import useFavicon from './use-favicon';
+import useFocusWithin from './use-focus-within';
+import useFullscreen from './use-fullscreen';
+import useGetState from './use-get-state';
+import useHistoryTravel from './use-history-travel';
+import useHover from './use-hover';
+import useInViewport from './use-in-viewport';
+import useInfiniteScroll from './use-infinite-scroll';
+import useInterval from './use-interval';
+import useIsomorphicLayoutEffect from './use-isomorphic-layout-effect';
+import useKeyPress from './use-key-press';
+import useLatest from './use-latest';
+import useLocalStorageState from './use-local-storage-state';
+import useLockFn from './use-lock-fn';
+import useLongPress from './use-long-press';
+import useMemoizedFn from './use-memoized-fn';
+import useMount from './use-mount';
+import useMouse from './use-mouse';
+import useMutationObserver from './use-mutation-observer';
+import useNetwork from './use-network';
+import usePagination from './use-pagination';
+import usePrevious from './use-previous';
+import useRafInterval from './use-raf-interval';
+import useRafState from './use-raf-state';
+import useRafTimeout from './use-raf-timeout';
+import useReactive from './use-reactive';
+import useRequest, { clearCache } from './use-request';
+import useResetState from './use-reset-state';
+import useResponsive, { configResponsive } from './use-responsive';
+import useSafeState from './use-safe-state';
+import useScroll from './use-scroll';
+import useSelections from './use-selections';
+import useSessionStorageState from './use-session-storage-state';
+import useSetState from './use-set-state';
+import useSize from './use-size';
+import useTextSelection from './use-text-selection';
+import useTheme from './use-theme';
+import useThrottle from './use-throttle';
+import useThrottleEffect from './use-throttle-effect';
+import useThrottleFn from './use-throttle-fn';
+import useTimeout from './use-timeout';
+import useTitle from './use-title';
+import useToggle from './use-toggle';
+import useTrackedEffect from './use-tracked-effect';
+import useUnmount from './use-unmount';
+import useUnmountedRef from './use-unmounted-ref';
+import useUpdate from './use-update';
+import useUpdateEffect from './use-update-effect';
+import useUpdateLayoutEffect from './use-update-layout-effect';
+import useUrlState from './use-url-state';
+import useVirtualList from './use-virtual-list';
+import useWebSocket from './use-web-socket';
+import useWhyDidYouUpdate from './use-why-did-you-update';
+export { clearCache, configResponsive, createUpdateEffect, useAsyncEffect, useBoolean, useClickAway, useControllableValue, useCookieState, useCountDown, useCounter, useCreation, useDebounce, useDebounceEffect, useDebounceFn, useDeepCompareEffect, useDeepCompareLayoutEffect, useDocumentVisibility, useDrag, useDrop, useEventListener, useEventTarget, useExternal, useFavicon, useFocusWithin, useFullscreen, useGetState, useHistoryTravel, useHover, useInfiniteScroll, useInterval, useInViewport, useIsomorphicLayoutEffect, useKeyPress, useLatest, useLocalStorageState, useLockFn, useLongPress, useMemoizedFn, useMount, useMouse, useMutationObserver, useNetwork, usePagination, usePrevious, useRafInterval, useRafState, useRafTimeout, useReactive, useRequest, useResetState, useResponsive, useSafeState, useScroll, useSelections, useSessionStorageState, useSetState, useSize, useTextSelection, useTheme, useThrottle, useThrottleEffect, useThrottleFn, useTimeout, useTitle, useToggle, useTrackedEffect, useUnmount, useUnmountedRef, useUpdate, useUpdateEffect, useUpdateLayoutEffect, useUrlState, useVirtualList, useWebSocket, useWhyDidYouUpdate, };

package/types/common/hooks/src/use-async-effect/index.d.ts

@@ -0,0 +1,3 @@
+import type { DependencyList } from 'react';
+declare function useAsyncEffect(effect: () => AsyncGenerator<void, void, void> | Promise<void>, deps?: DependencyList): void;
+export default useAsyncEffect;

package/types/common/hooks/src/use-boolean/index.d.ts

@@ -0,0 +1,7 @@
+export interface Actions {
+    setTrue: () => void;
+    setFalse: () => void;
+    set: (value: boolean) => void;
+    toggle: () => void;
+}
+export default function useBoolean(defaultValue?: boolean): [boolean, Actions];

package/types/common/hooks/src/use-click-away/index.d.ts

@@ -0,0 +1,4 @@
+import type { BasicTarget } from '../utils/domTarget';
+type DocumentEventKey = keyof DocumentEventMap;
+export default function useClickAway<T extends Event = Event>(onClickAway: (event: T) => void, target: BasicTarget | BasicTarget[], eventName?: DocumentEventKey | DocumentEventKey[]): void;
+export {};

package/types/common/hooks/src/use-controllable-value/index.d.ts

@@ -0,0 +1,16 @@
+import type { SetStateAction } from 'react';
+export interface Options<T> {
+    defaultValue?: T;
+    defaultValuePropName?: string;
+    valuePropName?: string;
+    trigger?: string;
+}
+export type Props = Record<string, any>;
+export interface StandardProps<T> {
+    value: T;
+    defaultValue?: T;
+    onChange: (val: T) => void;
+}
+declare function useControllableValue<T = any>(props: StandardProps<T>): [T, (v: SetStateAction<T>) => void];
+declare function useControllableValue<T = any>(props?: Props, options?: Options<T>): [T, (v: SetStateAction<T>, ...args: any[]) => void];
+export default useControllableValue;

package/types/common/hooks/src/use-cookie-state/index.d.ts

@@ -0,0 +1,7 @@
+import Cookies from '@unicom-cloud/utils/js-cookie';
+export type State = string | undefined;
+export interface Options extends Cookies.CookieAttributes {
+    defaultValue?: State | (() => State);
+}
+declare function useCookieState(cookieKey: string, options?: Options): readonly [State, (this: unknown, newValue: State | ((prevState: State) => State), newOptions?: Cookies.CookieAttributes | undefined) => void];
+export default useCookieState;

package/types/common/hooks/src/use-count-down/index.d.ts

@@ -0,0 +1,17 @@
+import dayjs from 'dayjs';
+export type TDate = dayjs.ConfigType;
+export interface Options {
+    leftTime?: number;
+    targetDate?: TDate;
+    interval?: number;
+    onEnd?: () => void;
+}
+export interface FormattedRes {
+    days: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+}
+declare const useCountdown: (options?: Options) => readonly [number, FormattedRes];
+export default useCountdown;

package/types/common/hooks/src/use-counter/index.d.ts

@@ -0,0 +1,18 @@
+export interface Options {
+    min?: number;
+    max?: number;
+}
+export interface Actions {
+    inc: (delta?: number) => void;
+    dec: (delta?: number) => void;
+    set: (value: number | ((c: number) => number)) => void;
+    reset: () => void;
+}
+export type ValueParam = number | ((c: number) => number);
+declare function useCounter(initialValue?: number, options?: Options): readonly [number, {
+    readonly inc: (this: unknown, delta?: number | undefined) => void;
+    readonly dec: (this: unknown, delta?: number | undefined) => void;
+    readonly set: (this: unknown, value: ValueParam) => void;
+    readonly reset: (this: unknown) => void;
+}];
+export default useCounter;

package/types/common/hooks/src/use-creation/index.d.ts

@@ -0,0 +1,3 @@
+import type { DependencyList } from 'react';
+declare const useCreation: <T>(factory: () => T, deps: DependencyList) => T;
+export default useCreation;

package/types/common/hooks/src/use-debounce/debounceOptions.d.ts

@@ -0,0 +1,6 @@
+export interface DebounceOptions {
+    wait?: number;
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}

package/types/common/hooks/src/use-debounce/index.d.ts

@@ -0,0 +1,3 @@
+import type { DebounceOptions } from './debounceOptions';
+declare function useDebounce<T>(value: T, options?: DebounceOptions): T;
+export default useDebounce;

package/types/common/hooks/src/use-debounce-effect/index.d.ts

@@ -0,0 +1,4 @@
+import type { DependencyList, EffectCallback } from 'react';
+import type { DebounceOptions } from '../use-debounce/debounceOptions';
+declare function useDebounceEffect(effect: EffectCallback, deps?: DependencyList, options?: DebounceOptions): void;
+export default useDebounceEffect;

package/types/common/hooks/src/use-debounce-fn/index.d.ts

@@ -0,0 +1,8 @@
+import type { DebounceOptions } from '../use-debounce/debounceOptions';
+type noop = (...args: any[]) => any;
+declare function useDebounceFn<T extends noop>(fn: T, options?: DebounceOptions): {
+    run: import("lodash").DebouncedFunc<(...args: Parameters<T>) => ReturnType<T>>;
+    cancel: () => void;
+    flush: () => ReturnType<T> | undefined;
+};
+export default useDebounceFn;

package/types/common/hooks/src/use-deep-compare-effect/index.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const _default: typeof useEffect | typeof import("react").useLayoutEffect;
+export default _default;

package/types/common/hooks/src/use-deep-compare-layout-effect/index.d.ts

@@ -0,0 +1,3 @@
+import { useLayoutEffect } from 'react';
+declare const _default: typeof import("react").useEffect | typeof useLayoutEffect;
+export default _default;

package/types/common/hooks/src/use-document-visibility/index.d.ts

@@ -0,0 +1,3 @@
+type VisibilityState = 'hidden' | 'visible' | 'prerender' | undefined;
+declare function useDocumentVisibility(): VisibilityState;
+export default useDocumentVisibility;

package/types/common/hooks/src/use-drag/index.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { BasicTarget } from '../utils/domTarget';
+export interface Options {
+    onDragStart?: (event: React.DragEvent) => void;
+    onDragEnd?: (event: React.DragEvent) => void;
+    dragImage?: {
+        image: string | Element;
+        offsetX?: number;
+        offsetY?: number;
+    };
+}
+declare const useDrag: <T>(data: T, target: BasicTarget, options?: Options) => void;
+export default useDrag;

package/types/common/hooks/src/use-drop/index.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { BasicTarget } from '../utils/domTarget';
+export interface Options {
+    onFiles?: (files: File[], event?: React.DragEvent) => void;
+    onUri?: (url: string, event?: React.DragEvent) => void;
+    onDom?: (content: any, event?: React.DragEvent) => void;
+    onText?: (text: string, event?: React.ClipboardEvent) => void;
+    onDragEnter?: (event?: React.DragEvent) => void;
+    onDragOver?: (event?: React.DragEvent) => void;
+    onDragLeave?: (event?: React.DragEvent) => void;
+    onDrop?: (event?: React.DragEvent) => void;
+    onPaste?: (event?: React.ClipboardEvent) => void;
+}
+declare const useDrop: (target: BasicTarget, options?: Options) => void;
+export default useDrop;

package/types/common/hooks/src/use-event-listener/index.d.ts

@@ -0,0 +1,17 @@
+import type { BasicTarget } from '../utils/domTarget';
+type noop = (...p: any) => void;
+export type Target = BasicTarget<HTMLElement | Element | Window | Document>;
+type Options<T extends Target = Target> = {
+    target?: T;
+    capture?: boolean;
+    once?: boolean;
+    passive?: boolean;
+    enable?: boolean;
+};
+declare function useEventListener<K extends keyof HTMLElementEventMap>(eventName: K, handler: (ev: HTMLElementEventMap[K]) => void, options?: Options<HTMLElement>): void;
+declare function useEventListener<K extends keyof ElementEventMap>(eventName: K, handler: (ev: ElementEventMap[K]) => void, options?: Options<Element>): void;
+declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (ev: DocumentEventMap[K]) => void, options?: Options<Document>): void;
+declare function useEventListener<K extends keyof WindowEventMap>(eventName: K, handler: (ev: WindowEventMap[K]) => void, options?: Options<Window>): void;
+declare function useEventListener(eventName: string | string[], handler: (event: Event) => void, options?: Options<Window>): void;
+declare function useEventListener(eventName: string | string[], handler: noop, options: Options): void;
+export default useEventListener;

package/types/common/hooks/src/use-event-target/index.d.ts

@@ -0,0 +1,14 @@
+interface EventTarget<U> {
+    target: {
+        value: U;
+    };
+}
+export interface Options<T, U> {
+    initialValue?: T;
+    transformer?: (value: U) => T;
+}
+declare function useEventTarget<T, U = T>(options?: Options<T, U>): readonly [T | undefined, {
+    readonly onChange: (e: EventTarget<U>) => void;
+    readonly reset: () => void;
+}];
+export default useEventTarget;

package/types/common/hooks/src/use-external/index.d.ts

@@ -0,0 +1,20 @@
+type JsOptions = {
+    type: 'js';
+    js?: Partial<HTMLScriptElement>;
+    keepWhenUnused?: boolean;
+};
+type CssOptions = {
+    type: 'css';
+    css?: Partial<HTMLStyleElement>;
+    keepWhenUnused?: boolean;
+};
+type DefaultOptions = {
+    type?: never;
+    js?: Partial<HTMLScriptElement>;
+    css?: Partial<HTMLStyleElement>;
+    keepWhenUnused?: boolean;
+};
+export type Options = JsOptions | CssOptions | DefaultOptions;
+export type Status = 'unset' | 'loading' | 'ready' | 'error';
+declare const useExternal: (path?: string, options?: Options) => Status;
+export default useExternal;

package/types/common/hooks/src/use-favicon/index.d.ts

@@ -0,0 +1,2 @@
+declare const useFavicon: (href: string) => void;
+export default useFavicon;

package/types/common/hooks/src/use-focus-within/index.d.ts

@@ -0,0 +1,7 @@
+import type { BasicTarget } from '../utils/domTarget';
+export interface Options {
+    onFocus?: (e: FocusEvent) => void;
+    onBlur?: (e: FocusEvent) => void;
+    onChange?: (isFocusWithin: boolean) => void;
+}
+export default function useFocusWithin(target: BasicTarget, options?: Options): boolean;

package/types/common/hooks/src/use-fullscreen/index.d.ts

@@ -0,0 +1,17 @@
+import type { BasicTarget } from '../utils/domTarget';
+export interface PageFullscreenOptions {
+    className?: string;
+    zIndex?: number;
+}
+export interface Options {
+    onExit?: () => void;
+    onEnter?: () => void;
+    pageFullscreen?: boolean | PageFullscreenOptions;
+}
+declare const useFullscreen: (target: BasicTarget, options?: Options) => readonly [any, {
+    readonly enterFullscreen: (this: unknown) => void;
+    readonly exitFullscreen: (this: unknown) => void;
+    readonly toggleFullscreen: (this: unknown) => void;
+    readonly isEnabled: any;
+}];
+export default useFullscreen;

package/types/common/hooks/src/use-get-state/index.d.ts

@@ -0,0 +1,9 @@
+import type { Dispatch, SetStateAction } from 'react';
+type GetStateAction<S> = () => S;
+declare function useGetState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>, GetStateAction<S>];
+declare function useGetState<S = undefined>(): [
+    S | undefined,
+    Dispatch<SetStateAction<S | undefined>>,
+    GetStateAction<S | undefined>
+];
+export default useGetState;

package/types/common/hooks/src/use-history-travel/index.d.ts

@@ -0,0 +1,10 @@
+export default function useHistoryTravel<T>(initialValue?: T, maxLength?: number): {
+    value: T | undefined;
+    backLength: number;
+    forwardLength: number;
+    setValue: (this: unknown, val: T) => void;
+    go: (this: unknown, step: number) => void;
+    back: (this: unknown) => void;
+    forward: (this: unknown) => void;
+    reset: (this: unknown, ...args: any[]) => void;
+};

package/types/common/hooks/src/use-hover/index.d.ts

@@ -0,0 +1,8 @@
+import type { BasicTarget } from '../utils/domTarget';
+export interface Options {
+    onEnter?: () => void;
+    onLeave?: () => void;
+    onChange?: (isHovering: boolean) => void;
+}
+declare const _default: (target: BasicTarget, options?: Options) => boolean;
+export default _default;

package/types/common/hooks/src/use-in-viewport/index.d.ts

@@ -0,0 +1,10 @@
+import type { BasicTarget } from '../utils/domTarget';
+type CallbackType = (entry: IntersectionObserverEntry) => void;
+export interface Options {
+    rootMargin?: string;
+    threshold?: number | number[];
+    root?: BasicTarget<Element>;
+    callback?: CallbackType;
+}
+declare function useInViewport(target: BasicTarget | BasicTarget[], options?: Options): readonly [boolean | undefined, number | undefined];
+export default useInViewport;

package/types/common/hooks/src/use-infinite-scroll/index.d.ts

@@ -0,0 +1,15 @@
+import type { Data, InfiniteScrollOptions, Service } from './types';
+declare const useInfiniteScroll: <TData extends Data>(service: Service<TData>, options?: InfiniteScrollOptions<TData>) => {
+    data: TData | undefined;
+    loading: boolean;
+    error: Error | undefined;
+    loadingMore: boolean;
+    noMore: boolean;
+    loadMore: (this: unknown) => void;
+    loadMoreAsync: (this: unknown) => Promise<TData>;
+    reload: (this: unknown) => void;
+    reloadAsync: (this: unknown) => Promise<TData>;
+    mutate: import("react").Dispatch<import("react").SetStateAction<TData | undefined>>;
+    cancel: () => void;
+};
+export default useInfiniteScroll;

package/types/common/hooks/src/use-infinite-scroll/types.d.ts

@@ -0,0 +1,32 @@
+import type { DependencyList } from 'react';
+import type { BasicTarget } from '../utils/domTarget';
+export type Data = {
+    list: any[];
+    [key: string]: any;
+};
+export type Service<TData extends Data> = (currentData?: TData) => Promise<TData>;
+export interface InfiniteScrollResult<TData extends Data> {
+    data: TData;
+    loading: boolean;
+    loadingMore: boolean;
+    error?: Error;
+    noMore: boolean;
+    loadMore: () => void;
+    loadMoreAsync: () => Promise<TData>;
+    reload: () => void;
+    reloadAsync: () => Promise<TData>;
+    cancel: () => void;
+    mutate: (data?: TData) => void;
+}
+export interface InfiniteScrollOptions<TData extends Data> {
+    target?: BasicTarget<Element | Document>;
+    isNoMore?: (data?: TData) => boolean;
+    threshold?: number;
+    direction?: 'bottom' | 'top';
+    manual?: boolean;
+    reloadDeps?: DependencyList;
+    onBefore?: () => void;
+    onSuccess?: (data: TData) => void;
+    onError?: (e: Error) => void;
+    onFinally?: (data?: TData, e?: Error) => void;
+}

package/types/common/hooks/src/use-interval/index.d.ts

@@ -0,0 +1,4 @@
+declare const useInterval: (fn: () => void, delay?: number, options?: {
+    immediate?: boolean;
+}) => () => void;
+export default useInterval;

package/types/common/hooks/src/use-isomorphic-layout-effect/index.d.ts

@@ -0,0 +1,3 @@
+import { useEffect } from 'react';
+declare const useIsomorphicLayoutEffect: typeof useEffect;
+export default useIsomorphicLayoutEffect;

package/types/common/hooks/src/use-key-press/index.d.ts

@@ -0,0 +1,14 @@
+import type { BasicTarget } from '../utils/domTarget';
+export type KeyType = number | string;
+export type KeyPredicate = (event: KeyboardEvent) => KeyType | boolean | undefined;
+export type KeyFilter = KeyType | KeyType[] | ((event: KeyboardEvent) => boolean);
+export type KeyEvent = 'keydown' | 'keyup';
+export type Target = BasicTarget<HTMLElement | Document | Window>;
+export type Options = {
+    events?: KeyEvent[];
+    target?: Target;
+    exactMatch?: boolean;
+    useCapture?: boolean;
+};
+declare function useKeyPress(keyFilter: KeyFilter, eventHandler: (event: KeyboardEvent, key: KeyType) => void, option?: Options): void;
+export default useKeyPress;

package/types/common/hooks/src/use-latest/index.d.ts

@@ -0,0 +1,2 @@
+declare function useLatest<T>(value: T): import("react").RefObject<T>;
+export default useLatest;

package/types/common/hooks/src/use-local-storage-state/index.d.ts

@@ -0,0 +1,2 @@
+declare const useLocalStorageState: <T>(key: string, options?: import("../create-use-storage-state").Options<T>) => readonly [T, (value: import("../create-use-storage-state").SetState<T>) => void];
+export default useLocalStorageState;

package/types/common/hooks/src/use-lock-fn/index.d.ts

@@ -0,0 +1,2 @@
+declare function useLockFn<P extends any[] = any[], V = any>(fn: (...args: P) => Promise<V>): (...args: P) => Promise<V | undefined>;
+export default useLockFn;

package/types/common/hooks/src/use-long-press/index.d.ts

@@ -0,0 +1,13 @@
+import type { BasicTarget } from '../utils/domTarget';
+type EventType = MouseEvent | TouchEvent;
+export interface Options {
+    delay?: number;
+    moveThreshold?: {
+        x?: number;
+        y?: number;
+    };
+    onClick?: (event: EventType) => void;
+    onLongPressEnd?: (event: EventType) => void;
+}
+declare function useLongPress(onLongPress: (event: EventType) => void, target: BasicTarget, { delay, moveThreshold, onClick, onLongPressEnd }?: Options): void;
+export default useLongPress;

package/types/common/hooks/src/use-memoized-fn/index.d.ts

@@ -0,0 +1,4 @@
+type noop = (this: any, ...args: any[]) => any;
+type PickFunction<T extends noop> = (this: ThisParameterType<T>, ...args: Parameters<T>) => ReturnType<T>;
+declare const useMemoizedFn: <T extends noop>(fn: T) => PickFunction<T>;
+export default useMemoizedFn;

package/types/common/hooks/src/use-mount/index.d.ts

@@ -0,0 +1,3 @@
+import { type EffectCallback } from 'react';
+declare const useMount: (fn: EffectCallback) => void;
+export default useMount;

package/types/common/hooks/src/use-mouse/index.d.ts

@@ -0,0 +1,17 @@
+import type { BasicTarget } from '../utils/domTarget';
+export interface CursorState {
+    screenX: number;
+    screenY: number;
+    clientX: number;
+    clientY: number;
+    pageX: number;
+    pageY: number;
+    elementX: number;
+    elementY: number;
+    elementH: number;
+    elementW: number;
+    elementPosX: number;
+    elementPosY: number;
+}
+declare const _default: (target?: BasicTarget) => CursorState;
+export default _default;

package/types/common/hooks/src/use-mutation-observer/index.d.ts

@@ -0,0 +1,3 @@
+import type { BasicTarget } from '../utils/domTarget';
+declare const useMutationObserver: (callback: MutationCallback, target: BasicTarget, options?: MutationObserverInit) => void;
+export default useMutationObserver;

package/types/common/hooks/src/use-network/index.d.ts

@@ -0,0 +1,12 @@
+export interface NetworkState {
+    since?: Date;
+    online?: boolean;
+    rtt?: number;
+    type?: string;
+    downlink?: number;
+    saveData?: boolean;
+    downlinkMax?: number;
+    effectiveType?: string;
+}
+declare function useNetwork(): NetworkState;
+export default useNetwork;

package/types/common/hooks/src/use-pagination/index.d.ts

@@ -0,0 +1,3 @@
+import type { Data, PaginationOptions, PaginationResult, Params, Service } from './types';
+declare const usePagination: <TData extends Data, TParams extends Params>(service: Service<TData, TParams>, options?: PaginationOptions<TData, TParams>) => PaginationResult<TData, TParams>;
+export default usePagination;

package/types/common/hooks/src/use-pagination/types.d.ts

@@ -0,0 +1,29 @@
+import type { Options, Result } from '../use-request/src/types';
+export type Data = {
+    total: number;
+    list: any[];
+};
+export type Params = [
+    {
+        current: number;
+        pageSize: number;
+        [key: string]: any;
+    },
+    ...any[]
+];
+export type Service<TData extends Data, TParams extends Params> = (...args: TParams) => Promise<TData>;
+export interface PaginationResult<TData extends Data, TParams extends Params> extends Result<TData, TParams> {
+    pagination: {
+        current: number;
+        pageSize: number;
+        total: number;
+        totalPage: number;
+        onChange: (current: number, pageSize: number) => void;
+        changeCurrent: (current: number) => void;
+        changePageSize: (pageSize: number) => void;
+    };
+}
+export interface PaginationOptions<TData extends Data, TParams extends Params> extends Options<TData, TParams> {
+    defaultPageSize?: number;
+    defaultCurrent?: number;
+}

package/types/common/hooks/src/use-previous/index.d.ts

@@ -0,0 +1,3 @@
+export type ShouldUpdateFunc<T> = (prev?: T, next?: T) => boolean;
+declare function usePrevious<T>(state: T, shouldUpdate?: ShouldUpdateFunc<T>): T | undefined;
+export default usePrevious;

package/types/common/hooks/src/use-raf-interval/index.d.ts

@@ -0,0 +1,4 @@
+declare function useRafInterval(fn: () => void, delay: number | undefined, options?: {
+    immediate?: boolean;
+}): () => void;
+export default useRafInterval;

package/types/common/hooks/src/use-raf-state/index.d.ts

@@ -0,0 +1,7 @@
+import type { Dispatch, SetStateAction } from 'react';
+declare function useRafState<S>(initialState: S | (() => S)): [S, Dispatch<SetStateAction<S>>];
+declare function useRafState<S = undefined>(): [
+    S | undefined,
+    Dispatch<SetStateAction<S | undefined>>
+];
+export default useRafState;

package/types/common/hooks/src/use-raf-timeout/index.d.ts

@@ -0,0 +1,2 @@
+declare function useRafTimeout(fn: () => void, delay: number | undefined): () => void;
+export default useRafTimeout;

package/types/common/hooks/src/use-reactive/index.d.ts

@@ -0,0 +1,2 @@
+declare function useReactive<S extends Record<string, any>>(initialState: S): S;
+export default useReactive;

package/types/common/hooks/src/use-request/index.d.ts

@@ -0,0 +1,4 @@
+import useRequest from './src/useRequest';
+import { clearCache } from './src/utils/cache';
+export { clearCache };
+export default useRequest;

package/types/common/hooks/src/use-request/src/Fetch.d.ts

@@ -0,0 +1,20 @@
+import type { RefObject } from 'react';
+import type { FetchState, Options, PluginReturn, Service, Subscribe } from './types';
+export default class Fetch<TData, TParams extends any[]> {
+    serviceRef: RefObject<Service<TData, TParams>>;
+    options: Options<TData, TParams>;
+    subscribe: Subscribe;
+    initState: Partial<FetchState<TData, TParams>>;
+    pluginImpls: PluginReturn<TData, TParams>[];
+    count: number;
+    state: FetchState<TData, TParams>;
+    constructor(serviceRef: RefObject<Service<TData, TParams>>, options: Options<TData, TParams>, subscribe: Subscribe, initState?: Partial<FetchState<TData, TParams>>);
+    setState(s?: Partial<FetchState<TData, TParams>>): void;
+    runPluginHandler(event: keyof PluginReturn<TData, TParams>, ...rest: any[]): any;
+    runAsync(...params: TParams): Promise<TData>;
+    run(...params: TParams): void;
+    cancel(): void;
+    refresh(): void;
+    refreshAsync(): Promise<TData>;
+    mutate(data?: TData | ((oldData?: TData) => TData | undefined)): void;
+}