etherreq 1.2.5 → 1.2.7

package/dist/etherreq.js

@@ -1,68 +1,101 @@
+/**
+ * 创建一个可配置的 HTTP 客户端
+ * @param defaultConfig - 默认配置（支持 baseURL, headers 等）
+ */
 export const create = (defaultConfig = {}) => {
-    // 拦截器存储
     const requestInterceptors = [];
     const responseInterceptors = [];
+    /**
+     * 核心请求函数
+     */
     const client = async (config) => {
-        // 合并默认配置
-        const mergedConfig = { ...defaultConfig, ...config };
+        // 合并配置：传入 config > defaultConfig，确保url始终存在
+        const { url, method: inputMethod, ...configWithoutUrl } = config; // 分离url和其他配置
+        const mergedConfig = {
+            url, // 确保url存在
+            method: (inputMethod ?? defaultConfig.method ?? 'GET'), // 使用输入的method或默认GET，并添加类型断言
+            headers: {
+                ...defaultConfig?.headers,
+                ...config.headers,
+            },
+            baseURL: config.baseURL ?? defaultConfig.baseURL,
+            body: config.body ?? defaultConfig.body,
+            params: config.params ?? defaultConfig.params,
+            cache: config.cache ?? defaultConfig.cache,
+            ...configWithoutUrl, // 使用分离后的配置，避免defaultConfig覆盖已明确设置的值
+        };
+        // 🔧 自动拼接 baseURL（如果提供了）
+        let finalUrl = mergedConfig.url;
+        if (mergedConfig.baseURL && mergedConfig.url && !mergedConfig.url.startsWith('http')) {
+            try {
+                finalUrl = new URL(mergedConfig.url, mergedConfig.baseURL).toString();
+            }
+            catch (err) {
+                throw new Error(`[etherreq] Invalid URL: ${mergedConfig.url} with base ${mergedConfig.baseURL}`);
+            }
+        }
         // 应用请求拦截器
-        let processedConfig = { ...mergedConfig };
+        let processedConfig = { ...mergedConfig, url: finalUrl };
         for (const interceptor of requestInterceptors) {
-            processedConfig = await interceptor(processedConfig);
+            processedConfig = await Promise.resolve(interceptor(processedConfig));
         }
+        const { url: processedUrl, method: processedMethod, headers, body, ...rest } = processedConfig;
+        // ✅ 关键：只在非 GET/HEAD/OPTIONS 时发送 body
+        const hasBody = body != null &&
+            processedMethod !== 'GET' &&
+            processedMethod !== 'HEAD' &&
+            processedMethod !== 'OPTIONS';
         try {
-            // 确定是否需要发送请求体
-            const method = processedConfig.method || 'GET';
-            const hasBody = processedConfig.body &&
-                method !== 'GET' &&
-                method !== 'HEAD' &&
-                method !== 'OPTIONS';
-            // 发送请求
-            const response = await fetch(processedConfig.url, {
-                method,
-                headers: {
-                    ...(processedConfig.headers || {}),
-                },
-                // 只有非GET/HEAD/OPTIONS请求才发送body
-                body: hasBody ? JSON.stringify(processedConfig.body) : undefined,
-            });
-            // 检查响应状态
+            const fetchOptions = {
+                method: processedMethod,
+                headers: headers || {},
+            };
+            if (hasBody) {
+                // 自动序列化 JSON（可扩展支持 FormData 等）
+                fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
+            }
+            const response = await fetch(processedUrl, fetchOptions);
             if (!response.ok) {
                 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
             }
-            // 解析响应数据
-            const data = await response.json();
+            // 尝试解析 JSON，失败则返回文本
+            let data;
+            const contentType = response.headers.get('content-type');
+            if (contentType && contentType.includes('application/json')) {
+                data = await response.json();
+            }
+            else {
+                data = await response.text();
+            }
             let responseObject = {
                 data,
                 status: response.status,
                 statusText: response.statusText,
-                headers: response.headers,
+                headers: Object.fromEntries(response.headers.entries()),
                 config: processedConfig,
             };
             // 应用响应拦截器
             for (const interceptor of responseInterceptors) {
-                responseObject = await interceptor(responseObject);
+                responseObject = await Promise.resolve(interceptor(responseObject));
             }
             return responseObject;
         }
         catch (error) {
-            // 如果是网络错误或其他类型的错误
             throw new Error(`Request failed: ${error.message}`);
         }
     };
-    // 拦截器接口
+    // 拦截器 API
     client.interceptors = {
         request: {
-            use: (fulfilled, rejected) => {
-                requestInterceptors.push(fulfilled);
+            use: (onFulfilled, onRejected) => {
+                requestInterceptors.push(onFulfilled);
             },
         },
         response: {
-            use: (fulfilled, rejected) => {
-                responseInterceptors.push(fulfilled);
+            use: (onFulfilled, onRejected) => {
+                responseInterceptors.push(onFulfilled);
             },
         },
     };
     return client;
 };
-export {};

package/dist/index.js

@@ -2,33 +2,30 @@
 import { request, baseURL as _baseURL, setBaseURL } from './request.js';
 // 示例封装方法
 const createMethod = (method) => (url, data, callback) => {
-    let options;
+    let options = { method }; // 修复：排除URL字段，明确指定method类型
     if (data &&
         typeof data === 'object' &&
         !Array.isArray(data) &&
-        !(data instanceof FormData) &&
-        !data.method &&
-        !data.headers &&
-        !data.params &&
-        !data.baseURL) {
-        // 对于GET请求，不应发送body，而是将数据作为params处理
-        if (method.toUpperCase() === 'GET') {
-            options = { params: data, method: method };
-        }
-        else {
-            options = { body: data, method: method };
-        }
+        method in { POST: 1, PUT: 1, PATCH: 1 }) {
+        // 有数据对象且为 POST/PUT/PATCH 请求
+        options = { ...options, params: data };
+    }
+    else if (data && typeof data !== 'function') {
+        // 有数据但不是对象（如原始类型）
+        options = { ...options, body: data };
     }
     else {
-        options = { ...data, method: method };
+        // 没有数据或数据是回调函数
+        if (typeof data === 'function')
+            callback = data;
     }
     const promise = request(url, options);
-    if (typeof callback === 'function') {
-        promise.then(data => callback(null, data)).catch(err => callback(err, null));
-    }
-    else {
-        return promise;
+    if (callback) {
+        promise
+            .then(data => callback(null, data))
+            .catch(err => callback(err, null));
     }
+    return promise;
 };
 export const etherreq = Object.assign((url, options, callback) => createMethod('GET')(url, options, callback), {
     get: createMethod('GET'),

package/dist/request.js

@@ -3,11 +3,11 @@ import { create } from './etherreq.js';
 import { requestCache, getCacheKey } from './cache.js';
 // 创建一个带有默认配置的请求实例
 const instance = create({
-    baseURL: 'https://api.example.com', // 默认基础 URL
+    baseURL: 'https://api.example.com', // 默认基础 URL（可被覆盖）
 });
 // 请求拦截器
 instance.interceptors.request.use((config) => {
-    const token = localStorage.getItem('token');
+    const token = typeof localStorage !== 'undefined' ? localStorage.getItem('token') : null;
     const headers = {
         ...(config.headers || {}),
         Authorization: token ? `Bearer ${token}` : undefined,
@@ -56,51 +56,63 @@ let _baseURL = 'https://api.example.com'; // 内部变量用于保存 base URL
  * 判断是否应该禁用缓存
  */
 function shouldDisableCache(config) {
-    // 检查请求级别的缓存禁用
     if (config.cache === false || config.disableCache) {
         return true;
     }
-    // 检查缓存配置
     if (config.cache && config.cache.enabled === false) {
         return true;
     }
     return false;
 }
 /**
- * 获取缓存过期时间
+ * 获取缓存过期时间（毫秒）
  */
 function getCacheTTL(config) {
     if (config.cache && typeof config.cache.ttl === 'number') {
         return config.cache.ttl;
     }
-    return 5 * 60 * 1000; // 默认5分钟
+    return 5 * 60 * 1000; // 默认 5 分钟
 }
 /**
- * 封装 request 函数，支持 baseURL 拼接等逻辑
- * @param url - 请求路径
+ * 封装 request 函数，支持 baseURL 拼接、URL 校验等
+ * @param url - 请求路径（必须是非空字符串）
  * @param options - 请求配置
  */
 export const request = (url, options = {}) => {
-    // 如果 options.baseURL 存在则使用它，否则使用全局 _baseURL，如果都不存在则使用当前页面的 origin
-    const baseURL = options.baseURL || _baseURL || (typeof window !== 'undefined' ? window.location.origin : '');
-    // 构造最终的 URL，如果 baseURL 为空则直接使用传入的 url
+    // 🔴 关键：严格校验 url
+    if (typeof url !== 'string' || url.trim() === '') {
+        throw new Error(`[etherreq] Invalid URL: "${String(url)}". Expected a non-empty string.`);
+    }
+    // 确定 baseURL：优先使用 options.baseURL，其次全局 _baseURL，最后 fallback 到当前页面 origin（仅浏览器）
+    let baseURL = options.baseURL || _baseURL;
+    if (!baseURL && typeof window !== 'undefined') {
+        baseURL = window.location.origin;
+    }
+    // 构造最终 URL
     let finalURL;
     if (baseURL && !url.startsWith('http')) {
-        // 只有当 url 不是绝对 URL 时才拼接 baseURL
-        finalURL = new URL(url, baseURL).toString();
+        try {
+            finalURL = new URL(url, baseURL).toString();
+        }
+        catch (err) {
+            throw new Error(`[etherreq] Invalid URL combination: base="${baseURL}", path="${url}"`);
+        }
     }
     else {
-        // 如果 url 是绝对 URL 或者 baseURL 为空，则直接使用 url
         finalURL = url;
     }
     return instance({
+        url: finalURL, // 明确指定url属性
         ...options,
-        url: finalURL,
     });
 };
-// 导出可读写的 baseURL 变量
-export { _baseURL as baseURL };
-// 允许外部设置 baseURL
+// 导出 baseURL 供读取（只读）
+export const baseURL = _baseURL;
+// 允许外部设置全局 baseURL
 export const setBaseURL = (newBaseURL) => {
-    _baseURL = newBaseURL;
+    if (typeof newBaseURL !== 'string' || newBaseURL.trim() === '') {
+        console.warn('[etherreq] setBaseURL received invalid value:', newBaseURL);
+        return;
+    }
+    _baseURL = newBaseURL.trim();
 };

package/dist/types/etherreq.d.ts

@@ -1,18 +1,17 @@
-export declare const create: (defaultConfig?: any) => {
-    (config: any): Promise<{
-        data: any;
-        status: number;
-        statusText: string;
-        headers: Headers;
-        config: any;
-    }>;
+import type { EtherRequestOptions } from './types/cache.js';
+import type { RequestConfig as EtherRequestConfig } from './types/config.js';
+/**
+ * 创建一个可配置的 HTTP 客户端
+ * @param defaultConfig - 默认配置（支持 baseURL, headers 等）
+ */
+export declare const create: (defaultConfig?: Partial<EtherRequestConfig>) => {
+    (config: EtherRequestOptions): Promise<any>;
     interceptors: {
         request: {
-            use: (fulfilled: any, rejected: any) => void;
+            use: (onFulfilled: (config: any) => any, onRejected?: any) => void;
         };
         response: {
-            use: (fulfilled: any, rejected: any) => void;
+            use: (onFulfilled: (response: any) => any, onRejected?: any) => void;
         };
     };
 };
-export {};

package/dist/types/index.d.ts

@@ -1,14 +1,14 @@
 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;
-    put: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any> | undefined;
-    delete: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any> | undefined;
-    del: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any> | undefined;
-    head: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any> | undefined;
-    options: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any> | undefined;
-    patch: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any> | undefined;
+export declare const etherreq: ((url: string, options?: EtherRequestOptions, callback?: (error: Error | null, data: any) => void) => Promise<any>) & {
+    get: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any>;
+    post: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any>;
+    put: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any>;
+    delete: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any>;
+    del: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any>;
+    head: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any>;
+    options: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any>;
+    patch: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any>;
     login: (url: string, data?: any, callback?: (error: Error | null, data: any) => void) => Promise<any> | undefined;
 };
 export { setBaseURL, _baseURL as baseURL };

package/dist/types/request.d.ts

@@ -1,10 +1,18 @@
-import type { EtherRequestOptions } from './types/cache.js';
-declare let _baseURL: string;
+import type { CacheOptions } from './types/cache.js';
+interface RequestConfigWithoutUrl {
+    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;
+}
 /**
- * 封装 request 函数，支持 baseURL 拼接等逻辑
- * @param url - 请求路径
+ * 封装 request 函数，支持 baseURL 拼接、URL 校验等
+ * @param url - 请求路径（必须是非空字符串）
  * @param options - 请求配置
  */
-export declare const request: (url: string, options?: EtherRequestOptions) => Promise<any>;
-export { _baseURL as baseURL };
+export declare const request: (url: string, options?: RequestConfigWithoutUrl) => Promise<any>;
+export declare const baseURL: string;
 export declare const setBaseURL: (newBaseURL: string) => void;
+export {};

package/dist/types/types/cache.d.ts

@@ -37,6 +37,7 @@ export interface CacheOptions {
  * 请求级别的完整选项（包含缓存）
  */
 export interface EtherRequestOptions {
+    url: string;
     method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
     headers?: Record<string, string>;
     body?: any;

package/package.json

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