@springbrand/gravel 0.1.0

package/dist/utils/storage-qetag.d.ts

@@ -0,0 +1,22 @@
+interface ITypeInfo {
+    ext: string;
+    mime: string;
+}
+export default class QiNiuETag {
+    currentLength: number;
+    chunkTime: number;
+    sha1String: any[];
+    type: ITypeInfo | undefined;
+    updateBlob(blob: File): Promise<void>;
+    changeCurrent(): void;
+    concatArr2Uint8(s: any): Uint8Array<ArrayBuffer>;
+    readBlobToArrayBuffer(blob: Blob): Promise<string | ArrayBuffer | null>;
+    get sha1Buffer(): any;
+    get getEtag(): string;
+    get typeInfo(): ITypeInfo | undefined;
+    get fileInfo(): {
+        sha1: string;
+        typeInfo: ITypeInfo | undefined;
+    };
+}
+export {};

package/dist/utils/storage-qetag.js

@@ -0,0 +1,101 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import fileType from "file-type";
+import hash from "js-sha1";
+const chunkSize = 4 * 1024 * 1024;
+const shA1 = hash.digest;
+class QiNiuETag {
+  constructor() {
+    __publicField(this, "currentLength", 0);
+    __publicField(this, "chunkTime", 0);
+    __publicField(this, "sha1String", []);
+    __publicField(this, "type");
+  }
+  async updateBlob(blob) {
+    let i = 0;
+    while (i < blob.size) {
+      const size = Math.min(
+        chunkSize,
+        blob.size - i,
+        chunkSize - this.currentLength
+      );
+      const to = i + size;
+      const chunkBlob = blob.slice(i, to);
+      const chunkData = await this.readBlobToArrayBuffer(chunkBlob);
+      if (chunkData === null) {
+        throw new Error("Failed to read blob data");
+      }
+      const chunkSha1 = shA1(chunkData);
+      this.sha1String.push(chunkSha1);
+      if (this.chunkTime === 0) {
+        this.type = await fileType(chunkData);
+      }
+      this.currentLength += size;
+      if (this.currentLength === chunkSize) {
+        this.changeCurrent();
+      }
+      i = to;
+    }
+  }
+  changeCurrent() {
+    if (this.currentLength > 0) {
+      this.chunkTime++;
+      this.currentLength = 0;
+    }
+  }
+  concatArr2Uint8(s) {
+    let tmp = [];
+    for (const i of s) tmp = tmp.concat(i);
+    return new Uint8Array(tmp);
+  }
+  readBlobToArrayBuffer(blob) {
+    return new Promise((resolve, reject) => {
+      const fileReader = new FileReader();
+      fileReader.onload = () => resolve(fileReader.result);
+      fileReader.onerror = reject;
+      fileReader.readAsArrayBuffer(blob);
+    });
+  }
+  get sha1Buffer() {
+    let returnData = this.concatArr2Uint8(this.sha1String);
+    let prefix;
+    if (this.chunkTime >= 1) {
+      prefix = [150];
+      returnData = shA1(returnData.buffer);
+    } else {
+      prefix = [22];
+      returnData = Array.apply([], returnData);
+    }
+    returnData = this.concatArr2Uint8([[prefix], returnData]);
+    return returnData;
+  }
+  get getEtag() {
+    const CHUNK_SIZE = 32768;
+    const length = this.sha1Buffer.length;
+    let index = 0;
+    let result = "";
+    let slice;
+    while (index < length) {
+      slice = this.sha1Buffer.subarray(
+        index,
+        Math.min(index + CHUNK_SIZE, length)
+      );
+      result += String.fromCharCode.apply(null, slice);
+      index += CHUNK_SIZE;
+    }
+    return btoa(result).replace(/\//g, "_").replace(/\+/g, "-");
+  }
+  get typeInfo() {
+    return this.type;
+  }
+  get fileInfo() {
+    return {
+      sha1: this.getEtag,
+      typeInfo: this.typeInfo
+    };
+  }
+}
+export {
+  QiNiuETag as default
+};

package/dist/utils/utils-api.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @description 将对象转换为URL参数
+ * @param url 基础URL
+ * @param params 参数对象
+ * @returns 带参数的完整URL
+ */
+export declare function getUrlWithParams(url: string, params: Record<string, any>): string;
+/**
+ * @description 大数字格式化工具函数
+ * @param num 要格式化的数字
+ * @param format 格式化配置
+ * @returns 格式化后的字符串
+ */
+export declare function formatLargeNumber(num: number, format?: {
+    unit?: number;
+    unitCN?: string;
+}): string;

package/dist/utils/utils-api.js

@@ -0,0 +1,31 @@
+import { filterEmptyValues } from "./utils-common.js";
+function getUrlWithParams(url, params) {
+  if (!params || Object.keys(params).length === 0) {
+    return url;
+  }
+  const urlObj = new URL(url, window.location.origin);
+  Object.entries(filterEmptyValues(params)).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null && value !== "") {
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          urlObj.searchParams.append(key, String(item));
+        });
+      } else {
+        urlObj.searchParams.set(key, String(value));
+      }
+    }
+  });
+  return urlObj.toString();
+}
+function formatLargeNumber(num, format = {}) {
+  const { unit = 1e4, unitCN = "万" } = format;
+  if (num < unit) {
+    return `${unit}+`;
+  }
+  const result = Math.floor(num / unit);
+  return `${result}${unitCN}+`;
+}
+export {
+  formatLargeNumber,
+  getUrlWithParams
+};

