@vef-framework/shared 2.0.4 → 2.0.6

package/dist/es/utils/task.js

@@ -1,13 +1,8 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import './lib.js';
-import { isFunction } from 'radashi';
-
-function scheduleMicrotask(task) {
-  if (isFunction(queueMicrotask)) {
-    queueMicrotask(task);
-  } else {
-    Promise.resolve().then(task);
-  }
+import "./lib.js";
+import { isFunction as o } from "radashi";
+function t(e) {
+  o(queueMicrotask) ? queueMicrotask(e) : Promise.resolve().then(e);
 }
-
-export { scheduleMicrotask };
+export {
+  t as scheduleMicrotask
+};

package/dist/es/utils/tree.js

@@ -1,252 +1,189 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import './lib.js';
-import { isArray, isFunction, isNullish } from 'radashi';
-
-function flattenTree(tree, options = {}) {
+import "./lib.js";
+import { isArray as a, isFunction as g, isNullish as I } from "radashi";
+function y(s, l = {}) {
   const {
-    childrenKey = "children",
-    includeParent = false,
-    includeLevel = false,
-    transform,
-    filter
-  } = options;
-  const result = [];
-  function traverse(nodes, parent, level = 0) {
-    if (!isArray(nodes)) {
-      return;
-    }
-    for (const node of nodes) {
-      const context = { parent, level };
-      if (isFunction(filter) && !filter(node, context)) {
-        const children2 = node[childrenKey];
-        if (isArray(children2)) {
-          traverse(children2, node, level + 1);
-        }
-        continue;
-      }
-      let newNode = node;
-      if (isFunction(transform)) {
-        newNode = transform(node, context);
-      } else if (includeParent || includeLevel) {
-        const flattenedNode = { data: node };
-        if (includeParent) {
-          flattenedNode.parent = parent;
+    childrenKey: d = "children",
+    includeParent: h = !1,
+    includeLevel: o = !1,
+    transform: c,
+    filter: n
+  } = l, e = [];
+  function r(t, u, i = 0) {
+    if (a(t))
+      for (const f of t) {
+        const p = { parent: u, level: i };
+        if (g(n) && !n(f, p)) {
+          const N = f[d];
+          a(N) && r(N, f, i + 1);
+          continue;
         }
-        if (includeLevel) {
-          flattenedNode.level = level;
+        let m = f;
+        if (g(c))
+          m = c(f, p);
+        else if (h || o) {
+          const N = { data: f };
+          h && (N.parent = u), o && (N.level = i), m = N;
         }
-        newNode = flattenedNode;
+        e.push(m);
+        const x = f[d];
+        a(x) && r(x, f, i + 1);
       }
-      result.push(newNode);
-      const children = node[childrenKey];
-      if (isArray(children)) {
-        traverse(children, node, level + 1);
-      }
-    }
   }
-  traverse(tree);
-  return result;
+  return r(s), e;
 }
-function getNodeValue(node, accessor) {
-  return isFunction(accessor) ? accessor(node) : node[accessor];
+function T(s, l) {
+  return g(l) ? l(s) : s[l];
 }
-function buildTree(nodes, options = {}) {
+function A(s, l = {}) {
   const {
-    idKey = "id",
-    parentIdKey = "parentId",
-    childrenKey = "children",
-    rootValue,
-    transform
-  } = options;
-  if (!isArray(nodes) || nodes.length === 0) {
+    idKey: d = "id",
+    parentIdKey: h = "parentId",
+    childrenKey: o = "children",
+    rootValue: c,
+    transform: n
+  } = l;
+  if (!a(s) || s.length === 0)
     return [];
+  const e = /* @__PURE__ */ new Map(), r = [];
+  for (const t of s) {
+    const u = T(t, d);
+    e.set(u, { ...t });
   }
-  const nodeMap = /* @__PURE__ */ new Map();
-  const rootNodes = [];
-  for (const node of nodes) {
-    const nodeId = getNodeValue(node, idKey);
-    nodeMap.set(nodeId, { ...node });
-  }
-  for (const originalNode of nodes) {
-    const nodeId = getNodeValue(originalNode, idKey);
-    const parentId = getNodeValue(originalNode, parentIdKey);
-    const node = nodeMap.get(nodeId);
-    const isRoot = isFunction(rootValue) ? rootValue(originalNode) : parentId === rootValue || isNullish(parentId);
-    if (isRoot) {
-      rootNodes.push(node);
-    } else {
-      const parentNode = nodeMap.get(parentId);
-      if (parentNode) {
-        if (!isArray(parentNode[childrenKey])) {
-          parentNode[childrenKey] = [];
-        }
-        parentNode[childrenKey].push(node);
-      } else {
-        rootNodes.push(node);
-      }
+  for (const t of s) {
+    const u = T(t, d), i = T(t, h), f = e.get(u);
+    if (g(c) ? c(t) : i === c || I(i))
+      r.push(f);
+    else {
+      const m = e.get(i);
+      m ? (a(m[o]) || (m[o] = []), m[o].push(f)) : r.push(f);
     }
   }
-  if (isFunction(transform)) {
-    let transformNode = function(node, level = 0) {
-      const children = node[childrenKey];
-      const transformedNode = transformFn(node, { children, level });
-      if (isArray(children)) {
-        transformedNode[childrenKey] = children.map((child) => transformNode(child, level + 1));
-      }
-      return transformedNode;
+  if (g(n)) {
+    let t = function(i, f = 0) {
+      const p = i[o], m = u(i, { children: p, level: f });
+      return a(p) && (m[o] = p.map((x) => t(x, f + 1))), m;
     };
-    const transformFn = transform;
-    return rootNodes.map((node) => transformNode(node));
+    const u = n;
+    return r.map((i) => t(i));
   }
-  return rootNodes;
+  return r;
 }
-function findNodeInTree(tree, predicate, childrenKey = "children") {
-  function search(nodes, parent, level = 0) {
-    if (isArray(nodes)) {
-      for (const node of nodes) {
-        if (predicate(node, { parent, level })) {
-          return node;
-        }
-        const children = node[childrenKey];
-        if (isArray(children)) {
-          const found = search(children, node, level + 1);
-          if (found) {
-            return found;
-          }
+function C(s, l, d = "children") {
+  function h(o, c, n = 0) {
+    if (a(o))
+      for (const e of o) {
+        if (l(e, { parent: c, level: n }))
+          return e;
+        const r = e[d];
+        if (a(r)) {
+          const t = h(r, e, n + 1);
+          if (t)
+            return t;
         }
       }
-    }
   }
-  return search(tree);
+  return h(s);
 }
-function traverseTree(tree, callback, options = {}) {
-  const { strategy = "dfs", childrenKey = "children" } = options;
-  if (!isArray(tree)) {
-    return;
-  }
-  if (strategy === "bfs") {
-    const queue = tree.map((node, index) => {
-      return {
-        node,
+function F(s, l, d = {}) {
+  const { strategy: h = "dfs", childrenKey: o = "children" } = d;
+  if (a(s))
+    if (h === "bfs") {
+      const c = s.map((n, e) => ({
+        node: n,
         level: 0,
-        index
-      };
-    });
-    while (queue.length > 0) {
-      const item = queue.shift();
-      callback(item.node, {
-        parent: item.parent,
-        level: item.level,
-        index: item.index
-      });
-      const children = item.node[childrenKey];
-      if (isArray(children)) {
-        for (const [index, child] of children.entries()) {
-          queue.push({
-            node: child,
-            parent: item.node,
-            level: item.level + 1,
-            index
-          });
-        }
-      }
-    }
-  } else {
-    let traverse = function(nodes, parent, level = 0) {
-      if (!isArray(nodes)) {
-        return;
-      }
-      for (const [index, node] of nodes.entries()) {
-        callback(node, {
-          parent,
-          level,
-          index
+        index: e
+      }));
+      for (; c.length > 0; ) {
+        const n = c.shift();
+        l(n.node, {
+          parent: n.parent,
+          level: n.level,
+          index: n.index
         });
-        const children = node[childrenKey];
-        if (isArray(children)) {
-          traverse(children, node, level + 1);
-        }
+        const e = n.node[o];
+        if (a(e))
+          for (const [r, t] of e.entries())
+            c.push({
+              node: t,
+              parent: n.node,
+              level: n.level + 1,
+              index: r
+            });
       }
-    };
-    traverse(tree);
-  }
-}
-function mapTree(tree, callback, childrenKey = "children") {
-  function transform(nodes, parent, level = 0) {
-    if (!isArray(nodes)) {
-      return [];
+    } else {
+      let c = function(n, e, r = 0) {
+        if (a(n))
+          for (const [t, u] of n.entries()) {
+            l(u, {
+              parent: e,
+              level: r,
+              index: t
+            });
+            const i = u[o];
+            a(i) && c(i, u, r + 1);
+          }
+      };
+      c(s);
     }
-    return nodes.map((node, index) => {
-      const mappedNode = callback(node, {
-        parent,
-        level,
-        index
-      });
-      const children = node[childrenKey];
-      if (isArray(children)) {
-        mappedNode[childrenKey] = transform(children, node, level + 1);
-      }
-      return mappedNode;
-    });
+}
+function R(s, l, d = "children") {
+  function h(o, c, n = 0) {
+    return a(o) ? o.map((e, r) => {
+      const t = l(e, {
+        parent: c,
+        level: n,
+        index: r
+      }), u = e[d];
+      return a(u) && (t[d] = h(u, e, n + 1)), t;
+    }) : [];
   }
-  return transform(tree);
+  return h(s);
 }
-function filterTree(tree, predicate, childrenKey = "children") {
-  function filter(nodes, parent, level = 0) {
-    if (!isArray(nodes)) {
-      return [];
-    }
-    return nodes.reduce((acc, node, index) => {
-      if (!predicate(node, {
-        parent,
-        level,
-        index
-      })) {
-        return acc;
+function V(s, l, d = "children") {
+  function h(o, c, n = 0) {
+    return a(o) ? o.reduce((e, r, t) => {
+      if (!l(r, {
+        parent: c,
+        level: n,
+        index: t
+      }))
+        return e;
+      const u = r[d], i = { ...r };
+      if (u && a(u)) {
+        const f = h(u, r, n + 1);
+        f.length > 0 ? i[d] = f : delete i[d];
       }
-      const children = node[childrenKey];
-      const newNode = { ...node };
-      if (children && isArray(children)) {
-        const filteredChildren = filter(children, node, level + 1);
-        if (filteredChildren.length > 0) {
-          newNode[childrenKey] = filteredChildren;
-        } else {
-          delete newNode[childrenKey];
-        }
-      }
-      acc.push(newNode);
-      return acc;
-    }, []);
+      return e.push(i), e;
+    }, []) : [];
   }
-  return filter(tree);
+  return h(s);
 }
-function filterTreeWithAncestors(tree, predicate, childrenKey = "children") {
-  function filter(nodes, parent, level = 0) {
-    if (!isArray(nodes)) {
+function b(s, l, d = "children") {
+  function h(o, c, n = 0) {
+    if (!a(o))
       return [];
-    }
-    const result = [];
-    for (const [index, node] of nodes.entries()) {
-      const nodeMatches = predicate(node, {
-        parent,
-        level,
-        index
-      });
-      const children = node[childrenKey];
-      const filteredChildren = isArray(children) ? filter(children, node, level + 1) : [];
-      if (nodeMatches || filteredChildren.length > 0) {
-        const newNode = { ...node };
-        if (filteredChildren.length > 0) {
-          newNode[childrenKey] = filteredChildren;
-        } else {
-          delete newNode[childrenKey];
-        }
-        result.push(newNode);
+    const e = [];
+    for (const [r, t] of o.entries()) {
+      const u = l(t, {
+        parent: c,
+        level: n,
+        index: r
+      }), i = t[d], f = a(i) ? h(i, t, n + 1) : [];
+      if (u || f.length > 0) {
+        const p = { ...t };
+        f.length > 0 ? p[d] = f : delete p[d], e.push(p);
       }
     }
-    return result;
+    return e;
   }
-  return filter(tree);
+  return h(s);
 }
-
-export { buildTree, filterTree, filterTreeWithAncestors, findNodeInTree, flattenTree, mapTree, traverseTree };
+export {
+  A as buildTree,
+  V as filterTree,
+  b as filterTreeWithAncestors,
+  C as findNodeInTree,
+  y as flattenTree,
+  R as mapTree,
+  F as traverseTree
+};

package/dist/es/utils/zod.js

@@ -1,6 +1,7 @@
-/*! @vef-framework/shared v2.0.2 made with ❤️ by Venus | 2025-11-25T15:03:13.127Z */
-import { z } from 'zod';
-export { z } from 'zod';
-import { zhCN } from 'zod/locales';
-
-z.config(zhCN());
+import { z as o } from "zod";
+import { z as t } from "zod";
+import { zhCN as r } from "zod/locales";
+o.config(r());
+export {
+  t as z
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vef-framework/shared",
   "type": "module",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "private": false,
   "description": "Shared utilities for VEF framework",
   "author": {