taro-uno-ui 1.0.1 → 1.0.2

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

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

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

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

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

@@ -1,112 +0,0 @@
-/**
- * 工具函数库统一导出文件
- * 提供所有工具函数的统一访问入口
- */
-
-// ==================== 导入已存在的工具函数 ====================
-
-// 导入安全工具函数
-import * as xssProtection from './security/xss-protection';
-import * as apiSecurity from './security/api-security';
-import { httpClient as defaultHttpClient } from './http/http-client';
-
-// 导入类型工具函数
-import { deepEqual } from './typeHelpers';
-
-// ==================== 创建命名空间和工具类 ====================
-
-/** 平台检测工具类 */
-export class PlatformDetector {
-  private static cache: Map<string, unknown> = new Map();
-
-  static is(platform: string): boolean {
-    return process.env['TARO_ENV'] === platform;
-  }
-
-  static isMiniProgram(): boolean {
-    return this.is('weapp') || this.is('alipay') || this.is('swan') || this.is('tt') || this.is('qq') || this.is('jd');
-  }
-
-  static isH5(): boolean {
-    return this.is('h5');
-  }
-
-  static isRN(): boolean {
-    return this.is('rn');
-  }
-
-  static getPlatform(): string {
-    return process.env['TARO_ENV'] || 'unknown';
-  }
-
-  static isMobile(): boolean {
-    return this.isMiniProgram() || (this.isH5() && window.innerWidth < 768);
-  }
-
-  static getPlatformInfo(): { platform: string; isMiniProgram: boolean; isH5: boolean; isRN: boolean; env: string } {
-    const platform = this.getPlatform();
-    if (this.cache.has(platform)) {
-      return this.cache.get(platform) as {
-        platform: string;
-        isMiniProgram: boolean;
-        isH5: boolean;
-        isRN: boolean;
-        env: string;
-      };
-    }
-
-    const info = {
-      platform,
-      isMiniProgram: this.isMiniProgram(),
-      isH5: this.isH5(),
-      isRN: this.isRN(),
-      env: process.env['NODE_ENV'] || 'development',
-    };
-
-    this.cache.set(platform, info);
-    return info;
-  }
-
-  static clearCache(): void {
-    this.cache.clear();
-  }
-}
-
-// 类名工具函数
-export const cn = (...classes: Array<string | undefined | null | false>): string => {
-  return classes.filter(Boolean).join(' ');
-};
-
-// 便捷访问实例
-export { PlatformDetector as platform };
-
-// ==================== 通用工具函数 ====================
-
-/** 通用工具函数 */
-export const utils = {
-  // 安全工具
-  security: {
-    ...xssProtection,
-    api: apiSecurity,
-  },
-  http: {
-    httpClient: defaultHttpClient,
-  },
-
-  // 平台工具
-  platform: PlatformDetector,
-
-  // 类型工具
-  types: {
-    deepEqual,
-  },
-
-  // 工具函数快捷访问
-  cn,
-};
-
-// ==================== 默认导出 ====================
-
-export default utils;
-
-// platform已通过export { PlatformDetector as platform }导出