@kevisual/api 0.0.48 → 0.0.49

package/dist/store-mark.js

@@ -0,0 +1,444 @@
+// store/store-mark/index.ts
+import { create } from "zustand";
+
+// dist/query-mark.js
+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));
+};
+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 = 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) {
+      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);
+  });
+};
+var wrapperError = ({ code, message }) => {
+  const result = {
+    code: code || 500,
+    success: false,
+    message: message || "api request error",
+    showError: (fn) => {},
+    noMsg: true
+  };
+  return result;
+};
+
+class Query {
+  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;
+    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"
+      });
+    }
+    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"
+        });
+      }
+    });
+  }
+  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 QueryMarkBase {
+  query;
+  isBrowser;
+  load;
+  storage;
+  onLoad;
+  constructor(opts) {
+    this.query = opts?.query || new Query;
+    this.isBrowser = opts?.isBrowser ?? true;
+    this.init();
+    this.onLoad = opts?.onLoad;
+  }
+  setQuery(query) {
+    this.query = query;
+  }
+  async init() {
+    this.load = true;
+    this.onLoad?.();
+  }
+  async post(data, opts) {
+    try {
+      return this.query.post({ path: "mark", ...data }, opts);
+    } catch (error) {
+      console.log("error", error);
+      return {
+        code: 400
+      };
+    }
+  }
+  async getMarkList(search, opts) {
+    return this.post({ key: "list", ...search }, opts);
+  }
+  async getMark(id, opts) {
+    return this.post({ key: "get", id }, opts);
+  }
+  async getVersion(id, opts) {
+    return this.post({ key: "getVersion", id }, opts);
+  }
+  async checkVersion(id, version, opts) {
+    if (!version) {
+      return true;
+    }
+    const res = await this.getVersion(id, opts);
+    if (res.code === 200) {
+      if (res.data.version > version) {
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  async updateMark(data, opts) {
+    return this.post({ key: "update", data }, opts);
+  }
+  async deleteMark(id, opts) {
+    return this.post({ key: "delete", id }, opts);
+  }
+}
+
+class QueryMark extends QueryMarkBase {
+  markType;
+  constructor(opts) {
+    super(opts);
+    this.markType = opts?.markType || "simple";
+  }
+  async getMarkList(search, opts) {
+    return this.post({ key: "list", ...search, markType: this.markType }, opts);
+  }
+  async updateMark(data, opts) {
+    if (!data.id) {
+      data.markType = this.markType || "simple";
+    }
+    return super.updateMark(data, opts);
+  }
+}
+
+// node_modules/.pnpm/es-toolkit@1.44.0/node_modules/es-toolkit/dist/array/uniqBy.mjs
+function uniqBy(arr, mapper) {
+  const map = new Map;
+  for (let i = 0;i < arr.length; i++) {
+    const item = arr[i];
+    const key = mapper(item, i, arr);
+    if (!map.has(key)) {
+      map.set(key, item);
+    }
+  }
+  return Array.from(map.values());
+}
+// store/store-mark/index.ts
+import { useContextKey } from "@kevisual/context";
+var queryClient = useContextKey("queryLogin");
+var useMarkStore = create((set, get) => {
+  return {
+    currentMarkId: "",
+    setCurrentMarkId: (markId) => set(() => ({ currentMarkId: markId })),
+    open: false,
+    setOpen: (open) => set(() => ({ open })),
+    getList: async () => {
+      const queryMark = get().queryMark;
+      const { search, pagination } = get();
+      const res = await queryMark.getMarkList({ page: pagination.current, pageSize: pagination.pageSize, search });
+      const oldList = get().list;
+      if (res.code === 200) {
+        const { pagination: pagination2, list } = res.data || {};
+        const newList = [...oldList, ...list];
+        const uniqueList = uniqBy(newList, (item) => item.id);
+        set(() => ({ list: uniqueList }));
+        set(() => ({ pagination: { current: pagination2.current, pageSize: pagination2.pageSize, total: pagination2.total } }));
+      }
+    },
+    getMarkFromList: (markId) => {
+      return get().list.find((item) => item.id === markId);
+    },
+    updateMark: async (mark) => {
+      const queryMark = get().queryMark;
+      const res = await queryMark.updateMark(mark);
+      if (res.code === 200) {
+        set((state) => {
+          const oldList = state.list;
+          const resMark = res.data;
+          const newList = oldList.map((item) => item.id === mark.id ? mark : item);
+          if (!mark.id) {
+            newList.unshift(resMark);
+          }
+          return {
+            list: newList
+          };
+        });
+      }
+      return res;
+    },
+    getMark: async (markId) => {
+      const queryMark = get().queryMark;
+      const res = await queryMark.getMark(markId);
+      return res;
+    },
+    list: [],
+    setList: (list) => set(() => ({ list })),
+    init: async (markType = "wallnote") => {
+      console.log("init", set, get);
+      const queryMark = new QueryMark({
+        query: queryClient,
+        markType
+      });
+      const url = new URL(window.location.href);
+      const pageSize = url.searchParams.get("pageSize") || "10";
+      set({ queryMark, markType, list: [], pagination: { current: 1, pageSize: parseInt(pageSize), total: 0 }, currentMarkId: "", markData: undefined });
+      setTimeout(async () => {
+        console.log("get", get);
+        get().getList();
+      }, 1000);
+    },
+    deleteMark: async (markId) => {
+      const queryMark = get().queryMark;
+      const res = await queryMark.deleteMark(markId);
+      const currentMarkId = get().currentMarkId;
+      if (res.code === 200) {
+        set((state) => ({
+          list: state.list.filter((item) => item.id !== markId)
+        }));
+        if (currentMarkId === markId) {
+          set(() => ({ currentMarkId: "", markData: undefined }));
+        }
+      }
+      return res;
+    },
+    queryMark: undefined,
+    markType: "simple",
+    markData: undefined,
+    setMarkData: (mark) => set(() => ({ markData: mark })),
+    pagination: {
+      current: 1,
+      pageSize: 10,
+      total: 0
+    },
+    setPagination: (pagination) => set(() => ({ pagination })),
+    search: "",
+    setSearch: (search) => set(() => ({ search, list: [], pagination: { current: 1, pageSize: 10, total: 0 } }))
+  };
+});
+export {
+  useMarkStore
+};

package/dist/utils.d.ts

@@ -4,15 +4,15 @@ declare const alphanumericWithDash = "abcdefghijklmnopqrstuvwxyz0123456789-";
 /**
  * 创建一个随机的字母字符串
  */
-declare const uuid: any;
+declare const uuid: (size?: number) => string;
 /**
  * 创建一个随机的 id，包含字母和数字
  */
-declare const nanoid: any;
+declare const nanoid: (size?: number) => string;
 /**
  * 创建一个随机的 id，包含字母、数字和短横线
  */
-declare const nanoidWithDash: any;
+declare const nanoidWithDash: (size?: number) => string;
 /**
  * 创建一个随机的 id，以字母开头的字符串
  * @param number

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kevisual/api",
-  "version": "0.0.48",
+  "version": "0.0.49",
   "description": "",
   "main": "mod.ts",
   "scripts": {
@@ -12,6 +12,7 @@
   "files": [
     "dist",
     "query",
+    "store",
     "mod.ts"
   ],
   "keywords": [],
@@ -28,15 +29,14 @@
     "@kevisual/types": "^0.0.12",
     "@kevisual/use-config": "^1.0.30",
     "@types/bun": "^1.3.9",
-    "@types/crypto-js": "^4.2.2",
     "@types/node": "^25.2.3",
     "@types/spark-md5": "^3.0.5",
-    "crypto-js": "^4.2.0",
     "dotenv": "^17.3.1",
     "fast-glob": "^3.3.3",
     "ws": "npm:@kevisual/ws"
   },
   "dependencies": {
+    "@kevisual/context": "^0.0.4",
     "@kevisual/js-filter": "^0.0.5",
     "@kevisual/load": "^0.0.6",
     "es-toolkit": "^1.44.0",
@@ -44,7 +44,9 @@
     "fuse.js": "^7.1.0",
     "nanoid": "^5.1.6",
     "path-browserify-esm": "^1.0.6",
-    "spark-md5": "^3.0.2"
+    "sonner": "^2.0.7",
+    "spark-md5": "^3.0.2",
+    "zustand": "^5.0.11"
   },
   "exports": {
     ".": "./mod.ts",
@@ -54,9 +56,9 @@
     "./proxy": "./query/query-proxy/index.ts",
     "./secret": "./query/query-secret/index.ts",
     "./resources": "./query/query-resources/index.ts",
+    "./utils": "./dist/utils.js",
     "./query-secret": "./dist/query-secret.js",
     "./query-mark": "./dist/query-mark.js",
-    "./utils": "./dist/utils.js",
     "./query-upload": "./dist/query-upload.js",
     "./query-app": "./dist/query-app.js",
     "./query-proxy": "./dist/query-proxy.js",
@@ -65,7 +67,10 @@
     "./query-login": "./dist/query-login.js",
     "./query-ai": "./dist/query-ai.js",
     "./query-resources": "./dist/query-resources.js",
+    "./store-mark": "./dist/store-mark.js",
+    "./store-auth": "./dist/store-auth.js",
     "./src/*": "./src/*",
+    "./store/*": "./src/*",
     "./query/*": "./query/*"
   }
 }

package/query/query-login/login-cache.ts

@@ -31,6 +31,8 @@ export type CacheLoginUser = {
   id?: string;
   accessToken?: string;
   refreshToken?: string;
+  accessTokenExpiresIn?: number;
+  createdAt?: number;
 };
 type CacheLogin = {
   loginUsers: CacheLoginUser[];
@@ -162,6 +164,8 @@ export class LoginCacheStore implements CacheStore<any> {
     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);
   }
 

package/query/query-login/query-login.ts

@@ -39,7 +39,7 @@ export class QueryLogin extends BaseQuery {
     this.isBrowser = opts?.isBrowser ?? true;
     this.init();
     this.onLoad = opts?.onLoad;
-    this.storage = opts?.storage || localStorage;
+    this.storage = opts?.storage || globalThis?.localStorage;
   }
   setQuery(query: Query) {
     this.query = query;
@@ -67,9 +67,9 @@ export class QueryLogin extends BaseQuery {
   async login(data: QueryLoginData) {
     const res = await this.post<QueryLoginResult>({ key: 'login', ...data });
     if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
       this.storage.setItem('token', accessToken || '');
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
     }
     return res;
   }
@@ -81,9 +81,9 @@ export class QueryLogin extends BaseQuery {
   async loginByCode(data: { phone: string; code: string }) {
     const res = await this.post<QueryLoginResult>({ path: 'sms', key: 'login', data });
     if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
       this.storage.setItem('token', accessToken || '');
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
     }
     return res;
   }
@@ -91,17 +91,17 @@ export class QueryLogin extends BaseQuery {
    * 设置token
    * @param token
    */
-  async setLoginToken(token: { accessToken: string; refreshToken: string }) {
-    const { accessToken, refreshToken } = token;
+  async setLoginToken(token: { accessToken: string; refreshToken: string; accessTokenExpiresIn?: number }) {
+    const { accessToken, refreshToken, accessTokenExpiresIn } = token;
     this.storage.setItem('token', accessToken || '');
-    await this.beforeSetLoginUser({ accessToken, refreshToken });
+    await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
   }
   async loginByWechat(data: { code: string }) {
     const res = await this.post<QueryLoginResult>({ path: 'wx', key: 'open-login', code: data.code });
     if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
       this.storage.setItem('token', accessToken || '');
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
     }
     return res;
   }
@@ -126,7 +126,7 @@ export class QueryLogin extends BaseQuery {
    * 登陆成功，需要获取用户信息进行缓存
    * @param param0
    */
-  async beforeSetLoginUser({ accessToken, refreshToken, check401 }: { accessToken?: string; refreshToken?: string; check401?: boolean }) {
+  async beforeSetLoginUser({ accessToken, refreshToken, check401, accessTokenExpiresIn }: { accessTokenExpiresIn?: number, accessToken?: string; refreshToken?: string; check401?: boolean }) {
     if (accessToken && refreshToken) {
       const resUser = await this.getMe(accessToken, check401);
       if (resUser.code === 200) {
@@ -137,6 +137,8 @@ export class QueryLogin extends BaseQuery {
             id: user.id,
             accessToken,
             refreshToken,
+            accessTokenExpiresIn,
+            createdAt: Date.now(),
           });
         } else {
           console.error('登录失败');
@@ -185,9 +187,9 @@ export class QueryLogin extends BaseQuery {
       if (hasRefreshToken) {
         const res = await that.queryRefreshToken(hasRefreshToken);
         if (res.code === 200) {
-          const { accessToken, refreshToken } = res?.data || {};
+          const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
           that.storage.setItem('token', accessToken || '');
-          await that.beforeSetLoginUser({ accessToken, refreshToken, check401: false });
+          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;
@@ -336,12 +338,17 @@ export class QueryLogin extends BaseQuery {
     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 });
+      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: '切换用户成功',
@@ -350,9 +357,9 @@ export class QueryLogin extends BaseQuery {
     const res = await this.postSwitchUser(username);
 
     if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
       this.storage.setItem('token', accessToken || '');
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
     }
     return res;
   }
@@ -409,9 +416,9 @@ export class QueryLogin extends BaseQuery {
       loginToken: token,
     });
     if (res.code === 200) {
-      const accessToken = res.data?.accessToken;
+      const { accessTokenExpiresIn, accessToken, refreshToken } = res.data;
       this.storage.setItem('token', accessToken || '');
-      await this.beforeSetLoginUser({ accessToken, refreshToken: res.data?.refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
       return res;
     }
     return false;
@@ -421,7 +428,7 @@ export class QueryLogin extends BaseQuery {
    * 
    * 
 
-import MD5 from 'crypto-js/md5.js';
+// import MD5 from 'crypto-js/md5.js';
 import jsonwebtoken from 'jsonwebtoken';
 
    */