@zcrkey/js-utils 0.0.6 → 0.0.9

package/dist/esm/color.js

@@ -0,0 +1,500 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+var CrColorUtil = /*#__PURE__*/function () {
+  function CrColorUtil() {
+    _classCallCheck(this, CrColorUtil);
+  }
+  _createClass(CrColorUtil, null, [{
+    key: "hexToRgb",
+    value:
+    /**
+     * hex 转 rgb 数组 [r,g,b]  r/g/b范围 0-255
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     */
+    function hexToRgb(hex) {
+      var hexVal = hex.replace('#', '');
+      if (hexVal.length === 3) {
+        hexVal = hexVal.split('').map(function (c) {
+          return c + c;
+        }).join('');
+      }
+      var hexInt = parseInt(hexVal, 16);
+      var r = hexInt >> 16 & 255;
+      var g = hexInt >> 8 & 255;
+      var b = hexInt & 255;
+      return [r, g, b];
+    }
+
+    /**
+     * rgb 转 hex 标准格式
+     * @param r 0-255
+     * @param g 0-255
+     * @param b 0-255
+     */
+  }, {
+    key: "rgbToHex",
+    value: function rgbToHex(r, g, b) {
+      var clamp = function clamp(val) {
+        return Math.max(0, Math.min(255, Math.round(val)));
+      };
+      var red = clamp(r);
+      var green = clamp(g);
+      var blue = clamp(b);
+      return '#' + this.twoDigits(red.toString(16)) + this.twoDigits(green.toString(16)) + this.twoDigits(blue.toString(16));
+    }
+
+    /**
+     * 将 rgb 格式转为 hsv 格式
+     * input: r,g,b in [0,1], out: h in [0,360) and s,v in [0,1]
+     * @param r 0-1
+     * @param g 0-1
+     * @param b 0-1
+     */
+  }, {
+    key: "rgb2hsv",
+    value: function rgb2hsv(r, g, b) {
+      var v = Math.max(r, g, b);
+      var n = v - Math.min(r, g, b);
+      var h = n && (v == r ? (g - b) / n : v == g ? 2 + (b - r) / n : 4 + (r - g) / n);
+      return [60 * (h < 0 ? h + 6 : h), v && n / v, v];
+    }
+
+    /**
+     * 将 hsv 格式转为 rgb 格式
+     * input: h in [0,360] and s,v in [0,1] - output: r,g,b in [0,1]
+     * @param h 0-360
+     * @param s 0-1
+     * @param v 0-1
+     */
+  }, {
+    key: "hsv2rgb",
+    value: function hsv2rgb(h, s, v) {
+      var f = function f(n) {
+        var k = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (n + h / 60) % 6;
+        return v - v * s * Math.max(Math.min(k, 4 - k, 1), 0);
+      };
+      return [f(5), f(3), f(1)];
+    }
+
+    /**
+     * hex 转 rgba 格式字符串 可直接用于css
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param alpha 透明度 0-1  默认1(完全不透明)
+     * @returns 例: rgba(255,255,255,0.5)
+     */
+  }, {
+    key: "hexToRgba",
+    value: function hexToRgba(hex) {
+      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var _this$hexToRgb = this.hexToRgb(hex),
+        _this$hexToRgb2 = _slicedToArray(_this$hexToRgb, 3),
+        r = _this$hexToRgb2[0],
+        g = _this$hexToRgb2[1],
+        b = _this$hexToRgb2[2];
+      var validAlpha = Math.max(0, Math.min(1, alpha));
+      return "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(validAlpha, ")");
+    }
+
+    /**
+     * 给hex颜色添加透明度，返回 8位带透明通道的hex格式 #RRGGBBAA (CSS常用)
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param alpha 透明度 0-1  默认1(完全不透明)
+     * @returns 例: #ffffff80  #ff000033
+     */
+  }, {
+    key: "hexAddAlpha",
+    value: function hexAddAlpha(hex) {
+      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var pureHex = hex.replace('#', '');
+      pureHex = pureHex.length === 3 ? pureHex.split('').map(function (char) {
+        return char + char;
+      }).join('') : pureHex;
+      var validAlpha = Math.max(0, Math.min(1, alpha));
+      var alphaHex = this.twoDigits(Math.round(validAlpha * 255).toString(16));
+      return "#".concat(pureHex).concat(alphaHex);
+    }
+
+    /**
+     * rgba 转 hex 格式
+     * @param r 0-255
+     * @param g 0-255
+     * @param b 0-255
+     */
+  }, {
+    key: "rgbaToHex",
+    value: function rgbaToHex(r, g, b) {
+      return this.rgbToHex(r, g, b);
+    }
+
+    /**
+     * hsv 转 hex 十六进制颜色
+     * @param h 色相 0-360
+     * @param s 饱和度 0-1
+     * @param v 明度 0-1
+     */
+  }, {
+    key: "hsvToHex",
+    value: function hsvToHex(h, s, v) {
+      var _this$hsv2rgb = this.hsv2rgb(h, s, v),
+        _this$hsv2rgb2 = _slicedToArray(_this$hsv2rgb, 3),
+        r = _this$hsv2rgb2[0],
+        g = _this$hsv2rgb2[1],
+        b = _this$hsv2rgb2[2];
+      return this.rgbToHex(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255));
+    }
+
+    /**
+     * hex 转 hsv 格式
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @returns [h:0-360, s:0-1, v:0-1]
+     */
+  }, {
+    key: "hexToHsv",
+    value: function hexToHsv(hex) {
+      var _this$hexToRgb3 = this.hexToRgb(hex),
+        _this$hexToRgb4 = _slicedToArray(_this$hexToRgb3, 3),
+        r = _this$hexToRgb4[0],
+        g = _this$hexToRgb4[1],
+        b = _this$hexToRgb4[2];
+      return this.rgb2hsv(r / 255, g / 255, b / 255);
+    }
+
+    /**
+     * 颜色加深处理 - 基于hex颜色
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param level 加深程度 0-1  0不变 1最深(接近黑色)
+     */
+  }, {
+    key: "darkenColor",
+    value: function darkenColor(hex, level) {
+      var _this$hexToRgb5 = this.hexToRgb(hex),
+        _this$hexToRgb6 = _slicedToArray(_this$hexToRgb5, 3),
+        r = _this$hexToRgb6[0],
+        g = _this$hexToRgb6[1],
+        b = _this$hexToRgb6[2];
+      var clamp = function clamp(val) {
+        return Math.max(0, Math.min(255, val));
+      };
+      var darkR = clamp(r - r * level);
+      var darkG = clamp(g - g * level);
+      var darkB = clamp(b - b * level);
+      return this.rgbToHex(darkR, darkG, darkB);
+    }
+
+    /**
+     * 颜色减淡/提亮处理 - 基于hex颜色
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param level 减淡程度 0-1  0不变 1最亮(接近白色)
+     */
+  }, {
+    key: "lightenColor",
+    value: function lightenColor(hex, level) {
+      var _this$hexToRgb7 = this.hexToRgb(hex),
+        _this$hexToRgb8 = _slicedToArray(_this$hexToRgb7, 3),
+        r = _this$hexToRgb8[0],
+        g = _this$hexToRgb8[1],
+        b = _this$hexToRgb8[2];
+      var clamp = function clamp(val) {
+        return Math.max(0, Math.min(255, val));
+      };
+      var lightR = clamp(r + (255 - r) * level);
+      var lightG = clamp(g + (255 - g) * level);
+      var lightB = clamp(b + (255 - b) * level);
+      return this.rgbToHex(lightR, lightG, lightB);
+    }
+
+    /**
+     * 解析8位带透明的hex #RRGGBBAA 为 普通hex + 透明度
+     * @param hex8 8位带透明的十六进制颜色 例：#ffffff80
+     * @returns { hex: '#ffffff', alpha: 0.5 }
+     */
+  }, {
+    key: "parseHex8",
+    value: function parseHex8(hex8) {
+      var pureHex = hex8.replace('#', '');
+      if (pureHex.length !== 8) return {
+        hex: hex8,
+        alpha: 1
+      };
+      var hex = "#".concat(pureHex.slice(0, 6));
+      var alphaHex = pureHex.slice(6);
+      var alpha = Math.round(parseInt(alphaHex, 16) / 255 * 100) / 100;
+      return {
+        hex: hex,
+        alpha: alpha
+      };
+    }
+
+    /**
+     * rgb 数组 转 rgb/rgba 字符串
+     * @param rgb [r,g,b] 0-255
+     * @param alpha 透明度0-1 传则返回rgba，不传返回rgb
+     */
+  }, {
+    key: "rgbToStr",
+    value: function rgbToStr(rgb, alpha) {
+      var _rgb = _slicedToArray(rgb, 3),
+        r = _rgb[0],
+        g = _rgb[1],
+        b = _rgb[2];
+      return alpha !== undefined ? "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(Math.max(0, Math.min(1, alpha)), ")") : "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")");
+    }
+
+    /**
+     * Hex颜色字符串 转 十进制数值（6位纯颜色值，无透明通道，专用于颜色运算）
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @returns 十进制数值 例：#ff0000 → 16711680，非法入参返回 0
+     */
+  }, {
+    key: "hexToNumber",
+    value: function hexToNumber(hex) {
+      var pureHex = hex.replace('#', '');
+      // 严谨校验：只允许3位/6位纯十六进制颜色，非法值返回0，避免NaN
+      if (!/^[0-9a-fA-F]{3}|[0-9a-fA-F]{6}$/.test(pureHex)) {
+        return 0;
+      }
+      return parseInt(pureHex, 16);
+    }
+
+    /**
+     * 十进制数值 转回 Hex颜色字符串（无透明通道 标准6位）
+     * @param num 十进制数值 例：16711680 → #ff0000
+     * @returns 标准6位十六进制颜色 #RRGGBB 格式
+     */
+  }, {
+    key: "numberToHex",
+    value: function numberToHex(num) {
+      // 位运算拆解R/G/B通道，值范围永远0-255，再转16进制字符串+补零
+      var r = this.twoDigits((num >> 16 & 255).toString(16));
+      var g = this.twoDigits((num >> 8 & 255).toString(16));
+      var b = this.twoDigits((num & 255).toString(16));
+      return "#".concat(r).concat(g).concat(b);
+    }
+
+    /**
+     * ARGB颜色字符串 转 十进制数值（8位带透明通道，专用于带透明的颜色运算）
+     * @param argb 支持 #AARRGGBB / AARRGGBB 格式 例：#80FFFFFF、80FFFFFF
+     * @returns 十进制数值 例：#80FFFFFF → 2147483647，非法入参/格式错误返回 0
+     */
+  }, {
+    key: "argbToNumber",
+    value: function argbToNumber(argb) {
+      var pureArgb = argb.replace('#', '');
+      if (!/^[0-9a-fA-F]{8}$/.test(pureArgb)) {
+        return 0;
+      }
+      return parseInt(pureArgb, 16);
+    }
+
+    /**
+     * 十进制数值 转回 ARGB颜色字符串（8位带透明通道，标准#AARRGGBB格式）
+     * @param num 十进制数值 例：2147483647 → #80ffffff
+     * @returns 标准ARGB颜色字符串 #AARRGGBB 小写格式
+     */
+  }, {
+    key: "numberToArgb",
+    value: function numberToArgb(num) {
+      var a = this.twoDigits((num >> 24 & 255).toString(16));
+      var r = this.twoDigits((num >> 16 & 255).toString(16));
+      var g = this.twoDigits((num >> 8 & 255).toString(16));
+      var b = this.twoDigits((num & 255).toString(16));
+      return "#".concat(a).concat(r).concat(g).concat(b);
+    }
+
+    /**
+     * 生成随机Hex颜色
+     * @param withSharp 是否带#号 默认为true
+     * @returns 随机hex颜色
+     */
+  }, {
+    key: "randomHexColor",
+    value: function randomHexColor() {
+      var withSharp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      var hex = this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16)) + this.twoDigits(Math.floor(Math.random() * 16).toString(16));
+      return withSharp ? "#".concat(hex) : hex;
+    }
+
+    /**
+     * 反色处理 - 取颜色的补色（比如黑色→白色，白色→黑色）
+     * @param hex 目标颜色
+     * @returns 反色hex
+     */
+  }, {
+    key: "reverseColor",
+    value: function reverseColor(hex) {
+      var _this$hexToRgb9 = this.hexToRgb(hex),
+        _this$hexToRgb10 = _slicedToArray(_this$hexToRgb9, 3),
+        r = _this$hexToRgb10[0],
+        g = _this$hexToRgb10[1],
+        b = _this$hexToRgb10[2];
+      return this.rgbToHex(255 - r, 255 - g, 255 - b);
+    }
+
+    /**
+     * 校验是否为合法的hex颜色
+     * @param hex 待校验的颜色字符串
+     * @returns true=合法 false=不合法
+     */
+  }, {
+    key: "isHexColor",
+    value: function isHexColor(hex) {
+      return /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(hex);
+    }
+
+    /**
+     * 标准6位Hex颜色 转 ARGB 8位颜色格式 ( 核心：ARGB格式是 #AARRGGBB )
+     * @param hex 6位标准hex 支持 #ffffff / ffffff / #fff / fff
+     * @param alpha 透明度 0~1  默认 1 (完全不透明)
+     * @returns 8位ARGB格式颜色 例：#80FFFFFF  半透明白色
+     */
+  }, {
+    key: "hexToArgb",
+    value: function hexToArgb(hex) {
+      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var pureHex = hex.replace('#', '');
+      if (pureHex.length === 3) {
+        pureHex = pureHex.split('').map(function (char) {
+          return char + char;
+        }).join('');
+      }
+      var validAlpha = Math.max(0, Math.min(1, alpha));
+      var alphaHex = this.twoDigits(Math.round(validAlpha * 255).toString(16));
+      return "#".concat(alphaHex).concat(pureHex);
+    }
+
+    /**
+     * ARGB 8位颜色格式 转回 标准6位Hex颜色 + 独立的透明度值 ( 反向解析 )
+     * @param argb 8位ARGB格式颜色 必须是 #AARRGGBB 格式 例：#80FFFFFF
+     * @returns { hex: '#ffffff', alpha: 0.5 } 标准hex + 0~1的透明度
+     */
+  }, {
+    key: "argbToHex",
+    value: function argbToHex(argb) {
+      var pureArgb = argb.replace('#', '');
+      if (pureArgb.length !== 8) {
+        console.warn('传入的不是合法的ARGB格式，格式必须是 #AARRGGBB');
+        return {
+          hex: argb,
+          alpha: 1
+        };
+      }
+      var alphaHex = pureArgb.slice(0, 2);
+      var hexVal = pureArgb.slice(2);
+      var alpha = Math.round(parseInt(alphaHex, 16) / 255 * 100) / 100;
+      return {
+        hex: "#".concat(hexVal),
+        alpha: alpha
+      };
+    }
+
+    /**
+     * ARGB格式(#AARRGGBB) 转 RRGGBBAA格式(#RRGGBBAA)
+     * @param argb #AARRGGBB
+     * @returns #RRGGBBAA
+     */
+  }, {
+    key: "argbToRgbaHex",
+    value: function argbToRgbaHex(argb) {
+      var pureArgb = argb.replace('#', '');
+      if (pureArgb.length !== 8) return argb;
+      return "#".concat(pureArgb.slice(2)).concat(pureArgb.slice(0, 2));
+    }
+
+    /**
+     * RRGGBBAA格式(#RRGGBBAA) 转 ARGB格式(#AARRGGBB)
+     * @param rgbaHex #RRGGBBAA
+     * @returns #AARRGGBB
+     */
+  }, {
+    key: "rgbaHexToArgb",
+    value: function rgbaHexToArgb(rgbaHex) {
+      var pureRgba = rgbaHex.replace('#', '');
+      if (pureRgba.length !== 8) return rgbaHex;
+      return "#".concat(pureRgba.slice(6)).concat(pureRgba.slice(0, 6));
+    }
+
+    /**
+     * 调整颜色饱和度
+     * @param hex 目标颜色
+     * @param level 调整程度 0-2  1=不变  <1=降低饱和度  >1=提高饱和度
+     * @returns 调整后的hex颜色
+     */
+  }, {
+    key: "adjustSaturation",
+    value: function adjustSaturation(hex, level) {
+      var _this$hexToHsv = this.hexToHsv(hex),
+        _this$hexToHsv2 = _slicedToArray(_this$hexToHsv, 3),
+        h = _this$hexToHsv2[0],
+        s = _this$hexToHsv2[1],
+        v = _this$hexToHsv2[2];
+      var newS = Math.max(0, Math.min(1, s * level));
+      return this.hsvToHex(h, newS, v);
+    }
+
+    /**
+     * 调整颜色明度
+     * @param hex 目标颜色
+     * @param level 调整程度 0-2  1=不变  <1=降低明度  >1=提高明度
+     * @returns 调整后的hex颜色
+     */
+  }, {
+    key: "adjustBrightness",
+    value: function adjustBrightness(hex, level) {
+      var _this$hexToHsv3 = this.hexToHsv(hex),
+        _this$hexToHsv4 = _slicedToArray(_this$hexToHsv3, 3),
+        h = _this$hexToHsv4[0],
+        s = _this$hexToHsv4[1],
+        v = _this$hexToHsv4[2];
+      var newV = Math.max(0, Math.min(1, v * level));
+      return this.hsvToHex(h, s, newV);
+    }
+
+    /**
+     * 普通6位Hex+透明度 → 直接返回ARGB对应的十进制数值
+     * @param hex 支持 #fff / #ffffff 格式
+     * @param alpha 透明度 0-1
+     * @returns ARGB十进制数值
+     */
+  }, {
+    key: "hexAlphaToArgbNumber",
+    value: function hexAlphaToArgbNumber(hex) {
+      var alpha = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var argbStr = this.hexToArgb(hex, alpha);
+      return this.argbToNumber(argbStr);
+    }
+
+    /**
+     * ARGB十进制数值 → 解析出 普通Hex + 0-1透明度
+     * @param num ARGB十进制数值
+     * @returns { hex: '#ffffff', alpha: 0.5 }
+     */
+  }, {
+    key: "argbNumberToHexAlpha",
+    value: function argbNumberToHexAlpha(num) {
+      var argbStr = this.numberToArgb(num);
+      return this.argbToHex(argbStr);
+    }
+
+    /**
+     * 补零成两位字符
+     */
+  }, {
+    key: "twoDigits",
+    value: function twoDigits(num) {
+      var s = num.toString();
+      return s.length === 1 ? '0' + s : s;
+    }
+  }]);
+  return CrColorUtil;
+}();
+export { CrColorUtil as default };

