taro-uno-ui 0.9.0 → 1.0.0

package/dist/utils/http/request-cache.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Request Cache Manager
+ * Provides intelligent request caching and deduplication
+ */
+export interface CacheConfig {
+    /** Cache time to live in milliseconds */
+    ttl?: number;
+    /** Cache key generator function */
+    keyGenerator?: (url: string, params?: any) => string;
+    /** Whether to enable cache */
+    enabled?: boolean;
+}
+export interface CachedResponse<T> {
+    data: T;
+    timestamp: number;
+    ttl: number;
+}
+export declare class RequestCache {
+    private cache;
+    private pendingRequests;
+    /**
+     * Generate cache key from request config
+     */
+    generateKey(url: string, params?: any): string;
+    /**
+     * Get cached response if valid
+     */
+    get<T>(key: string): T | null;
+    /**
+     * Set cache entry
+     */
+    set<T>(key: string, data: T, ttl?: number): void;
+    /**
+     * Check if request is already in flight
+     */
+    hasPendingRequest(key: string): boolean;
+    /**
+     * Get pending request promise
+     */
+    getPendingRequest<T>(key: string): Promise<T> | undefined;
+    /**
+     * Set pending request
+     */
+    setPendingRequest<T>(key: string, promise: Promise<T>): void;
+    /**
+     * Clear specific cache entry
+     */
+    clear(key: string): void;
+    /**
+     * Clear all cache
+     */
+    clearAll(): void;
+    /**
+     * Clear expired entries
+     */
+    clearExpired(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        pending: number;
+    };
+}
+export declare const globalRequestCache: RequestCache;

package/dist/utils/http/request.d.ts

