@kevisual/api 0.0.46 → 0.0.48

package/dist/query-upload.js

@@ -0,0 +1,355 @@
+// query/query-upload/core/upload-progress.ts
+class UploadProgress {
+  progress;
+  onStart;
+  onDone;
+  onProgress;
+  data;
+  end;
+  constructor(uploadOpts) {
+    this.progress = 0;
+    this.end = false;
+    const mockFn = () => {};
+    this.onStart = uploadOpts.onStart || mockFn;
+    this.onDone = uploadOpts.onDone || mockFn;
+    this.onProgress = uploadOpts.onProgress || mockFn;
+  }
+  start(msg) {
+    this.progress = 0;
+    msg && this.info(msg);
+    this.end = false;
+    this.onStart?.();
+  }
+  done() {
+    this.progress = 100;
+    this.end = true;
+    this.onDone?.();
+  }
+  set(progress, data) {
+    this.progress = progress;
+    this.data = data;
+    this.onProgress?.(progress, data);
+    console.log("uploadProgress set", progress, data);
+  }
+  setOnStart(callback) {
+    this.onStart = callback;
+  }
+  setOnDone(callback) {
+    this.onDone = callback;
+  }
+  setOnProgress(callback) {
+    this.onProgress = callback;
+  }
+  info(msg) {
+    console.log(msg);
+  }
+  error(msg) {
+    console.error(msg);
+  }
+  warn(msg) {
+    console.warn(msg);
+  }
+}
+
+// query/query-upload/utils/random-id.ts
+var randomId = () => {
+  return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+};
+
+// query/query-upload/core/upload-chunk.ts
+var uploadFileChunked = async (file, opts, opts2) => {
+  const { directory, appKey, version, username, isPublic, noCheckAppFiles = true } = opts;
+  const { uploadProgress, createEventSource, baseUrl = "", token, FormDataFn } = opts2 || {};
+  return new Promise(async (resolve, reject) => {
+    const taskId = randomId();
+    const filename = opts.filename || file.name;
+    uploadProgress?.start(`${filename} 上传中...`);
+    const searchParams = new URLSearchParams;
+    searchParams.set("taskId", taskId);
+    if (isPublic) {
+      searchParams.set("public", "true");
+    }
+    if (noCheckAppFiles) {
+      searchParams.set("noCheckAppFiles", "1");
+    }
+    const eventSource = createEventSource(baseUrl + "/api/s1/events", searchParams);
+    let isError = false;
+    eventSource.onmessage = function(event) {
+      console.log("Progress update:", event.data);
+      const parseIfJson = (data) => {
+        try {
+          return JSON.parse(data);
+        } catch (e) {
+          return data;
+        }
+      };
+      const receivedData = parseIfJson(event.data);
+      if (typeof receivedData === "string")
+        return;
+      const progress = Number(receivedData.progress);
+      const progressFixed = progress.toFixed(2);
+      uploadProgress?.set(progress, { ...receivedData, progressFixed, filename, taskId });
+    };
+    eventSource.onerror = function(event) {
+      console.log("eventSource.onerror", event);
+      isError = true;
+      reject(event);
+    };
+    const chunkSize = 1 * 1024 * 1024;
+    const totalChunks = Math.ceil(file.size / chunkSize);
+    for (let currentChunk = 0;currentChunk < totalChunks; currentChunk++) {
+      const start = currentChunk * chunkSize;
+      const end = Math.min(start + chunkSize, file.size);
+      const chunk = file.slice(start, end);
+      const formData = new FormDataFn;
+      formData.append("file", chunk, filename);
+      formData.append("chunkIndex", currentChunk.toString());
+      formData.append("totalChunks", totalChunks.toString());
+      const isLast = currentChunk === totalChunks - 1;
+      if (directory) {
+        formData.append("directory", directory);
+      }
+      if (appKey && version) {
+        formData.append("appKey", appKey);
+        formData.append("version", version);
+      }
+      if (username) {
+        formData.append("username", username);
+      }
+      try {
+        const res = await fetch(baseUrl + "/api/s1/resources/upload/chunk?taskId=" + taskId, {
+          method: "POST",
+          body: formData,
+          headers: {
+            "task-id": taskId,
+            Authorization: `Bearer ${token}`
+          }
+        }).then((response) => response.json());
+        if (res?.code !== 200) {
+          console.log("uploadChunk error", res);
+          uploadProgress?.error(res?.message || "上传失败");
+          isError = true;
+          eventSource.close();
+          uploadProgress?.done();
+          reject(new Error(res?.message || "上传失败"));
+          return;
+        }
+        if (isLast) {
+          fetch(baseUrl + "/api/s1/events/close?taskId=" + taskId);
+          eventSource.close();
+          uploadProgress?.done();
+          resolve(res);
+        }
+      } catch (error) {
+        console.log("Error uploading chunk", error);
+        fetch(baseUrl + "/api/s1/events/close?taskId=" + taskId);
+        reject(error);
+        return;
+      }
+    }
+    if (!uploadProgress?.end) {
+      uploadProgress?.done();
+    }
+  });
+};
+
+// query/query-upload/core/upload.ts
+var uploadFiles = async (files, opts, opts2) => {
+  const { directory, appKey, version, username, noCheckAppFiles = true } = opts;
+  const { uploadProgress, createEventSource, baseUrl = "", token, FormDataFn } = opts2 || {};
+  const length = files.length;
+  const maxSize = opts.maxSize || 20 * 1024 * 1024;
+  const totalSize = files.reduce((acc, file) => acc + file.size, 0);
+  if (totalSize > maxSize) {
+    const maxSizeMB = maxSize / 1024 / 1024;
+    uploadProgress?.error("有文件大小不能超过" + maxSizeMB + "MB");
+    return;
+  }
+  const maxCount = opts.maxCount || 10;
+  if (length > maxCount) {
+    uploadProgress?.error(`最多只能上传${maxCount}个文件`);
+    return;
+  }
+  uploadProgress?.info(`上传中，共${length}个文件`);
+  return new Promise((resolve, reject) => {
+    const formData = new FormDataFn;
+    const webkitRelativePath = files[0]?.webkitRelativePath;
+    const keepDirectory = webkitRelativePath !== "";
+    const root = keepDirectory ? webkitRelativePath.split("/")[0] : "";
+    for (let i = 0;i < files.length; i++) {
+      const file = files[i];
+      if (keepDirectory) {
+        const webkitRelativePath2 = file.webkitRelativePath.replace(root + "/", "");
+        formData.append("file", file, webkitRelativePath2);
+      } else {
+        formData.append("file", files[i], files[i].name);
+      }
+    }
+    if (directory) {
+      formData.append("directory", directory);
+    }
+    if (appKey && version) {
+      formData.append("appKey", appKey);
+      formData.append("version", version);
+    }
+    if (username) {
+      formData.append("username", username);
+    }
+    const searchParams = new URLSearchParams;
+    const taskId = randomId();
+    searchParams.set("taskId", taskId);
+    if (noCheckAppFiles) {
+      searchParams.set("noCheckAppFiles", "1");
+    }
+    const eventSource = new EventSource("/api/s1/events?taskId=" + taskId);
+    uploadProgress?.start("上传中...");
+    eventSource.onopen = async function(event) {
+      const res = await fetch("/api/s1/resources/upload?" + searchParams.toString(), {
+        method: "POST",
+        body: formData,
+        headers: {
+          "task-id": taskId,
+          Authorization: `Bearer ${token}`
+        }
+      }).then((response) => response.json());
+      console.log("upload success", res);
+      fetch("/api/s1/events/close?taskId=" + taskId);
+      eventSource.close();
+      uploadProgress?.done();
+      resolve(res);
+    };
+    eventSource.onmessage = function(event) {
+      console.log("Progress update:", event.data);
+      const parseIfJson = (data) => {
+        try {
+          return JSON.parse(data);
+        } catch (e) {
+          return data;
+        }
+      };
+      const receivedData = parseIfJson(event.data);
+      if (typeof receivedData === "string")
+        return;
+      const progress = Number(receivedData.progress);
+      const progressFixed = progress.toFixed(2);
+      console.log("progress", progress);
+      uploadProgress?.set(progress, { ...receivedData, taskId, progressFixed });
+    };
+    eventSource.onerror = function(event) {
+      console.log("eventSource.onerror", event);
+      reject(event);
+    };
+  });
+};
+
+// query/query-upload/utils/to-file.ts
+var getFileExtension = (filename) => {
+  return filename.split(".").pop();
+};
+var getFileType = (extension) => {
+  switch (extension) {
+    case "js":
+      return "text/javascript";
+    case "css":
+      return "text/css";
+    case "html":
+      return "text/html";
+    case "json":
+      return "application/json";
+    case "png":
+      return "image/png";
+    case "jpg":
+      return "image/jpeg";
+    case "jpeg":
+      return "image/jpeg";
+    case "gif":
+      return "image/gif";
+    case "svg":
+      return "image/svg+xml";
+    case "webp":
+      return "image/webp";
+    case "ico":
+      return "image/x-icon";
+    default:
+      return "text/plain";
+  }
+};
+var checkIsBase64 = (content) => {
+  return content.startsWith("data:");
+};
+var getDirectoryAndName = (filename) => {
+  if (!filename) {
+    return null;
+  }
+  if (filename.startsWith(".")) {
+    return null;
+  } else {
+    filename = filename.replace(/^\/+/, "");
+  }
+  const hasDirectory = filename.includes("/");
+  if (!hasDirectory) {
+    return { directory: "", name: filename };
+  }
+  const parts = filename.split("/");
+  const name = parts.pop();
+  const directory = parts.join("/");
+  return { directory, name };
+};
+var toFile = (content, filename) => {
+  const directoryAndName = getDirectoryAndName(filename);
+  if (!directoryAndName) {
+    throw new Error("Invalid filename");
+  }
+  const { name } = directoryAndName;
+  const extension = getFileExtension(name);
+  if (!extension) {
+    throw new Error("Invalid filename");
+  }
+  const isBase64 = checkIsBase64(content);
+  const type = getFileType(extension);
+  if (isBase64) {
+    const base64Data = content.split(",")[1];
+    const byteCharacters = atob(base64Data);
+    const byteNumbers = new Array(byteCharacters.length);
+    for (let i = 0;i < byteCharacters.length; i++) {
+      byteNumbers[i] = byteCharacters.charCodeAt(i);
+    }
+    const byteArray = new Uint8Array(byteNumbers);
+    const blob = new Blob([byteArray], { type });
+    return new File([blob], filename, { type });
+  } else {
+    const blob = new Blob([content], { type });
+    return new File([blob], filename, { type });
+  }
+};
+// query/query-upload/query-upload-browser.ts
+var uploadChunk = async (file, opts, props) => {
+  const uploadProgress = new UploadProgress({
+    onStart: function() {
+      props?.onStart?.();
+    },
+    onDone: () => {
+      props?.onDone?.();
+    },
+    onProgress: (progress, data) => {
+      props?.onProgress?.(progress, data);
+    }
+  });
+  const result = await uploadFileChunked(file, opts, {
+    uploadProgress,
+    token: props?.token,
+    createEventSource: (url, searchParams) => {
+      return new EventSource(url + "?" + searchParams.toString());
+    },
+    FormDataFn: FormData
+  });
+  return result;
+};
+export {
+  uploadFiles,
+  uploadFileChunked,
+  uploadChunk,
+  toFile,
+  randomId,
+  UploadProgress
+};