package/dist/utils/utils-canvas.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @description Blob转换File对象
+ * @param blobData
+ */
+export declare function structureFile(blobData: Blob): File;
+/**
+ * @description blobToUrl
+ * @param {*} blobData
+ */
+export declare function blobToUrl(blobData: Blob): string;
+/**
+ * @description base64ToBlob
+ * @param {*} base64
+ */
+export declare function convertBase64ToBlob(base64: string): Blob;
+/**
+ * @description base64ToUrl
+ * @param {*} base64
+ */
+export declare function base64ToUrl(base64: string): string;
+/**
+ * @description base64ToFile
+ * @param {*} base64
+ */
+export declare function base64ToFile(base64: string): File;
+/**
+ * @description blobToBase64
+ * @param blob
+ */
+export declare function blobToBase64(blob: Blob): Promise<unknown>;

package/dist/utils/utils-canvas.js

@@ -0,0 +1,54 @@
+function structureFile(blobData) {
+  const fileType = blobData.type.split("/");
+  const ext = fileType[1];
+  const file = new window.File([blobData], `tag.${ext}`, {
+    type: blobData.type
+  });
+  return file;
+}
+function blobToUrl(blobData) {
+  return URL.createObjectURL(blobData);
+}
+function convertBase64ToBlob(base64) {
+  const base64Arr = base64.split(",");
+  let imgType = "";
+  let base64String = "";
+  if (base64Arr.length > 1) {
+    base64String = base64Arr[1];
+    imgType = base64Arr[0].substring(
+      base64Arr[0].indexOf(":") + 1,
+      base64Arr[0].indexOf(";")
+    );
+  }
+  const bytes = atob(base64String);
+  const bytesCode = new ArrayBuffer(bytes.length);
+  const byteArray = new Uint8Array(bytesCode);
+  for (let i = 0; i < bytes.length; i++) {
+    byteArray[i] = bytes.charCodeAt(i);
+  }
+  return new Blob([bytesCode], { type: imgType });
+}
+function base64ToUrl(base64) {
+  const blobData = convertBase64ToBlob(base64);
+  return blobToUrl(blobData);
+}
+function base64ToFile(base64) {
+  const blobData = convertBase64ToBlob(base64);
+  return structureFile(blobData);
+}
+function blobToBase64(blob) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => resolve(reader.result);
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
+export {
+  base64ToFile,
+  base64ToUrl,
+  blobToBase64,
+  blobToUrl,
+  convertBase64ToBlob,
+  structureFile
+};

package/dist/utils/utils-common.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @description 过滤对象中的空值
+ * @param obj 要过滤的对象
+ * @returns 过滤后的对象
+ */
+export declare function filterEmptyValues(obj: Record<string, any>): Record<string, any>;

package/dist/utils/utils-common.js

@@ -0,0 +1,15 @@
+function filterEmptyValues(obj) {
+  if (!obj || typeof obj !== "object") {
+    return {};
+  }
+  const filtered = {};
+  Object.entries(obj).forEach(([key, value]) => {
+    if (value !== "" && value !== null && value !== void 0) {
+      filtered[key] = value;
+    }
+  });
+  return filtered;
+}
+export {
+  filterEmptyValues
+};

