declare function isUndefined(obj: any): obj is undefined; declare function isClass(value: unknown): boolean; declare function isExist(obj: any): boolean; declare function isWindow(el: any): el is Window; declare function isPhone(phone: unknown): boolean; declare function isEmail(email: unknown): boolean; /** * 对象本地存储 */ declare class ObjectLocalStorage { /** * 设置Deep数据 * @param key * @param rootKey * @param value */ static set(key: unknown, rootKey: unknown, value: unknown): boolean; /** * 获取Deep数据 * @param key * @param rootKey */ static get(key: unknown, rootKey: unknown): any; /** * 删除Deep数据（清空叶子属性） * @param key * @param rootKey */ static delete(key: unknown, rootKey: unknown): void; /** * 清空ObjectLocalStorage数据，置为空对象 * @param key */ static clear(key: unknown): boolean; } /** * 将指定的文本写入粘贴板 * @param text 需要写入的文本 * @returns Promise 是否写入成功 */ declare function writeClipboard(text: string): Promise; /** * 从剪贴板读取文本内容 * @returns Promise 返回剪贴板文本内容，失败时返回null */ declare function readClipboard(): Promise; interface RGB extends Record { r: number; g: number; b: number; a?: number; } interface RGBColor extends RGB { a?: 1; format?: 'name' | 'rgb'; } interface RGBAColor extends RGB { a: number; format?: 'name' | 'rgba'; } interface HEX3Color extends RGB { a?: 1; format?: 'name' | 'hex3'; } interface HEX4Color extends RGB { a: number; format?: 'name' | 'hex4'; } interface HEX6Color extends RGB { a?: 1; format?: 'name' | 'hex6'; } interface HEX8Color extends RGB { a: number; format?: 'name' | 'hex8'; } interface HSL extends Record { h: number; s: number; l: number; a?: number; } interface HSLColor extends HSL { a?: 1; format?: 'name' | 'hsl'; } interface HSLAColor extends HSL { a: number; format?: 'name' | 'hsla'; } interface HSV extends Record { h: number; s: number; v: number; a?: number; } interface HSVColor extends HSV { a?: 1; format?: 'name' | 'hsv'; } interface HSVAColor extends HSV { a: number; format?: 'name' | 'hsva'; } type Color = string | RGBColor | RGBAColor | HSLColor | HSLAColor | HSVColor | HSVAColor | HEX3Color | HEX4Color | HEX6Color | HEX8Color; type ObjectColor = Exclude; interface ColorMeta { rgb: RGBColor; hsl: HSLColor; hsv: HSVColor; hex: string; alpha: number; rgba: RGBAColor; hsla: HSLAColor; hsva: HSVAColor; hex8: string; gray: number; origin: Color; } type ColorType = 'hex' | 'rgb' | 'hsv' | 'hsl'; declare const RGB_REG: RegExp; declare const RGBA_REG: RegExp; declare const HSL_REG: RegExp; declare const HSLA_REG: RegExp; declare const HSV_REG: RegExp; declare const HSVA_REG: RegExp; declare const HEX_REG_3: RegExp; declare const HEX_REG_4: RegExp; declare const HEX_REG_6: RegExp; declare const HEX_REG_8: RegExp; declare const NAMED_COLORS: Readonly<{ aliceblue: "f0f8ff"; antiquewhite: "faebd7"; aqua: "0ff"; aquamarine: "7fffd4"; azure: "f0ffff"; beige: "f5f5dc"; bisque: "ffe4c4"; black: "000"; blanchedalmond: "ffebcd"; blue: "00f"; blueviolet: "8a2be2"; brown: "a52a2a"; burlywood: "deb887"; burntsienna: "ea7e5d"; cadetblue: "5f9ea0"; chartreuse: "7fff00"; chocolate: "d2691e"; coral: "ff7f50"; cornflowerblue: "6495ed"; cornsilk: "fff8dc"; crimson: "dc143c"; cyan: "0ff"; darkblue: "00008b"; darkcyan: "008b8b"; darkgoldenrod: "b8860b"; darkgray: "a9a9a9"; darkgreen: "006400"; darkgrey: "a9a9a9"; darkkhaki: "bdb76b"; darkmagenta: "8b008b"; darkolivegreen: "556b2f"; darkorange: "ff8c00"; darkorchid: "9932cc"; darkred: "8b0000"; darksalmon: "e9967a"; darkseagreen: "8fbc8f"; darkslateblue: "483d8b"; darkslategray: "2f4f4f"; darkslategrey: "2f4f4f"; darkturquoise: "00ced1"; darkviolet: "9400d3"; deeppink: "ff1493"; deepskyblue: "00bfff"; dimgray: "696969"; dimgrey: "696969"; dodgerblue: "1e90ff"; firebrick: "b22222"; floralwhite: "fffaf0"; forestgreen: "228b22"; fuchsia: "f0f"; gainsboro: "dcdcdc"; ghostwhite: "f8f8ff"; gold: "ffd700"; goldenrod: "daa520"; gray: "808080"; green: "008000"; greenyellow: "adff2f"; grey: "808080"; honeydew: "f0fff0"; hotpink: "ff69b4"; indianred: "cd5c5c"; indigo: "4b0082"; ivory: "fffff0"; khaki: "f0e68c"; lavender: "e6e6fa"; lavenderblush: "fff0f5"; lawngreen: "7cfc00"; lemonchiffon: "fffacd"; lightblue: "add8e6"; lightcoral: "f08080"; lightcyan: "e0ffff"; lightgoldenrodyellow: "fafad2"; lightgray: "d3d3d3"; lightgreen: "90ee90"; lightgrey: "d3d3d3"; lightpink: "ffb6c1"; lightsalmon: "ffa07a"; lightseagreen: "20b2aa"; lightskyblue: "87cefa"; lightslategray: "789"; lightslategrey: "789"; lightsteelblue: "b0c4de"; lightyellow: "ffffe0"; lime: "0f0"; limegreen: "32cd32"; linen: "faf0e6"; magenta: "f0f"; maroon: "800000"; mediumaquamarine: "66cdaa"; mediumblue: "0000cd"; mediumorchid: "ba55d3"; mediumpurple: "9370db"; mediumseagreen: "3cb371"; mediumslateblue: "7b68ee"; mediumspringgreen: "00fa9a"; mediumturquoise: "48d1cc"; mediumvioletred: "c71585"; midnightblue: "191970"; mintcream: "f5fffa"; mistyrose: "ffe4e1"; moccasin: "ffe4b5"; navajowhite: "ffdead"; navy: "000080"; oldlace: "fdf5e6"; olive: "808000"; olivedrab: "6b8e23"; orange: "ffa500"; orangered: "ff4500"; orchid: "da70d6"; palegoldenrod: "eee8aa"; palegreen: "98fb98"; paleturquoise: "afeeee"; palevioletred: "db7093"; papayawhip: "ffefd5"; peachpuff: "ffdab9"; peru: "cd853f"; pink: "ffc0cb"; plum: "dda0dd"; powderblue: "b0e0e6"; purple: "800080"; rebeccapurple: "663399"; red: "f00"; rosybrown: "bc8f8f"; royalblue: "4169e1"; saddlebrown: "8b4513"; salmon: "fa8072"; sandybrown: "f4a460"; seagreen: "2e8b57"; seashell: "fff5ee"; sienna: "a0522d"; silver: "c0c0c0"; skyblue: "87ceeb"; slateblue: "6a5acd"; slategray: "708090"; slategrey: "708090"; snow: "fffafa"; springgreen: "00ff7f"; steelblue: "4682b4"; tan: "d2b48c"; teal: "008080"; thistle: "d8bfd8"; tomato: "ff6347"; turquoise: "40e0d0"; violet: "ee82ee"; wheat: "f5deb3"; white: "fff"; whitesmoke: "f5f5f5"; yellow: "ff0"; yellowgreen: "9acd32"; }>; type ColorName = keyof typeof NAMED_COLORS; declare const COLOR_NAMES: Readonly>; declare function isHex(color: any): boolean; declare function isRgb(color: any): boolean; declare function isRgba(color: any): boolean; /** * 判断给定的字符串是否为一个合法颜色值 * * @param value 原始字符串 * * @returns 是否为合法颜色 */ declare function isColor(value: string): boolean; /** * 将给定的字符串转化为 {@link ObjectColor}，无法转换时返回 null * * @param color 原始颜色字符串 * * @returns 解析后的颜色对象 */ declare function parseStringColor(color: string): ObjectColor | null; /** * 将给定的 {@link Color} 解析为 {@link ColorMeta} * * @param color 原始颜色值 * * @returns 解析后的颜色元数据 */ declare function parseColor(color: Color): ColorMeta; /** * 将给定的 {@link Color} 解析为 {@link RGBAColor} * * @param originColor 原始颜色值 * * @returns 解析后的 RGB 颜色对象 */ declare function parseColorToRgba(originColor: Color): RGBAColor; /** * 将原始的 h、s、l 值标准化为 0 ~ 1 的值 * * @param h 0 ~ 360 * @param s 0 ~ 1，0% ~ 100% * @param l 0 ~ 1，0% ~ 100% * * @returns 标准化后的 HSL 对象 */ declare function normalizeHsl(h: number | string, s: number | string, l: number | string): { h: number; s: number; l: number; }; /** * 将原始的 r、g、b 值标准化为 0 ~ 1 的值 * * @param r 0 ~ 255 * @param g 0 ~ 255 * @param b 0 ~ 255 * * @returns 标准化后 RGB 对象 */ declare function normalizeRgb(r: number | string, g: number | string, b: number | string): { r: number; g: number; b: number; }; /** * 将原始的 h、s、v 值标准化为 0 ~ 1 的值 * * @param h 0 ~ 360 * @param s 0 ~ 1，0% ~ 100% * @param v 0 ~ 1，0% ~ 100% * * @returns 标准化的 HSV 对象 */ declare function normalizeHsv(h: number | string, s: number | string, v: number | string): { h: number; s: number; v: number; }; /** * 将原始透明度值标准化为 0 ~ 1 的值 * * @param a 0 ~ 1，0% ~ 100% * * @returns 标准化后的透明度 */ declare function normalizeAlpha(a: number | string): number; /** * 将 HSL 颜色转换为 RGB 颜色 * * @param h 0 ~ 360 * @param s 0 ~ 1，0% ~ 100% * @param l 0 ~ 1，0% ~ 100% * * @returns 转换后的 RGB 颜色 */ declare function hslToRgb(h: number | string, s: number | string, l: number | string): RGBColor; /** * 将 RGB 颜色转换为 HSL 颜色 * * @param r 0 ~ 255 * @param g 0 ~ 255 * @param b 0 ~ 255 * * @returns 转换后的 HSL 颜色 */ declare function rgbToHsl(r: number | string, g: number | string, b: number | string): HSLColor; /** * 将 HSL 颜色转换为 HSV 颜色 * * @param h 0 ~ 360 * @param s 0 ~ 1，0% ~ 100% * @param l 0 ~ 1，0% ~ 100% * * @returns 转换后的 HSV 颜色 */ declare function hslToHsv(h: number | string, s: number | string, l: number | string): HSVColor; /** * 将 HSV 颜色转换为 HSL 颜色 * * @param h 0 ~ 360 * @param s 0 ~ 1，0% ~ 100% * @param v 0 ~ 1，0% ~ 100% * * @returns 转换后的 HSL 颜色 */ declare function hsvToHsl(h: number | string, s: number | string, v: number | string): HSLColor; /** * 将 HSV 颜色转换为 RGB 颜色 * * @param h 0 ~ 360 * @param s 0 ~ 1，0% ~ 100% * @param v 0 ~ 1，0% ~ 100% * * @returns 转换后的 RGB 颜色 */ declare function hsvToRgb(h: number | string, s: number | string, v: number | string): RGBColor; /** * 将 RGB 颜色转换为 HSV 颜色 * * @param r 0 ~ 255 * @param g 0 ~ 255 * @param b 0 ~ 255 * * @returns 转换后的 HSV 颜色 */ declare function rgbToHsv(r: number | string, g: number | string, b: number | string): HSVColor; /** * 将 RGB 颜色转换为 HEX 颜色 * * @param r 0 ~ 255 * @param g 0 ~ 255 * @param b 0 ~ 255 * @param allow3Char 是否允许 3 位的 HEX 值 * * @returns 转换后的 HEX 颜色 */ declare function rgbToHex(r: number | string, g: number | string, b: number | string, allow3Char?: boolean): string; /** * 将 RGBA 颜色转换为 HEX 颜色 * * @param r 0 ~ 255 * @param g 0 ~ 255 * @param b 0 ~ 255 * @param a 0 ~ 1，0% ~ 100% * @param allow4Char 是否允许 4 位的 HEX 值 * * @returns 转换后的 HEX 颜色 */ declare function rgbaToHex(r: number | string, g: number | string, b: number | string, a: number | string, allow4Char?: boolean): string; /** * 将两种颜色按照一定的比例混合 * * @param color1 第一种颜色 * @param color2 第二种颜色 * @param weight 混合比例 0 ~ 1，越小则第一种颜色越少 * * @returns 混合后的颜色 */ declare function mixColor(color1: Color, color2: Color, weight?: number): RGBAColor; /** * 调整给定颜色值的透明度 * * @param color 需要调整的颜色 * @param alpha 调整后的透明度 0 ~ 1，0% ~ 100% * * @returns 调整后的颜色 */ declare function adjustAlpha(color: Color, alpha: number | string): RGBAColor; /** * 随机生成一个颜色值 * * @param withAlpha 是否具有透明度 * @param type 颜色的类型 * * @returns 生成的颜色字面值 */ declare function randomColor(withAlpha?: boolean, type?: ColorType): string; /** * 随机生成一个特定色调（冷暖色）的颜色值 * * @param prefer 色调 * @param withAlpha 是否具有透明度 * @param type 颜色的类型 * * @returns 生成的颜色字面值 */ declare function randomPreferColor(prefer: 'hard' | 'soft', withAlpha?: boolean, type?: ColorType): string; /** * 随机生成一个冷色调的颜色值 * * @param withAlpha 是否具有透明度 * @param type 颜色的类型 * * @returns 生成的颜色字面值 */ declare function randomHardColor(withAlpha?: boolean, type?: ColorType): string; /** * 随机生成一个暖色调的颜色值 * * @param withAlpha 是否具有透明度 * @param type 颜色的类型 * * @returns 生成的颜色字面值 */ declare function randomSoftColor(withAlpha?: boolean, type?: ColorType): string; /** * 获取给定颜色的灰度 * * @param color 颜色字面值 * * @returns 颜色的灰度 */ declare function toGrayScale(color: string): number; /** 当前环境是否为客户端 */ declare const isClient: boolean; /** 当前环境是否为 IOS */ declare const isIOS: boolean | ""; /** * 判断一个值是否为指定的类型 * * @param value 需判断的值 * @param type 指定的类型，注意大小写 * * @returns 类型是否匹配 */ declare function is(value: unknown, type: string): boolean; /** * 判断一个对象是否包含指定的键值 * * @param value 需判断的对象 * @param key 指定的键值 * * @returns 是否包含键值 */ declare function has(value: Record, key: string | symbol): key is keyof typeof value; /** * 判断一个值是否已定义 * * @param value 需判断的值 * * @returns 是否已定义 */ declare function isDefined(value: T | undefined | null): value is Exclude; /** * 判断一个值是否未被定义 * * @param value 需判断的值 * * @returns 是否未定义 */ declare function isNull(value: unknown): value is null | undefined; /** * 判断一个值是否为数字 * * @param value 需判断的值 * * @returns 是否为数字 */ declare function isNumber(value: unknown): value is number; /** * 判断一个值是否为 `NaN` * * @param value 需判断的值 * * @returns 是否为 `NaN` */ declare function isNaN(value: unknown): value is number; /** * 判断一个值是否为字符串 * * @param value 需判断的值 * * @returns 是否为字符串 */ declare function isString(value: unknown): value is string; /** * 判断一个值是否为布尔值 * * @param value 需判断的值 * * @returns 是否为布尔值 */ declare function isBoolean(value: unknown): value is boolean; /** * 判断一个值是否为 `true` * * @param value 需判断的值 * * @returns 是否为 `true` */ declare function isTrue(value: unknown): value is true; /** * 判断一个值是否为 `false` * * @param value 需判断的值 * * @returns 是否为 `false` */ declare function isFalse(value: unknown): value is false; /** * 判断一个值是否为 `Symbol` * * @param value 需判断的值 * * @returns 是否为 `Symbol` */ declare function isSymbol(value: unknown): value is symbol; /** * 判断一个值是否为 `BigInt` * * @param value 需判断的值 * * @returns 是否为 `BigInt` */ declare function isBigInt(value: unknown): value is bigint; /** * 判断一个值是否为数组 * * @param value 需判断的值 * * @returns 是否为数组 */ declare function isArray(value: unknown): value is T[]; /** * 判断一个值是否为对象 * * 注意，`null` 与原生的特殊对象不被包含 * * @param value 需判断的值 * * @returns 是否为对象 */ declare function isObject = Record>(value: unknown): value is T; /** * 判断一个值是否为 `Promise` * * 如果一个对象包含 `then` 和 `catch` 方法，则被认为是一个 `Promise` * * @param value 需判断的值 * * @returns 是否为 `Promise` */ declare function isPromise(value: unknown): value is Promise; /** * 判断一个值是否为函数 * * @param value 需判断的值 * * @returns 是否为函数 */ declare function isFunction(value: unknown): value is (...any: any[]) => any; /** * 判断一个值是否为 `Set` * * @param value 需判断的值 * * @returns 是否为 `Set` */ declare function isSet(value: unknown): value is Set; /** * 判断一个值是否为 `Map` * * @param value 需判断的值 * * @returns 是否为 `Map` */ declare function isMap(value: unknown): value is Map; /** * 判断一个值是否为 `Date` * * @param value 需判断的值 * * @returns 是否为 `Date` */ declare function isDate(value: unknown): value is Date; /** * 判断一个值是否为正则 * * @param value 需判断的值 * * @returns 是否为正则 */ declare function isRegExp(value: unknown): value is RegExp; /** * 判断一个值是否为空 * * - 如果这是一个数组或字符串，则 `length` 为 `0` 时为空 * - 如果这是一个 `Set` 或 `Map`，则 `size` 为 `0` 时为空 * - 如果这是一个对象，则无任何键值时为空 * - 如果这是一个数字，则为 `NaN` 时为空 * - 其余情况下，未定义时为空 * * @param value 需判断的值 * * @returns 是否为空 */ declare function isEmpty(value: unknown): boolean; /** * 是否为空对象 * @param obj */ declare function isEmptyObject(obj: any): boolean; /** * 判断一个值是否为 `Element` * * @param value 需判断的值 * @param ssr 是否考虑服务端渲染 * * @returns 是否为 `Element` */ declare function isElement(value: unknown, ssr?: boolean): value is T; /** * 判断一个值能否被迭代 * * @param value 需判断的值 * * @returns 能否被迭代 */ declare function isIterable(value: unknown): boolean; /** * 一个空的占位函数 */ declare function noop(...args: any[]): any; /** * 一个返回 `true` 的占位函数 * * @returns `true` */ declare function toTrue(...args: any[]): true; /** * 一个返回 `false` 的占位函数 * * @returns `false` */ declare function toFalse(...args: any[]): false; /** * 生成一个值递进的数组 * * @param size 大小 * @param start 开始的数值，默认为 1 * @param step 跨度，默认为 1 * * @returns 生成的数组 */ declare function range(size: number, start?: number, step?: number): number[]; /** * 获取变量的类型 * * @param value 任意变量 * * @returns 变量的类型 */ declare function getType(value: unknown): string; /** * 根据长度生成一串随机的字符串 * * @param length 字符串的长度 * * @returns 生成的字符串 */ declare function randomString(length?: number): string; /** * 根据一系列判断条件，执行第一个为 `true` 的条件所对应的回调函数 * * @param conditions 判断条件及回调函数 * @param options 额外的选项 * * @returns 是否匹配了任一条件 */ declare function decide(conditions: [boolean | (() => boolean), () => void | Promise][], options?: { /** * 当匹配任意一个条件时，会在该条件对应的回调函数执行前执行 */ beforeMatchAny?: () => void | Promise; /** * 当匹配任意一个条件时，会在该条件对应的回调函数执行完后执行 */ afterMatchAny?: () => void | Promise; }): Promise; declare function getGlobalCount(): number; declare function setGlobalCount(count: number): void; declare function createCounter(count?: number): { getCount: () => number; setCount: (newCount: number) => void; }; /** * Caesar Cipher * @zh 凯撒密码 * @param str * @param shift */ declare function caesarCipher(str: string, shift: number): string; /** * xor 密码 * @param str * @param key * @description 生成的结果为乱码，通过乱码解密获得明文 */ declare function xorCipher(str: string, key: string): string; /** * base64 编码 * @param str */ declare function base64Encode(str: string): string; /** * base64 解码 * @param str */ declare function base64Decode(str: string): string; interface BITree { tree: number[]; /** * 为第 index 个元素增减值 * * @param index 索引值 * @param num 增减的值 */ add(index: number, num: number): void; /** * 求前 index 个元素的和 * * @param index 索引值 * * @returns 前 index 个元素的和 */ sum(index?: number): number; /** * 获取第 index 个元素的值 * * @param index 索引值 * * @returns 第 index 个元素的值 */ get(index: number): number; /** * 根据目标值寻找一个最接近的元素的索引值 * * @param target 目标值 * * @returns 最接近的元素的索引值 */ boundIndex(target: number): number; } /** * 创建一个二叉索引树（Fenwick 树）对象 * * 为了节省初始化性能开销，需确保元素最小值已知，其初始值为：元素最小值 * 元素总数 * * @param length 树的大小，即元素的总数 * @param min 规定元素的最小值 * * @returns 二叉索引树对象 */ declare function createBITree(length: number, min?: number): BITree; /** * 时间单位类型 */ type Unit = 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'; /** * 日期时间处理类（兼容原有API并增强） */ declare class DateTime { private readonly date; /** * 构造函数 * @param date 可选日期参数，支持Date对象、时间戳或ISO字符串 * @throws 如果传入无效日期会抛出错误 */ constructor(date?: Date | string | number); /** * 创建DateTime实例（工厂方法） * @param date 可选日期参数 * @returns 新的DateTime实例 */ static create(date?: Date | string | number): DateTime; /** * 获取星期几（中国习惯：周一为1，周日为7） * @returns 1-7的数字 */ day(): number; /** * 格式化日期时间 * @param formatStr 格式化字符串，默认'YYYY-MM-DD HH:mm:ss' * @returns 格式化后的日期字符串 */ format(formatStr?: string): string; /** * 添加时间量 * @param value 要添加的数值 * @param unit 时间单位 * @returns 新的DateTime实例 */ add(value: number, unit: Unit): DateTime; /** * 减去时间量 * @param value 要减去的数值 * @param unit 时间单位 * @returns 新的DateTime实例 */ subtract(value: number, unit: Unit): DateTime; /** * 获取时间单位的开始时刻 * @param unit 时间单位 * @returns 新的DateTime实例 */ startOf(unit: Unit): DateTime; /** * 获取时间单位的结束时刻 * @param unit 时间单位 * @returns 新的DateTime实例 */ endOf(unit: Unit): DateTime; /** * 计算两个日期的时间差 * @param other 要比较的日期 * @param unit 时间单位，默认为毫秒 * @returns 时间差值 */ diff(other: DateTime | Date | string | number, unit?: Unit): number; /** * 获取周范围（带偏移量） * @param offset 周偏移量（0=本周，1=下周，-1=上周） * @param weekStartsOn 周起始日（1-7，默认1表示周一） * @returns [周开始时间, 周结束时间] */ getWeekRange(offset?: number, weekStartsOn?: number): [DateTime, DateTime]; /** * 获取月范围（带偏移量） * @param offset 月偏移量（0=本月，1=下月，-1=上月） * @returns [月开始时间, 月结束时间] */ getMonthRange(offset?: number): [DateTime, DateTime]; /** * 获取季度范围（带偏移量） * @param offset 季度偏移量（0=本季，1=下季，-1=上季） * @returns [季度开始时间, 季度结束时间] */ getQuarterRange(offset?: number): [DateTime, DateTime]; /** * 获取年范围（带偏移量） * @param offset 年偏移量（0=本年，1=明年，-1=去年） * @returns [年开始时间, 年结束时间] */ getYearRange(offset?: number): [DateTime, DateTime]; /** * 是否为工作日（周一至周五） * @returns 是否为工作日 */ isWeekday(): boolean; /** * 是否为周末（周六或周日） * @returns 是否为周末 */ isWeekend(): boolean; /** * 判断日期是否相同（可精确到指定单位） * @param other 要比较的日期 * @param unit 比较单位，默认为毫秒级 * @returns 是否相同 */ isSame(other: DateTime | Date | string, unit?: Unit): boolean; /** * 判断是否在某个日期之前 * @param other 要比较的日期 * @returns 是否在前 */ isBefore(other: Date | string | number): boolean; /** * 判断是否在某个日期之后 * @param other 要比较的日期 * @returns 是否在后 */ isAfter(other: Date | string | number): boolean; /** * 检查日期是否有效 * @returns 是否有效 */ isValid(): boolean; /** * 转换为原生Date对象 * @returns Date对象 */ toDate(): Date; /** * 转换为时间戳 * @returns 时间戳（毫秒） */ valueOf(): number; /** * 转换为ISO字符串 * @returns ISO格式字符串 */ toString(): string; /** * 获取当前月份的天数 * @private * @returns 天数 */ private daysInMonth; } /** * 格式化日期（快捷方法） * @param date 日期，默认为当前时间 * @param format 格式字符串，默认为'YYYY-MM-DD HH:mm:ss' * @returns 格式化后的字符串 */ declare function formatDate(date?: Date | string | number, format?: string): string; /** * 获取当前周范围 * @param format 可选格式字符串 * @returns [周开始时间, 周结束时间] */ declare function getCurrentWeek(format?: string): [string, string]; /** * 获取当前月范围 * @param format 可选格式字符串 * @returns [月开始时间, 月结束时间] */ declare function getCurrentMonth(format?: string): [string, string]; /** * 生成日期范围数组 * @param start 开始日期 * @param end 结束日期 * @param format 格式字符串，默认为'YYYY-MM-DD' * @returns 日期字符串数组 */ declare function getDateRange(start: Date | string | number, end: Date | string | number, format?: string): string[]; /** * 人性化显示时间差 * @param start 开始时间 * @param end 结束时间，默认为当前时间 * @returns 人性化字符串（如"3天前"） */ declare function humanizeDiff(start: Date | string | number, end?: Date | string | number): string; declare global { interface Date { /** * 判断是否在某个日期之前 * @param other 要比较的日期 * @returns 是否在前 */ isBefore(other: Date): boolean; /** * 判断是否在某个日期之后 * @param other 要比较的日期 * @returns 是否在后 */ isAfter(other: Date): boolean; } } /** * 时间转换成相对时间 * @param timestamp */ declare function timeAgo(timestamp: number): string; interface DeepCloneOptions { /** * 一个自定义的克隆对象方法，用于处理方法内置以外的对象克隆，如 Class 的实例 * * @param type 对象的类型，注意格式为大驼峰 * @param obj 原始对象 * * @returns 克隆后对象 */ cloneObject?: (type: string, obj: unknown) => any; } /** * 深度拷贝对象或数组 * * @param obj 需要拷贝的对象或数组 * * @returns 克隆后的对象 */ declare function deepClone(obj: T, options?: DeepCloneOptions): T; /** * 将一个对象销毁，销毁后的对象所有方法不可用，属性值均为 `null` * * @param object 要销毁的对象 * @param message 销毁后，调用方法时的错误信息 */ declare function destroyObject(object: any, message?: string): void; /** * 专用的类型，用于适配 Vexip UI 中 `transfer` 属性的处理 */ interface TransferNode extends Element { __transferElement?: Element | null; } interface EventPayload extends EventInit { /** * 事件的类型 */ type: string; [prop: string]: any; } /** * 当前是否可以使用触摸交互 */ declare const USE_TOUCH: boolean; /** * 当前点击的类型，可以使用触摸交互时为 `pointerdown`，否则为 `click` */ declare const CLICK_TYPE: string; /** * 为指定的元素派发事件 * * @param el 指定的元素 * @param payload 事件的属性 * @param Event 事件类 * * @returns 事件是否派发成功 */ declare function dispatchEvent(el: Element, payload: EventPayload, Event?: { new (type: string, eventInitDict?: EventInit | undefined): Event; prototype: Event; readonly AT_TARGET: number; readonly BUBBLING_PHASE: number; readonly CAPTURING_PHASE: number; readonly NONE: number; }): boolean; /** * 检索匹配指定选择器的所有元素 * * @param selector 选择器 * @param root 根元素，不指定时为 `document.body` * * @returns 匹配的所有元素 */ declare function queryAll(selector: string, root?: Element | null): HTMLElement[]; /** * 判断指定的元素是否聚焦或包含聚焦的元素 * * @param el 需判断的元素 * * @returns 是否聚焦或包含聚焦的元素 */ declare function isFocusIn(el?: Element | null): boolean; /** * 判断一个元素是否包含另一个元素 * * @param el 被包含的元素（子元素） * @param parent 包含的元素（父元素） * * @returns 元素是否包含另一个元素 */ declare function contains(el?: Element | null, parent?: HTMLElement | null): boolean; /** * 判断指定的元素是否隐藏 * * @param el 需判断的元素 * * @returns 元素是否隐藏 */ declare function isHidden(el?: Element | null): boolean; /** * 判断指定的元素是否可见 * * @param el 需判断的元素 * * @returns 元素是否可见 */ declare function isVisible(el?: Element | null): boolean; /** * 判断指定的元素是否被禁用 * * @param el 需判断的元素 * * @returns 元素是否被禁用 */ declare function isDisabled(el?: Element | null): boolean; /** * 检索可以被切换焦点（Tab）的元素 * * @param root 根元素，不指定时为 `document.body` * @param includeDisabled 是否包含被禁用的元素 * * @returns 可以被切换焦点的元素 */ declare function queryTabables(root?: HTMLElement, includeDisabled?: boolean): HTMLElement[]; /** * 获取元素横向的内边距像素值 * * @param el 指定的元素 * * @returns 元素横向的内边距像素值 */ declare function getXPadding(el: HTMLElement | null): number; /** * 获取元素纵向的内边距像素值 * * @param el 指定的元素 * * @returns 元素纵向的内边距像素值 */ declare function getYPadding(el: HTMLElement | null): number; /** * 获取元素横向的外边距像素值 * * @param el 指定的元素 * * @returns 元素横向的外边距像素值 */ declare function getXMargin(el: HTMLElement | null): number; /** * 获取元素纵向的外边距像素值 * * @param el 指定的元素 * * @returns 元素纵向的外边距像素值 */ declare function getYMargin(el: HTMLElement | null): number; /** * 获取元素横向的边框像素值 * * @param el 指定的元素 * * @returns 元素横向的边框像素值 */ declare function getXBorder(el: HTMLElement | null): number; /** * 获取元素纵向的边框像素值 * * @param el 指定的元素 * * @returns 元素纵向的边框像素值 */ declare function getYBorder(el: HTMLElement | null): number; /** * 获取元素的选中宽度 * * @param el 指定的元素 * * @returns 元素的选中宽度 */ declare function getRangeWidth(el: HTMLElement | null): number; /** * 给定的值如果为合法数字，则将转换为像素值 * * @param value 需要判断的值 * * @returns 转换后的像素值 */ declare function toCssSize(value: number | string): string; /** * 将指定的值转换为 HTML 属性值 * * @param value 需要转换的值 * * @returns 转换后的 HTML 属性值 */ declare function toAttrValue(value?: boolean | null): 'true' | undefined; declare function toAttrValue(value?: string | number | null): string | undefined; /** * 将 html 内容的敏感字符进行转换 * * @param string html 内容 * * @returns 转换后的 html 内容 */ declare function escapeHtml(string: unknown): string; declare class EventBus { private events; private static instance; /** * Get all registered events. */ static getEvents(): Map; /** * Get the number of registered events. */ static getEventsSize(): number; /** * Get the callback function of a specific event. * @param name Event name */ static getEvent(name: string): CallableFunction | undefined; /** * Check if an event is registered. * @param name Event name */ static hasEvent(name: string): boolean; /** * Delete an event. * @param name Event name * @returns Whether the event was deleted */ static deleteEvent(name: string): boolean; /** * Register or overwrite an event. * @param name Event name * @param callback Callback function */ static setEvent(name: string, callback: CallableFunction): Map; /** * Bind an event. * @param name Event name * @param callback Callback function */ static on(name: string, callback: CallableFunction): Map; /** * Trigger an event. * @param name Event name * @param payload Arguments passed to the callback */ static emit(name: string, ...payload: any[]): any; /** * Trigger an event once and then remove it. * @param name Event name * @param payload Arguments passed to the callback */ static once(name: string, ...payload: any[]): any; /** * Remove one or more events. * @param name Event name or array of names * @returns Whether all events were removed */ static off(name: string | string[]): boolean; /** * Get the singleton instance of EventBus. */ static getInstance(): EventBus; private static isFunction; } type EventType = number | string | symbol; type EventHandler = (...payload: any[]) => void; type EventHandlerSet = Set; type EventHandlerMap = Map; interface EventEmitter { /** * 为指定的事件添加回调方法 * * @param type 事件类型 * @param handler 回调方法 */ on: (type: EventType, handler: EventHandler) => void; /** * 为指定的事件移除回调方法 * * @param type 事件类型 * @param handler 回调方法 */ off: (type: EventType, handler: EventHandler) => void; /** * 为指定的事件清除所有回调方法 * * @param type 事件类型 */ clear: (type: EventType) => void; /** * 清除所有事件的所有回调方法 */ clearAll: () => void; /** * 派发特定的事件 * * @param type 事件类型 * @param payload 传入事件回调方法的参数 */ emit: (type: EventType, ...payload: any[]) => void; } /** * 创建一个自定义的事件发射器 * * @returns 事件发射器 */ declare function createEventEmitter(): EventEmitter; type Key = string | number; type KeyCombo = Key | Key[]; type MouseButton = 'left' | 'middle' | 'right' | number; interface KeyEventOptions { preventDefault?: boolean; stopPropagation?: boolean; target?: EventTarget; event?: 'keydown' | 'keyup' | 'keypress'; } interface MouseEventOptions { preventDefault?: boolean; stopPropagation?: boolean; target?: EventTarget; event?: 'mousedown' | 'mouseup' | 'click' | 'dblclick'; } interface LongPressOptions { threshold?: number; interval?: number; } interface Listener { unsubscribe: () => void; } declare class KeyboardListener { private static normalizeKey; private static isComboMatch; static on(combo: KeyCombo, callback: (event: KeyboardEvent) => void, options?: KeyEventOptions): Listener; static once(combo: KeyCombo, callback: (event: KeyboardEvent) => void, options?: KeyEventOptions): Listener; static longPress(key: Key, callback: (event: KeyboardEvent) => void, options?: KeyEventOptions & LongPressOptions): Listener; } declare class MouseListener { private static isButtonMatch; static on(button: MouseButton, callback: (event: MouseEvent) => void, options?: MouseEventOptions): Listener; static once(button: MouseButton, callback: (event: MouseEvent) => void, options?: MouseEventOptions): Listener; static longPress(button: MouseButton, callback: (event: MouseEvent) => void, options?: MouseEventOptions & LongPressOptions): Listener; static onClickOutside(element: HTMLElement, callback: (event: MouseEvent) => void, options?: Omit): Listener; } /** * 仅发出一次的提示消息 * * @param message 消息内容 * @param logFn 输出函数 */ declare function infoOnce(message: string, logFn?: { (...data: any[]): void; (message?: any, ...optionalParams: any[]): void; }): void; /** * 仅发出一次的警告消息 * * @param message 消息内容 * @param logFn 输出函数 */ declare function warnOnce(message: string, logFn?: { (...data: any[]): void; (message?: any, ...optionalParams: any[]): void; }): void; /** * 仅发出一次的错误消息 * * @param message 消息内容 * @param logFn 输出函数 */ declare function errorOnce(message: string, logFn?: { (...data: any[]): void; (message?: any, ...optionalParams: any[]): void; }): void; /** * 将给定的常量字符串类型拓展为不区分大小写的任意组合 */ type AnyCase = string extends S ? string : S extends `${infer F1}${infer F2}${infer R}` ? `${Uppercase | Lowercase}${Uppercase | Lowercase}${AnyCase}` : S extends `${infer F}${infer R}` ? `${Uppercase | Lowercase}${AnyCase}` : ''; /** * 将字面值转换为短横线连接 * * @param value 需要转换的字面值 * * @returns 转换后的短横线连接字面值 * * @example * ```ts * toKebabCase('AaBbCc') // aa-bb-cc * toKebabCase('AABb') // aa-bb * toKebabCase('AAA') // aaa * toKebabCase('AaBb CcDd') // aa-bb cc-dd * ``` */ declare function toKebabCase(value: string): string; /** * 将给定的常量字符串类型拓展为大驼峰 */ type CapitalCase = T extends `${infer First} ${infer Rest}` ? CapitalCase<`${First}-${Rest}`> : T extends `${infer First}-${infer Rest}` ? `${Capitalize}${CapitalCase}` : Capitalize; /** * 将字面值转换为大驼峰 * * @param value 需要转换的字面值 * * @returns 转换后的大驼峰字面值 */ declare function toCapitalCase(value: T): CapitalCase; /** * 将字面值转换为小驼峰 * * @param value 需要转换的字面值 * * @returns 转换后的小驼峰字面值 */ declare function toCamelCase(value: string): string; declare const numberRE: RegExp; /** * 检测给定的值是否可以通过 parseFlat 或 Number 方法转为数字 * * 开启严格模式则通过正则以更严格的方法判断 * * @param value 需要检测的值 * @param strict 是否为严格模式 * * @returns 值是否可以转为数字 */ declare function isValidNumber(value: unknown, strict?: boolean): boolean; /** * 将给定的值转成数字，NaN 的情况将会处理成 0 * * @param value 需要转换的值 * * @returns 转换后的数字 */ declare function toNumber(value: unknown): number; /** * 为给定的整数开头填充 0，直至满足指定的长度 * * @param number 需要处理的整数 * @param length 填充至的长度 * * @returns 填充后的字面值 */ declare function padStartZeros(number: number, length: number): string; /** * 将小于 10 整数 N 变成 `0N` 的字符串，方法不会对入参校验 * * @param number 需要处理的整数 * * @returns 填充后的字面值 */ declare function doubleDigits(number: number): string; /** * 返回数字的小数位数 * * @param number 指定的数字 * * @returns 数字的小数位数 */ declare function decimalLength(number: number | string): number; /** * Return decimal length of a number * * @param number The input number * @deprecated Using `decimalLength` to replace it */ declare function digitLength(number: number | string): number; /** * 将给定的数字格式化为指定的位阶 * * @param number 需要格式化的数字 * @param segment 分隔的位数，默认为 3 * @param separator 分隔的符号，默认为 ',' * * @returns 格式化后的字面值 */ declare function segmentNumber(number: number | string, segment?: number, separator?: string): string; /** * 将给定的实数保留一定的小数 * * @param number 需要处理的实数 * @param decimal 需要保留的小数 * * @returns 保留小数后的值 */ declare function toFixed(number: number, decimal: number): number; /** * 将给定的实数扩大一定的倍数并保留一定的小数 * * @param number 要处理的实数 * @param multiple 要扩大的倍数 * @param decimal 要保留的小数 * * @returns 扩大并保留小数后的值 */ declare function multipleFixed(number: number, multiple: number, decimal: number): number; /** * 根据临界值对给定的数字进行舍入 * * @param number 需要舍入的数 * @param criticalValue 舍入的临界值 (0 ~ 1)，达到临界值进位反之舍弃 * * @returns 舍入后的值 */ declare function round(number: number, criticalValue: number): number; /** * 将给定的数字限定在指定的范围内 * * @param number 需要限定范围的数 * @param min 边界最小值，包含该值 * @param max 边界最大值，包含该值 * * @returns 限定在范围内的值 */ declare function boundRange(number: number | string, min: number, max: number): number; /** * 将给定的被除数和除数，不断的取余直至达到次数限制或余数小于除数，返回系列余数 * * @param number 被除数，需大于 0 * @param divideBy 除数，需大于 1 * @param limit 次数限制，默认为 0，小于 1 则不作限制 * * @returns 相除过程的系列余数 */ declare function leaveNumber(number: number, divideBy: number, limit?: number): number[]; /** * 将给定的数字转换为序数词 * * @param number 需要转换的数字 * * @returns 转换后的序数词 */ declare function ordinalNumber(number: number): string; type SizeUnitWithAuto = AnyCase<'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'AUTO'>; type SizeUnit = Exclude>; /** * 根据给定的 Byte 数值，将其格式化成指定单位的大小 * * @param byte 需要计算的 Byte 数值 * @param unit 格式化的单位 * @param precision 结果的精度 * @param joinUtil 是否加入单位 * * @returns 格式化后的值 */ declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto): number; declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, precision?: number): number; declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, joinUtil?: true): number; declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, joinUtil?: true, precision?: number): number; /** * 在给定的范围内随机一个数 * * @param max 最大值 * @param min 最小值，默认为 0 * * @returns 生成的随机数 */ declare function random(max: number, min?: number): number; /** * 将数字处理为的指定的有效位数 * * @param number 需要处理的数字 * @param precision 数字的有效位数 * * @returns 处理后的数字 * * @example * ```ts * toPrecision(0.09999999999999998) === 0.1 // true * ``` */ declare function toPrecision(number: number | string, precision?: number): number; /** * 精确的乘法 * * @param numbers 需要依次相乘的数字 * * @returns 乘积 */ declare const times: (...numbers: (number | string)[]) => number; /** * 精确的加法 * * @param numbers 需要依次相加的数字 * * @returns 和 */ declare const plus: (...numbers: (number | string)[]) => number; /** * 精确的减法 * * @param numbers 需要依次相减的数字 * * @returns 差值 */ declare const minus: (...numbers: (number | string)[]) => number; /** * 精确的除法 * * @param numbers 需要依次相除的数字 * * @returns 商 */ declare const divide: (...numbers: (number | string)[]) => number; declare const raf: (cb: FrameRequestCallback) => void; interface ThrottleOptions { leading?: boolean; trailing?: boolean; interval?: number; } interface DebounceOptions { leading?: boolean; trailing?: boolean; delay?: number; } /** * 将一个方法进行节流 * * @param method 需要节流的方法，需自行绑定 this * @param options 节流配置项，可设置间隔时间和 leading/trailing 行为 * * @returns 节流后的方法 */ declare function throttle any>(method: T, options?: number | ThrottleOptions): (...args: Parameters) => void; /** * 将一个方法进行防抖 * * @param method 需要防抖的方法，需自行绑定 this * @param options 防抖配置项，可设置延迟时间和 leading/trailing 行为 * * @returns 防抖后的方法 */ declare function debounce any>(method: T, options?: number | DebounceOptions): (...args: Parameters) => void; /** * 对给定的方法进行微任务级别的防抖 * * @param method 需要防抖的方法，需自行绑定 this * @param options 配置项，可设置 leading/trailing 行为 * * @returns 防抖后的方法 */ declare function debounceMinor any>(method: T, options?: { leading?: boolean; trailing?: boolean; }): (...args: Parameters) => Promise>>; /** * 对给定的方法进行渲染帧级别的防抖 * * @param method 需要防抖的方法，需自行绑定 this * @param options 配置项，可设置 leading/trailing 行为 * * @returns 防抖后的方法 */ declare function debounceFrame any>(method: T, options?: { leading?: boolean; trailing?: boolean; }): (...args: Parameters) => Promise>>; /** * 在下一微任务，仅执行一次传入的方法 * * @param method 需要执行的方法 * @param args 方法的额外参数，在方法调用前多次传入将会覆盖之前的参数 */ declare function nextTickOnce any>(method: T, ...args: any[]): undefined; /** * 在下一渲染帧，仅执行一次传入的方法 * * @param method 需要执行的方法 * @param args 方法的额外参数，在方法调用前多次传入将会覆盖之前的参数 */ declare function nextFrameOnce any>(method: T, ...args: any[]): undefined; /** * 按指定的并发数，并行地为系列源数据执行操作 * * @param maxConcurrency 最大的并发数 * @param source 源数据 * @param iteratorFn 处理操作的异步函数 * * @returns 等待所有任务执行完的 Promise 对象 */ declare function runParallel(maxConcurrency: number, source: T[], iteratorFn: (item: T, source: T[]) => Promise): Promise; /** * 判断当前的环境是否支持 CSS 样式：`gap`、`row-gap` 和 `column-gap` * * @returns 是否支持 */ declare function supportFlexGap(): boolean; /** * 判断当前环境是否支持 `` 标签的 `loading` 属性 * * @returns 是否支持 */ declare function supportImgLoading(): boolean; /** * 如果一个值不为数组，则将其转换为数组 * * @param value 指定的值 * * @returns 原始数组或转换后的数组 */ declare function ensureArray(value: T | T[]): T[]; /** * 如果一个值为函数，则执行它并返回结果，否则返回其本身 * * @param value 指定的值 * @param args 若为函数时，传入的参数 * * @returns 原始值或函数执行结果 */ declare function callIfFunc(value: T | ((...args: P) => T), ...args: P): T; /** * 将路径中的 `\` 替换为 `/` * * @param path 指定的路径 * * @returns 替换后的路径 */ declare function normalizePath(path: string): string; /** * 获取字符串的最后一个字符 * * @param value 指定的字符串 * * @returns 最后一个字符 */ declare function getLast(value: string): string | undefined; /** * 获取数组的最后一个元素 * * @param value 指定的数组 * * @returns 最后一个元素 */ declare function getLast(value: T[]): T | undefined; /** * 根据数组元素中某个或多个属性的值转换为映射对象 * * @param list 需要被转换的数组 * @param prop 需要被转换的属性或提供一个读取方法 * @param accessor 映射的值的读取方法，默认返回元素本身 * @param isMap 是否使用 Map 对象储存结果 * * @returns 转换后的映射对象 */ declare function listToMap(list: T[], prop: keyof T | ((item: T) => any), accessor?: (item: T) => O, isMap?: false): Record; declare function listToMap(list: T[], prop: K, accessor?: (item: T) => O, isMap?: true): Map; declare function listToMap(list: T[], prop: (item: T) => K, accessor?: (item: T) => O, isMap?: true): Map; /** * 移除数组中的某个元素 * * @param array 需要被移除元素的数组 * @param item 需要被移除的元素, 或一个查找方法，如果元素为函数时则需要做一层简单包装 * @param isFn 标记数组的元素是否为函数 * * @returns 被移除的元素 */ declare function removeArrayItem(array: T[], item: T | ((item: T) => boolean), isFn?: boolean): T | null; /** * 按照一定顺序的属性对数据进行分组 * * @param list 需要分数的数据 * @param props 需要按顺序分组的属性 * * @returns 分组后的对象 */ declare function groupByProps(list: T[], props?: Array any)> | string | ((item: T) => any)): Record; interface TreeOptions { keyField?: T; childField?: T; parentField?: T; /** 若指定，`parent` 值等于 `rootId` 的节点被认为是顶级节点 */ rootId?: any; } /** * 将一个展平的列表转换为树 * * @param list 要转换的列表 * @param options 转换的配置项 * * @returns 转换后的树 */ declare function transformTree(list: T[], options?: TreeOptions): T[]; /** * 将一个树展平成列表 * * @param tree 要展平的树 * @param options 转换的配置项 * * @returns 展平后的列表 */ declare function flatTree(tree: T[], options?: TreeOptions & { /** 是否为深度优先遍历 */ depthFirst?: boolean; /** * 是否为无 ID 的节点插入 ID 值 * * @default true */ injectId?: boolean; /** 构建节点的 ID 的方法 */ buildId?: (index: number) => any; /** 过滤节点的方法 */ filter?: (item: T) => boolean; /** 过滤的结果是否会影响其子级 */ cascaded?: boolean; /** 是否强制为节点插入 ID 值 */ forceInject?: boolean; }): T[]; /** * 遍历树并为每个节点执行回调方法 * * @param tree 要遍历的树 * @param cb 回调函数 * @param options 遍历的配置项 */ declare function walkTree(tree: T[], cb: (item: T, depth: number, parent: T | null) => void, options?: { /** 是否为深度优先遍历 */ depthFirst?: boolean; childField?: keyof T; }): void; /** * 遍历树并为每个节点执行回调方法，并用其返回值构建一颗新的树 * * @param tree 要遍历的树 * @param cb 回调函数 * @param options 遍历的配置项 * * @returns 构建后新的树 */ declare function mapTree(tree: T[], cb: (item: T, depth: number, parent: T | null) => R, options?: { /** 是否为深度优先遍历 */ depthFirst?: boolean; childField?: keyof T; /** 是否强制重置 `children` 字段 */ clearChildren?: boolean; }): R[]; /** * 遍历树并为每个节点执行过滤方法，并用符合条件的节点构建一棵新的树 * * @param tree 要遍历的树 * @param cb 过滤的方法 * @param options 遍历的配置项 * * @returns 过滤后新的树 */ declare function filterTree(tree: T[], cb: (item: T, depth: number, parent: T | null) => boolean, options?: { /** 判断一个节点是否为叶子节点 */ isLeaf?: (item: T) => boolean; /** 是否只对叶子节点进行过滤 */ leafOnly?: boolean; childField?: keyof T; }): T[]; interface SortOptions { /** 属性名 */ key: T; /** 排序方法 */ method?: (prev: any, next: any) => number; /** 读取方法 */ accessor?: (...args: any[]) => any; /** 升降序 */ type?: 'asc' | 'desc'; /** 传入读取器的额外参数 */ params?: any[]; } /** * 根据依赖的属性对数组逐层排序 * * @param list 需要排序的数组 * @param props 排序依赖的属性 * * @returns 排序后的数组 */ declare function sortByProps(list: T[], props: keyof T | SortOptions | (keyof T | SortOptions)[]): T[]; /** * 将两个对象进行深度的动态合并 * * @param sourceObj 用于接收合并的源对象 * @param targetObj 被合并的对象，当属性名相同但值类型不同的情况，此对象的权重更高 * @param isNewObj 标记合并至一个全新的对象（深度的） * * @returns 合并后的对象 */ declare function mergeObjects, U extends Record>(sourceObj: T, targetObj: U, isNewObj?: boolean): T & U; /** * 将一个任务队列按每帧一次依次指定，返回一个触发取消的方法 * * @param queue 任务队列 * * @returns 终止队列执行的方法 */ declare function runQueueFrame(queue: Array<() => void>): () => boolean; /** * 深度克隆一个对象 * @param source 要克隆的对象 * @param cache 用于处理循环引用的缓存Map (内部使用) * @returns 深度克隆后的新对象 */ declare function cloneDeep(source: T, cache?: WeakMap): T; /** * 原地洗牌算法 (Fisher-Yates) * @param array 要洗牌的数组 * @returns 洗牌后的同一数组 (原地修改) */ declare function shuffle(array: T[]): T[]; /** * 不改变原数组的洗牌 * @param array 要洗牌的数组 * @returns 洗牌后的新数组 */ declare function shuffled(array: readonly T[]): T[]; export { AnyCase, BITree, CLICK_TYPE, COLOR_NAMES, CapitalCase, Color, ColorMeta, ColorName, ColorType, DateTime, DeepCloneOptions, EventBus, EventEmitter, EventHandler, EventHandlerMap, EventHandlerSet, EventPayload, EventType, HEX3Color, HEX4Color, HEX6Color, HEX8Color, HEX_REG_3, HEX_REG_4, HEX_REG_6, HEX_REG_8, HSLAColor, HSLA_REG, HSLColor, HSL_REG, HSVAColor, HSVA_REG, HSVColor, HSV_REG, Key, KeyCombo, KeyEventOptions, KeyboardListener, Listener, LongPressOptions, MouseButton, MouseEventOptions, MouseListener, NAMED_COLORS, ObjectColor, ObjectLocalStorage, RGBAColor, RGBA_REG, RGBColor, RGB_REG, SizeUnit, SizeUnitWithAuto, SortOptions, TransferNode, TreeOptions, USE_TOUCH, adjustAlpha, base64Decode, base64Encode, boundRange, transformTree as buildTree, caesarCipher, callIfFunc, cloneDeep, contains, createBITree, createCounter, createEventEmitter, debounce, debounceFrame, debounceMinor, decide, decimalLength, deepClone, destroyObject, digitLength, dispatchEvent, divide, doubleDigits, ensureArray, errorOnce, escapeHtml, filterTree, flatTree, formatByteSize, formatDate, getCurrentMonth, getCurrentWeek, getDateRange, getGlobalCount, getLast, getRangeWidth, getType, getXBorder, getXMargin, getXPadding, getYBorder, getYMargin, getYPadding, groupByProps, has, hslToHsv, hslToRgb, hsvToHsl, hsvToRgb, humanizeDiff, infoOnce, is, isArray, isBigInt, isBoolean, isClass, isClient, isColor, isDate, isDefined, isDisabled, isElement, isEmail, isEmpty, isEmptyObject, isExist, isFalse, isFocusIn, isFunction, isHex, isHidden, isIOS, isIterable, isMap, isNaN, isNull, isNumber, isObject, isPhone, isPromise, isRegExp, isRgb, isRgba, isSet, isString, isSymbol, isTrue, isUndefined, isValidNumber, isVisible, isWindow, leaveNumber, listToMap, mapTree, mergeObjects, minus, mixColor, multipleFixed, nextFrameOnce, nextTickOnce, noop, normalizeAlpha, normalizeHsl, normalizeHsv, normalizePath, normalizeRgb, numberRE, ordinalNumber, padStartZeros, parseColor, parseColorToRgba, parseStringColor, plus, queryAll, queryTabables, raf, random, randomColor, randomHardColor, randomPreferColor, randomSoftColor, randomString, range, readClipboard, removeArrayItem, rgbToHex, rgbToHsl, rgbToHsv, rgbaToHex, round, runParallel, runQueueFrame, segmentNumber, setGlobalCount, shuffle, shuffled, sortByProps, supportFlexGap, supportImgLoading, throttle, timeAgo, times, toAttrValue, toCamelCase, toCapitalCase, toCssSize, toFalse, toFixed, toGrayScale, toKebabCase, toNumber, toPrecision, toTrue, listToMap as transformListToMap, transformTree, walkTree, warnOnce, writeClipboard, xorCipher };