@kevisual/query 0.0.40 → 0.0.42

package/dist/query-browser.js

@@ -1,131 +1,114 @@
-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);
-                }
-            }
-        }
-        url.search = searchParams.toString();
-    }
-    let body = undefined;
-    if (isGet) {
-        body = undefined;
-    }
-    else if (isPostFile) {
-        body = opts.body; // 如果是文件上传，直接使用 FormData
-    }
-    else {
-        if (opts.body && typeof opts.body === 'object' && !(opts.body instanceof FormData)) {
-            headers = {
-                'Content-Type': 'application/json',
-                ...headers,
-            };
-            body = JSON.stringify(opts.body); // 否则将对象转换为 JSON 字符串
-        }
-    }
-    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);
-    });
+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;
+  } 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);
+    }
+  }
+  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();
+    }
+    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;
+    }
+  }).catch((err) => {
+    if (err.name === "AbortError") {
+      return {
+        code: 408,
+        message: "请求超时"
+      };
+    }
+    return {
+      code: 500,
+      message: err.message || "网络错误"
+    };
+  }).finally(() => {
+    clearTimeout(timer);
+  });
 };
 
-const createStoreImpl = (createState) => {
+// node_modules/.pnpm/zustand@5.0.11/node_modules/zustand/esm/vanilla.mjs
+var createStoreImpl = (createState) => {
   let state;
-  const listeners = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set;
   const setState = (partial, replace) => {
     const nextState = typeof partial === "function" ? partial(state) : partial;
     if (!Object.is(nextState, state)) {
@@ -144,479 +127,403 @@ const createStoreImpl = (createState) => {
   const initialState = state = createState(setState, getState, api);
   return api;
 };
-const createStore = ((createState) => createState ? createStoreImpl(createState) : createStoreImpl);
+var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
 
-const parseWsUrl = (url) => {
-    try {
-        new URL(url);
-        return url;
-    }
-    catch (e) {
-        const _url = new URL(url, location.origin);
-        if (_url.protocol === 'http:') {
-            _url.protocol = 'ws:';
-        }
-        if (_url.protocol === 'https:') {
-            _url.protocol = 'wss:';
-        }
-        return _url.href;
-    }
+// src/utils.ts
+var parseWsUrl = (url) => {
+  try {
+    new URL(url);
+    return url;
+  } catch (e) {
+    const _url = new URL(url, location.origin);
+    if (_url.protocol === "http:") {
+      _url.protocol = "ws:";
+    }
+    if (_url.protocol === "https:") {
+      _url.protocol = "wss:";
+    }
+    return _url.href;
+  }
 };
 
+// src/ws.ts
 class QueryWs {
-    url;
-    store;
-    ws;
-    constructor(opts) {
-        const url = opts?.url || '/api/router';
-        if (opts?.store) {
-            this.store = opts.store;
-        }
-        else {
-            const store = createStore((set) => ({
-                connected: false,
-                status: 'connecting',
-                setConnected: (connected) => set({ connected }),
-                setStatus: (status) => set({ status }),
-            }));
-            this.store = store;
-        }
-        const wsUrl = parseWsUrl(url);
-        if (opts?.ws && opts.ws instanceof WebSocket) {
-            this.ws = opts.ws;
-        }
-        else {
-            this.ws = new WebSocket(wsUrl);
-        }
-        this.connect();
-    }
-    /**
-     * 连接 WebSocket
-     */
-    async connect(opts) {
-        const store = this.store;
-        const that = this;
-        const connected = store.getState().connected;
-        if (connected) {
-            return Promise.resolve(true);
-        }
-        return new Promise((resolve, reject) => {
-            const ws = that.ws || new WebSocket(that.url);
-            const timeout = opts?.timeout || 5 * 60 * 1000; // 默认 5 分钟
-            let timer = setTimeout(() => {
-                const isOpen = ws.readyState === WebSocket.OPEN;
-                if (isOpen) {
-                    console.log('WebSocket 连接成功 in timer');
-                    resolve(true);
-                    return;
-                }
-                console.error('WebSocket 连接超时', that.url);
-                resolve(false);
-            }, timeout);
-            ws.onopen = (ev) => {
-                store.getState().setConnected(true);
-                store.getState().setStatus('connected');
-                resolve(true);
-                clearTimeout(timer);
-            };
-            ws.onclose = (ev) => {
-                store.getState().setConnected(false);
-                store.getState().setStatus('disconnected');
-                this.ws = null;
-            };
-        });
-    }
-    /**
-     * ws.onopen 必须用这个去获取，否者会丢失链接信息
-     * @param callback
-     * @returns
-     */
-    listenConnect(callback) {
-        const store = this.store;
-        const { connected } = store.getState();
-        if (connected) {
-            callback();
-            return;
-        }
-        const subscriptionOne = (selector, listener) => {
-            const unsubscribe = store.subscribe((newState, oldState) => {
-                if (selector(newState) !== selector(oldState)) {
-                    listener(newState, oldState);
-                    unsubscribe();
-                }
-            });
-            return unsubscribe;
-        };
-        const cancel = subscriptionOne((state) => state.connected, () => {
-            callback();
-        });
-        return cancel;
-    }
-    listenClose(callback) {
-        const store = this.store;
-        const { status } = store.getState();
-        if (status === 'disconnected') {
-            callback();
-        }
-        const subscriptionOne = (selector, listener) => {
-            const unsubscribe = store.subscribe((newState, oldState) => {
-                if (selector(newState) !== selector(oldState)) {
-                    listener(newState, oldState);
-                    unsubscribe();
-                }
-            });
-            return unsubscribe;
-        };
-        const cancel = subscriptionOne((state) => state.status, (newState, oldState) => {
-            if (newState.status === 'disconnected') {
-                callback();
-            }
-        });
-        return cancel;
-    }
-    onMessage(fn, opts) {
-        const ws = this.ws;
-        const isJson = opts?.isJson ?? true;
-        const selector = opts?.selector;
-        const parseIfJson = (data) => {
-            try {
-                return JSON.parse(data);
-            }
-            catch (e) {
-                return data;
-            }
-        };
-        const listener = (event) => {
-            const received = parseIfJson(event.data);
-            if (typeof received === 'string' && !isJson) {
-                fn(received, event);
-            }
-            else if (typeof received === 'object' && isJson) {
-                fn(selector ? selector(received) : received, event);
-            }
-            else ;
-        };
-        ws.addEventListener('message', listener);
-        return () => {
-            ws.removeEventListener('message', listener);
-        };
-    }
-    close() {
-        const ws = this.ws;
-        const store = this.store;
-        ws?.close?.();
-        this.ws = null;
+  url;
+  store;
+  ws;
+  constructor(opts) {
+    const url = opts?.url || "/api/router";
+    if (opts?.store) {
+      this.store = opts.store;
+    } else {
+      const store = createStore((set) => ({
+        connected: false,
+        status: "connecting",
+        setConnected: (connected) => set({ connected }),
+        setStatus: (status) => set({ status })
+      }));
+      this.store = store;
+    }
+    const wsUrl = parseWsUrl(url);
+    if (opts?.ws && opts.ws instanceof WebSocket) {
+      this.ws = opts.ws;
+    } else {
+      this.ws = new WebSocket(wsUrl);
+    }
+    this.connect();
+  }
+  async connect(opts) {
+    const store = this.store;
+    const that = this;
+    const connected = store.getState().connected;
+    if (connected) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve, reject) => {
+      const ws = that.ws || new WebSocket(that.url);
+      const timeout = opts?.timeout || 5 * 60 * 1000;
+      let timer = setTimeout(() => {
+        const isOpen = ws.readyState === WebSocket.OPEN;
+        if (isOpen) {
+          console.log("WebSocket 连接成功 in timer");
+          resolve(true);
+          return;
+        }
+        console.error("WebSocket 连接超时", that.url);
+        resolve(false);
+      }, timeout);
+      ws.onopen = (ev) => {
+        store.getState().setConnected(true);
+        store.getState().setStatus("connected");
+        resolve(true);
+        clearTimeout(timer);
+      };
+      ws.onclose = (ev) => {
         store.getState().setConnected(false);
-        store.getState().setStatus('disconnected');
-    }
-    /**
-     * 发送消息
-     *
-     * @param data
-     * @param opts
-     * @returns
-     */
-    send(data, opts) {
-        const ws = this.ws;
-        const isJson = opts?.isJson ?? true;
-        const wrapper = opts?.wrapper;
-        if (!ws || ws.readyState !== WebSocket.OPEN) {
-            console.error('WebSocket is not open');
-            return;
-        }
-        if (isJson) {
-            ws.send(JSON.stringify(wrapper ? wrapper(data) : data));
-        }
-        else {
-            ws.send(data);
-        }
-    }
-    getOpen() {
-        if (!this.ws) {
-            return false;
-        }
-        return this.ws.readyState === WebSocket.OPEN;
-    }
+        store.getState().setStatus("disconnected");
+        this.ws = null;
+      };
+    });
+  }
+  listenConnect(callback) {
+    const store = this.store;
+    const { connected } = store.getState();
+    if (connected) {
+      callback();
+      return;
+    }
+    const subscriptionOne = (selector, listener) => {
+      const unsubscribe = store.subscribe((newState, oldState) => {
+        if (selector(newState) !== selector(oldState)) {
+          listener(newState, oldState);
+          unsubscribe();
+        }
+      });
+      return unsubscribe;
+    };
+    const cancel = subscriptionOne((state) => state.connected, () => {
+      callback();
+    });
+    return cancel;
+  }
+  listenClose(callback) {
+    const store = this.store;
+    const { status } = store.getState();
+    if (status === "disconnected") {
+      callback();
+    }
+    const subscriptionOne = (selector, listener) => {
+      const unsubscribe = store.subscribe((newState, oldState) => {
+        if (selector(newState) !== selector(oldState)) {
+          listener(newState, oldState);
+          unsubscribe();
+        }
+      });
+      return unsubscribe;
+    };
+    const cancel = subscriptionOne((state) => state.status, (newState, oldState) => {
+      if (newState.status === "disconnected") {
+        callback();
+      }
+    });
+    return cancel;
+  }
+  onMessage(fn, opts) {
+    const ws = this.ws;
+    const isJson = opts?.isJson ?? true;
+    const selector = opts?.selector;
+    const parseIfJson = (data) => {
+      try {
+        return JSON.parse(data);
+      } catch (e) {
+        return data;
+      }
+    };
+    const listener = (event) => {
+      const received = parseIfJson(event.data);
+      if (typeof received === "string" && !isJson) {
+        fn(received, event);
+      } else if (typeof received === "object" && isJson) {
+        fn(selector ? selector(received) : received, event);
+      } else {}
+    };
+    ws.addEventListener("message", listener);
+    return () => {
+      ws.removeEventListener("message", listener);
+    };
+  }
+  close() {
+    const ws = this.ws;
+    const store = this.store;
+    ws?.close?.();
+    this.ws = null;
+    store.getState().setConnected(false);
+    store.getState().setStatus("disconnected");
+  }
+  send(data, opts) {
+    const ws = this.ws;
+    const isJson = opts?.isJson ?? true;
+    const wrapper = opts?.wrapper;
+    if (!ws || ws.readyState !== WebSocket.OPEN) {
+      console.error("WebSocket is not open");
+      return;
+    }
+    if (isJson) {
+      ws.send(JSON.stringify(wrapper ? wrapper(data) : data));
+    } else {
+      ws.send(data);
+    }
+  }
+  getOpen() {
+    if (!this.ws) {
+      return false;
+    }
+    return this.ws.readyState === WebSocket.OPEN;
+  }
 }
 
-const wrapperError = ({ code, message }) => {
-    const result = {
-        code: code || 500,
-        success: false,
-        message: message || 'api request error',
-        showError: (fn) => {
-            //
-        },
-        noMsg: true,
-    };
-    return result;
+// src/query.ts
+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;
-            };
-        }
-    }
-    setQueryWs(qws) {
-        this.qws = qws;
-    }
-    /**
-     * 突然停止请求
-     */
-    setStop(stop) {
-        this.stop = stop;
-    }
-    /**
-     * 发送 get 请求，转到 post 请求
-     *  T是请求类型自定义
-     *  S是返回类型自定义
-     * @param params 请求参数
-     * @param options 请求配置
-     * @returns 请求结果
-     */
-    async get(params, options) {
-        return this.post(params, options);
-    }
-    /**
-     * 发送 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,
-                    });
-                }
-            }
-        }
-        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'});
-            }
-        });
-    }
-    /**
-     * 设置请求前处理，设置请求前处理函数
-     * @param fn 处理函数
-     */
-    before(fn) {
-        this.beforeRequest = fn;
-    }
-    /**
-     * 设置请求后处理，设置请求后处理函数
-     * @param fn 处理函数
-     */
-    after(fn) {
-        this.afterResponse = fn;
-    }
-    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,
-            };
+  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;
+  }
+  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
+      });
+    }
+    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: adapter2
+          });
         }
         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;
