@pawover/kit 0.0.0-alpha.3 → 0.0.0-alpha.31

package/dist/types/hooks/react/useMount.d.ts

@@ -1,11 +0,0 @@
-import { type EffectCallback } from "react";
-type MountCallback = EffectCallback | AsyncFunc;
-/**
- * 在组件初始化时执行的 Hook
- * - 即使在严格模式下也只执行一次
- * @reference https://ahooks.js.org/hooks/use-mount
- *
- * @param {MountCallback} effect 副作用函数
- */
-export declare function useMount(effect: MountCallback): void;
-export {};

package/dist/types/hooks/react/useResponsive.d.ts

@@ -1,16 +0,0 @@
-import type { Breakpoint } from "@pawover/types";
-type ResponsiveValues = Record<Breakpoint, boolean>;
-interface ResponsiveHookOptions {
-    /**
-     * 紧凑布局断点
-     * - 低于此断点时使用紧凑布局
-     * @default "xl"
-     */
-    compactBreakPoint?: Breakpoint;
-}
-export declare function useResponsive(options?: ResponsiveHookOptions): {
-    responsive: ResponsiveValues;
-    current: Breakpoint;
-    isCompact: boolean;
-};
-export {};

package/dist/types/hooks/react/useUnmount.d.ts

@@ -1,6 +0,0 @@
-/**
- * 在组件卸载时执行的 Hook
- *
- * @param {Func} effect 副作用函数
- */
-export declare function useUnmount(effect: Func): void;

package/dist/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./enums";
-export * from "./utils";

package/dist/types/utils/array.d.ts

@@ -1,76 +0,0 @@
-export declare function toArray<T>(candidate?: T | T[] | false): T[];
-/**
- * 获取数组第一项
- *
- * @param initialList 初始数组
- * @param saveValue 安全值
- */
-export declare function arrayFirst<T>(initialList: readonly T[], saveValue?: T): T | undefined;
-/**
- * 获取数组最后一项
- *
- * @param initialList 初始数组
- * @param saveValue 安全值
- */
-export declare function arrayLast<T>(initialList: readonly T[], saveValue?: T): T | undefined;
-export declare function arrayDiff<T>(initialList: readonly T[], diffList: readonly T[], match: (row: T) => PropertyKey): T[];
-/**
- * 数组竞争
- * - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
- *
- * @param initialList 数组
- * @param match 匹配函数
- */
-export declare function arrayCompete<T>(initialList: readonly T[], match: (a: T, b: T) => T): T | null;
-/**
- * 统计数组的项目出现次数
- * - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数
- *
- * @param initialList 初始数组
- * @param match 标识符匹配函数
- */
-export declare function arrayCounting<T, K extends PropertyKey>(initialList: readonly T[], match: (row: T) => K): Record<string, number>;
-/**
- * 数组项替换
- * - 在给定的数组中，替换符合匹配函数结果的项目。只替换第一个匹配项。始终返回原始数组的副本。
- *
- * @param initialList 初始数组
- * @param newItem 替换项
- * @param match 匹配函数
- */
-export declare function arrayReplace<T>(initialList: readonly T[], newItem: T, match: (row: T, index: number) => boolean): T[];
-/**
- * 数组选择
- * - 一次性应用 `filter` 和 `map` 操作
- *
- * @param initialList 初始数组
- * @param filter filter 函数
- * @param mapper map 函数
- */
-export declare function arrayPick<T, K = T>(initialList: readonly T[], filter: (row: T, index: number) => boolean, mapper?: ((row: T, index: number) => K) | undefined): (readonly T[] & unknown[]) | K[];
-/**
- * 数组切分
- * - 将数组以指定的长度切分后，组合在高维数组中
- *
- * @param initialList 初始数组
- * @param size 分割尺寸，默认 `10`
- */
-export declare function arraySplit<T>(initialList: readonly T[], size?: number): T[][];
-/**
- * 数组迭代
- * - 运行一个函数 n 次以生成一个值，迭代函数将作为还原器运行无数次，然后返回累积值
- *
- * @param count 迭代次数
- * @param iterate 迭代函数
- * @param initialValue 初始值
- */
-export declare function arrayIterate<T>(count: number, iterate: (currentValue: T, iteration: number) => T, initialValue: T): T;
-/**
- * 数组合并
- * - 通过给定的标识符匹配函数，用第二个数组中的匹配项替换第一个数组中匹配项的所有内容
- *
- * @param initialList 初始数组
- * @param mergeList 待合并数组
- * @param match 标识符匹配函数
- */
-export declare function arrayMerge<T>(initialList: readonly T[], mergeList: readonly T[], match: (item: T) => unknown): readonly T[] & unknown[];

