@unicom-cloud/ui 0.8.107 → 0.8.109

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;
+}

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useAutoRunPlugin: Plugin<any, any[]>;
+export default useAutoRunPlugin;

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useCachePlugin: Plugin<any, any[]>;
+export default useCachePlugin;

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useDebouncePlugin: Plugin<any, any[]>;
+export default useDebouncePlugin;

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useLoadingDelayPlugin: Plugin<any, any[]>;
+export default useLoadingDelayPlugin;

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const usePollingPlugin: Plugin<any, any[]>;
+export default usePollingPlugin;

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useRefreshOnWindowFocusPlugin: Plugin<any, any[]>;
+export default useRefreshOnWindowFocusPlugin;

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useRetryPlugin: Plugin<any, any[]>;
+export default useRetryPlugin;

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

@@ -0,0 +1,3 @@
+import type { Plugin } from '../types';
+declare const useThrottlePlugin: Plugin<any, any[]>;
+export default useThrottlePlugin;

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

@@ -0,0 +1,73 @@
+import type { DependencyList } from 'react';
+import type Fetch from './Fetch';
+import type { CachedData } from './utils/cache';
+export type Service<TData, TParams extends any[]> = (...args: TParams) => Promise<TData>;
+export type Subscribe = () => void;
+export interface FetchState<TData, TParams extends any[]> {
+    loading: boolean;
+    params?: TParams;
+    data?: TData;
+    error?: Error;
+}
+export interface PluginReturn<TData, TParams extends any[]> {
+    onBefore?: (params: TParams) => ({
+        stopNow?: boolean;
+        returnNow?: boolean;
+    } & Partial<FetchState<TData, TParams>>) | void;
+    onRequest?: (service: Service<TData, TParams>, params: TParams) => {
+        servicePromise?: Promise<TData>;
+    };
+    onSuccess?: (data: TData, params: TParams) => void;
+    onError?: (e: Error, params: TParams) => void;
+    onFinally?: (params: TParams, data?: TData, e?: Error) => void;
+    onCancel?: () => void;
+    onMutate?: (data: TData) => void;
+}
+export interface Options<TData, TParams extends any[]> {
+    manual?: boolean;
+    onBefore?: (params: TParams) => void;
+    onSuccess?: (data: TData, params: TParams) => void;
+    onError?: (e: Error, params: TParams) => void;
+    onFinally?: (params: TParams, data?: TData, e?: Error) => void;
+    defaultParams?: TParams;
+    refreshDeps?: DependencyList;
+    refreshDepsAction?: () => void;
+    loadingDelay?: number;
+    pollingInterval?: number;
+    pollingWhenHidden?: boolean;
+    pollingErrorRetryCount?: number;
+    refreshOnWindowFocus?: boolean;
+    focusTimespan?: number;
+    debounceWait?: number;
+    debounceLeading?: boolean;
+    debounceTrailing?: boolean;
+    debounceMaxWait?: number;
+    throttleWait?: number;
+    throttleLeading?: boolean;
+    throttleTrailing?: boolean;
+    cacheKey?: string;
+    cacheTime?: number;
+    staleTime?: number;
+    setCache?: (data: CachedData<TData, TParams>) => void;
+    getCache?: (params: TParams) => CachedData<TData, TParams> | undefined;
+    retryCount?: number;
+    retryInterval?: number;
+    ready?: boolean;
+}
+export type Plugin<TData, TParams extends any[]> = {
+    (fetchInstance: Fetch<TData, TParams>, options: Options<TData, TParams>): PluginReturn<TData, TParams>;
+    onInit?: (options: Options<TData, TParams>) => Partial<FetchState<TData, TParams>>;
+};
+export interface Result<TData, TParams extends any[]> {
+    loading: boolean;
+    data?: TData;
+    error?: Error;
+    params: TParams | [];
+    cancel: Fetch<TData, TParams>['cancel'];
+    refresh: Fetch<TData, TParams>['refresh'];
+    refreshAsync: Fetch<TData, TParams>['refreshAsync'];
+    run: Fetch<TData, TParams>['run'];
+    runAsync: Fetch<TData, TParams>['runAsync'];
+    mutate: Fetch<TData, TParams>['mutate'];
+}
+export type Timeout = ReturnType<typeof setTimeout>;

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