@@ -0,0 +1,280 @@
+/**
+ * Unified Request Client
+ * Production-ready HTTP client with multi-platform support, caching, retry logic, and interceptors
+ */
+import { RequestCache } from './request-cache';
+import type { RequestOptions, IRequestAdapter, RequestInterceptor, ResponseInterceptor, RetryConfig, InterceptorRegistration } from './types';
+export interface RequestInstanceConfig {
+    /** Base URL for all requests */
+    baseURL?: string;
+    /** Default headers */
+    headers?: Record<string, string>;
+    /** Default timeout in milliseconds */
+    timeout?: number;
+    /** Custom adapter */
+    adapter?: IRequestAdapter;
+    /** Enable request caching */
+    enableCache?: boolean;
+    /** Default cache TTL */
+    cacheTTL?: number;
+    /** Default retry configuration */
+    retry?: RetryConfig;
+    /** Enable security features */
+    enableSecurity?: boolean;
+}
+/**
+ * Unified Request Client
+ *
+ * @example
+ * ```typescript
+ * const client = new RequestClient({
+ *   baseURL: 'https://api.example.com',
+ *   timeout: 10000,
+ *   enableCache: true,
+ * });
+ *
+ * // GET request
+ * const data = await client.get<User>('/users/1');
+ *
+ * // POST request
+ * const created = await client.post<User>('/users', { name: 'John' });
+ * ```
+ */
+export declare class Request {
+    private baseURL;
+    private defaultHeaders;
+    private defaultTimeout;
+    private adapter;
+    private cache;
+    private errorManager;
+    private security;
+    private requestInterceptors;
+    private responseInterceptors;
+    private static globalRequestInterceptors;
+    private static globalResponseInterceptors;
+    private defaultRetryConfig;
+    private enableSecurity;
+    private enableCache;
+    private cacheTTL;
+    constructor(config?: RequestInstanceConfig & {
+        _testing?: {
+            cache?: RequestCache;
+            errorManager?: any;
+            security?: any;
+        };
+    });
+    /**
+     * Detect appropriate adapter based on environment
+     */
+    private detectAdapter;
+    /**
+     * Convert priority string to number
+     */
+    private getPriorityValue;
+    /**
+     * Sort interceptors by priority
+     */
+    private sortInterceptors;
+    /**
+     * Add request interceptor with enhanced features
+     */
+    useRequestInterceptor(interceptor: RequestInterceptor): InterceptorRegistration;
+    /**
+     * Add response interceptor with enhanced features
+     */
+    useResponseInterceptor(interceptor: ResponseInterceptor): InterceptorRegistration;
+    /**
+     * Add global request interceptor (shared across all instances)
+     */
+    static useGlobalRequestInterceptor(interceptor: RequestInterceptor): InterceptorRegistration;
+    /**
+     * Add global response interceptor (shared across all instances)
+     */
+    static useGlobalResponseInterceptor(interceptor: ResponseInterceptor): InterceptorRegistration;
+    /**
+     * Clear all interceptors or by group
+     */
+    clearInterceptors(group?: string): void;
+    /**
+     * Clear all global interceptors or by group
+     */
+    static clearGlobalInterceptors(group?: string): void;
+    /**
+     * Get all interceptors
+     */
+    getInterceptors(): {
+        request: ({
+            id: string;
+        } & RequestInterceptor)[];
+        response: ({
+            id: string;
+        } & ResponseInterceptor)[];
+    };
+    /**
+     * Get all global interceptors
+     */
+    static getGlobalInterceptors(): {
+        request: ({
+            id: string;
+        } & RequestInterceptor)[];
+        response: ({
+            id: string;
+        } & ResponseInterceptor)[];
+    };
+    /**
+     * Build full URL from base and relative URL
+     */
+    private buildURL;
+    /**
+     * Append query parameters to URL
+     */
+    private appendParams;
+    /**
+     * Calculate retry delay based on strategy
+     */
+    private calculateRetryDelay;
+    /**
+     * Execute request with retry logic
+     */
+    private executeWithRetry;
+    /**
+     * Build request config from options
+     */
+    private buildRequestConfig;
+    /**
+     * Perform security checks and add security headers
+     */
+    private performSecurityCheck;
+    /**
+     * Execute request interceptors with global + instance interceptors and priority support
+     */
+    private executeRequestInterceptors;
+    /**
+     * Execute response interceptors with global + instance interceptors and priority support
+     */
+    private executeResponseInterceptors;
+    /**
+     * Handle request error
+     */
+    private handleRequestError;
+    /**
+     * Handle response status
+     */
+    private handleResponseStatus;
+    /**
+     * Execute HTTP request
+     */
+    request<T = any>(options: RequestOptions): Promise<T>;
+    /**
+     * GET request
+     */
+    get<T = any>(url: string, options?: Omit<RequestOptions, 'url' | 'method' | 'data'>): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T = any>(url: string, data?: any, options?: Omit<RequestOptions, 'url' | 'method' | 'data'>): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T = any>(url: string, data?: any, options?: Omit<RequestOptions, 'url' | 'method' | 'data'>): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T = any>(url: string, data?: any, options?: Omit<RequestOptions, 'url' | 'method' | 'data'>): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T = any>(url: string, options?: Omit<RequestOptions, 'url' | 'method' | 'data'>): Promise<T>;
+    /**
+     * Upload file
+     */
+    upload<T = any>(options: RequestOptions & {
+        filePath: string | File;
+        name?: string;
+        formData?: Record<string, any>;
+        onProgress?: (progress: {
+            progress: number;
+            totalBytesSent: number;
+            totalBytesExpectedToSend: number;
+        }) => void;
+    }): Promise<T>;
+    /**
+     * Download file
+     */
+    download<T = any>(options: RequestOptions & {
+        filePath?: string;
+        onProgress?: (progress: {
+            progress: number;
+            totalBytesWritten: number;
+            totalBytesExpectedToWrite: number;
+        }) => void;
+    }): Promise<T>;
+    /**
+     * Clear cache
+     */
+    clearCache(url?: string, params?: any): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        pending: number;
+    };
+    /**
+     * Execute request with common logic
+     */
+    private executeRequestWithCommonLogic;
+    /**
+     * Set default headers
+     */
+    setDefaultHeaders(headers: Record<string, string>): this;
+    /**
+     * Update default header
+     */
+    updateDefaultHeader(key: string, value: string): this;
+    /**
+     * Remove default header
+     */
+    removeDefaultHeader(key: string): this;
+    /**
+     * Set default timeout
+     */
+    setDefaultTimeout(timeout: number): this;
+    /**
+     * Enable/disable security features
+     */
+    setSecurityEnabled(enabled: boolean): this;
+    /**
+     * Enable/disable cache
+     */
+    setCacheEnabled(enabled: boolean): this;
+    /**
+     * Set default cache TTL
+     */
+    setDefaultCacheTTL(ttl: number): this;
+    /**
+     * Set authorization header with token
+     */
+    setAuthToken(token: string, type?: string): this;
+    /**
+     * Clear authorization header
+     */
+    clearAuthToken(): this;
+    /**
+     * Set base URL
+     */
+    setBaseURL(baseURL: string): this;
+    /**
+     * Create a new client instance with merged config
+     */
+    createInstance(config?: RequestInstanceConfig): Request;
+    /**
+     * Quick GET request with simplified API
+     */
+    quickGet<T = any>(url: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<T>;
+    /**
+     * Quick POST request with simplified API
+     */
+    quickPost<T = any>(url: string, data?: any, headers?: Record<string, string>): Promise<T>;
+}
+export declare const request: Request;

