@kevisual/query 0.0.40 → 0.0.42

package/dist/query.js

@@ -1,384 +1,303 @@
-const isTextForContentType = (contentType) => {
-    if (!contentType)
-        return false;
-    const textTypes = ['text/', 'xml', 'html', 'javascript', 'css', 'csv', 'plain', 'x-www-form-urlencoded', 'md'];
-    return textTypes.some((type) => contentType.includes(type));
+// src/adapter.ts
+var isTextForContentType = (contentType) => {
+  if (!contentType)
+    return false;
+  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md"];
+  return textTypes.some((type) => contentType.includes(type));
 };
-/**
- *
- * @param opts
- * @param overloadOpts 覆盖fetch的默认配置
- * @returns
- */
-const adapter = async (opts = {}, overloadOpts) => {
-    const controller = new AbortController();
-    const signal = controller.signal;
-    const isPostFile = opts.isPostFile || false; // 是否为文件上传
-    let responseType = opts.responseType || 'json'; // 响应类型
-    if (opts.isBlob) {
-        responseType = 'blob';
-    }
-    else if (opts.isText) {
-        responseType = 'text';
-    }
-    const timeout = opts.timeout || 60000 * 3; // 默认超时时间为 60s * 3
-    const timer = setTimeout(() => {
-        controller.abort();
-    }, timeout);
-    let method = overloadOpts?.method || opts?.method || 'POST';
-    let headers = { ...opts?.headers, ...overloadOpts?.headers };
-    let origin = '';
-    let url;
-    if (opts?.url?.startsWith('http')) {
-        url = new URL(opts.url);
-    }
-    else {
-        origin = window?.location?.origin || 'http://localhost:51515';
-        url = new URL(opts?.url || '', origin);
-    }
-    const isGet = method === 'GET';
-    const oldSearchParams = url.searchParams;
-    if (isGet) {
-        let searchParams = new URLSearchParams({ ...Object.fromEntries(oldSearchParams), ...opts?.params, ...opts?.body });
-        url.search = searchParams.toString();
-    }
-    else {
-        const params = {
-            ...Object.fromEntries(oldSearchParams),
-            ...opts.params,
-        };
-        const searchParams = new URLSearchParams(params);
-        if (typeof opts.body === 'object' && opts.body !== null) {
-            // 浏览器环境下，自动将 body 中的 path 和 key 提取到查询参数中, 更容易排查问题
-            let body = opts.body || {};
-            if (!params.path && body?.path) {
-                searchParams.set('path', body.path);
-                if (body?.key) {
-                    searchParams.set('key', body.key);
-                }
-            }
+var adapter = async (opts = {}, overloadOpts) => {
+  const controller = new AbortController;
+  const signal = controller.signal;
+  const isPostFile = opts.isPostFile || false;
+  let responseType = opts.responseType || "json";
+  if (opts.isBlob) {
+    responseType = "blob";
+  } else if (opts.isText) {
+    responseType = "text";
+  }
+  const timeout = opts.timeout || 60000 * 3;
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+  let method = overloadOpts?.method || opts?.method || "POST";
+  let headers = { ...opts?.headers, ...overloadOpts?.headers };
+  let origin = "";
+  let url;
+  if (opts?.url?.startsWith("http")) {
+    url = new URL(opts.url);
+  } else {
+    origin = globalThis?.location?.origin || "http://localhost:51515";
+    url = new URL(opts?.url || "", origin);
+  }
+  const isGet = method === "GET";
+  const oldSearchParams = url.searchParams;
+  if (isGet) {
+    let searchParams = new URLSearchParams({ ...Object.fromEntries(oldSearchParams), ...opts?.params, ...opts?.body });
+    url.search = searchParams.toString();
+  } else {
+    const params = {
+      ...Object.fromEntries(oldSearchParams),
+      ...opts.params
+    };
+    const searchParams = new URLSearchParams(params);
+    if (typeof opts.body === "object" && opts.body !== null) {
+      let body2 = opts.body || {};
+      if (!params.path && body2?.path) {
+        searchParams.set("path", body2.path);
+        if (body2?.key) {
+          searchParams.set("key", body2.key);
         }
-        url.search = searchParams.toString();
+      }
     }
-    let body = undefined;
-    if (isGet) {
-        body = undefined;
+    url.search = searchParams.toString();
+  }
+  let body = undefined;
+  if (isGet) {
+    body = undefined;
+  } else if (isPostFile) {
+    body = opts.body;
+  } else {
+    if (opts.body && typeof opts.body === "object" && !(opts.body instanceof FormData)) {
+      headers = {
+        "Content-Type": "application/json",
+        ...headers
+      };
+      body = JSON.stringify(opts.body);
     }
-    else if (isPostFile) {
-        body = opts.body; // 如果是文件上传，直接使用 FormData
+  }
+  return fetch(url, {
+    method: method.toUpperCase(),
+    signal,
+    body,
+    ...overloadOpts,
+    headers
+  }).then(async (response) => {
+    const contentType = response.headers.get("Content-Type");
+    if (responseType === "blob") {
+      return await response.blob();
     }
-    else {
-        if (opts.body && typeof opts.body === 'object' && !(opts.body instanceof FormData)) {
-            headers = {
-                'Content-Type': 'application/json',
-                ...headers,
-            };
-            body = JSON.stringify(opts.body); // 否则将对象转换为 JSON 字符串
-        }
+    const isText = responseType === "text";
+    const isJson = contentType && contentType.includes("application/json");
+    if (isJson && !isText) {
+      return await response.json();
+    } else if (isTextForContentType(contentType)) {
+      return {
+        code: response.status,
+        status: response.status,
+        data: await response.text()
+      };
+    } else {
+      return response;
     }
-    return fetch(url, {
-        method: method.toUpperCase(),
-        signal,
-        body: body,
-        ...overloadOpts,
-        headers: headers,
-    })
-        .then(async (response) => {
-        // 获取 Content-Type 头部信息
-        const contentType = response.headers.get('Content-Type');
-        if (responseType === 'blob') {
-            return await response.blob(); // 直接返回 Blob 对象
-        }
-        const isText = responseType === 'text';
-        const isJson = contentType && contentType.includes('application/json');
-        // 判断返回的数据类型
-        if (isJson && !isText) {
-            return await response.json(); // 解析为 JSON
-        }
-        else if (isTextForContentType(contentType)) {
-            return {
-                code: response.status,
-                status: response.status,
-                data: await response.text(), // 直接返回文本内容
-            };
-        }
-        else {
-            return response;
-        }
-    })
-        .catch((err) => {
-        if (err.name === 'AbortError') {
-            return {
-                code: 408,
-                message: '请求超时',
-            };
-        }
-        return {
-            code: 500,
-            message: err.message || '网络错误',
-        };
-    })
-        .finally(() => {
-        clearTimeout(timer);
-    });
+  }).catch((err) => {
+    if (err.name === "AbortError") {
+      return {
+        code: 408,
+        message: "请求超时"
+      };
+    }
+    return {
+      code: 500,
+      message: err.message || "网络错误"
+    };
+  }).finally(() => {
+    clearTimeout(timer);
+  });
 };
 
-/**
- * 设置基础响应, 设置 success 和 showError,
- * success 是 code 是否等于 200
- * showError 是 如果 success 为 false 且 noMsg 为 false, 则调用 showError
- * @param res 响应
- */
-const setBaseResponse = (res) => {
-    res.success = res.code === 200;
-    /**
-     * 显示错误
-     * @param fn 错误处理函数
-     */
-    res.showError = (fn) => {
-        if (!res.success && !res.noMsg) {
-            fn?.();
-        }
-    };
-    return res;
+// src/query.ts
+var setBaseResponse = (res) => {
+  res.success = res.code === 200;
+  res.showError = (fn) => {
+    if (!res.success && !res.noMsg) {
+      fn?.();
+    }
+  };
+  return res;
 };
-const wrapperError = ({ code, message }) => {
-    const result = {
-        code: code || 500,
-        success: false,
-        message: message || 'api request error',
-        showError: (fn) => {
-            //
-        },
-        noMsg: true,
-    };
-    return result;
+var wrapperError = ({ code, message }) => {
+  const result = {
+    code: code || 500,
+    success: false,
+    message: message || "api request error",
+    showError: (fn) => {},
+    noMsg: true
+  };
+  return result;
 };
-/**
- * const query = new Query();
- * const res = await query.post({
- *   path: 'demo',
- *   key: '1',
- *  });
- *
- * U是参数 V是返回值
- */
+
 class Query {
-    adapter;
-    url;
-    /**
-     * 请求前处理函数
-     */
-    beforeRequest;
-    /**
-     *  请求后处理函数
-     */
-    afterResponse;
-    headers;
-    timeout;
-    /**
-     * 需要突然停止请求，比如401的时候
-     */
-    stop;
-    // 默认不使用ws
-    qws;
-    /**
-     * 默认是 /client/router或者 默认是 /api/router
-     */
-    isClient = false;
-    constructor(opts) {
-        this.adapter = opts?.adapter || adapter;
-        const defaultURL = opts?.isClient ? '/client/router' : '/api/router';
-        this.url = opts?.url || defaultURL;
-        this.headers = opts?.headers || {
-            'Content-Type': 'application/json',
-        };
-        this.timeout = opts?.timeout || 60000 * 3; // 默认超时时间为 60s * 3
-        if (opts?.beforeRequest) {
-            this.beforeRequest = opts.beforeRequest;
-        }
-        else {
-            this.beforeRequest = async (opts) => {
-                const token = globalThis?.localStorage?.getItem('token');
-                if (token) {
-                    opts.headers = {
-                        ...opts.headers,
-                        Authorization: `Bearer ${token}`,
-                    };
-                }
-                return opts;
-            };
+  adapter;
+  url;
+  beforeRequest;
+  afterResponse;
+  headers;
+  timeout;
+  stop;
+  qws;
+  isClient = false;
+  constructor(opts) {
+    this.adapter = opts?.adapter || adapter;
+    const defaultURL = opts?.isClient ? "/client/router" : "/api/router";
+    this.url = opts?.url || defaultURL;
+    this.headers = opts?.headers || {
+      "Content-Type": "application/json"
+    };
+    this.timeout = opts?.timeout || 60000 * 3;
+    if (opts?.beforeRequest) {
+      this.beforeRequest = opts.beforeRequest;
+    } else {
+      this.beforeRequest = async (opts2) => {
+        const token = globalThis?.localStorage?.getItem("token");
+        if (token) {
+          opts2.headers = {
+            ...opts2.headers,
+            Authorization: `Bearer ${token}`
+          };
         }
+        return opts2;
+      };
     }
-    setQueryWs(qws) {
-        this.qws = qws;
-    }
-    /**
-     * 突然停止请求
-     */
-    setStop(stop) {
-        this.stop = stop;
+  }
+  setQueryWs(qws) {
+    this.qws = qws;
+  }
+  setStop(stop) {
+    this.stop = stop;
+  }
+  async get(params, options) {
+    return this.post(params, options);
+  }
+  async post(body, options) {
+    const url = options?.url || this.url;
+    console.log("query post", url, body, options);
+    const { headers, adapter: adapter2, beforeRequest, afterResponse, timeout, ...rest } = options || {};
+    const _headers = { ...this.headers, ...headers };
+    const _adapter = adapter2 || this.adapter;
+    const _beforeRequest = beforeRequest || this.beforeRequest;
+    const _afterResponse = afterResponse || this.afterResponse;
+    const _timeout = timeout || this.timeout;
+    const req = {
+      url,
+      headers: _headers,
+      body,
+      timeout: _timeout,
+      ...rest
+    };
+    try {
+      if (_beforeRequest) {
+        const res = await _beforeRequest(req);
+        if (res === false) {
+          return wrapperError({
+            code: 500,
+            message: "request is cancel",
+            req
+          });
+        }
+      }
+    } catch (e) {
+      console.error("request beforeFn error", e, req);
+      return wrapperError({
+        code: 500,
+        message: "api request beforeFn error",
+        req
+      });
     }
-    /**
-     * 发送 get 请求，转到 post 请求
-     *  T是请求类型自定义
-     *  S是返回类型自定义
-     * @param params 请求参数
-     * @param options 请求配置
-     * @returns 请求结果
-     */
-    async get(params, options) {
-        return this.post(params, options);
+    if (this.stop && !options?.noStop) {
+      const that = this;
+      await new Promise((resolve) => {
+        let timer = 0;
+        const detect = setInterval(() => {
+          if (!that.stop) {
+            clearInterval(detect);
+            resolve(true);
+          }
+          timer++;
+          if (timer > 30) {
+            console.error("request stop: timeout", req.url, timer);
+          }
+        }, 1000);
+      });
     }
-    /**
-     * 发送 post 请求
-     *  T是请求类型自定义
-     *  S是返回类型自定义
-     * @param body 请求体
-     * @param options 请求配置
-     * @returns 请求结果
-     */
-    async post(body, options) {
-        const url = options?.url || this.url;
-        const { headers, adapter, beforeRequest, afterResponse, timeout, ...rest } = options || {};
-        const _headers = { ...this.headers, ...headers };
-        const _adapter = adapter || this.adapter;
-        const _beforeRequest = beforeRequest || this.beforeRequest;
-        const _afterResponse = afterResponse || this.afterResponse;
-        const _timeout = timeout || this.timeout;
-        const req = {
-            url: url,
-            headers: _headers,
-            body,
-            timeout: _timeout,
-            ...rest,
-        };
-        try {
-            if (_beforeRequest) {
-                const res = await _beforeRequest(req);
-                if (res === false) {
-                    return wrapperError({
-                        code: 500,
-                        message: 'request is cancel',
-                        // @ts-ignore
-                        req: req,
-                    });
-                }
-            }
+    return _adapter(req).then(async (res) => {
+      try {
+        if (_afterResponse) {
+          return await _afterResponse(res, {
+            req,
+            res,
+            fetch: adapter2
+          });
         }
-        catch (e) {
-            console.error('request beforeFn error', e, req);
-            return wrapperError({
-                code: 500,
-                message: 'api request beforeFn error'});
-        }
-        if (this.stop && !options?.noStop) {
-            const that = this;
-            await new Promise((resolve) => {
-                let timer = 0;
-                const detect = setInterval(() => {
-                    if (!that.stop) {
-                        clearInterval(detect);
-                        resolve(true);
-                    }
-                    timer++;
-                    if (timer > 30) {
-                        console.error('request stop: timeout', req.url, timer);
-                    }
-                }, 1000);
-            });
-        }
-        return _adapter(req).then(async (res) => {
-            try {
-                if (_afterResponse) {
-                    return await _afterResponse(res, {
-                        req,
-                        res,
-                        fetch: adapter,
-                    });
-                }
-                return res;
-            }
-            catch (e) {
-                console.error('request afterFn error', e, req);
-                return wrapperError({
-                    code: 500,
-                    message: 'api request afterFn error'});
-            }
+        return res;
+      } catch (e) {
+        console.error("request afterFn error", e, req);
+        return wrapperError({
+          code: 500,
+          message: "api request afterFn error",
+          req
         });
+      }
+    });
+  }
+  before(fn) {
+    this.beforeRequest = fn;
+  }
+  after(fn) {
+    this.afterResponse = fn;
+  }
+  async fetchText(urlOrOptions, options) {
+    let _options = { ...options };
+    if (typeof urlOrOptions === "string" && !_options.url) {
+      _options.url = urlOrOptions;
     }
-    /**
-     * 设置请求前处理，设置请求前处理函数
-     * @param fn 处理函数
-     */
-    before(fn) {
-        this.beforeRequest = fn;
-    }
-    /**
-     * 设置请求后处理，设置请求后处理函数
-     * @param fn 处理函数
-     */
-    after(fn) {
-        this.afterResponse = fn;
+    if (typeof urlOrOptions === "object") {
+      _options = { ...urlOrOptions, ..._options };
     }
-    async fetchText(urlOrOptions, options) {
-        let _options = { ...options };
-        if (typeof urlOrOptions === 'string' && !_options.url) {
-            _options.url = urlOrOptions;
-        }
-        if (typeof urlOrOptions === 'object') {
-            _options = { ...urlOrOptions, ..._options };
-        }
-        const res = await adapter({
-            method: 'GET',
-            ..._options,
-            headers: {
-                ...this.headers,
-                ...(_options?.headers || {}),
-            },
-        });
-        if (res && !res.code) {
-            return {
-                code: 200,
-                data: res,
-            };
-        }
-        return res;
+    const res = await adapter({
+      method: "GET",
+      ..._options,
+      headers: {
+        ...this.headers,
+        ..._options?.headers || {}
+      }
+    });
+    if (res && !res.code) {
+      return {
+        code: 200,
+        data: res
+      };
     }
+    return res;
+  }
 }
 class BaseQuery {
-    query;
-    queryDefine;
-    constructor(opts) {
-        if (opts?.clientQuery) {
-            this.query = opts.clientQuery;
-        }
-        else {
-            this.query = opts?.query;
-        }
-        if (opts.queryDefine) {
-            this.queryDefine = opts.queryDefine;
-            this.queryDefine.query = this.query;
-        }
+  query;
+  queryDefine;
+  constructor(opts) {
+    if (opts?.clientQuery) {
+      this.query = opts.clientQuery;
+    } else {
+      this.query = opts?.query;
     }
-    get chain() {
-        return this.queryDefine.queryChain;
-    }
-    post(data, options) {
-        return this.query.post(data, options);
-    }
-    get(data, options) {
-        return this.query.get(data, options);
-    }
-}
-/**
- * @deprecated
- * 前端调用后端QueryRouter, 默认路径 /client/router
- */
-class ClientQuery extends Query {
-    constructor(opts) {
-        super({ ...opts, url: opts?.url || '/client/router' });
+    if (opts.queryDefine) {
+      this.queryDefine = opts.queryDefine;
+      this.queryDefine.query = this.query;
     }
+  }
+  get chain() {
+    return this.queryDefine.queryChain;
+  }
+  post(data, options) {
+    return this.query.post(data, options);
+  }
+  get(data, options) {
+    return this.query.get(data, options);
+  }
 }
-
-export { BaseQuery, ClientQuery, Query, adapter, setBaseResponse, wrapperError };
+export {
+  wrapperError,
+  setBaseResponse,
+  adapter,
+  Query,
+  BaseQuery
+};