etherreq 1.1.15 → 1.2.0

package/README.md

@@ -1,80 +1,206 @@
-# etherreq
+# EtherReq
 
-一个轻量级、无感知的 HTTP 请求库，基于  Fetch封装，支持自动 Token 注入、拦截器、TypeScript 类型定义等功能。
+一个轻量级、无感知的 HTTP 请求库，基于 Fetch 封装，支持自动 Token 注入、拦截器、TypeScript 类型定义和智能缓存功能。
 
-##  快速使用
+## 特性
 
-安装
+- 🚀 **轻量级**: 基于原生 Fetch API 构建
+- 🔐 **自动认证**: login 方法自动管理 token
+- 🔄 **智能缓存**: 支持内存和 localStorage 双重缓存
+- 🎯 **TypeScript**: 完整的类型支持
+- ⚡ **拦截器**: 请求/响应拦截器支持
+- 📦 **零依赖**: 无需额外依赖包
 
-```
+## 安装
+
+```bash
 npm install etherreq
 # 或者
 yarn add etherreq
 ```
 
-## API 接口
+## 快速开始
 
-```javascript
+```typescript
 import { etherreq } from 'etherreq';
 
-// GET 请求
-import { etherreq } from 'etherreq';
-  const  ab = async () => {
-    const a= await etherreq.get('http://localhost:8081/api/users')
-    //获取gat数据
-    console.log(a);
-  }
+// GET 请求（自动缓存）
+const users = await etherreq.get('http://localhost:8081/api/users');
+console.log(users);
 
 // POST 请求
-etherreq.post('/login', { username: 'test', password: '123456' }).then(data => {
-  console.log('登录成功:', data);
+const result = await etherreq.post('/login', { 
+  username: 'test', 
+  password: '123456' 
 });
+console.log('登录成功:', result);
+
+// 带数据的POST请求
+const user = {
+  id: 1,
+  name: '张三',
+  sex: '男',
+  age: 18,
+};
+const newUser = await etherreq.post('/add', user);
+console.log(newUser);
+```
 
-  const b = async () => {
-    const user={
-      id : 1,
-      name : 'name',
-      sex : '男',
-      age : 18,
-    }    
-const b1 =await etherreq.post('/add',user);
-console.log(b1);
-  };
+## 登录认证
 
+```typescript
 // 登录方法（自动保存 token）
-  const login = async () => {
-    const user={
-    "id": 1,
-    "username": "zhy",
-    "password": "123456"
-    }    
-const login =await etherreq.login('users/login',user);
-console.log(login);
+const login = async () => {
+  const userData = {
+    id: 1,
+    username: "zhy",
+    password: "123456"
   };
+  
+  const loginResult = await etherreq.login('users/login', userData);
+  console.log(loginResult);
+  // 后续请求会自动携带 token
+};
+```
 
+## 缓存功能
 
-```
+### 自动缓存
+GET 请求默认启用智能缓存：
+- 内存缓存（快速访问）
+- localStorage 持久化（页面刷新后仍有效）
+- 自动过期清理（默认5分钟）
 
+### 缓存控制选项
 
+```typescript
+// 禁用缓存
+const data = await etherreq.get('/api/data', {
+  cache: false
+});
+
+// 自定义缓存时间
+const data = await etherreq.get('/api/data', {
+  cache: {
+    enabled: true,
+    ttl: 10 * 60 * 1000 // 10分钟
+  }
+});
+
+// 指定存储策略
+const data = await etherreq.get('/api/data', {
+  cache: {
+    storage: 'memory+local', // 'memory' | 'local' | 'memory+local'
+    ttl: 300000
+  }
+});
+```
+
+### 带参数的请求缓存
+```typescript
+// 不同参数生成不同缓存键
+const page1 = await etherreq.get('/users', {
+  params: { page: 1, limit: 10 }
+});
 