package/dist/types/utils/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./array";
-export * from "./object";
-export * from "./string";
-export * from "./to";
-export * from "./tree";
-export * from "./typeof";

package/dist/types/utils/object.d.ts

@@ -1,53 +0,0 @@
-import type { NonEmptyObject, UnionToTuple, ValueOf } from "type-fest";
-/**
- * 返回对象的可枚举属性和方法的名称
- * - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
- *
- * @param obj 对象
- * @returns 对象所有可枚举的属性的键名
- */
-export declare function objectKeys<O extends AnyObject>(obj: O): (keyof O)[];
-/**
- * 返回对象的可枚举属性的值数组
- *
- * @param obj 对象
- */
-export declare function objectValues<O extends AnyObject>(obj: O): UnionToTuple<ValueOf<O>>;
-/**
- * 返回对象的可枚举属性的键/值数组
- *
- * @param obj 对象
- */
-export declare function objectEntries<O extends AnyObject>(obj: O): [string & keyof O, O[keyof O]][];
-/**
- * 对象反转
- * - 返回交换了对象的可枚举属性的值/键对象
- *
- * @param obj 对象
- */
-export declare function objectSwitch<O extends AnyObject>(obj: NonEmptyObject<O>): Record<O[keyof O], keyof O>;
-/**
- * 对象合并
- * - 将两个对象递归合并为一个新对象，从右到左依次使用数值
- * - 递归只适用于子对象属性
- */
-export declare function objectAssign<O extends AnyObject>(obj: O, overrideObj: O): O;
-export declare function objectPick<O extends AnyObject, K extends keyof O>(obj: O, keys: readonly K[]): Pick<O, K>;
-/**
- * 获取枚举所有属性的键
- *
- * @param enumeration 枚举
- */
-export declare function enumKeys<E extends AnyObject>(enumeration: NonEmptyObject<E>): [keyof E, ...(keyof E)[]];
-/**
- * 获取枚举所有属性的值
- *
- * @param enumeration 枚举
- */
-export declare function enumValues<E extends AnyObject>(enumeration: NonEmptyObject<E>): UnionToTuple<ValueOf<E>>;
-/**
- * 返回枚举的属性的键/值数组
- *
- * @param enumeration 枚举
- */
-export declare function enumEntries<E extends AnyObject>(enumeration: NonEmptyObject<E>): [keyof E, E[keyof E]][];

package/dist/types/utils/string.d.ts

@@ -1,13 +0,0 @@
-/**
- * 转义特殊字符
- *
- * @link https://github.com/sindresorhus/escape-string-regexp
- * @param value 字符串
- */
-export declare function escapeStringRegexp(value: string): string;
-/**
- * 首字母大小写
- */
-export declare function stringInitialCase(value: string, type: "lower" | "upper"): string;
-export declare function stringToJson<R extends AnyObject = AnyObject, D extends R = R>(data: string | null | undefined, safeValue: D): R;
-export declare function stringToValues<T extends number | string = number>(data: string | null | undefined, valueType?: "number" | "string"): T[];

package/dist/types/utils/to.d.ts

@@ -1,5 +0,0 @@
-/**
- * @param promise
- * @param errorExt - 可以传递给err对象的其他信息
- */
-export declare function to<T, U = Error>(promise: Readonly<Promise<T>>, errorExt?: UnknownObject): Promise<[U, undefined] | [null, T]>;

package/dist/types/utils/tree/index.d.ts

@@ -1,6 +0,0 @@
-export { treeFilter } from "./treeFilter";
-export { treeFind } from "./treeFind";
-export { treeForEach } from "./treeForEach";
-export { treeMap } from "./treeMap";
-export { rowsToTree } from "./rowsToTree";
-export { treeToRows } from "./treeToRows";

package/dist/types/utils/tree/rowsToTree.d.ts