@@ -0,0 +1,3 @@
+import type { Options, Plugin, Service } from './types';
+declare function useRequest<TData, TParams extends any[]>(service: Service<TData, TParams>, options?: Options<TData, TParams>, plugins?: Plugin<TData, TParams>[]): import("./types").Result<TData, TParams>;
+export default useRequest;

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

@@ -0,0 +1,3 @@
+import type { Options, Plugin, Result, Service } from './types';
+declare function useRequestImplement<TData, TParams extends any[]>(service: Service<TData, TParams>, options?: Options<TData, TParams>, plugins?: Plugin<TData, TParams>[]): Result<TData, TParams>;
+export default useRequestImplement;

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

@@ -0,0 +1,14 @@
+type Timer = ReturnType<typeof setTimeout>;
+type CachedKey = string | number;
+export interface CachedData<TData = any, TParams = any> {
+    data: TData;
+    params: TParams;
+    time: number;
+}
+interface RecordData extends CachedData {
+    timer: Timer | undefined;
+}
+declare const setCache: (key: CachedKey, cacheTime: number, cachedData: CachedData) => void;
+declare const getCache: (key: CachedKey) => RecordData | undefined;
+declare const clearCache: (key?: string | string[]) => void;
+export { getCache, setCache, clearCache };

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

@@ -0,0 +1,4 @@
+type CachedKey = string | number;
+declare const getCachePromise: (cacheKey: CachedKey) => Promise<any> | undefined;
+declare const setCachePromise: (cacheKey: CachedKey, promise: Promise<any>) => void;
+export { getCachePromise, setCachePromise };

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

@@ -0,0 +1,4 @@
+type Listener = (data: any) => void;
+declare const trigger: (key: string, data: any) => void;
+declare const subscribe: (key: string, listener: Listener) => () => void;
+export { trigger, subscribe };

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

@@ -0,0 +1 @@
+export default function isDocumentVisible(): boolean;

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

@@ -0,0 +1,2 @@
+declare const isOnline: () => boolean;
+export default isOnline;

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

@@ -0,0 +1 @@
+export default function limit(fn: any, timespan: number): (...args: any[]) => void;

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

@@ -0,0 +1,3 @@
+type Listener = () => void;
+declare function subscribe(listener: Listener): () => void;
+export default subscribe;

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

@@ -0,0 +1,3 @@
+type Listener = () => void;
+declare function subscribe(listener: Listener): () => void;
+export default subscribe;

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

@@ -0,0 +1,4 @@
+import type { Dispatch, SetStateAction } from 'react';
+type ResetState = () => void;
+declare const useResetState: <S>(initialState: S | (() => S)) => [S, Dispatch<SetStateAction<S>>, ResetState];
+export default useResetState;

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

@@ -0,0 +1,5 @@
+type ResponsiveConfig = Record<string, number>;
+type ResponsiveInfo = Record<string, boolean>;
+export declare function configResponsive(config: ResponsiveConfig): void;
+declare function useResponsive(): ResponsiveInfo;
+export default useResponsive;

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

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

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

@@ -0,0 +1,9 @@
+import type { BasicTarget } from '../utils/domTarget';
+type Position = {
+    left: number;
+    top: number;
+};
+export type Target = BasicTarget<Element | Document>;
+export type ScrollListenController = (val: Position) => boolean;
+declare function useScroll(target?: Target, shouldUpdate?: ScrollListenController): Position | undefined;
+export default useScroll;

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

@@ -0,0 +1,21 @@
+import React from 'react';
+export interface Options<T> {
+    defaultSelected?: T[];
+    itemKey?: string | ((item: T) => React.Key);
+}
+declare function useSelections<T>(items: T[], options?: T[] | Options<T>): {
+    readonly selected: T[];
+    readonly noneSelected: boolean;
+    readonly allSelected: boolean;
+    readonly partiallySelected: boolean;
+    readonly setSelected: React.Dispatch<React.SetStateAction<T[]>>;
+    readonly isSelected: (item: T) => boolean;
+    readonly select: (this: unknown, item: T) => void;
+    readonly unSelect: (this: unknown, item: T) => void;
+    readonly toggle: (this: unknown, item: T) => void;
+    readonly selectAll: (this: unknown) => void;
+    readonly unSelectAll: (this: unknown) => void;
+    readonly clearAll: (this: unknown) => void;
+    readonly toggleAll: (this: unknown) => void;
+};
+export default useSelections;

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

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

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