+const page2 = await etherreq.get('/users', {
+  params: { page: 2, limit: 10 }
+});
+// 这两个请求会有独立的缓存
+```
 
+## API 接口
 
 ### 请求方法
 
-etherreq.login(url,data)
+```typescript
+etherreq(url, options?)           // 默认 GET
+etherreq.get(url, options?)
+etherreq.post(url, data?, options?)
+etherreq.put(url, data?, options?)
+etherreq.delete(url, options?)
+etherreq.del(url, options?)       // delete 别名
+etherreq.head(url, options?)
+etherreq.options(url, options?)
+etherreq.patch(url, data?, options?)
+etherreq.login(url, data?, options?)
+```
+
+### 配置选项
+
+```typescript
+interface EtherRequestOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+  headers?: Record<string, string>;
+  body?: any;
+  params?: Record<string, string | number | boolean>;
+  baseURL?: string;
+  cache?: CacheOptions | false;
+}
+```
+
+### 缓存选项
 
-etherreq.get（url,data）
+```typescript
+interface CacheOptions {
+  enabled?: boolean;     // 是否启用缓存
+  storage?: 'memory' | 'local' | 'memory+local'; // 存储策略
+  ttl?: number;          // 过期时间（毫秒）
+}
+```
 
-etherreq.delete（url,data）
+## 高级用法
 
-etherreq.head（url,data）
+### 设置基础URL
+```typescript
+import { setBaseURL } from 'etherreq';
+
+setBaseURL('https://api.example.com');
+// 后续请求将使用此基础URL
+```
+
+### 并发请求
+```typescript
+const [users, posts] = await Promise.all([
+  etherreq.get('/users'),
+  etherreq.get('/posts')
+]);
+```
+
+### 错误处理
+```typescript
+try {
+  const data = await etherreq.get('/api/data');
+} catch (error) {
+  console.error('请求失败:', error.message);
+}
+```
+
+## TypeScript 支持
+
+完整的类型定义支持：
+
+```typescript
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+// 类型安全的请求
+const user: User = await etherreq.get<User>('/users/1');
+const users: User[] = await etherreq.get<User[]>('/users');
+```
 
-etherreq.options（url,data）
+## 浏览器兼容性
 
-etherreq.post（url,data）
+- Chrome 67+
+- Firefox 61+
+- Safari 12+
+- Edge 79+
 
-etherreq.put（url,data）
+需要 Promise 和 fetch API 支持。
 
-etherreq.patch（url,data）
+## License
 
-在login方法执行后后端需要返回token，之后在执行其他方法时不需要配置token，token会自动携带
+MIT

package/dist/cache.js

@@ -0,0 +1,281 @@
+/**
+ * 生成缓存键的哈希值，避免特殊字符和长度问题
+ * @param str 输入字符串
+ * @returns 哈希值字符串
+ */
+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位整数
+    }
+    return Math.abs(hash).toString(36);
+}
+/**
+ * 检查localStorage是否可用
+ * @returns boolean
+ */
+function isLocalStorageAvailable() {
+    try {
+        const testKey = '__storage_test__';
+        localStorage.setItem(testKey, 'test');
+        localStorage.removeItem(testKey);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/**
+ * 获取缓存 key（使用哈希算法避免特殊字符）
+ * @param url 请求地址
+ * @param options 请求参数
+ * @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);
+    }
+    const params = new URLSearchParams(stringifiedParams);
+    const keyString = `${options.method}:${url}?${params.toString()}`;
+    return `etherreq_cache_${hashString(keyString)}`;
+}
+/**
+ * 内存缓存存储类
+ */
+class MemoryCache {
+    constructor() {
+        this.store = new Map();
+        this.cleanupTimer = null;
+        this.startCleanupInterval();
+    }
+    /**
+     * 启动定期清理过期缓存
+     */
+    startCleanupInterval() {
+        if (this.cleanupTimer)
+            return;
+        this.cleanupTimer = setInterval(() => {
+            this.cleanupExpired();
+        }, 30000); // 每30秒清理一次
+    }
+    /**
+     * 清理过期缓存
+     */
+    cleanupExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.store.entries()) {
+            if (entry.expireAt <= now) {
+                this.store.delete(key);
+            }
+        }
+    }
+    /**
+     * 设置缓存
+     */
+    set(key, value, ttl = 5 * 60 * 1000) {
+        const expireAt = Date.now() + ttl;
+        this.store.set(key, { value, expireAt });
+    }
+    /**
+     * 获取缓存
+     */
+    get(key) {
+        const entry = this.store.get(key);
+        if (entry && entry.expireAt > Date.now()) {
+            return entry.value;
+        }
+        // 过期则删除
+        if (entry) {
+            this.store.delete(key);
+        }
+        return null;
+    }
+    /**
+     * 删除指定缓存
+     */
+    delete(key) {
+        this.store.delete(key);
+    }
+    /**
+     * 清空所有缓存
+     */
+    clear() {
+        this.store.clear();
+    }
+    /**
+     * 获取缓存大小
+     */
+    size() {
+        return this.store.size;
+    }
+    /**
+     * 停止清理定时器
+     */
+    destroy() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+    }
+}
+/**
+ * 本地存储缓存类
+ */
+class LocalStorageCache {
+    constructor(prefix = 'etherreq_') {
+        this.prefix = prefix;
+        this.available = isLocalStorageAvailable();
+    }
+    /**
+     * 设置缓存到localStorage
+     */
+    set(key, value, ttl = 5 * 60 * 1000) {
+        if (!this.available)
+            return;
+        try {
+            const expireAt = Date.now() + ttl;
+            const entry = { value, expireAt };
+            localStorage.setItem(`${this.prefix}${key}`, JSON.stringify(entry));
+        }
+        catch (error) {
+            console.warn('LocalStorage缓存设置失败:', error);
+        }
+    }
+    /**
+     * 从localStorage获取缓存
+     */
+    get(key) {
+        if (!this.available)
+            return null;
+        try {
+            const item = localStorage.getItem(`${this.prefix}${key}`);
+            if (!item)
+                return null;
+            const entry = JSON.parse(item);
+            if (entry.expireAt > Date.now()) {
+                return entry.value;
+            }
+            else {
+                // 过期则删除
+                localStorage.removeItem(`${this.prefix}${key}`);
+                return null;
+            }
+        }
+        catch (error) {
+            console.warn('LocalStorage缓存获取失败:', error);
+            return null;
+        }
+    }
+    /**
+     * 删除指定缓存
+     */
+    delete(key) {
+        if (!this.available)
+            return;
+        try {
+            localStorage.removeItem(`${this.prefix}${key}`);
+        }
+        catch (error) {
+            console.warn('LocalStorage缓存删除失败:', error);
+        }
+    }
+    /**
+     * 清空所有缓存（只清空当前应用的缓存）
+     */
+    clear() {
+        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);
+                }
+            }
+            keysToRemove.forEach(key => localStorage.removeItem(key));
+        }
+        catch (error) {
+            console.warn('LocalStorage缓存清空失败:', error);
+        }
+    }
+}
+/**
+ * 复合缓存类 - 结合内存和本地存储
+ */
+class HybridCache {
+    constructor() {
+        this.memoryCache = new MemoryCache();
+        this.localStorageCache = new LocalStorageCache();
+    }
+    /**
+     * 设置缓存（同时存储到内存和本地存储）
+     */
+    set(key, value, ttl = 5 * 60 * 1000) {
+        this.memoryCache.set(key, value, ttl);
+        this.localStorageCache.set(key, value, ttl);
+    }
+    /**
+     * 获取缓存（优先从内存获取，否则从本地存储获取）
+     */
+    get(key) {
+        // 先从内存获取
+        let value = this.memoryCache.get(key);
+        if (value !== null) {
+            return value;
+        }
+        // 内存没有则从本地存储获取
+        value = this.localStorageCache.get(key);
+        if (value !== null) {
+            // 同步到内存缓存
+            this.memoryCache.set(key, value);
+            return value;
+        }
+        return null;
+    }
+    /**
+     * 删除指定缓存
+     */
+    delete(key) {
+        this.memoryCache.delete(key);
+        this.localStorageCache.delete(key);
+    }
+    /**
+     * 清空所有缓存
+     */
+    clear() {
+        this.memoryCache.clear();
+        this.localStorageCache.clear();
+    }
+    /**
+     * 销毁缓存实例
+     */
+    destroy() {
+        this.memoryCache.destroy();
+    }
+}
+/**
+ * 缓存工厂类
+ */
+class CacheFactory {
+    static create(storageType = 'memory+local') {
+        switch (storageType) {
+            case 'memory':
+                return new MemoryCache();
+            case 'local':
+                return new LocalStorageCache();
+            case 'memory+local':
+            default:
+                return new HybridCache();
+        }
+    }
+}
+// 默认导出混合缓存实例
+export const requestCache = CacheFactory.create('memory+local');
+// 导出缓存工厂和工具函数
+export { CacheFactory, MemoryCache, LocalStorageCache, HybridCache, hashString, isLocalStorageAvailable };

package/dist/etherreq.js

@@ -0,0 +1,84 @@
+// 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;
+        }
+        // 检查 url 是否存在
+        if (!config.url) {
+            throw new Error('请求配置中缺少 url 属性');
+        }
+        let response;
+        const { url, method = 'GET', headers = {}, body } = config;
+        let text = '';
+        try {
+            const options = {
+                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 格式');
+            }
+            const data = JSON.parse(text);
+            response = {
+                data,
+                status: res.status,
+                statusText: res.statusText,
+                headers: Object.fromEntries(res.headers.entries()),
+                config,
+            };
+        }
+        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);
+                }
+            }
+            throw error;
+        }
+        // 响应拦截器执行
+        for (const interceptor of interceptors.response) {
+            response = await interceptor.fulfilled(response);
+        }
+        return response;
+    };
+    const instance = (config) => {
+        return dispatchRequest({
+            ...defaultConfig,
+            ...config,
+        });
+    };
+    instance.use = (fulfilled, rejected) => use(fulfilled, rejected, 'request');
+    instance.interceptors = {
+        request: {
+            use: (fulfilled, rejected) => use(fulfilled, rejected, 'request'),
+        },
+        response: {
+            use: (fulfilled, rejected) => use(fulfilled, rejected, 'response'),
+        },
+    };
+    return instance;
+};

package/dist/index.js

@@ -0,0 +1,59 @@
+// src/index.ts
+import { request, baseURL as _baseURL, setBaseURL } from './request';
+// 示例封装方法
+const createMethod = (method) => (url, data, callback) => {
+    let options;
+    if (data &&
+        typeof data === 'object' &&
+        !Array.isArray(data) &&
+        !(data instanceof FormData) &&
+        !data.method &&
+        !data.headers &&
+        !data.params &&
+        !data.baseURL) {
+        options = { body: data, method: method };
+    }
+    else {
+        options = { ...data, method: method };
+    }
+    const promise = request(url, options);
+    if (typeof callback === 'function') {
+        promise.then(data => callback(null, data)).catch(err => callback(err, null));
+    }
+    else {
+        return promise;
+    }
+};
+export const etherreq = Object.assign((url, options, callback) => createMethod('GET')(url, options, callback), {
+    get: createMethod('GET'),
+    post: createMethod('POST'),
+    put: createMethod('PUT'),
+    delete: createMethod('DELETE'),
+    del: createMethod('DELETE'),
+    head: createMethod('HEAD'),
+    options: createMethod('OPTIONS'),
+    patch: createMethod('PATCH'),
+    login: (url, data, callback) => {
+        // 确保总是获得Promise对象，即使提供了callback
+        const loginPromise = createMethod('POST')(url, data);
+        // 如果createMethod返回undefined（提供了callback的情况），创建一个新的Promise
+        const promiseToUse = loginPromise instanceof Promise ? loginPromise : request(url, {
+            ...(typeof data === 'object' && !Array.isArray(data) && !(data instanceof FormData) ? { body: data } : data),
+            method: 'POST'
+        });
+        promiseToUse.then((response) => {
+            const token = response.data?.token;
+            if (token) {
+                localStorage.setItem('token', token); // 保存 token 到 localStorage
+            }
+            return response;
+        });
+        if (typeof callback === 'function') {
+            promiseToUse.then(data => callback(null, data)).catch(err => callback(err, null));
+        }
+        else {
+            return promiseToUse;
+        }
+    },
+});
+export { setBaseURL, _baseURL as baseURL };