@@ -1,10 +0,0 @@
-import type { ChildrenKey, ParentIdKey, RowKey } from "./types";
-export interface RowsToTreeOptions<RK extends string = RowKey, PK extends string = ParentIdKey, CK extends string = ChildrenKey> {
-    rowKey?: RK;
-    parentIdKey?: PK;
-    childrenKey?: CK;
-}
-/**
- * 行结构 转 树结构
- */
-export declare function rowsToTree<T extends AnyObject = AnyObject, CK extends string = ChildrenKey, R = TreeLike<T, CK>, RK extends string = RowKey, PK extends string = ParentIdKey>(rows: T[], options?: RowsToTreeOptions<RK, PK, CK> | undefined): R[];

package/dist/types/utils/tree/treeFilter.d.ts

@@ -1,6 +0,0 @@
-import { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey } from "./types";
-export type TreeFilterOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
-export type TreeFilterInnerOption<T extends AnyObject, CK extends string = ChildrenKey> = BaseInnerOptions<T, CK>;
-export type TreeFilterCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => boolean;
-export declare function treeFilter<T extends AnyObject, CK extends string = ChildrenKey>(tree: T[], callback: TreeFilterCallback<T>, options?: TreeFilterOptions<T, CK>): T[];
-export declare function treeFilter<T extends AnyObject, CK extends string = ChildrenKey>(tree: T, callback: TreeFilterCallback<T>, options?: TreeFilterOptions<T, CK>): T;

package/dist/types/utils/tree/treeFind.d.ts

@@ -1,8 +0,0 @@
-import { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey } from "./types";
-export type TreeFindOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
-export type TreeFindInnerOption<T extends AnyObject, CK extends string = ChildrenKey> = BaseInnerOptions<T, CK>;
-export type TreeFindCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => boolean;
-/**
- * 查找树节点，找到第一个返回非空值的节点
- */
-export declare function treeFind<T extends AnyObject, CK extends string = ChildrenKey>(tree: T | T[], callback: TreeFindCallback<T>, options?: TreeFindOptions<T, CK>): T | undefined;

package/dist/types/utils/tree/treeForEach.d.ts

@@ -1,5 +0,0 @@
-import { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey } from "./types";
-export type TreeForeachOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
-export type TreeForeachInnerOption<T extends AnyObject, CK extends string = ChildrenKey> = BaseInnerOptions<T, CK>;
-export type TreeForeachCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => void;
-export declare function treeForEach<T extends AnyObject, CK extends string = ChildrenKey>(tree: T | T[], callback: TreeForeachCallback<T>, options?: TreeForeachOptions<T, CK>): void;

package/dist/types/utils/tree/treeMap.d.ts

@@ -1,6 +0,0 @@
-import { type BaseCallbackMeta, type BaseInnerOptions, type BaseOptions, type ChildrenKey } from "./types";
-export type TreeMapOptions<T extends AnyObject, CK extends string> = BaseOptions<T, CK>;
-export type TreeMapInnerOption<T extends AnyObject, CK extends string> = BaseInnerOptions<T, CK>;
-export type TreeMapCallback<R extends AnyObject, T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => R;
-export declare function treeMap<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey>(tree: T[], callback: TreeMapCallback<R, T>, options?: TreeMapOptions<T, CK>): TreeLike<R, CK>[];
-export declare function treeMap<R extends AnyObject, T extends AnyObject, CK extends string = ChildrenKey>(tree: T, callback: TreeMapCallback<R, T>, options?: TreeMapOptions<T, CK>): TreeLike<R, CK>;

package/dist/types/utils/tree/treeToRows.d.ts

@@ -1,9 +0,0 @@
-import type { SetOptional } from "type-fest";
-import { type TreeForeachOptions } from "./treeForEach";
-import type { ChildrenKey } from "./types";
-type TreeToRowsOptions<T extends AnyObject, CK extends string = ChildrenKey> = TreeForeachOptions<T, CK>;
-/**
- * 树结构 转 行结构
- */
-export declare function treeToRows<T extends AnyObject, CK extends string = ChildrenKey, R extends AnyObject = SetOptional<T, CK>>(tree: T | T[], options?: TreeToRowsOptions<T, CK>): R[];
-export {};

package/dist/types/utils/tree/types.d.ts

