taro-uno-ui 0.9.0-beta → 1.0.0

package/dist/hooks/useCounter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * useCounter Hook
+ * Manage counter state with increment, decrement, and reset
+ *
+ * @example
+ * ```typescript
+ * const { count, increment, decrement, reset, set } = useCounter(0, { min: 0, max: 100 });
+ * increment(); // 1
+ * increment(5); // 6
+ * decrement(3); // 3
+ * ```
+ */
+export interface UseCounterOptions {
+    /** Minimum allowed value */
+    min?: number;
+    /** Maximum allowed value */
+    max?: number;
+    /** Step size for increment/decrement */
+    step?: number;
+}
+export interface UseCounterReturn {
+    /** Current count value */
+    count: number;
+    /** Increment count */
+    increment: (step?: number) => void;
+    /** Decrement count */
+    decrement: (step?: number) => void;
+    /** Reset to initial value */
+    reset: () => void;
+    /** Set to specific value */
+    set: (value: number) => void;
+}
+/**
+ * Hook for managing counter state with constraints
+ */
+export declare function useCounter(initialValue?: number, options?: UseCounterOptions): UseCounterReturn;

package/dist/hooks/useDebounce.d.ts

@@ -0,0 +1,31 @@
+/**
+ * useDebounce & useThrottle Hooks
+ * Delay value updates or limit function call frequency
+ *
+ * @example
+ * ```typescript
+ * // Debounce - delays until user stops typing
+ * const debouncedSearch = useDebounce(searchTerm, 500);
+ *
+ * // Throttle - limits calls to once per interval
+ * const throttledScroll = useThrottle(scrollY, 100);
+ * ```
+ */
+/**
+ * Hook for debouncing a value
+ * Updates only after the value stops changing for the specified delay
+ */
+export declare function useDebounce<T>(value: T, delay?: number): T;
+/**
+ * Hook for throttling a value
+ * Updates at most once per interval
+ */
+export declare function useThrottle<T>(value: T, interval?: number): T;
+/**
+ * Hook for debouncing a callback function
+ */
+export declare function useDebouncedCallback<T extends (...args: any[]) => any>(callback: T, delay?: number): (...args: Parameters<T>) => void;
+/**
+ * Hook for throttling a callback function
+ */
+export declare function useThrottledCallback<T extends (...args: any[]) => any>(callback: T, interval?: number): (...args: Parameters<T>) => void;

package/dist/hooks/useDeepCompareEffect.d.ts

@@ -0,0 +1,22 @@
+/**
+ * useDeepCompareEffect Hook
+ * Effect hook with deep comparison of dependencies
+ *
+ * @example
+ * ```typescript
+ * const [user, setUser] = useState({ name: 'John', age: 30 });
+ *
+ * useDeepCompareEffect(() => {
+ *   console.log('User changed:', user);
+ *   // This effect will only run when the actual content of user changes, not on every render
+ * }, [user]);
+ * ```
+ */
+/**
+ * Hook for deep comparison effect
+ */
+export declare function useDeepCompareEffect(callback: React.EffectCallback, dependencies: any[]): void;
+/**
+ * Hook for deep comparison layout effect
+ */
+export declare function useDeepCompareLayoutEffect(callback: React.EffectCallback, dependencies: any[]): void;

package/dist/hooks/useEventHandling.d.ts

