@vef-framework/shared 1.0.134 → 2.0.0

package/dist/es/utils/equal.js

@@ -0,0 +1,170 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+function isShallowEqual(value1, value2) {
+  if (Object.is(value1, value2)) {
+    return true;
+  }
+  if (typeof value1 !== "object" || value1 === null || typeof value2 !== "object" || value2 === null) {
+    return false;
+  }
+  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;
+}
+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;
+            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;
+      }
+      for (let index = firstArray.length; index-- !== 0; ) {
+        if (!compareValues(firstArray[index], secondArray[index])) {
+          return false;
+        }
+      }
+      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;
+  };
+  return compareValues(value1, value2);
+}
+
+export { isDeepEqual, isShallowEqual };

package/dist/es/utils/error.js

@@ -0,0 +1,33 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+import * as stackTrace from 'stacktrace-js';
+import { getBaseName } from './path.js';
+
+async function parseErrorStack(error, filter) {
+  return await stackTrace.fromError(error, {
+    offline: true,
+    filter
+  });
+}
+function filterUserFrame(stackFrame) {
+  return !stackFrame.fileName || !stackFrame.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 getCurrentStack(filter) {
+  return await stackTrace.get({
+    offline: true,
+    filter
+  });
+}
+function getCurrentStackSync(filter) {
+  return stackTrace.getSync({
+    offline: true,
+    filter
+  });
+}
+
+export { filterUserFrame, getCurrentStack, getCurrentStackSync, getSanitizedErrorStack, parseErrorStack };

package/dist/es/utils/event.js

@@ -0,0 +1,57 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+import mitt from 'mitt';
+
+class EventEmitter {
+  /** Private mitt instance for handling the actual event operations */
+  #bus = mitt();
+  /**
+   * Subscribe to an event with a listener function.
+   * Returns an unsubscribe function for easy cleanup.
+   *
+   * @param eventType - The type of event to listen for
+   * @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);
+    };
+  }
+  emit(eventType, eventPayload) {
+    if (eventPayload) {
+      this.#bus.emit(eventType, eventPayload);
+    } else {
+      this.#bus.emit(eventType);
+    }
+  }
+  /**
+   * Remove a specific listener for an event type.
+   * If no listener is provided, removes all listeners for that event type.
+   *
+   * @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);
+  }
+  /**
+   * Remove all event listeners from all event types.
+   * Useful for cleanup when the emitter is no longer needed.
+   */
+  clear() {
+    this.#bus.all.clear();
+  }
+  /**
+   * Get all registered listeners for debugging purposes.
+   * Returns a Map of event types to their listener arrays.
+   */
+  getAllListeners() {
+    return this.#bus.all;
+  }
+}
+function createEventEmitter() {
+  return new EventEmitter();
+}
+
+export { EventEmitter, createEventEmitter };

package/dist/es/utils/format.js

@@ -0,0 +1,26 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+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) {
+    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]}`;
+}
+function formatNumber(num, decimals = 2) {
+  if (num === 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]}`;
+}
+
+export { formatBytes, formatNumber };

package/dist/es/utils/function.js

@@ -0,0 +1,41 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+function isAsyncFunction(fn) {
+  return fn.constructor.name === "AsyncFunction" || Object.prototype.toString.call(fn) === "[object AsyncFunction]" || fn.toString().startsWith("async ");
+}
+async function invokeAwaitableFn(fn, args, options) {
+  const {
+    onInvoke,
+    onSuccess,
+    onError,
+    onFinally
+  } = options;
+  const returned = fn(...args);
+  if (returned instanceof Promise) {
+    let context;
+    try {
+      context = onInvoke?.();
+      const result = await returned;
+      onSuccess?.(result, context);
+      return result;
+    } catch (error) {
+      onError?.(error, context);
+      throw error;
+    } finally {
+      onFinally?.(context);
+    }
+  } else {
+    return returned;
+  }
+}
+function identity(value) {
+  return value;
+}
+function createThrowNotImplementedFn(feature) {
+  return () => throwNotImplemented(feature);
+}
+function throwNotImplemented(feature) {
+  const label = feature ? `${feature} not implemented` : "Not implemented";
+  throw new Error(label);
+}
+
+export { createThrowNotImplementedFn, identity, invokeAwaitableFn, isAsyncFunction, throwNotImplemented };

package/dist/es/utils/id.js

@@ -0,0 +1,34 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+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;
+}
+let createId = init({
+  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);
+  });
+}
+function generateId() {
+  return createId();
+}
+
+export { generateId };

package/dist/es/utils/index.js

@@ -0,0 +1,18 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+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';

package/dist/es/utils/key.js

@@ -0,0 +1,30 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+import './lib.js';
+import { isPlainObject } from 'radashi';
+
+function hashKey(key) {
+  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;
+      }
+      return value;
+    }
+  );
+}
+
+export { hashKey };

package/dist/es/utils/lib.js

@@ -0,0 +1,10 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+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 };

package/dist/es/utils/object.js

@@ -0,0 +1,16 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+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;
+    }
+  }
+  return target;
+}
+
+export { mergeWith };

package/dist/es/utils/path.js

@@ -0,0 +1,49 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+import path 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 };

package/dist/es/utils/pinyin.js

@@ -0,0 +1,47 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+import ModernChineseDict from '@pinyin-pro/data/modern';
+import { addDict, pinyin } from 'pinyin-pro';
+import './lib.js';
+import { isString } from 'radashi';
+
+addDict(ModernChineseDict);
+const baseOptions = {
+  type: "array",
+  toneType: "none",
+  multiple: false,
+  nonZh: "consecutive",
+  surname: "head"
+};
+function getPinyin(text) {
+  return pinyin(
+    text,
+    {
+      ...baseOptions,
+      pattern: "pinyin"
+    }
+  );
+}
+function getPinyinInitials(text) {
+  return pinyin(
+    text,
+    {
+      ...baseOptions,
+      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("");
+    }
+  }
+  return result;
+}
+
+export { getPinyin, getPinyinInitials, withPinyin };

package/dist/es/utils/security.js

@@ -0,0 +1,39 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+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;
+}
+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;
+}
+
+export { decryptUsingRSA, encryptUsingRSA };

package/dist/es/utils/string.js

@@ -0,0 +1,9 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+import './lib.js';
+import { snake } from 'radashi';
+
+function constantCase(value) {
+  return snake(value).toUpperCase();
+}
+
+export { constantCase };

package/dist/es/utils/task.js

@@ -0,0 +1,13 @@
+/*! @vef-framework/shared v2.0.0 made with ❤️ by Venus | 2025-11-25T10:06:28.916Z */
+import './lib.js';
+import { isFunction } from 'radashi';
+
+function scheduleMicrotask(task) {
+  if (isFunction(queueMicrotask)) {
+    queueMicrotask(task);
+  } else {
+    Promise.resolve().then(task);
+  }
+}
+
+export { scheduleMicrotask };