+    }
+    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;
+  }
 }
 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;
-        }
-    }
-    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' });
-    }
+  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;
+    }
+  }
+  get chain() {
+    return this.queryDefine.queryChain;
+  }
+  post(data, options) {
+    return this.query.post(data, options);
+  }
+  get(data, options) {
+    return this.query.get(data, options);
+  }
 }
 
-/**
- * 前端调用后端QueryRouter, 封装 beforeRequest 和 wss
- */
+// src/query-browser.ts
 class QueryClient extends Query {
-    tokenName;
-    storage;
-    token;
-    constructor(opts) {
-        super(opts);
-        this.tokenName = opts?.tokenName || 'token';
-        this.storage = opts?.storage || globalThis.localStorage;
-        this.beforeRequest = async (opts) => {
-            const token = this.token || this.getToken();
-            if (token) {
-                opts.headers = {
-                    ...opts.headers,
-                    Authorization: `Bearer ${token}`,
-                };
-            }
-            return opts;
+  tokenName;
+  storage;
+  token;
+  constructor(opts) {
+    super(opts);
+    this.tokenName = opts?.tokenName || "token";
+    this.storage = opts?.storage || globalThis.localStorage;
+    this.beforeRequest = async (opts2) => {
+      const token = this.token || this.getToken();
+      if (token) {
+        opts2.headers = {
+          ...opts2.headers,
+          Authorization: `Bearer ${token}`
         };
-        if (opts?.io) {
-            this.createWs();
-        }
-    }
-    createWs(opts) {
-        this.qws = new QueryWs({ url: this.url, ...opts });
-    }
-    getToken() {
-        return this.storage.getItem(this.tokenName);
-    }
-    saveToken(token) {
-        this.storage.setItem(this.tokenName, token);
-    }
-    removeToken() {
-        this.storage.removeItem(this.tokenName);
-    }
+      }
+      return opts2;
+    };
+    if (opts?.io) {
+      this.createWs();
+    }
+  }
+  createWs(opts) {
+    this.qws = new QueryWs({ url: this.url, ...opts });
+  }
+  getToken() {
+    return this.storage.getItem(this.tokenName);
+  }
+  saveToken(token) {
+    this.storage.setItem(this.tokenName, token);
+  }
+  removeToken() {
+    this.storage.removeItem(this.tokenName);
+  }
 }
-// 移除默认生成的实例
-// export const client = new QueryClient();
-
-export { BaseQuery, ClientQuery, Query, QueryClient, QueryWs, adapter, wrapperError };
+export {
+  wrapperError,
+  adapter,
+  QueryWs,
+  QueryClient,
+  Query,
+  BaseQuery
+};