package/dist/utils/utils-image.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 下载图片
+ * @param url 图片URL
+ */
+export declare function downloadImage(url: string): void;
+/**
+ * @description 获取网络图片
+ * @param url
+ */
+export declare function fetchHasOnlineFile(url: string): Promise<number | false>;
+/**
+ * @description 判断文件类型是否有效
+ * @param file
+ * @param validExtensions
+ * @param validMimeTypes
+ */
+export declare const isValidFileType: (file: File | string, validExtensions?: string[], validMimeTypes?: string[]) => boolean;
+/**
+ * @description 判断文件大小是否有效
+ * @param file
+ * @param maxSize
+ */
+export declare const isValidFileSize: (file: File, maxSize?: number) => boolean;
+/**
+ * @description getBase64 by tempUrl
+ * @param tempUrl
+ */
+export declare const getBase64Client: (tempUrl: string) => Promise<string>;
+/**
+ * @description 下载图片
+ * @param url
+ */
+export declare const downloadImageClient: (url: string) => Promise<void>;

package/dist/utils/utils-image.js

@@ -0,0 +1,57 @@
+import axios from "axios";
+import FileSaver from "file-saver";
+import { blobToBase64 } from "./utils-canvas.js";
+function downloadImage(url) {
+  const a = document.createElement("a");
+  a.href = url;
+  a.target = "_blank";
+  a.download = "my-labubu.png";
+  a.click();
+}
+async function fetchHasOnlineFile(url) {
+  const res = await fetch(url, {
+    method: "head"
+  });
+  if (res.status === 200) {
+    return Number(res.headers.get("Content-Length"));
+  } else {
+    return false;
+  }
+}
+const isValidFileType = (file, validExtensions = [".jpg", ".jpeg", ".png", ".gif", ".webp"], validMimeTypes = [
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]) => {
+  if (typeof file === "string") {
+    return validExtensions.some((ext) => file.toLowerCase().endsWith(ext));
+  } else if (file instanceof File) {
+    return validMimeTypes.includes(file.type);
+  }
+  return false;
+};
+const isValidFileSize = (file, maxSize = 10 * 1024 * 1024) => {
+  return file.size <= maxSize;
+};
+const getBase64Client = async (tempUrl) => {
+  const response = await fetch(tempUrl);
+  const blob = await response.blob();
+  const base64 = await blobToBase64(blob);
+  return base64;
+};
+const downloadImageClient = async (url) => {
+  const response = await axios.get(url, { responseType: "blob" });
+  const blob = response.data;
+  const tempUrl = URL.createObjectURL(blob);
+  const uuid = Math.random().toString(36).substring(2);
+  FileSaver.saveAs(tempUrl, `${uuid}.png`);
+};
+export {
+  downloadImage,
+  downloadImageClient,
+  fetchHasOnlineFile,
+  getBase64Client,
+  isValidFileSize,
+  isValidFileType
+};

package/dist/utils/utils-random.d.ts

@@ -0,0 +1 @@
+export declare const nanoid: (size?: number) => string;

package/dist/utils/utils-random.js

@@ -0,0 +1,6 @@
+import { customAlphabet } from "nanoid";
+const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+const nanoid = customAlphabet(alphabet, 16);
+export {
+  nanoid
+};

package/dist/utils/utils-time.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 计算距离现在多少时间
+ * @param date 目标日期
+ * @param options 配置选项
+ * @returns 格式化的时间差字符串
+ */
+export declare function timeAgo(date: string | Date, options?: {
+    lang?: "zh" | "en";
+    showSeconds?: boolean;
+    showZero?: boolean;
+}): string;
+/**
+ * 格式化日期为相对时间（简化版）
+ * @param date 目标日期
+ * @returns 格式化的时间差字符串
+ */
+export declare function formatTimeAgo(date: string | Date): string;
+/**
+ * 获取详细的时间信息
+ * @param date 目标日期
+ * @returns 包含各种时间单位的对象
+ */
+export declare function getTimeDetails(date: string | Date): {
+    seconds: number;
+    minutes: number;
+    hours: number;
+    days: number;
+    weeks: number;
+    months: number;
+    years: number;
+    isValid: boolean;
+};
+/**
+ * 获取时间戳
+ * @returns 时间戳
+ */
+export declare const getTimestamp: () => number;
+/**
+ * 睡眠
+ * @param ms 睡眠时间
+ * @returns 睡眠后的Promise
+ */
+export declare const sleep: (ms: number) => Promise<unknown>;
+/**
+ * 格式化时间
+ * @param time 时间
+ * @returns 格式化后的时间
+ */
+export declare const formatTimeString: (time: Date) => string;

package/dist/utils/utils-time.js