@@ -1,24 +0,0 @@
-export type RowKey = "id";
-export type ParentIdKey = "parentId";
-export type ChildrenKey = "children";
-export type Strategy = "pre" | "post" | "breadth";
-export interface BaseCallbackMeta<T> {
-    depth: number;
-    parents?: T[];
-}
-export interface BaseOptions<T, CK extends string> {
-    childrenKey?: CK;
-    strategy?: Strategy;
-    getChildrenKey?: (row: T, meta: BaseCallbackMeta<T>) => CK | undefined;
-}
-export interface BaseInnerOptions<T, CK extends string> {
-    childrenKey: CK;
-    parents: T[];
-    depth: number;
-    getChildrenKey?: (row: T, meta: BaseCallbackMeta<T>) => CK | undefined;
-}
-export interface QueueItem<T, CK extends string> {
-    queueRow: T;
-    queueOptions: BaseInnerOptions<T, CK>;
-}
-export declare function getFinalChildrenKey<T, CK extends string>(tree: T, meta: BaseCallbackMeta<T>, options: BaseInnerOptions<T, CK>): CK;

package/dist/types/utils/typeof.d.ts

@@ -1,29 +0,0 @@
-import type { Class } from "type-fest";
-export declare function isString<T extends string>(value: unknown): value is T;
-export declare function isNumber<T extends number>(value: unknown): value is T;
-export declare function isBoolean<T extends boolean>(value: unknown): value is T;
-export declare function isObject<T extends Record<PropertyKey, unknown>>(value: unknown): value is T;
-export declare function isArray<T extends unknown[]>(value: unknown): value is T;
-export declare function isBigInt<T extends bigint>(value: unknown): value is T;
-export declare function isSymbol<T extends symbol>(value: unknown): value is T;
-export declare function isFunction<T extends Func>(value: unknown): value is T;
-export declare function isGeneratorFunction<T extends Func>(value: unknown): value is T;
-export declare function isAsyncFunction<T extends AsyncFunc>(value: unknown): value is T;
-export declare function isPromise<T extends Promise<unknown>>(value: unknown): value is T;
-export declare function isPromiseLike<T extends PromiseLike<unknown>>(value: unknown): value is T;
-export declare function isNull<T extends null>(value: unknown): value is T;
-export declare function isUndefined<T extends undefined>(value: unknown): value is T;
-export declare function isDate<T extends Date>(value: unknown): value is T;
-export declare function isRegExp<T extends RegExp>(value: unknown): value is T;
-export declare function isError<T extends Error>(value: unknown): value is T;
-export declare function isFile<T extends File>(value: unknown): value is T;
-export declare function isMap<T extends Map<unknown, unknown>>(value: unknown): value is T;
-export declare function isWeakMap<T extends WeakMap<AnyObject, unknown>>(value: unknown): value is T;
-export declare function isSet<T extends Set<unknown>>(value: unknown): value is T;
-export declare function isWeakSet<T extends WeakSet<AnyObject>>(value: unknown): value is T;
-export declare function isWindow<T extends Window>(value: unknown): value is T;
-export declare function isWebSocket<T extends WebSocket>(value: unknown): value is T;
-export declare function isURLSearchParams<T extends Window>(value: unknown): value is T;
-export declare function isClass<T extends Class<AnyObject>>(value: unknown): value is T;
-export declare function isInteger<T extends number>(value: unknown): value is T;
-export declare function isIterable<T extends Iterable<unknown>>(value: unknown): value is T;

package/dist/utils/array.js

