toolset.io/framework/umd/transform.d.ts

前端开发常用工具集。

/**
 * 如果一个值不为数组，则将其转换为数组
 *
 * @param value 指定的值
 *
 * @returns 原始数组或转换后的数组
 */
export declare function ensureArray<T>(value: T | T[]): T[];
/**
 * 如果一个值为函数，则执行它并返回结果，否则返回其本身
 *
 * @param value 指定的值
 * @param args 若为函数时，传入的参数
 *
 * @returns 原始值或函数执行结果
 */
export declare function callIfFunc<T, P extends any[] = any[]>(value: T | ((...args: P) => T), ...args: P): T;
/**
 * 将路径中的 `\` 替换为 `/`
 *
 * @param path 指定的路径
 *
 * @returns 替换后的路径
 */
export declare function normalizePath(path: string): string;
/**
 * 获取字符串的最后一个字符
 *
 * @param value 指定的字符串
 *
 * @returns 最后一个字符
 */
export declare function getLast(value: string): string | undefined;
/**
 * 获取数组的最后一个元素
 *
 * @param value 指定的数组
 *
 * @returns 最后一个元素
 */
export declare function getLast<T>(value: T[]): T | undefined;
/**
 * 根据数组元素中某个或多个属性的值转换为映射对象
 *
 * @param list 需要被转换的数组
 * @param prop 需要被转换的属性或提供一个读取方法
 * @param accessor 映射的值的读取方法，默认返回元素本身
 * @param isMap 是否使用 Map 对象储存结果
 *
 * @returns 转换后的映射对象
 */
export declare function listToMap<T = any, O = T>(list: T[], prop: keyof T | ((item: T) => any), accessor?: (item: T) => O, isMap?: false): Record<string, O>;
export declare function listToMap<T = any, O = T, K extends keyof T = keyof T>(list: T[], prop: K, accessor?: (item: T) => O, isMap?: true): Map<T[K], O>;
export declare function listToMap<T = any, O = T, K = any>(list: T[], prop: (item: T) => K, accessor?: (item: T) => O, isMap?: true): Map<K extends keyof T ? T[K] : unknown, O>;
export { 
/** @deprecated please use listToMap to replace it */
listToMap as transformListToMap };
/**
 * 移除数组中的某个元素
 *
 * @param array 需要被移除元素的数组
 * @param item 需要被移除的元素, 或一个查找方法，如果元素为函数时则需要做一层简单包装
 * @param isFn 标记数组的元素是否为函数
 *
 * @returns 被移除的元素
 */
export declare function removeArrayItem<T = any>(array: T[], item: T | ((item: T) => boolean), isFn?: boolean): T | null;
/**
 * 按照一定顺序的属性对数据进行分组
 *
 * @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[]>;
export interface TreeOptions<T = string> {
    keyField?: T;
    childField?: T;
    parentField?: T;
    /** 若指定，`parent` 值等于 `rootId` 的节点被认为是顶级节点 */
    rootId?: any;
}
/**
 * 将一个展平的列表转换为树
 *
 * @param list 要转换的列表
 * @param options 转换的配置项
 *
 * @returns 转换后的树
 */
export declare function transformTree<T = any>(list: T[], options?: TreeOptions<keyof T>): T[];
export { transformTree as buildTree };
/**
 * 将一个树展平成列表
 *
 * @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 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 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 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[];
export interface SortOptions<T = string> {
    /** 属性名 */
    key: T;
    /** 排序方法 */
    method?: (prev: any, next: any) => number;
    /** 读取方法 */
    accessor?: (...args: any[]) => any;
    /** 升降序 */
    type?: 'asc' | 'desc';
    /** 传入读取器的额外参数 */
    params?: any[];
}
/**
 * 根据依赖的属性对数组逐层排序
 *
 * @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[];
/**
 * 将两个对象进行深度的动态合并
 *
 * @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 queue 任务队列
 *
 * @returns 终止队列执行的方法
 */
export declare function runQueueFrame(queue: Array<() => void>): () => boolean;