@@ -0,0 +1,6 @@
+declare function useSet<K>(initialValue?: Iterable<K>): readonly [Set<K>, {
+    readonly add: (this: unknown, key: K) => void;
+    readonly remove: (this: unknown, key: K) => void;
+    readonly reset: (this: unknown) => void;
+}];
+export default useSet;

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

@@ -0,0 +1,3 @@
+export type SetState<S extends Record<string, any>> = <K extends keyof S>(state: Pick<S, K> | null | ((prevState: Readonly<S>) => Pick<S, K> | S | null)) => void;
+declare const useSetState: <S extends Record<string, any>>(initialState: S | (() => S)) => [S, SetState<S>];
+export default useSetState;

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

@@ -0,0 +1,7 @@
+import type { BasicTarget } from '../utils/domTarget';
+type Size = {
+    width: number;
+    height: number;
+};
+declare function useSize(target: BasicTarget): Size | undefined;
+export default useSize;

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

@@ -0,0 +1,14 @@
+import type { BasicTarget } from '../utils/domTarget';
+interface Rect {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+    height: number;
+    width: number;
+}
+export interface State extends Rect {
+    text: string;
+}
+declare function useTextSelection(target?: BasicTarget<Document | Element>): State;
+export default useTextSelection;

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

@@ -0,0 +1,16 @@
+export declare enum ThemeMode {
+    LIGHT = "light",
+    DARK = "dark",
+    SYSTEM = "system"
+}
+export type ThemeModeType = `${ThemeMode}`;
+export type ThemeType = 'light' | 'dark';
+type Options = {
+    localStorageKey?: string;
+};
+export default function useTheme(options?: Options): {
+    theme: ThemeType;
+    themeMode: "light" | "dark" | "system";
+    setThemeMode: (this: unknown, mode: "light" | "dark" | "system") => void;
+};
+export {};

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

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

package/types/common/hooks/src/use-throttle/throttleOptions.d.ts

@@ -0,0 +1,5 @@
+export interface ThrottleOptions {
+    wait?: number;
+    leading?: boolean;
+    trailing?: boolean;
+}

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

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

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

@@ -0,0 +1,8 @@
+import type { ThrottleOptions } from '../use-throttle/throttleOptions';
+type noop = (...args: any[]) => any;
+declare function useThrottleFn<T extends noop>(fn: T, options?: ThrottleOptions): {
+    run: import("lodash").DebouncedFuncLeading<(...args: Parameters<T>) => ReturnType<T>>;
+    cancel: () => void;
+    flush: () => ReturnType<T>;
+};
+export default useThrottleFn;

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

@@ -0,0 +1,2 @@
+declare const useTimeout: (fn: () => void, delay?: number) => () => void;
+export default useTimeout;

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

@@ -0,0 +1,5 @@
+export interface Options {
+    restoreOnUnmount?: boolean;
+}
+declare function useTitle(title: string, options?: Options): void;
+export default useTitle;

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

@@ -0,0 +1,10 @@
+export interface Actions<T> {
+    setLeft: () => void;
+    setRight: () => void;
+    set: (value: T) => void;
+    toggle: () => void;
+}
+declare function useToggle<T = boolean>(): [boolean, Actions<T>];
+declare function useToggle<T>(defaultValue: T): [T, Actions<T>];
+declare function useToggle<T, U>(defaultValue: T, reverseValue: U): [T | U, Actions<T | U>];
+export default useToggle;

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

@@ -0,0 +1,4 @@
+import type { DependencyList } from 'react';
+type Effect<T extends DependencyList> = (changes?: number[], previousDeps?: T, currentDeps?: T) => void | (() => void);
+declare const useTrackedEffect: <T extends DependencyList>(effect: Effect<T>, deps?: [...T]) => void;
+export default useTrackedEffect;

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

@@ -0,0 +1,2 @@
+declare const useUnmount: (fn: () => void) => void;
+export default useUnmount;

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

@@ -0,0 +1,2 @@
+declare const useUnmountedRef: () => import("react").RefObject<boolean>;
+export default useUnmountedRef;

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

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

package/types/common/hooks/src/use-update-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-update-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-url-state/index.d.ts

