amos-apptool 1.2.2 → 1.3.1

package/esm/equal.js

@@ -0,0 +1,36 @@
+export const Equal = {
+  any(e, t) {
+    if (e === t) return !0;
+    if (Number.isNaN(e) && Number.isNaN(t)) return !0;
+    if ("number" == typeof e && "string" == typeof t || "string" == typeof e && "number" == typeof t) {
+      const r = Number(e), n = Number(t);
+      return !Number.isNaN(r) && !Number.isNaN(n) && r === n;
+    }
+    return "object" == typeof e && "object" == typeof t && null !== e && null !== t && this.obj(e, t);
+  },
+  single(e, t) {
+    const r = [ "string", "number" ];
+    if (!r.includes(typeof e) || !r.includes(typeof t)) return !1;
+    if (e === t) return !0;
+    if (typeof e != typeof t) {
+      const r = Number(e), n = Number(t);
+      return !Number.isNaN(r) && !Number.isNaN(n) && r === n;
+    }
+    return !1;
+  },
+  string(e, t, r = {
+    ignoreCase: !1,
+    trim: !1
+  }) {
+    if ("string" != typeof e || "string" != typeof t) return !1;
+    let n = e, o = t;
+    return r.trim && (n = n.trim(), o = o.trim()), r.ignoreCase && (n = n.toLowerCase(), 
+    o = o.toLowerCase()), n === o;
+  },
+  obj(e, t, r) {
+    if (null === e || null === t || "object" != typeof e || "object" != typeof t) return e === t;
+    const n = r || [ ...new Set([ ...Object.keys(e), ...Object.keys(t) ]) ];
+    for (const r of n) if (!this.any(e[r], t[r])) return !1;
+    return !0;
+  }
+};

package/esm/index.js

@@ -48,6 +48,10 @@ export { default as strUtils } from "./strUtils";
 
 export { default as utils } from "./utils";
 
+export * from "./search";
+
+export * from "./equal";
+
 export { default as addition } from "./math/addition";
 
 export { default as amountCase } from "./math/amountCase";

package/esm/search.js

