@pawover/kit 0.0.0-alpha.1 → 0.0.0-alpha.11

package/dist/enums.d.ts

@@ -0,0 +1,23 @@
+//#region src/enums/index.d.ts
+/** 屏幕响应断点 token 配置 */
+declare const BREAK_POINT_TOKENS: {
+  readonly XS: 576;
+  readonly XSMin: 576;
+  readonly XSMax: 767;
+  readonly SM: 768;
+  readonly SMMin: 768;
+  readonly SMMax: 991;
+  readonly MD: 992;
+  readonly MDMin: 992;
+  readonly MDMax: 1199;
+  readonly LG: 1200;
+  readonly LGMin: 1200;
+  readonly LGMax: 1599;
+  readonly XL: 1600;
+  readonly XLMin: 1600;
+  readonly XLMax: 1919;
+  readonly XXL: 1920;
+  readonly XXLMin: 1920;
+};
+//#endregion
+export { BREAK_POINT_TOKENS };

package/dist/enums.js

@@ -0,0 +1,24 @@
+//#region src/enums/index.ts
+/** 屏幕响应断点 token 配置 */
+const BREAK_POINT_TOKENS = {
+	XS: 576,
+	XSMin: 576,
+	XSMax: 767,
+	SM: 768,
+	SMMin: 768,
+	SMMax: 991,
+	MD: 992,
+	MDMin: 992,
+	MDMax: 1199,
+	LG: 1200,
+	LGMin: 1200,
+	LGMax: 1599,
+	XL: 1600,
+	XLMin: 1600,
+	XLMax: 1919,
+	XXL: 1920,
+	XXLMin: 1920
+};
+
+//#endregion
+export { BREAK_POINT_TOKENS };

package/dist/hooks-react.d.ts

@@ -0,0 +1,63 @@
+import * as react0 from "react";
+import { DependencyList, EffectCallback } from "react";
+import { Breakpoint } from "@pawover/types";
+
+//#region src/hooks/react/useCreation.d.ts
+
+/**
+ * useCreation
+ * @reference https://ahooks.js.org/zh-CN/hooks/use-creation
+ *
+ * @template T
+ * @param {() => T} factory
+ * @param {DependencyList} deps
+ */
+declare function useCreation<T>(factory: () => T, deps: DependencyList): T;
+//#endregion
+//#region src/hooks/react/useLatest.d.ts
+/**
+ * 返回当前最新值的 Hook
+ * @reference https://ahooks.js.org/zh-CN/hooks/use-latest
+ *
+ * @template T
+ * @param {T} value
+ */
+declare function useLatest<T>(value: T): react0.RefObject<T>;
+//#endregion
+//#region src/hooks/react/useMount.d.ts
+type MountCallback = EffectCallback | AsyncFunc;
+/**
+ * 在组件初始化时执行的 Hook
+ * - 即使在严格模式下也只执行一次
+ * @reference https://ahooks.js.org/hooks/use-mount
+ *
+ * @param {MountCallback} effect 副作用函数
+ */
+declare function useMount(effect: MountCallback): void;
+//#endregion
+//#region src/hooks/react/useResponsive.d.ts
+type ResponsiveValues = Record<Breakpoint, boolean>;
+interface ResponsiveHookOptions {
+  /**
+   * 紧凑布局断点
+   * - 低于此断点时使用紧凑布局
+   * @default "xl"
+   */
+  compactBreakPoint?: Breakpoint;
+}
+declare function useResponsive(options?: ResponsiveHookOptions): {
+  responsive: ResponsiveValues;
+  current: Breakpoint;
+  isCompact: boolean;
+};
+//#endregion
+//#region src/hooks/react/useUnmount.d.ts
+/**
+ * 在组件卸载时执行的 Hook
+ * @reference https://ahooks.js.org/zh-CN/hooks/use-unmount
+ *
+ * @param {Func} effect 副作用函数
+ */
+declare function useUnmount(effect: Func): void;
+//#endregion
+export { useCreation, useLatest, useMount, useResponsive, useUnmount };

package/dist/hooks-react.js

