@vef-framework/shared 2.0.3 → 2.0.5

package/dist/es/utils/function.js

@@ -1,41 +1,41 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-function isAsyncFunction(fn) {
-  return fn.constructor.name === "AsyncFunction" || Object.prototype.toString.call(fn) === "[object AsyncFunction]" || fn.toString().startsWith("async ");
+function m(t) {
+  return t.constructor.name === "AsyncFunction" || Object.prototype.toString.call(t) === "[object AsyncFunction]" || t.toString().startsWith("async ");
 }
-async function invokeAwaitableFn(fn, args, options) {
+async function y(t, e, c) {
   const {
-    onInvoke,
-    onSuccess,
-    onError,
-    onFinally
-  } = options;
-  const returned = fn(...args);
-  if (returned instanceof Promise) {
-    let context;
+    onInvoke: i,
+    onSuccess: s,
+    onError: l,
+    onFinally: u
+  } = c, r = t(...e);
+  if (r instanceof Promise) {
+    let o;
     try {
-      context = onInvoke?.();
-      const result = await returned;
-      onSuccess?.(result, context);
-      return result;
-    } catch (error) {
-      onError?.(error, context);
-      throw error;
+      o = i?.();
+      const n = await r;
+      return s?.(n, o), n;
+    } catch (n) {
+      throw l?.(n, o), n;
     } finally {
-      onFinally?.(context);
+      u?.(o);
     }
-  } else {
-    return returned;
-  }
+  } else
+    return r;
 }
-function identity(value) {
-  return value;
+function p(t) {
+  return t;
 }
-function createThrowNotImplementedFn(feature) {
-  return () => throwNotImplemented(feature);
+function w(t) {
+  return () => a(t);
 }
-function throwNotImplemented(feature) {
-  const label = feature ? `${feature} not implemented` : "Not implemented";
-  throw new Error(label);
+function a(t) {
+  const e = t ? `${t} not implemented` : "Not implemented";
+  throw new Error(e);
 }
-
-export { createThrowNotImplementedFn, identity, invokeAwaitableFn, isAsyncFunction, throwNotImplemented };
+export {
+  w as createThrowNotImplementedFn,
+  p as identity,
+  y as invokeAwaitableFn,
+  m as isAsyncFunction,
+  a as throwNotImplemented
+};

package/dist/es/utils/id.js

@@ -1,34 +1,25 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import { init } from '@paralleldrive/cuid2';
-import { isNullish } from 'radashi';
-
-function isFingerprintSupported() {
-  if (isNullish(navigator)) {
-    return false;
-  }
-  if (navigator.userAgent.includes("jsdom")) {
-    return false;
-  }
-  return true;
+import { init as r } from "@paralleldrive/cuid2";
+import { isNullish as n } from "radashi";
+function o() {
+  return !(n(navigator) || navigator.userAgent.includes("jsdom"));
 }
-let createId = init({
+let e = r({
   length: 16,
   // vef-framework default fingerprint
   fingerprint: "0cd902ccad1f26c27b8db84af2282b7b"
 });
-if (isFingerprintSupported()) {
-  import('@fingerprintjs/fingerprintjs').then(({ load }) => load()).then((fp) => fp.get()).then((result) => {
-    const fingerprint = result.visitorId;
-    createId = init({
-      length: 16,
-      fingerprint
-    });
-  }).catch((error) => {
-    console.error("Failed to initialize fingerprint:", error);
+o() && import("@fingerprintjs/fingerprintjs").then(({ load: t }) => t()).then((t) => t.get()).then((t) => {
+  const i = t.visitorId;
+  e = r({
+    length: 16,
+    fingerprint: i
   });
+}).catch((t) => {
+  console.error("Failed to initialize fingerprint:", t);
+});
+function c() {
+  return e();
 }
-function generateId() {
-  return createId();
-}
-
-export { generateId };
+export {
+  c as generateId
+};

package/dist/es/utils/index.js

@@ -1,18 +1,80 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-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 } from './chrono.js';
-export { isDeepEqual, isShallowEqual } from './equal.js';
-export { filterUserFrame, getCurrentStack, getCurrentStackSync, getSanitizedErrorStack, parseErrorStack } from './error.js';
-export { EventEmitter, createEventEmitter } from './event.js';
-export { formatBytes, formatNumber } from './format.js';
-export { createThrowNotImplementedFn, identity, invokeAwaitableFn, isAsyncFunction, throwNotImplemented } from './function.js';
-export { generateId } from './id.js';
-export { hashKey } from './key.js';
-export { alwaysFalse, alwaysTrue } from './lib.js';
-export { mergeWith } from './object.js';
-export { formatPath, getBaseName, getDirName, getExtName, getRelativePath, isAbsolutePath, joinPaths, normalizePath, parsePath, pathSeparator, resolvePath } from './path.js';
-export { getPinyin, getPinyinInitials, withPinyin } from './pinyin.js';
-export { decryptUsingRSA, encryptUsingRSA } from './security.js';
-export { constantCase } from './string.js';
-export { scheduleMicrotask } from './task.js';
-export { buildTree, filterTree, filterTreeWithAncestors, findNodeInTree, flattenTree, mapTree, traverseTree } from './tree.js';
-import './zod.js';
+import { DEFAULT_DATETIME_FORMAT as o, DEFAULT_DATE_FORMAT as a, DEFAULT_TIME_FORMAT as i, LOCALIZED_DATETIME_FORMAT as m, LOCALIZED_DATE_FORMAT as n, formatDate as s, formatDuration as p, getLocalizedDateTime as T, getNow as f, getNowDateString as l, getNowDateTimeString as g, getNowTimeString as E, getTemporalFormats as A, parseDate as D, tryParseDate as h } from "./chrono.js";
+import { isDeepEqual as c, isShallowEqual as F } from "./equal.js";
+import { filterUserFrame as S, getCurrentStack as d, getCurrentStackSync as u, getSanitizedErrorStack as w, parseErrorStack as N } from "./error.js";
+import { EventEmitter as I, createEventEmitter as _ } from "./event.js";
+import { formatBytes as L, formatNumber as R } from "./format.js";
+import { createThrowNotImplementedFn as k, identity as v, invokeAwaitableFn as U, isAsyncFunction as C, throwNotImplemented as b } from "./function.js";
+import { generateId as q } from "./id.js";
+import { hashKey as W } from "./key.js";
+import { alwaysFalse as j, alwaysTrue as K } from "./lib.js";
+import { mergeWith as H } from "./object.js";
+import { formatPath as Q, getBaseName as V, getDirName as X, getExtName as Y, getRelativePath as $, isAbsolutePath as ee, joinPaths as te, normalizePath as re, parsePath as oe, pathSeparator as ae, resolvePath as ie } from "./path.js";
+import { getPinyin as ne, getPinyinInitials as se, withPinyin as pe } from "./pinyin.js";
+import { decryptUsingRSA as fe, encryptUsingRSA as le } from "./security.js";
+import { constantCase as Ee } from "./string.js";
+import { scheduleMicrotask as De } from "./task.js";
+import { buildTree as xe, filterTree as ce, filterTreeWithAncestors as Fe, findNodeInTree as ye, flattenTree as Se, mapTree as de, traverseTree as ue } from "./tree.js";
+import "./zod.js";
+export {
+  o as DEFAULT_DATETIME_FORMAT,
+  a as DEFAULT_DATE_FORMAT,
+  i as DEFAULT_TIME_FORMAT,
+  I as EventEmitter,
+  m as LOCALIZED_DATETIME_FORMAT,
+  n as LOCALIZED_DATE_FORMAT,
+  j as alwaysFalse,
+  K as alwaysTrue,
+  xe as buildTree,
+  Ee as constantCase,
+  _ as createEventEmitter,
+  k as createThrowNotImplementedFn,
+  fe as decryptUsingRSA,
+  le as encryptUsingRSA,
+  ce as filterTree,
+  Fe as filterTreeWithAncestors,
+  S as filterUserFrame,
+  ye as findNodeInTree,
+  Se as flattenTree,
+  L as formatBytes,
+  s as formatDate,
+  p as formatDuration,
+  R as formatNumber,
+  Q as formatPath,
+  q as generateId,
+  V as getBaseName,
+  d as getCurrentStack,
+  u as getCurrentStackSync,
+  X as getDirName,
+  Y as getExtName,
+  T as getLocalizedDateTime,
+  f as getNow,
+  l as getNowDateString,
+  g as getNowDateTimeString,
+  E as getNowTimeString,
+  ne as getPinyin,
+  se as getPinyinInitials,
+  $ as getRelativePath,
+  w as getSanitizedErrorStack,
+  A as getTemporalFormats,
+  W as hashKey,
+  v as identity,
+  U as invokeAwaitableFn,
+  ee as isAbsolutePath,
+  C as isAsyncFunction,
+  c as isDeepEqual,
+  F as isShallowEqual,
+  te as joinPaths,
+  de as mapTree,
+  H as mergeWith,
+  re as normalizePath,
+  D as parseDate,
+  N as parseErrorStack,
+  oe as parsePath,
+  ae as pathSeparator,
+  ie as resolvePath,
+  De as scheduleMicrotask,
+  b as throwNotImplemented,
+  ue as traverseTree,
+  h as tryParseDate,
+  pe as withPinyin
+};

package/dist/es/utils/key.js

@@ -1,30 +1,24 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import './lib.js';
-import { isPlainObject } from 'radashi';
-
-function hashKey(key) {
+import "./lib.js";
+import { isPlainObject as c } from "radashi";
+function m(n) {
   return JSON.stringify(
-    key,
-    (_, value) => {
-      if (isPlainObject(value)) {
-        const stringKeys = Object.keys(value).toSorted();
-        const symbolKeys = Object.getOwnPropertySymbols(value);
-        const result = {};
-        for (const key2 of stringKeys) {
-          result[key2] = value[key2];
-        }
-        const symbolResult = {};
-        for (const sym of symbolKeys) {
-          symbolResult[sym.toString()] = value[sym];
-        }
-        for (const key2 of Object.keys(symbolResult).toSorted()) {
-          result[`@@${key2}`] = symbolResult[key2];
-        }
-        return result;
+    n,
+    (f, o) => {
+      if (c(o)) {
+        const e = Object.keys(o).toSorted(), y = Object.getOwnPropertySymbols(o), r = {};
+        for (const t of e)
+          r[t] = o[t];
+        const s = {};
+        for (const t of y)
+          s[t.toString()] = o[t];
+        for (const t of Object.keys(s).toSorted())
+          r[`@@${t}`] = s[t];
+        return r;
       }
-      return value;
+      return o;
     }
   );
 }
-
-export { hashKey };
+export {
+  m as hashKey
+};

package/dist/es/utils/lib.js

@@ -1,10 +1,64 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import { always } from 'radashi';
-export { always, assign, camel as camelCase, capitalize, cluster, debounce, first, get, isArray, isBigInt, isBoolean, isDate, isEmpty, isError, isFloat, isFunction, isInt, isIntString, isMap, isNullish, isNumber, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isUndefined, isWeakMap, isWeakSet, dash as kebabCase, last, max, memo as memoize, min, noop, omit, once, pascal as pascalCase, pick, set, similarity, snake as snakeCase, sum, template, throttle, toFloat, toInt, trim, unique } from 'radashi';
-export { klona as cloneDeep } from 'klona';
-export { parse as decodeQueryString, stringify as encodeQueryString } from 'qs';
-
-const alwaysTrue = always(true);
-const alwaysFalse = always(false);
-
-export { alwaysFalse, alwaysTrue };
+import { always as s } from "radashi";
+import { always as r, assign as n, camel as l, capitalize as m, cluster as c, debounce as p, first as u, get as y, isArray as g, isBigInt as f, isBoolean as b, isDate as d, isEmpty as k, isError as S, isFloat as x, isFunction as w, isInt as C, isIntString as F, isMap as I, isNullish as h, isNumber as E, isObject as P, isPlainObject as j, isPrimitive as z, isPromise as B, isRegExp as D, isSet as M, isString as N, isSymbol as O, isUndefined as Q, isWeakMap as W, isWeakSet as q, dash as v, last as A, max as R, memo as T, min as U, noop as G, omit as H, once as J, pascal as K, pick as L, set as V, similarity as X, snake as Y, sum as Z, template as _, throttle as $, toFloat as ss, toInt as es, trim as is, unique as as } from "radashi";
+import { klona as os } from "klona";
+import { parse as ns, stringify as ls } from "qs";
+const i = s(!0), a = s(!1);
+export {
+  r as always,
+  a as alwaysFalse,
+  i as alwaysTrue,
+  n as assign,
+  l as camelCase,
+  m as capitalize,
+  os as cloneDeep,
+  c as cluster,
+  p as debounce,
+  ns as decodeQueryString,
+  ls as encodeQueryString,
+  u as first,
+  y as get,
+  g as isArray,
+  f as isBigInt,
+  b as isBoolean,
+  d as isDate,
+  k as isEmpty,
+  S as isError,
+  x as isFloat,
+  w as isFunction,
+  C as isInt,
+  F as isIntString,
+  I as isMap,
+  h as isNullish,
+  E as isNumber,
+  P as isObject,
+  j as isPlainObject,
+  z as isPrimitive,
+  B as isPromise,
+  D as isRegExp,
+  M as isSet,
+  N as isString,
+  O as isSymbol,
+  Q as isUndefined,
+  W as isWeakMap,
+  q as isWeakSet,
+  v as kebabCase,
+  A as last,
+  R as max,
+  T as memoize,
+  U as min,
+  G as noop,
+  H as omit,
+  J as once,
+  K as pascalCase,
+  L as pick,
+  V as set,
+  X as similarity,
+  Y as snakeCase,
+  Z as sum,
+  _ as template,
+  $ as throttle,
+  ss as toFloat,
+  es as toInt,
+  is as trim,
+  as as unique
+};

package/dist/es/utils/object.js

@@ -1,16 +1,13 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import './lib.js';
-import { isUndefined } from 'radashi';
-
-function mergeWith(target, source, overrideExisting = false) {
-  const validEntries = Object.entries(source).filter(([_, value]) => !isUndefined(value));
-  for (const [key, value] of validEntries) {
-    const targetKey = key;
-    if (overrideExisting || isUndefined(target[targetKey])) {
-      target[targetKey] = value;
-    }
+import "./lib.js";
+import { isUndefined as o } from "radashi";
+function m(e, r, f = !1) {
+  const s = Object.entries(r).filter(([t, i]) => !o(i));
+  for (const [t, i] of s) {
+    const n = t;
+    (f || o(e[n])) && (e[n] = i);
   }
-  return target;
+  return e;
 }
-
-export { mergeWith };
+export {
+  m as mergeWith
+};

package/dist/es/utils/path.js

@@ -1,49 +1,58 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import path from 'path-browserify';
-
+import o from "path-browserify";
 const {
-  basename,
-  dirname,
-  extname,
-  isAbsolute,
-  join,
-  normalize,
-  parse,
-  relative,
-  resolve,
-  format,
-  sep: pathSeparator
-} = path;
-function getBaseName(path2, keepExt = true) {
-  const ext = keepExt ? void 0 : extname(path2);
-  return basename(path2, ext);
-}
-function getExtName(path2) {
-  return extname(path2);
-}
-function getDirName(path2) {
-  return dirname(path2);
-}
-function joinPaths(...paths) {
-  return join(...paths);
-}
-function isAbsolutePath(path2) {
-  return isAbsolute(path2);
-}
-function normalizePath(path2) {
-  return normalize(path2);
-}
-function parsePath(path2) {
-  return parse(path2);
-}
-function formatPath(pathObject) {
-  return format(pathObject);
-}
-function getRelativePath(from, to) {
-  return relative(from, to);
-}
-function resolvePath(...pathSegments) {
-  return resolve(...pathSegments);
-}
-
-export { formatPath, getBaseName, getDirName, getExtName, getRelativePath, isAbsolutePath, joinPaths, normalizePath, parsePath, pathSeparator, resolvePath };
+  basename: a,
+  dirname: u,
+  extname: n,
+  isAbsolute: i,
+  join: s,
+  normalize: f,
+  parse: c,
+  relative: m,
+  resolve: h,
+  format: l,
+  sep: P
+} = o;
+function v(t, e = !0) {
+  const r = e ? void 0 : n(t);
+  return a(t, r);
+}
+function g(t) {
+  return n(t);
+}
+function x(t) {
+  return u(t);
+}
+function b(...t) {
+  return s(...t);
+}
+function N(t) {
+  return i(t);
+}
+function d(t) {
+  return f(t);
+}
+function j(t) {
+  return c(t);
+}
+function z(t) {
+  return l(t);
+}
+function A(t, e) {
+  return m(t, e);
+}
+function B(...t) {
+  return h(...t);
+}
+export {
+  z as formatPath,
+  v as getBaseName,
+  x as getDirName,
+  g as getExtName,
+  A as getRelativePath,
+  N as isAbsolutePath,
+  b as joinPaths,
+  d as normalizePath,
+  j as parsePath,
+  P as pathSeparator,
+  B as resolvePath
+};

package/dist/es/utils/pinyin.js

@@ -1,47 +1,46 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import ModernChineseDict from '@pinyin-pro/data/modern';
-import { addDict, pinyin } from 'pinyin-pro';
-import './lib.js';
-import { isString } from 'radashi';
-
-addDict(ModernChineseDict);
-const baseOptions = {
+import a from "@pinyin-pro/data/modern";
+import { addDict as c, pinyin as o } from "pinyin-pro";
+import "./lib.js";
+import { isString as f } from "radashi";
+c(a);
+const r = {
   type: "array",
   toneType: "none",
-  multiple: false,
+  multiple: !1,
   nonZh: "consecutive",
   surname: "head"
 };
-function getPinyin(text) {
-  return pinyin(
-    text,
+function u(n) {
+  return o(
+    n,
     {
-      ...baseOptions,
+      ...r,
       pattern: "pinyin"
     }
   );
 }
-function getPinyinInitials(text) {
-  return pinyin(
-    text,
+function m(n) {
+  return o(
+    n,
     {
-      ...baseOptions,
+      ...r,
       pattern: "first"
     }
   );
 }
-function withPinyin(obj, ...keys) {
-  const result = { ...obj };
-  for (const key of keys) {
-    const value = obj[key];
-    if (isString(value)) {
-      const pinyinKey = `${key}Pinyin`;
-      const initialsKey = `${key}PinyinInitials`;
-      result[pinyinKey] = getPinyin(value).join("");
-      result[initialsKey] = getPinyinInitials(value).join("");
+function g(n, ...s) {
+  const i = { ...n };
+  for (const t of s) {
+    const e = n[t];
+    if (f(e)) {
+      const p = `${t}Pinyin`, y = `${t}PinyinInitials`;
+      i[p] = u(e).join(""), i[y] = m(e).join("");
     }
   }
-  return result;
+  return i;
 }
-
-export { getPinyin, getPinyinInitials, withPinyin };
+export {
+  u as getPinyin,
+  m as getPinyinInitials,
+  g as withPinyin
+};

package/dist/es/utils/security.js

@@ -1,39 +1,31 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import JSEncrypt from 'jsencrypt';
-import './lib.js';
-import { isNullish } from 'radashi';
-
-function encryptUsingRSA(value, publicKey) {
-  if (isNullish(value)) {
-    throw new Error(`Failed to encrypt data [${value}] using RSA`);
-  }
-  if (!publicKey || publicKey.trim() === "") {
-    throw new Error(`Failed to encrypt data [${value}] using RSA`);
-  }
-  const rsa = new JSEncrypt();
-  rsa.setPublicKey(publicKey);
-  const encrypted = rsa.encrypt(value);
-  if (!encrypted) {
-    console.error("Failed to encrypt data using RSA", value);
-    throw new Error(`Failed to encrypt data [${value}] using RSA`);
-  }
-  return encrypted;
+import i from "jsencrypt";
+import "./lib.js";
+import { isNullish as e } from "radashi";
+function a(r, t) {
+  if (e(r))
+    throw new Error(`Failed to encrypt data [${r}] using RSA`);
+  if (!t || t.trim() === "")
+    throw new Error(`Failed to encrypt data [${r}] using RSA`);
+  const n = new i();
+  n.setPublicKey(t);
+  const o = n.encrypt(r);
+  if (!o)
+    throw console.error("Failed to encrypt data using RSA", r), new Error(`Failed to encrypt data [${r}] using RSA`);
+  return o;
 }
-function decryptUsingRSA(value, privateKey) {
-  if (isNullish(value)) {
-    throw new Error(`Failed to decrypt data [${value}] using RSA`);
-  }
-  if (!privateKey || privateKey.trim() === "") {
-    throw new Error(`Failed to decrypt data [${value}] using RSA`);
-  }
-  const rsa = new JSEncrypt();
-  rsa.setPrivateKey(privateKey);
-  const decrypted = rsa.decrypt(value);
-  if (!decrypted) {
-    console.error("Failed to decrypt data using RSA", value);
-    throw new Error(`Failed to decrypt data [${value}] using RSA`);
-  }
-  return decrypted;
+function p(r, t) {
+  if (e(r))
+    throw new Error(`Failed to decrypt data [${r}] using RSA`);
+  if (!t || t.trim() === "")
+    throw new Error(`Failed to decrypt data [${r}] using RSA`);
+  const n = new i();
+  n.setPrivateKey(t);
+  const o = n.decrypt(r);
+  if (!o)
+    throw console.error("Failed to decrypt data using RSA", r), new Error(`Failed to decrypt data [${r}] using RSA`);
+  return o;
 }
-
-export { decryptUsingRSA, encryptUsingRSA };
+export {
+  p as decryptUsingRSA,
+  a as encryptUsingRSA
+};

package/dist/es/utils/string.js

@@ -1,9 +1,8 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import './lib.js';
-import { snake } from 'radashi';
-
-function constantCase(value) {
-  return snake(value).toUpperCase();
+import "./lib.js";
+import { snake as o } from "radashi";
+function n(t) {
+  return o(t).toUpperCase();
 }
-
-export { constantCase };
+export {
+  n as constantCase
+};