package/dist/utils/http/taro-adapter.d.ts

@@ -0,0 +1,4 @@
+import { IRequestAdapter, RequestConfig, ResponseData } from './types';
+export declare class TaroAdapter implements IRequestAdapter {
+    request<T = any>(config: RequestConfig): Promise<ResponseData<T>>;
+}

package/dist/utils/http/types.d.ts

@@ -0,0 +1,351 @@
+/**
+ * Enhanced Request Types
+ * Extended type definitions for the unified request client
+ */
+/** HTTP Methods */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+/** Platform types */
+export type Platform = 'web' | 'weapp' | 'alipay' | 'swan' | 'tt' | 'qq' | 'jd' | 'h5' | 'rn';
+/** Request configuration */
+export interface RequestConfig {
+    /** Request URL */
+    url: string;
+    /** HTTP method */
+    method?: HttpMethod;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Request body data */
+    data?: any;
+    /** URL query parameters */
+    params?: Record<string, any>;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Response type */
+    responseType?: 'json' | 'text' | 'arraybuffer' | 'blob';
+    /** Enable credentials (cookies) */
+    withCredentials?: boolean;
+    /** Custom request metadata */
+    meta?: Record<string, any>;
+}
+/** Response data structure */
+export interface ResponseData<T = any> {
+    /** Response data */
+    data: T;
+    /** HTTP status code */
+    statusCode: number;
+    /** Response headers */
+    header: Record<string, string>;
+    /** Error message (if any) */
+    errMsg?: string;
+    /** Response cookies */
+    cookies?: string[];
+}
+/** Interceptor priority levels */
+export type InterceptorPriority = 'low' | 'medium' | 'high' | number;
+/** Request interceptor function with enhanced features */
+export interface RequestInterceptor {
+    /** Called before request is sent */
+    onRequest?: (config: RequestConfig) => RequestConfig | Promise<RequestConfig>;
+    /** Called if request configuration fails */
+    onRequestError?: (error: Error) => Error | Promise<Error>;
+    /** Interceptor priority */
+    priority?: InterceptorPriority;
+    /** Interceptor group name */
+    group?: string;
+}
+/** Response interceptor function with enhanced features */
+export interface ResponseInterceptor {
+    /** Called on successful response */
+    onResponse?: <T>(response: ResponseData<T>) => ResponseData<T> | Promise<ResponseData<T>>;
+    /** Called on response error */
+    onResponseError?: (error: Error) => Error | Promise<Error>;
+    /** Interceptor priority */
+    priority?: InterceptorPriority;
+    /** Interceptor group name */
+    group?: string;
+}
+/** Interceptor registration result */
+export interface InterceptorRegistration {
+    /** ID of the registered interceptor */
+    id: string;
+    /** Function to remove the interceptor */
+    eject: () => void;
+}
+/** Global interceptors manager */
+export interface GlobalInterceptorsManager {
+    /** Add a global request interceptor */
+    useRequestInterceptor: (interceptor: RequestInterceptor) => InterceptorRegistration;
+    /** Add a global response interceptor */
+    useResponseInterceptor: (interceptor: ResponseInterceptor) => InterceptorRegistration;
+    /** Remove all global interceptors */
+    clearAll: () => void;
+    /** Remove all interceptors by group */
+    clearByGroup: (group: string) => void;
+    /** Get all global request interceptors */
+    getRequestInterceptors: () => Array<{
+        id: string;
+    } & RequestInterceptor>;
+    /** Get all global response interceptors */
+    getResponseInterceptors: () => Array<{
+        id: string;
+    } & ResponseInterceptor>;
+}
+/** Retry configuration */
+export interface RetryConfig {
+    /** Maximum number of retries */
+    retries?: number;
+    /** Delay between retries in milliseconds */
+    retryDelay?: number;
+    /** Function to determine if request should be retried */
+    shouldRetry?: (error: Error, attempt: number) => boolean;
+    /** Retry delay strategy */
+    retryDelayStrategy?: 'fixed' | 'exponential' | 'linear';
+    /** Maximum retry delay */
+    maxRetryDelay?: number;
+}
+/** Cache configuration */
+export interface CacheConfig {
+    /** Enable caching */
+    enabled?: boolean;
+    /** Cache TTL in milliseconds */
+    ttl?: number;
+    /** Custom cache key generator */
+    keyGenerator?: (config: RequestConfig) => string;
+    /** Force refresh (bypass cache) */
+    forceRefresh?: boolean;
+}
+/** Loading state configuration */
+export interface LoadingConfig {
+    /** Show global loading indicator */
+    showLoading?: boolean;
+    /** Custom loading text */
+    loadingText?: string;
+    /** Loading delay (ms) before showing indicator */
+    loadingDelay?: number;
+}
+/** Request options (extends config with additional features) */
+export interface RequestOptions extends RequestConfig {
+    /** Base URL to prepend */
+    baseURL?: string;
+    /** Retry configuration */
+    retry?: RetryConfig;
+    /** Cache configuration */
+    cache?: CacheConfig;
+    /** Loading state configuration */
+    loading?: LoadingConfig;
+    /** Cancel token for request cancellation */
+    cancelToken?: AbortSignal;
+    /** Request hooks */
+    hooks?: {
+        /** Before request sent */
+        beforeRequest?: (config: RequestConfig) => void;
+        /** After response received */
+        afterResponse?: <T>(response: ResponseData<T>) => void;
+        /** On request error */
+        onError?: (error: Error) => void;
+    };
+}
+/** Platform adapter interface */
+export interface IRequestAdapter {
+    /** Execute HTTP request */
+    request<T = any>(config: RequestConfig): Promise<ResponseData<T>>;
+    /** Upload file */
+    upload?<T = any>(config: UploadConfig): Promise<ResponseData<T>>;
+    /** Download file */
+    download?<T = any>(config: DownloadConfig): Promise<ResponseData<T>>;
+}
+/** Upload configuration */
+export interface UploadConfig extends Omit<RequestConfig, 'data'> {
+    /** File path or file object */
+    filePath: string | File;
+    /** Form field name for file */
+    name?: string;
+    /** Additional form data */
+    formData?: Record<string, any>;
+    /** Upload progress callback */
+    onProgress?: (progress: UploadProgress) => void;
+}
+/** Upload progress */
+export interface UploadProgress {
+    /** Upload progress percentage (0-100) */
+    progress: number;
+    /** Total bytes to upload */
+    totalBytesSent: number;
+    /** Bytes sent so far */
+    totalBytesExpectedToSend: number;
+}
+/** Download configuration */
+export interface DownloadConfig extends Omit<RequestConfig, 'data' | 'responseType'> {
+    /** Download destination path */
+    filePath?: string;
+    /** Download progress callback */
+    onProgress?: (progress: DownloadProgress) => void;
+}
+/** Download progress */
+export interface DownloadProgress {
+    /** Download progress percentage (0-100) */
+    progress: number;
+    /** Total bytes downloaded */
+    totalBytesWritten: number;
+    /** Expected total bytes */
+    totalBytesExpectedToWrite: number;
+}
+/** HTTP client error */
+export declare class HttpError extends Error {
+    statusCode?: number | undefined;
+    response?: ResponseData | undefined;
+    config?: RequestConfig | undefined;
+    requestId?: string;
+    timestamp: number;
+    retryAttempts?: number;
+    platform?: Platform;
+    constructor(message: string, statusCode?: number | undefined, response?: ResponseData | undefined, config?: RequestConfig | undefined, options?: {
+        retryAttempts?: number;
+        platform?: Platform;
+        requestId?: string;
+    });
+    toJSON(): {
+        name: string;
+        message: string;
+        statusCode: number | undefined;
+        requestId: string | undefined;
+        timestamp: number;
+        retryAttempts: number | undefined;
+        platform: Platform | undefined;
+        url: string | undefined;
+        method: HttpMethod | undefined;
+        response: ResponseData<any> | undefined;
+    };
+}
+/** Network error (no response received) */
+export declare class NetworkError extends Error {
+    config?: RequestConfig | undefined;
+    requestId?: string;
+    timestamp: number;
+    retryAttempts?: number;
+    platform?: Platform;
+    constructor(message: string, config?: RequestConfig | undefined, options?: {
+        retryAttempts?: number;
+        platform?: Platform;
+        requestId?: string;
+    });
+    toJSON(): {
+        name: string;
+        message: string;
+        requestId: string | undefined;
+        timestamp: number;
+        retryAttempts: number | undefined;
+        platform: Platform | undefined;
+        url: string | undefined;
+        method: HttpMethod | undefined;
+    };
+}
+/** Timeout error */
+export declare class TimeoutError extends Error {
+    timeout?: number | undefined;
+    config?: RequestConfig | undefined;
+    requestId?: string;
+    timestamp: number;
+    retryAttempts?: number;
+    platform?: Platform;
+    constructor(message: string, timeout?: number | undefined, config?: RequestConfig | undefined, options?: {
+        retryAttempts?: number;
+        platform?: Platform;
+        requestId?: string;
+    });
+    toJSON(): {
+        name: string;
+        message: string;
+        timeout: number | undefined;
+        requestId: string | undefined;
+        timestamp: number;
+        retryAttempts: number | undefined;
+        platform: Platform | undefined;
+        url: string | undefined;
+        method: HttpMethod | undefined;
+    };
+}
+/** Cancel error */
+export declare class CancelError extends Error {
+    config?: RequestConfig | undefined;
+    requestId?: string;
+    timestamp: number;
+    platform?: Platform;
+    constructor(message?: string, config?: RequestConfig | undefined, options?: {
+        platform?: Platform;
+        requestId?: string;
+    });
+    toJSON(): {
+        name: string;
+        message: string;
+        requestId: string | undefined;
+        timestamp: number;
+        platform: Platform | undefined;
+        url: string | undefined;
+        method: HttpMethod | undefined;
+    };
+}
+/** Request state (for hooks) */
+export interface RequestState<T> {
+    /** Response data */
+    data: T | null;
+    /** Error object */
+    error: Error | null;
+    /** Loading state */
+    loading: boolean;
+    /** Request has been called at least once */
+    called: boolean;
+}
+/** Mutation state (for hooks) */
+export interface MutationState<T, V = any> {
+    /** Response data */
+    data: T | null;
+    /** Error object */
+    error: Error | null;
+    /** Loading state */
+    loading: boolean;
+    /** Mutation variables */
+    variables: V | null;
+}
+/** Request hook options */
+export interface UseRequestOptions<T> extends Omit<RequestOptions, 'url' | 'method' | 'data' | 'params'> {
+    /** Manual mode - don't execute on mount */
+    manual?: boolean;
+    /** Default data value */
+    initialData?: T;
+    /** Dependencies array for auto-refetch */
+    deps?: any[];
+    /** Debounce delay in milliseconds */
+    debounceDelay?: number;
+    /** Polling interval in milliseconds */
+    pollingInterval?: number;
+    /** Ready condition - only execute when true */
+    ready?: boolean;
+    /** Refresh dependencies - refetch when these change */
+    refreshDeps?: any[];
+    /** Format response data */
+    formatResult?: (data: any) => T;
+    /** Error handler */
+    onError?: (error: Error) => void;
+    /** Success handler */
+    onSuccess?: (data: T) => void;
+    /** Completion handler (success or error) */
+    onCompleted?: (data: T | null, error: Error | null) => void;
+}
+/** Mutation hook options */
+export interface UseMutationOptions<T, V = any> extends Omit<RequestOptions, 'url' | 'method' | 'data' | 'params'> {
+    /** Optimistic update function */
+    optimisticData?: (variables: V) => T;
+    /** Rollback on error */
+    rollbackOnError?: boolean;
+    /** Error handler */
+    onError?: (error: Error, variables: V) => void;
+    /** Success handler */
+    onSuccess?: (data: T, variables: V) => void;
+    /** Before mutation */
+    onMutate?: (variables: V) => void | Promise<void>;
+    /** After mutation completes */
+    onCompleted?: (data: T | null, error: Error | null, variables: V) => void;
+}
+/** Query key type */
+export type QueryKey = string | readonly unknown[];

package/dist/utils/http/web-adapter.d.ts

@@ -0,0 +1,4 @@
+import { IRequestAdapter, RequestConfig, ResponseData } from './types';
+export declare class WebAdapter implements IRequestAdapter {
+    request<T = any>(config: RequestConfig): Promise<ResponseData<T>>;
+}