@@ -0,0 +1,108 @@
+import { deepCopy } from "./_deepCopy";
+
+export function recursive(t, h = "children") {
+  return new class {
+    constructor(t, h) {
+      this.list = deepCopy(t || []), this.childName = h;
+    }
+    getLeafNodes() {
+      const t = [], h = i => {
+        if (i[this.childName] && i[this.childName].length > 0) for (const t of i[this.childName]) h(t); else t.push(i);
+      };
+      return (this.list || []).map(t => h(t)), t;
+    }
+    some(t) {
+      const h = i => i.some((i, e) => {
+        const s = t(i, e);
+        return s || !!(i[this.childName] && i[this.childName].length > 0) && h(i[this.childName]);
+      });
+      return h(this.list);
+    }
+    find(t) {
+      let h = null;
+      const i = e => e.find((e, s) => {
+        const l = t(e, s);
+        return l ? (h = e, l) : !!(e[this.childName] && e[this.childName].length > 0) && i(e[this.childName]);
+      });
+      return i(this.list), h;
+    }
+    findParent(t) {
+      let h = null;
+      const i = (e, s) => e.find((e, l) => {
+        const c = t(e, l, s);
+        return c ? (h = s, c) : !!(e[this.childName] && e[this.childName].length > 0) && i(e[this.childName], e);
+      });
+      return i(this.list, {}), h;
+    }
+    findPath(t) {
+      let h = [];
+      const i = e => e.some((e, s) => {
+        let l = !1;
+        return t(e, s) ? l = !0 : e[this.childName] && e[this.childName].length > 0 && (l = i(e[this.childName], e)), 
+        l && (h = [ ...h, e ]), l;
+      });
+      return i(this.list), h;
+    }
+    getMaxLengthPaths() {
+      let t = [], h = [];
+      const i = (e, s) => e.forEach((e, s) => {
+        e[this.childName] && e[this.childName].length > 0 ? (h.push(e), i(e[this.childName], e)) : (h.push(e), 
+        t.push(h), h = []);
+      });
+      return i(this.list), t.reduce((t, h) => t.length > h.length ? t : h, []);
+    }
+    getPaths(t) {
+      let h = [], i = [];
+      const e = (s, l) => s.forEach((s, l) => {
+        s[this.childName] && s[this.childName].length > 0 ? (i.push(s), e(s[this.childName], s)) : (i.push(s), 
+        t ? t(s) && h.push(i) : h.push(i), i = []);
+      });
+      return e(this.list), h;
+    }
+    findIndex(t) {
+      let h = -1;
+      const i = (e, s) => e.find((e, l) => {
+        const c = t(e, l, s);
+        return c ? (h = l, c) : !!(e[this.childName] && e[this.childName].length > 0) && i(e[this.childName], e);
+      });
+      return i(this.list, {}), h;
+    }
+    filter(t) {
+      const h = (i, e) => i.filter((i, s) => {
+        i[this.childName] && i[this.childName].length > 0 && (i[this.childName] = h(i[this.childName], i));
+        return t(i, s, e);
+      });
+      return h(this.list, {});
+    }
+    flatFilter(t) {
+      const h = [], i = (e, s) => e.forEach((e, l) => {
+        t(e, l, s) && h.push(e), e[this.childName] && e[this.childName].length > 0 && i(e[this.childName], e);
+      });
+      return i(this.list, {}), h;
+    }
+    map(t) {
+      const h = (i, e) => i.map((i, s) => {
+        const l = t(i, s, e);
+        return l && (i = l), i[this.childName] && i[this.childName].length > 0 && (i[this.childName] = h(i[this.childName], i)), 
+        i;
+      });
+      return h(this.list, {});
+    }
+    search(t) {
+      const h = (i, e) => i.filter((i, s) => {
+        let l = t(i, s, e), c = !1;
+        return l && l.length && (l[1] ? (l = !1, c = !0) : l = l[0]), l || (i[this.childName] && i[this.childName].length > 0 && (i[this.childName] = h(i[this.childName], i), 
+        i[this.childName] && i[this.childName].length > 0 && (l = !0)), !!c || l);
+      });
+      return h(this.list, {});
+    }
+    forEach(t) {
+      const h = (i, e) => i.map((i, s) => {
+        const l = t(i, s, e);
+        return l && (i = l), i[this.childName] && i[this.childName].length > 0 && (i[this.childName] = h(i[this.childName], i)), 
+        i;
+      });
+      return h(this.list, {});
+    }
+  }(t, h);
+}

package/index.d.ts

@@ -1612,3 +1612,202 @@ export {
   utils
 };
 
