@pawover/kit 0.0.0-alpha.9 → 0.0.0-beta.2

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

@@ -1,8 +0,0 @@
-/**
- * 返回当前最新值的 Hook
- * @reference https://ahooks.js.org/zh-CN/hooks/use-latest
- *
- * @template T
- * @param {T} value
- */
-export declare function useLatest<T>(value: T): import("react").RefObject<T>;

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,7 +0,0 @@
-/**
- * 在组件卸载时执行的 Hook
- * @reference https://ahooks.js.org/zh-CN/hooks/use-unmount
- *
- * @param {Func} effect 副作用函数
- */
-export declare function useUnmount(effect: Func): void;

package/dist/types/index.d.ts

@@ -1 +0,0 @@
-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/clone.d.ts

@@ -1,13 +0,0 @@
-export 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;
-}
-export declare const DefaultCloningStrategy: CloningStrategy;
-/**
- * cloneDeep
- * @reference https://github.com/radashi-org/radashi/blob/main/src/object/cloneDeep.ts
- */
-export declare function cloneDeep<T extends AnyObject>(root: T, customStrategy?: Partial<CloningStrategy>): T;

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

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

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

@@ -1,54 +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]][];
-export 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>;

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

@@ -1,15 +0,0 @@
-import type { Replace } from "type-fest";
-/**
- * 转义特殊字符
- *
- * @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[];
-export declare function stringReplace<I extends string, S extends string, R extends string>(input: I, search: S, replacement: R): Replace<I, S, R>;

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,37 +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;
-/**
- * 判断给定的值是否相等
- * @reference https://github.com/radashi-org/radashi/blob/main/src/typed/isEqual.ts
- *
- * @param {T} x
- * @param {T} y
- */
-export declare function isEqual<T>(x: T, y: T): boolean;

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

@@ -1,3 +0,0 @@
-export * from "./primitive";
-export * from "./validator/input";
-export * from "./validator/societal";

package/dist/types/zod/primitive.d.ts

@@ -1,32 +0,0 @@
-import { z } from "zod";
-/** 空 */
-export declare const empty: z.ZodUnion<readonly [z.ZodNull, z.ZodUndefined]>;
-/** 字符串 */
-export declare const string: z.ZodString;
-/** 字符串-空 */
-export declare const stringEmpty: z.ZodOptional<z.ZodNullable<z.ZodLiteral<"">>>;
-/** 字符串-非空 */
-export declare const stringNoEmpty: z.ZodString;
-/** 字符串-可空 */
-export declare const stringAllowEmpty: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-/** 数字 */
-export declare const number: z.ZodNumber;
-/** 数字-可空 */
-export declare const numberAllowEmpty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-/** 整数 */
-export declare const int: z.ZodNumber;
-/** 整数-可空 */
-export declare const intAllowEmpty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-/** 自然数 */
-export declare const natural: z.ZodNumber;
-/** 自然数-可空 */
-export declare const naturalAllowEmpty: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-/** 布尔值 */
-export declare const boolean: z.ZodBoolean;
-/** 布尔值-可空 */
-export declare const booleanAllowEmpty: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
-export declare const bigint: z.ZodBigInt;
-export declare const symbol: z.ZodSymbol;
-export declare const any: z.ZodAny;
-export declare const unknown: z.ZodUnknown;
-export declare const never: z.ZodNever;

package/dist/types/zod/validator/input.d.ts

@@ -1,27 +0,0 @@
-import { z } from "zod";
-/** 字母 */
-export declare const alphabet: z.ZodString;
-/** 小写字母 */
-export declare const alphabetLowercase: z.ZodString;
-/** 大写字母 */
-export declare const alphabetUppercase: z.ZodString;
-/** 不包含字母 */
-export declare const alphabetOmit: z.ZodString;
-/** 数字和字母 */
-export declare const numberAlphabet: z.ZodString;
-/** 有符号十进制浮点数字符串 */
-export declare const stringSignedDecimalismFloat: z.ZodString;
-/** 无符号十进制浮点数字符串 */
-export declare const stringUnsignedDecimalismFloat: z.ZodString;
-/** 有符号十进制整数字符串 */
-export declare const stringSignedDecimalismInt: z.ZodString;
-/** 无符号十进制整数字符串 */
-export declare const stringUnsignedDecimalismInt: z.ZodString;
-/** 包含空格 */
-export declare const spaceInclude: z.ZodString;
-/** 首空格 */
-export declare const spaceStart: z.ZodString;
-/** 尾空格 */
-export declare const spaceEnd: z.ZodString;
-/** 首尾空格 */
-export declare const spaceStartEnd: z.ZodIntersection<z.ZodString, z.ZodString>;

package/dist/types/zod/validator/societal.d.ts

@@ -1,39 +0,0 @@
-import { z } from "zod";
-/** 手机号码 */
-export declare const phone: z.ZodString;
-/** 固定电话 */
-export declare const telephone: z.ZodString;
-/** 电子邮箱 */
-export declare const email: z.ZodString;
-/** 中文姓名 */
-export declare const chineseName: z.ZodString;
-/** 手机机身码 */
-export declare const IMEI: z.ZodString;
-/** 身份证号 */
-export declare const ID: z.ZodString;
-/** 链接 */
-export declare const link: z.ZodString;
-/** 端口号网址 */
-export declare const linkPort: z.ZodString;
-/** 统一社会信用代码 */
-export declare const USCC_S: z.ZodString;
-/** 统一社会信用代码 - 15位/18位/20位数字/字母 */
-export declare const USCC: z.ZodString;
-/** 迅雷链接 */
-export declare const thunder: z.ZodString;
-/** windows 文件夹路径 */
-export declare const dirPathWindows: z.ZodString;
-/** windows 文件路径 */
-export declare const filePathWindows: z.ZodString;
-/** linux 文件夹路径 */
-export declare const dirPathLinux: z.ZodString;
-/** linux 文件路径 */
-export declare const filePathLinux: z.ZodString;
-/** 车牌号 新能源 */
-export declare const carCodeGreen: z.ZodString;
-/** 车牌号 非新能源 */
-export declare const carCodeNotGreen: z.ZodString;
-/** 中国省份 */
-export declare const chinaProvince: z.ZodString;
-/** 民族 */
-export declare const nation: z.ZodString;

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;
-    }, []);
-}