@@ -0,0 +1,81 @@
+/**
+ * 事件处理相关的自定义hooks
+ * 提供通用的事件处理逻辑，包括防抖、节流、点击处理等
+ */
+import type { ITouchEvent } from '@tarojs/components';
+interface DebounceOptions {
+    delay?: number;
+    leading?: boolean;
+    trailing?: boolean;
+}
+/** 防抖事件处理hook */
+export declare function useDebounce<T extends (...args: unknown[]) => unknown>(callback: T, options?: DebounceOptions): T & {
+    cancel: () => void;
+};
+interface ThrottleOptions {
+    delay?: number;
+    leading?: boolean;
+    trailing?: boolean;
+}
+/** 节流事件处理hook */
+export declare function useThrottle<T extends (...args: unknown[]) => unknown>(callback: T, options?: ThrottleOptions): T & {
+    cancel: () => void;
+};
+interface ClickOptions {
+    disabled?: boolean;
+    stopPropagation?: boolean;
+    preventDefault?: boolean;
+    debounceTime?: number;
+    throttleTime?: number;
+    doubleClickDelay?: number;
+}
+/** 点击事件处理hook */
+export declare function useClickHandler(onClick?: (event: ITouchEvent) => void, options?: ClickOptions): ((event: ITouchEvent) => void) | (((...args: unknown[]) => unknown) & {
+    cancel: () => void;
+});
+interface LongPressOptions {
+    delay?: number;
+    moveThreshold?: number;
+    onLongPress?: (event: ITouchEvent) => void;
+    onLongPressEnd?: (event: ITouchEvent) => void;
+}
+/** 长按事件处理hook */
+export declare function useLongPress(options?: LongPressOptions): {
+    onTouchStart: (event: ITouchEvent) => void;
+    onTouchMove: (event: ITouchEvent) => void;
+    onTouchEnd: (event: ITouchEvent) => void;
+};
+interface DragOptions {
+    onDragStart?: (event: ITouchEvent) => void;
+    onDragMove?: (event: ITouchEvent, delta: {
+        x: number;
+        y: number;
+    }) => void;
+    onDragEnd?: (event: ITouchEvent) => void;
+    threshold?: number;
+}
+/** 拖拽事件处理hook */
+export declare function useDrag(options?: DragOptions): {
+    onTouchStart: (event: ITouchEvent) => void;
+    onTouchMove: (event: ITouchEvent) => void;
+    onTouchEnd: (event: ITouchEvent) => void;
+};
+interface KeyboardOptions {
+    key?: string;
+    keyCode?: number;
+    ctrlKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+    preventDefault?: boolean;
+    stopPropagation?: boolean;
+}
+/** 键盘事件处理hook */
+export declare function useKeyboard(onKeyPress?: (event: KeyboardEvent) => void, options?: KeyboardOptions): void;
+interface EventDelegateOptions {
+    selector?: string;
+    filter?: (element: Element) => boolean;
+}
+/** 事件委托hook */
+export declare function useEventDelegate<T extends keyof DocumentEventMap>(eventType: T, handler: (event: DocumentEventMap[T]) => void, options?: EventDelegateOptions): void;
+export {};

package/dist/hooks/useEventListener.d.ts

@@ -0,0 +1,19 @@
+/**
+ * useEventListener Hook
+ * Simplified event listener management with automatic cleanup
+ *
+ * @example
+ * ```typescript
+ * const handleResize = (event: Event) => {
+ *   console.log('Window resized:', window.innerWidth, window.innerHeight);
+ * };
+ *
+ * useEventListener('resize', handleResize, window);
+ * ```
+ */
+/**
+ * Hook for simplified event listener management
+ */
+export declare function useEventListener<K extends keyof WindowEventMap>(eventName: K, handler: (event: WindowEventMap[K]) => void, element?: Window, options?: boolean | AddEventListenerOptions): void;
+export declare function useEventListener<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, element?: Document, options?: boolean | AddEventListenerOptions): void;
+export declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement>(eventName: K, handler: (event: HTMLElementEventMap[K]) => void, element?: T, options?: boolean | AddEventListenerOptions): void;

