@kevisual/api 0.0.47 → 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/dist/utils.js

@@ -1,44 +1,22 @@
-// node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.js
-import { webcrypto as crypto } from "node:crypto";
-var POOL_SIZE_MULTIPLIER = 128;
-var pool;
-var poolOffset;
-function fillPool(bytes) {
-  if (!pool || pool.length < bytes) {
-    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-    crypto.getRandomValues(pool);
-    poolOffset = 0;
-  } else if (poolOffset + bytes > pool.length) {
-    crypto.getRandomValues(pool);
-    poolOffset = 0;
-  }
-  poolOffset += bytes;
-}
-function random(bytes) {
-  fillPool(bytes |= 0);
-  return pool.subarray(poolOffset - bytes, poolOffset);
-}
-function customRandom(alphabet, defaultSize, getRandom) {
-  let mask = (2 << 31 - Math.clz32(alphabet.length - 1 | 1)) - 1;
-  let step = Math.ceil(1.6 * mask * defaultSize / alphabet.length);
+// node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/index.browser.js
+var random = (bytes) => crypto.getRandomValues(new Uint8Array(bytes));
+var customRandom = (alphabet, defaultSize, getRandom) => {
+  let mask = (2 << Math.log2(alphabet.length - 1)) - 1;
+  let step = -~(1.6 * mask * defaultSize / alphabet.length);
   return (size = defaultSize) => {
-    if (!size)
-      return "";
     let id = "";
     while (true) {
       let bytes = getRandom(step);
-      let i = step;
-      while (i--) {
-        id += alphabet[bytes[i] & mask] || "";
+      let j = step | 0;
+      while (j--) {
+        id += alphabet[bytes[j] & mask] || "";
         if (id.length >= size)
           return id;
       }
     }
   };
-}
-function customAlphabet(alphabet, size = 21) {
-  return customRandom(alphabet, size, random);
-}
+};
+var customAlphabet = (alphabet, size = 21) => customRandom(alphabet, size | 0, random);
 
 // query/utils/random.ts
 var letter = "abcdefghijklmnopqrstuvwxyz";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kevisual/api",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "description": "",
   "main": "mod.ts",
   "scripts": {
@@ -12,31 +12,31 @@
   "files": [
     "dist",
     "query",
+    "store",
     "mod.ts"
   ],
   "keywords": [],
   "author": "abearxiong <xiongxiao@xiongxiao.me> (https://www.xiongxiao.me)",
   "license": "MIT",
-  "packageManager": "pnpm@10.28.2",
+  "packageManager": "pnpm@10.29.3",
   "type": "module",
   "devDependencies": {
     "@kevisual/cache": "^0.0.5",
     "@kevisual/code-builder": "^0.0.6",
-    "@kevisual/query": "^0.0.39",
+    "@kevisual/query": "^0.0.40",
     "@kevisual/remote-app": "^0.0.4",
     "@kevisual/router": "^0.0.70",
     "@kevisual/types": "^0.0.12",
     "@kevisual/use-config": "^1.0.30",
-    "@types/bun": "^1.3.8",
-    "@types/crypto-js": "^4.2.2",
-    "@types/node": "^25.2.0",
+    "@types/bun": "^1.3.9",
+    "@types/node": "^25.2.3",
     "@types/spark-md5": "^3.0.5",
-    "crypto-js": "^4.2.0",
-    "dotenv": "^17.2.3",
+    "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,8 +56,9 @@
     "./proxy": "./query/query-proxy/index.ts",
     "./secret": "./query/query-secret/index.ts",
     "./resources": "./query/query-resources/index.ts",
-    "./query-secret": "./dist/query-secret.js",
     "./utils": "./dist/utils.js",
+    "./query-secret": "./dist/query-secret.js",
+    "./query-mark": "./dist/query-mark.js",
     "./query-upload": "./dist/query-upload.js",
     "./query-app": "./dist/query-app.js",
     "./query-proxy": "./dist/query-proxy.js",
@@ -63,6 +66,11 @@
     "./query-config": "./dist/query-config.js",
     "./query-login": "./dist/query-login.js",
     "./query-ai": "./dist/query-ai.js",
-    "./query-resources": "./dist/query-resources.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);
   }