@kevisual/api 0.0.52 → 0.0.54

package/dist/query-login-node.js

@@ -0,0 +1,1374 @@
+// node_modules/@kevisual/query/dist/query-browser.js
+var isTextForContentType = (contentType) => {
+  if (!contentType)
+    return false;
+  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md", "json"];
+  return textTypes.some((type) => contentType.includes(type));
+};
+var adapter = async (opts = {}, overloadOpts) => {
+  const controller = new AbortController;
+  const signal = controller.signal;
+  const isPostFile = opts.isPostFile || false;
+  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");
+    const isJson = contentType && contentType.includes("application/json");
+    const isSuccess = response.ok;
+    if (isJson) {
+      const json = await response.json();
+      if (json?.code) {
+        return json;
+      }
+      return {
+        code: isSuccess ? 200 : response.status,
+        status: response.status,
+        data: json
+      };
+    } else if (isTextForContentType(contentType)) {
+      return {
+        code: isSuccess ? 200 : response.status,
+        status: response.status,
+        data: await response.text()
+      };
+    } else {
+      return {
+        code: isSuccess ? 200 : response.status,
+        status: response.status,
+        data: "非文本非JSON响应, 请手动处理response。",
+        response
+      };
+    }
+  }).catch((err) => {
+    if (err.name === "AbortError") {
+      return {
+        code: 408,
+        message: "请求超时"
+      };
+    }
+    return {
+      code: 500,
+      message: err.message || "网络错误"
+    };
+  }).finally(() => {
+    clearTimeout(timer);
+  });
+};
+var wrapperError = ({ code, message }) => {
+  const result = {
+    code: code || 500,
+    message: message || "请求错误"
+  };
+  return result;
+};
+
+class Query {
+  adapter;
+  baseURL;
+  url;
+  beforeRequest;
+  afterResponse;
+  headers;
+  timeout;
+  stop;
+  qws;
+  tokenName;
+  storage;
+  token;
+  constructor(opts) {
+    this.adapter = opts?.adapter || adapter;
+    this.tokenName = opts?.tokenName || "token";
+    this.storage = opts?.storage || globalThis?.localStorage;
+    const defaultURL = opts?.isClient ? "/client/router" : "/api/router";
+    this.url = opts?.url || defaultURL;
+    if (this.url.startsWith("http")) {
+      const urlObj = new URL(this.url);
+      this.baseURL = urlObj.origin;
+    }
+    this.baseURL = opts?.baseURL || this.baseURL;
+    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 = this.token || this.storage?.getItem?.(this.tokenName);
+        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;
+    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
+    };
+    const isStartsWithHttp = req.url.startsWith("http");
+    if (!isStartsWithHttp) {
+      if (this.baseURL) {
+        const baseURL = new URL(this.baseURL || globalThis?.location?.origin).origin;
+        req.url = baseURL + req.url;
+      }
+    }
+    try {
+      if (_beforeRequest) {
+        const res = await _beforeRequest(req);
+        if (res === false) {
+          return wrapperError({
+            code: 500,
+            message: "请求取消",
+            req
+          });
+        }
+      }
+    } catch (e) {
+      console.error("request beforeFn error", e, req);
+      return wrapperError({
+        code: 500,
+        message: "请求在请求前处理时发生错误",
+        req
+      });
+    }
+    if (this.stop && !options?.noStop) {
+      const that = this;
+      const res = await new Promise((resolve) => {
+        let timer = 0;
+        const detect = setInterval(() => {
+          if (!that.stop) {
+            clearInterval(detect);
+            resolve(true);
+          }
+          timer++;
+          if (timer > 5) {
+            console.error("等待请求失败：", req.url, timer);
+            clearInterval(detect);
+            resolve(false);
+          }
+        }, 1000);
+      });
+      if (!res) {
+        return wrapperError({
+          code: 500,
+          message: "请求取消，可能是因为用户未登录或者token过期",
+          req
+        });
+      }
+    }
+    return _adapter(req).then(async (res) => {
+      try {
+        if (_afterResponse) {
+          return await _afterResponse(res, {
+            req,
+            res,
+            fetch: adapter2
+          });
+        }
+        return res;
+      } catch (e) {
+        console.error("请求在响应后处理时发生错误", e, req);
+        return wrapperError({
+          code: 500,
+          message: "请求在响应后处理时发生错误",
+          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);
+  }
+}
+
+// query/query-login/login-cache.ts
+class LoginCacheStore {
+  cache;
+  name;
+  cacheData;
+  constructor(opts) {
+    if (!opts.cache) {
+      throw new Error("cache is required");
+    }
+    this.cache = opts.cache;
+    this.cacheData = {
+      loginUsers: [],
+      user: undefined,
+      id: undefined,
+      accessToken: undefined,
+      refreshToken: undefined
+    };
+    this.name = opts.name;
+  }
+  async setValue(value) {
+    await this.cache.set(this.name, value);
+    this.cacheData = value;
+    return value;
+  }
+  async delValue() {
+    await this.cache.del();
+  }
+  getValue() {
+    return this.cache.get(this.name);
+  }
+  async init() {
+    const defaultData = {
+      loginUsers: [],
+      user: null,
+      id: null,
+      accessToken: null,
+      refreshToken: null
+    };
+    if (this.cache.init) {
+      try {
+        const cacheData = await this.cache.init();
+        this.cacheData = cacheData || defaultData;
+      } catch (error) {
+        console.log("cacheInit error", error);
+      }
+    } else {
+      this.cacheData = await this.getValue() || defaultData;
+    }
+  }
+  async setLoginUser(user) {
+    const has = this.cacheData.loginUsers.find((u) => u.id === user.id);
+    if (has) {
+      this.cacheData.loginUsers = this.cacheData?.loginUsers?.filter((u) => u?.id && u.id !== user.id);
+    }
+    this.cacheData.loginUsers.push(user);
+    this.cacheData.user = user.user;
+    this.cacheData.id = user.id;
+    this.cacheData.accessToken = user.accessToken;
+    this.cacheData.refreshToken = user.refreshToken;
+    this.cacheData.accessTokenExpiresIn = user.accessTokenExpiresIn;
+    this.cacheData.createdAt = user.createdAt;
+    await this.setValue(this.cacheData);
+  }
+  getCurrentUser() {
+    const cacheData = this.cacheData;
+    return Promise.resolve(cacheData.user);
+  }
+  getCurrentUserList() {
+    return Promise.resolve(this.cacheData.loginUsers.filter((u) => u?.id));
+  }
+  getRefreshToken() {
+    const cacheData = this.cacheData;
+    return Promise.resolve(cacheData.refreshToken || "");
+  }
+  getAccessToken() {
+    const cacheData = this.cacheData;
+    return Promise.resolve(cacheData.accessToken || "");
+  }
+  async clearCurrentUser() {
+    const user = await this.getCurrentUser();
+    const has = this.cacheData.loginUsers.find((u) => u.id === user.id);
+    if (has) {
+      this.cacheData.loginUsers = this.cacheData?.loginUsers?.filter((u) => u?.id && u.id !== user.id);
+    }
+    this.cacheData.user = undefined;
+    this.cacheData.id = undefined;
+    this.cacheData.accessToken = undefined;
+    this.cacheData.refreshToken = undefined;
+    await this.setValue(this.cacheData);
+  }
+  async clearAll() {
+    this.cacheData.loginUsers = [];
+    this.cacheData.user = undefined;
+    this.cacheData.id = undefined;
+    this.cacheData.accessToken = undefined;
+    this.cacheData.refreshToken = undefined;
+    await this.setValue(this.cacheData);
+  }
+}
+
+// node_modules/.pnpm/@kevisual+load@0.0.6/node_modules/@kevisual/load/dist/load.js
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var eventemitter3 = { exports: {} };
+var hasRequiredEventemitter3;
+function requireEventemitter3() {
+  if (hasRequiredEventemitter3)
+    return eventemitter3.exports;
+  hasRequiredEventemitter3 = 1;
+  (function(module) {
+    var has = Object.prototype.hasOwnProperty, prefix = "~";
+    function Events() {}
+    if (Object.create) {
+      Events.prototype = Object.create(null);
+      if (!new Events().__proto__)
+        prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt])
+        emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn)
+        emitter._events[evt].push(listener);
+      else
+        emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0)
+        emitter._events = new Events;
+      else
+        delete emitter._events[evt];
+    }
+    function EventEmitter() {
+      this._events = new Events;
+      this._eventsCount = 0;
+    }
+    EventEmitter.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0)
+        return names;
+      for (name in events = this._events) {
+        if (has.call(events, name))
+          names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers)
+        return [];
+      if (handlers.fn)
+        return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners)
+        return 0;
+      if (listeners.fn)
+        return 1;
+      return listeners.length;
+    };
+    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once)
+          this.removeListener(event, listeners.fn, undefined, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1);i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0;i < length; i++) {
+          if (listeners[i].once)
+            this.removeListener(event, listeners[i].fn, undefined, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args)
+                for (j = 1, args = new Array(len - 1);j < len; j++) {
+                  args[j - 1] = arguments[j];
+                }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length)
+          this._events[evt] = events.length === 1 ? events[0] : events;
+        else
+          clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt])
+          clearEvent(this, evt);
+      } else {
+        this._events = new Events;
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+    EventEmitter.prefixed = prefix;
+    EventEmitter.EventEmitter = EventEmitter;
+    {
+      module.exports = EventEmitter;
+    }
+  })(eventemitter3);
+  return eventemitter3.exports;
+}
+var eventemitter3Exports = requireEventemitter3();
+var EventEmitter = /* @__PURE__ */ getDefaultExportFromCjs(eventemitter3Exports);
+var reRunFn = (promiseOpts) => {
+  const timeout = promiseOpts.timeout || 5 * 60 * 1000;
+  const interval = promiseOpts.interval || 1000;
+  const checkSuccess = promiseOpts?.checkSuccess || (() => true);
+  const signal = promiseOpts.signal;
+  return new Promise(async (resolve, reject) => {
+    let intervalId;
+    let timeoutId = setTimeout(() => {
+      clearTimeout(intervalId);
+      resolve({
+        code: 500,
+        message: "timeout"
+      });
+    }, timeout);
+    const fn = promiseOpts.fn || (() => true);
+    const runFn = async () => {
+      if (signal?.aborted) {
+        clearInterval(intervalId);
+        clearTimeout(timeoutId);
+        return resolve({
+          code: 499,
+          message: "operation cancelled"
+        });
+      }
+      const res = await fn();
+      if (!!checkSuccess(res)) {
+        clearInterval(intervalId);
+        clearTimeout(timeoutId);
+        resolve({
+          code: 200,
+          data: res
+        });
+      } else {
+        setTimeout(() => {
+          runFn();
+        }, interval);
+      }
+    };
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        clearInterval(intervalId);
+        clearTimeout(timeoutId);
+        resolve({
+          code: 499,
+          message: "operation cancelled"
+        });
+      });
+    }
+    runFn();
+  });
+};
+
+class BaseLoad {
+  modules = new Map;
+  event;
+  loading;
+  static reRunFn = reRunFn;
+  timeout = 5 * 60 * 1000;
+  constructor() {
+    this.event = new EventEmitter;
+    this.loading = false;
+  }
+  listenKey(key, listenOpts) {
+    const timeout = listenOpts?.timeout ?? this.timeout;
+    return new Promise((resolve) => {
+      const timeoutId = setTimeout(() => {
+        this.event.removeListener(key, onEvent);
+        resolve({
+          code: 500,
+          message: "timeout"
+        });
+      }, timeout);
+      const onEvent = (error) => {
+        clearTimeout(timeoutId);
+        if (error) {
+          return resolve({
+            code: 500,
+            message: error
+          });
+        }
+        const data = this.modules.get(key);
+        if (data?.loadSuccessClear) {
+          this.remove(key);
+        }
+        resolve({
+          code: 200,
+          data: data?.modules
+        });
+      };
+      this.event.once(key, onEvent);
+    });
+  }
+  async hasLoaded(key, hasLoadOpts) {
+    if (!key) {
+      return {
+        code: 404,
+        message: "key is required"
+      };
+    }
+    const has = this.modules.has(key);
+    if (!has) {
+      const isExist = hasLoadOpts?.isExist ?? true;
+      const timeout = hasLoadOpts?.timeout ?? this.timeout;
+      if (isExist) {
+        return await this.listenKey(key, { timeout });
+      }
+      return {
+        code: 404
+      };
+    }
+    const data = this.modules.get(key);
+    if (data?.status === "loaded") {
+      return {
+        code: 200,
+        data: data.modules
+      };
+    }
+    if (data?.status === "loading") {
+      return await this.listenKey(key, { timeout: hasLoadOpts?.timeout ?? this.timeout });
+    }
+    if (data?.status === "error") {
+      return {
+        code: 500,
+        message: "load error"
+      };
+    }
+    if (data?.status === "cancel") {
+      return {
+        code: 499,
+        message: "operation cancelled"
+      };
+    }
+    return {
+      code: 404
+    };
+  }
+  async loadFn(loadContent, opts) {
+    const key = opts.key;
+    if (!key) {
+      return {
+        code: 404,
+        message: "key is required"
+      };
+    }
+    const newModule = {
+      key: opts.key,
+      status: "loading",
+      loading: true,
+      loadSuccessClear: opts.loadSuccessClear ?? true
+    };
+    let errorMessage = "";
+    try {
+      const isReRun = opts.isReRun ?? false;
+      let res;
+      if (!isReRun) {
+        this.modules.set(key, newModule);
+        res = await loadContent();
+      } else {
+        newModule.controller = new AbortController;
+        const signal = newModule.controller.signal;
+        this.modules.set(key, newModule);
+        const data = await reRunFn({
+          timeout: opts.timeout,
+          interval: opts.interval,
+          checkSuccess: opts.checkSuccess,
+          fn: loadContent,
+          signal
+        });
+        newModule.controller = null;
+        if (data.code === 499) {
+          newModule.status = "cancel";
+          return {
+            code: 499,
+            message: "operation cancelled"
+          };
+        }
+        if (data.code !== 200) {
+          throw new Error(data.message);
+        }
+        res = data.data;
+      }
+      newModule.modules = res;
+      newModule.status = "loaded";
+      return {
+        code: 200,
+        data: res
+      };
+    } catch (error) {
+      errorMessage = error.message;
+      newModule.status = "error";
+      return {
+        code: 500,
+        message: error
+      };
+    } finally {
+      newModule.loading = false;
+      this.modules.set(opts.key, newModule);
+      if (!errorMessage) {
+        this.event.emit(opts.key);
+      } else {
+        this.event.emit(opts.key, errorMessage);
+      }
+    }
+  }
+  async load(loadContent, opts) {
+    this.loading = true;
+    const key = opts.key;
+    if (!key) {
+      return {
+        code: 404,
+        message: "key is required"
+      };
+    }
+    if (opts?.force) {
+      this.remove(key);
+    }
+    const has = this.modules.has(key);
+    if (has) {
+      return await this.hasLoaded(key);
+    }
+    if (typeof loadContent === "function") {
+      return this.loadFn(loadContent, opts);
+    }
+    console.error("loadContent is not a function and not has loaded");
+  }
+  remove(key) {
+    const has = this.modules.has(key);
+    if (has) {
+      this.checkRemoveController(key);
+      this.modules.delete(key);
+    }
+  }
+  emitLoaded(key) {
+    this.checkRemoveController(key);
+    this.event.emit(key);
+  }
+  setModule(key, data, loadData) {
+    const newModule = {
+      key,
+      status: "loaded",
+      loading: false,
+      modules: data || {},
+      ...loadData
+    };
+    this.modules.set(key, newModule);
+    this.emitLoaded(key);
+    return newModule;
+  }
+  cancel(key) {
+    this.checkRemoveController(key);
+  }
+  checkRemoveController(key) {
+    const data = this.modules.get(key);
+    if (data?.controller) {
+      data.controller?.abort?.();
+      delete data.controller;
+      this.modules.set(key, data);
+    }
+  }
+}
+
+// query/query-login/query-login.ts
+class QueryLogin extends BaseQuery {
+  cacheStore;
+  isBrowser;
+  load;
+  storage;
+  onLoad;
+  constructor(opts) {
+    super({
+      query: opts?.query || new Query
+    });
+    this.cacheStore = new LoginCacheStore({ name: "login", cache: opts?.cache });
+    this.isBrowser = opts?.isBrowser ?? true;
+    this.init();
+    this.onLoad = opts?.onLoad;
+    this.storage = opts?.storage || globalThis?.localStorage;
+    if (!this.storage) {
+      throw new Error("storage is required");
+    }
+  }
+  setQuery(query) {
+    this.query = query;
+  }
+  async init() {
+    await this.cacheStore.init();
+    this.load = true;
+    this.onLoad?.();
+  }
+  async post(data, opts) {
+    try {
+      return this.query.post({ path: "user", ...data }, opts);
+    } catch (error) {
+      console.log("error", error);
+      return {
+        code: 400
+      };
+    }
+  }
+  async login(data) {
+    const res = await this.post({ key: "login", ...data });
+    if (res.code === 200) {
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
+      this.storage.setItem("token", accessToken || "");
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+    }
+    return res;
+  }
+  async loginByCode(data) {
+    const res = await this.post({ path: "sms", key: "login", data });
+    if (res.code === 200) {
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
+      this.storage.setItem("token", accessToken || "");
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+    }
+    return res;
+  }
+  async setLoginToken(token) {
+    const { accessToken, refreshToken, accessTokenExpiresIn } = token;
+    this.storage.setItem("token", accessToken || "");
+    await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+  }
+  async loginByWechat(data) {
+    const res = await this.post({ path: "wx", key: "open-login", code: data.code });
+    if (res.code === 200) {
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
+      this.storage.setItem("token", accessToken || "");
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+    }
+    return res;
+  }
+  async checkWechat({ onSuccess, onError }) {
+    const url = new URL(window.location.href);
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (code && state) {
+      const res = await this.loginByWechat({ code });
+      if (res.code === 200) {
+        onSuccess?.(res.data);
+      } else {
+        onError?.(res);
+      }
+    }
+  }
+  async beforeSetLoginUser({ accessToken, refreshToken, check401, accessTokenExpiresIn }) {
+    if (accessToken && refreshToken) {
+      const resUser = await this.getMe(accessToken, check401);
+      if (resUser.code === 200) {
+        const user = resUser.data;
+        if (user) {
+          this.cacheStore.setLoginUser({
+            user,
+            id: user.id,
+            accessToken,
+            refreshToken,
+            accessTokenExpiresIn,
+            createdAt: Date.now()
+          });
+        } else {
+          console.error("登录失败");
+        }
+      }
+    }
+  }
+  async queryRefreshToken(refreshToken) {
+    const _refreshToken = refreshToken || this.cacheStore.getRefreshToken();
+    let data = { refreshToken: _refreshToken };
+    if (!_refreshToken) {
+      await this.cacheStore.clearCurrentUser();
+      return {
+        code: 401,
+        message: "请先登录",
+        data: {}
+      };
+    }
+    return this.post({ key: "refreshToken", data }, {
+      afterResponse: async (response, ctx) => {
+        return response;
+      }
+    });
+  }
+  async afterCheck401ToRefreshToken(response, ctx, refetch) {
+    const that = this;
+    if (response?.code === 401) {
+      const hasRefreshToken = await that.cacheStore.getRefreshToken();
+      if (hasRefreshToken) {
+        const res = await that.queryRefreshToken(hasRefreshToken);
+        if (res.code === 200) {
+          const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
+          that.storage.setItem("token", accessToken || "");
+          await that.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn, check401: false });
+          if (refetch && ctx && ctx.req && ctx.req.url && ctx.fetch) {
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+            const url = ctx.req?.url;
+            const body = ctx.req?.body;
+            const headers = ctx.req?.headers;
+            const res2 = await ctx.fetch(url, {
+              method: "POST",
+              body,
+              headers: { ...headers, Authorization: `Bearer ${accessToken}` }
+            });
+            return res2;
+          }
+        } else {
+          that.storage.removeItem("token");
+          await that.cacheStore.clearCurrentUser();
+        }
+        return res;
+      }
+    }
+    return response;
+  }
+  async run401Action(response, ctx, opts) {
+    const that = this;
+    const refetch = opts?.refetch ?? false;
+    if (response?.code === 401) {
+      if (that.query.stop === true) {
+        return { code: 500, success: false, message: "refresh token loading..." };
+      }
+      that.query.stop = true;
+      const res = await that.afterCheck401ToRefreshToken(response, ctx, refetch);
+      that.query.stop = false;
+      opts?.afterCheck?.(res);
+      if (res.code === 401) {
+        opts?.afterAlso401?.(res);
+      }
+      return res;
+    } else {
+      return response;
+    }
+  }
+  async getMe(token, check401 = true) {
+    const _token = token || this.storage.getItem("token");
+    const that = this;
+    return that.post({ key: "me" }, {
+      beforeRequest: async (config) => {
+        if (config.headers) {
+          config.headers["Authorization"] = `Bearer ${_token}`;
+        }
+        if (!_token) {
+          return false;
+        }
+        return config;
+      },
+      afterResponse: async (response, ctx) => {
+        if (response?.code === 401 && check401 && !token) {
+          return await that.afterCheck401ToRefreshToken(response, ctx);
+        }
+        return response;
+      }
+    });
+  }
+  async checkLocalUser() {
+    const user = await this.cacheStore.getCurrentUser();
+    if (user) {
+      return user;
+    }
+    return null;
+  }
+  async checkLocalToken() {
+    const token = this.storage.getItem("token");
+    return !!token;
+  }
+  async getToken() {
+    const token = this.storage.getItem("token");
+    return token || "";
+  }
+  async beforeRequest(opts = {}) {
+    const token = this.storage.getItem("token");
+    if (token) {
+      opts.headers = { ...opts.headers, Authorization: `Bearer ${token}` };
+    }
+    return opts;
+  }
+  async postSwitchUser(username) {
+    return this.post({ key: "switchCheck", data: { username } });
+  }
+  async switchUser(username) {
+    const localUserList = await this.cacheStore.getCurrentUserList();
+    const user = localUserList.find((userItem) => userItem.user.username === username);
+    if (user) {
+      this.storage.setItem("token", user.accessToken || "");
+      await this.beforeSetLoginUser({
+        accessToken: user.accessToken,
+        refreshToken: user.refreshToken,
+        accessTokenExpiresIn: user.accessTokenExpiresIn
+      });
+      return {
+        code: 200,
+        data: {
+          accessToken: user.accessToken,
+          refreshToken: user.refreshToken,
+          accessTokenExpiresIn: user.accessTokenExpiresIn
+        },
+        success: true,
+        message: "切换用户成功"
+      };
+    }
+    const res = await this.postSwitchUser(username);
+    if (res.code === 200) {
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
+      this.storage.setItem("token", accessToken || "");
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+    }
+    return res;
+  }
+  async logout() {
+    this.storage.removeItem("token");
+    const users = await this.cacheStore.getCurrentUserList();
+    const tokens = users.map((user) => {
+      return user?.accessToken;
+    }).filter(Boolean);
+    this.cacheStore.delValue();
+    return this.post({ key: "logout", data: { tokens } });
+  }
+  async hasUser(username) {
+    const that = this;
+    return this.post({
+      path: "org",
+      key: "hasUser",
+      data: {
+        username
+      }
+    }, {
+      afterResponse: async (response, ctx) => {
+        if (response?.code === 401) {
+          const res = await that.afterCheck401ToRefreshToken(response, ctx, true);
+          return res;
+        }
+        return response;
+      }
+    });
+  }
+  async checkLoginStatus(token) {
+    const res = await this.post({
+      path: "user",
+      key: "checkLoginStatus",
+      loginToken: token
+    });
+    if (res.code === 200) {
+      const { accessTokenExpiresIn, accessToken, refreshToken } = res.data;
+      this.storage.setItem("token", accessToken || "");
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+      return res;
+    }
+    return false;
+  }
+  loginWithWeb(baseURL, { MD5, jsonwebtoken }) {
+    const randomId = Math.random().toString(36).substring(2, 15);
+    const timestamp = Date.now();
+    const tokenSecret = "xiao" + randomId;
+    let sign = "";
+    if (MD5) {
+      sign = MD5(`${tokenSecret}${timestamp}`).toString();
+    }
+    let token = "";
+    if (jsonwebtoken) {
+      token = jsonwebtoken.sign({ randomId, timestamp, sign }, tokenSecret, {
+        expiresIn: 60 * 10
+      });
+    } else {
+      token = tokenSecret;
+    }
+    const url = `${baseURL}/api/router?path=user&key=webLogin&p&loginToken=${token}&sign=${sign}&randomId=${randomId}`;
+    return { url, token, tokenSecret };
+  }
+  async pollLoginStatus(data) {
+    const token = data.token;
+    const load = new BaseLoad;
+    load.load(async () => {
+      const res2 = await this.checkLoginStatus(token);
+      if (res2.code === 500) {
+        load.cancel("check-login-status");
+      }
+      return res2;
+    }, {
+      key: "check-login-status",
+      isReRun: true,
+      checkSuccess: (data2) => {
+        return data2?.code === 200;
+      }
+    });
+    const res = await load.hasLoaded("check-login-status", {
+      timeout: 60 * 3 * 1000
+    });
+    if (res.code === 200 && res.data?.code === 200) {
+      try {
+        console.log("网页登录成功");
+        return true;
+      } catch (error) {
+        console.log("登录失败", error);
+        return false;
+      }
+    }
+    console.log("登录失败", res);
+    return false;
+  }
+}
+
+// query/query-login/login-node-cache.ts
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import fs from "node:fs";
+import { readFileSync, writeFileSync, accessSync, unlinkSync, mkdirSync } from "node:fs";
+var fileExists = (filePath, { createIfNotExists = true, isFile = true, isDir = false } = {}) => {
+  try {
+    accessSync(filePath, fs.constants.F_OK);
+    return true;
+  } catch (error) {
+    if (createIfNotExists && isDir) {
+      mkdirSync(filePath, { recursive: true });
+      return true;
+    } else if (createIfNotExists && isFile) {
+      mkdirSync(dirname(filePath), { recursive: true });
+      return false;
+    }
+    return false;
+  }
+};
+var readConfigFile = (filePath) => {
+  try {
+    const data = readFileSync(filePath, "utf-8");
+    const jsonData = JSON.parse(data);
+    return jsonData;
+  } catch (error) {
+    return {};
+  }
+};
+var writeConfigFile = (filePath, data) => {
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
+};
+var getHostName = (baseURL) => {
+  const configDir = join(homedir(), ".config", "envision");
+  const configFile = join(configDir, "config.json");
+  const config = readConfigFile(configFile);
+  const _baseURL = baseURL || config.baseURL || "https://kevisual.cn";
+  const hostname = new URL(_baseURL).hostname;
+  return hostname;
+};
+
+class StorageNode {
+  cacheData;
+  filePath = "";
+  hostname = "";
+  isLoaded = false;
+  constructor(opts) {
+    this.cacheData = {};
+    const hostname = getHostName(opts?.baseURL);
+    this.setHostName(hostname, { load: opts?.load });
+  }
+  setHostName(hostname, opts) {
+    const load = opts?.load ?? false;
+    if (hostname.startsWith("http")) {
+      hostname = new URL(hostname).hostname;
+    }
+    const configDir = join(homedir(), ".config", "envision");
+    this.filePath = join(configDir, "config", `${hostname}-storage.json`);
+    this.hostname = hostname;
+    fileExists(this.filePath, { isFile: true });
+    if (load) {
+      this.loadCache();
+    }
+  }
+  loadCache(force) {
+    if (this.isLoaded && !force)
+      return;
+    const filePath = this.filePath;
+    try {
+      const data = readConfigFile(filePath);
+      this.cacheData = data;
+      this.isLoaded = true;
+    } catch (error) {
+      this.cacheData = {};
+      writeFileSync(filePath, JSON.stringify(this.cacheData, null, 2));
+    }
+  }
+  get length() {
+    return Object.keys(this.cacheData).length;
+  }
+  getItem(key) {
+    return this.cacheData[key];
+  }
+  setItem(key, value) {
+    this.cacheData[key] = value;
+    writeFileSync(this.filePath, JSON.stringify(this.cacheData, null, 2));
+  }
+  removeItem(key) {
+    delete this.cacheData[key];
+    writeFileSync(this.filePath, JSON.stringify(this.cacheData, null, 2));
+  }
+  clear() {
+    this.cacheData = {};
+    writeFileSync(this.filePath, JSON.stringify(this.cacheData, null, 2));
+  }
+  key(index) {
+    return Object.keys(this.cacheData)[index];
+  }
+}
+
+class LoginNodeCache {
+  filepath;
+  isLoaded = false;
+  constructor(opts) {
+    this.filepath = join(homedir(), ".config", "envision", "config", `${getHostName(opts?.baseURL)}-login.json`);
+    fileExists(this.filepath, { isFile: true });
+    if (opts?.load) {
+      this.loadCache(this.filepath);
+    }
+  }
+  async get(_key) {
+    try {
+      const filePath = this.filepath;
+      const data = readConfigFile(filePath);
+      return data;
+    } catch (error) {
+      console.log("get error", error);
+      return {};
+    }
+  }
+  async set(_key, value) {
+    try {
+      const data = readConfigFile(this.filepath);
+      const newData = { ...data, ...value };
+      writeConfigFile(this.filepath, newData);
+    } catch (error) {
+      console.log("set error", error);
+    }
+  }
+  async del() {
+    unlinkSync(this.filepath);
+  }
+  loadCache(filePath, force) {
+    if (this.isLoaded && !force)
+      return;
+    try {
+      const data = readFileSync(filePath, "utf-8");
+      const jsonData = JSON.parse(data);
+      this.isLoaded = true;
+      return jsonData;
+    } catch (error) {
+      console.log("create new cache file:", filePath);
+      const defaultData = { loginUsers: [] };
+      writeConfigFile(filePath, defaultData);
+      return defaultData;
+    }
+  }
+  init() {
+    return this.loadCache(this.filepath);
+  }
+}
+
+// query/query-login/query-login-node.ts
+var cache = new LoginNodeCache;
+
+class QueryLoginNode extends QueryLogin {
+  constructor(opts) {
+    const baseURL = opts?.query?.baseURL;
+    const storage = new StorageNode({ baseURL, load: true });
+    const cache2 = new LoginNodeCache({ baseURL, load: true });
+    super({
+      ...opts,
+      isBrowser: false,
+      storage,
+      cache: cache2
+    });
+  }
+}
+export {
+  cache,
+  StorageNode,
+  QueryLoginNode
+};