@vef-framework/shared 2.0.4 → 2.0.6

package/dist/es/utils/chrono.js

@@ -1,31 +1,20 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import dayjs from 'dayjs';
-import locale from 'dayjs/locale/zh-cn';
-import customParseFormat from 'dayjs/plugin/customParseFormat';
-import duration from 'dayjs/plugin/duration';
-import localizedFormat from 'dayjs/plugin/localizedFormat';
-import relativeTime from 'dayjs/plugin/relativeTime';
-
-dayjs.locale(locale);
-dayjs.extend(localizedFormat);
-dayjs.extend(customParseFormat);
-dayjs.extend(duration);
-dayjs.extend(relativeTime);
-const DEFAULT_DATE_FORMAT = "YYYY-MM-DD";
-const DEFAULT_TIME_FORMAT = "HH:mm:ss";
-const DEFAULT_DATETIME_FORMAT = "YYYY-MM-DD HH:mm:ss";
-const LOCALIZED_DATETIME_FORMAT = "LLLL";
-const LOCALIZED_DATE_FORMAT = "LLdddd";
-const YEAR_FORMATS = ["YYYY"];
-const QUARTER_FORMATS = ["YYYY-Q季度"];
-const MONTH_FORMATS = [
+import t from "dayjs";
+import i from "dayjs/locale/zh-cn";
+import a from "dayjs/plugin/customParseFormat";
+import u from "dayjs/plugin/duration";
+import c from "dayjs/plugin/localizedFormat";
+import f from "dayjs/plugin/relativeTime";
+t.locale(i);
+t.extend(c);
+t.extend(a);
+t.extend(u);
+t.extend(f);
+const T = "YYYY-MM-DD", H = "HH:mm:ss", m = "YYYY-MM-DD HH:mm:ss", A = "LLLL", E = "LLdddd", F = ["YYYY"], d = ["YYYY-Q季度"], _ = [
   "YYYY-MM",
   "YYYY/MM",
   "YYYY.MM",
   "YYYYMM"
-];
-const WEEK_FORMATS = ["YYYY-wo"];
-const DATE_FORMATS = [
+], O = ["YYYY-wo"], M = [
   "YYYY-MM-DD",
   "YYYY/MM/DD",
   "YYYY.MM.DD",
@@ -33,11 +22,7 @@ const DATE_FORMATS = [
   "YY/MM/DD",
   "YY.MM.DD",
   "YYMMDD"
-];
-const TIME_FORMATS = ["HH:mm:ss", "HH.mm.ss", "HHmmss"];
-const HOUR_FORMATS = ["HH"];
-const MINUTE_FORMATS = ["HH:mm", "HH.mm", "HHmm"];
-const DATETIME_FORMATS = [
+], R = ["HH:mm:ss", "HH.mm.ss", "HHmmss"], l = ["HH"], L = ["HH:mm", "HH.mm", "HHmm"], D = [
   "YYYY-MM-DD HH:mm:ss",
   "YYYY/MM/DD HH:mm:ss",
   "YYYY.MM.DD HH.mm.ss",
@@ -47,75 +32,73 @@ const DATETIME_FORMATS = [
   "YY.MM.DD HH.mm.ss",
   "YYMMDDHHmmss"
 ];
-function formatDuration(seconds, unit = "seconds") {
-  const duration2 = dayjs.duration(seconds, unit);
-  const days = Math.floor(duration2.asDays());
-  const hours = duration2.hours();
-  const minutes = duration2.minutes();
-  if (days > 0) {
-    return `${days}天${hours}小时${minutes}分钟`;
-  }
-  if (hours > 0) {
-    return `${hours}小时${minutes}分钟`;
-  }
-  return `${minutes}分钟`;
+function $(o, r = "seconds") {
+  const n = t.duration(o, r), Y = Math.floor(n.asDays()), s = n.hours(), e = n.minutes();
+  return Y > 0 ? `${Y}天${s}小时${e}分钟` : s > 0 ? `${s}小时${e}分钟` : `${e}分钟`;
 }
-function parseDate(date, format = DEFAULT_DATETIME_FORMAT) {
-  if (date instanceof Date) {
-    return dayjs(date);
-  }
-  return format ? dayjs(date, format) : dayjs(date);
+function h(o, r = m) {
+  return o instanceof Date ? t(o) : r ? t(o, r) : t(o);
 }
-function tryParseDate(date) {
-  for (const format of DATETIME_FORMATS) {
-    const parsed = dayjs(date, format, true);
-    if (parsed.isValid()) {
-      return parsed;
-    }
-  }
-  for (const format of DATE_FORMATS) {
-    const parsed = dayjs(date, format, true);
-    if (parsed.isValid()) {
-      return parsed;
-    }
+function x(o) {
+  for (const n of D) {
+    const Y = t(o, n, !0);
+    if (Y.isValid())
+      return Y;
   }
-  const defaultParsed = dayjs(date);
-  if (defaultParsed.isValid()) {
-    return defaultParsed;
+  for (const n of M) {
+    const Y = t(o, n, !0);
+    if (Y.isValid())
+      return Y;
   }
-  return null;
+  const r = t(o);
+  return r.isValid() ? r : null;
 }
-function formatDate(date, format = DEFAULT_DATETIME_FORMAT) {
-  return date.format(format);
+function y(o, r = m) {
+  return o.format(r);
 }
-function getNow() {
-  return dayjs();
+function P() {
+  return t();
 }
-function getNowDateString() {
-  return dayjs().format(DEFAULT_DATE_FORMAT);
+function V() {
+  return t().format(T);
 }
-function getNowTimeString() {
-  return dayjs().format(DEFAULT_TIME_FORMAT);
+function z() {
+  return t().format(H);
 }
-function getNowDateTimeString() {
-  return dayjs().format(DEFAULT_DATETIME_FORMAT);
+function C() {
+  return t().format(m);
 }
-function getLocalizedDateTime(includeTime = true) {
-  return dayjs().format(includeTime ? LOCALIZED_DATETIME_FORMAT : LOCALIZED_DATE_FORMAT);
+function Q(o = !0) {
+  return t().format(o ? A : E);
 }
-const FORMAT_MAP = {
-  year: YEAR_FORMATS,
-  quarter: QUARTER_FORMATS,
-  month: MONTH_FORMATS,
-  week: WEEK_FORMATS,
-  date: DATE_FORMATS,
-  time: TIME_FORMATS,
-  hour: HOUR_FORMATS,
-  minute: MINUTE_FORMATS,
-  datetime: DATETIME_FORMATS
+const S = {
+  year: F,
+  quarter: d,
+  month: _,
+  week: O,
+  date: M,
+  time: R,
+  hour: l,
+  minute: L,
+  datetime: D
 };
-function getTemporalFormats(mode) {
-  return FORMAT_MAP[mode];
+function Z(o) {
+  return S[o];
 }
-
-export { DEFAULT_DATETIME_FORMAT, DEFAULT_DATE_FORMAT, DEFAULT_TIME_FORMAT, LOCALIZED_DATETIME_FORMAT, LOCALIZED_DATE_FORMAT, formatDate, formatDuration, getLocalizedDateTime, getNow, getNowDateString, getNowDateTimeString, getNowTimeString, getTemporalFormats, parseDate, tryParseDate };
+export {
+  m as DEFAULT_DATETIME_FORMAT,
+  T as DEFAULT_DATE_FORMAT,
+  H as DEFAULT_TIME_FORMAT,
+  A as LOCALIZED_DATETIME_FORMAT,
+  E as LOCALIZED_DATE_FORMAT,
+  y as formatDate,
+  $ as formatDuration,
+  Q as getLocalizedDateTime,
+  P as getNow,
+  V as getNowDateString,
+  C as getNowDateTimeString,
+  z as getNowTimeString,
+  Z as getTemporalFormats,
+  h as parseDate,
+  x as tryParseDate
+};

package/dist/es/utils/equal.js

@@ -1,170 +1,120 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-function isShallowEqual(value1, value2) {
-  if (Object.is(value1, value2)) {
-    return true;
+function j(n, o) {
+  if (Object.is(n, o))
+    return !0;
+  if (typeof n != "object" || n === null || typeof o != "object" || o === null)
+    return !1;
+  if (n instanceof Map && o instanceof Map) {
+    if (n.size !== o.size)
+      return !1;
+    for (const [r, e] of n)
+      if (!o.has(r) || !Object.is(e, o.get(r)))
+        return !1;
+    return !0;
   }
-  if (typeof value1 !== "object" || value1 === null || typeof value2 !== "object" || value2 === null) {
-    return false;
+  if (n instanceof Set && o instanceof Set) {
+    if (n.size !== o.size)
+      return !1;
+    for (const r of n)
+      if (!o.has(r))
+        return !1;
+    return !0;
   }
-  if (value1 instanceof Map && value2 instanceof Map) {
-    if (value1.size !== value2.size) {
-      return false;
-    }
-    for (const [k, v] of value1) {
-      if (!value2.has(k) || !Object.is(v, value2.get(k))) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (value1 instanceof Set && value2 instanceof Set) {
-    if (value1.size !== value2.size) {
-      return false;
-    }
-    for (const v of value1) {
-      if (!value2.has(v)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  const isArray1 = Array.isArray(value1);
-  const isArray2 = Array.isArray(value2);
-  if (isArray1 !== isArray2) {
-    return false;
-  }
-  if (value1.constructor !== value2.constructor) {
-    return false;
-  }
-  const keysA = Object.keys(value1);
-  if (keysA.length !== Object.keys(value2).length) {
-    return false;
-  }
-  for (const element of keysA) {
-    if (!Object.hasOwn(value2, element) || !Object.is(value1[element], value2[element])) {
-      return false;
-    }
-  }
-  return true;
+  const O = Array.isArray(n), h = Array.isArray(o);
+  if (O !== h || n.constructor !== o.constructor)
+    return !1;
+  const l = Object.keys(n);
+  if (l.length !== Object.keys(o).length)
+    return !1;
+  for (const r of l)
+    if (!Object.hasOwn(o, r) || !Object.is(n[r], o[r]))
+      return !1;
+  return !0;
 }
-function isDeepEqual(value1, value2) {
-  const { valueOf, toString } = Object.prototype;
-  const visited = /* @__PURE__ */ new WeakMap();
-  const compareValues = (currentFirst, currentSecond) => {
-    if (currentFirst === currentSecond) {
-      return true;
-    }
-    if (typeof currentFirst !== "object" || typeof currentSecond !== "object" || !currentFirst || !currentSecond) {
-      return currentFirst !== currentFirst && currentSecond !== currentSecond;
-    }
-    if (Object.getPrototypeOf(currentFirst) !== Object.getPrototypeOf(currentSecond)) {
-      return false;
-    }
-    const { constructor } = currentFirst;
-    if (constructor === Date) {
-      return currentFirst.getTime() === currentSecond.getTime();
-    }
-    if (constructor === RegExp) {
-      const firstRegex = currentFirst;
-      const secondRegex = currentSecond;
-      return firstRegex.source === secondRegex.source && firstRegex.flags === secondRegex.flags;
-    }
-    if (constructor === Set) {
-      const firstSet = currentFirst;
-      const secondSet = currentSecond;
-      if (firstSet.size !== secondSet.size) {
-        return false;
-      }
-      for (const value of firstSet) {
-        let found = false;
-        for (const secondValue of secondSet) {
-          if (compareValues(value, secondValue)) {
-            found = true;
+function A(n, o) {
+  const { valueOf: O, toString: h } = Object.prototype, l = /* @__PURE__ */ new WeakMap(), r = (e, f) => {
+    if (e === f)
+      return !0;
+    if (typeof e != "object" || typeof f != "object" || !e || !f)
+      return e !== e && f !== f;
+    if (Object.getPrototypeOf(e) !== Object.getPrototypeOf(f))
+      return !1;
+    const { constructor: a } = e;
+    if (a === Date)
+      return e.getTime() === f.getTime();
+    if (a === RegExp) {
+      const t = e, s = f;
+      return t.source === s.source && t.flags === s.flags;
+    }
+    if (a === Set) {
+      const t = e, s = f;
+      if (t.size !== s.size)
+        return !1;
+      for (const i of t) {
+        let y = !1;
+        for (const c of s)
+          if (r(i, c)) {
+            y = !0;
             break;
           }
-        }
-        if (!found) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (constructor === ArrayBuffer) {
-      const firstView = new DataView(currentFirst);
-      const secondView = new DataView(currentSecond);
-      return compareValues(firstView, secondView);
-    }
-    if (constructor === DataView || ArrayBuffer.isView(currentFirst)) {
-      let firstView;
-      let secondView;
-      if (constructor === DataView) {
-        firstView = currentFirst;
-        secondView = currentSecond;
-      } else {
-        const firstTyped = currentFirst;
-        const secondTyped = currentSecond;
-        firstView = new DataView(firstTyped.buffer, firstTyped.byteOffset, firstTyped.byteLength);
-        secondView = new DataView(secondTyped.buffer, secondTyped.byteOffset, secondTyped.byteLength);
-      }
-      if (firstView.byteLength !== secondView.byteLength) {
-        return false;
-      }
-      for (let index = firstView.byteLength; index-- !== 0; ) {
-        if (firstView.getUint8(index) !== secondView.getUint8(index)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    if (visited.has(currentFirst) && visited.get(currentFirst) === currentSecond) {
-      return true;
-    }
-    visited.set(currentFirst, currentSecond);
-    if (constructor === Array) {
-      const firstArray = currentFirst;
-      const secondArray = currentSecond;
-      if (firstArray.length !== secondArray.length) {
-        return false;
+        if (!y)
+          return !1;
       }
-      for (let index = firstArray.length; index-- !== 0; ) {
-        if (!compareValues(firstArray[index], secondArray[index])) {
-          return false;
-        }
+      return !0;
+    }
+    if (a === ArrayBuffer) {
+      const t = new DataView(e), s = new DataView(f);
+      return r(t, s);
+    }
+    if (a === DataView || ArrayBuffer.isView(e)) {
+      let t, s;
+      if (a === DataView)
+        t = e, s = f;
+      else {
+        const i = e, y = f;
+        t = new DataView(i.buffer, i.byteOffset, i.byteLength), s = new DataView(y.buffer, y.byteOffset, y.byteLength);
       }
-      return true;
-    }
-    if (constructor === Map) {
-      const firstMap = currentFirst;
-      const secondMap = currentSecond;
-      if (firstMap.size !== secondMap.size) {
-        return false;
-      }
-      for (const [key, value] of firstMap) {
-        if (!secondMap.has(key) || !compareValues(value, secondMap.get(key))) {
-          return false;
-        }
-      }
-      return true;
-    }
-    const firstAsAny = currentFirst;
-    const secondAsAny = currentSecond;
-    if (firstAsAny.valueOf !== valueOf && typeof firstAsAny.valueOf === "function" && typeof secondAsAny.valueOf === "function") {
-      return firstAsAny.valueOf() === secondAsAny.valueOf();
-    }
-    if (firstAsAny.toString !== toString && typeof firstAsAny.toString === "function" && typeof secondAsAny.toString === "function") {
-      return firstAsAny.toString() === secondAsAny.toString();
-    }
-    const firstKeys = Object.keys(currentFirst);
-    let currentKey;
-    for (let index = firstKeys.length; index-- !== 0; ) {
-      currentKey = firstKeys[index];
-      if (!Object.hasOwn(currentSecond, currentKey) || !compareValues(firstAsAny[currentKey], secondAsAny[currentKey])) {
-        return false;
-      }
-    }
-    return Object.keys(currentSecond).length === firstKeys.length;
+      if (t.byteLength !== s.byteLength)
+        return !1;
+      for (let i = t.byteLength; i-- !== 0; )
+        if (t.getUint8(i) !== s.getUint8(i))
+          return !1;
+      return !0;
+    }
+    if (l.has(e) && l.get(e) === f)
+      return !0;
+    if (l.set(e, f), a === Array) {
+      const t = e, s = f;
+      if (t.length !== s.length)
+        return !1;
+      for (let i = t.length; i-- !== 0; )
+        if (!r(t[i], s[i]))
+          return !1;
+      return !0;
+    }
+    if (a === Map) {
+      const t = e, s = f;
+      if (t.size !== s.size)
+        return !1;
+      for (const [i, y] of t)
+        if (!s.has(i) || !r(y, s.get(i)))
+          return !1;
+      return !0;
+    }
+    const g = e, b = f;
+    if (g.valueOf !== O && typeof g.valueOf == "function" && typeof b.valueOf == "function")
+      return g.valueOf() === b.valueOf();
+    if (g.toString !== h && typeof g.toString == "function" && typeof b.toString == "function")
+      return g.toString() === b.toString();
+    const w = Object.keys(e);
+    let p;
+    for (let t = w.length; t-- !== 0; )
+      if (p = w[t], !Object.hasOwn(f, p) || !r(g[p], b[p]))
+        return !1;
+    return Object.keys(f).length === w.length;
   };
-  return compareValues(value1, value2);
+  return r(n, o);
 }
-
-export { isDeepEqual, isShallowEqual };
+export {
+  A as isDeepEqual,
+  j as isShallowEqual
+};

package/dist/es/utils/error.js

@@ -1,33 +1,36 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import * as stackTrace from 'stacktrace-js';
-import { getBaseName } from './path.js';
-
-async function parseErrorStack(error, filter) {
-  return await stackTrace.fromError(error, {
-    offline: true,
-    filter
+import * as t from "stacktrace-js";
+import { getBaseName as o } from "./path.js";
+async function i(e, r) {
+  return await t.fromError(e, {
+    offline: !0,
+    filter: r
   });
 }
-function filterUserFrame(stackFrame) {
-  return !stackFrame.fileName || !stackFrame.fileName.includes("node_modules");
+function u(e) {
+  return !e.fileName || !e.fileName.includes("node_modules");
 }
-async function getSanitizedErrorStack(error) {
-  const frames = await parseErrorStack(error, filterUserFrame);
-  const cleanStack = frames.map((frame) => `    at ${frame.functionName || "anonymous"} (${frame.fileName ? getBaseName(frame.fileName, true) : "unknown"}:${frame.lineNumber}:${frame.columnNumber})`).join("\n");
-  return `${error.name}: ${error.message}
-${cleanStack}`;
+async function f(e) {
+  const a = (await i(e, u)).map((n) => `    at ${n.functionName || "anonymous"} (${n.fileName ? o(n.fileName, !0) : "unknown"}:${n.lineNumber}:${n.columnNumber})`).join(`
+`);
+  return `${e.name}: ${e.message}
+${a}`;
 }
-async function getCurrentStack(filter) {
-  return await stackTrace.get({
-    offline: true,
-    filter
+async function m(e) {
+  return await t.get({
+    offline: !0,
+    filter: e
   });
 }
-function getCurrentStackSync(filter) {
-  return stackTrace.getSync({
-    offline: true,
-    filter
+function s(e) {
+  return t.getSync({
+    offline: !0,
+    filter: e
   });
 }
-
-export { filterUserFrame, getCurrentStack, getCurrentStackSync, getSanitizedErrorStack, parseErrorStack };
+export {
+  u as filterUserFrame,
+  m as getCurrentStack,
+  s as getCurrentStackSync,
+  f as getSanitizedErrorStack,
+  i as parseErrorStack
+};

package/dist/es/utils/event.js

@@ -1,9 +1,7 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import mitt from 'mitt';
-
-class EventEmitter {
+import r from "mitt";
+class s {
   /** Private mitt instance for handling the actual event operations */
-  #bus = mitt();
+  #t = r();
   /**
    * Subscribe to an event with a listener function.
    * Returns an unsubscribe function for easy cleanup.
@@ -12,18 +10,13 @@ class EventEmitter {
    * @param eventListener - The function to call when the event is emitted
    * @returns A function that removes this specific listener when called
    */
-  on(eventType, eventListener) {
-    this.#bus.on(eventType, eventListener);
-    return () => {
-      this.#bus.off(eventType, eventListener);
+  on(t, i) {
+    return this.#t.on(t, i), () => {
+      this.#t.off(t, i);
     };
   }
-  emit(eventType, eventPayload) {
-    if (eventPayload) {
-      this.#bus.emit(eventType, eventPayload);
-    } else {
-      this.#bus.emit(eventType);
-    }
+  emit(t, i) {
+    i ? this.#t.emit(t, i) : this.#t.emit(t);
   }
   /**
    * Remove a specific listener for an event type.
@@ -32,26 +25,28 @@ class EventEmitter {
    * @param eventType - The type of event to remove listeners from
    * @param eventListener - Optional specific listener to remove
    */
-  off(eventType, eventListener) {
-    this.#bus.off(eventType, eventListener);
+  off(t, i) {
+    this.#t.off(t, i);
   }
   /**
    * Remove all event listeners from all event types.
    * Useful for cleanup when the emitter is no longer needed.
    */
   clear() {
-    this.#bus.all.clear();
+    this.#t.all.clear();
   }
   /**
    * Get all registered listeners for debugging purposes.
    * Returns a Map of event types to their listener arrays.
    */
   getAllListeners() {
-    return this.#bus.all;
+    return this.#t.all;
   }
 }
-function createEventEmitter() {
-  return new EventEmitter();
+function l() {
+  return new s();
 }
-
-export { EventEmitter, createEventEmitter };
+export {
+  s as EventEmitter,
+  l as createEventEmitter
+};

package/dist/es/utils/format.js

@@ -1,26 +1,20 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-const BYTES_UNIT = 1024;
-const BYTE_SIZES = ["B", "KB", "MB", "GB", "TB", "PB"];
-const NUMBER_UNIT = 1e3;
-const NUMBER_UNITS = ["", "K", "M", "B", "T"];
-function formatBytes(bytes, decimals = 2) {
-  if (bytes === 0) {
+const a = ["B", "KB", "MB", "GB", "TB", "PB"];
+const N = ["", "K", "M", "B", "T"];
+function M(t, r = 2) {
+  if (t === 0)
     return "0 B";
-  }
-  const dm = Math.max(decimals, 0);
-  const i = Math.floor(Math.log(bytes) / Math.log(BYTES_UNIT));
-  return `${Number.parseFloat((bytes / BYTES_UNIT ** i).toFixed(dm))} ${BYTE_SIZES[i]}`;
+  const B = Math.max(r, 0), o = Math.floor(Math.log(t) / Math.log(1024));
+  return `${Number.parseFloat((t / 1024 ** o).toFixed(B))} ${a[o]}`;
 }
-function formatNumber(num, decimals = 2) {
-  if (num === 0) {
+function n(t, r = 2) {
+  if (t === 0)
     return "0";
-  }
-  if (num < NUMBER_UNIT) {
-    return num.toString();
-  }
-  const dm = Math.max(decimals, 0);
-  const i = Math.floor(Math.log(num) / Math.log(NUMBER_UNIT));
-  return `${Number.parseFloat((num / NUMBER_UNIT ** i).toFixed(dm))} ${NUMBER_UNITS[i]}`;
+  if (t < 1e3)
+    return t.toString();
+  const B = Math.max(r, 0), o = Math.floor(Math.log(t) / Math.log(1e3));
+  return `${Number.parseFloat((t / 1e3 ** o).toFixed(B))} ${N[o]}`;
 }
-
-export { formatBytes, formatNumber };
+export {
+  M as formatBytes,
+  n as formatNumber
+};