taro-uno-ui 0.9.0 → 1.0.0

package/src/utils/http/taro-adapter.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import Taro from '@tarojs/taro';
+import { TaroAdapter } from './taro-adapter';
+
+vi.mock('@tarojs/taro', () => ({
+  default: {
+    request: vi.fn(),
+  },
+}));
+
+describe('TaroAdapter', () => {
+  let adapter: TaroAdapter;
+
+  beforeEach(() => {
+    adapter = new TaroAdapter();
+    vi.clearAllMocks();
+  });
+
+  it('should make a GET request successfully', async () => {
+    const mockResponse = {
+      data: { id: 1, name: 'Test' },
+      statusCode: 200,
+      header: { 'content-type': 'application/json' },
+      errMsg: 'request:ok',
+    };
+
+    (Taro.request as any).mockResolvedValue(mockResponse);
+
+    const response = await adapter.request({
+      url: 'https://api.example.com/users',
+      method: 'GET',
+    });
+
+    expect(Taro.request).toHaveBeenCalledWith({
+      url: 'https://api.example.com/users',
+      method: 'GET',
+      header: undefined,
+      data: {},
+      timeout: 10000,
+    });
+
+    expect(response).toEqual({
+      data: mockResponse.data,
+      statusCode: 200,
+      header: mockResponse.header,
+      errMsg: 'request:ok',
+    });
+  });
+
+  it('should handle request errors', async () => {
+    const mockError = new Error('Network error');
+    (Taro.request as any).mockRejectedValue(mockError);
+
+    await expect(adapter.request({
+      url: 'https://api.example.com/error',
+      method: 'GET',
+    })).rejects.toThrow('Network error');
+  });
+
+  it('should merge params into data', async () => {
+    (Taro.request as any).mockResolvedValue({ statusCode: 200, data: {} });
+
+    await adapter.request({
+      url: 'https://api.example.com/search',
+      method: 'GET',
+      params: { q: 'test' },
+      data: { limit: 10 },
+    });
+
+    expect(Taro.request).toHaveBeenCalledWith(expect.objectContaining({
+      data: { q: 'test', limit: 10 },
+    }));
+  });
+});

package/src/utils/http/taro-adapter.ts

@@ -0,0 +1,24 @@
+import Taro from '@tarojs/taro';
+import { IRequestAdapter, RequestConfig, ResponseData } from './types';
+
+export class TaroAdapter implements IRequestAdapter {
+  async request<T = any>(config: RequestConfig): Promise<ResponseData<T>> {
+    const response = await Taro.request({
+      url: config.url,
+      method: config.method,
+      header: config.headers,
+      data: {
+        ...config.data,
+        ...config.params,
+      },
+      timeout: config.timeout || 10000,
+    });
+
+    return {
+      data: response.data as T,
+      statusCode: response.statusCode,
+      header: response.header || {},
+      errMsg: response.errMsg,
+    };
+  }
+}

package/src/utils/http/types.ts