package/dist/hooks/useLifecycle.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 生命周期管理相关的自定义hooks
+ * 提供通用的生命周期管理逻辑，包括组件挂载、卸载、副作用处理等
+ */
+/** 组件挂载状态hook */
+export declare function useMounted(): boolean;
+interface LifecycleOptions {
+    onMount?: () => void | (() => void);
+    onUnmount?: () => void;
+}
+/** 组件生命周期hook */
+export declare function useLifecycle(options?: LifecycleOptions): void;
+/** 一次性执行hook */
+export declare function useOnce(callback: () => void | (() => void), dependencies?: unknown[]): void;
+/** 条件执行hook */
+export declare function useConditionalEffect(callback: () => void | (() => void), condition: boolean, dependencies?: unknown[]): void;
+interface AsyncEffectOptions<T> {
+    onError?: (error: Error) => void;
+    onSuccess?: (result: T) => void;
+}
+/** 异步副作用hook */
+export declare function useAsyncEffect<T>(asyncCallback: () => Promise<T> | (() => Promise<T>), options?: AsyncEffectOptions<T>, dependencies?: unknown[]): void;
+interface TimerOptions {
+    immediate?: boolean;
+}
+/** 定时器hook */
+export declare function useTimer(callback: () => void, delay: number, options?: TimerOptions): {
+    start: () => void;
+    stop: () => void;
+    reset: () => void;
+    isActive: boolean;
+};
+/** 延迟执行hook */
+export declare function useDelay<T>(callback: () => T, delay: number, dependencies?: any[]): {
+    result: T | null;
+    loading: boolean;
+};
+interface NetworkState {
+    online: boolean;
+    offline: boolean;
+    effectiveType?: string;
+    downlink?: number;
+    rtt?: number;
+}
+/** 网络状态监听hook */
+export declare function useNetworkState(): NetworkState;
+/** 页面可见性监听hook */
+export declare function usePageVisibility(): boolean;
+interface WindowSize {
+    width: number;
+    height: number;
+}
+/** 窗口大小监听hook */
+export declare function useWindowSize(): WindowSize;
+interface ScrollPosition {
+    x: number;
+    y: number;
+}
+/** 滚动位置监听hook */
+export declare function useScrollPosition(): ScrollPosition;
+interface MediaQueryOptions {
+    defaultMatches?: boolean;
+}
+/** 媒体查询监听hook */
+export declare function useMediaQuery(query: string, options?: MediaQueryOptions): boolean;
+export {};

package/dist/hooks/useMediaQuery.d.ts

@@ -0,0 +1,22 @@
+/**
+ * useMediaQuery Hook
+ * Track media query matches for responsive design
+ *
+ * @example
+ * ```typescript
+ * const isMobile = useMediaQuery('(max-width: 768px)');
+ * const isDark = useMediaQuery('(prefers-color-scheme: dark)');
+ * ```
+ */
+/**
+ * Hook for tracking media query matches
+ */
+export declare function useMediaQuery(query: string): boolean;
+/**
+ * Predefined breakpoint hooks
+ */
+export declare function useIsMobile(): boolean;
+export declare function useIsTablet(): boolean;
+export declare function useIsDesktop(): boolean;
+export declare function usePrefersDarkMode(): boolean;
+export declare function usePrefersReducedMotion(): boolean;

package/dist/hooks/useMutation.d.ts

