2284 lines
59 KiB
TypeScript
2284 lines
59 KiB
TypeScript
/**
|
||
* 为日期增减给定的天数
|
||
*
|
||
* @param date 原始日期
|
||
* @param amount 增减的天数
|
||
*
|
||
* @returns 修改后的日期
|
||
*/
|
||
export declare function addDays(date: Dateable, amount: number): Date;
|
||
|
||
/**
|
||
* 为日期增减给定的半天数（12小时）
|
||
*
|
||
* @param date 原始日期
|
||
* @param amount 增减的半天数
|
||
*
|
||
* @returns 修改后的日期
|
||
*/
|
||
export declare function addHalfDays(date: Dateable, amount: number): Date;
|
||
|
||
/**
|
||
* 为日期增减给定的小时
|
||
*
|
||
* @param date 原始日期
|
||
* @param amount 增减的小时
|
||
*
|
||
* @returns 修改后的日期
|
||
*/
|
||
export declare function addHours(date: Dateable, amount: number): Date;
|
||
|
||
/**
|
||
* 为日期增减给定的毫秒
|
||
*
|
||
* @param date 原始日期
|
||
* @param amount 增减的毫秒
|
||
*
|
||
* @returns 修改后的日期
|
||
*/
|
||
export declare function addMilliseconds(date: Dateable, amount: number): Date;
|
||
|
||
/**
|
||
* 为日期增减给定的分钟
|
||
*
|
||
* @param date 原始日期
|
||
* @param amount 增减的分钟
|
||
*
|
||
* @returns 修改后的日期
|
||
*/
|
||
export declare function addMinutes(date: Dateable, amount: number): Date;
|
||
|
||
/**
|
||
* 为日期增减给定的月数
|
||
*
|
||
* @param date 原始日期
|
||
* @param amount 增减的月数
|
||
*
|
||
* @returns 修改后的日期
|
||
*/
|
||
export declare function addMonths(date: Dateable, amount: number): Date;
|
||
|
||
/**
|
||
* 为日期增减给定的季度（3个月）
|
||
*
|
||
* @param date 原始日期
|
||
* @param amount 增减的季度
|
||
*
|
||
* @returns 修改后的日期
|
||
*/
|
||
export declare function addQuarters(date: Dateable, amount: number): Date;
|
||
|
||
/**
|
||
* 为日期增减给定的秒
|
||
*
|
||
* @param date 原始日期
|
||
* @param amount 增减的秒
|
||
*
|
||
* @returns 修改后的日期
|
||
*/
|
||
export declare function addSeconds(date: Dateable, amount: number): Date;
|
||
|
||
/**
|
||
* 为日期增减给定的周数
|
||
*
|
||
* @param date 原始日期
|
||
* @param amount 增减的周数
|
||
*
|
||
* @returns 修改后的日期
|
||
*/
|
||
export declare function addWeeks(date: Dateable, amount: number): Date;
|
||
|
||
/**
|
||
* 为日期增减给定的年份
|
||
*
|
||
* @param date 原始日期
|
||
* @param amount 增减的年份
|
||
*
|
||
* @returns 修改后的日期
|
||
*/
|
||
export declare function addYears(date: Dateable, amount: number): Date;
|
||
|
||
/**
|
||
* 调整给定颜色值的透明度
|
||
*
|
||
* @param color 需要调整的颜色
|
||
* @param alpha 调整后的透明度 0 ~ 1，0% ~ 100%
|
||
*
|
||
* @returns 调整后的颜色
|
||
*/
|
||
export declare function adjustAlpha(color: Color, alpha: number | string): RGBAColor;
|
||
|
||
/**
|
||
* 将给定的常量字符串类型拓展为不区分大小写的任意组合
|
||
*/
|
||
export declare type AnyCase<S> = string extends S ? string : S extends `${infer F1}${infer F2}${infer R}` ? `${Uppercase<F1> | Lowercase<F1>}${Uppercase<F2> | Lowercase<F2>}${AnyCase<R>}` : S extends `${infer F}${infer R}` ? `${Uppercase<F> | Lowercase<F>}${AnyCase<R>}` : '';
|
||
|
||
export declare 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;
|
||
}
|
||
|
||
/**
|
||
* 将给定的数字限定在指定的范围内
|
||
*
|
||
* @param number 需要限定范围的数
|
||
* @param min 边界最小值，包含该值
|
||
* @param max 边界最大值，包含该值
|
||
*
|
||
* @returns 限定在范围内的值
|
||
*/
|
||
export declare function boundRange(number: number | string, min: number, max: number): number;
|
||
|
||
/**
|
||
* 如果一个值为函数，则执行它并返回结果，否则返回其本身
|
||
*
|
||
* @param value 指定的值
|
||
* @param args 若为函数时，传入的参数
|
||
*
|
||
* @returns 原始值或函数执行结果
|
||
*/
|
||
export declare function callIfFunc<T, P extends any[] = any[]>(value: T | ((...args: P) => T), ...args: P): T;
|
||
|
||
/**
|
||
* 将给定的常量字符串类型拓展为大驼峰
|
||
*/
|
||
export declare type CapitalCase<T extends string> = T extends `${infer First} ${infer Rest}` ? CapitalCase<`${First}-${Rest}`> : T extends `${infer First}-${infer Rest}` ? `${Capitalize<First>}${CapitalCase<Rest>}` : Capitalize<T>;
|
||
|
||
/**
|
||
* 当前点击的类型，可以使用触摸交互时为 `pointerdown`，否则为 `click`
|
||
*/
|
||
export declare const CLICK_TYPE: string;
|
||
|
||
export declare type Color = string | RGBColor | RGBAColor | HSLColor | HSLAColor | HSVColor | HSVAColor | HEX3Color | HEX4Color | HEX6Color | HEX8Color;
|
||
|
||
export declare const COLOR_NAMES: Readonly<Set<ColorName>>;
|
||
|
||
export declare interface ColorMeta {
|
||
rgb: RGBColor;
|
||
hsl: HSLColor;
|
||
hsv: HSVColor;
|
||
hex: string;
|
||
alpha: number;
|
||
rgba: RGBAColor;
|
||
hsla: HSLAColor;
|
||
hsva: HSVAColor;
|
||
hex8: string;
|
||
gray: number;
|
||
origin: Color;
|
||
}
|
||
|
||
export declare type ColorName = keyof typeof NAMED_COLORS;
|
||
|
||
export declare type ColorType = 'hex' | 'rgb' | 'hsv' | 'hsl';
|
||
|
||
/**
|
||
* 升序比较两个日期大小，用于给数组的 sort 方法使用
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 比较后的结果，`-1` 则左侧小，`1` 则右侧小，`0` 则相等
|
||
*/
|
||
export declare function compareAsc(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 降序比较两个日期大小，用于给数组的 sort 方法使用
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 比较后的结果，`1` 则左侧小，`-1` 则右侧小，`0` 则相等
|
||
*/
|
||
export declare function compareDesc(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 判断一个元素是否包含另一个元素
|
||
*
|
||
* @param el 被包含的元素（子元素）
|
||
* @param parent 包含的元素（父元素）
|
||
*
|
||
* @returns 元素是否包含另一个元素
|
||
*/
|
||
export declare function contains(el?: Element | null, parent?: HTMLElement | null): boolean;
|
||
|
||
/**
|
||
* 创建一个二叉索引树（Fenwick 树）对象
|
||
*
|
||
* 为了节省初始化性能开销，需确保元素最小值已知，其初始值为：元素最小值 * 元素总数
|
||
*
|
||
* @param length 树的大小，即元素的总数
|
||
* @param min 规定元素的最小值
|
||
*
|
||
* @returns 二叉索引树对象
|
||
*/
|
||
export declare function createBITree(length: number, min?: number): BITree;
|
||
|
||
export declare function createCounter(count?: number): {
|
||
getCount: () => number;
|
||
setCount: (newCount: number) => void;
|
||
};
|
||
|
||
/**
|
||
* 创建一个自定义的事件发射器
|
||
*
|
||
* @returns 事件发射器
|
||
*/
|
||
export declare function createEventEmitter(): EventEmitter;
|
||
|
||
export declare type Dateable = number | string | Date;
|
||
|
||
export declare const DAY_ON_HOURS = 24;
|
||
|
||
export declare const DAY_ON_MILLISECONDS: number;
|
||
|
||
/** @deprecated renames to `DAY_ON_MILLISECONDS` */
|
||
export declare const DAY_ON_MILLS: number;
|
||
|
||
export declare const DAY_ON_MINUTES: number;
|
||
|
||
export declare const DAY_ON_SECONDS: number;
|
||
|
||
/**
|
||
* 将一个方法进行防抖
|
||
*
|
||
* @param method 需要防抖的方法，需自行绑定 this
|
||
* @param delay 防抖的限制时间，默认 100ms
|
||
*
|
||
* @returns 防抖后的方法
|
||
*/
|
||
export declare function debounce<T extends (...args: any[]) => any>(method: T, delay?: number): (...args: Parameters<T>) => void;
|
||
|
||
/**
|
||
* 对给定的方法进行渲染帧级别的防抖
|
||
*
|
||
* @param method 需要防抖的方法，需自行绑定 this
|
||
*
|
||
* @returns 防抖后的方法
|
||
*/
|
||
export declare function debounceFrame<T extends (...args: any[]) => any>(method: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
|
||
|
||
/**
|
||
* 对给定的方法进行微任务级别的防抖
|
||
*
|
||
* @param method 需要防抖的方法，需自行绑定 this
|
||
*
|
||
* @returns 防抖后的方法
|
||
*/
|
||
export declare function debounceMinor<T extends (...args: any[]) => any>(method: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
|
||
|
||
/**
|
||
* 根据一系列判断条件，执行第一个为 `true` 的条件所对应的回调函数
|
||
*
|
||
* @param conditions 判断条件及回调函数
|
||
* @param options 额外的选项
|
||
*
|
||
* @returns 是否匹配了任一条件
|
||
*/
|
||
export declare function decide(conditions: [boolean | (() => boolean), () => void | Promise<void>][], options?: {
|
||
/**
|
||
* 当匹配任意一个条件时，会在该条件对应的回调函数执行前执行
|
||
*/
|
||
beforeMatchAny?: () => void | Promise<void>;
|
||
/**
|
||
* 当匹配任意一个条件时，会在该条件对应的回调函数执行完后执行
|
||
*/
|
||
afterMatchAny?: () => void | Promise<void>;
|
||
}): Promise<boolean>;
|
||
|
||
/**
|
||
* 返回数字的小数位数
|
||
*
|
||
* @param number 指定的数字
|
||
*
|
||
* @returns 数字的小数位数
|
||
*/
|
||
export declare function decimalLength(number: number | string): number;
|
||
|
||
/**
|
||
* 深度拷贝对象或数组
|
||
*
|
||
* @param obj 需要拷贝的对象或数组
|
||
*
|
||
* @returns 克隆后的对象
|
||
*/
|
||
export declare function deepClone<T>(obj: T, options?: DeepCloneOptions): T;
|
||
|
||
export declare interface DeepCloneOptions {
|
||
/**
|
||
* 一个自定义的克隆对象方法，用于处理方法内置以外的对象克隆，如 Class 的实例
|
||
*
|
||
* @param type 对象的类型，注意格式为大驼峰
|
||
* @param obj 原始对象
|
||
*
|
||
* @returns 克隆后对象
|
||
*/
|
||
cloneObject?: (type: string, obj: unknown) => any;
|
||
}
|
||
|
||
/**
|
||
* 将一个对象销毁，销毁后的对象所有方法不可用，属性值均为 `null`
|
||
*
|
||
* @param object 要销毁的对象
|
||
* @param message 销毁后，调用方法时的错误信息
|
||
*/
|
||
export declare function destroyObject(object: any, message?: string): void;
|
||
|
||
/**
|
||
* 比较两个日期相差的天数
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的天数
|
||
*/
|
||
export declare function differenceDays(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的完整天
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的完整天数
|
||
*/
|
||
export declare function differenceFullDays(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的完整小时
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的完整小时数
|
||
*/
|
||
export declare function differenceFullHours(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的完整分钟
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的完整分钟数
|
||
*/
|
||
export declare function differenceFullMinutes(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的完整月
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的完整月份
|
||
*/
|
||
export declare function differenceFullMonths(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的完整季度
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的完整季度
|
||
*/
|
||
export declare function differenceFullQuarters(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的完整秒
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的完整秒数
|
||
*/
|
||
export declare function differenceFullSeconds(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的完整周
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的完整周数
|
||
*/
|
||
export declare function differenceFullWeeks(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的完整年份
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的完整年份
|
||
*/
|
||
export declare function differenceFullYears(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的小时
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的小时数
|
||
*/
|
||
export declare function differenceHours(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的毫秒
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的毫秒数
|
||
*/
|
||
export declare function differenceMilliseconds(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的分钟
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的分钟数
|
||
*/
|
||
export declare function differenceMinutes(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的月
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的月份
|
||
*/
|
||
export declare function differenceMonths(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的季度
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的季度
|
||
*/
|
||
export declare function differenceQuarters(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的秒
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的秒数
|
||
*/
|
||
export declare function differenceSeconds(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的周
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
* @param weekStartOn 设定周的第一天，默认为周日
|
||
*
|
||
* @returns 相差的周数
|
||
*/
|
||
export declare function differenceWeeks(left: Dateable, right: Dateable, weekStartOn?: number): number;
|
||
|
||
/**
|
||
* 比较两个日期相差的年份
|
||
*
|
||
* @param left 原始日期
|
||
* @param right 原始日期
|
||
*
|
||
* @returns 相差的年份
|
||
*/
|
||
export declare function differenceYears(left: Dateable, right: Dateable): number;
|
||
|
||
/**
|
||
* Return decimal length of a number
|
||
*
|
||
* @param number The input number
|
||
* @deprecated Using `decimalLength` to replace it
|
||
*/
|
||
export declare function digitLength(number: number | string): number;
|
||
|
||
/**
|
||
* 为指定的元素派发事件
|
||
*
|
||
* @param el 指定的元素
|
||
* @param payload 事件的属性
|
||
* @param Event 事件类
|
||
*
|
||
* @returns 事件是否派发成功
|
||
*/
|
||
declare function dispatchEvent_2(el: Element, payload: EventPayload, Event?: {
|
||
new (type: string, eventInitDict?: EventInit): Event;
|
||
prototype: Event;
|
||
readonly NONE: 0;
|
||
readonly CAPTURING_PHASE: 1;
|
||
readonly AT_TARGET: 2;
|
||
readonly BUBBLING_PHASE: 3;
|
||
}): boolean;
|
||
export { dispatchEvent_2 as dispatchEvent }
|
||
|
||
/**
|
||
* 精确的除法
|
||
*
|
||
* @param numbers 需要依次相除的数字
|
||
*
|
||
* @returns 商
|
||
*/
|
||
export declare const divide: (...numbers: (number | string)[]) => number;
|
||
|
||
/**
|
||
* 将小于 10 整数 N 变成 `0N` 的字符串，方法不会对入参校验
|
||
*
|
||
* @param number 需要处理的整数
|
||
*
|
||
* @returns 填充后的字面值
|
||
*/
|
||
export declare function doubleDigits(number: number): string;
|
||
|
||
/**
|
||
* 获取给定日期所在天的结束日期
|
||
*
|
||
* @param date 原始日期
|
||
*
|
||
* @returns 新的开始日期
|
||
*/
|
||
export declare function endOfDay(date: Dateable): Date;
|
||
|
||
/**
|
||
* 如果一个值不为数组，则将其转换为数组
|
||
*
|
||
* @param value 指定的值
|
||
*
|
||
* @returns 原始数组或转换后的数组
|
||
*/
|
||
export declare function ensureArray<T>(value: T | T[]): T[];
|
||
|
||
/**
|
||
* 仅发出一次的错误消息
|
||
*
|
||
* @param message 消息内容
|
||
* @param logFn 输出函数
|
||
*/
|
||
export declare function errorOnce(message: string, logFn?: (...data: any[]) => void): void;
|
||
|
||
/**
|
||
* 将 html 内容的敏感字符进行转换
|
||
*
|
||
* @param string html 内容
|
||
*
|
||
* @returns 转换后的 html 内容
|
||
*/
|
||
export declare function escapeHtml(string: unknown): string;
|
||
|
||
export declare 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;
|
||
}
|
||
|
||
export declare type EventHandler = (...payload: any[]) => void;
|
||
|
||
export declare type EventHandlerMap = Map<EventType, EventHandlerSet>;
|
||
|
||
export declare type EventHandlerSet = Set<EventHandler>;
|
||
|
||
export declare interface EventPayload extends EventInit {
|
||
/**
|
||
* 事件的类型
|
||
*/
|
||
type: string;
|
||
[prop: string]: any;
|
||
}
|
||
|
||
export declare type EventType = number | string | symbol;
|
||
|
||
/**
|
||
* 遍历树并为每个节点执行过滤方法，并用符合条件的节点构建一棵新的树
|
||
*
|
||
* @param tree 要遍历的树
|
||
* @param cb 过滤的方法
|
||
* @param options 遍历的配置项
|
||
*
|
||
* @returns 过滤后新的树
|
||
*/
|
||
export declare function filterTree<T = any>(tree: T[], cb: (item: T, depth: number, parent: T | null) => boolean, options?: {
|
||
/** 判断一个节点是否为叶子节点 */
|
||
isLeaf?: (item: T) => boolean;
|
||
/** 是否只对叶子节点进行过滤 */
|
||
leafOnly?: boolean;
|
||
childField?: keyof T;
|
||
}): T[];
|
||
|
||
/**
|
||
* 将一个树展平成列表
|
||
*
|
||
* @param tree 要展平的树
|
||
* @param options 转换的配置项
|
||
*
|
||
* @returns 展平后的列表
|
||
*/
|
||
export declare function flatTree<T = any>(tree: T[], options?: TreeOptions<keyof T> & {
|
||
/** 是否为深度优先遍历 */
|
||
depthFirst?: boolean;
|
||
/**
|
||
* 是否为无 ID 的节点插入 ID 值
|
||
*
|
||
* @default true
|
||
*/
|
||
injectId?: boolean;
|
||
/** 构建节点的 ID 的方法 */
|
||
buildId?: (index: number) => any;
|
||
/** 过滤节点的方法 */
|
||
filter?: (item: T) => boolean;
|
||
/** 过滤的结果是否会影响其子级 */
|
||
cascaded?: boolean;
|
||
/** 是否强制为节点插入 ID 值 */
|
||
forceInject?: boolean;
|
||
}): T[];
|
||
|
||
/**
|
||
* 将日期格式化成指定格式
|
||
*
|
||
* @param date 需要格式化的Date对象
|
||
* @param pattern 格式化结构 年-y 月-M 日-d 时-H 分-m 秒-s 季度-q
|
||
*
|
||
* @returns 格式化后的字面值
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* format(new Date(), 'yyyy-MM-dd')
|
||
* ```
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* format(Date.now(), 'yyyy-MM-dd\'T\'HH:mm:ss\'Z\'')
|
||
* ```
|
||
*/
|
||
export declare function format(date: Dateable, pattern?: string): string;
|
||
|
||
/**
|
||
* 根据给定的 Byte 数值，将其格式化成指定单位的大小
|
||
*
|
||
* @param byte 需要计算的 Byte 数值
|
||
* @param unit 格式化的单位
|
||
* @param precision 结果的精度
|
||
* @param joinUtil 是否加入单位
|
||
*
|
||
* @returns 格式化后的值
|
||
*/
|
||
export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto): number;
|
||
|
||
export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, precision?: number): number;
|
||
|
||
export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, joinUtil?: true): number;
|
||
|
||
export declare function formatByteSize(byte: number, unit?: SizeUnitWithAuto, joinUtil?: true, precision?: number): number;
|
||
|
||
/**
|
||
* 获取中文星期
|
||
*
|
||
* @param date 给定的日期
|
||
*
|
||
* @returns 中文星期
|
||
*/
|
||
export declare function getChineseWeek(date: Date): string;
|
||
|
||
export declare function getGlobalCount(): number;
|
||
|
||
/**
|
||
* 获取字符串的最后一个字符
|
||
*
|
||
* @param value 指定的字符串
|
||
*
|
||
* @returns 最后一个字符
|
||
*/
|
||
export declare function getLast(value: string): string | undefined;
|
||
|
||
/**
|
||
* 获取数组的最后一个元素
|
||
*
|
||
* @param value 指定的数组
|
||
*
|
||
* @returns 最后一个元素
|
||
*/
|
||
export declare function getLast<T>(value: T[]): T | undefined;
|
||
|
||
/**
|
||
* 获取给定年份和月份的最后一天
|
||
*
|
||
* @param year 原始年份
|
||
* @param month 原始月份
|
||
*
|
||
* @returns 最后一天
|
||
*/
|
||
export declare function getLastDayOfMonth(year: number, month: number): number;
|
||
|
||
/**
|
||
* 根据给定的日期获取上一个周日
|
||
*
|
||
* @param date 原始日期
|
||
*
|
||
* @returns 上一个周日
|
||
*/
|
||
export declare function getLastSunday(date: Date): Date;
|
||
|
||
/**
|
||
* 获取日期所在的季度
|
||
*
|
||
* @param date 给定的日期
|
||
*
|
||
* @returns 日期所在的季度
|
||
*/
|
||
export declare function getQuarter(date: Dateable): number;
|
||
|
||
/**
|
||
* 获取元素的选中宽度
|
||
*
|
||
* @param el 指定的元素
|
||
*
|
||
* @returns 元素的选中宽度
|
||
*/
|
||
export declare function getRangeWidth(el: HTMLElement | null): number;
|
||
|
||
/**
|
||
* 获取日期的时间部分
|
||
*
|
||
* @param date 给定的日期
|
||
*
|
||
* @returns 日期的时间部分
|
||
*/
|
||
export declare function getTime(date: Dateable): string;
|
||
|
||
/**
|
||
* 获取变量的类型
|
||
*
|
||
* @param value 任意变量
|
||
*
|
||
* @returns 变量的类型
|
||
*/
|
||
export declare function getType(value: unknown): string;
|
||
|
||
/**
|
||
* 获取元素横向的边框像素值
|
||
*
|
||
* @param el 指定的元素
|
||
*
|
||
* @returns 元素横向的边框像素值
|
||
*/
|
||
export declare function getXBorder(el: HTMLElement | null): number;
|
||
|
||
/**
|
||
* 获取元素横向的外边距像素值
|
||
*
|
||
* @param el 指定的元素
|
||
*
|
||
* @returns 元素横向的外边距像素值
|
||
*/
|
||
export declare function getXMargin(el: HTMLElement | null): number;
|
||
|
||
/**
|
||
* 获取元素横向的内边距像素值
|
||
*
|
||
* @param el 指定的元素
|
||
*
|
||
* @returns 元素横向的内边距像素值
|
||
*/
|
||
export declare function getXPadding(el: HTMLElement | null): number;
|
||
|
||
/**
|
||
* 获取元素纵向的边框像素值
|
||
*
|
||
* @param el 指定的元素
|
||
*
|
||
* @returns 元素纵向的边框像素值
|
||
*/
|
||
export declare function getYBorder(el: HTMLElement | null): number;
|
||
|
||
/**
|
||
* 获取元素纵向的外边距像素值
|
||
*
|
||
* @param el 指定的元素
|
||
*
|
||
* @returns 元素纵向的外边距像素值
|
||
*/
|
||
export declare function getYMargin(el: HTMLElement | null): number;
|
||
|
||
/**
|
||
* 获取元素纵向的内边距像素值
|
||
*
|
||
* @param el 指定的元素
|
||
*
|
||
* @returns 元素纵向的内边距像素值
|
||
*/
|
||
export declare function getYPadding(el: HTMLElement | null): number;
|
||
|
||
/**
|
||
* 按照一定顺序的属性对数据进行分组
|
||
*
|
||
* @param list 需要分数的数据
|
||
* @param props 需要按顺序分组的属性
|
||
*
|
||
* @returns 分组后的对象
|
||
*/
|
||
export declare function groupByProps<T = any>(list: T[], props?: Array<string | ((item: T) => any)> | string | ((item: T) => any)): Record<string, T[]>;
|
||
|
||
/**
|
||
* 判断一个对象是否包含指定的键值
|
||
*
|
||
* @param value 需判断的对象
|
||
* @param key 指定的键值
|
||
*
|
||
* @returns 是否包含键值
|
||
*/
|
||
export declare function has(value: Record<string, any>, key: string | symbol): key is keyof typeof value;
|
||
|
||
export declare interface HEX3Color extends RGB {
|
||
a?: 1;
|
||
format?: 'name' | 'hex3';
|
||
}
|
||
|
||
export declare interface HEX4Color extends RGB {
|
||
a: number;
|
||
format?: 'name' | 'hex4';
|
||
}
|
||
|
||
export declare interface HEX6Color extends RGB {
|
||
a?: 1;
|
||
format?: 'name' | 'hex6';
|
||
}
|
||
|
||
export declare interface HEX8Color extends RGB {
|
||
a: number;
|
||
format?: 'name' | 'hex8';
|
||
}
|
||
|
||
export declare const HEX_REG_3: RegExp;
|
||
|
||
export declare const HEX_REG_4: RegExp;
|
||
|
||
export declare const HEX_REG_6: RegExp;
|
||
|
||
export declare const HEX_REG_8: RegExp;
|
||
|
||
export declare const HOUR_ON_MILLISECONDS: number;
|
||
|
||
/** @deprecated renames to `HOUR_ON_MILLISECONDS` */
|
||
export declare const HOUR_ON_MILLS: number;
|
||
|
||
export declare const HOUR_ON_MINUTES = 60;
|
||
|
||
export declare const HOUR_ON_SECONDS: number;
|
||
|
||
declare interface HSL extends Record<any, any> {
|
||
h: number;
|
||
s: number;
|
||
l: number;
|
||
a?: number;
|
||
}
|
||
|
||
export declare const HSL_REG: RegExp;
|
||
|
||
export declare const HSLA_REG: RegExp;
|
||
|
||
export declare interface HSLAColor extends HSL {
|
||
a: number;
|
||
format?: 'name' | 'hsla';
|
||
}
|
||
|
||
export declare interface HSLColor extends HSL {
|
||
a?: 1;
|
||
format?: 'name' | 'hsl';
|
||
}
|
||
|
||
/**
|
||
* 将 HSL 颜色转换为 HSV 颜色
|
||
*
|
||
* @param h 0 ~ 360
|
||
* @param s 0 ~ 1，0% ~ 100%
|
||
* @param l 0 ~ 1，0% ~ 100%
|
||
*
|
||
* @returns 转换后的 HSV 颜色
|
||
*/
|
||
export declare function hslToHsv(h: number | string, s: number | string, l: number | string): HSVColor;
|
||
|
||
/**
|
||
* 将 HSL 颜色转换为 RGB 颜色
|
||
*
|
||
* @param h 0 ~ 360
|
||
* @param s 0 ~ 1，0% ~ 100%
|
||
* @param l 0 ~ 1，0% ~ 100%
|
||
*
|
||
* @returns 转换后的 RGB 颜色
|
||
*/
|
||
export declare function hslToRgb(h: number | string, s: number | string, l: number | string): RGBColor;
|
||
|
||
declare interface HSV extends Record<any, any> {
|
||
h: number;
|
||
s: number;
|
||
v: number;
|
||
a?: number;
|
||
}
|
||
|
||
export declare const HSV_REG: RegExp;
|
||
|
||
export declare const HSVA_REG: RegExp;
|
||
|
||
export declare interface HSVAColor extends HSV {
|
||
a: number;
|
||
format?: 'name' | 'hsva';
|
||
}
|
||
|
||
export declare interface HSVColor extends HSV {
|
||
a?: 1;
|
||
format?: 'name' | 'hsv';
|
||
}
|
||
|
||
/**
|
||
* 将 HSV 颜色转换为 HSL 颜色
|
||
*
|
||
* @param h 0 ~ 360
|
||
* @param s 0 ~ 1，0% ~ 100%
|
||
* @param v 0 ~ 1，0% ~ 100%
|
||
*
|
||
* @returns 转换后的 HSL 颜色
|
||
*/
|
||
export 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 颜色
|
||
*/
|
||
export declare function hsvToRgb(h: number | string, s: number | string, v: number | string): RGBColor;
|
||
|
||
/**
|
||
* 仅发出一次的提示消息
|
||
*
|
||
* @param message 消息内容
|
||
* @param logFn 输出函数
|
||
*/
|
||
export declare function infoOnce(message: string, logFn?: (...data: any[]) => void): void;
|
||
|
||
/**
|
||
* 判断一个值是否为指定的类型
|
||
*
|
||
* @param value 需判断的值
|
||
* @param type 指定的类型，注意大小写
|
||
*
|
||
* @returns 类型是否匹配
|
||
*/
|
||
export declare function is(value: unknown, type: string): boolean;
|
||
|
||
/**
|
||
* 判断一个值是否为数组
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为数组
|
||
*/
|
||
export declare function isArray<T = any>(value: unknown): value is T[];
|
||
|
||
/**
|
||
* 判断一个值是否为 `BigInt`
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为 `BigInt`
|
||
*/
|
||
export declare function isBigInt(value: unknown): value is bigint;
|
||
|
||
/**
|
||
* 判断一个值是否为布尔值
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为布尔值
|
||
*/
|
||
export declare function isBoolean(value: unknown): value is boolean;
|
||
|
||
/** 当前环境是否为客户端 */
|
||
export declare const isClient: boolean;
|
||
|
||
/**
|
||
* 判断给定的字符串是否为一个合法颜色值
|
||
*
|
||
* @param value 原始字符串
|
||
*
|
||
* @returns 是否为合法颜色
|
||
*/
|
||
export declare function isColor(value: string): boolean;
|
||
|
||
/**
|
||
* 判断一个值是否为 `Date`
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为 `Date`
|
||
*/
|
||
export declare function isDate(value: unknown): value is Date;
|
||
|
||
/**
|
||
* 判断一个值是否已定义
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否已定义
|
||
*/
|
||
export declare function isDefined<T = unknown>(value: T | undefined | null): value is Exclude<T, undefined | null>;
|
||
|
||
/**
|
||
* 判断指定的元素是否被禁用
|
||
*
|
||
* @param el 需判断的元素
|
||
*
|
||
* @returns 元素是否被禁用
|
||
*/
|
||
export declare function isDisabled(el?: Element | null): boolean;
|
||
|
||
/**
|
||
* 判断一个值是否为 `Element`
|
||
*
|
||
* @param value 需判断的值
|
||
* @param ssr 是否考虑服务端渲染
|
||
*
|
||
* @returns 是否为 `Element`
|
||
*/
|
||
export declare function isElement<T extends Element = Element>(value: unknown, ssr?: boolean): value is T;
|
||
|
||
/**
|
||
* 判断一个值是否为空
|
||
*
|
||
* - 如果这是一个数组或字符串，则 `length` 为 `0` 时为空
|
||
* - 如果这是一个 `Set` 或 `Map`，则 `size` 为 `0` 时为空
|
||
* - 如果这是一个对象，则无任何键值时为空
|
||
* - 如果这是一个数字，则为 `NaN` 时为空
|
||
* - 其余情况下，未定义时为空
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为空
|
||
*/
|
||
export declare function isEmpty(value: unknown): boolean;
|
||
|
||
/**
|
||
* 判断一个值是否为 `false`
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为 `false`
|
||
*/
|
||
export declare function isFalse(value: unknown): value is false;
|
||
|
||
/**
|
||
* 判断指定的元素是否聚焦或包含聚焦的元素
|
||
*
|
||
* @param el 需判断的元素
|
||
*
|
||
* @returns 是否聚焦或包含聚焦的元素
|
||
*/
|
||
export declare function isFocusIn(el?: Element | null): boolean;
|
||
|
||
/**
|
||
* 判断一个值是否为函数
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为函数
|
||
*/
|
||
export declare function isFunction(value: unknown): value is (...any: any[]) => any;
|
||
|
||
/**
|
||
* 判断指定的元素是否隐藏
|
||
*
|
||
* @param el 需判断的元素
|
||
*
|
||
* @returns 元素是否隐藏
|
||
*/
|
||
export declare function isHidden(el?: Element | null): boolean;
|
||
|
||
/** 当前环境是否为 IOS */
|
||
export declare const isIOS: boolean | "";
|
||
|
||
/**
|
||
* 判断一个值能否被迭代
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 能否被迭代
|
||
*/
|
||
export declare function isIterable(value: unknown): boolean;
|
||
|
||
/**
|
||
* 判断给定的年份是否为闰年
|
||
*
|
||
* @param year 原始年份
|
||
*
|
||
* @returns 是否为闰年
|
||
*/
|
||
export declare function isLeapYear(year: number): boolean;
|
||
|
||
/**
|
||
* 判断一个值是否为 `Map`
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为 `Map`
|
||
*/
|
||
export declare function isMap<K = any, V = any>(value: unknown): value is Map<K, V>;
|
||
|
||
/**
|
||
* 判断一个值是否为 `NaN`
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为 `NaN`
|
||
*/
|
||
declare function isNaN_2(value: unknown): value is number;
|
||
export { isNaN_2 as isNaN }
|
||
|
||
/**
|
||
* 判断一个值是否未被定义
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否未定义
|
||
*/
|
||
export declare function isNull(value: unknown): value is null | undefined;
|
||
|
||
/**
|
||
* 判断一个值是否为数字
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为数字
|
||
*/
|
||
export declare function isNumber(value: unknown): value is number;
|
||
|
||
/**
|
||
* 判断一个值是否为对象
|
||
*
|
||
* 注意，`null` 与原生的特殊对象不被包含
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为对象
|
||
*/
|
||
export declare function isObject<T extends Record<any, any> = Record<any, any>>(value: unknown): value is T;
|
||
|
||
/**
|
||
* 判断一个值是否为 `Promise`
|
||
*
|
||
* 如果一个对象包含 `then` 和 `catch` 方法，则被认为是一个 `Promise`
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为 `Promise`
|
||
*/
|
||
export declare function isPromise<T = any>(value: unknown): value is Promise<T>;
|
||
|
||
/**
|
||
* 判断一个值是否为正则
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为正则
|
||
*/
|
||
export declare function isRegExp(value: unknown): value is RegExp;
|
||
|
||
/**
|
||
* 判断一个值是否为 `Set`
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为 `Set`
|
||
*/
|
||
export declare function isSet<T = any>(value: unknown): value is Set<T>;
|
||
|
||
/**
|
||
* 判断一个值是否为字符串
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为字符串
|
||
*/
|
||
export declare function isString(value: unknown): value is string;
|
||
|
||
/**
|
||
* 判断一个值是否为 `Symbol`
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为 `Symbol`
|
||
*/
|
||
export declare function isSymbol(value: unknown): value is symbol;
|
||
|
||
/**
|
||
* 判断一个值是否为 `true`
|
||
*
|
||
* @param value 需判断的值
|
||
*
|
||
* @returns 是否为 `true`
|
||
*/
|
||
export declare function isTrue(value: unknown): value is true;
|
||
|
||
/**
|
||
* 检测给定的值是否可以通过 parseFlat 或 Number 方法转为数字
|
||
*
|
||
* 开启严格模式则通过正则以更严格的方法判断
|
||
*
|
||
* @param value 需要检测的值
|
||
* @param strict 是否为严格模式
|
||
*
|
||
* @returns 值是否可以转为数字
|
||
*/
|
||
export declare function isValidNumber(value: unknown, strict?: boolean): boolean;
|
||
|
||
/**
|
||
* 判断指定的元素是否可见
|
||
*
|
||
* @param el 需判断的元素
|
||
*
|
||
* @returns 元素是否可见
|
||
*/
|
||
export declare function isVisible(el?: Element | null): boolean;
|
||
|
||
/**
|
||
* 将给定的被除数和除数，不断的取余直至达到次数限制或余数小于除数，返回系列余数
|
||
*
|
||
* @param number 被除数，需大于 0
|
||
* @param divideBy 除数，需大于 1
|
||
* @param limit 次数限制，默认为 0，小于 1 则不作限制
|
||
*
|
||
* @returns 相除过程的系列余数
|
||
*/
|
||
export declare function leaveNumber(number: number, divideBy: number, limit?: number): number[];
|
||
|
||
declare function listToMap<T = any, K extends keyof T = keyof T>(list: T[], prop: K, useMap?: false): Record<T[K] extends RecordKey ? T[K] : RecordKey, T>;
|
||
|
||
declare function listToMap<T = any, O = T, K extends keyof T = keyof T>(list: T[], prop: K, accessor?: (item: T) => O, useMap?: false): Record<T[K] extends RecordKey ? T[K] : RecordKey, O>;
|
||
|
||
declare function listToMap<T = any, K = RecordKey>(list: T[], prop: (item: T) => K, useMap?: false): Record<K extends RecordKey ? K : RecordKey, T>;
|
||
|
||
declare function listToMap<T = any, O = T, K = RecordKey>(list: T[], prop: (item: T) => K, accessor?: (item: T) => O, useMap?: false): Record<K extends RecordKey ? K : RecordKey, O>;
|
||
|
||
declare function listToMap<T = any, K extends keyof T = keyof T>(list: T[], prop: K, useMap?: true): Map<T[K], T>;
|
||
|
||
declare function listToMap<T = any, O = T, K extends keyof T = keyof T>(list: T[], prop: K, accessor?: (item: T) => O, useMap?: true): Map<T[K], O>;
|
||
|
||
declare function listToMap<T = any, K = any>(list: T[], prop: (item: T) => K, useMap?: true): Map<K, T>;
|
||
|
||
declare function listToMap<T = any, O = T, K = any>(list: T[], prop: (item: T) => K, accessor?: (item: T) => O, useMap?: true): Map<K, O>;
|
||
export { listToMap }
|
||
export { listToMap as transformListToMap }
|
||
|
||
/**
|
||
* 遍历树并为每个节点执行回调方法，并用其返回值构建一颗新的树
|
||
*
|
||
* @param tree 要遍历的树
|
||
* @param cb 回调函数
|
||
* @param options 遍历的配置项
|
||
*
|
||
* @returns 构建后新的树
|
||
*/
|
||
export declare function mapTree<T = any, R = any>(tree: T[], cb: (item: T, depth: number, parent: T | null) => R, options?: {
|
||
/** 是否为深度优先遍历 */
|
||
depthFirst?: boolean;
|
||
childField?: keyof T;
|
||
/** 是否强制重置 `children` 字段 */
|
||
clearChildren?: boolean;
|
||
}): R[];
|
||
|
||
/**
|
||
* 将两个对象进行深度的动态合并
|
||
*
|
||
* @param sourceObj 用于接收合并的源对象
|
||
* @param targetObj 被合并的对象，当属性名相同但值类型不同的情况，此对象的权重更高
|
||
* @param isNewObj 标记合并至一个全新的对象（深度的）
|
||
*
|
||
* @returns 合并后的对象
|
||
*/
|
||
export declare function mergeObjects<T extends Record<string, any>, U extends Record<string, any>>(sourceObj: T, targetObj: U, isNewObj?: boolean): T & U;
|
||
|
||
/**
|
||
* 精确的减法
|
||
*
|
||
* @param numbers 需要依次相减的数字
|
||
*
|
||
* @returns 差值
|
||
*/
|
||
export declare const minus: (...numbers: (number | string)[]) => number;
|
||
|
||
export declare const MINUTE_ON_MILLISECONDS: number;
|
||
|
||
/** @deprecated renames to `MINUTE_ON_MILLISECONDS` */
|
||
export declare const MINUTE_ON_MILLS: number;
|
||
|
||
export declare const MINUTE_ON_SECONDS = 60;
|
||
|
||
/**
|
||
* 将两种颜色按照一定的比例混合
|
||
*
|
||
* @param color1 第一种颜色
|
||
* @param color2 第二种颜色
|
||
* @param weight 混合比例 0 ~ 1，越小则第一种颜色越少
|
||
*
|
||
* @returns 混合后的颜色
|
||
*/
|
||
export declare function mixColor(color1: Color, color2: Color, weight?: number): RGBAColor;
|
||
|
||
/**
|
||
* 将给定的实数扩大一定的倍数并保留一定的小数
|
||
*
|
||
* @param number 要处理的实数
|
||
* @param multiple 要扩大的倍数
|
||
* @param decimal 要保留的小数
|
||
*
|
||
* @returns 扩大并保留小数后的值
|
||
*/
|
||
export declare function multipleFixed(number: number, multiple: number, decimal: number): number;
|
||
|
||
export 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";
|
||
}>;
|
||
|
||
/**
|
||
* 在下一渲染帧，仅执行一次传入的方法
|
||
*
|
||
* @param method 需要执行的方法
|
||
* @param args 方法的额外参数，在方法调用前多次传入将会覆盖之前的参数
|
||
*/
|
||
export declare function nextFrameOnce<T extends (...args: any[]) => any>(method: T, ...args: any[]): undefined;
|
||
|
||
/**
|
||
* 在下一微任务，仅执行一次传入的方法
|
||
*
|
||
* @param method 需要执行的方法
|
||
* @param args 方法的额外参数，在方法调用前多次传入将会覆盖之前的参数
|
||
*/
|
||
export declare function nextTickOnce<T extends (...args: any[]) => any>(method: T, ...args: any[]): undefined;
|
||
|
||
/**
|
||
* 一个空的占位函数
|
||
*/
|
||
export declare function noop(...args: any[]): any;
|
||
|
||
/**
|
||
* 将原始透明度值标准化为 0 ~ 1 的值
|
||
*
|
||
* @param a 0 ~ 1，0% ~ 100%
|
||
*
|
||
* @returns 标准化后的透明度
|
||
*/
|
||
export declare function normalizeAlpha(a: number | string): number;
|
||
|
||
/**
|
||
* 将原始的 h、s、l 值标准化为 0 ~ 1 的值
|
||
*
|
||
* @param h 0 ~ 360
|
||
* @param s 0 ~ 1，0% ~ 100%
|
||
* @param l 0 ~ 1，0% ~ 100%
|
||
*
|
||
* @returns 标准化后的 HSL 对象
|
||
*/
|
||
export declare function normalizeHsl(h: number | string, s: number | string, l: number | string): {
|
||
h: number;
|
||
s: number;
|
||
l: number;
|
||
};
|
||
|
||
/**
|
||
* 将原始的 h、s、v 值标准化为 0 ~ 1 的值
|
||
*
|
||
* @param h 0 ~ 360
|
||
* @param s 0 ~ 1，0% ~ 100%
|
||
* @param v 0 ~ 1，0% ~ 100%
|
||
*
|
||
* @returns 标准化的 HSV 对象
|
||
*/
|
||
export declare function normalizeHsv(h: number | string, s: number | string, v: number | string): {
|
||
h: number;
|
||
s: number;
|
||
v: number;
|
||
};
|
||
|
||
/**
|
||
* 将路径中的 `\` 替换为 `/`
|
||
*
|
||
* @param path 指定的路径
|
||
*
|
||
* @returns 替换后的路径
|
||
*/
|
||
export declare function normalizePath(path: string): string;
|
||
|
||
/**
|
||
* 将原始的 r、g、b 值标准化为 0 ~ 1 的值
|
||
*
|
||
* @param r 0 ~ 255
|
||
* @param g 0 ~ 255
|
||
* @param b 0 ~ 255
|
||
*
|
||
* @returns 标准化后 RGB 对象
|
||
*/
|
||
export declare function normalizeRgb(r: number | string, g: number | string, b: number | string): {
|
||
r: number;
|
||
g: number;
|
||
b: number;
|
||
};
|
||
|
||
export declare const numberRE: RegExp;
|
||
|
||
export declare type ObjectColor = Exclude<Color, string>;
|
||
|
||
/**
|
||
* 将给定的数字转换为序数词
|
||
*
|
||
* @param value 需要转换的数字
|
||
*
|
||
* @returns 转换后的序数词
|
||
*/
|
||
export declare function ordinalNumber(value: number): string;
|
||
|
||
/**
|
||
* 为给定的整数开头填充 0，直至满足指定的长度
|
||
*
|
||
* @param number 需要处理的整数
|
||
* @param length 填充至的长度
|
||
*
|
||
* @returns 填充后的字面值
|
||
*/
|
||
export declare function padStartZeros(number: number, length: number): string;
|
||
|
||
/**
|
||
* 将给定的 {@link Color} 解析为 {@link ColorMeta}
|
||
*
|
||
* @param color 原始颜色值
|
||
*
|
||
* @returns 解析后的颜色元数据
|
||
*/
|
||
export declare function parseColor(color: Color): ColorMeta;
|
||
|
||
/**
|
||
* 将给定的 {@link Color} 解析为 {@link RGBAColor}
|
||
*
|
||
* @param originColor 原始颜色值
|
||
*
|
||
* @returns 解析后的 RGB 颜色对象
|
||
*/
|
||
export declare function parseColorToRgba(originColor: Color): RGBAColor;
|
||
|
||
/**
|
||
* 将给定的字符串转化为 {@link ObjectColor}，无法转换时返回 null
|
||
*
|
||
* @param color 原始颜色字符串
|
||
*
|
||
* @returns 解析后的颜色对象
|
||
*/
|
||
export declare function parseStringColor(color: string): ObjectColor | null;
|
||
|
||
/**
|
||
* 精确的加法
|
||
*
|
||
* @param numbers 需要依次相加的数字
|
||
*
|
||
* @returns 和
|
||
*/
|
||
export declare const plus: (...numbers: (number | string)[]) => number;
|
||
|
||
export declare const QUARTER_ON_MONTHS = 3;
|
||
|
||
/**
|
||
* 检索匹配指定选择器的所有元素
|
||
*
|
||
* @param selector 选择器
|
||
* @param root 根元素，不指定时为 `document.body`
|
||
*
|
||
* @returns 匹配的所有元素
|
||
*/
|
||
export declare function queryAll(selector: string, root?: Element | null): HTMLElement[];
|
||
|
||
/**
|
||
* 检索可以被切换焦点（Tab）的元素
|
||
*
|
||
* @param root 根元素，不指定时为 `document.body`
|
||
* @param includeDisabled 是否包含被禁用的元素
|
||
*
|
||
* @returns 可以被切换焦点的元素
|
||
*/
|
||
export declare function queryTabables(root?: HTMLElement, includeDisabled?: boolean): HTMLElement[];
|
||
|
||
export declare const raf: (cb: FrameRequestCallback) => void;
|
||
|
||
/**
|
||
* 在给定的范围内随机一个数
|
||
*
|
||
* @param max 最大值
|
||
* @param min 最小值，默认为 0
|
||
*
|
||
* @returns 生成的随机数
|
||
*/
|
||
export declare function random(max: number, min?: number): number;
|
||
|
||
/**
|
||
* 随机生成一个颜色值
|
||
*
|
||
* @param withAlpha 是否具有透明度
|
||
* @param type 颜色的类型
|
||
*
|
||
* @returns 生成的颜色字面值
|
||
*/
|
||
export declare function randomColor(withAlpha?: boolean, type?: ColorType): string;
|
||
|
||
/**
|
||
* 随机生成一个冷色调的颜色值
|
||
*
|
||
* @param withAlpha 是否具有透明度
|
||
* @param type 颜色的类型
|
||
*
|
||
* @returns 生成的颜色字面值
|
||
*/
|
||
export declare function randomHardColor(withAlpha?: boolean, type?: ColorType): string;
|
||
|
||
/**
|
||
* 随机生成一个特定色调（冷暖色）的颜色值
|
||
*
|
||
* @param prefer 色调
|
||
* @param withAlpha 是否具有透明度
|
||
* @param type 颜色的类型
|
||
*
|
||
* @returns 生成的颜色字面值
|
||
*/
|
||
export declare function randomPreferColor(prefer: 'hard' | 'soft', withAlpha?: boolean, type?: ColorType): string;
|
||
|
||
/**
|
||
* 随机生成一个暖色调的颜色值
|
||
*
|
||
* @param withAlpha 是否具有透明度
|
||
* @param type 颜色的类型
|
||
*
|
||
* @returns 生成的颜色字面值
|
||
*/
|
||
export declare function randomSoftColor(withAlpha?: boolean, type?: ColorType): string;
|
||
|
||
/**
|
||
* 根据长度生成一串随机的字符串
|
||
*
|
||
* @param length 字符串的长度
|
||
*
|
||
* @returns 生成的字符串
|
||
*/
|
||
export declare function randomString(length?: number): string;
|
||
|
||
/**
|
||
* 生成一个值递进的数组
|
||
*
|
||
* @param size 大小
|
||
* @param start 开始的数值，默认为 1
|
||
* @param step 跨度，默认为 1
|
||
*
|
||
* @returns 生成的数组
|
||
*/
|
||
export declare function range(size: number, start?: number, step?: number): number[];
|
||
|
||
/**
|
||
* 生成一个天数递进的日期数组
|
||
*
|
||
* @param start 开始日期
|
||
* @param size range 的大小, 默认 42 (一般电子日历为 6 行 7 列)
|
||
* @param step range 的跨幅
|
||
*
|
||
* @returns 生成的日期数组
|
||
*/
|
||
export declare function rangeDate(start: Dateable, size?: number, step?: number): Date[];
|
||
|
||
/**
|
||
* 生成一个月份递进的日期数组
|
||
*
|
||
* @param start 开始日期
|
||
* @param size range 的大小, 默认 12 (一年)
|
||
* @param step range 的跨幅
|
||
*
|
||
* @returns 生成的日期数组
|
||
*/
|
||
export declare function rangeMonth(start: Dateable, size?: number, step?: number): Date[];
|
||
|
||
declare type RecordKey = string | number | symbol;
|
||
|
||
/**
|
||
* 移除数组中的某个元素
|
||
*
|
||
* @param array 需要被移除元素的数组
|
||
* @param item 需要被移除的元素, 或一个查找方法，如果元素为函数时则需要做一层简单包装
|
||
* @param isFn 标记数组的元素是否为函数
|
||
*
|
||
* @returns 被移除的元素
|
||
*/
|
||
export declare function removeArrayItem<T = any>(array: T[], item: T | ((item: T) => boolean), isFn?: boolean): T | null;
|
||
|
||
declare interface RGB extends Record<any, any> {
|
||
r: number;
|
||
g: number;
|
||
b: number;
|
||
a?: number;
|
||
}
|
||
|
||
export declare const RGB_REG: RegExp;
|
||
|
||
export declare const RGBA_REG: RegExp;
|
||
|
||
export declare interface RGBAColor extends RGB {
|
||
a: number;
|
||
format?: 'name' | 'rgba';
|
||
}
|
||
|
||
/**
|
||
* 将 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 颜色
|
||
*/
|
||
export declare function rgbaToHex(r: number | string, g: number | string, b: number | string, a: number | string, allow4Char?: boolean): string;
|
||
|
||
export declare interface RGBColor extends RGB {
|
||
a?: 1;
|
||
format?: 'name' | 'rgb';
|
||
}
|
||
|
||
/**
|
||
* 将 RGB 颜色转换为 HEX 颜色
|
||
*
|
||
* @param r 0 ~ 255
|
||
* @param g 0 ~ 255
|
||
* @param b 0 ~ 255
|
||
* @param allow3Char 是否允许 3 位的 HEX 值
|
||
*
|
||
* @returns 转换后的 HEX 颜色
|
||
*/
|
||
export declare function rgbToHex(r: number | string, g: number | string, b: number | string, allow3Char?: boolean): string;
|
||
|
||
/**
|
||
* 将 RGB 颜色转换为 HSL 颜色
|
||
*
|
||
* @param r 0 ~ 255
|
||
* @param g 0 ~ 255
|
||
* @param b 0 ~ 255
|
||
*
|
||
* @returns 转换后的 HSL 颜色
|
||
*/
|
||
export declare function rgbToHsl(r: number | string, g: number | string, b: number | string): HSLColor;
|
||
|
||
/**
|
||
* 将 RGB 颜色转换为 HSV 颜色
|
||
*
|
||
* @param r 0 ~ 255
|
||
* @param g 0 ~ 255
|
||
* @param b 0 ~ 255
|
||
*
|
||
* @returns 转换后的 HSV 颜色
|
||
*/
|
||
export declare function rgbToHsv(r: number | string, g: number | string, b: number | string): HSVColor;
|
||
|
||
/**
|
||
* 根据临界值对给定的数字进行舍入
|
||
*
|
||
* @param number 需要舍入的数
|
||
* @param criticalValue 舍入的临界值 (0 ~ 1)，达到临界值进位反之舍弃
|
||
*
|
||
* @returns 舍入后的值
|
||
*/
|
||
export declare function round(number: number, criticalValue: number): number;
|
||
|
||
/**
|
||
* 按指定的并发数，并行地为系列源数据执行操作
|
||
*
|
||
* @param maxConcurrency 最大的并发数
|
||
* @param source 源数据
|
||
* @param iteratorFn 处理操作的异步函数
|
||
*
|
||
* @returns 等待所有任务执行完的 Promise 对象
|
||
*/
|
||
export declare function runParallel<T>(maxConcurrency: number, source: T[], iteratorFn: (item: T, source: T[]) => Promise<any>): Promise<any[]>;
|
||
|
||
/**
|
||
* 将一个任务队列按每帧一次依次指定，返回一个触发取消的方法
|
||
*
|
||
* @param queue 任务队列
|
||
*
|
||
* @returns 终止队列执行的方法
|
||
*/
|
||
export declare function runQueueFrame(queue: Array<() => void>): () => boolean;
|
||
|
||
export declare const SECOND_ON_MILLISECONDS = 1000;
|
||
|
||
/** @deprecated renames to `SECOND_ON_MILLISECONDS` */
|
||
export declare const SECOND_ON_MILLS = 1000;
|
||
|
||
/**
|
||
* 将给定的数字格式化为指定的位阶
|
||
*
|
||
* @param number 需要格式化的数字
|
||
* @param segment 分隔的位数，默认为 3
|
||
* @param separator 分隔的符号，默认为 ','
|
||
*
|
||
* @returns 格式化后的字面值
|
||
*/
|
||
export declare function segmentNumber(number: number | string, segment?: number, separator?: string): string;
|
||
|
||
export declare function setGlobalCount(count: number): void;
|
||
|
||
export declare type SizeUnit = Exclude<SizeUnitWithAuto, AnyCase<'AUTO'>>;
|
||
|
||
export declare type SizeUnitWithAuto = AnyCase<'B' | 'KB' | 'MB' | 'GB' | 'TB' | 'AUTO'>;
|
||
|
||
/**
|
||
* 根据依赖的属性对数组逐层排序
|
||
*
|
||
* @param list 需要排序的数组
|
||
* @param props 排序依赖的属性
|
||
*
|
||
* @returns 排序后的数组
|
||
*/
|
||
export declare function sortByProps<T = any>(list: T[], props: keyof T | SortOptions<keyof T> | (keyof T | SortOptions<keyof T>)[]): T[];
|
||
|
||
export declare interface SortOptions<T = string> {
|
||
/** 属性名 */
|
||
key: T;
|
||
/** 排序方法 */
|
||
method?: (prev: any, next: any) => number;
|
||
/** 读取方法 */
|
||
accessor?: (...args: any[]) => any;
|
||
/** 升降序 */
|
||
type?: 'asc' | 'desc';
|
||
/** 传入读取器的额外参数 */
|
||
params?: any[];
|
||
}
|
||
|
||
/**
|
||
* 获取给定的日期所在天的开始日期
|
||
*
|
||
* @param date 原始日期
|
||
*
|
||
* @returns 新的开始日期
|
||
*/
|
||
export declare function startOfDay(date: Dateable): Date;
|
||
|
||
/**
|
||
* 获取给定的日期所在小时的开始日期 (分钟归零)
|
||
*
|
||
* @param date 原始日期
|
||
*
|
||
* @returns 新的开始日期
|
||
*/
|
||
export declare function startOfHour(date: Dateable): Date;
|
||
|
||
/**
|
||
* 获取给定的日期所在分钟的开始日期 (秒归零)
|
||
*
|
||
* @param date 原始日期
|
||
*
|
||
* @returns 新的开始日期
|
||
*/
|
||
export declare function startOfMinute(date: Dateable): Date;
|
||
|
||
/**
|
||
* 获取给定的日期所在月份的第一天的开始日期
|
||
*
|
||
* @param date 原始日期
|
||
* @param startOn 设定一个月的第一天，默认为 1 号
|
||
*
|
||
* @returns 新的开始日期
|
||
*/
|
||
export declare function startOfMonth(date: Dateable, startOn?: number): Date;
|
||
|
||
/**
|
||
* 获取给定日期所在季度的第一天的开始日期
|
||
*
|
||
* @param date 原始日期
|
||
*
|
||
* @returns 新的开始日期
|
||
*/
|
||
export declare function startOfQuarter(date: Dateable): Date;
|
||
|
||
/**
|
||
* 获取给定的日期所在秒的开始日期（毫秒归零）
|
||
*
|
||
* @param date 原始日期
|
||
*
|
||
* @returns 新的开始日期
|
||
*/
|
||
export declare function startOfSecond(date: Dateable): Date;
|
||
|
||
/**
|
||
* 获取给定的日期所在周的第一天的开始日期
|
||
*
|
||
* @param date 需要解析的时间
|
||
* @param startOn 设定周的第一天，默认为周日
|
||
*
|
||
* @returns 新的开始日期
|
||
*/
|
||
export declare function startOfWeek(date: Dateable, startOn?: number): Date;
|
||
|
||
/**
|
||
* 获取给定日期所在年份的第一天的开始日期
|
||
*
|
||
* @param date 原始日期
|
||
* @param startOn 设定年的开始月份，默认为一月
|
||
*
|
||
* @returns 新的开始日期
|
||
*/
|
||
export declare function startOfYear(date: Dateable, startOn?: number): Date;
|
||
|
||
/**
|
||
* 判断当前的环境是否支持 CSS 样式：`gap`、`row-gap` 和 `column-gap`
|
||
*
|
||
* @returns 是否支持
|
||
*/
|
||
export declare function supportFlexGap(): boolean;
|
||
|
||
/**
|
||
* 判断当前环境是否支持 `<img>` 标签的 `loading` 属性
|
||
*
|
||
* @returns 是否支持
|
||
*/
|
||
export declare function supportImgLoading(): boolean;
|
||
|
||
/**
|
||
* 将一个方法进行节流
|
||
*
|
||
* @param method 需要节流的方法，需自行绑定 this
|
||
* @param interval 节流后的触发间隔，默认 16 ms (1 帧)
|
||
*
|
||
* @returns 节流后的方法
|
||
*/
|
||
export declare function throttle<T extends (...args: any[]) => any>(method: T, interval?: number): (...args: Parameters<T>) => void;
|
||
|
||
/**
|
||
* 精确的乘法
|
||
*
|
||
* @param numbers 需要依次相乘的数字
|
||
*
|
||
* @returns 乘积
|
||
*/
|
||
export declare const times: (...numbers: (number | string)[]) => number;
|
||
|
||
/**
|
||
* 将指定的值转换为 HTML 属性值
|
||
*
|
||
* @param value 需要转换的值
|
||
*
|
||
* @returns 转换后的 HTML 属性值
|
||
*/
|
||
export declare function toAttrValue(value?: boolean | null): 'true' | undefined;
|
||
|
||
export declare function toAttrValue(value?: string | number | null): string | undefined;
|
||
|
||
/**
|
||
* 将字面值转换为小驼峰
|
||
*
|
||
* @param value 需要转换的字面值
|
||
*
|
||
* @returns 转换后的小驼峰字面值
|
||
*/
|
||
export declare function toCamelCase(value: string): string;
|
||
|
||
/**
|
||
* 将字面值转换为大驼峰
|
||
*
|
||
* @param value 需要转换的字面值
|
||
*
|
||
* @returns 转换后的大驼峰字面值
|
||
*/
|
||
export declare function toCapitalCase<T extends string>(value: T): CapitalCase<T>;
|
||
|
||
/**
|
||
* 给定的值如果为合法数字，则将转换为像素值
|
||
*
|
||
* @param value 需要判断的值
|
||
*
|
||
* @returns 转换后的像素值
|
||
*/
|
||
export declare function toCssSize(value: number | string): string;
|
||
|
||
/**
|
||
* 将任意可转为 `Date` 对象的变量转为一个新日期
|
||
*
|
||
* @param any 任意可转换的值
|
||
* @param strict 是否在传入非法值时抛错
|
||
*
|
||
* @returns 转换后的 `Date` 对象
|
||
*/
|
||
export declare function toDate(any: Dateable, strict?: boolean): Date;
|
||
|
||
/**
|
||
* 一个返回 `false` 的占位函数
|
||
*
|
||
* @returns `false`
|
||
*/
|
||
export declare function toFalse(...args: any[]): false;
|
||
|
||
/**
|
||
* 将给定的实数保留一定的小数
|
||
*
|
||
* @param number 需要处理的实数
|
||
* @param decimal 需要保留的小数
|
||
*
|
||
* @returns 保留小数后的值
|
||
*/
|
||
export declare function toFixed(number: number, decimal: number): number;
|
||
|
||
/**
|
||
* 获取给定颜色的灰度
|
||
*
|
||
* @param color 颜色字面值
|
||
*
|
||
* @returns 颜色的灰度
|
||
*/
|
||
export declare function toGrayScale(color: string): number;
|
||
|
||
/**
|
||
* 将字面值转换为短横线连接
|
||
*
|
||
* @param value 需要转换的字面值
|
||
*
|
||
* @returns 转换后的短横线连接字面值
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* toKebabCase('AaBbCc') // aa-bb-cc
|
||
* toKebabCase('AABb') // aa-bb
|
||
* toKebabCase('AAA') // aaa
|
||
* toKebabCase('AaBb CcDd') // aa-bb cc-dd
|
||
* ```
|
||
*/
|
||
export declare function toKebabCase(value: string): string;
|
||
|
||
/**
|
||
* 将给定的值转成数字，NaN 的情况将会处理成 0
|
||
*
|
||
* @param value 需要转换的值
|
||
*
|
||
* @returns 转换后的数字
|
||
*/
|
||
export declare function toNumber(value: unknown): number;
|
||
|
||
/**
|
||
* 将数字处理为的指定的有效位数
|
||
*
|
||
* @param number 需要处理的数字
|
||
* @param precision 数字的有效位数
|
||
*
|
||
* @returns 处理后的数字
|
||
*
|
||
* @example
|
||
* ```ts
|
||
* toPrecision(0.09999999999999998) === 0.1 // true
|
||
* ```
|
||
*/
|
||
export declare function toPrecision(number: number | string, precision?: number): number;
|
||
|
||
/**
|
||
* 一个返回 `true` 的占位函数
|
||
*
|
||
* @returns `true`
|
||
*/
|
||
export declare function toTrue(...args: any[]): true;
|
||
|
||
/**
|
||
* 专用的类型，用于适配 Vexip UI 中 `transfer` 属性的处理
|
||
*/
|
||
export declare interface TransferNode extends Element {
|
||
__transferElement?: Element | null;
|
||
}
|
||
|
||
/**
|
||
* 将一个展平的列表转换为树
|
||
*
|
||
* @param list 要转换的列表
|
||
* @param options 转换的配置项
|
||
*
|
||
* @returns 转换后的树
|
||
*/
|
||
declare function transformTree<T = any>(list: T[], options?: TreeOptions<keyof T>): T[];
|
||
export { transformTree as buildTree }
|
||
export { transformTree }
|
||
|
||
export declare interface TreeOptions<T = string> {
|
||
keyField?: T;
|
||
childField?: T;
|
||
parentField?: T;
|
||
/** 若指定，`parent` 值等于 `rootId` 的节点被认为是顶级节点 */
|
||
rootId?: any;
|
||
}
|
||
|
||
/**
|
||
* 当前是否可以使用触摸交互
|
||
*/
|
||
export declare const USE_TOUCH: boolean;
|
||
|
||
/**
|
||
* 遍历树并为每个节点执行回调方法
|
||
*
|
||
* @param tree 要遍历的树
|
||
* @param cb 回调函数
|
||
* @param options 遍历的配置项
|
||
*/
|
||
export declare function walkTree<T = any>(tree: T[], cb: (item: T, depth: number, parent: T | null) => void, options?: {
|
||
/** 是否为深度优先遍历 */
|
||
depthFirst?: boolean;
|
||
childField?: keyof T;
|
||
}): void;
|
||
|
||
/**
|
||
* 仅发出一次的警告消息
|
||
*
|
||
* @param message 消息内容
|
||
* @param logFn 输出函数
|
||
*/
|
||
export declare function warnOnce(message: string, logFn?: (...data: any[]) => void): void;
|
||
|
||
export declare const WEEK_ON_DAYS = 7;
|
||
|
||
export declare const WEEK_ON_HOURS: number;
|
||
|
||
export declare const WEEK_ON_MILLISECONDS: number;
|
||
|
||
/** @deprecated renames to `WEEK_ON_MILLISECONDS` */
|
||
export declare const WEEK_ON_MILLS: number;
|
||
|
||
export declare const WEEK_ON_MINUTES: number;
|
||
|
||
export declare const WEEK_ON_SECONDS: number;
|
||
|
||
/**
|
||
* 将指定的文本写入粘贴板
|
||
*
|
||
* @param text 需要写入的文本
|
||
*
|
||
* @returns 是否写入成功
|
||
*/
|
||
export declare function writeClipboard(text: string): Promise<boolean>;
|
||
|
||
export declare const YEAR_ON_MONTHS: number;
|
||
|
||
export declare const YEAR_ON_QUARTERS = 4;
|
||
|
||
export { }
|