@kevisual/api 0.0.42 → 0.0.44

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.42",
+  "version": "0.0.44",
   "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,10 +21,12 @@
   "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.30",
+    "@types/spark-md5": "^3.0.5",
     "@types/bun": "^1.3.8",
     "@types/crypto-js": "^4.2.2",
     "@types/node": "^25.2.0",
@@ -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, fromJSONSchema, toJSONSchema } from '@kevisual/router/browser';
 import { filter } from '@kevisual/js-filter'
 import { EventEmitter } from 'eventemitter3';
 import { initApi } from './router-api-proxy.ts';
@@ -190,6 +190,7 @@ export class QueryProxy {
 
   /**
    * 初始化路由
+   * main
    * @returns 
    */
   async init() {
@@ -246,6 +247,8 @@ export class QueryProxy {
       return
     }
     const routes = router.getList();
+    // TODO: args
+    // const args = fromJSONSchema(r);
     for (const r of routes) {
       console.debug(`注册路由: [${r.path}] ${r?.key}`, 'Context');
       let metadata = r.metadata || {};
@@ -378,6 +381,13 @@ export class QueryProxy {
       return;
     }
   }
+  getQueryByViewId(viewId: string): string | undefined {
+    const view = this.views.find(v => v.id === viewId);
+    if (view) {
+      return view.query;
+    }
+    return undefined;
+  }
   /**
    * 列出路由
    * @param filter 
@@ -386,14 +396,10 @@ export class QueryProxy {
    */
   async listRoutes(filterFn?: (item: Route) => boolean, opts?: { viewId?: string, query?: string }) {
     let query = opts?.query;
-    if (opts?.viewId) {
-      const view = this.views.find(v => v.id === opts.viewId);
-      if (view) {
-        query = view.query;
-      }
-    } if (opts?.query) {
-      query = opts.query;
+    if (opts?.viewId && !query) {
+      query = this.getQueryByViewId(opts.viewId);
     }
+
     const routes = this.router.routes.filter(filterFn || (() => true));
     if (query) {
       if (query.toLocaleUpperCase().startsWith('WHERE')) {

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-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}`;