@unicom-cloud/utils 0.1.21 → 0.1.22

package/package.json

@@ -1 +1 @@
-{"name":"@unicom-cloud/utils","version":"0.1.21","dependencies":{},"peerDependencies":{"lodash":"^4.17.21"},"main":"./index.js","type":"module","types":"types/index.d.ts","publishConfig":{"registry":"https://registry.npmjs.org/","access":"public"}}
+{"name":"@unicom-cloud/utils","version":"0.1.22","dependencies":{},"peerDependencies":{"lodash":"^4.17.21"},"main":"./index.js","type":"module","types":"types/index.d.ts","publishConfig":{"registry":"https://registry.npmjs.org/","access":"public"}}

package/tree/search/index.js

@@ -1,80 +1,21 @@
 import "../../is/index.js";
-import A from "lodash/isArray";
-import T from "lodash/isObjectLike";
-import F from "lodash/isString";
-import x from "lodash/isFunction";
-function z(c, r, e, i) {
-  return r && c ? { shouldExit: !0, newMatch: !0 } : e && !c ? { shouldExit: !0, newMatch: !1 } : { shouldExit: !1, newMatch: i || c };
+import S from "lodash/isArray";
+import B from "lodash/isObjectLike";
+import m from "lodash/isString";
+import C from "lodash/isNumber";
+import K from "lodash/isFunction";
+import L from "lodash/isRegExp";
+function j(o, f, h, w) {
+  return f && o ? { shouldExit: !0, newMatch: !0 } : h && !o ? { shouldExit: !0, newMatch: !1 } : { shouldExit: !1, newMatch: w || o };
 }
-function O(c, r, e) {
-  const { strict: i, fuzzyMatch: l, caseSensitive: u, matchMode: S, allowEmptyString: y } = e, n = S === "OR", p = S === "AND";
-  let M = !1;
-  const t = Object.entries(r), m = {};
-  for (const [d, s] of t) {
-    const a = c[d];
-    if (s === "")
-      if (y)
-        m[d] = a === "";
-      else {
-        m[d] = !1;
-        continue;
-      }
-    let o = !1;
-    try {
-      if (s instanceof RegExp)
-        o = F(a) ? s.test(a) : !1;
-      else if (x(s))
-        o = !!s(a);
-      else if (l && F(s)) {
-        const h = String(a), D = u ? s : s.toLowerCase();
-        o = (u ? h : h.toLowerCase()).includes(D);
-      } else
-        o = i ? a === s : a == s;
-    } catch {
-      o = !1;
-    }
-    m[d] = o;
-    const g = z(o, n, p, M);
-    if (g.shouldExit)
-      return { match: g.newMatch, matches: m };
-    M = g.newMatch;
-  }
-  return { match: M, matches: m };
-}
-function K(c, r, e) {
-  const i = [];
-  for (const l of c) {
-    const { match: u, matches: S } = O(
-      l,
-      r,
-      e
-    );
-    let y = u;
-    if (e.customMatcher)
-      try {
-        const t = e.customMatcher(l, S);
-        typeof t == "boolean" ? y = t : t && typeof t.match == "boolean" && (y = t.match);
-      } catch (t) {
-        console.warn("Custom matcher function error:", t);
-      }
-    const n = { ...l }, p = l[e.childrenKey];
-    if (A(p)) {
-      const t = K(
-        p,
-        r,
-        e
-      );
-      t.length > 0 ? n[e.childrenKey] = t : delete n[e.childrenKey];
-    }
-    const M = n[e.childrenKey] && n[e.childrenKey].length > 0;
-    (y || M) && i.push(n);
-  }
-  return i;
+function k(o, f) {
+  const h = { ...o };
+  return delete h[f], h;
 }
-function V(c, r, e = {}) {
-  if (!A(c)) throw new TypeError("参数treeData必须是一个数组");
-  if (!T(r)) throw new TypeError("参数searchCondition必须是一个对象");
-  const i = {
+function Q(o, f, h = {}) {
+  if (!S(o)) throw new TypeError("参数 treeData 必须是一个数组");
+  if (!B(f)) throw new TypeError("参数 searchCondition 必须是一个对象");
+  const w = {
     strategy: "BFS",
     childrenKey: "children",
     strict: !1,
@@ -83,68 +24,96 @@ function V(c, r, e = {}) {
     caseSensitive: !1,
     allowEmptyString: !1,
     matchMode: "AND",
-    preserveTreeStructure: !1,
-    customMatcher: void 0,
-    ...e
+    returnTree: !1,
+    returnTreeMaxDepth: 0,
+    // 只在 returnTree 为 true 时才生效
+    ...h
     // 用户配置覆盖默认值
   }, {
-    strategy: l,
-    childrenKey: u,
-    strict: S,
-    fuzzyMatch: y,
-    returnAllMatches: n,
-    caseSensitive: p,
-    allowEmptyString: M,
-    matchMode: t,
-    preserveTreeStructure: m,
-    customMatcher: d
-  } = i;
-  if (m) {
-    const f = K(
-      c,
-      r,
-      i
+    strategy: E,
+    childrenKey: a,
+    strict: R,
+    fuzzyMatch: b,
+    returnAllMatches: M,
+    caseSensitive: v,
+    allowEmptyString: z,
+    matchMode: T,
+    returnTree: g,
+    returnTreeMaxDepth: p
+  } = w, D = T === "OR", x = T === "AND", y = E === "BFS";
+  if (!(y || E === "DFS")) throw new Error('配置 strategy 必须是 "BFS" 或 "DFS"');
+  if (!(D || x)) throw new Error('配置 matchMode 必须是 "AND" 或 "OR"');
+  if (!m(a)) throw new TypeError("配置 childrenKey 必须是字符串");
+  if (g) {
+    if (!M) throw new Error(
+      "当 returnTree 为 true 时，returnAllMatches 也必须为 true"
     );
-    return n ? f : f[0] || null;
+    if (!(C(p) && p > -1)) throw new TypeError("配置 returnTreeMaxDepth 必须是一个非负整数");
   }
-  const s = t === "OR", a = t === "AND", o = l === "BFS";
-  if (!(o || l === "DFS")) throw new Error('配置 strategy 必须是 "BFS" 或 "DFS"');
-  if (!(s || a)) throw new Error('配置 matchMode 必须是 "AND" 或 "OR"');
-  if (!F(u)) throw new TypeError("配置 childrenKey 必须是字符串");
-  const h = [...c], D = [];
-  if (Object.entries(r).length)
-    for (; h.length > 0; ) {
-      const f = o ? h.shift() : h.pop();
-      if (!f) continue;
-      try {
-        const { match: w, matches: v } = O(
-          f,
-          r,
-          i
-        );
-        let R = w;
-        if (d) {
-          const E = d(f, v);
-          typeof E == "boolean" ? R = E : E && typeof E.match == "boolean" && (R = E.match);
+  const d = [...o], A = [], F = Object.entries(f);
+  if (F.length) {
+    const N = (r) => {
+      let s = !1;
+      for (const [n, e] of F) {
+        const t = r[n];
+        if (e === "" && !z)
+          continue;
+        let i = !1;
+        if (K(e))
+          i = !!e(t, r);
+        else if (L(e) && m(t))
+          i = t ? e.test(t) : !1;
+        else if (b && m(e) && m(t)) {
+          let l = e, c = t;
+          v || (l = e.toLowerCase(), c = t.toLowerCase()), i = c.includes(l);
+        } else
+          i = R ? t === e : t == e;
+        const u = j(i, D, x, s);
+        if (u.shouldExit)
+          return u.newMatch;
+        s = u.newMatch;
+      }
+      return s;
+    };
+    if (g) {
+      const r = (n, e = 1) => {
+        const t = p > 0 && e > p, i = !t && N(n), u = t ? void 0 : n[a], l = [];
+        if (S(u))
+          for (const c of u) {
+            const O = r(c, e + 1);
+            O && l.push(O);
+          }
+        if (i || l.length > 0) {
+          const c = k(n, a);
+          return l.length > 0 && (c[a] = l), c;
         }
-        if (R)
-          if (n)
-            D.push(f);
+        return null;
+      }, s = [];
+      for (const n of o) {
+        const e = r(n, 1);
+        e && s.push(e);
+      }
+      return s;
+    } else
+      for (; d.length > 0; ) {
+        const r = y ? d.shift() : d.pop();
+        if (!r) continue;
+        if (N(r))
+          if (M)
+            A.push(r);
           else
-            return f;
-      } catch {
-        continue;
+            return r;
+        const s = r[a];
+        if (S(s))
+          if (y)
+            d.push(...s);
+          else
+            for (let n = s.length - 1; n >= 0; n--)
+              d.push(s[n]);
       }
-      const N = f[u];
-      if (A(N))
-        if (o)
-          h.push(...N);
-        else
-          for (let w = N.length - 1; w >= 0; w--)
-            h.push(N[w]);
-    }
-  return n ? D : null;
+  }
+  return M ? A : null;
 }
 export {
-  V as default
+  Q as default
 };

package/types/is/index.d.ts

@@ -3,25 +3,17 @@ import isArray from 'lodash/isArray';
 import isArrayBuffer from 'lodash/isArrayBuffer';
 import isArrayLike from 'lodash/isArrayLike';
 import isArrayLikeObject from 'lodash/isArrayLikeObject';
-export function isBlob(o: any): boolean;
 import isBoolean from 'lodash/isBoolean';
 import isBuffer from 'lodash/isBuffer';
-export function isColor(color: any): boolean;
-export function isColor2(color: any): boolean;
 import isDate from 'lodash/isDate';
 import isElement from 'lodash/isElement';
 import isEmpty from 'lodash/isEmpty';
-export function isEmptyArray(o: any): boolean;
-export function isEmptyObject(o: any): boolean;
-export function isEmptyValue(o: any): boolean;
 import isEqual from 'lodash/isEqual';
 import isEqualWith from 'lodash/isEqualWith';
 import isError from 'lodash/isError';
-export function isFile(o: any): boolean;
 import isFinite from 'lodash/isFinite';
 import isFunction from 'lodash/isFunction';
 import isInteger from 'lodash/isInteger';
-export function isJSON(text: any): boolean;
 import isLength from 'lodash/isLength';
 import isMap from 'lodash/isMap';
 import isMatch from 'lodash/isMatch';
@@ -34,12 +26,6 @@ import isNumber from 'lodash/isNumber';
 import isObject from 'lodash/isObject';
 import isObjectLike from 'lodash/isObjectLike';
 import isPlainObject from 'lodash/isPlainObject';
-export function isPromise(p: any): p is Promise<any>;
-export const isReadableByteStreamControllerSupported: boolean;
-export function isReadableStream(params: any): boolean;
-export const isReadableStreamDefaultControllerSupported: boolean;
-export const isReadableStreamSupported: boolean;
-export const isReadableStreamSymbolAsyncIteratorSupported: any;
 import isRegExp from 'lodash/isRegExp';
 import isSafeInteger from 'lodash/isSafeInteger';
 import isSet from 'lodash/isSet';
@@ -47,7 +33,21 @@ import isString from 'lodash/isString';
 import isSymbol from 'lodash/isSymbol';
 import isTypedArray from 'lodash/isTypedArray';
 import isUndefined from 'lodash/isUndefined';
-export function isValidColor(value: any): boolean;
 import isWeakMap from 'lodash/isWeakMap';
 import isWeakSet from 'lodash/isWeakSet';
-export { isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBoolean, isBuffer, isDate, isElement, isEmpty, isEqual, isEqualWith, isError, isFinite, isFunction, isInteger, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isUndefined, isWeakMap, isWeakSet };
+declare function isPromise(p: any): p is Promise<any>;
+declare function isEmptyArray(o: any): boolean;
+declare function isEmptyObject(o: any): boolean;
+declare function isEmptyValue(o: any): boolean;
+declare function isFile(o: any): boolean;
+declare function isBlob(o: any): boolean;
+declare function isReadableStream(params: any): boolean;
+declare const isReadableStreamSupported: boolean;
+declare const isReadableStreamDefaultControllerSupported: boolean;
+declare const isReadableByteStreamControllerSupported: boolean;
+declare const isReadableStreamSymbolAsyncIteratorSupported: any;
+declare function isJSON(text: any): boolean;
+declare function isColor(color: any): boolean;
+declare function isColor2(color: any): boolean;
+declare function isValidColor(value: any): boolean;
+export { isArguments, isArray, isArrayBuffer, isArrayLike, isArrayLikeObject, isBlob, isBoolean, isBuffer, isColor, isColor2, isDate, isElement, isEmpty, isEmptyArray, isEmptyObject, isEmptyValue, isEqual, isEqualWith, isError, isFile, isFinite, isFunction, isInteger, isJSON, isLength, isMap, isMatch, isMatchWith, isNaN, isNative, isNil, isNull, isNumber, isObject, isObjectLike, isPlainObject, isPromise, isReadableByteStreamControllerSupported, isReadableStream, isReadableStreamDefaultControllerSupported, isReadableStreamSupported, isReadableStreamSymbolAsyncIteratorSupported, isRegExp, isSafeInteger, isSet, isString, isSymbol, isTypedArray, isUndefined, isValidColor, isWeakMap, isWeakSet, };

package/types/tree/search/index.d.ts

@@ -9,19 +9,7 @@ type Primitive = string | number | boolean | symbol | null | undefined;
  * 3. 正则表达式
  * @template T 节点值的泛型类型
  */
-type ConditionValue<T = unknown> = Primitive | ((value: T) => boolean) | RegExp;
-/**
- * 自定义匹配函数类型
- * @param node 当前节点
- * @param matches 当前已匹配的条件信息
- * @returns 返回boolean或对象包含匹配详情
- */
-type CustomMatchFunction = (node: TreeNode, matches: {
-    [key: string]: boolean;
-}) => boolean | {
-    match: boolean;
-    reason?: string;
-};
+type ConditionValue<T = unknown> = Primitive | ((value: T, node?: TreeNode) => boolean) | RegExp;
 /**
  * 树搜索配置选项接口
  */
@@ -67,15 +55,15 @@ interface SearchOptions {
      */
     allowEmptyString?: boolean;
     /**
-     * 是否保留树形结构（返回包含匹配节点的最小完整子树）
+     * 是否以树结构返回结果（保留父子关系）
      * @default false
      */
-    preserveTreeStructure?: boolean;
+    returnTree?: boolean;
     /**
-     * 自定义匹配函数，可以覆盖默认的匹配逻辑
-     * 返回true表示匹配，false表示不匹配
+     * 搜索深度限制（从1开始计数），0表示无限制
+     * @default 0
      */
-    customMatcher?: CustomMatchFunction;
+    returnTreeMaxDepth?: number;
 }
 /**
  * 树节点接口定义