@kevisual/api 0.0.41 → 0.0.43

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,68 @@
+// 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);
+  return (size = defaultSize) => {
+    if (!size)
+      return "";
+    let id = "";
+    while (true) {
+      let bytes = getRandom(step);
+      let i = step;
+      while (i--) {
+        id += alphabet[bytes[i] & mask] || "";
+        if (id.length >= size)
+          return id;
+      }
+    }
+  };
+}
+function customAlphabet(alphabet, size = 21) {
+  return customRandom(alphabet, size, 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,11 +1,10 @@
 {
   "name": "@kevisual/api",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "",
   "main": "mod.ts",
   "scripts": {
-    "build": "bun run bun.config.ts",
-    "postbuild": "bun bun.copy.config.mjs"
+    "build": "bun run bun.config.ts"
   },
   "publishConfig": {
     "access": "public"
@@ -22,13 +21,15 @@
   "type": "module",
   "devDependencies": {
     "@kevisual/cache": "^0.0.5",
+    "@kevisual/code-builder": "^0.0.5",
     "@kevisual/query": "^0.0.39",
-    "@kevisual/router": "^0.0.66",
+    "@kevisual/router": "^0.0.69",
     "@kevisual/types": "^0.0.12",
-    "@kevisual/use-config": "^1.0.28",
+    "@kevisual/use-config": "^1.0.30",
+    "@types/spark-md5": "^3.0.5",
     "@types/bun": "^1.3.8",
     "@types/crypto-js": "^4.2.2",
-    "@types/node": "^25.1.0",
+    "@types/node": "^25.2.0",
     "crypto-js": "^4.2.0",
     "dotenv": "^17.2.3",
     "fast-glob": "^3.3.3"
@@ -36,7 +37,6 @@
   "dependencies": {
     "@kevisual/js-filter": "^0.0.5",
     "@kevisual/load": "^0.0.6",
-    "@types/spark-md5": "^3.0.5",
     "es-toolkit": "^1.44.0",
     "eventemitter3": "^5.0.4",
     "fuse.js": "^7.1.0",
@@ -52,6 +52,15 @@
     "./proxy": "./query/query-proxy/index.ts",
     "./secret": "./query/query-secret/index.ts",
     "./resources": "./query/query-resources/index.ts",
-    "./query/*": "./query/*"
+    "./query-secret": "./dist/query-secret.js",
+    "./utils": "./dist/utils.js",
+    "./query-upload": "./dist/query-upload.js",
+    "./query-app": "./dist/query-app.js",
+    "./query-proxy": "./dist/query-proxy.js",
+    "./query-shop": "./dist/query-shop.js",
+    "./query-config": "./dist/query-config.js",
+    "./query-login": "./dist/query-login.js",
+    "./query-ai": "./dist/query-ai.js",
+    "./query-resources": "./dist/query-resources.js"
   }
-}
+}

package/query/query-ai/index.ts

@@ -0,0 +1 @@
+export * from './query-ai.ts'

package/query/query-app/index.ts

@@ -0,0 +1 @@
+export * from './query-app.ts'

package/query/query-config/index.ts

@@ -0,0 +1 @@
+export * from './query-config.ts';

package/query/query-login/index.ts

@@ -0,0 +1 @@
+export * from './query-login-browser.ts';

package/query/query-proxy/proxy.ts

@@ -1,5 +1,5 @@
 import { QueryClient as Query, Result } from '@kevisual/query';
-import { QueryRouterServer, App, Route } from '@kevisual/router';
+import { QueryRouterServer, type App, type Route } from '@kevisual/router/browser';
 import { filter } from '@kevisual/js-filter'
 import { EventEmitter } from 'eventemitter3';
 import { initApi } from './router-api-proxy.ts';

package/query/query-proxy/router-api-proxy.ts

@@ -1,6 +1,6 @@
 import { Query } from "@kevisual/query";
 import { RouterViewApi, RouterItem } from "./proxy.ts";
-import { App, type QueryRouterServer } from "@kevisual/router";
+import { type App, type QueryRouterServer } from "@kevisual/router";
 import { filter } from "@kevisual/js-filter";
 import { isBrowser } from "es-toolkit";
 export const initApi = async (opts: {

package/query/query-resources/index.ts

@@ -2,15 +2,18 @@ import { adapter, DataOpts, Result } from '@kevisual/query';
 import path from 'path-browserify-esm';
 import { hashContent } from './utils';
 
+type Process = {}
 type QueryResourcesOptions = {
   prefix?: string;
   storage?: Storage;
   username?: string;
+  onProcess?: (opts?: Process) => void;
   [key: string]: any;
 };
 export class QueryResources {
   prefix: string; // root/resources
   storage: Storage;
+  onProcess?: (opts?: Process) => void;
   constructor(opts: QueryResourcesOptions) {
     if (opts.username) {
       this.prefix = `/${opts.username}/resources/`;
@@ -18,6 +21,7 @@ export class QueryResources {
       this.prefix = opts.prefix || '';
     }
     this.storage = opts.storage || localStorage;
+    this.onProcess = opts.onProcess || (() => { });
   }
   setUsername(username: string) {
     this.prefix = `/${username}/resources/`;
@@ -81,6 +85,7 @@ export class QueryResources {
       // 使用分块上传
       return this.uploadChunkedFile(filepath, content, hash, { chunkSize, ...restOpts });
     }
+    this.onProcess?.({ type: 'uploadBegin', filename, size: fileSize, process: 0 });
 
     const formData = new FormData();
     if (isBlob) {
@@ -88,7 +93,7 @@ export class QueryResources {
     } else {
       formData.append('file', new Blob([content], { type }));
     }
-    return adapter({
+    const res = await adapter({
       url: url.toString(),
       isPostFile: true,
       method: 'POST',
@@ -101,6 +106,8 @@ export class QueryResources {
         ...restOpts?.params,
       },
     });
+    this.onProcess?.({ type: 'uploadFinish', filename, size: fileSize, process: 100 });
+    return res;
   }
   async uploadChunkedFile(filepath: string, file: Blob, hash: string, opts?: DataOpts & { chunkSize?: number }): Promise<Result<any>> {
     const pathname = `${this.prefix}${filepath}`;
@@ -114,8 +121,10 @@ export class QueryResources {
     const { chunkSize: _chunkSize, ...restOpts } = opts || {};
     const chunkSize = _chunkSize ?? 5 * 1024 * 1024; // 5MB
     const totalChunks = Math.ceil(file.size / chunkSize);
+    this.onProcess?.({ type: 'uploadBegin', filename, size: file.size, process: 0 });
 
     for (let currentChunk = 0; currentChunk < totalChunks; currentChunk++) {
+      this.onProcess?.({ type: 'uploadChunkedFile', filename, size: file.size, process: 0, totalChunks, currentChunk: currentChunk + 1 });
       const start = currentChunk * chunkSize;
       const end = Math.min(start + chunkSize, file.size);
       const chunkBlob = file.slice(start, end);
@@ -145,15 +154,16 @@ export class QueryResources {
           },
         });
         if (res.code !== 200) {
-          throw new Error(`Chunk upload failed with code ${res!.code}, message: ${res!.message}`);
+          throw new Error(`Chunk 上传失败 code ${res!.code}, 错误信息是: ${res!.message}`);
         }
         console.log(`Chunk ${currentChunk + 1}/${totalChunks} uploaded`, res);
+        this.onProcess?.({ type: 'uploadChunkedFile', filename, size: file.size, process: Math.round(((currentChunk + 1) / totalChunks) * 100), totalChunks, currentChunk: currentChunk + 1 });
       } catch (error) {
         console.error(`Error uploading chunk ${currentChunk + 1}/${totalChunks}`, error);
         return { code: 500, message: `分块上传失败: ${(error as Error).message}` };
       }
     }
-
+    this.onProcess?.({ type: 'uploadFinish', filename, size: file.size, process: 100 });
     return { code: 200, message: '上传成功' };
   }
 

package/query/query-shop/index.ts

@@ -0,0 +1 @@
+export * from './query-shop.ts'

package/query/query-upload/index.ts

@@ -0,0 +1 @@
+export * from './query-upload-browser.ts';

package/query/utils/index.ts

@@ -0,0 +1 @@
+export * from './random.ts';

package/query/utils/random.ts

@@ -4,10 +4,19 @@ export const letter = 'abcdefghijklmnopqrstuvwxyz';
 export const number = '0123456789';
 const alphanumeric = `${letter}${number}`;
 export const alphanumericWithDash = `${alphanumeric}-`;
+/**
+ * 创建一个随机的字母字符串
+ */
 export const uuid = customAlphabet(letter);
 
+/** 
+ * 创建一个随机的 id，包含字母和数字
+ */
 export const nanoid = customAlphabet(alphanumeric, 10);
 
+/**
+ * 创建一个随机的 id，包含字母、数字和短横线
+ */
 export const nanoidWithDash = customAlphabet(alphanumericWithDash, 10);
 
 /**
@@ -20,6 +29,12 @@ export const randomId = (number: number) => {
   return `${_letter}${nanoid(number)}`;
 };
 
+/**
+ * 创建一个随机的字母字符串
+ * @param number 
+ * @param opts 
+ * @returns 
+ */
 export const randomLetter = (number: number = 8, opts?: { before?: string; after?: string }) => {
   const { before = '', after = '' } = opts || {};
   return `${before}${uuid(number)}${after}`;