@brix-sdk/platform-shared 1.0.0

package/dist/chunk-OGZE7TFO.js

@@ -0,0 +1,509 @@
+import { init_id } from './chunk-DJX6ASLI.js';
+
+// src/utils/debounce.ts
+function debounce(fn, delay2) {
+  let timeoutId = null;
+  return function(...args) {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    const context = this;
+    timeoutId = setTimeout(() => {
+      fn.apply(context, args);
+      timeoutId = null;
+    }, delay2);
+  };
+}
+function throttle(fn, limit) {
+  let inThrottle = false;
+  let lastArgs = null;
+  let lastContext = null;
+  return function(...args) {
+    if (!inThrottle) {
+      fn.apply(this, args);
+      inThrottle = true;
+      setTimeout(() => {
+        inThrottle = false;
+        if (lastArgs !== null && lastContext !== null) {
+          fn.apply(lastContext, lastArgs);
+          lastArgs = null;
+          lastContext = null;
+        }
+      }, limit);
+    } else {
+      lastArgs = args;
+      lastContext = this;
+    }
+  };
+}
+
+// src/utils/index.ts
+init_id();
+
+// src/utils/guards.ts
+function isNullOrUndefined(value) {
+  return value === null || value === void 0;
+}
+function isNotNullOrUndefined(value) {
+  return value !== null && value !== void 0;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && !Number.isNaN(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isPromise(value) {
+  return value instanceof Promise || isObject(value) && isFunction(value.then) && isFunction(value.catch);
+}
+function assertNotNull(value, message = "Value is null or undefined") {
+  if (isNullOrUndefined(value)) {
+    throw new Error(message);
+  }
+}
+function assert(condition, message = "Assertion failed") {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+
+// src/utils/clone.ts
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      clonedMap.set(deepClone(key), deepClone(value));
+    });
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clonedSet.add(deepClone(value));
+    });
+    return clonedSet;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  const clonedObj = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      clonedObj[key] = deepClone(obj[key]);
+    }
+  }
+  return clonedObj;
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length) {
+    return target;
+  }
+  const source = sources.shift();
+  if (source === void 0) {
+    return target;
+  }
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const targetValue = target[key];
+      const sourceValue = source[key];
+      if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+        target[key] = deepMerge(
+          targetValue,
+          sourceValue
+        );
+      } else if (sourceValue !== void 0) {
+        target[key] = deepClone(sourceValue);
+      }
+    }
+  }
+  return deepMerge(target, ...sources);
+}
+
+// src/utils/format.ts
+function formatFileSize(bytes, decimals = 2) {
+  if (bytes === 0) return "0 B";
+  if (bytes < 0) return "-" + formatFileSize(-bytes, decimals);
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const index = Math.min(i, sizes.length - 1);
+  return `${parseFloat((bytes / Math.pow(k, index)).toFixed(decimals))} ${sizes[index]}`;
+}
+function parseFileSize(sizeStr) {
+  const units = {
+    B: 1,
+    KB: 1024,
+    MB: 1024 ** 2,
+    GB: 1024 ** 3,
+    TB: 1024 ** 4,
+    PB: 1024 ** 5
+  };
+  const match = sizeStr.trim().toUpperCase().match(/^([\d.]+)\s*([A-Z]+)$/);
+  if (!match) return 0;
+  const [, value, unit] = match;
+  return parseFloat(value) * (units[unit] || 1);
+}
+function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
+  const d = new Date(date);
+  if (isNaN(d.getTime())) {
+    return "Invalid Date";
+  }
+  const replacements = {
+    YYYY: d.getFullYear().toString(),
+    YY: d.getFullYear().toString().slice(-2),
+    MM: (d.getMonth() + 1).toString().padStart(2, "0"),
+    M: (d.getMonth() + 1).toString(),
+    DD: d.getDate().toString().padStart(2, "0"),
+    D: d.getDate().toString(),
+    HH: d.getHours().toString().padStart(2, "0"),
+    H: d.getHours().toString(),
+    mm: d.getMinutes().toString().padStart(2, "0"),
+    m: d.getMinutes().toString(),
+    ss: d.getSeconds().toString().padStart(2, "0"),
+    s: d.getSeconds().toString(),
+    SSS: d.getMilliseconds().toString().padStart(3, "0")
+  };
+  let result = format;
+  const keys = Object.keys(replacements).sort((a, b) => b.length - a.length);
+  for (const key of keys) {
+    result = result.replace(new RegExp(key, "g"), replacements[key]);
+  }
+  return result;
+}
+function formatRelativeTime(date, now = Date.now()) {
+  const d = new Date(date);
+  const diff = now - d.getTime();
+  const absDiff = Math.abs(diff);
+  const suffix = diff > 0 ? "\u524D" : "\u540E";
+  const seconds = Math.floor(absDiff / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const months = Math.floor(days / 30);
+  const years = Math.floor(days / 365);
+  if (seconds < 60) {
+    return seconds <= 10 ? "\u521A\u521A" : `${seconds}\u79D2${suffix}`;
+  }
+  if (minutes < 60) {
+    return `${minutes}\u5206\u949F${suffix}`;
+  }
+  if (hours < 24) {
+    return `${hours}\u5C0F\u65F6${suffix}`;
+  }
+  if (days < 30) {
+    return `${days}\u5929${suffix}`;
+  }
+  if (months < 12) {
+    return `${months}\u4E2A\u6708${suffix}`;
+  }
+  return `${years}\u5E74${suffix}`;
+}
+function formatDuration(ms, options = {}) {
+  const { style = "short" } = options;
+  const seconds = Math.floor(ms / 1e3 % 60);
+  const minutes = Math.floor(ms / (1e3 * 60) % 60);
+  const hours = Math.floor(ms / (1e3 * 60 * 60) % 24);
+  const days = Math.floor(ms / (1e3 * 60 * 60 * 24));
+  if (style === "long") {
+    const parts = [];
+    if (days > 0) parts.push(`${days}\u5929`);
+    if (hours > 0) parts.push(`${hours}\u5C0F\u65F6`);
+    if (minutes > 0) parts.push(`${minutes}\u5206\u949F`);
+    if (seconds > 0 || parts.length === 0) parts.push(`${seconds}\u79D2`);
+    return parts.join("");
+  }
+  if (days > 0) {
+    return `${days}d ${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+  }
+  if (hours > 0) {
+    return `${hours}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+  }
+  return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+}
+function formatNumber(num, decimals) {
+  if (isNaN(num)) return "NaN";
+  if (!isFinite(num)) return num > 0 ? "\u221E" : "-\u221E";
+  const fixed = decimals !== void 0 ? num.toFixed(decimals) : num.toString();
+  const [intPart, decPart] = fixed.split(".");
+  const formattedInt = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return decPart ? `${formattedInt}.${decPart}` : formattedInt;
+}
+function formatPercent(value, decimals = 2, asRatio = true) {
+  const percent = asRatio ? value * 100 : value;
+  return `${percent.toFixed(decimals)}%`;
+}
+function formatCurrency(amount, currency = "CNY", locale = "zh-CN") {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency
+  }).format(amount);
+}
+function truncate(str, maxLength, suffix = "...") {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - suffix.length) + suffix;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function camelCase(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+// src/utils/timing.ts
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function delayWith(ms, value) {
+  return new Promise((resolve) => setTimeout(() => resolve(value), ms));
+}
+function cancelableDelay(ms) {
+  let timeoutId;
+  let rejectFn;
+  const promise = new Promise((resolve, reject) => {
+    rejectFn = reject;
+    timeoutId = setTimeout(resolve, ms);
+  });
+  return {
+    promise,
+    cancel: () => {
+      clearTimeout(timeoutId);
+      rejectFn(new Error("Delay cancelled"));
+    }
+  };
+}
+function withTimeout(promise, ms, message = "Operation timed out") {
+  let timeoutId;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(message));
+    }, ms);
+  });
+  return Promise.race([promise, timeoutPromise]).finally(() => {
+    clearTimeout(timeoutId);
+  });
+}
+function nextTick(fn) {
+  setTimeout(fn, 0);
+}
+function requestIdleCallback(fn, options) {
+  if (typeof window !== "undefined" && "requestIdleCallback" in window) {
+    return window.requestIdleCallback(fn, options);
+  }
+  return setTimeout(fn, options?.timeout ?? 1);
+}
+
+// src/utils/validators.ts
+function isValidEmail(email) {
+  if (!email || typeof email !== "string") return false;
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email.trim());
+}
+function isValidPhone(phone) {
+  if (!phone || typeof phone !== "string") return false;
+  const phoneRegex = /^1[3-9]\d{9}$/;
+  return phoneRegex.test(phone.trim());
+}
+function isValidUrl(url) {
+  if (!url || typeof url !== "string") return false;
+  try {
+    const parsed = new URL(url);
+    return ["http:", "https:"].includes(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+function isValidIPv4(ip) {
+  if (!ip || typeof ip !== "string") return false;
+  const parts = ip.split(".");
+  if (parts.length !== 4) return false;
+  return parts.every((part) => {
+    const num = parseInt(part, 10);
+    return num >= 0 && num <= 255 && part === num.toString();
+  });
+}
+function isValidJSON(str) {
+  try {
+    JSON.parse(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidIdCard(idCard) {
+  if (!idCard || typeof idCard !== "string") return false;
+  const id = idCard.trim().toUpperCase();
+  if (id.length === 18) {
+    if (!/^\d{17}[\dX]$/.test(id)) return false;
+    const weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+    const checkCodes = ["1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"];
+    let sum = 0;
+    for (let i = 0; i < 17; i++) {
+      sum += parseInt(id[i], 10) * weights[i];
+    }
+    return id[17] === checkCodes[sum % 11];
+  }
+  if (id.length === 15) {
+    return /^\d{15}$/.test(id);
+  }
+  return false;
+}
+function isValidUnifiedCreditCode(code) {
+  if (!code || typeof code !== "string") return false;
+  const regex = /^[0-9A-HJ-NPQRTUWXY]{2}\d{6}[0-9A-HJ-NPQRTUWXY]{10}$/;
+  return regex.test(code.trim().toUpperCase());
+}
+function isValidBankCard(cardNumber) {
+  if (!cardNumber || typeof cardNumber !== "string") return false;
+  const cleaned = cardNumber.replace(/\s/g, "");
+  if (!/^\d{13,19}$/.test(cleaned)) return false;
+  let sum = 0;
+  let isEven = false;
+  for (let i = cleaned.length - 1; i >= 0; i--) {
+    let digit = parseInt(cleaned[i], 10);
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+    sum += digit;
+    isEven = !isEven;
+  }
+  return sum % 10 === 0;
+}
+function checkPasswordStrength(password) {
+  const suggestions = [];
+  let score = 0;
+  if (!password) {
+    return { strength: "weak", score: 0, suggestions: ["\u8BF7\u8F93\u5165\u5BC6\u7801"] };
+  }
+  if (password.length >= 8) score += 1;
+  else suggestions.push("\u5BC6\u7801\u957F\u5EA6\u81F3\u5C118\u4F4D");
+  if (password.length >= 12) score += 1;
+  if (password.length >= 16) score += 1;
+  if (/[a-z]/.test(password)) score += 1;
+  else suggestions.push("\u5EFA\u8BAE\u5305\u542B\u5C0F\u5199\u5B57\u6BCD");
+  if (/[A-Z]/.test(password)) score += 1;
+  else suggestions.push("\u5EFA\u8BAE\u5305\u542B\u5927\u5199\u5B57\u6BCD");
+  if (/\d/.test(password)) score += 1;
+  else suggestions.push("\u5EFA\u8BAE\u5305\u542B\u6570\u5B57");
+  if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) score += 2;
+  else suggestions.push("\u5EFA\u8BAE\u5305\u542B\u7279\u6B8A\u5B57\u7B26");
+  const commonPatterns = [
+    /^123/,
+    /password/i,
+    /qwerty/i,
+    /^abc/i
+  ];
+  if (commonPatterns.some((p) => p.test(password))) {
+    score -= 2;
+    suggestions.push("\u907F\u514D\u4F7F\u7528\u5E38\u89C1\u5BC6\u7801\u6A21\u5F0F");
+  }
+  let strength;
+  if (score <= 2) strength = "weak";
+  else if (score <= 4) strength = "medium";
+  else if (score <= 6) strength = "strong";
+  else strength = "very-strong";
+  return { strength, score: Math.max(0, score), suggestions };
+}
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function isNumeric(value) {
+  if (typeof value === "number") return !isNaN(value) && isFinite(value);
+  if (typeof value === "string") return !isNaN(parseFloat(value)) && isFinite(parseFloat(value));
+  return false;
+}
+function isInteger(value) {
+  return Number.isInteger(value);
+}
+function isPositive(value) {
+  return typeof value === "number" && value > 0;
+}
+function isInRange(value, min, max) {
+  return typeof value === "number" && value >= min && value <= max;
+}
+/**
+ * @file format.ts
+ * @description 格式化工具函数集
+ * @module @brix/utils/format
+ * @version 3.0.0
+ * 
+ * 【模块说明】
+ * 提供各种数据格式化工具，包括文件大小、日期时间、数字、货币、字符串等。
+ * 这些函数遵循中国大陆的常用格式习惯，同时支持国际化配置。
+ * 
+ * 【使用场景】
+ * - 文件大小：上传下载、存储空间显示
+ * - 日期格式化：时间显示、相对时间、倒计时
+ * - 数字格式化：金额、百分比、统计数据
+ * - 字符串处理：截断、大小写转换
+ * 
+ * @license Apache-2.0
+ */
+/**
+ * @file timing.ts
+ * @description 时间控制工具函数集
+ * @module @brix/utils/timing
+ * @version 3.0.0
+ * 
+ * 【模块说明】
+ * 提供各种时间控制相关的工具函数，包括防抖、节流、延迟、超时等。
+ * 这些函数是前端开发中最常用的性能优化工具。
+ * 
+ * 【使用场景】
+ * - 防抖：搜索输入、表单校验、窗口调整
+ * - 节流：滚动事件、按钮点击、拖拽操作
+ * - 延迟：动画间隔、轮询等待、用户反馈
+ * - 超时：网络请求、长时任务控制
+ * 
+ * @license Apache-2.0
+ */
+/**
+ * @file validators.ts
+ * @description 验证工具函数集
+ * @module @brix/utils/validators
+ * @version 3.0.0
+ * 
+ * 【模块说明】
+ * 提供各种数据验证工具函数，包括基础格式验证、中国特有证件验证、密码强度检查等。
+ * 验证函数均返回布尔值，不抛出异常，便于条件判断使用。
+ * 
+ * 【使用场景】
+ * - 表单验证：邮箱、手机号、密码等
+ * - 证件验证：身份证、统一社会信用代码、银行卡等
+ * - 数据校验：URL、IP、JSON 格式等
+ * - 类型检查：空值、数字、范围等
+ * 
+ * @license Apache-2.0
+ */
+
+export { assert, assertNotNull, camelCase, cancelableDelay, capitalize, checkPasswordStrength, debounce, deepClone, deepMerge, delay, delayWith, formatCurrency, formatDate, formatDuration, formatFileSize, formatNumber, formatPercent, formatRelativeTime, isArray, isBoolean, isEmpty, isFunction, isInRange, isInteger, isNotNullOrUndefined, isNullOrUndefined, isNumber, isNumeric, isObject, isPositive, isPromise, isString, isValidBankCard, isValidEmail, isValidIPv4, isValidIdCard, isValidJSON, isValidPhone, isValidUnifiedCreditCode, isValidUrl, kebabCase, nextTick, parseFileSize, requestIdleCallback, throttle, truncate, withTimeout };
+//# sourceMappingURL=chunk-OGZE7TFO.js.map
+//# sourceMappingURL=chunk-OGZE7TFO.js.map