@seayoo-web/request 3.5.2 → 4.0.1

package/dist/wx.js

@@ -1,61 +1,70 @@
-import { h as i, r as p, c as f, H as l, E as h, a as d, i as y, N as g } from "./retry-Cxkf8ke1.js";
-import { g as E } from "./retry-Cxkf8ke1.js";
-const m = async function(t, n, r) {
-  return i(await p(x, t, n, r), t, n, r);
-}, x = async function(t, n, r) {
-  const e = await f(t, n, r), a = e.method === "PATCH" ? "POST" : e.method, u = l(e.url, e.params);
-  return h() ? new Promise((c) => {
+import { h as l, r as p, c as y, E as R, R as u, f as x, a as h, t as c, N as w } from "./retry-b0Etywu_.js";
+import { g as O } from "./retry-b0Etywu_.js";
+const m = async function(s, o, n) {
+  return l(await p(q, s, o, n), s, o, n);
+}, q = async function(s, o, n) {
+  const t = await y(s, o, n), r = t.method;
+  return !R() || r === "PATCH" ? {
+    url: t.url,
+    method: r,
+    status: -1,
+    error: u.NotSupport,
+    statusText: u.NotSupport,
+    body: ""
+  } : new Promise((f) => {
     wx.request({
-      url: u,
-      data: e.body,
-      header: e.headers,
-      method: a,
-      dataType: "string",
-      responseType: "text",
-      fail() {
-        c({
-          url: u,
-          method: a,
+      url: t.url,
+      data: t.body,
+      header: t.headers,
+      method: r,
+      dataType: "raw",
+      timeout: t.timeout,
+      responseType: t.asBuffer ? "arraybuffer" : "text",
+      fail({ errMsg: e, errno: d, exception: i }) {
+        f({
+          url: t.url,
+          method: r,
           status: -1,
-          statusText: d.Unknown,
-          body: ""
+          error: u.Unknown,
+          statusText: e,
+          body: JSON.stringify({ errMsg: e, errno: d, exception: i })
         });
       },
-      success(o) {
-        c({
-          url: u,
-          method: a,
-          status: o.statusCode,
-          statusText: o.statusCode + "",
-          headers: { ...o.header },
-          body: e.method === "HEAD" || o.statusCode === 204 ? "" : R(o.data)
-        });
+      async success(e) {
+        f(
+          await x(
+            {
+              url: t.url,
+              method: r,
+              status: e.statusCode,
+              statusText: `WxRequest${e.statusCode}`,
+              headers: { ...e.header },
+              body: null
+            },
+            {
+              asBuffer: t.asBuffer,
+              text: () => c(e.data),
+              buffer: async () => e.data instanceof ArrayBuffer ? e.data : await h(c(e.data))
+            }
+          )
+        );
       }
     });
-  }) : {
-    url: u,
-    method: a,
-    status: -1,
-    statusText: d.NotSupport,
-    body: ""
-  };
+  });
 };
-function R(t) {
-  return typeof t == "string" ? t : t instanceof ArrayBuffer && y() ? new TextDecoder().decode(t) : JSON.stringify(t);
-}
 // @__NO_SIDE_EFFECTS__
-function q(t) {
-  return new g(m, t);
+function b(s) {
+  return new w(m, s);
 }
-const s = /* @__PURE__ */ q(), T = s.setConfig, b = s.head, C = s.get, H = s.post, N = s.del, S = s.put;
+const a = /* @__PURE__ */ b(), T = a.setConfig, N = a.head, B = a.get, C = a.post, S = a.del, A = a.put;
 export {
-  q as NetRequest,
-  d as RequestInternalError,
-  N as del,
-  C as get,
-  E as getResponseRulesDescription,
-  b as head,
-  H as post,
-  S as put,
+  b as NetRequest,
+  u as RequestInternalError,
+  S as del,
+  B as get,
+  O as getResponseRulesDescription,
+  N as head,
+  C as post,
+  A as put,
   T as setGlobalConfig
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seayoo-web/request",
-  "version": "3.5.2",
+  "version": "4.0.1",
   "description": "request tools for seayoo web",
   "type": "module",
   "source": "./src/index.ts",

package/types/inc/cache.d.ts

@@ -1,4 +1,4 @@
-import { RequestCacheResolve } from "./type";
+import { RequestCacheResolve, RequestQueryParams } from "./type";
 /** 为 get 请求并发而设计的缓冲工具 */
 export declare class Cache<T = unknown> {
     private ttl;
@@ -6,7 +6,7 @@ export declare class Cache<T = unknown> {
     private timer;
     private loopCheck;
     constructor(ttl?: number);
-    getKey(method: string, url: string, param?: Record<string, unknown>, resolve?: RequestCacheResolve): string;
+    getKey(method: string, url: string, param?: RequestQueryParams, resolve?: RequestCacheResolve): string;
     updateTTL(ttl: number): void;
     get(key: string, ttl?: number): Promise<T> | null;
     set(key: string, action: Promise<T>, ttl?: number): void;

package/types/inc/config.d.ts

@@ -1,10 +1,10 @@
-import type { IRequestGlobalConfig } from "./type";
+import type { RequestGlobalConfig } from "./type";
 import type { SomeRequired } from "@seayoo-web/utils";
-export declare class RequestGlobalConfig {
+export declare class GlobalConfigHelper {
     private config;
-    constructor(config?: IRequestGlobalConfig);
-    set(config: Partial<IRequestGlobalConfig>): void;
-    get<T extends keyof IRequestGlobalConfig>(key: T): SomeRequired<IRequestGlobalConfig, "timeout" | "credentials" | "baseURL" | "maxRetry" | "cacheTTL" | "responseRule" | "retryInterval" | "retryResolve" | "defaultTypeGuardMessage">[T];
+    constructor(config?: RequestGlobalConfig);
+    set(config: Partial<RequestGlobalConfig>): void;
+    get<T extends keyof RequestGlobalConfig>(key: T): SomeRequired<RequestGlobalConfig, "timeout" | "credentials" | "baseURL" | "maxRetry" | "cacheTTL" | "responseRule" | "retryInterval" | "retryResolve" | "defaultTypeGuardMessage">[T];
     /** 基于 baseURL 返回完整的 url 地址 */
     getFullUrl(url: string): string;
     /** 提示消息 */

package/types/inc/guard.d.ts

@@ -1,3 +1,3 @@
-import type { RequestGlobalConfig } from "./config";
-import type { IResponseResult, TypeGuardParam } from "./type";
-export declare function checkTypedDataResult<T>(url: string, result: IResponseResult, config: RequestGlobalConfig, typeGard: TypeGuardParam<T> | null): IResponseResult<T | null | unknown>;
+import type { GlobalConfigHelper } from "./config";
+import type { ResponseResult, DataGuard } from "./type";
+export declare function withGuard<T>(url: string, result: ResponseResult, config: GlobalConfigHelper, dataGuard: DataGuard<T> | null): ResponseResult<T | null | unknown>;

package/types/inc/jsonp.d.ts

@@ -1,9 +1,10 @@
+import { RequestQueryParams } from "./type";
 import type { TypeGuardFn } from "@seayoo-web/utils";
 /**
  * 以 script 方式加载远程资源，资源通过回调函数接收，强制进行类型校验
  */
-export declare function jsonp<T>(url: string, typeGuard: TypeGuardFn<T>, params?: Record<string, string | number | boolean>): Promise<T | null>;
+export declare function jsonp<T>(url: string, typeGuard: TypeGuardFn<T>, params?: RequestQueryParams): Promise<T | null>;
 /**
  * 以 script 方式加载远程资源，资源通过全局变量接收，强制进行类型校验
  */
-export declare function jsonx<T>(url: string, typeGuard: TypeGuardFn<T>, params?: Record<string, string | number | boolean>): Promise<T | null>;
+export declare function jsonx<T>(url: string, typeGuard: TypeGuardFn<T>, params?: RequestQueryParams): Promise<T | null>;

package/types/inc/main.d.ts

@@ -1,63 +1,80 @@
-import type { TypeGuardParam, IRequestOptions, IRequestGlobalConfig, IResponseResult, NetRequestAgent, ResponseWithType, ResponseWithoutType } from "./type";
-type RequestBody = NonNullable<IRequestOptions["body"]>;
+import type { DataGuard, RequestOptions, RequestGlobalConfig, ResponseResult, NetRequestAgent, ResponseWithType, ResponseWithoutType, RequestQueryParams } from "./type";
+type RequestBody = NonNullable<RequestOptions["body"]>;
+export type URLPlus = string | {
+    url: string;
+    params: RequestQueryParams;
+};
+export type BufferRequestOptions = RequestOptions & {
+    asBuffer: true;
+};
 /** 工具函数主类 */
 export declare class NetRequestHandler {
     private agent;
     private config;
     private cache;
-    constructor(agent: NetRequestAgent, config?: IRequestGlobalConfig);
+    constructor(agent: NetRequestAgent, config?: RequestGlobalConfig);
+    /** 发送网络请求，含有缓存控制逻辑，不含有 guard 逻辑 */
+    private send;
     /**
-     * 执行网络请求
+     * 发送一个网络请求，method 默认是 `GET`。推荐使用包装函数，如 `get` / `post` 等
      */
-    request(url: string, options?: IRequestOptions): Promise<IResponseResult<unknown>>;
-    /**
-     * 检查响应的数据类型
-     */
-    private guard;
+    request(op: {
+        url: string;
+        options?: RequestOptions;
+    }): Promise<ResponseResult<unknown>>;
+    request<T>(op: {
+        url: string;
+        options?: RequestOptions;
+        guard: DataGuard<T>;
+    }): Promise<ResponseResult<T>>;
+    /** 整理合并通用参数 */
+    private gen;
     /**
      * 修改默认请求配置: baseURL / timeout / credentials / errorHandler / messageHandler / responseHandler / logHandler / responseRule
      */
-    setConfig(config: IRequestGlobalConfig): void;
+    setConfig(config: RequestGlobalConfig): void;
     /**
      * 读取默认的请求配置
      */
-    getConfig<T extends keyof IRequestGlobalConfig>(key: T): import("@seayoo-web/utils").SomeRequired<IRequestGlobalConfig, "timeout" | "credentials" | "baseURL" | "maxRetry" | "cacheTTL" | "responseRule" | "retryInterval" | "retryResolve" | "defaultTypeGuardMessage">[T];
+    getConfig<T extends keyof RequestGlobalConfig>(key: T): import("@seayoo-web/utils").SomeRequired<RequestGlobalConfig, "timeout" | "credentials" | "baseURL" | "maxRetry" | "cacheTTL" | "responseRule" | "retryInterval" | "retryResolve" | "defaultTypeGuardMessage">[T];
     /**
      * 发送一个 HEAD 请求，并且不处理响应 body
      */
-    head(url: string, options?: IRequestOptions): ResponseWithoutType;
+    head(url: string, params?: RequestQueryParams | null, options?: Omit<RequestOptions, "asBuffer">): ResponseWithoutType;
     /**
      * 发送一个 GET 请求，请求自带 500ms 缓冲控制以应对并发场景
      */
-    get(url: string): ResponseWithoutType;
-    get(url: string, typeGard: null, options?: IRequestOptions): ResponseWithoutType;
-    get<T>(url: string, typeGard: TypeGuardParam<T>, options?: IRequestOptions): ResponseWithType<T>;
+    get(url: string, params?: RequestQueryParams): ResponseWithoutType;
+    get(url: string, params: RequestQueryParams | null, guard: null, options: BufferRequestOptions): ResponseWithType<ArrayBuffer>;
+    get(url: string, params: RequestQueryParams | null, guard: null, options?: RequestOptions): ResponseWithoutType;
+    get<T>(url: string, params: RequestQueryParams | null, guard: DataGuard<T>, options?: RequestOptions): ResponseWithType<T>;
     /**
-     * 发送一个 POST 请求，可选 typeGuard 用于检查数据类型
+     * 发送一个 POST 请求
      */
-    post(url: string): ResponseWithoutType;
-    post(url: string, data: RequestBody): ResponseWithoutType;
-    post(url: string, data: RequestBody, typeGard: null, options?: IRequestOptions): ResponseWithoutType;
-    post<T>(url: string, data: RequestBody, typeGard: TypeGuardParam<T>, options?: IRequestOptions): ResponseWithType<T>;
+    post(url: URLPlus, data?: RequestBody): ResponseWithoutType;
+    post(url: URLPlus, body: RequestBody, guard: null, options: BufferRequestOptions): ResponseWithType<ArrayBuffer>;
+    post(url: URLPlus, body: RequestBody, guard: null, options?: RequestOptions): ResponseWithoutType;
+    post<T>(url: URLPlus, body: RequestBody, guard: DataGuard<T>, options?: RequestOptions): ResponseWithType<T>;
     /**
-     * 发送一个 DELETE 请求，可选 typeGuard 用于检查数据类型
+     * 发送一个 DELETE 请求
      */
-    del(url: string): ResponseWithoutType;
-    del(url: string, typeGard: null, options?: IRequestOptions): ResponseWithoutType;
-    del<T>(url: string, typeGard: TypeGuardParam<T>, options?: IRequestOptions): ResponseWithType<T>;
+    del(url: string, params?: RequestQueryParams): ResponseWithoutType;
+    del(url: string, params: RequestQueryParams | null, guard: null, options: BufferRequestOptions): ResponseWithType<ArrayBuffer>;
+    del(url: string, params: RequestQueryParams | null, guard: null, options?: RequestOptions): ResponseWithoutType;
+    del<T>(url: string, params: RequestQueryParams | null, guard: DataGuard<T>, options?: RequestOptions): ResponseWithType<T>;
     /**
-     * 发送一个 PUT 请求，可选 typeGuard 用于检查数据类型
+     * 发送一个 PUT 请求
      */
-    put(url: string): ResponseWithoutType;
-    put(url: string, data: RequestBody): ResponseWithoutType;
-    put(url: string, data: RequestBody, typeGard: null, options?: IRequestOptions): ResponseWithoutType;
-    put<T>(url: string, data: RequestBody, typeGard: TypeGuardParam<T>, options?: IRequestOptions): ResponseWithType<T>;
+    put(url: URLPlus, body?: RequestBody): ResponseWithoutType;
+    put(url: URLPlus, body: RequestBody, guard: null, options: BufferRequestOptions): ResponseWithType<ArrayBuffer>;
+    put(url: URLPlus, body: RequestBody, guard: null, options?: RequestOptions): ResponseWithoutType;
+    put<T>(url: URLPlus, body: RequestBody, guard: DataGuard<T>, options?: RequestOptions): ResponseWithType<T>;
     /**
-     * 发送一个 PATCH 请求，可选 typeGuard 用于检查数据类型
+     * 发送一个 PATCH 请求
      */
-    patch(url: string): ResponseWithoutType;
-    patch(url: string, data: RequestBody): ResponseWithoutType;
-    patch(url: string, data: RequestBody, typeGard: null, options?: IRequestOptions): ResponseWithoutType;
-    patch<T>(url: string, data: RequestBody, typeGard: TypeGuardParam<T>, options?: IRequestOptions): ResponseWithType<T>;
+    patch(url: URLPlus, data?: RequestBody): ResponseWithoutType;
+    patch(url: URLPlus, body: RequestBody, guard: null, options: BufferRequestOptions): ResponseWithType<ArrayBuffer>;
+    patch(url: URLPlus, body: RequestBody, guard: null, options?: RequestOptions): ResponseWithoutType;
+    patch<T>(url: URLPlus, body: RequestBody, guard: DataGuard<T>, options?: RequestOptions): ResponseWithType<T>;
 }
 export {};

package/types/inc/option.d.ts

@@ -1,11 +1,10 @@
-import type { RequestGlobalConfig } from "./config";
-import type { IBaseRequestOptions, IBaseRequestBody } from "./type";
-type FixedRequestOptions = Omit<Required<IBaseRequestOptions>, "params" | "body" | "abort"> & {
+import type { GlobalConfigHelper } from "./config";
+import type { BaseRequestOptions, BaseRequestBody } from "./type";
+type FixedRequestOptions = Omit<Required<BaseRequestOptions>, "params" | "body" | "abort"> & {
     url: string;
-    params: Record<string, string>;
-    abort?: IBaseRequestOptions["abort"];
+    abort?: BaseRequestOptions["abort"];
     body: ReturnType<typeof convertBody>;
 };
-export declare function convertOptions(url: string, config: RequestGlobalConfig, options?: IBaseRequestOptions): Promise<FixedRequestOptions>;
-declare function convertBody(body: IBaseRequestOptions["body"]): IBaseRequestBody | undefined;
+export declare function convertOptions(url: string, config: GlobalConfigHelper, options?: BaseRequestOptions): Promise<FixedRequestOptions>;
+declare function convertBody(body: BaseRequestOptions["body"]): BaseRequestBody | undefined;
 export {};

package/types/inc/request.xhr.d.ts

@@ -1,6 +1,6 @@
-import type { NetRequestAgent, IRequestGlobalConfig, IRequestOptions, IResponseResult, IRetryRequestOptions, IBaseRequestOptions } from "./type";
+import type { NetRequestAgent, RequestGlobalConfig, RequestOptions, ResponseResult, RetryRequestOptions, BaseRequestOptions } from "./type";
 /** 进度回调函数配置 */
-interface XHRequestOptions extends IBaseRequestOptions {
+interface XHRequestOptions extends BaseRequestOptions {
     onUploadProgress?: (progress: {
         total: number;
         loaded: number;
@@ -15,10 +15,10 @@ export declare const xhRequest: NetRequestAgent;
 /**
  * 上传文件，支持进度信息和多文件上传，不抛错，限制在浏览器中使用，不支持重试
  */
-export declare function xhrUpload(url: string, files: Record<string, Blob> | Blob, options?: Omit<IRequestOptions, keyof XHRequestOptions | keyof IRetryRequestOptions> & Omit<XHRequestOptions, "body" | "method"> & {
+export declare function xhrUpload(url: string, files: Record<string, Blob> | Blob, options?: Omit<RequestOptions, keyof XHRequestOptions | keyof RetryRequestOptions> & Omit<XHRequestOptions, "body" | "method"> & {
     body?: Record<string, unknown>;
     method?: "POST" | "PUT";
 }, 
 /** 全局配置中独有的配置，以受全局配置控制 */
-config?: Omit<IRequestGlobalConfig, keyof IRequestOptions>): Promise<IResponseResult>;
+config?: Omit<RequestGlobalConfig, keyof RequestOptions>): Promise<ResponseResult>;
 export {};

package/types/inc/response.d.ts

@@ -1,3 +1,8 @@
-import type { RequestGlobalConfig } from "./config";
-import type { IRequestOptions, IResponseResult, IRequestBaseResponse } from "./type";
-export declare function handleResponse(res: IRequestBaseResponse, url: string, config: RequestGlobalConfig, options?: IRequestOptions): IResponseResult;
+import type { GlobalConfigHelper } from "./config";
+import type { RequestOptions, ResponseResult, RequestBaseResponse } from "./type";
+export declare function formatResponse(baseResult: RequestBaseResponse, options: {
+    asBuffer?: boolean;
+    text: () => Promise<string> | string;
+    buffer: () => Promise<ArrayBuffer> | ArrayBuffer;
+}): Promise<RequestBaseResponse>;
+export declare function handleResponse(res: RequestBaseResponse, url: string, config: GlobalConfigHelper, options?: RequestOptions): ResponseResult;

package/types/inc/retry.d.ts

@@ -1,3 +1,3 @@
-import type { RequestGlobalConfig } from "./config";
-import type { NetRequestCoreFn, IRequestOptions } from "./type";
-export declare function retryRequest(agent: NetRequestCoreFn, url: string, config: RequestGlobalConfig, options?: IRequestOptions, _try?: number): ReturnType<NetRequestCoreFn>;
+import type { GlobalConfigHelper } from "./config";
+import type { NetRequestCoreFn, RequestOptions } from "./type";
+export declare function retryRequest(agent: NetRequestCoreFn, url: string, config: GlobalConfigHelper, options?: RequestOptions, _try?: number): ReturnType<NetRequestCoreFn>;

package/types/inc/rule.d.ts

@@ -1,12 +1,12 @@
-import type { IResponseResult, IResponseRule } from "./type";
-type ResponseInfo = Pick<IResponseResult, "ok" | "code" | "data" | "message">;
+import type { ResponseResult, ResponseRule, RequestBaseResponse } from "./type";
+type ResponseInfo = Pick<ResponseResult, "ok" | "code" | "data" | "message">;
 /**
  * 分析响应内容中的错误信息和数据
  */
-export declare function analysesResponse(status: number, statusText: string, responseText: string, globalRule: IResponseRule, rule?: IResponseRule): ResponseInfo;
+export declare function analysesResponse(res: RequestBaseResponse, globalRule: ResponseRule, rule?: ResponseRule): ResponseInfo;
+export declare function statusOK(status: number): boolean;
 /**
  * 将 Response Rules 转化成为自然描述语言
  */
-export declare const getResponseRulesDescription: (rules: IResponseRule) => string;
-export declare function statusOK(status: number): boolean;
+export declare const getResponseRulesDescription: (rules: ResponseRule) => string;
 export {};

package/types/inc/sentry.d.ts

@@ -1,12 +1,12 @@
-import type { ERequestRawError, IRequestGlobalConfig } from "./type";
+import type { ERequestRawError, RequestGlobalConfig, ResponseBody } from "./type";
 /** 根据响应组织整理 sentry 上报信息 */
 export declare function getSentryExceptionData(data: {
     url: string;
     status: number;
-    code: string;
     method: string;
+    code: string;
     message: string;
-    body: string;
+    body: ResponseBody;
     headers: Record<string, string>;
     error?: ERequestRawError;
-}): Pick<Parameters<NonNullable<IRequestGlobalConfig["errorHandler"]>>[0], "sentryError" | "sentryTags" | "sentryExtra">;
+}): Pick<Parameters<NonNullable<RequestGlobalConfig["errorHandler"]>>[0], "sentryError" | "sentryTags" | "sentryExtra">;