package/dist/utils.d.ts

@@ -0,0 +1,33 @@
+declare const letter = "abcdefghijklmnopqrstuvwxyz";
+declare const number = "0123456789";
+declare const alphanumericWithDash = "abcdefghijklmnopqrstuvwxyz0123456789-";
+/**
+ * 创建一个随机的字母字符串
+ */
+declare const uuid: any;
+/**
+ * 创建一个随机的 id，包含字母和数字
+ */
+declare const nanoid: any;
+/**
+ * 创建一个随机的 id，包含字母、数字和短横线
+ */
+declare const nanoidWithDash: any;
+/**
+ * 创建一个随机的 id，以字母开头的字符串
+ * @param number
+ * @returns
+ */
+declare const randomId: (number: number) => string;
+/**
+ * 创建一个随机的字母字符串
+ * @param number
+ * @param opts
+ * @returns
+ */
+declare const randomLetter: (number?: number, opts?: {
+    before?: string;
+    after?: string;
+}) => string;
+
+export { alphanumericWithDash, letter, nanoid, nanoidWithDash, number, randomId, randomLetter, uuid };

package/dist/utils.js

@@ -0,0 +1,46 @@
+// 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) => {
+    let id = "";
+    while (true) {
+      let bytes = getRandom(step);
+      let j = step | 0;
+      while (j--) {
+        id += alphabet[bytes[j] & mask] || "";
+        if (id.length >= size)
+          return id;
+      }
+    }
+  };
+};
+var customAlphabet = (alphabet, size = 21) => customRandom(alphabet, size | 0, random);
+
+// query/utils/random.ts
+var letter = "abcdefghijklmnopqrstuvwxyz";
+var number = "0123456789";
+var alphanumeric = `${letter}${number}`;
+var alphanumericWithDash = `${alphanumeric}-`;
+var uuid = customAlphabet(letter);
+var nanoid = customAlphabet(alphanumeric, 10);
+var nanoidWithDash = customAlphabet(alphanumericWithDash, 10);
+var randomId = (number2) => {
+  const _letter = uuid(1);
+  return `${_letter}${nanoid(number2)}`;
+};
+var randomLetter = (number2 = 8, opts) => {
+  const { before = "", after = "" } = opts || {};
+  return `${before}${uuid(number2)}${after}`;
+};
+export {
+  uuid,
+  randomLetter,
+  randomId,
+  number,
+  nanoidWithDash,
+  nanoid,
+  letter,
+  alphanumericWithDash
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kevisual/api",
-  "version": "0.0.46",
+  "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/remote-app": "^0.0.2",
+    "@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-remote/index.ts

@@ -1,2 +1,5 @@
-import { RemoteApp } from '@Kevisual/remote-app'
+import { RemoteApp } from '@kevisual/remote-app'
 
+export {
+  RemoteApp
+}

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 '';