@@ -1,196 +0,0 @@
-import { isArray, isFunction } from "./typeof";
-export function toArray(candidate) {
-    if (candidate === undefined || candidate === false) {
-        return [];
-    }
-    return isArray(candidate) ? candidate : [candidate];
-}
-/**
- * 获取数组第一项
- *
- * @param initialList 初始数组
- * @param saveValue 安全值
- */
-export function arrayFirst(initialList, saveValue) {
-    if (!isArray(initialList) || initialList.length === 0) {
-        return saveValue;
-    }
-    return initialList[0];
-}
-/**
- * 获取数组最后一项
- *
- * @param initialList 初始数组
- * @param saveValue 安全值
- */
-export function arrayLast(initialList, saveValue) {
-    if (!isArray(initialList) || initialList.length === 0) {
-        return saveValue;
-    }
-    return initialList[initialList.length - 1];
-}
-export function arrayDiff(initialList, diffList, match) {
-    if (!isArray(initialList) && !isArray(diffList)) {
-        return [];
-    }
-    if (!isArray(initialList) || !initialList.length) {
-        return [...diffList];
-    }
-    if (!isArray(diffList) || !diffList.length) {
-        return [...initialList];
-    }
-    if (!isFunction(match)) {
-        return [];
-    }
-    const keys = diffList.reduce((prev, curr) => {
-        prev[match(curr)] = true;
-        return prev;
-    }, {});
-    return initialList.filter((a) => !keys[match(a)]);
-}
-/**
- * 数组竞争
- * - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
- *
- * @param initialList 数组
- * @param match 匹配函数
- */
-export function arrayCompete(initialList, match) {
-    if (!isArray(initialList) || initialList.length === 0 || !isFunction(match)) {
-        return null;
-    }
-    return initialList.reduce(match);
-}
-/**
- * 统计数组的项目出现次数
- * - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数
- *
- * @param initialList 初始数组
- * @param match 标识符匹配函数
- */
-export function arrayCounting(initialList, match) {
-    if (!isArray(initialList) || !isFunction(match)) {
-        return {};
-    }
-    return initialList.reduce((prev, curr) => {
-        const id = match(curr).toString();
-        prev[id] = (prev[id] ?? 0) + 1;
-        return prev;
-    }, {});
-}
-/**
- * 数组项替换
- * - 在给定的数组中，替换符合匹配函数结果的项目。只替换第一个匹配项。始终返回原始数组的副本。
- *
- * @param initialList 初始数组
- * @param newItem 替换项
- * @param match 匹配函数
- */
-export function arrayReplace(initialList, newItem, match) {
-    if (!initialList) {
-        return [];
-    }
-    if (newItem === undefined || !isFunction(match)) {
-        return [...initialList];
-    }
-    for (let i = 0; i < initialList.length; i++) {
-        const item = initialList[i];
-        if (item !== undefined && match(item, i)) {
-            return [...initialList.slice(0, i), newItem, ...initialList.slice(i + 1, initialList.length)];
-        }
-    }
-    return [...initialList];
-}
-/**
- * 数组选择
- * - 一次性应用 `filter` 和 `map` 操作
- *
- * @param initialList 初始数组
- * @param filter filter 函数
- * @param mapper map 函数
- */
-export function arrayPick(initialList, filter, mapper) {
-    if (!isArray(initialList)) {
-        return [];
-    }
-    if (!isFunction(filter)) {
-        return initialList;
-    }
-    const hasMapper = isFunction(mapper);
-    return initialList.reduce((prev, curr, index) => {
-        if (!filter(curr, index)) {
-            return prev;
-        }
-        if (hasMapper) {
-            prev.push(mapper(curr, index));
-        }
-        else {
-            prev.push(curr);
-        }
-        return prev;
-    }, []);
-}
-/**
- * 数组切分
- * - 将数组以指定的长度切分后，组合在高维数组中
- *
- * @param initialList 初始数组
- * @param size 分割尺寸，默认 `10`
- */
-export function arraySplit(initialList, size = 10) {
-    if (!isArray(initialList)) {
-        return [];
-    }
-    const count = Math.ceil(initialList.length / size);
-    return Array.from({ length: count })
-        .fill(null)
-        .map((_c, i) => {
-        return initialList.slice(i * size, i * size + size);
-    });
-}
-/**
- * 数组迭代
- * - 运行一个函数 n 次以生成一个值，迭代函数将作为还原器运行无数次，然后返回累积值
- *
- * @param count 迭代次数
- * @param iterate 迭代函数
- * @param initialValue 初始值
- */
-export function arrayIterate(count, iterate, initialValue) {
-    let result = initialValue;
-    if (isFunction(iterate)) {
-        for (let i = 1; i <= count; i++) {
-            result = iterate(result, i);
-        }
-    }
-    return result;
-}
-/**
- * 数组合并
- * - 通过给定的标识符匹配函数，用第二个数组中的匹配项替换第一个数组中匹配项的所有内容
- *
- * @param initialList 初始数组
- * @param mergeList 待合并数组
- * @param match 标识符匹配函数
- */
-export function arrayMerge(initialList, mergeList, match) {
-    if (!isArray(initialList)) {
-        return [];
-    }
-    if (!isArray(mergeList)) {
-        return initialList;
-    }
-    if (!isFunction(match)) {
-        return initialList;
-    }
-    return initialList.reduce((prev, curr) => {
-        const matched = mergeList.find((list) => match(curr) === match(list));
-        if (matched) {
-            prev.push(matched);
-        }
-        else {
-            prev.push(curr);
-        }
-        return prev;
-    }, []);
-}