@@ -0,0 +1,414 @@
+/**
+ * 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 class HttpError extends Error {
+  public requestId?: string;
+  public timestamp: number;
+  public retryAttempts?: number;
+  public platform?: Platform;
+
+  constructor(
+    message: string,
+    public statusCode?: number,
+    public response?: ResponseData,
+    public config?: RequestConfig,
+    options?: { retryAttempts?: number; platform?: Platform; requestId?: string },
+  ) {
+    super(message);
+    this.name = 'HttpError';
+    this.timestamp = Date.now();
+    this.retryAttempts = options?.retryAttempts;
+    this.platform = options?.platform;
+    this.requestId = options?.requestId;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      requestId: this.requestId,
+      timestamp: this.timestamp,
+      retryAttempts: this.retryAttempts,
+      platform: this.platform,
+      url: this.config?.url,
+      method: this.config?.method,
+      response: this.response,
+    };
+  }
+}
+
+/** Network error (no response received) */
+export class NetworkError extends Error {
+  public requestId?: string;
+  public timestamp: number;
+  public retryAttempts?: number;
+  public platform?: Platform;
+
+  constructor(
+    message: string,
+    public config?: RequestConfig,
+    options?: { retryAttempts?: number; platform?: Platform; requestId?: string },
+  ) {
+    super(message);
+    this.name = 'NetworkError';
+    this.timestamp = Date.now();
+    this.retryAttempts = options?.retryAttempts;
+    this.platform = options?.platform;
+    this.requestId = options?.requestId;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      requestId: this.requestId,
+      timestamp: this.timestamp,
+      retryAttempts: this.retryAttempts,
+      platform: this.platform,
+      url: this.config?.url,
+      method: this.config?.method,
+    };
+  }
+}
+
+/** Timeout error */
+export class TimeoutError extends Error {
+  public requestId?: string;
+  public timestamp: number;
+  public retryAttempts?: number;
+  public platform?: Platform;
+
+  constructor(
+    message: string,
+    public timeout?: number,
+    public config?: RequestConfig,
+    options?: { retryAttempts?: number; platform?: Platform; requestId?: string },
+  ) {
+    super(message);
+    this.name = 'TimeoutError';
+    this.timestamp = Date.now();
+    this.retryAttempts = options?.retryAttempts;
+    this.platform = options?.platform;
+    this.requestId = options?.requestId;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      timeout: this.timeout,
+      requestId: this.requestId,
+      timestamp: this.timestamp,
+      retryAttempts: this.retryAttempts,
+      platform: this.platform,
+      url: this.config?.url,
+      method: this.config?.method,
+    };
+  }
+}
+
+/** Cancel error */
+export class CancelError extends Error {
+  public requestId?: string;
+  public timestamp: number;
+  public platform?: Platform;
+
+  constructor(
+    message: string = 'Request cancelled',
+    public config?: RequestConfig,
+    options?: { platform?: Platform; requestId?: string },
+  ) {
+    super(message);
+    this.name = 'CancelError';
+    this.timestamp = Date.now();
+    this.platform = options?.platform;
+    this.requestId = options?.requestId;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      requestId: this.requestId,
+      timestamp: this.timestamp,
+      platform: this.platform,
+      url: this.config?.url,
+      method: this.config?.method,
+    };
+  }
+}
+
+/** 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/src/utils/http/web-adapter.ts

@@ -0,0 +1,33 @@
+import { IRequestAdapter, RequestConfig, ResponseData } from './types';
+
+export class WebAdapter implements IRequestAdapter {
+  async request<T = any>(config: RequestConfig): Promise<ResponseData<T>> {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), config.timeout || 10000);
+
+    try {
+      const response = await fetch(config.url, {
+        method: config.method,
+        headers: config.headers,
+        body: config.method !== 'GET' ? JSON.stringify(config.data) : undefined,
+        signal: controller.signal,
+      });
+
+      const data = await response.json();
+
+      // Convert Headers object to Record<string, string>
+      const headers: Record<string, string> = {};
+      response.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+
+      return {
+        data,
+        statusCode: response.status,
+        header: headers,
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+}

package/src/utils/index.ts

@@ -8,13 +8,10 @@
 // 导入安全工具函数
 import * as xssProtection from './security/xss-protection';
 import * as apiSecurity from './security/api-security';
-import { httpClient as defaultHttpClient } from './network/http-client';
+import { httpClient as defaultHttpClient } from './http/http-client';
 
 // 导入类型工具函数
-import {
-  deepEqual,
-} from './typeHelpers';
-
+import { deepEqual } from './typeHelpers';
 
 // ==================== 创建命名空间和工具类 ====================
 
@@ -43,7 +40,7 @@ export class PlatformDetector {
   }
 
   static isMobile(): boolean {
-    return this.isMiniProgram() || this.isH5() && window.innerWidth < 768;
+    return this.isMiniProgram() || (this.isH5() && window.innerWidth < 768);
   }
 
   static getPlatformInfo(): { platform: string; isMiniProgram: boolean; isH5: boolean; isRN: boolean; env: string } {
@@ -63,7 +60,7 @@ export class PlatformDetector {
       isMiniProgram: this.isMiniProgram(),
       isH5: this.isH5(),
       isRN: this.isRN(),
-      env: process.env['NODE_ENV'] || 'development'
+      env: process.env['NODE_ENV'] || 'development',
     };
 
     this.cache.set(platform, info);
@@ -92,7 +89,7 @@ export const utils = {
     ...xssProtection,
     api: apiSecurity,
   },
-  network: {
+  http: {
     httpClient: defaultHttpClient,
   },
 

package/src/utils/inputValidator.ts

@@ -67,7 +67,7 @@ class InputValidator {
     return {
       isValid: errors.length === 0,
       errors,
-      sanitized
+      sanitized,
     };
   }
 
@@ -81,7 +81,7 @@ class InputValidator {
     return this.validateString(email, {
       required: true,
       pattern: emailPattern,
-      sanitize: true
+      sanitize: true,
     });
   }
 
@@ -115,7 +115,7 @@ class InputValidator {
     return this.validateString(phone, {
       required: true,
       pattern: phonePattern,
-      sanitize: true
+      sanitize: true,
     });
   }
 
@@ -136,19 +136,19 @@ class InputValidator {
       if (!allowedProtocols.includes(urlObj.protocol)) {
         return {
           isValid: false,
-          errors: ['只支持 http 和 https 协议']
+          errors: ['只支持 http 和 https 协议'],
         };
       }
 
       return {
         isValid: true,
         errors: [],
-        sanitized: url
+        sanitized: url,
       };
     } catch (e) {
       return {
         isValid: false,
-        errors: ['无效的URL地址']
+        errors: ['无效的URL地址'],
       };
     }
   }
@@ -179,7 +179,7 @@ class InputValidator {
 
     return {
       isValid: errors.length === 0,
-      errors
+      errors,
     };
   }
 
@@ -219,7 +219,7 @@ class InputValidator {
         if (typeof value === 'string') {
           const result = this.validateString(value, rule || {});
           if (!result.isValid) {
-            errors.push(...result.errors.map(err => `${key}: ${err}`));
+            errors.push(...result.errors.map((err) => `${key}: ${err}`));
           }
           if (result.sanitized !== undefined) {
             sanitized[key] = result.sanitized;
@@ -230,7 +230,7 @@ class InputValidator {
           const strValue = String(value);
           const result = this.validateNumber(strValue, rule?.minLength, rule?.maxLength);
           if (!result.isValid) {
-            errors.push(...result.errors.map(err => `${key}: ${err}`));
+            errors.push(...result.errors.map((err) => `${key}: ${err}`));
           }
           sanitized[key] = value;
         } else {
@@ -242,7 +242,7 @@ class InputValidator {
     return {
       isValid: errors.length === 0,
       errors,
-      sanitized: Object.keys(sanitized).length > 0 ? sanitized : undefined
+      sanitized: Object.keys(sanitized).length > 0 ? sanitized : undefined,
     };
   }
 }
@@ -253,9 +253,12 @@ const inputValidator = new InputValidator();
 // 导出便捷方法
 export const validateString = (value: string, rules: ValidationRule) => inputValidator.validateString(value, rules);
 export const validateEmail = (email: string) => inputValidator.validateEmail(email);
-export const validatePhone = (phone: string, countryCode: 'CN' | 'US' | 'GB' | 'JP' | 'KR' = 'CN') => inputValidator.validatePhone(phone, countryCode);
+export const validatePhone = (phone: string, countryCode: 'CN' | 'US' | 'GB' | 'JP' | 'KR' = 'CN') =>
+  inputValidator.validatePhone(phone, countryCode);
 export const validateURL = (url: string) => inputValidator.validateURL(url);
-export const validateNumber = (value: string, min?: number, max?: number) => inputValidator.validateNumber(value, min, max);
-export const validateObject = (obj: Record<string, any>, rules: Record<string, ValidationRule>) => inputValidator.validateObject(obj, rules);
+export const validateNumber = (value: string, min?: number, max?: number) =>
+  inputValidator.validateNumber(value, min, max);
+export const validateObject = (obj: Record<string, any>, rules: Record<string, ValidationRule>) =>
+  inputValidator.validateObject(obj, rules);
 
-export default inputValidator;
+export default inputValidator;