@@ -0,0 +1,112 @@
+import dayjs from "dayjs";
+function timeAgo(date, options = {}) {
+  const { lang = "zh", showSeconds = false, showZero = false } = options;
+  const now = /* @__PURE__ */ new Date();
+  const targetDate = typeof date === "string" ? new Date(date) : date;
+  const diffInMs = now.getTime() - targetDate.getTime();
+  if (isNaN(diffInMs) || diffInMs < 0) {
+    return lang === "zh" ? "刚刚" : "just now";
+  }
+  const diffInSeconds = Math.floor(diffInMs / 1e3);
+  const diffInMinutes = Math.floor(diffInSeconds / 60);
+  const diffInHours = Math.floor(diffInMinutes / 60);
+  const diffInDays = Math.floor(diffInHours / 24);
+  const diffInWeeks = Math.floor(diffInDays / 7);
+  const diffInMonths = Math.floor(diffInDays / 30);
+  const diffInYears = Math.floor(diffInDays / 365);
+  if (lang === "zh") {
+    if (diffInYears > 0) {
+      return `${diffInYears}年前`;
+    }
+    if (diffInMonths > 0) {
+      return `${diffInMonths}个月前`;
+    }
+    if (diffInWeeks > 0) {
+      return `${diffInWeeks}周前`;
+    }
+    if (diffInDays > 0) {
+      return `${diffInDays}天前`;
+    }
+    if (diffInHours > 0) {
+      return `${diffInHours}小时前`;
+    }
+    if (diffInMinutes > 0) {
+      return `${diffInMinutes}分钟前`;
+    }
+    if (showSeconds && diffInSeconds > 0) {
+      return `${diffInSeconds}秒前`;
+    }
+    return showZero ? "0秒前" : "刚刚";
+  } else {
+    if (diffInYears > 0) {
+      return `${diffInYears} year${diffInYears > 1 ? "s" : ""} ago`;
+    }
+    if (diffInMonths > 0) {
+      return `${diffInMonths} month${diffInMonths > 1 ? "s" : ""} ago`;
+    }
+    if (diffInWeeks > 0) {
+      return `${diffInWeeks} week${diffInWeeks > 1 ? "s" : ""} ago`;
+    }
+    if (diffInDays > 0) {
+      return `${diffInDays} day${diffInDays > 1 ? "s" : ""} ago`;
+    }
+    if (diffInHours > 0) {
+      return `${diffInHours} hour${diffInHours > 1 ? "s" : ""} ago`;
+    }
+    if (diffInMinutes > 0) {
+      return `${diffInMinutes} minute${diffInMinutes > 1 ? "s" : ""} ago`;
+    }
+    if (showSeconds && diffInSeconds > 0) {
+      return `${diffInSeconds} second${diffInSeconds > 1 ? "s" : ""} ago`;
+    }
+    return showZero ? "0 seconds ago" : "just now";
+  }
+}
+function formatTimeAgo(date) {
+  return timeAgo(date, { lang: "en" });
+}
+function getTimeDetails(date) {
+  const now = /* @__PURE__ */ new Date();
+  const targetDate = typeof date === "string" ? new Date(date) : date;
+  const diffInMs = now.getTime() - targetDate.getTime();
+  if (isNaN(diffInMs) || diffInMs < 0) {
+    return {
+      seconds: 0,
+      minutes: 0,
+      hours: 0,
+      days: 0,
+      weeks: 0,
+      months: 0,
+      years: 0,
+      isValid: false
+    };
+  }
+  return {
+    seconds: Math.floor(diffInMs / 1e3),
+    minutes: Math.floor(diffInMs / (1e3 * 60)),
+    hours: Math.floor(diffInMs / (1e3 * 60 * 60)),
+    days: Math.floor(diffInMs / (1e3 * 60 * 60 * 24)),
+    weeks: Math.floor(diffInMs / (1e3 * 60 * 60 * 24 * 7)),
+    months: Math.floor(diffInMs / (1e3 * 60 * 60 * 24 * 30)),
+    years: Math.floor(diffInMs / (1e3 * 60 * 60 * 24 * 365)),
+    isValid: true
+  };
+}
+const getTimestamp = () => {
+  const time = Date.parse((/* @__PURE__ */ new Date()).toUTCString());
+  return time / 1e3;
+};
+const sleep = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+const formatTimeString = (time) => {
+  return dayjs(time).format("YYYY-MM-DD HH:mm:ss");
+};
+export {
+  formatTimeAgo,
+  formatTimeString,
+  getTimeDetails,
+  getTimestamp,
+  sleep,
+  timeAgo
+};