package/dist/utils/index.js

@@ -1,6 +0,0 @@
-export * from "./array";
-export * from "./object";
-export * from "./string";
-export * from "./to";
-export * from "./tree";
-export * from "./typeof";

package/dist/utils/object.js

@@ -1,138 +0,0 @@
-import { isArray, isObject } from "./typeof";
-/**
- * 返回对象的可枚举属性和方法的名称
- * - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
- *
- * @param obj 对象
- * @returns 对象所有可枚举的属性的键名
- */
-export function objectKeys(obj) {
-    return Object.keys(obj);
-}
-/**
- * 返回对象的可枚举属性的值数组
- *
- * @param obj 对象
- */
-export function objectValues(obj) {
-    return Object.values(obj);
-}
-/**
- * 返回对象的可枚举属性的键/值数组
- *
- * @param obj 对象
- */
-export function objectEntries(obj) {
-    return Object.entries(obj);
-}
-/**
- * 对象反转
- * - 返回交换了对象的可枚举属性的值/键对象
- *
- * @param obj 对象
- */
-export function objectSwitch(obj) {
-    const result = {};
-    if (!isObject(obj)) {
-        return result;
-    }
-    for (const [k, v] of objectEntries(obj)) {
-        result[v] = k;
-    }
-    return result;
-}
-/**
- * 对象合并
- * - 将两个对象递归合并为一个新对象，从右到左依次使用数值
- * - 递归只适用于子对象属性
- */
-export function objectAssign(obj, overrideObj) {
-    const result = {};
-    if (!isObject(obj) && !isObject(overrideObj)) {
-        return result;
-    }
-    if (!isObject(obj) || !isObject(overrideObj)) {
-        return obj ?? overrideObj ?? result;
-    }
-    return Object.entries({ ...obj, ...overrideObj }).reduce((prev, [key, value]) => {
-        return {
-            ...prev,
-            [key]: (() => {
-                if (isObject(obj[key])) {
-                    return objectAssign(obj[key], value);
-                }
-                return value;
-            })(),
-        };
-    }, result);
-}
-export function objectPick(obj, keys) {
-    const result = {};
-    if (!isObject(obj)) {
-        return result;
-    }
-    if (!isArray(keys)) {
-        return obj;
-    }
-    return keys.reduce((prev, curr) => {
-        if (curr in obj) {
-            prev[curr] = obj[curr];
-        }
-        return prev;
-    }, result);
-}
-function enumType(enumeration) {
-    if (!isObject(enumeration)) {
-        throw Error(`function enumKeys expected parameter is a enum, but got ${typeof enumeration}`);
-    }
-    if (!objectKeys(enumeration).length) {
-        throw Error("Enum requires at least one member");
-    }
-    return enumeration;
-}
-/**
- * 获取枚举所有属性的键
- *
- * @param enumeration 枚举
- */
-export function enumKeys(enumeration) {
-    const e = enumType(enumeration);
-    const keys = objectKeys(e);
-    const values = objectValues(e);
-    const isTwoWayEnum = keys.every((k) => values.some((v) => `${v}` === k));
-    if (isTwoWayEnum) {
-        return keys.splice(keys.length / 2, keys.length / 2);
-    }
-    return keys;
-}
-/**
- * 获取枚举所有属性的值
- *
- * @param enumeration 枚举
- */
-export function enumValues(enumeration) {
-    const e = enumType(enumeration);
-    const keys = objectKeys(e);
-    const values = objectValues(e);
-    const isTwoWayEnum = keys.every((k) => values.some((v) => `${v}` === k));
-    if (isTwoWayEnum) {
-        return values.splice(keys.length / 2, keys.length / 2);
-    }
-    return values;
-}
-/**
- * 返回枚举的属性的键/值数组
- *
- * @param enumeration 枚举
- */
-export function enumEntries(enumeration) {
-    const e = enumType(enumeration);
-    const keys = objectKeys(e);
-    const values = objectValues(e);
-    const entries = objectEntries(e);
-    const isTwoWayEnum = keys.every((k) => values.some((v) => `${v}` === k));
-    if (isTwoWayEnum) {
-        return entries.splice(keys.length / 2, keys.length / 2);
-    }
-    return entries;
-}