@@ -0,0 +1,47 @@
+/**
+ * useMutation Hook
+ * React hook for data mutation operations (POST, PUT, DELETE, PATCH)
+ *
+ * @example
+ * ```typescript
+ * const { mutate, loading, error } = useMutation<User, CreateUserInput>({
+ *   url: '/api/users',
+ *   method: 'POST',
+ *   onSuccess: (data) => {
+ *     console.log('User created:', data);
+ *   },
+ * });
+ *
+ * // Trigger mutation
+ * await mutate({ name: 'John Doe', email: 'john@example.com' });
+ * ```
+ */
+import type { RequestOptions, UseMutationOptions, MutationState } from '../utils/http/types';
+export interface UseMutationResult<T, V = any> extends MutationState<T, V> {
+    /** Execute mutation */
+    mutate: (variables: V, options?: Partial<RequestOptions>) => Promise<T | undefined>;
+    /** Execute mutation (async version) */
+    mutateAsync: (variables: V, options?: Partial<RequestOptions>) => Promise<T>;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Hook for mutation operations (POST, PUT, DELETE, PATCH)
+ */
+export declare function useMutation<T = any, V = any>(options: RequestOptions & UseMutationOptions<T, V>): UseMutationResult<T, V>;
+/**
+ * Hook for POST mutations
+ */
+export declare function usePost<T = any, V = any>(url: string, options?: Omit<UseMutationOptions<T, V>, 'url' | 'method'>): UseMutationResult<T, V>;
+/**
+ * Hook for PUT mutations
+ */
+export declare function usePut<T = any, V = any>(url: string, options?: Omit<UseMutationOptions<T, V>, 'url' | 'method'>): UseMutationResult<T, V>;
+/**
+ * Hook for PATCH mutations
+ */
+export declare function usePatch<T = any, V = any>(url: string, options?: Omit<UseMutationOptions<T, V>, 'url' | 'method'>): UseMutationResult<T, V>;
+/**
+ * Hook for DELETE mutations
+ */
+export declare function useDelete<T = any, V = any>(url: string, options?: Omit<UseMutationOptions<T, V>, 'url' | 'method'>): UseMutationResult<T, V>;

package/dist/hooks/usePerformance.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 性能优化相关的自定义hooks
+ * 提供通用的性能优化逻辑，包括缓存、记忆化、虚拟化等
+ */
+interface MemoizationOptions {
+    maxSize?: number;
+    ttl?: number;
+}
+/** 函数记忆化hook */
+export declare function useMemoizedFunction<T extends (...args: unknown[]) => unknown>(fn: T, options?: MemoizationOptions): T;
+interface CacheOptions<_T> {
+    key?: string;
+    ttl?: number;
+    deps?: unknown[];
+}
+/** 计算结果缓存hook */
+export declare function useComputedCache<T>(compute: () => T, options?: CacheOptions<T>): T;
+interface VirtualListOptions {
+    itemHeight: number;
+    overscanCount?: number;
+    containerHeight: number;
+}
+/** 虚拟列表hook */
+export declare function useVirtualList<T>(items: T[], options: VirtualListOptions): {
+    visibleItems: T[];
+    offsetY: number;
+    totalHeight: number;
+    handleScroll: (event: React.UIEvent<HTMLDivElement>) => void;
+    visibleRange: {
+        startIndex: number;
+        endIndex: number;
+    };
+};
+interface LazyLoadOptions {
+    threshold?: number;
+    rootMargin?: string;
+    triggerOnce?: boolean;
+}
+/** 懒加载hook */
+export declare function useLazyLoad(elementRef: React.RefObject<Element>, options?: LazyLoadOptions): {
+    isVisible: boolean;
+    hasLoaded: boolean;
+};
+interface RequestCacheOptions {
+    ttl?: number;
+    dedupe?: boolean;
+}
+/** 请求防抖缓存hook */
+export declare function useRequestCache<T, P extends unknown[]>(requestFn: (...params: P) => Promise<T>, options?: RequestCacheOptions): {
+    execute: (...params: P) => Promise<T>;
+    loading: boolean;
+    error: Error | null;
+    clearCache: () => void;
+};
+interface BatchUpdateOptions {
+    delay?: number;
+    maxSize?: number;
+}
+/** 批量更新优化hook */
+export declare function useBatchUpdate<T>(onUpdate: (items: T[]) => void, options?: BatchUpdateOptions): {
+    addItem: (item: T) => void;
+    flushBatch: () => void;
+};
+interface PriorityUpdateOptions {
+    highPriorityDelay?: number;
+    lowPriorityDelay?: number;
+}
+/** 优先级更新管理hook */
+export declare function usePriorityUpdates<T>(highPriorityUpdate: (value: T) => void, lowPriorityUpdate: (value: T) => void, options?: PriorityUpdateOptions): {
+    addHighPriority: (value: T) => void;
+    addLowPriority: (value: T) => void;
+};
+export {};

package/dist/hooks/usePerformanceMonitor.d.ts

@@ -0,0 +1,66 @@
+/**
+ * 性能监控 Hook
+ * 用于监控组件性能指标
+ */
+export interface PerformanceMetrics {
+    renderTime: number;
+    renderCount: number;
+    lastRenderTime: number;
+    memoryUsage?: {
+        used: number;
+        total: number;
+        percentage: number;
+    };
+    loadTime?: number;
+    resourceLoadTimes?: Array<{
+        name: string;
+        duration: number;
+        size?: number;
+    }>;
+    interactionTime?: number;
+    firstInputDelay?: number;
+    customMetrics?: Record<string, number>;
+}
+export interface PerformanceMonitorOptions {
+    enableRenderMonitor?: boolean;
+    enableMemoryMonitor?: boolean;
+    enableNetworkMonitor?: boolean;
+    enableInteractionMonitor?: boolean;
+    thresholds?: {
+        renderTime?: number;
+        memoryUsage?: number;
+        interactionTime?: number;
+    };
+    onPerformanceWarning?: (metrics: PerformanceMetrics) => void;
+    onPerformanceUpdate?: (metrics: PerformanceMetrics) => void;
+    onCriticalPerformanceIssue?: (metrics: PerformanceMetrics) => void;
+}
+/**
+ * 性能监控 Hook
+ * @param options 监控选项
+ * @returns 性能指标和控制函数
+ */
+export declare function usePerformanceMonitor(options?: PerformanceMonitorOptions): {
+    metrics: PerformanceMetrics;
+    monitorRenderPerformance: () => void;
+    completeRenderMonitoring: () => void;
+    recordCustomMetric: (name: string, value: number) => void;
+    startMonitoring: () => () => void;
+    stopMonitoring: () => void;
+    resetMetrics: () => void;
+    getPerformanceReport: () => {
+        timestamp: string;
+        metrics: PerformanceMetrics;
+        summary: {
+            renderPerformance: string;
+            memoryUsage: string;
+            interactionPerformance: string;
+        };
+        recommendations: {
+            type: string;
+            issue: string;
+            suggestion: string;
+        }[];
+    };
+};
+export default usePerformanceMonitor;

package/dist/hooks/usePlatform.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 获取当前平台信息
+ * @returns 当前平台类型
+ */
+export declare const usePlatform: () => string;
+/**
+ * 检查是否为H5平台
+ * @returns 是否为H5平台
+ */
+export declare const useIsH5: () => boolean;
+/**
+ * 检查是否为小程序平台
+ * @returns 是否为小程序平台
+ */
+export declare const useIsMiniProgram: () => boolean;
+/**
+ * 检查是否为React Native平台
+ * @returns 是否为React Native平台
+ */
+export declare const useIsReactNative: () => boolean;

package/dist/hooks/usePrevious.d.ts

@@ -0,0 +1,14 @@
+/**
+ * usePrevious Hook
+ * Get the previous value of a variable from the last render
+ *
+ * @example
+ * ```typescript
+ * const [count, setCount] = useState(0);
+ * const prevCount = usePrevious(count); // Get the previous count value
+ * ```
+ */
+/**
+ * Hook for getting the previous value of a variable from the last render
+ */
+export declare function usePrevious<T>(value: T): T | undefined;

package/dist/hooks/useRequest.d.ts

@@ -0,0 +1,32 @@
+import { Request } from '@/utils/http/request';
+import type { RequestOptions as UnifiedRequestOptions } from '@/utils/http/types';
+export interface UseRequestOptions<T = unknown> {
+    client?: Request;
+    service?: ((client: Request) => Promise<T>) | string;
+    method?: UnifiedRequestOptions['method'];
+    params?: Record<string, unknown>;
+    data?: unknown;
+    manual?: boolean;
+    enabled?: boolean;
+    cacheKey?: string;
+    staleTime?: number;
+    retry?: number;
+    retryDelay?: number;
+    pollingInterval?: number;
+    initialData?: T;
+    onSuccess?: (data: T) => void;
+    onError?: (error: Error) => void;
+    transform?: (data: unknown) => T;
+    keepPreviousData?: boolean;
+    deps?: unknown[];
+}
+export interface UseRequestResult<T = unknown> {
+    data: T | undefined;
+    error: Error | undefined;
+    loading: boolean;
+    refetch: () => Promise<T | undefined>;
+    cancel: () => void;
+    setData: (updater: T | ((prev: T | undefined) => T)) => void;
+}
+export declare function useRequest<T = unknown>(options: UseRequestOptions<T>): UseRequestResult<T>;
+export default useRequest;

package/dist/hooks/useStateManagement.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 状态管理相关的自定义hooks
+ * 提供通用的状态管理逻辑，包括受控/非受控模式、状态同步等
+ */
+type ValidationResult = {
+    valid: boolean;
+    message?: string;
+};
+/** 受控/非受控状态管理hook */
+export declare function useControlledState<T>(value: T | undefined, defaultValue: T, onChange?: (value: T) => void): [T, (value: T) => void];
+/** 状态同步管理hook */
+export declare function useSyncedState<T>(value: T, dependencies?: unknown[]): [T, (value: T) => void];
+interface StateHistoryOptions<_T> {
+    maxSize?: number;
+    enableUndo?: boolean;
+    enableRedo?: boolean;
+}
+/** 状态历史管理hook */
+export declare function useStateHistory<T>(initialState: T, options?: StateHistoryOptions<T>): {
+    state: T;
+    setState: (newState: T) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    history: T[];
+    currentIndex: number;
+};
+/** 状态验证管理hook */
+export declare function useValidatedState<T>(initialValue: T, validator?: (value: T) => ValidationResult, options?: {
+    validateOnBlur?: boolean;
+    validateOnChange?: boolean;
+    validateOnMount?: boolean;
+}): {
+    setValue: (newValue: T) => void;
+    markAsTouched: () => void;
+    reset: () => void;
+    validate: (value: T) => ValidationResult;
+    value: T;
+    isValid: boolean;
+    error?: string;
+    isDirty: boolean;
+    isTouched: boolean;
+};
+/** 状态批量更新hook */
+export declare function useBatchStateUpdate<T extends Record<string, unknown>>(initialState: T): {
+    state: T;
+    updateField: <K extends keyof T>(field: K, value: T[K]) => void;
+    commitUpdates: () => void;
+    resetUpdates: () => void;
+};
+interface PersistenceOptions {
+    key: string;
+    storage?: 'localStorage' | 'sessionStorage';
+    serialize?: (value: unknown) => string;
+    deserialize?: (value: string) => unknown;
+}
+/** 状态持久化hook */
+export declare function usePersistentState<T>(initialValue: T, options: PersistenceOptions): readonly [T, (newValue: T) => void, () => void];
+/** 状态选择器hook */
+export declare function useStateSelector<T, R>(state: T, selector: (state: T) => R): R;
+export {};

package/dist/hooks/useStorage.d.ts

@@ -0,0 +1,27 @@
+/**
+ * useLocalStorage Hook
+ * Persist state to localStorage with automatic serialization
+ *
+ * @example
+ * ```typescript
+ * const [user, setUser, removeUser] = useLocalStorage<User>('user', null);
+ * setUser({ id: 1, name: 'John' }); // Saved to localStorage['user']
+ * removeUser(); // Clears from localStorage
+ * ```
+ */
+export interface UseStorageOptions<T> {
+    /** Custom serializer */
+    serializer?: (value: T) => string;
+    /** Custom deserializer */
+    deserializer?: (value: string) => T;
+    /** Initialize from storage on mount */
+    initializeWithValue?: boolean;
+}
+/**
+ * Hook for persisting state to localStorage
+ */
+export declare function useLocalStorage<T>(key: string, initialValue: T, options?: UseStorageOptions<T>): [T, (value: T | ((prev: T) => T)) => void, () => void];
+/**
+ * Hook for persisting state to sessionStorage
+ */
+export declare function useSessionStorage<T>(key: string, initialValue: T, options?: UseStorageOptions<T>): [T, (value: T | ((prev: T) => T)) => void, () => void];