package/dist/esm/index.d.ts

@@ -1,8 +1,9 @@
+export { default as CrColorUtil } from './color';
 export type * from './eventCenter';
 export { default as CrEventCenter } from './eventCenter';
-export type * from './objUtil';
-export { default as CrObjUtil } from './objUtil';
+export type * from './obj';
+export { default as CrObjUtil } from './obj';
 export { default as CrStorage } from './storage';
-export type * from './treeUtil';
-export { default as CrTreeUtil } from './treeUtil';
+export type * from './tree';
+export { default as CrTreeUtil } from './tree';
 export { default as CrUtil } from './util';

package/dist/esm/index.js

@@ -1,5 +1,6 @@
+export { default as CrColorUtil } from "./color";
 export { default as CrEventCenter } from "./eventCenter";
-export { default as CrObjUtil } from "./objUtil";
+export { default as CrObjUtil } from "./obj";
 export { default as CrStorage } from "./storage";
-export { default as CrTreeUtil } from "./treeUtil";
+export { default as CrTreeUtil } from "./tree";
 export { default as CrUtil } from "./util";

package/dist/{cjs/treeUtil.d.ts → esm/tree.d.ts}

@@ -21,13 +21,17 @@ export default class CrTreeUtil {
      * 树形数据转列表数据
      * @param tree
      * @param options
+     * @param options.idField 默认值 id
+     * @param options.parentIdField 默认值 parentId
      * @param options.childrenField 默认值 children
-     * @param options.isCloneDeep 是否需要深拷贝, 默认值为 true
+     * @param options.rootParentValue 根节点的父值，默认值 null
      * @returns
      */
     static treeToList<T extends Record<string, any>>(tree: T[], options?: {
+        idField?: string;
+        parentIdField?: string;
         childrenField?: string;
-        isCloneDeep?: boolean;
+        rootParentValue?: any;
     }): T[];
     /**
      * 获取扁平化父数据(包含自身)

package/dist/esm/{treeUtil.js → tree.js}

@@ -17,6 +17,7 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { cloneDeep as _cloneDeep, find as _find, get as _get, keyBy as _keyBy } from 'lodash';
+import CrUtil from "./util";
 var CrTreeUtil = /*#__PURE__*/function () {
   function CrTreeUtil() {
     _classCallCheck(this, CrTreeUtil);
@@ -116,31 +117,59 @@ var CrTreeUtil = /*#__PURE__*/function () {
      * 树形数据转列表数据
      * @param tree
      * @param options
+     * @param options.idField 默认值 id
+     * @param options.parentIdField 默认值 parentId
      * @param options.childrenField 默认值 children
-     * @param options.isCloneDeep 是否需要深拷贝, 默认值为 true
+     * @param options.rootParentValue 根节点的父值，默认值 null
      * @returns
      */
   }, {
     key: "treeToList",
     value: function treeToList(tree, options) {
       var _ref2 = options || {},
+        _ref2$idField = _ref2.idField,
+        idField = _ref2$idField === void 0 ? 'id' : _ref2$idField,
+        _ref2$parentIdField = _ref2.parentIdField,
+        parentIdField = _ref2$parentIdField === void 0 ? 'parentId' : _ref2$parentIdField,
         _ref2$childrenField = _ref2.childrenField,
         childrenField = _ref2$childrenField === void 0 ? 'children' : _ref2$childrenField,
-        _ref2$isCloneDeep = _ref2.isCloneDeep,
-        isCloneDeep = _ref2$isCloneDeep === void 0 ? true : _ref2$isCloneDeep;
+        _ref2$rootParentValue = _ref2.rootParentValue,
+        rootParentValue = _ref2$rootParentValue === void 0 ? null : _ref2$rootParentValue;
       var result = [];
-      var queue = _toConsumableArray(tree);
-      while (queue.length) {
-        var node = queue.shift();
+      var originQueue = _cloneDeep(_toConsumableArray(tree));
+      var queue = originQueue.map(function (node) {
+        return {
+          node: node,
+          parentId: rootParentValue
+        };
+      });
+      var _loop = function _loop() {
+        var _ref3 = queue.shift(),
+          node = _ref3.node,
+          parentId = _ref3.parentId;
+        if (!node || !CrUtil.isObject(node)) {
+          return 1; // continue
+        }
         var children = node[childrenField];
+        var nodeId = node[idField];
         var _ = node[childrenField],
           rest = _objectWithoutProperties(node, [childrenField].map(_toPropertyKey));
-        result.push(rest);
-        if (children && children.length) {
-          queue.push.apply(queue, _toConsumableArray(children));
+        var flatNode = _objectSpread(_objectSpread({}, rest), {}, _defineProperty({}, parentIdField, parentId));
+        result.push(flatNode);
+        if (children && CrUtil.isArray(children) && children.length > 0) {
+          var childQueue = children.map(function (childNode) {
+            return {
+              node: childNode,
+              parentId: nodeId
+            };
+          });
+          queue.push.apply(queue, _toConsumableArray(childQueue));
         }
+      };
+      while (queue.length) {
+        if (_loop()) continue;
       }
-      return isCloneDeep ? _cloneDeep(result) : result;
+      return result;
     }
 
     /**

package/dist/esm/util.d.ts

@@ -10,7 +10,7 @@ export default class CrUtil {
      * @param value
      * @returns boolean
      */
-    static isObject<T = any>(value: T): value is T extends object ? (T extends any[] ? never : T) : never;
+    static isObject(value: unknown): value is Record<string | number, unknown>;
     /**
      * 判断是否为空对象
      * @param value
@@ -91,7 +91,7 @@ export default class CrUtil {
      * @param settings.idField 默认值 id
      * @param settings.pidField 默认值 parentId
      * @param settings.childrenField 默认值 children
-     * @deprecated 即将移除，使用 {@link CrObjUtil.listToTree} 替代
+     * @deprecated 即将移除，使用 {@link CrTreeUtil.listToTree} 替代
      * @returns
      */
     static listToTreeData(listData: any[], settings?: {
@@ -108,7 +108,7 @@ export default class CrUtil {
      * @param settings.idField 默认值 id
      * @param settings.pidField 默认值 parentId
      * @param settings.childrenField 默认值 children
-     * @deprecated 即将移除，使用 {@link CrObjUtil.treeToList} 替代
+     * @deprecated 即将移除，使用 {@link CrTreeUtil.treeToList} 替代
      * @returns
      */
     static treeDataToListData(treeData: any[], pid?: string | number, settings?: {
@@ -125,7 +125,7 @@ export default class CrUtil {
      * @param settings.valueField 默认值 value
      * @param settings.idField 默认值 id
      * @param settings.pidField 默认值 parentId
-     * @deprecated 即将移除，使用 {@link CrObjUtil.getFlatParentDatas} 替代
+     * @deprecated 即将移除，使用 {@link CrTreeUtil.getFlatParentDatas} 替代
      * @returns
      */
     static getParentNodes<T, R extends Record<string, any>>(listData: R[], value: number | string, settings?: {
@@ -201,9 +201,21 @@ export default class CrUtil {
      */
     static compareDataDiff(data1: any, data2: any): Record<string, "added" | "removed" | "modified">;
     /**
-     * 格式化为千分位
+     * 格式化为千分位，主要用于展示格式化
      * @param value
      * @returns 12345.6789 => 12,345.6789
      */
     static fmtThousands(value: number | string | undefined): string;
+    /**
+     * 格式化为千分位格式
+     * @param value
+     * @returns
+     */
+    static formatThousands(value?: string | number): string;
+    /**
+     * 解析千分位格式
+     * @param value
+     * @returns
+     */
+    static parseThousands(value?: string | number): string;
 }