+// search
+/**
+ * 递归遍历树形结构的类类型定义
+ * @template T 树节点的类型
+ */
+declare class RecursiveClass<T = Record<string, any>> {
+  /** 原始树形列表数据 */
+  list: T[];
+  /** 子节点字段名 */
+  childName: string;
+
+  /**
+   * 构造函数
+   * @param _list 树形结构列表
+   * @param _childName 子节点字段名
+   */
+  constructor(_list: T[], _childName: string);
+
+  /**
+   * 按顺序获取树的所有叶子节点
+   * @returns 所有叶子节点组成的数组
+   */
+  getLeafNodes(): T[];
+
+  /**
+   * 递归执行 some 逻辑（只要有一个节点满足条件就返回 true）
+   * @param callback 回调函数，参数为当前节点、索引，返回布尔值
+   * @returns 是否存在满足条件的节点
+   */
+  some(callback: (node: T, index: number) => boolean): boolean;
+
+  /**
+   * 递归查找第一个满足条件的节点
+   * @param callback 回调函数，参数为当前节点、索引，返回布尔值
+   * @returns 满足条件的节点 | null
+   */
+  find(callback: (node: T, index: number) => boolean): T | null;
+
+  /**
+   * 递归查找满足条件节点的父节点
+   * @param callback 回调函数，参数为当前节点、索引、父节点，返回布尔值
+   * @returns 父节点 | null
+   */
+  findParent(callback: (node: T, index: number, parent: T) => boolean): T | null;
+
+  /**
+   * 递归查找满足条件节点的路径（从目标节点到根节点）
+   * @param callback 回调函数，参数为当前节点、索引，返回布尔值
+   * @returns 路径节点组成的数组
+   */
+  findPath(callback: (node: T, index: number) => boolean): T[];
+
+  /**
+   * 获取树中最长路径的节点数组
+   * @returns 最长路径的节点数组
+   */
+  getMaxLengthPaths(): T[];
+
+  /**
+   * 获取树中所有路径（可通过回调筛选）
+   * @param callback 可选回调函数，参数为叶子节点，返回布尔值，用于筛选路径
+   * @returns 所有符合条件的路径数组
+   */
+  getPaths(callback?: (node: T) => boolean): T[][];
+
+  /**
+   * 递归查找满足条件节点的索引
+   * @param callback 回调函数，参数为当前节点、索引、父节点，返回布尔值
+   * @returns 满足条件的节点索引（未找到返回 -1）
+   */
+  findIndex(callback: (node: T, index: number, parent: T) => boolean): number;
+
+  /**
+   * 递归过滤树形结构（保留满足条件的节点及其父节点层级）
+   * @param callback 回调函数，参数为当前节点、索引、父节点，返回布尔值
+   * @returns 过滤后的树形结构
+   */
+  filter(callback: (node: T, index: number, parent: T) => boolean): T[];
+
+  /**
+   * 扁平化过滤（返回所有满足条件的节点，不保留树形结构）
+   * @param callback 回调函数，参数为当前节点、索引、父节点，返回布尔值
+   * @returns 满足条件的所有节点数组
+   */
+  flatFilter(callback: (node: T, index: number, parent: T) => boolean): T[];
+
+  /**
+   * 递归映射（遍历所有节点并支持修改节点，保留树形结构）
+   * @param callback 回调函数，参数为当前节点、索引、父节点，返回修改后的节点或原节点
+   * @returns 映射后的树形结构
+   */
+  map(callback: (node: T, index: number, parent: T) => T | void): T[];
+
+  /**
+   * 递归搜索（支持复杂的搜索逻辑，返回匹配节点及其父层级）
+   * @param callback 回调函数，参数为当前节点、索引、父节点，返回布尔值或 [boolean, boolean]
+   * @returns 搜索后的树形结构
+   */
+  search(
+    callback: (node: T, index: number, parent: T) => boolean | [boolean, boolean]
+  ): T[];
+
+  /**
+   * 递归遍历所有节点（支持修改节点，保留树形结构）
+   * @param callback 回调函数，参数为当前节点、索引、父节点，返回修改后的节点或原节点
+   * @returns 遍历后的树形结构
+   */
+  forEach(callback: (node: T, index: number, parent: T) => T | void): T[];
+}
+
+/**
+ * 用于遍历树形结构数据, 递归执行 `some/find/filter/map/search` 等操作
+ * @template T 树节点的类型
+ * @param list 树形结构列表
+ * @param childName 子节点字段名（默认 'children'）
+ * @returns 递归操作的实例
+ * @example
+ *  recursive([{name: 'ray', children: [ { name: 'dd' }, { name: 'mm'}, ...]}, { name: 'ilex' }]).find(d => d.name === 'mm');
+ */
+export declare function recursive<T = Record<string, any>>(
+  list: T[],
+  childName?: string
+): RecursiveClass<T>;
+
+/**
+ * 字符串比较的配置项类型
+ */
+export interface StringCompareOptions {
+  /** 是否忽略大小写，默认 false */
+  ignoreCase?: boolean;
+  /** 是否去除首尾空格，默认 false */
+  trim?: boolean;
+}
+
+/**
+ * 等值比较工具核心对象类型
+ */
+export interface EqualTool {
+  /**
+   * 通用等值比较（智能匹配任意类型）
+   * @param a 第一个比较值
+   * @param b 第二个比较值
+   * @returns 两个值是否相等
+   * @example
+   *  Equal.any(NaN, NaN); // true
+   *  Equal.any({ name: '123' }, { name: 123 }); // true
+   */
+  any<T = any>(a: T, b: T): boolean;
+
+  /**
+   * 单一值比较（专注数字/文本）
+   * @param a 数字或文本值
+   * @param b 数字或文本值
+   * @returns 两个值是否相等
+   * @example
+   *  Equal.single(123, 123); // true
+   *  Equal.single(123, '123'); // true
+   *  Equal.single('abc', 'abc'); // true
+   *  Equal.single('123a', 123); // false
+   */
+  single(a: string | number, b: string | number): boolean;
+
+  /**
+   * 纯字符串比较（支持扩展配置）
+   * @param a 待比较的字符串
+   * @param b 待比较的字符串
+   * @param options 字符串比较配置项
+   * @returns 两个字符串是否相等
+   * @example
+   *  Equal.string('  Hello  ', 'hello', { ignoreCase: true, trim: true }); // true
+   *  Equal.string('abc', 'ABC'); // false（默认不忽略大小写）
+   */
+  string(
+    a: string,
+    b: string,
+    options?: StringCompareOptions
+  ): boolean;
+
+  /**
+   * 对象属性比较
+   * @param a 第一个对象
+   * @param b 第二个对象
+   * @param props 指定要比较的属性列表（不传则比较全部自有属性）
+   * @returns 对象的指定属性是否全部相等
+   * @example
+   *  Equal.obj({ age: 18 }, { age: '18' }); // true
+   *  Equal.obj({ a: 1, b: 2 }, { a: 1, b: 3 }, ['a', 'b']); // false
+   */
+  obj<T extends Record<string, any>>(
+    a: T,
+    b: T,
+    props?: (keyof T)[]
+  ): boolean;
+}
+
+/**
+ * 等值比较工具实例
+ */
+export const Equal: EqualTool;

