taro-uno-ui 1.0.0 → 1.0.2

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

@@ -1,65 +0,0 @@
-/**
- * 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

@@ -1,280 +0,0 @@
-/**
- * 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

@@ -1,4 +0,0 @@
-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

@@ -1,351 +0,0 @@
-/**
- * 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

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