@kevisual/api 0.0.47 → 0.0.48

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.48",
   "description": "",
   "main": "mod.ts",
   "scripts": {
@@ -17,22 +17,22 @@
   "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/bun": "^1.3.9",
     "@types/crypto-js": "^4.2.2",
-    "@types/node": "^25.2.0",
+    "@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"
   },
@@ -55,6 +55,7 @@
     "./secret": "./query/query-secret/index.ts",
     "./resources": "./query/query-resources/index.ts",
     "./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",
@@ -63,6 +64,8 @@
     "./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",
+    "./src/*": "./src/*",
+    "./query/*": "./query/*"
   }
 }

package/query/query-mark/index.ts

@@ -0,0 +1,154 @@
+import { Query } from '@kevisual/query';
+import type { Result, DataOpts } from '@kevisual/query/query';
+
+export type SimpleObject = Record<string, any>;
+export const markType = ['simple', 'md', 'mdx', 'wallnote', 'excalidraw', 'chat'] as const;
+export type MarkType = (typeof markType)[number];
+export type MarkData = {
+  nodes?: any[];
+  edges?: any[];
+  elements?: any[];
+  permission?: any;
+
+  [key: string]: any;
+};
+export type Mark = {
+  id: string;
+  title: string;
+  description: string;
+  markType: MarkType;
+  link: string;
+  data?: MarkData;
+  uid: string;
+  puid: string;
+  summary: string;
+  thumbnail?: string;
+  tags: string[];
+  createdAt: string;
+  updatedAt: string;
+  version: number;
+};
+export type ShowMarkPick = Pick<Mark, 'id' | 'title' | 'description' | 'summary' | 'link' | 'tags' | 'thumbnail' | 'updatedAt'>;
+
+export type SearchOpts = {
+  page?: number;
+  pageSize?: number;
+  search?: string;
+  sort?: string; // DESC, ASC
+  markType?: MarkType; // 类型
+  [key: string]: any;
+};
+
+export type QueryMarkOpts<T extends SimpleObject = SimpleObject> = {
+  query?: Query;
+  isBrowser?: boolean;
+  onLoad?: () => void;
+} & T;
+
+export type ResultMarkList = {
+  list: Mark[];
+  pagination: {
+    pageSize: number;
+    current: number;
+    total: number;
+  };
+};
+export type QueryMarkData = {
+  id?: string;
+  title?: string;
+  description?: string;
+  [key: string]: any;
+};
+export type QueryMarkResult = {
+  accessToken: string;
+  refreshToken: string;
+};
+
+export class QueryMarkBase<T extends SimpleObject = SimpleObject> {
+  query: Query;
+  isBrowser: boolean;
+  load?: boolean;
+  storage?: Storage;
+  onLoad?: () => void;
+
+  constructor(opts?: QueryMarkOpts<T>) {
+    this.query = opts?.query || new Query();
+    this.isBrowser = opts?.isBrowser ?? true;
+    this.init();
+    this.onLoad = opts?.onLoad;
+  }
+  setQuery(query: Query) {
+    this.query = query;
+  }
+  private async init() {
+    this.load = true;
+    this.onLoad?.();
+  }
+
+  async post<T = Result<any>>(data: any, opts?: DataOpts): Promise<T> {
+    try {
+      return this.query.post({ path: 'mark', ...data }, opts) as Promise<T>;
+    } catch (error) {
+      console.log('error', error);
+      return {
+        code: 400,
+      } as any;
+    }
+  }
+
+  async getMarkList(search: SearchOpts, opts?: DataOpts) {
+    return this.post<Result<ResultMarkList>>({ key: 'list', ...search }, opts);
+  }
+
+  async getMark(id: string, opts?: DataOpts) {
+    return this.post<Result<Mark>>({ key: 'get', id }, opts);
+  }
+  async getVersion(id: string, opts?: DataOpts) {
+    return this.post<Result<{ version: number; id: string }>>({ key: 'getVersion', id }, opts);
+  }
+  /**
+   * 检查版本
+   * 当需要更新时，返回true
+   * @param id
+   * @param version
+   * @param opts
+   * @returns
+   */
+  async checkVersion(id: string, version?: number, opts?: DataOpts) {
+    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: any, opts?: DataOpts) {
+    return this.post<Result<Mark>>({ key: 'update', data }, opts);
+  }
+
+  async deleteMark(id: string, opts?: DataOpts) {
+    return this.post<Result<Mark>>({ key: 'delete', id }, opts);
+  }
+}
+export class QueryMark extends QueryMarkBase<SimpleObject> {
+  markType: string;
+  constructor(opts?: QueryMarkOpts & { markType?: MarkType }) {
+    super(opts);
+    this.markType = opts?.markType || 'simple';
+  }
+  async getMarkList(search?: SearchOpts, opts?: DataOpts) {
+    return this.post<Result<ResultMarkList>>({ key: 'list', ...search, markType: this.markType }, opts);
+  }
+  async updateMark(data: any, opts?: DataOpts) {
+    if (!data.id) {
+      data.markType = this.markType || 'simple';
+    }
+    return super.updateMark(data, opts);
+  }
+}

package/query/query-resources/utils.ts

@@ -1,13 +1,12 @@
-import MD5 from 'crypto-js/md5';
 import SparkMD5 from 'spark-md5';
 
 export const hashContent = (str: string | Blob | Buffer): Promise<string> | string => {
   if (typeof str === 'string') {
-    return MD5(str).toString();
+    return SparkMD5.hash(str);
   } else if (str instanceof Blob) {
     return hashBlob(str);
   } else if (Buffer.isBuffer(str)) {
-    return MD5(str.toString()).toString();
+    return SparkMD5.hash(str.toString());
   }
   console.error('hashContent error: input must be a string, Blob, or Buffer');
   return '';