package/lib/equal.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+}), exports.Equal = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray")), _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+function _createForOfIteratorHelper(e, r) {
+  var t = "undefined" != typeof Symbol && e[Symbol.iterator] || e["@@iterator"];
+  if (!t) {
+    if (Array.isArray(e) || (t = _unsupportedIterableToArray(e)) || r && e && "number" == typeof e.length) {
+      t && (e = t);
+      var n = 0, o = function() {};
+      return {
+        s: o,
+        n: function() {
+          return n >= e.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: e[n++]
+          };
+        },
+        e: function(e) {
+          throw e;
+        },
+        f: o
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var a, u = !0, i = !1;
+  return {
+    s: function() {
+      t = t.call(e);
+    },
+    n: function() {
+      var e = t.next();
+      return u = e.done, e;
+    },
+    e: function(e) {
+      i = !0, a = e;
+    },
+    f: function() {
+      try {
+        u || null == t.return || t.return();
+      } finally {
+        if (i) throw a;
+      }
+    }
+  };
+}
+
+function _unsupportedIterableToArray(e, r) {
+  if (e) {
+    if ("string" == typeof e) return _arrayLikeToArray(e, r);
+    var t = {}.toString.call(e).slice(8, -1);
+    return "Object" === t && e.constructor && (t = e.constructor.name), "Map" === t || "Set" === t ? Array.from(e) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(e, r) : void 0;
+  }
+}
+
+function _arrayLikeToArray(e, r) {
+  (null == r || r > e.length) && (r = e.length);
+  for (var t = 0, n = Array(r); t < r; t++) n[t] = e[t];
+  return n;
+}
+
+var Equal = exports.Equal = {
+  any: function(e, r) {
+    if (e === r) return !0;
+    if (Number.isNaN(e) && Number.isNaN(r)) return !0;
+    if ("number" == typeof e && "string" == typeof r || "string" == typeof e && "number" == typeof r) {
+      var t = Number(e), n = Number(r);
+      return !Number.isNaN(t) && !Number.isNaN(n) && t === n;
+    }
+    return "object" === (0, _typeof2.default)(e) && "object" === (0, _typeof2.default)(r) && null !== e && null !== r && this.obj(e, r);
+  },
+  single: function(e, r) {
+    var t = [ "string", "number" ];
+    if (!t.includes((0, _typeof2.default)(e)) || !t.includes((0, _typeof2.default)(r))) return !1;
+    if (e === r) return !0;
+    if ((0, _typeof2.default)(e) !== (0, _typeof2.default)(r)) {
+      var n = Number(e), o = Number(r);
+      return !Number.isNaN(n) && !Number.isNaN(o) && n === o;
+    }
+    return !1;
+  },
+  string: function(e, r) {
+    var t = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {
+      ignoreCase: !1,
+      trim: !1
+    };
+    if ("string" != typeof e || "string" != typeof r) return !1;
+    var n = e, o = r;
+    return t.trim && (n = n.trim(), o = o.trim()), t.ignoreCase && (n = n.toLowerCase(), 
+    o = o.toLowerCase()), n === o;
+  },
+  obj: function(e, r, t) {
+    if (null === e || null === r || "object" !== (0, _typeof2.default)(e) || "object" !== (0, 
+    _typeof2.default)(r)) return e === r;
+    var n, o = _createForOfIteratorHelper(t || (0, _toConsumableArray2.default)(new Set([].concat((0, 
+    _toConsumableArray2.default)(Object.keys(e)), (0, _toConsumableArray2.default)(Object.keys(r))))));
+    try {
+      for (o.s(); !(n = o.n()).done; ) {
+        var a = n.value;
+        if (!this.any(e[a], r[a])) return !1;
+      }
+    } catch (e) {
+      o.e(e);
+    } finally {
+      o.f();
+    }
+    return !0;
+  }
+};

package/lib/index.js

@@ -242,7 +242,29 @@ Object.keys(_shallowEqual).forEach(function(e) {
   }));
 });
 