@@ -0,0 +1,252 @@
+import { useEffect, useRef, useState } from "react";
+
+//#region src/utils/typeof.ts
+const prototypes = {
+	string: "[object String]",
+	number: "[object Number]",
+	boolean: "[object Boolean]",
+	object: "[object Object]",
+	array: "[object Array]",
+	bigInt: "[object BigInt]",
+	symbol: "[object Symbol]",
+	function: "[object Function]",
+	generatorFunction: "[object GeneratorFunction]",
+	asyncFunction: "[object AsyncFunction]",
+	promise: "[object Promise]",
+	null: "[object Null]",
+	undefined: "[object Undefined]",
+	date: "[object Date]",
+	regExp: "[object RegExp]",
+	error: "[object Error]",
+	file: "[object File]",
+	map: "[object Map]",
+	weakMap: "[object WeakMap]",
+	set: "[object Set]",
+	weakSet: "[object WeakSet]",
+	window: "[object Window]",
+	webSocket: "[object WebSocket]",
+	URLSearchParams: "[object URLSearchParams]"
+};
+function resolvePrototypeString(value) {
+	return Object.prototype.toString.call(value);
+}
+function isObject(value) {
+	return resolvePrototypeString(value) === prototypes.object;
+}
+function isFunction(value) {
+	return [
+		prototypes.function,
+		prototypes.generatorFunction,
+		prototypes.asyncFunction
+	].includes(resolvePrototypeString(value));
+}
+function isPromise(value) {
+	return resolvePrototypeString(value) === prototypes.promise;
+}
+function isPromiseLike(value) {
+	return isPromise(value) || isObject(value) && isFunction(value["then"]);
+}
+/**
+* 判断给定的值是否相等
+* @reference https://github.com/radashi-org/radashi/blob/main/src/typed/isEqual.ts
+*
+* @param {T} x
+* @param {T} y
+*/
+function isEqual(x, y) {
+	if (Object.is(x, y)) return true;
+	if (x instanceof Date && y instanceof Date) return x.getTime() === y.getTime();
+	if (x instanceof RegExp && y instanceof RegExp) return x.toString() === y.toString();
+	if (typeof x !== "object" || x === null || typeof y !== "object" || y === null) return false;
+	const keysX = Reflect.ownKeys(x);
+	const keysY = Reflect.ownKeys(y);
+	if (keysX.length !== keysY.length) return false;
+	for (const key of keysX) {
+		if (!Reflect.has(y, key)) return false;
+		if (!isEqual(x[key], y[key])) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/utils/object.ts
+/**
+* 返回对象的可枚举属性和方法的名称
+* - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
+*
+* @param obj 对象
+* @returns 对象所有可枚举的属性的键名
+*/
+function objectKeys(obj) {
+	return Object.keys(obj);
+}
+
+//#endregion
+//#region src/hooks/react/useCreation.ts
+/**
+* useCreation
+* @reference https://ahooks.js.org/zh-CN/hooks/use-creation
+*
+* @template T
+* @param {() => T} factory
+* @param {DependencyList} deps
+*/
+function useCreation(factory, deps) {
+	const { current } = useRef({
+		deps,
+		result: void 0,
+		isInitialized: false
+	});
+	if (current.isInitialized === false || !isEqual(current.deps, deps)) {
+		current.deps = deps;
+		current.result = factory();
+		current.isInitialized = true;
+	}
+	return current.result;
+}
+
+//#endregion
+//#region src/hooks/react/useLatest.ts
+/**
+* 返回当前最新值的 Hook
+* @reference https://ahooks.js.org/zh-CN/hooks/use-latest
+*
+* @template T
+* @param {T} value
+*/
+function useLatest(value) {
+	const ref = useRef(value);
+	ref.current = value;
+	return ref;
+}
+
+//#endregion
+//#region src/hooks/react/useMount.ts
+/**
+* 在组件初始化时执行的 Hook
+* - 即使在严格模式下也只执行一次
+* @reference https://ahooks.js.org/hooks/use-mount
+*
+* @param {MountCallback} effect 副作用函数
+*/
+function useMount(effect) {
+	if (!isFunction(effect)) console.error(`useMount expected parameter is a function, but got ${typeof effect}`);
+	const isMountedRef = useRef(false);
+	const effectRef = useLatest(effect);
+	useEffect(() => {
+		if (isMountedRef.current) return;
+		isMountedRef.current = true;
+		const result = effectRef.current?.();
+		if (isPromiseLike(result)) return;
+		return result;
+	}, []);
+}
+
+//#endregion
+//#region src/enums/index.ts
+/** 屏幕响应断点 token 配置 */
+const BREAK_POINT_TOKENS = {
+	XS: 576,
+	XSMin: 576,
+	XSMax: 767,
+	SM: 768,
+	SMMin: 768,
+	SMMax: 991,
+	MD: 992,
+	MDMin: 992,
+	MDMax: 1199,
+	LG: 1200,
+	LGMin: 1200,
+	LGMax: 1599,
+	XL: 1600,
+	XLMin: 1600,
+	XLMax: 1919,
+	XXL: 1920,
+	XXLMin: 1920
+};
+
+//#endregion
+//#region src/hooks/react/useResponsive.ts
+const subscriberList = /* @__PURE__ */ new Set();
+const { XS, SM, MD, LG, XL, XXL } = BREAK_POINT_TOKENS;
+const defaultResponsiveValues = {
+	xxl: false,
+	xl: false,
+	lg: false,
+	md: false,
+	sm: false,
+	xs: false
+};
+const responsiveConfig = Object.freeze({
+	xxl: XXL,
+	xl: XL,
+	lg: LG,
+	md: MD,
+	sm: SM,
+	xs: XS
+});
+let responsiveValues = { ...defaultResponsiveValues };
+function useResponsive(options) {
+	const { compactBreakPoint = "xl" } = options || {};
+	calculate();
+	const [responsive, setResponsive] = useState(responsiveValues);
+	const isCompact = !responsive[compactBreakPoint];
+	const current = objectKeys(defaultResponsiveValues).find((key) => responsive[key] === true) || "xs";
+	useEffect(() => {
+		addListener();
+		const subscriber = () => {
+			setResponsive(responsiveValues);
+		};
+		subscriberList.add(subscriber);
+		return () => {
+			subscriberList.delete(subscriber);
+			if (subscriberList.size === 0) removeListener();
+		};
+	}, []);
+	return {
+		responsive,
+		current,
+		isCompact
+	};
+}
+function resizeListener() {
+	const oldInfo = responsiveValues;
+	calculate();
+	if (oldInfo === responsiveValues) return;
+	for (const subscriber of subscriberList) subscriber();
+}
+function addListener() {
+	window.addEventListener("resize", resizeListener);
+}
+function removeListener() {
+	window.removeEventListener("resize", resizeListener);
+}
+function calculate() {
+	const width = window.innerWidth;
+	const newValues = { ...defaultResponsiveValues };
+	let shouldUpdate = false;
+	for (const key of objectKeys(responsiveConfig)) {
+		newValues[key] = width >= responsiveConfig[key];
+		if (newValues[key] !== responsiveValues[key]) shouldUpdate = true;
+	}
+	if (shouldUpdate) responsiveValues = newValues;
+}
+
+//#endregion
+//#region src/hooks/react/useUnmount.ts
+/**
+* 在组件卸载时执行的 Hook
+* @reference https://ahooks.js.org/zh-CN/hooks/use-unmount
+*
+* @param {Func} effect 副作用函数
+*/
+function useUnmount(effect) {
+	if (!isFunction(effect)) console.error(`useUnmount expected parameter is a function, got ${typeof effect}`);
+	const effectRef = useLatest(effect);
+	useEffect(() => () => {
+		effectRef.current?.();
+	}, []);
+}
+
+//#endregion
+export { useCreation, useLatest, useMount, useResponsive, useUnmount };

package/dist/index.d.ts

@@ -0,0 +1,270 @@
+import { Class, NonEmptyObject, Replace, SetOptional, UnionToTuple, ValueOf } from "type-fest";
+
+//#region src/utils/tree/types.d.ts
+type RowKey = "id";
+type ParentIdKey = "parentId";
+type ChildrenKey = "children";
+type Strategy = "pre" | "post" | "breadth";
+interface BaseCallbackMeta<T> {
+  depth: number;
+  parents?: T[];
+}
+interface BaseOptions<T, CK extends string> {
+  childrenKey?: CK;
+  strategy?: Strategy;
+  getChildrenKey?: (row: T, meta: BaseCallbackMeta<T>) => CK | undefined;
+}
+//#endregion
+//#region src/utils/tree/treeFilter.d.ts
+type TreeFilterOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
+type TreeFilterCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => boolean;
+declare function treeFilter<T extends AnyObject, CK extends string = ChildrenKey>(tree: T[], callback: TreeFilterCallback<T>, options?: TreeFilterOptions<T, CK>): T[];
+declare function treeFilter<T extends AnyObject, CK extends string = ChildrenKey>(tree: T, callback: TreeFilterCallback<T>, options?: TreeFilterOptions<T, CK>): T;
+//#endregion
+//#region src/utils/tree/treeFind.d.ts
+type TreeFindOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
+type TreeFindCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => boolean;
+/**
+ * 查找树节点，找到第一个返回非空值的节点
+ */
+declare function treeFind<T extends AnyObject, CK extends string = ChildrenKey>(tree: T | T[], callback: TreeFindCallback<T>, options?: TreeFindOptions<T, CK>): T | undefined;
+//#endregion
+//#region src/utils/tree/treeForEach.d.ts
+type TreeForeachOptions<T extends AnyObject, CK extends string = ChildrenKey> = BaseOptions<T, CK>;
+type TreeForeachCallback<T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => void;
+declare function treeForEach<T extends AnyObject, CK extends string = ChildrenKey>(tree: T | T[], callback: TreeForeachCallback<T>, options?: TreeForeachOptions<T, CK>): void;
+//#endregion
+//#region src/utils/tree/treeMap.d.ts
+type TreeMapOptions<T extends AnyObject, CK extends string> = BaseOptions<T, CK>;
+type TreeMapCallback<R extends AnyObject, T extends AnyObject> = (row: T, meta: BaseCallbackMeta<T>) => R;
+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>[];
+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>;
+//#endregion
+//#region src/utils/tree/rowsToTree.d.ts
+interface RowsToTreeOptions<RK extends string = RowKey, PK extends string = ParentIdKey, CK extends string = ChildrenKey> {
+  rowKey?: RK;
+  parentIdKey?: PK;
+  childrenKey?: CK;
+}
+/**
+ * 行结构 转 树结构
+ */
+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[];
+//#endregion
+//#region src/utils/tree/treeToRows.d.ts
+type TreeToRowsOptions<T extends AnyObject, CK extends string = ChildrenKey> = TreeForeachOptions<T, CK>;
+/**
+ * 树结构 转 行结构
+ */
+declare function treeToRows<T extends AnyObject, CK extends string = ChildrenKey, R extends AnyObject = SetOptional<T, CK>>(tree: T | T[], options?: TreeToRowsOptions<T, CK>): R[];
+//#endregion
+//#region src/utils/array.d.ts
+declare function toArray<T>(candidate?: T | T[] | false): T[];
+/**
+ * 获取数组第一项
+ *
+ * @param initialList 初始数组
+ * @param saveValue 安全值
+ */
+declare function arrayFirst<T>(initialList: readonly T[], saveValue?: T): T | undefined;
+/**
+ * 获取数组最后一项
+ *
+ * @param initialList 初始数组
+ * @param saveValue 安全值
+ */
+declare function arrayLast<T>(initialList: readonly T[], saveValue?: T): T | undefined;
+declare function arrayDiff<T>(initialList: readonly T[], diffList: readonly T[], match: (row: T) => PropertyKey): T[];
+/**
+ * 数组竞争
+ * - 返回在匹配函数的比较条件中获胜的最终项目，适用于更复杂的最小值/最大值计算
+ *
+ * @param initialList 数组
+ * @param match 匹配函数
+ */
+declare function arrayCompete<T>(initialList: readonly T[], match: (a: T, b: T) => T): T | null;
+/**
+ * 统计数组的项目出现次数
+ * - 通过给定的标识符匹配函数，返回一个对象，其中键是回调函数返回的 key 值，每个值是一个整数，表示该 key 出现的次数
+ *
+ * @param initialList 初始数组
+ * @param match 标识符匹配函数
+ */
+declare function arrayCounting<T, K extends PropertyKey>(initialList: readonly T[], match: (row: T) => K): Record<string, number>;
+/**
+ * 数组项替换
+ * - 在给定的数组中，替换符合匹配函数结果的项目。只替换第一个匹配项。始终返回原始数组的副本。
+ *
+ * @param initialList 初始数组
+ * @param newItem 替换项
+ * @param match 匹配函数
+ */
+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 函数
+ */
+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`
+ */
+declare function arraySplit<T>(initialList: readonly T[], size?: number): T[][];
+/**
+ * 数组迭代
+ * - 运行一个函数 n 次以生成一个值，迭代函数将作为还原器运行无数次，然后返回累积值
+ *
+ * @param count 迭代次数
+ * @param iterate 迭代函数
+ * @param initialValue 初始值
+ */
+declare function arrayIterate<T>(count: number, iterate: (currentValue: T, iteration: number) => T, initialValue: T): T;
+/**
+ * 数组合并
+ * - 通过给定的标识符匹配函数，用第二个数组中的匹配项替换第一个数组中匹配项的所有内容
+ *
+ * @param initialList 初始数组
+ * @param mergeList 待合并数组
+ * @param match 标识符匹配函数
+ */
+declare function arrayMerge<T>(initialList: readonly T[], mergeList: readonly T[], match: (item: T) => unknown): readonly T[] & unknown[];
+//#endregion
+//#region src/utils/clone.d.ts
+interface CloningStrategy {
+  cloneMap: <K, V>(parent: Map<K, V>, track: (newParent: Map<K, V>) => Map<K, V>, clone: <T>(value: T) => T) => Map<K, V> | null;
+  cloneSet: <T>(parent: Set<T>, track: (newParent: Set<T>) => Set<T>, clone: <T>(value: T) => T) => Set<T> | null;
+  cloneArray: <T>(parent: readonly T[], track: (newParent: T[]) => T[], clone: <T>(value: T) => T) => T[] | null;
+  cloneObject: <T extends AnyObject>(parent: T, track: (newParent: T) => T, clone: <T>(value: T) => T) => T | null;
+  cloneOther: <T>(parent: T, track: (newParent: T) => T, clone: <T>(value: T) => T) => T | null;
+}
+declare const DefaultCloningStrategy: CloningStrategy;
+/**
+ * cloneDeep
+ * @reference https://github.com/radashi-org/radashi/blob/main/src/object/cloneDeep.ts
+ */
+declare function cloneDeep<T extends AnyObject>(root: T, customStrategy?: Partial<CloningStrategy>): T;
+//#endregion
+//#region src/utils/object.d.ts
+/**
+ * 返回对象的可枚举属性和方法的名称
+ * - `Object.keys` 始终返回 `string[]` 类型，此函数可以返回具体类型
+ *
+ * @param obj 对象
+ * @returns 对象所有可枚举的属性的键名
+ */
+declare function objectKeys<O extends AnyObject>(obj: O): (keyof O)[];
+/**
+ * 返回对象的可枚举属性的值数组
+ *
+ * @param obj 对象
+ */
+declare function objectValues<O extends AnyObject>(obj: O): UnionToTuple<ValueOf<O>>;
+/**
+ * 返回对象的可枚举属性的键/值数组
+ *
+ * @param obj 对象
+ */
+declare function objectEntries<O extends AnyObject>(obj: O): [string & keyof O, O[keyof O]][];
+/**
+ * 对象反转
+ * - 返回交换了对象的可枚举属性的值/键对象
+ *
+ * @param obj 对象
+ */
+declare function objectSwitch<O extends AnyObject>(obj: NonEmptyObject<O>): Record<O[keyof O], keyof O>;
+/**
+ * 对象合并
+ * - 将两个对象递归合并为一个新对象，从右到左依次使用数值
+ * - 递归只适用于子对象属性
+ */
+declare function objectAssign<O extends AnyObject>(obj: O, overrideObj: O): O;
+declare function objectPick<O extends AnyObject, K extends keyof O>(obj: O, keys: readonly K[]): Pick<O, K>;
+/**
+ * 获取枚举所有属性的键
+ *
+ * @param enumeration 枚举
+ */
+declare function enumKeys<E extends AnyObject>(enumeration: NonEmptyObject<E>): [keyof E, ...(keyof E)[]];
+/**
+ * 获取枚举所有属性的值
+ *
+ * @param enumeration 枚举
+ */
+declare function enumValues<E extends AnyObject>(enumeration: NonEmptyObject<E>): UnionToTuple<ValueOf<E>>;
+/**
+ * 返回枚举的属性的键/值数组
+ *
+ * @param enumeration 枚举
+ */
+declare function enumEntries<E extends AnyObject>(enumeration: NonEmptyObject<E>): [keyof E, E[keyof E]][];
+declare function mapEntries<TKey extends PropertyKey, TValue, TNewKey extends PropertyKey, TNewValue>(obj: UnknownObject<TKey, TValue>, toEntry: (key: TKey, value: TValue) => [TNewKey, TNewValue]): UnknownObject<TNewKey, TNewValue>;
+//#endregion
+//#region src/utils/string.d.ts
+/**
+ * 转义特殊字符
+ *
+ * @link https://github.com/sindresorhus/escape-string-regexp
+ * @param value 字符串
+ */
+declare function escapeStringRegexp(value: string): string;
+/**
+ * 首字母大小写
+ */
+declare function stringInitialCase(value: string, type: "lower" | "upper"): string;
+declare function stringToJson<R extends AnyObject = AnyObject, D extends R = R>(data: string | null | undefined, safeValue: D): R;
+declare function stringToValues<T extends number | string = number>(data: string | null | undefined, valueType?: "number" | "string"): T[];
+declare function stringReplace<I extends string, S extends string, R extends string>(input: I, search: S, replacement: R): Replace<I, S, R>;
+//#endregion
+//#region src/utils/to.d.ts
+/**
+ * @param promise
+ * @param errorExt - 可以传递给err对象的其他信息
+ */
+declare function to<T, U = Error>(promise: Readonly<Promise<T>>, errorExt?: UnknownObject): Promise<[U, undefined] | [null, T]>;
+//#endregion
+//#region src/utils/typeof.d.ts
+declare function isString<T extends string>(value: unknown): value is T;
+declare function isNumber<T extends number>(value: unknown): value is T;
+declare function isBoolean<T extends boolean>(value: unknown): value is T;
+declare function isObject<T extends Record<PropertyKey, unknown>>(value: unknown): value is T;
+declare function isArray<T extends unknown[]>(value: unknown): value is T;
+declare function isBigInt<T extends bigint>(value: unknown): value is T;
+declare function isSymbol<T extends symbol>(value: unknown): value is T;
+declare function isFunction<T extends Func>(value: unknown): value is T;
+declare function isGeneratorFunction<T extends Func>(value: unknown): value is T;
+declare function isAsyncFunction<T extends AsyncFunc>(value: unknown): value is T;
+declare function isPromise<T extends Promise<unknown>>(value: unknown): value is T;
+declare function isPromiseLike<T extends PromiseLike<unknown>>(value: unknown): value is T;
+declare function isNull<T extends null>(value: unknown): value is T;
+declare function isUndefined<T extends undefined>(value: unknown): value is T;
+declare function isDate<T extends Date>(value: unknown): value is T;
+declare function isRegExp<T extends RegExp>(value: unknown): value is T;
+declare function isError<T extends Error>(value: unknown): value is T;
+declare function isFile<T extends File>(value: unknown): value is T;
+declare function isMap<T extends Map<unknown, unknown>>(value: unknown): value is T;
+declare function isWeakMap<T extends WeakMap<AnyObject, unknown>>(value: unknown): value is T;
+declare function isSet<T extends Set<unknown>>(value: unknown): value is T;
+declare function isWeakSet<T extends WeakSet<AnyObject>>(value: unknown): value is T;
+declare function isWindow<T extends Window>(value: unknown): value is T;
+declare function isWebSocket<T extends WebSocket>(value: unknown): value is T;
+declare function isURLSearchParams<T extends Window>(value: unknown): value is T;
+declare function isClass<T extends Class<AnyObject>>(value: unknown): value is T;
+declare function isInteger<T extends number>(value: unknown): value is T;
+declare function isIterable<T extends Iterable<unknown>>(value: unknown): value is T;
+/**
+ * 判断给定的值是否相等
+ * @reference https://github.com/radashi-org/radashi/blob/main/src/typed/isEqual.ts
+ *
+ * @param {T} x
+ * @param {T} y
+ */
+declare function isEqual<T>(x: T, y: T): boolean;
+//#endregion
+export { CloningStrategy, DefaultCloningStrategy, arrayCompete, arrayCounting, arrayDiff, arrayFirst, arrayIterate, arrayLast, arrayMerge, arrayPick, arrayReplace, arraySplit, cloneDeep, enumEntries, enumKeys, enumValues, escapeStringRegexp, isArray, isAsyncFunction, isBigInt, isBoolean, isClass, isDate, isEqual, isError, isFile, isFunction, isGeneratorFunction, isInteger, isIterable, isMap, isNull, isNumber, isObject, isPromise, isPromiseLike, isRegExp, isSet, isString, isSymbol, isURLSearchParams, isUndefined, isWeakMap, isWeakSet, isWebSocket, isWindow, mapEntries, objectAssign, objectEntries, objectKeys, objectPick, objectSwitch, objectValues, rowsToTree, stringInitialCase, stringReplace, stringToJson, stringToValues, to, toArray, treeFilter, treeFind, treeForEach, treeMap, treeToRows };