@zcrkey/js-utils 0.0.6 → 0.0.9

package/dist/cjs/color.d.ts

@@ -0,0 +1,195 @@
+export default class CrColorUtil {
+    /**
+     * hex 转 rgb 数组 [r,g,b]  r/g/b范围 0-255
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     */
+    static hexToRgb(hex: string): number[];
+    /**
+     * rgb 转 hex 标准格式
+     * @param r 0-255
+     * @param g 0-255
+     * @param b 0-255
+     */
+    static rgbToHex(r: number, g: number, b: number): string;
+    /**
+     * 将 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
+     */
+    static rgb2hsv(r: number, g: number, b: number): number[];
+    /**
+     * 将 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
+     */
+    static hsv2rgb(h: number, s: number, v: number): number[];
+    /**
+     * hex 转 rgba 格式字符串 可直接用于css
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param alpha 透明度 0-1  默认1(完全不透明)
+     * @returns 例: rgba(255,255,255,0.5)
+     */
+    static hexToRgba(hex: string, alpha?: number): string;
+    /**
+     * 给hex颜色添加透明度，返回 8位带透明通道的hex格式 #RRGGBBAA (CSS常用)
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param alpha 透明度 0-1  默认1(完全不透明)
+     * @returns 例: #ffffff80  #ff000033
+     */
+    static hexAddAlpha(hex: string, alpha?: number): string;
+    /**
+     * rgba 转 hex 格式
+     * @param r 0-255
+     * @param g 0-255
+     * @param b 0-255
+     */
+    static rgbaToHex(r: number, g: number, b: number): string;
+    /**
+     * hsv 转 hex 十六进制颜色
+     * @param h 色相 0-360
+     * @param s 饱和度 0-1
+     * @param v 明度 0-1
+     */
+    static hsvToHex(h: number, s: number, v: number): string;
+    /**
+     * hex 转 hsv 格式
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @returns [h:0-360, s:0-1, v:0-1]
+     */
+    static hexToHsv(hex: string): number[];
+    /**
+     * 颜色加深处理 - 基于hex颜色
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param level 加深程度 0-1  0不变 1最深(接近黑色)
+     */
+    static darkenColor(hex: string, level: number): string;
+    /**
+     * 颜色减淡/提亮处理 - 基于hex颜色
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @param level 减淡程度 0-1  0不变 1最亮(接近白色)
+     */
+    static lightenColor(hex: string, level: number): string;
+    /**
+     * 解析8位带透明的hex #RRGGBBAA 为 普通hex + 透明度
+     * @param hex8 8位带透明的十六进制颜色 例：#ffffff80
+     * @returns { hex: '#ffffff', alpha: 0.5 }
+     */
+    static parseHex8(hex8: string): {
+        hex: string;
+        alpha: number;
+    };
+    /**
+     * rgb 数组 转 rgb/rgba 字符串
+     * @param rgb [r,g,b] 0-255
+     * @param alpha 透明度0-1 传则返回rgba，不传返回rgb
+     */
+    static rgbToStr(rgb: number[], alpha?: number): string;
+    /**
+     * Hex颜色字符串 转 十进制数值（6位纯颜色值，无透明通道，专用于颜色运算）
+     * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+     * @returns 十进制数值 例：#ff0000 → 16711680，非法入参返回 0
+     */
+    static hexToNumber(hex: string): number;
+    /**
+     * 十进制数值 转回 Hex颜色字符串（无透明通道 标准6位）
+     * @param num 十进制数值 例：16711680 → #ff0000
+     * @returns 标准6位十六进制颜色 #RRGGBB 格式
+     */
+    static numberToHex(num: number): string;
+    /**
+     * ARGB颜色字符串 转 十进制数值（8位带透明通道，专用于带透明的颜色运算）
+     * @param argb 支持 #AARRGGBB / AARRGGBB 格式 例：#80FFFFFF、80FFFFFF
+     * @returns 十进制数值 例：#80FFFFFF → 2147483647，非法入参/格式错误返回 0
+     */
+    static argbToNumber(argb: string): number;
+    /**
+     * 十进制数值 转回 ARGB颜色字符串（8位带透明通道，标准#AARRGGBB格式）
+     * @param num 十进制数值 例：2147483647 → #80ffffff
+     * @returns 标准ARGB颜色字符串 #AARRGGBB 小写格式
+     */
+    static numberToArgb(num: number): string;
+    /**
+     * 生成随机Hex颜色
+     * @param withSharp 是否带#号 默认为true
+     * @returns 随机hex颜色
+     */
+    static randomHexColor(withSharp?: boolean): string;
+    /**
+     * 反色处理 - 取颜色的补色（比如黑色→白色，白色→黑色）
+     * @param hex 目标颜色
+     * @returns 反色hex
+     */
+    static reverseColor(hex: string): string;
+    /**
+     * 校验是否为合法的hex颜色
+     * @param hex 待校验的颜色字符串
+     * @returns true=合法 false=不合法
+     */
+    static isHexColor(hex: string): boolean;
+    /**
+     * 标准6位Hex颜色 转 ARGB 8位颜色格式 ( 核心：ARGB格式是 #AARRGGBB )
+     * @param hex 6位标准hex 支持 #ffffff / ffffff / #fff / fff
+     * @param alpha 透明度 0~1  默认 1 (完全不透明)
+     * @returns 8位ARGB格式颜色 例：#80FFFFFF  半透明白色
+     */
+    static hexToArgb(hex: string, alpha?: number): string;
+    /**
+     * ARGB 8位颜色格式 转回 标准6位Hex颜色 + 独立的透明度值 ( 反向解析 )
+     * @param argb 8位ARGB格式颜色 必须是 #AARRGGBB 格式 例：#80FFFFFF
+     * @returns { hex: '#ffffff', alpha: 0.5 } 标准hex + 0~1的透明度
+     */
+    static argbToHex(argb: string): {
+        hex: string;
+        alpha: number;
+    };
+    /**
+     * ARGB格式(#AARRGGBB) 转 RRGGBBAA格式(#RRGGBBAA)
+     * @param argb #AARRGGBB
+     * @returns #RRGGBBAA
+     */
+    static argbToRgbaHex(argb: string): string;
+    /**
+     * RRGGBBAA格式(#RRGGBBAA) 转 ARGB格式(#AARRGGBB)
+     * @param rgbaHex #RRGGBBAA
+     * @returns #AARRGGBB
+     */
+    static rgbaHexToArgb(rgbaHex: string): string;
+    /**
+     * 调整颜色饱和度
+     * @param hex 目标颜色
+     * @param level 调整程度 0-2  1=不变  <1=降低饱和度  >1=提高饱和度
+     * @returns 调整后的hex颜色
+     */
+    static adjustSaturation(hex: string, level: number): string;
+    /**
+     * 调整颜色明度
+     * @param hex 目标颜色
+     * @param level 调整程度 0-2  1=不变  <1=降低明度  >1=提高明度
+     * @returns 调整后的hex颜色
+     */
+    static adjustBrightness(hex: string, level: number): string;
+    /**
+     * 普通6位Hex+透明度 → 直接返回ARGB对应的十进制数值
+     * @param hex 支持 #fff / #ffffff 格式
+     * @param alpha 透明度 0-1
+     * @returns ARGB十进制数值
+     */
+    static hexAlphaToArgbNumber(hex: string, alpha?: number): number;
+    /**
+     * ARGB十进制数值 → 解析出 普通Hex + 0-1透明度
+     * @param num ARGB十进制数值
+     * @returns { hex: '#ffffff', alpha: 0.5 }
+     */
+    static argbNumberToHexAlpha(num: number): {
+        hex: string;
+        alpha: number;
+    };
+    /**
+     * 补零成两位字符
+     */
+    private static twoDigits;
+}