@@ -0,0 +1,10 @@
+import type { ParseOptions, StringifyOptions } from '@unicom-cloud/utils/query-string';
+import React from 'react';
+export interface Options {
+    navigateMode?: 'push' | 'replace';
+    parseOptions?: ParseOptions;
+    stringifyOptions?: StringifyOptions;
+}
+type UrlState = Record<string, any>;
+declare const useUrlState: <S extends UrlState = UrlState>(initialState?: S | (() => S), options?: Options) => readonly [Partial<{ [key in keyof S]: Required<S>[key] extends any[] ? string[] : string; }>, (this: unknown, s: React.SetStateAction<Partial<{ [key in keyof S]: Required<S>[key] extends any[] ? string[] : string; }>>) => void];
+export default useUrlState;

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

@@ -0,0 +1,13 @@
+import type { BasicTarget } from '../utils/domTarget';
+type ItemHeight<T> = (index: number, data: T) => number;
+export interface Options<T> {
+    containerTarget: BasicTarget;
+    wrapperTarget: BasicTarget;
+    itemHeight: number | ItemHeight<T>;
+    overscan?: number;
+}
+declare const useVirtualList: <T = any>(list: T[], options: Options<T>) => readonly [{
+    index: number;
+    data: T;
+}[], (this: unknown, index: number) => void];
+export default useVirtualList;

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

@@ -0,0 +1,26 @@
+export declare enum ReadyState {
+    Connecting = 0,
+    Open = 1,
+    Closing = 2,
+    Closed = 3
+}
+export interface Options {
+    reconnectLimit?: number;
+    reconnectInterval?: number;
+    manual?: boolean;
+    onOpen?: (event: WebSocketEventMap['open'], instance: WebSocket) => void;
+    onClose?: (event: WebSocketEventMap['close'], instance: WebSocket) => void;
+    onMessage?: (message: WebSocketEventMap['message'], instance: WebSocket) => void;
+    onError?: (event: WebSocketEventMap['error'], instance: WebSocket) => void;
+    protocols?: string | string[];
+}
+export interface Result {
+    latestMessage?: WebSocketEventMap['message'];
+    sendMessage: WebSocket['send'];
+    disconnect: () => void;
+    connect: () => void;
+    readyState: ReadyState;
+    webSocketIns?: WebSocket;
+}
+declare function useWebSocket(socketUrl: string, options?: Options): Result;
+export default useWebSocket;

package/types/common/hooks/src/use-why-did-you-update/index.d.ts

@@ -0,0 +1,3 @@
+export type IProps = Record<string, any>;
+declare function useWhyDidYouUpdate(componentName: string, props: IProps): void;
+export default useWhyDidYouUpdate;

package/types/common/hooks/src/utils/createEffectWithTarget.d.ts

@@ -0,0 +1,4 @@
+import type { DependencyList, EffectCallback, useEffect, useLayoutEffect } from 'react';
+import type { BasicTarget } from './domTarget';
+declare const createEffectWithTarget: (useEffectType: typeof useEffect | typeof useLayoutEffect) => (effect: EffectCallback, deps: DependencyList, target: BasicTarget<any> | BasicTarget<any>[]) => void;
+export default createEffectWithTarget;

package/types/common/hooks/src/utils/depsAreSame.d.ts

@@ -0,0 +1,3 @@
+import type { DependencyList } from 'react';
+declare function depsAreSame(oldDeps: DependencyList, deps: DependencyList): boolean;
+export default depsAreSame;

package/types/common/hooks/src/utils/depsEqual.d.ts

@@ -0,0 +1,2 @@
+import type { DependencyList } from 'react';
+export declare const depsEqual: (aDeps?: DependencyList, bDeps?: DependencyList) => boolean;

package/types/common/hooks/src/utils/domTarget.d.ts

@@ -0,0 +1,6 @@
+import type { RefObject } from 'react';
+type TargetValue<T> = T | undefined | null;
+type TargetType = HTMLElement | Element | Window | Document;
+export type BasicTarget<T extends TargetType = Element> = (() => TargetValue<T>) | TargetValue<T> | RefObject<TargetValue<T>>;
+export declare function getTargetElement<T extends TargetType>(target: BasicTarget<T>, defaultElement?: T): TargetValue<T>;
+export default getTargetElement;

