etherreq 1.2.1 → 1.2.4

package/dist/cache.js

@@ -7,8 +7,8 @@ function hashString(str) {
     let hash = 0;
     for (let i = 0; i < str.length; i++) {
         const char = str.charCodeAt(i);
-        hash = ((hash << 5) - hash) + char;
-        hash = hash & hash; // 转换为32位整数
+        hash = (hash << 5) - hash + char;
+        hash |= 0; // 转换为32位整数
     }
     return Math.abs(hash).toString(36);
 }
@@ -18,9 +18,9 @@ function hashString(str) {
  */
 function isLocalStorageAvailable() {
     try {
-        const testKey = '__storage_test__';
-        localStorage.setItem(testKey, 'test');
-        localStorage.removeItem(testKey);
+        const test = '__storage_test__';
+        localStorage.setItem(test, test);
+        localStorage.removeItem(test);
         return true;
     }
     catch (e) {
@@ -34,15 +34,19 @@ function isLocalStorageAvailable() {
  * @returns 缓存键字符串
  */
 export function getCacheKey(url, options) {
-    const rawParams = options.params || {};
-    // 将所有值转换为 string
-    const stringifiedParams = {};
-    for (const [key, value] of Object.entries(rawParams)) {
-        stringifiedParams[key] = String(value);
+    // 仅对GET请求添加参数到缓存键中
+    if (options.method.toUpperCase() !== 'GET') {
+        return hashString(url);
     }
-    const params = new URLSearchParams(stringifiedParams);
-    const keyString = `${options.method}:${url}?${params.toString()}`;
-    return `etherreq_cache_${hashString(keyString)}`;
+    // 将参数按字母顺序排序以确保一致的缓存键
+    if (options.params) {
+        const sortedParams = Object.keys(options.params)
+            .sort()
+            .map(key => `${key}=${options.params[key]}`)
+            .join('&');
+        return hashString(`${url}?${sortedParams}`);
+    }
+    return hashString(url);
 }
 /**
  * 内存缓存存储类
@@ -69,7 +73,7 @@ class MemoryCache {
     cleanupExpired() {
         const now = Date.now();
         for (const [key, entry] of this.store.entries()) {
-            if (entry.expireAt <= now) {
+            if (entry.expireAt < now) {
                 this.store.delete(key);
             }
         }
@@ -86,14 +90,14 @@ class MemoryCache {
      */
     get(key) {
         const entry = this.store.get(key);
-        if (entry && entry.expireAt > Date.now()) {
-            return entry.value;
+        if (!entry) {
+            return null;
         }
-        // 过期则删除
-        if (entry) {
+        if (entry.expireAt < Date.now()) {
             this.store.delete(key);
+            return null;
         }
-        return null;
+        return entry.value;
     }
     /**
      * 删除指定缓存
@@ -127,7 +131,7 @@ class MemoryCache {
  * 本地存储缓存类
  */
 class LocalStorageCache {
-    constructor(prefix = 'etherreq_') {
+    constructor(prefix = 'etherreq_cache_') {
         this.prefix = prefix;
         this.available = isLocalStorageAvailable();
     }
@@ -138,12 +142,14 @@ class LocalStorageCache {
         if (!this.available)
             return;
         try {
-            const expireAt = Date.now() + ttl;
-            const entry = { value, expireAt };
-            localStorage.setItem(`${this.prefix}${key}`, JSON.stringify(entry));
+            const item = {
+                value,
+                expireAt: Date.now() + ttl,
+            };
+            localStorage.setItem(this.prefix + key, JSON.stringify(item));
         }
-        catch (error) {
-            console.warn('LocalStorage缓存设置失败:', error);
+        catch (e) {
+            console.warn('Cache set failed:', e);
         }
     }
     /**
@@ -153,21 +159,19 @@ class LocalStorageCache {
         if (!this.available)
             return null;
         try {
-            const item = localStorage.getItem(`${this.prefix}${key}`);
-            if (!item)
+            const itemStr = localStorage.getItem(this.prefix + key);
+            if (!itemStr) {
                 return null;
-            const entry = JSON.parse(item);
-            if (entry.expireAt > Date.now()) {
-                return entry.value;
             }
-            else {
-                // 过期则删除
-                localStorage.removeItem(`${this.prefix}${key}`);
+            const item = JSON.parse(itemStr);
+            if (item.expireAt < Date.now()) {
+                localStorage.removeItem(this.prefix + key);
                 return null;
             }
+            return item.value;
         }
-        catch (error) {
-            console.warn('LocalStorage缓存获取失败:', error);
+        catch (e) {
+            console.error('Cache get failed:', e);
             return null;
         }
     }
@@ -191,17 +195,16 @@ class LocalStorageCache {
         if (!this.available)
             return;
         try {
-            const keysToRemove = [];
             for (let i = 0; i < localStorage.length; i++) {
                 const key = localStorage.key(i);
                 if (key && key.startsWith(this.prefix)) {
-                    keysToRemove.push(key);
+                    localStorage.removeItem(key);
+                    i--; // 修正索引
                 }
             }
-            keysToRemove.forEach(key => localStorage.removeItem(key));
         }
-        catch (error) {
-            console.warn('LocalStorage缓存清空失败:', error);
+        catch (e) {
+            console.error('Cache clear failed:', e);
         }
     }
 }
@@ -276,6 +279,6 @@ class CacheFactory {
     }
 }
 // 默认导出混合缓存实例
-export const requestCache = CacheFactory.create('memory+local');
+export const requestCache = CacheFactory.create();
 // 导出缓存工厂和工具函数
 export { CacheFactory, MemoryCache, LocalStorageCache, HybridCache, hashString, isLocalStorageAvailable };

package/dist/etherreq.js

@@ -1,84 +1,68 @@
-// src/etherreq.ts
 export const create = (defaultConfig = {}) => {
-    const interceptors = {
-        request: [],
-        response: [],
-    };
-    const use = (fulfilled, rejected, type = 'request') => {
-        interceptors[type].push({ fulfilled, rejected });
-    };
-    const dispatchRequest = async (config) => {
-        // 请求拦截器执行
-        for (const interceptor of interceptors.request) {
-            const nextConfig = await interceptor.fulfilled(config);
-            // ✅ 拦截器可以返回一个 response 对象，表示中断请求
-            if (nextConfig && nextConfig.isFromCache) {
-                return nextConfig.data; // ✅ 直接返回缓存结果，不再往下执行
-            }
-            config = nextConfig;
+    // 拦截器存储
+    const requestInterceptors = [];
+    const responseInterceptors = [];
+    const client = async (config) => {
+        // 合并默认配置
+        const mergedConfig = { ...defaultConfig, ...config };
+        // 应用请求拦截器
+        let processedConfig = { ...mergedConfig };
+        for (const interceptor of requestInterceptors) {
+            processedConfig = await interceptor(processedConfig);
         }
-        // 检查 url 是否存在
-        if (!config.url) {
-            throw new Error('请求配置中缺少 url 属性');
-        }
-        let response;
-        const { url, method = 'GET', headers = {}, body } = config;
-        let text = '';
         try {
-            const options = {
+            // 确定是否需要发送请求体
+            const method = processedConfig.method || 'GET';
+            const hasBody = processedConfig.body &&
+                method !== 'GET' &&
+                method !== 'HEAD' &&
+                method !== 'OPTIONS';
+            // 发送请求
+            const response = await fetch(processedConfig.url, {
                 method,
-                headers,
-                body: method !== 'GET' ? JSON.stringify(body) : undefined,
-            };
-            const res = await fetch(url, options);
-            text = await res.text();
-            if (!res.ok) {
-                throw new Error(`HTTP 错误: ${res.status} - ${res.statusText}`);
-            }
-            if (text.trim().startsWith('<')) {
-                throw new Error('服务器返回了 HTML 页面，预期为 JSON 格式');
+                headers: {
+                    ...(processedConfig.headers || {}),
+                },
+                // 只有非GET/HEAD/OPTIONS请求才发送body
+                body: hasBody ? JSON.stringify(processedConfig.body) : undefined,
+            });
+            // 检查响应状态
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
-            const data = JSON.parse(text);
-            response = {
+            // 解析响应数据
+            const data = await response.json();
+            let responseObject = {
                 data,
-                status: res.status,
-                statusText: res.statusText,
-                headers: Object.fromEntries(res.headers.entries()),
-                config,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                config: processedConfig,
             };
-        }
-        catch (error) {
-            error.message += `\n请求地址: ${url}`;
-            if (text) {
-                error.message += `\n响应内容: ${text.substring(0, 200)}...`;
-            }
-            for (const interceptor of interceptors.response) {
-                if (interceptor.rejected) {
-                    return interceptor.rejected(error);
-                }
+            // 应用响应拦截器
+            for (const interceptor of responseInterceptors) {
+                responseObject = await interceptor(responseObject);
             }
-            throw error;
+            return responseObject;
         }
-        // 响应拦截器执行
-        for (const interceptor of interceptors.response) {
-            response = await interceptor.fulfilled(response);
+        catch (error) {
+            // 如果是网络错误或其他类型的错误
+            throw new Error(`Request failed: ${error.message}`);
         }
-        return response;
-    };
-    const instance = (config) => {
-        return dispatchRequest({
-            ...defaultConfig,
-            ...config,
-        });
     };
-    instance.use = (fulfilled, rejected) => use(fulfilled, rejected, 'request');
-    instance.interceptors = {
+    // 拦截器接口
+    client.interceptors = {
         request: {
-            use: (fulfilled, rejected) => use(fulfilled, rejected, 'request'),
+            use: (fulfilled, rejected) => {
+                requestInterceptors.push(fulfilled);
+            },
         },
         response: {
-            use: (fulfilled, rejected) => use(fulfilled, rejected, 'response'),
+            use: (fulfilled, rejected) => {
+                responseInterceptors.push(fulfilled);
+            },
         },
     };
-    return instance;
+    return client;
 };
+export {};

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { request, baseURL as _baseURL, setBaseURL } from './request';
+import { request, baseURL as _baseURL, setBaseURL } from './request.js';
 // 示例封装方法
 const createMethod = (method) => (url, data, callback) => {
     let options;
@@ -11,7 +11,13 @@ const createMethod = (method) => (url, data, callback) => {
         !data.headers &&
         !data.params &&
         !data.baseURL) {
-        options = { body: data, method: method };
+        // 对于GET请求，不应发送body，而是将数据作为params处理
+        if (method.toUpperCase() === 'GET') {
+            options = { params: data, method: method };
+        }
+        else {
+            options = { body: data, method: method };
+        }
     }
     else {
         options = { ...data, method: method };

package/dist/request.js

@@ -1,6 +1,6 @@
 // src/request.ts
-import { create } from './etherreq';
-import { requestCache, getCacheKey } from './cache';
+import { create } from './etherreq.js';
+import { requestCache, getCacheKey } from './cache.js';
 // 创建一个带有默认配置的请求实例
 const instance = create({
     baseURL: 'https://api.example.com', // 默认基础 URL

package/dist/types/cache.d.ts

@@ -1,4 +1,4 @@
-import { CacheStorage } from './types/cache';
+import type { CacheStorage } from './types/cache.js';
 /**
  * 生成缓存键的哈希值，避免特殊字符和长度问题
  * @param str 输入字符串

package/dist/types/etherreq.d.ts

@@ -1,13 +1,11 @@
-interface RequestConfig {
-    url?: string;
-    method?: string;
-    headers?: Record<string, string>;
-    body?: any;
-    [key: string]: any;
-}
-export declare const create: (defaultConfig?: RequestConfig) => {
-    (config: RequestConfig): Promise<any>;
-    use(fulfilled: any, rejected: any): void;
+export declare const create: (defaultConfig?: any) => {
+    (config: any): Promise<{
+        data: any;
+        status: number;
+        statusText: string;
+        headers: Headers;
+        config: any;
+    }>;
     interceptors: {
         request: {
             use: (fulfilled: any, rejected: any) => void;

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
-import { baseURL as _baseURL, setBaseURL } from './request';
-import { EtherRequestOptions } from './types/cache';
+import { baseURL as _baseURL, setBaseURL } from './request.js';
+import type { EtherRequestOptions } from './types/cache.js';
 export declare const etherreq: ((url: string, options?: EtherRequestOptions, callback?: (error: Error | null, data: any) => void) => Promise<any> | undefined) & {
     get: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any> | undefined;
     post: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any> | undefined;

package/dist/types/request.d.ts

@@ -1,4 +1,4 @@
-import { EtherRequestOptions } from './types/cache';
+import type { EtherRequestOptions } from './types/cache.js';
 declare let _baseURL: string;
 /**
  * 封装 request 函数，支持 baseURL 拼接等逻辑

package/dist/types/types/config.d.ts

@@ -1,4 +1,13 @@
-import { CacheOptions } from './cache';
+import type { CacheOptions } from './cache';
+export interface RequestConfig {
+    url?: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: any;
+    params?: Record<string, string | number | boolean>;
+    baseURL?: string;
+    cache?: CacheOptions | false;
+}
 /**
  * 全局配置接口
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "etherreq",
-  "version": "1.2.1",
+  "version": "1.2.4",
   "description": "A lightweight custom HTTP request library with TypeScript support.",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",