package/dist/cjs/color.js

@@ -0,0 +1,357 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/color.ts
+var color_exports = {};
+__export(color_exports, {
+  default: () => CrColorUtil
+});
+module.exports = __toCommonJS(color_exports);
+var CrColorUtil = class {
+  /**
+   * hex 转 rgb 数组 [r,g,b]  r/g/b范围 0-255
+   * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+   */
+  static hexToRgb(hex) {
+    let hexVal = hex.replace("#", "");
+    if (hexVal.length === 3) {
+      hexVal = hexVal.split("").map((c) => c + c).join("");
+    }
+    const hexInt = parseInt(hexVal, 16);
+    const r = hexInt >> 16 & 255;
+    const g = hexInt >> 8 & 255;
+    const b = hexInt & 255;
+    return [r, g, b];
+  }
+  /**
+   * rgb 转 hex 标准格式
+   * @param r 0-255
+   * @param g 0-255
+   * @param b 0-255
+   */
+  static rgbToHex(r, g, b) {
+    const clamp = (val) => Math.max(0, Math.min(255, Math.round(val)));
+    const red = clamp(r);
+    const green = clamp(g);
+    const 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
+   */
+  static rgb2hsv(r, g, b) {
+    let v = Math.max(r, g, b);
+    let n = v - Math.min(r, g, b);
+    let 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
+   */
+  static hsv2rgb(h, s, v) {
+    let f = (n, k = (n + h / 60) % 6) => 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)
+   */
+  static hexToRgba(hex, alpha = 1) {
+    const [r, g, b] = this.hexToRgb(hex);
+    const validAlpha = Math.max(0, Math.min(1, alpha));
+    return `rgba(${r}, ${g}, ${b}, ${validAlpha})`;
+  }
+  /**
+   * 给hex颜色添加透明度，返回 8位带透明通道的hex格式 #RRGGBBAA (CSS常用)
+   * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+   * @param alpha 透明度 0-1  默认1(完全不透明)
+   * @returns 例: #ffffff80  #ff000033
+   */
+  static hexAddAlpha(hex, alpha = 1) {
+    let pureHex = hex.replace("#", "");
+    pureHex = pureHex.length === 3 ? pureHex.split("").map((char) => char + char).join("") : pureHex;
+    const validAlpha = Math.max(0, Math.min(1, alpha));
+    const alphaHex = this.twoDigits(Math.round(validAlpha * 255).toString(16));
+    return `#${pureHex}${alphaHex}`;
+  }
+  /**
+   * rgba 转 hex 格式
+   * @param r 0-255
+   * @param g 0-255
+   * @param b 0-255
+   */
+  static rgbaToHex(r, g, b) {
+    return this.rgbToHex(r, g, b);
+  }
+  /**
+   * hsv 转 hex 十六进制颜色
+   * @param h 色相 0-360
+   * @param s 饱和度 0-1
+   * @param v 明度 0-1
+   */
+  static hsvToHex(h, s, v) {
+    const [r, g, b] = this.hsv2rgb(h, s, v);
+    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]
+   */
+  static hexToHsv(hex) {
+    const [r, g, b] = this.hexToRgb(hex);
+    return this.rgb2hsv(r / 255, g / 255, b / 255);
+  }
+  /**
+   * 颜色加深处理 - 基于hex颜色
+   * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+   * @param level 加深程度 0-1  0不变 1最深(接近黑色)
+   */
+  static darkenColor(hex, level) {
+    const [r, g, b] = this.hexToRgb(hex);
+    const clamp = (val) => Math.max(0, Math.min(255, val));
+    const darkR = clamp(r - r * level);
+    const darkG = clamp(g - g * level);
+    const darkB = clamp(b - b * level);
+    return this.rgbToHex(darkR, darkG, darkB);
+  }
+  /**
+   * 颜色减淡/提亮处理 - 基于hex颜色
+   * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+   * @param level 减淡程度 0-1  0不变 1最亮(接近白色)
+   */
+  static lightenColor(hex, level) {
+    const [r, g, b] = this.hexToRgb(hex);
+    const clamp = (val) => Math.max(0, Math.min(255, val));
+    const lightR = clamp(r + (255 - r) * level);
+    const lightG = clamp(g + (255 - g) * level);
+    const 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 }
+   */
+  static parseHex8(hex8) {
+    const pureHex = hex8.replace("#", "");
+    if (pureHex.length !== 8)
+      return { hex: hex8, alpha: 1 };
+    const hex = `#${pureHex.slice(0, 6)}`;
+    const alphaHex = pureHex.slice(6);
+    const alpha = Math.round(parseInt(alphaHex, 16) / 255 * 100) / 100;
+    return { hex, alpha };
+  }
+  /**
+   * rgb 数组 转 rgb/rgba 字符串
+   * @param rgb [r,g,b] 0-255
+   * @param alpha 透明度0-1 传则返回rgba，不传返回rgb
+   */
+  static rgbToStr(rgb, alpha) {
+    const [r, g, b] = rgb;
+    return alpha !== void 0 ? `rgba(${r}, ${g}, ${b}, ${Math.max(0, Math.min(1, alpha))})` : `rgb(${r}, ${g}, ${b})`;
+  }
+  /**
+   * Hex颜色字符串 转 十进制数值（6位纯颜色值，无透明通道，专用于颜色运算）
+   * @param hex 支持 #fff / #ffffff / fff / ffffff 格式
+   * @returns 十进制数值 例：#ff0000 → 16711680，非法入参返回 0
+   */
+  static hexToNumber(hex) {
+    const pureHex = hex.replace("#", "");
+    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 格式
+   */
+  static numberToHex(num) {
+    const r = this.twoDigits((num >> 16 & 255).toString(16));
+    const g = this.twoDigits((num >> 8 & 255).toString(16));
+    const b = this.twoDigits((num & 255).toString(16));
+    return `#${r}${g}${b}`;
+  }
+  /**
+   * ARGB颜色字符串 转 十进制数值（8位带透明通道，专用于带透明的颜色运算）
+   * @param argb 支持 #AARRGGBB / AARRGGBB 格式 例：#80FFFFFF、80FFFFFF
+   * @returns 十进制数值 例：#80FFFFFF → 2147483647，非法入参/格式错误返回 0
+   */
+  static argbToNumber(argb) {
+    const 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 小写格式
+   */
+  static numberToArgb(num) {
+    const a = this.twoDigits((num >> 24 & 255).toString(16));
+    const r = this.twoDigits((num >> 16 & 255).toString(16));
+    const g = this.twoDigits((num >> 8 & 255).toString(16));
+    const b = this.twoDigits((num & 255).toString(16));
+    return `#${a}${r}${g}${b}`;
+  }
+  /**
+   * 生成随机Hex颜色
+   * @param withSharp 是否带#号 默认为true
+   * @returns 随机hex颜色
+   */
+  static randomHexColor(withSharp = true) {
+    const 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 ? `#${hex}` : hex;
+  }
+  /**
+   * 反色处理 - 取颜色的补色（比如黑色→白色，白色→黑色）
+   * @param hex 目标颜色
+   * @returns 反色hex
+   */
+  static reverseColor(hex) {
+    const [r, g, b] = this.hexToRgb(hex);
+    return this.rgbToHex(255 - r, 255 - g, 255 - b);
+  }
+  /**
+   * 校验是否为合法的hex颜色
+   * @param hex 待校验的颜色字符串
+   * @returns true=合法 false=不合法
+   */
+  static 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  半透明白色
+   */
+  static hexToArgb(hex, alpha = 1) {
+    let pureHex = hex.replace("#", "");
+    if (pureHex.length === 3) {
+      pureHex = pureHex.split("").map((char) => char + char).join("");
+    }
+    const validAlpha = Math.max(0, Math.min(1, alpha));
+    const alphaHex = this.twoDigits(Math.round(validAlpha * 255).toString(16));
+    return `#${alphaHex}${pureHex}`;
+  }
+  /**
+   * ARGB 8位颜色格式 转回 标准6位Hex颜色 + 独立的透明度值 ( 反向解析 )
+   * @param argb 8位ARGB格式颜色 必须是 #AARRGGBB 格式 例：#80FFFFFF
+   * @returns { hex: '#ffffff', alpha: 0.5 } 标准hex + 0~1的透明度
+   */
+  static argbToHex(argb) {
+    const pureArgb = argb.replace("#", "");
+    if (pureArgb.length !== 8) {
+      console.warn("传入的不是合法的ARGB格式，格式必须是 #AARRGGBB");
+      return { hex: argb, alpha: 1 };
+    }
+    const alphaHex = pureArgb.slice(0, 2);
+    const hexVal = pureArgb.slice(2);
+    const alpha = Math.round(parseInt(alphaHex, 16) / 255 * 100) / 100;
+    return { hex: `#${hexVal}`, alpha };
+  }
+  /**
+   * ARGB格式(#AARRGGBB) 转 RRGGBBAA格式(#RRGGBBAA)
+   * @param argb #AARRGGBB
+   * @returns #RRGGBBAA
+   */
+  static argbToRgbaHex(argb) {
+    const pureArgb = argb.replace("#", "");
+    if (pureArgb.length !== 8)
+      return argb;
+    return `#${pureArgb.slice(2)}${pureArgb.slice(0, 2)}`;
+  }
+  /**
+   * RRGGBBAA格式(#RRGGBBAA) 转 ARGB格式(#AARRGGBB)
+   * @param rgbaHex #RRGGBBAA
+   * @returns #AARRGGBB
+   */
+  static rgbaHexToArgb(rgbaHex) {
+    const pureRgba = rgbaHex.replace("#", "");
+    if (pureRgba.length !== 8)
+      return rgbaHex;
+    return `#${pureRgba.slice(6)}${pureRgba.slice(0, 6)}`;
+  }
+  /**
+   * 调整颜色饱和度
+   * @param hex 目标颜色
+   * @param level 调整程度 0-2  1=不变  <1=降低饱和度  >1=提高饱和度
+   * @returns 调整后的hex颜色
+   */
+  static adjustSaturation(hex, level) {
+    const [h, s, v] = this.hexToHsv(hex);
+    const 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颜色
+   */
+  static adjustBrightness(hex, level) {
+    const [h, s, v] = this.hexToHsv(hex);
+    const 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十进制数值
+   */
+  static hexAlphaToArgbNumber(hex, alpha = 1) {
+    const argbStr = this.hexToArgb(hex, alpha);
+    return this.argbToNumber(argbStr);
+  }
+  /**
+   * ARGB十进制数值 → 解析出 普通Hex + 0-1透明度
+   * @param num ARGB十进制数值
+   * @returns { hex: '#ffffff', alpha: 0.5 }
+   */
+  static argbNumberToHexAlpha(num) {
+    const argbStr = this.numberToArgb(num);
+    return this.argbToHex(argbStr);
+  }
+  /**
+   * 补零成两位字符
+   */
+  static twoDigits(num) {
+    const s = num.toString();
+    return s.length === 1 ? "0" + s : s;
+  }
+};

package/dist/cjs/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/cjs/index.js

@@ -29,20 +29,23 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  CrColorUtil: () => import_color.default,
   CrEventCenter: () => import_eventCenter.default,
-  CrObjUtil: () => import_objUtil.default,
+  CrObjUtil: () => import_obj.default,
   CrStorage: () => import_storage.default,
-  CrTreeUtil: () => import_treeUtil.default,
+  CrTreeUtil: () => import_tree.default,
   CrUtil: () => import_util.default
 });
 module.exports = __toCommonJS(src_exports);
+var import_color = __toESM(require("./color"));
 var import_eventCenter = __toESM(require("./eventCenter"));
-var import_objUtil = __toESM(require("./objUtil"));
+var import_obj = __toESM(require("./obj"));
 var import_storage = __toESM(require("./storage"));
-var import_treeUtil = __toESM(require("./treeUtil"));
+var import_tree = __toESM(require("./tree"));
 var import_util = __toESM(require("./util"));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CrColorUtil,
   CrEventCenter,
   CrObjUtil,
   CrStorage,

package/dist/cjs/{objUtil.js → obj.js}

@@ -16,12 +16,12 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/objUtil.ts
-var objUtil_exports = {};
-__export(objUtil_exports, {
+// src/obj.ts
+var obj_exports = {};
+__export(obj_exports, {
   default: () => CrObjUtil
 });
-module.exports = __toCommonJS(objUtil_exports);
+module.exports = __toCommonJS(obj_exports);
 var import_lodash = require("lodash");
 var CrObjUtil = class {
   /**

package/dist/{esm/treeUtil.d.ts → cjs/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[];
     /**
      * 获取扁平化父数据(包含自身)