package/types/common/hooks/src/utils/getDocumentOrShadow.d.ts

@@ -0,0 +1,3 @@
+import type { BasicTarget } from '../utils/domTarget';
+declare const getDocumentOrShadow: (target: BasicTarget | BasicTarget[]) => Document | Node;
+export default getDocumentOrShadow;

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

@@ -0,0 +1 @@
+export { isBoolean, isFunction, isNumber, isObject, isString, isUndefined, } from '../../../utils/is';

package/types/common/hooks/src/utils/isAppleDevice.d.ts

@@ -0,0 +1,2 @@
+import { isAppleDevice } from '@unicom-cloud/utils/constant/platform';
+export default isAppleDevice;

package/types/common/hooks/src/utils/isBrowser.d.ts

@@ -0,0 +1,2 @@
+declare const isBrowser: boolean;
+export default isBrowser;

package/types/common/hooks/src/utils/isDev.d.ts

@@ -0,0 +1,2 @@
+declare const isDev: boolean;
+export default isDev;

package/types/common/hooks/src/utils/rect.d.ts

@@ -0,0 +1,4 @@
+declare const getScrollTop: (el: Document | Element) => number;
+declare const getScrollHeight: (el: Document | Element) => number;
+declare const getClientHeight: (el: Document | Element) => number;
+export { getScrollTop, getScrollHeight, getClientHeight };

package/types/common/hooks/src/utils/useDeepCompareWithTarget.d.ts

@@ -0,0 +1,4 @@
+import type { DependencyList, EffectCallback } from 'react';
+import type { BasicTarget } from './domTarget';
+declare const useDeepCompareEffectWithTarget: (effect: EffectCallback, deps: DependencyList, target: BasicTarget<any> | BasicTarget<any>[]) => void;
+export default useDeepCompareEffectWithTarget;

package/types/common/hooks/src/utils/useEffectWithTarget.d.ts

@@ -0,0 +1,2 @@
+declare const useEffectWithTarget: (effect: import("react").EffectCallback, deps: import("react").DependencyList, target: import("./domTarget").BasicTarget<any> | import("./domTarget").BasicTarget<any>[]) => void;
+export default useEffectWithTarget;

package/types/common/hooks/src/utils/useIsomorphicLayoutEffectWithTarget.d.ts

@@ -0,0 +1,2 @@
+declare const useIsomorphicLayoutEffectWithTarget: (effect: import("react").EffectCallback, deps: import("react").DependencyList, target: import("./domTarget").BasicTarget<any> | import("./domTarget").BasicTarget<any>[]) => void;
+export default useIsomorphicLayoutEffectWithTarget;

package/types/common/hooks/src/utils/useLayoutEffectWithTarget.d.ts

@@ -0,0 +1,2 @@
+declare const useEffectWithTarget: (effect: import("react").EffectCallback, deps: import("react").DependencyList, target: import("./domTarget").BasicTarget<any> | import("./domTarget").BasicTarget<any>[]) => void;
+export default useEffectWithTarget;

package/types/common/hooks/useForceUpdate.d.ts

@@ -1,3 +1,4 @@
+import useForceUpdate from './src/use-update';
 /**
  * 手动触发一次组件的rerender
  * @desc {en} Manually trigger the rerender of the component once
@@ -12,5 +13,4 @@
  * }
  * ```
  */
-declare function useForceUpdate(): import("react").DispatchWithoutAction;
 export default useForceUpdate;

package/types/common/hooks/useInterval.d.ts

@@ -1,2 +1 @@
-declare function useInterval(callback: Function, delay: null | number): () => void;
-export default useInterval;
+export { default } from './src/use-interval';

package/types/common/hooks/useMergeProps.d.ts

@@ -1,5 +1,5 @@
 export interface MergePropsOptions {
     _ignorePropsFromGlobal?: boolean;
 }
-declare function useMergeProps<PropsType extends Record<string, any>>(componentProps: PropsType & MergePropsOptions, defaultProps: Partial<PropsType>, globalComponentConfig?: Partial<PropsType> | undefined): PropsType;
+declare function useMergeProps<T>(componentProps: T & MergePropsOptions, defaultProps: Partial<T>, globalComponentConfig?: Partial<T> | undefined): T;
 export default useMergeProps;