-var _strUtils = _interopRequireDefault(require("./strUtils")), _utils = _interopRequireDefault(require("./utils")), _addition = _interopRequireDefault(require("./math/addition")), _amountCase = _interopRequireDefault(require("./math/amountCase")), _coinFormat = _interopRequireDefault(require("./math/coinFormat")), _colorUtil = _interopRequireDefault(require("./math/colorUtil")), _dateTime = _interopRequireDefault(require("./math/dateTime")), _pwdStrength = _interopRequireDefault(require("./math/pwdStrength")), _randomColor = _interopRequireDefault(require("./math/randomColor")), _subtraction = _interopRequireDefault(require("./math/subtraction")), _mul = _interopRequireDefault(require("./math/mul")), _divide = _interopRequireDefault(require("./math/divide")), _calendarUtils = require("./math/calendarUtils");
+var _strUtils = _interopRequireDefault(require("./strUtils")), _utils = _interopRequireDefault(require("./utils")), _search = require("./search");
+
+Object.keys(_search).forEach(function(e) {
+  "default" !== e && "__esModule" !== e && (Object.prototype.hasOwnProperty.call(_exportNames, e) || e in exports && exports[e] === _search[e] || Object.defineProperty(exports, e, {
+    enumerable: !0,
+    get: function() {
+      return _search[e];
+    }
+  }));
+});
+
+var _equal = require("./equal");
+
+Object.keys(_equal).forEach(function(e) {
+  "default" !== e && "__esModule" !== e && (Object.prototype.hasOwnProperty.call(_exportNames, e) || e in exports && exports[e] === _equal[e] || Object.defineProperty(exports, e, {
+    enumerable: !0,
+    get: function() {
+      return _equal[e];
+    }
+  }));
+});
+
+var _addition = _interopRequireDefault(require("./math/addition")), _amountCase = _interopRequireDefault(require("./math/amountCase")), _coinFormat = _interopRequireDefault(require("./math/coinFormat")), _colorUtil = _interopRequireDefault(require("./math/colorUtil")), _dateTime = _interopRequireDefault(require("./math/dateTime")), _pwdStrength = _interopRequireDefault(require("./math/pwdStrength")), _randomColor = _interopRequireDefault(require("./math/randomColor")), _subtraction = _interopRequireDefault(require("./math/subtraction")), _mul = _interopRequireDefault(require("./math/mul")), _divide = _interopRequireDefault(require("./math/divide")), _calendarUtils = require("./math/calendarUtils");
 
 Object.keys(_calendarUtils).forEach(function(e) {
   "default" !== e && "__esModule" !== e && (Object.prototype.hasOwnProperty.call(_exportNames, e) || e in exports && exports[e] === _calendarUtils[e] || Object.defineProperty(exports, e, {

package/lib/search.js

@@ -0,0 +1,238 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+}), exports.recursive = recursive;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray")), _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck")), _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass")), _deepCopy = require("./_deepCopy");
+
+function _createForOfIteratorHelper(e, t) {
+  var r = "undefined" != typeof Symbol && e[Symbol.iterator] || e["@@iterator"];
+  if (!r) {
+    if (Array.isArray(e) || (r = _unsupportedIterableToArray(e)) || t && e && "number" == typeof e.length) {
+      r && (e = r);
+      var n = 0, i = function() {};
+      return {
+        s: i,
+        n: function() {
+          return n >= e.length ? {
+            done: !0
+          } : {
+            done: !1,
+            value: e[n++]
+          };
+        },
+        e: function(e) {
+          throw e;
+        },
+        f: i
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var a, u = !0, l = !1;
+  return {
+    s: function() {
+      r = r.call(e);
+    },
+    n: function() {
+      var e = r.next();
+      return u = e.done, e;
+    },
+    e: function(e) {
+      l = !0, a = e;
+    },
+    f: function() {
+      try {
+        u || null == r.return || r.return();
+      } finally {
+        if (l) throw a;
+      }
+    }
+  };
+}
+
+function _unsupportedIterableToArray(e, t) {
+  if (e) {
+    if ("string" == typeof e) return _arrayLikeToArray(e, t);
+    var r = {}.toString.call(e).slice(8, -1);
+    return "Object" === r && e.constructor && (r = e.constructor.name), "Map" === r || "Set" === r ? Array.from(e) : "Arguments" === r || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r) ? _arrayLikeToArray(e, t) : void 0;
+  }
+}
+
+function _arrayLikeToArray(e, t) {
+  (null == t || t > e.length) && (t = e.length);
+  for (var r = 0, n = Array(t); r < t; r++) n[r] = e[r];
+  return n;
+}
+
+function recursive(e) {
+  var t = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : "children";
+  return new (function() {
+    return (0, _createClass2.default)(function e(t, r) {
+      (0, _classCallCheck2.default)(this, e), this.list = (0, _deepCopy.deepCopy)(t || []), 
+      this.childName = r;
+    }, [ {
+      key: "getLeafNodes",
+      value: function() {
+        var e = this, t = [], r = function(n) {
+          if (n[e.childName] && n[e.childName].length > 0) {
+            var i, a = _createForOfIteratorHelper(n[e.childName]);
+            try {
+              for (a.s(); !(i = a.n()).done; ) {
+                var u = i.value;
+                r(u);
+              }
+            } catch (e) {
+              a.e(e);
+            } finally {
+              a.f();
+            }
+          } else t.push(n);
+        };
+        return (this.list || []).map(function(e) {
+          return r(e);
+        }), t;
+      }
+    }, {
+      key: "some",
+      value: function(e) {
+        var t = this, r = function(n) {
+          return n.some(function(n, i) {
+            var a = e(n, i);
+            return a || !!(n[t.childName] && n[t.childName].length > 0) && r(n[t.childName]);
+          });
+        };
+        return r(this.list);
+      }
+    }, {
+      key: "find",
+      value: function(e) {
+        var t = this, r = null, n = function(i) {
+          return i.find(function(i, a) {
+            var u = e(i, a);
+            return u ? (r = i, u) : !!(i[t.childName] && i[t.childName].length > 0) && n(i[t.childName]);
+          });
+        };
+        return n(this.list), r;
+      }
+    }, {
+      key: "findParent",
+      value: function(e) {
+        var t = this, r = null, n = function(i, a) {
+          return i.find(function(i, u) {
+            var l = e(i, u, a);
+            return l ? (r = a, l) : !!(i[t.childName] && i[t.childName].length > 0) && n(i[t.childName], i);
+          });
+        };
+        return n(this.list, {}), r;
+      }
+    }, {
+      key: "findPath",
+      value: function(e) {
+        var t = this, r = [], n = function(i) {
+          return i.some(function(i, a) {
+            var u = !1;
+            return e(i, a) ? u = !0 : i[t.childName] && i[t.childName].length > 0 && (u = n(i[t.childName], i)), 
+            u && (r = [].concat((0, _toConsumableArray2.default)(r), [ i ])), u;
+          });
+        };
+        return n(this.list), r;
+      }
+    }, {
+      key: "getMaxLengthPaths",
+      value: function() {
+        var e = this, t = [], r = [], n = function(i, a) {
+          return i.forEach(function(i, a) {
+            i[e.childName] && i[e.childName].length > 0 ? (r.push(i), n(i[e.childName], i)) : (r.push(i), 
+            t.push(r), r = []);
+          });
+        };
+        return n(this.list), t.reduce(function(e, t) {
+          return e.length > t.length ? e : t;
+        }, []);
+      }
+    }, {
+      key: "getPaths",
+      value: function(e) {
+        var t = this, r = [], n = [], i = function(a, u) {
+          return a.forEach(function(a, u) {
+            a[t.childName] && a[t.childName].length > 0 ? (n.push(a), i(a[t.childName], a)) : (n.push(a), 
+            e ? e(a) && r.push(n) : r.push(n), n = []);
+          });
+        };
+        return i(this.list), r;
+      }
+    }, {
+      key: "findIndex",
+      value: function(e) {
+        var t = this, r = -1, n = function(i, a) {
+          return i.find(function(i, u) {
+            var l = e(i, u, a);
+            return l ? (r = u, l) : !!(i[t.childName] && i[t.childName].length > 0) && n(i[t.childName], i);
+          });
+        };
+        return n(this.list, {}), r;
+      }
+    }, {
+      key: "filter",
+      value: function(e) {
+        var t = this, r = function(n, i) {
+          return n.filter(function(n, a) {
+            return n[t.childName] && n[t.childName].length > 0 && (n[t.childName] = r(n[t.childName], n)), 
+            e(n, a, i);
+          });
+        };
+        return r(this.list, {});
+      }
+    }, {
+      key: "flatFilter",
+      value: function(e) {
+        var t = this, r = [], n = function(i, a) {
+          return i.forEach(function(i, u) {
+            e(i, u, a) && r.push(i), i[t.childName] && i[t.childName].length > 0 && n(i[t.childName], i);
+          });
+        };
+        return n(this.list, {}), r;
+      }
+    }, {
+      key: "map",
+      value: function(e) {
+        var t = this, r = function(n, i) {
+          return n.map(function(n, a) {
+            var u = e(n, a, i);
+            return u && (n = u), n[t.childName] && n[t.childName].length > 0 && (n[t.childName] = r(n[t.childName], n)), 
+            n;
+          });
+        };
+        return r(this.list, {});
+      }
+    }, {
+      key: "search",
+      value: function(e) {
+        var t = this, r = function(n, i) {
+          return n.filter(function(n, a) {
+            var u = e(n, a, i), l = !1;
+            return u && u.length && (u[1] ? (u = !1, l = !0) : u = u[0]), u || (n[t.childName] && n[t.childName].length > 0 && (n[t.childName] = r(n[t.childName], n), 
+            n[t.childName] && n[t.childName].length > 0 && (u = !0)), !!l || u);
+          });
+        };
+        return r(this.list, {});
+      }
+    }, {
+      key: "forEach",
+      value: function(e) {
+        var t = this, r = function(n, i) {
+          return n.map(function(n, a) {
+            var u = e(n, a, i);
+            return u && (n = u), n[t.childName] && n[t.childName].length > 0 && (n[t.childName] = r(n[t.childName], n)), 
+            n;
+          });
+        };
+        return r(this.list, {});
+      }
+    } ]);
+  }())(e, t);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amos-apptool",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "description": "amos app tool",
   "main": "./lib/index.js",
   "module": "./esm/index.js",