@kevisual/api 0.0.46 → 0.0.47

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,6 +1,6 @@
 {
   "name": "@kevisual/api",
-  "version": "0.0.46",
+  "version": "0.0.47",
   "description": "",
   "main": "mod.ts",
   "scripts": {
@@ -23,7 +23,7 @@
     "@kevisual/cache": "^0.0.5",
     "@kevisual/code-builder": "^0.0.6",
     "@kevisual/query": "^0.0.39",
-    "@kevisual/remote-app": "^0.0.2",
+    "@kevisual/remote-app": "^0.0.4",
     "@kevisual/router": "^0.0.70",
     "@kevisual/types": "^0.0.12",
     "@kevisual/use-config": "^1.0.30",

package/query/query-remote/index.ts

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