zzz-pc-view 0.0.1

package/src/utils/class/combine.d.ts

@@ -0,0 +1,109 @@
+import { ClassType } from '../DeclareType';
+/**
+ * 定义一个类型别名 `IntersectionOf`，用于计算类型数组 `T` 中所有类型的交集。
+ * 如果 `T` 是一个单元素数组 `[Class]`，则返回 `Class`。
+ * 如果 `T` 是一个多元素数组 `[First, ...Intermediate]`，则返回 `First` 与 `IntersectionOf<Intermediate>` 的交集。
+ * 否则返回 `unknown`。
+ */
+type IntersectionOf<T> = T extends [infer Class] ? Class : T extends [infer First, ...infer Intermediate] ? First & IntersectionOf<Intermediate> : unknown;
+/**
+ * 定义一个类型别名 `CombineConstructorParams`，用于获取类型数组 `T` 中每个类的构造函数参数类型。
+ * 返回一个对象类型，其键为 `T` 中每个类的索引，值为该类的构造函数参数类型数组。
+ */
+type CombineConstructorParams<T extends ClassType[]> = {
+    [K in keyof T]: ConstructorParameters<T[K]>;
+};
+/**
+ * 定义一个类型别名 `CombineInstance`，用于获取类型数组 `T` 中每个类的实例类型。
+ * 返回一个对象类型，其键为 `T` 中每个类的索引，值为该类的实例类型。
+ */
+type CombineInstance<T extends ClassType[]> = {
+    [K in keyof T]: InstanceType<T[K]>;
+};
+/**
+ * 定义一个类型别名 `CombineClassType`，用于描述组合类的类型。
+ * 组合类的构造函数接受 `CombineConstructorParams<T>` 作为参数，并返回 `IntersectionOf<CombineInstance<T>>` 类型的实例。
+ * 组合类还包含一个静态属性 `InstanceType`，其类型为 `IntersectionOf<CombineInstance<T>>`。
+ * 此外，组合类还继承了 `IntersectionOf<T>` 中的所有属性和方法。
+ */
+type CombineClassType<T extends ClassType[]> = {
+    new (...args: CombineConstructorParams<T>): IntersectionOf<CombineInstance<T>>;
+    InstanceType: IntersectionOf<CombineInstance<T>>;
+} & IntersectionOf<T>;
+/**
+ * 定义一个接口 `CombineClass`，用于描述组合类的基本结构。
+ * 组合类的构造函数接受任意数量的参数并返回任意类型的值。
+ * 组合类还包含一个可选的静态属性 `InstanceType`，其类型为任意类型。
+ */
+export interface CombineClass {
+    new (...args: any): any;
+    InstanceType?: any;
+}
+/**
+ * 定义一个类型别名 `CombineInstanceType`，用于获取组合类 `T` 的实例类型。
+ * 如果 `T` 包含一个名为 `InstanceType` 的静态属性，则返回该属性的类型。
+ * 否则返回 `T` 的实例类型。
+ * @template T - 组合类的类型。
+ */
+export type CombineInstanceType<T extends CombineClass> = {
+    [K in keyof T]: K extends 'InstanceType' ? T[K] : never;
+}[keyof T] extends never ? InstanceType<T> : T['InstanceType'];
+/**
+ * 定义一个类型别名 `CombinedClassType`，用于描述组合类的类型。
+ * 组合类的构造函数接受任意数量的参数，并返回 `CombineInstanceType<T>` 类型的实例。
+ * @template T - 组合类的类型。
+ */
+export type CombinedClassType<T extends CombineClass> = {
+    new (...args: any): CombineInstanceType<T>;
+};
+/**
+ * 组合多个类的函数。
+ *
+ * 该函数接受一个或多个类作为参数，并返回一个新的组合类。
+ * 组合类的实例将具有所有输入类的属性和方法。
+ *
+ * @template T - 输入类的数组类型。
+ * @param {...T} Classes - 要组合的类。
+ * @example
+    combine(
+      class A {
+        constructor(public a: number) {}
+
+        get aa() {
+          return this.a + 1
+        }
+
+        static a = 2
+      },
+      class B {
+        constructor(public b: string) {}
+
+        get bb() {
+          return this.b + '!!'
+        }
+
+        static b = 'b'
+      }
+    )
+ * @returns
+    class {
+      a: number
+      get aa() {
+        return this.a + 1
+      }
+      static a = 2
+
+      b: string
+      get bb() {
+        return this.b + '!!'
+      }
+      static b = 'b'
+
+      constructor(AClassConstructorParams: [number], BClassConstructorParams: [string]) {
+        this.a = AClassConstructorParams[0]
+        this.b = BClassConstructorParams[0]
+      }
+    }
+ */
+export declare const combine: <T extends ClassType[]>(...Classes: T) => CombineClassType<T>;
+export {};

package/src/utils/crypto/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 使用 DES 算法加密字符串
+ *
+ * @param {string} secretKey - 用于加密的密钥
+ * @param {string} str - 需要加密的字符串
+ * @returns {string} - 加密后的字符串
+ *
+ * @example encrypt('abcdefg', 'Good Day')
+ * // 输出: 'mogppK+YrC+iXpgns4wXHg=='
+ */
+export declare const encrypt: (secretKey: string, str: string) => string;
+/**
+ * 使用 DES 算法解密字符串
+ *
+ * @param {string} secretKey - 用于解密的密钥
+ * @param {string} str - 需要解密的字符串
+ * @returns {string} - 解密后的字符串
+ *
+ * @example decrypt('abcdefg', 'mogppK+YrC+iXpgns4wXHg==')
+ * // 输出: 'Good Day'
+ */
+export declare const decrypt: (secretKey: string, str: string) => string;
+/**
+ * 将对象转换为 URL 查询字符串
+ *
+ * @param {any} query - 需要转换的对象
+ * @param {string} prefix - 查询字符串的前缀，默认为 '?'
+ * @returns {string} - 转换后的 URL 查询字符串
+ *
+ * @example stringify({ name: 'John', age: 30 })
+ * // 输出: '?name=John&age=30'
+ */
+export declare const stringify: (query: any, prefix?: string) => string;
+/**
+ * 将 URL 查询字符串解析为对象
+ *
+ * @param {string} queryString - 需要解析的 URL 查询字符串
+ * @param {string} prefix - 查询字符串的前缀，默认为 '?'
+ * @returns {unknown} - 解析后的对象
+ *
+ * @example parse('?name=John&age=30')
+ * // 输出: { name: 'John', age: 30 }
+ */
+export declare const parse: (queryString: string, prefix?: string) => unknown;

package/src/utils/empty/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 定义一个空函数，用于作为默认的回调函数。
+ * 这个函数不执行任何操作，用于在没有提供回调函数时作为默认值。
+ * @returns {void} - 不返回任何值。
+ */
+export declare const fn: () => void;
+/**
+ * 定义一个空对象，用于作为默认的对象值。
+ * 这个对象不包含任何属性，用于在没有提供对象时作为默认值。
+ * @type {Object} - 返回一个空对象。
+ */
+export declare const object: {};
+/**
+ * 定义一个空数组，用于作为默认的数组值。
+ * 这个数组不包含任何元素，用于在没有提供数组时作为默认值。
+ * @type {Array} - 返回一个空数组。
+ */
+export declare const list: never[];

package/src/utils/httpRequest/HttpRequestError.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 定义一个自定义错误类 `HttpRequestError`，它继承自 `Error` 类。
+ * 这个类用于表示 HTTP 请求过程中发生的错误。
+ */
+export declare class HttpRequestError extends Error {
+    code: string | number;
+    /**
+     * 构造函数，用于创建 `HttpRequestError` 类的实例。
+     *
+     * @param code - 错误码，可以是字符串或数字类型。
+     * @param msg - 错误消息，描述错误的详细信息。
+     */
+    constructor(code: string | number, msg: string);
+}

package/src/utils/httpRequest/httpRequestCreator.d.ts

@@ -0,0 +1,61 @@
+import { AxiosRequestConfig, CancelTokenSource, CreateAxiosDefaults, InternalAxiosRequestConfig } from 'axios';
+import { HttpRequestError } from './HttpRequestError';
+/**
+ * 定义一个接口HttpRequestPromise，它继承自Promise，并包含一个ajaxSource属性，类型为CancelTokenSource。
+ * 这个接口通常用于表示一个HTTP请求的Promise对象，并且可以通过ajaxSource属性取消请求。
+ */
+export interface HttpRequestPromise<T = any> extends Promise<T> {
+    ajaxSource: CancelTokenSource;
+}
+/**
+ * 定义一个接口HttpRequestLoader，它是一个泛型函数，接受一个AxiosRequestConfig类型的参数，并返回一个HttpRequestPromise类型的对象。
+ * 这个接口通常用于表示一个HTTP请求的加载器，它可以发送请求并返回一个Promise对象。
+ */
+export interface HttpRequestLoader {
+    <T>(config: AxiosRequestConfig): HttpRequestPromise<T>;
+}
+/**
+ * 定义一个常量TIME_OUT_CODE，它的值为'TIME_OUT'，用于表示请求超时的错误码。
+ */
+export declare const ABORTED_CODE = "ABORTED";
+/**
+ * 定义一个函数create，它接受一个包含多个属性的对象作为参数，并返回一个HttpRequestLoader类型的函数。
+ * 这个函数通常用于创建一个HTTP请求的加载器，它可以根据传入的参数配置axios实例，并处理请求和响应。
+ *
+ * @param option - 包含多个属性的对象，用于配置axios实例和处理请求和响应。
+ * @param option.options 创建axio时的参数
+ * @param option.errorDataCode 异常的数据的错误码
+ * @param option.requestIntercept 请求栏截器，可选
+ * @param option.errorHandler 错误处理回调方法，可选
+ * @param option.dataCodeProp 返回数据中的code的属性名，可选，默认为code
+ * @param option.dataSuccessCodeRanges 返回数据中的code的正常值的范围的数组，可选，数组中出现[number, number]，则code的值判断为在这两个数中间(大于等于和小于等于的关系)，如果出现number或string类型，则为等于关系，出现多个则视为或的关系，只要有一个满足则为true
+ * @param option.dataMsgProp 返回数据中的message的属性名，可选，默认为msg
+ * @param option.dataDataProp 返回数据中的data的属性名，可选，默认为data
+ * @returns 一个HttpRequestLoader类型的函数，用于发送HTTP请求。
+ *
+ * @example
+    create(
+      {
+        axiosOptions: {
+          baseURL: '/api'
+        },
+        errorDataCode: 500,
+        requestIntercept: (requestConfig) => requestConfig,
+        errorHandler: (error) => Promise.reject(error),
+        dataCodeProp: 'code',
+        dataSuccessCodeRanges: [[200, 300], 0, 'success'],
+        dataMsgProp: 'msg',
+        dataDataProp: 'data'
+      }
+    )
+ */
+export declare const create: (option: {
+    axiosOptions: CreateAxiosDefaults;
+    errorDataCode: HttpRequestError["code"];
+    requestIntercept?(requestConfig: InternalAxiosRequestConfig): InternalAxiosRequestConfig | Promise<InternalAxiosRequestConfig>;
+    errorHandler?(error: HttpRequestError): Promise<HttpRequestError>;
+    dataCodeProp?: string | number;
+    dataSuccessCodeRanges?: ([number, number] | number | string)[];
+    dataMsgProp?: string | number;
+    dataDataProp?: string | number;
+}) => HttpRequestLoader;

package/src/utils/httpRequest/httpRequestUtil.d.ts

@@ -0,0 +1,24 @@
+import { HttpRequestPromise } from './httpRequestCreator';
+import { HttpRequestError } from './HttpRequestError';
+/**
+ * 绑定then方法到HttpRequestPromise，并返回一个新的HttpRequestPromise。
+ * 这个函数用于在HTTP请求的Promise链中添加一个then方法，并确保新的Promise仍然包含ajaxSource属性，以便可以取消请求。
+ *
+ * @template T - 扩展自HttpRequestPromise的类型。
+ * @template M - 一个函数类型，它接受HTTP请求的响应作为参数，并返回一个值或一个Promise。
+ * @param {T} request - 原始的HttpRequestPromise。
+ * @param {M} then - 要添加到Promise链中的then方法。
+ * @returns {HttpRequestPromise<ReturnType<M> extends Promise<infer D> ? D : void>} - 一个新的HttpRequestPromise，包含then方法的结果和原始的ajaxSource属性。
+ */
+export declare const bindThenAjaxSource: <T extends HttpRequestPromise, M extends (response: T extends HttpRequestPromise<infer D> ? D : any) => any>(request: T, then: M) => HttpRequestPromise<ReturnType<M> extends Promise<infer D> ? D : void>;
+/**
+ * 绑定catch方法到HttpRequestPromise，并返回一个新的HttpRequestPromise。
+ * 这个函数用于在HTTP请求的Promise链中添加一个catch方法，并确保新的Promise仍然包含ajaxSource属性，以便可以取消请求。
+ *
+ * @template T - 扩展自HttpRequestPromise的类型。
+ * @template M - 一个函数类型，它接受HTTP请求的错误对象作为参数，并返回一个值或一个Promise。
+ * @param {T} request - 原始的HttpRequestPromise。
+ * @param {M} catchFn - 要添加到Promise链中的catch方法。
+ * @returns {T} - 一个新的HttpRequestPromise，包含catch方法的结果和原始的ajaxSource属性。
+ */
+export declare const bindCatchAjaxSource: <T extends HttpRequestPromise, M extends (error: HttpRequestError) => any>(request: T, catchFn: M) => T;

package/src/utils/httpRequest/index.d.ts

@@ -0,0 +1,3 @@
+export * from './HttpRequestError';
+export * from './httpRequestUtil';
+export * from './httpRequestCreator';

package/src/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from './DeclareType';
+export * as empty from './empty';
+export * from './class/combine';
+export * from './class/bind';
+export * from './crypto';
+export * from './math/toFixed';
+export * from './math/unitConvertor';
+export * as reduce from './reduce';
+export * from './Date/ZDate';
+export * as mock from './mock';
+export * as httpRequest from './httpRequest';

package/src/utils/math/toFixed.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 将数字四舍六入五成双到指定的小数位数。
+ *
+ * @param {number} number - 要四舍六入五成双的数字。
+ * @param {number} [fractionDigits=0] - 要保留的小数位数。默认为0。
+ * @returns {number} - 四舍六入五成双后的数字。
+ *
+ * @example toFixed(12.5, 0)
+ * // 输出 12
+ */
+export declare const toFixed: (number: number, fractionDigits?: number) => number;

package/src/utils/math/unitConvertor.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 基本单位配置对象，包含单位列表、正转换函数和负转换函数。
+ */
+declare const baseUnitConfig: {
+    readonly list: readonly [readonly ["mg/L", 1000, "mg/m3", 1000, "μg/m3", 1000, "ng/m3"], readonly ["ppml", 1000, "ppm", 1000, "ppb", 1000, "ppt"], readonly ["mg/L", 1000, "mg/m³", 1000, "μg/m³", 1000, "ng/m³"], readonly ["kg", 1000, "g", 1000, "mg", 1000, "μg"], readonly ["psi", 6.895, "kpa", 10, "hpa", 100, "pa", 0.0075, "mm hg"], readonly ["km", 1000, "m"], readonly ["km/s", 1000, "m/s"], readonly ["m³/s", 3600, "m³/h", 24, "m³/d"], readonly ["kg/s", 3600, "kg/h", 24, "kg/d"], readonly ["m/s", 3.6, "km/h"]];
+    readonly positive: (n: number) => (value: number) => number;
+    readonly negative: (n: number) => (value: number) => number;
+};
+/**
+ * 基本单位配置类型，与 `baseUnitConfig` 类型相同。
+ */
+type BaseUnitConfig = typeof baseUnitConfig;
+/**
+ * 基本单位配置列表中值的类型，排除数字类型。
+ */
+type BaseUnitConfigListValue = BaseUnitConfig['list'][number][number];
+/**
+ * 单位键类型，从基本单位配置列表中提取的单位字符串。
+ */
+export type UnitKey = Exclude<BaseUnitConfigListValue, number>;
+/**
+ * 单位转换函数，根据输入单位和输出单位进行数值转换。
+ *
+ * @param value - 要转换的数值。
+ * @param inputUnit - 输入单位。
+ * @param outputUnit - 输出单位。
+ * @param otherParams - 其他参数，如重量和摩尔。
+ * @returns 转换后的数值。
+ *
+ * @example unitConvertor(9, 'μg/m³', 'ppb', 64)
+ * @returns 3.4382812499999997
+ */
+export declare const unitConvertor: (value: number, inputUnit?: UnitKey | null, outputUnit?: UnitKey | null, ...otherParams: any[]) => any;
+export {};

package/src/utils/mock/HttpResponse.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 定义 HttpResponseDataKey 类型，它是一个以 "data" 开头的字符串
+ */
+type HttpResponseDataKey = `data${string}`;
+/**
+ * HttpResponse 类，用于模拟 HTTP 响应
+ * @template T - 响应数据的类型
+ */
+export declare class HttpResponse<T> {
+    /**
+     * HTTP 响应的状态码
+     */
+    code: number | string;
+    /**
+     * HTTP 响应的消息
+     */
+    msg: string;
+    /**
+     * 响应数据，使用 HttpResponseDataKey 作为键
+     */
+    [dataProp: HttpResponseDataKey]: T;
+    /**
+     * 构造函数，用于创建 HttpResponse 实例
+     * @param {HttpResponseDataKey} dataProp - 响应数据的键
+     * @param {T} data - 响应数据的值
+     * @param {boolean} [randomCode=false] - 是否随机生成状态码
+     */
+    constructor(dataProp: HttpResponseDataKey, data: T, randomCode?: boolean);
+}
+export {};

package/src/utils/mock/createDataTimes.d.ts

@@ -0,0 +1,20 @@
+import { ZDateUnit } from '../Date/ZDate';
+/**
+ * 根据日期范围和间隔生成日期时间数组
+ * @param dateRange - 日期范围，包含开始日期和结束日期
+ * @param interval - 时间间隔
+ * @param dateUnit - 时间单位
+ * @param repeat - 重复次数，默认为1
+ * @returns 生成的日期时间数组
+ */
+export declare const createDataTimesByRange: (dateRange: [string | Date, string | Date], interval: number, dateUnit: ZDateUnit, repeat?: number) => string[];
+/**
+ * 根据开始时间、长度和间隔生成日期时间数组
+ * @param beginTime - 开始时间
+ * @param length - 时间长度
+ * @param interval - 时间间隔
+ * @param dateUnit - 时间单位
+ * @param repeat - 重复次数，默认为1
+ * @returns 生成的日期时间数组
+ */
+export declare const createDataTimesByLength: (beginTime: string, length: number, interval: number, dateUnit: ZDateUnit, repeat?: number) => string[];

package/src/utils/mock/index.d.ts

@@ -0,0 +1,2 @@
+export * from './HttpResponse';
+export * from './createDataTimes';

package/src/utils/reduce/completeByDate.d.ts

@@ -0,0 +1,51 @@
+import { WeekParams, ZDateUnit } from '../Date/ZDate';
+import { KeyMatch } from '../DeclareType';
+/**
+ * 根据日期范围和时间间隔补全数据列表。
+ *
+ * @template T - 数据类型。
+ * @template U - 日期单位类型。
+ * @param {T[]} list - 原始数据列表。
+ * @param {KeyMatch<T, string>} dataTimeProp - 数据中日期时间属性的键名。
+ * @param {[string, string]} dateRange - 日期范围，包含开始日期和结束日期的字符串数组。
+ * @param {Object} completeConfig - 补全配置对象。
+ * @param {number} completeConfig.interval - 时间间隔。
+ * @param {U} completeConfig.unit - 日期单位。
+ * @param {string} completeConfig.format - 日期格式化字符串。
+ * @param {boolean} [completeConfig.isUTC] - 是否使用UTC时间，默认为false。
+ * @param {U extends 'Week' ? WeekParams : never} [completeConfig.unitParams] - 当单位为周时的额外参数。
+ * @param {(data: T) => T} [missDataFormatter] - 缺失数据格式化函数，默认为恒等函数。
+ * @returns {T[]} - 补全后的列表。
+ *
+ * @example
+    completeByDate(
+      [
+        { dataTime: '2024/01/01 00:00:00' },
+        { dataTime: '2024/01/01 03:00:00' },
+      ],
+      'dataTime', // 数据中的时间属性名
+      ['2024/01/01 00:00:00', '2024/01/01 05:00:00'], // 补齐时间的范围
+      {
+        interval: 1, // 间隔1
+        unit: 'Hours', // 补齐单位为小时
+        format: 'YYYY/MM/DD HH:mm:ss', // 此处格式必须和数据中的时间格式一致
+        weekParams: [1, 1] // 当unit为Week时, 此参数生效
+      }
+    )
+ * // 输出
+    [
+      { dataTime: '2024/01/01 00:00:00' },
+      { dataTime: '2024/01/01 01:00:00' },
+      { dataTime: '2024/01/01 02:00:00' },
+      { dataTime: '2024/01/01 03:00:00' },
+      { dataTime: '2024/01/01 04:00:00' },
+      { dataTime: '2024/01/01 05:00:00' }
+    ]
+ */
+export declare const completeByDate: <T, U extends ZDateUnit>(list: T[], dataTimeProp: KeyMatch<T, string>, dateRange: [string, string], completeConfig: {
+    interval: number;
+    unit: U;
+    format: string;
+    isUTC?: boolean;
+    unitParams?: U extends "Week" ? WeekParams : never;
+}, missDataFormatter?: (data: T) => T) => T[];

package/src/utils/reduce/index.d.ts

@@ -0,0 +1,9 @@
+export * from './completeByDate';
+export * from './mappingBuilder';
+export * from './ratio';
+export * from './sumByGroup';
+export * from './toGroup';
+export * from './valueConvertor';
+export * from './verticalToHorizontal';
+export * from './sort';
+export * as tree from './tree';

package/src/utils/reduce/mappingBuilder.d.ts

@@ -0,0 +1,69 @@
+import { KeyMatch } from '../DeclareType';
+/**
+ * 将对象数组转换为键值对形式的对象。
+ *
+ * @template T - 对象类型。
+ * @param {T[]} dataList - 对象数组。
+ * @param {KeyMatch<T, PropertyKey>} mapKeyProp - 用于生成键的属性名。
+ * @returns {Record<PropertyKey, T>} - 转换后的键值对对象。
+ *
+ * @example
+    toKeyValue(
+      [
+        { id: 'id1', name: 'name1' },
+        { id: 'id2', name: 'name2' }
+      ],
+      'id'
+    )
+ * // 输出
+    {
+      id1: { id: 'id1', name: 'name1' },
+      id2: { id: 'id2', name: 'name2' }
+    }
+ */
+export declare const toKeyValue: <T>(dataList: T[], mapKeyProp: KeyMatch<T, PropertyKey>) => Record<PropertyKey, T>;
+/**
+ * 将对象数组转换为键值对形式的对象，其中值为数组。
+ *
+ * @template T - 对象类型。
+ * @param {T[]} dataList - 对象数组。
+ * @param {KeyMatch<T, PropertyKey>} mapKeyProp - 用于生成键的属性名。
+ * @returns {Record<PropertyKey, T[]>} - 转换后的键值对对象。
+ *
+ * @example
+    toKeyValues(
+      [
+        { id: 'id1', name: 'name1' },
+        { id: 'id1', name: 'name2' },
+        { id: 'id2', name: 'name3' }
+      ],
+      'id'
+    )
+ * // 输出
+    {
+      id1: [
+        { id: 'id1', name: 'name1' },
+        { id: 'id1', name: 'name2' }
+      ],
+      id2: [
+        { id: 'id2', name: 'name3' }
+      ]
+    }
+ */
+export declare const toKeyValues: <T>(dataList: T[], mapKeyProp: KeyMatch<T, PropertyKey>) => Record<PropertyKey, T[]>;
+/**
+ * 将属性键数组转换为键值对形式的对象，其中值为 `true`。
+ *
+ * @param {PropertyKey[]} list - 属性键数组。
+ * @returns {Record<PropertyKey, true>} - 转换后的键值对对象。
+ *
+ * @example
+    toTrue(['1001', '1002', '1003'])
+ * // 输出
+    {
+      '1001': true,
+      '1002': true,
+      '1003': true
+    }
+ */
+export declare const toTrue: (list: PropertyKey[]) => Record<PropertyKey, true>;

package/src/utils/reduce/ratio.d.ts

@@ -0,0 +1,104 @@
+import { KeyMatch, KeyValType } from '../DeclareType';
+/**
+ * 定义一个类型别名 `NumberValueProp<T>`，它表示一个联合类型，包含 `KeyMatch<T, number | undefined | null>` 和 `KeyValType`。
+ * 这个类型别名通常用于表示键值对中的键或值的类型，其中值可以是数字、undefined 或 null。
+ */
+type NumberValueProp<T> = KeyMatch<T, number | undefined | null> & KeyValType;
+/**
+ * 定义一个类型别名 `RatioValue<MD>`，它表示一个对象类型，其中键是 `MD` 数组中每个元素的索引，值是由分子键和分母键组成的字符串，格式为 `${分子键}/${分母键}`。
+ * 这个类型别名通常用于表示比例值的类型。
+ */
+type RatioValue<MD extends [KeyValType, KeyValType][]> = {
+    [K in keyof MD]: `${MD[K][0]}/${MD[K][1]}`;
+};
+/**
+ * 定义一个类型别名 `ResponseData<T, MD>`，它表示一个对象类型，其中包含 `T` 类型的所有属性，以及 `RatioValue<MD>` 类型中每个键对应的值，值的类型是可选的数字。
+ * 这个类型别名通常用于表示响应数据的类型，其中包含原始数据和计算得到的比例值。
+ */
+type ResponseData<T, MD extends [KeyValType, KeyValType][]> = T & {
+    [K in RatioValue<MD>[number]]?: number;
+};
+/**
+ * 定义一个函数 `ratioByHorizontal`，它接受五个参数：`list`、`props`、`n`、`fractionDigits` 和 `enableFourRoundSix`。
+ * 这个函数通常用于计算水平方向上的比例值，并返回一个包含原始数据和计算得到的比例值的数组。
+ *
+ * @param list - 原始数据数组，类型为 `T[]`。
+ * @param props - 比例值的键值对数组，类型为 `MD`，其中 `MD` 是一个二维数组，每个元素是一个包含分子键和分母键的数组。
+ * @param n - 比例值的乘数，类型为 `number`，默认值为 1。
+ * @param fractionDigits - 保留的小数位数，类型为 `number`，默认值为 2。
+ * @param enableFourRoundSix - 是否启用四舍六入五成双规则，类型为 `boolean`，默认值为 true。
+ * @returns 一个包含原始数据和计算得到的比例值的数组，类型为 `ResponseData<T, MD>[]`。
+ *
+ * @example
+    ratioByHorizontal(
+      [
+        { a: 1, b: 2, c: 4, d: 2 },
+        { a: 4, b: 2, c: 1, d: 2 }
+      ],
+      [['a', 'b'], ['c', 'd']] as const,
+      100,
+      5
+    )
+ * // 输出
+    [
+      { a: 1, b: 2, c: 4, d: 2, 'a/b': 0.5, 'c/d': 2 },
+      { a: 4, b: 2, c: 1, d: 2, 'a/b': 2, 'c/d': 0.5 },
+    ]
+ */
+export declare const ratioByHorizontal: <T, MD extends [NumberValueProp<T>, NumberValueProp<T>][]>(list: T[], props: MD, n?: number, fractionDigits?: number, enableFourRoundSix?: boolean) => ResponseData<T, MD>[];
+/**
+ * 定义一个函数 `ratioByVertical`，它接受一个包含以下属性的对象作为参数：
+ * - `list`: 原始数据数组，类型为 `T[]`。
+ * - `props`: 比例值的键值对数组，类型为 `BD`，其中 `BD` 是一个包含三个元素的数组，分别表示基准键、过滤键和值键。
+ * - `propValues`: 比例值的键值对数组，类型为 `MD`，其中 `MD` 是一个二维数组，每个元素是一个包含分子键和分母键的数组。
+ * - `n`: 比例值的乘数，类型为 `number`，默认值为 1。
+ * - `fractionDigits`: 保留的小数位数，类型为 `number`，默认值为 2。
+ * - `enableFourRoundSix`: 是否启用四舍六入五成双规则，类型为 `boolean`，默认值为 true。
+ * - `formatter`: 格式化函数，类型为 `(ratioData: T, calcItems: [T, T]) => void`，默认值为一个空函数。
+ * 这个函数通常用于计算垂直方向上的比例值，并返回一个包含原始数据和计算得到的比例值的数组。
+ *
+ * @param option - 包含计算比例值所需的所有参数的对象。
+ * @returns 一个包含原始数据和计算得到的比例值的数组，类型为 `T[]`。
+ *
+ * @example
+    ratioByVertical(
+      {
+        list: [
+          { dataTime: '2024/01/01 00:00:00', factorId: '1001', value: 1 },
+          { dataTime: '2024/01/01 00:00:00', factorId: '1002', value: 2 }
+        ],
+        props: ['dataTime', 'factorId', 'value'],
+        propValues: ['1001', '1002'],
+        n: 1,
+        fractionDigits: 5,
+        enableFourRoundSix: true,
+        formatter: (ratioData, calcItems) => {
+          ratioData.dataTime = '2024/01/01:23:59:59'
+        }
+      }
+    )
+ * // 输出
+    [{
+      dataTime: '2024/01/01 00:00:00',
+      factorId: '1001',
+      value: 1
+    }, {
+      dataTime: '2024/01/01 00:00:00',
+      factorId: '1002',
+      value: 2
+    }, {
+      dataTime: '2024/01/01:23:59:59',
+      factorId: '1001/1002',
+      value: 0.5
+    }]
+ */
+export declare const ratioByVertical: <T, BD extends [KeyMatch<T, KeyValType>, KeyMatch<T, KeyValType>, KeyMatch<T, number>], MD extends [T[BD[1]], T[BD[1]]][]>(option: {
+    list: T[];
+    props: BD;
+    propValues: MD;
+    n?: number;
+    fractionDigits?: number;
+    enableFourRoundSix?: boolean;
+    formatter?: (ratioData: T, calcItems: [T, T]) => void;
+}) => T[];
+export {};

package/src/utils/reduce/sort.d.ts

@@ -0,0 +1,12 @@
+import { KeyMatch } from '../DeclareType';
+/**
+ * 对列表进行排序的函数。
+ *
+ * 该函数接受一个列表和一个排序键作为参数，根据排序键对列表进行排序。
+ * 排序键可以是一个字符串或一个函数，用于指定排序的依据。
+ *
+ * @param {T[]} list - 需要排序的列表。
+ * @param {KeyMatch<T, undefined | number>} sortKey - 排序键，可以是一个字符串或一个函数。
+ * @returns {T[]} 返回排序后的列表。
+ */
+export declare const sort: <T>(list: T[], sortKey: KeyMatch<T, undefined | number>) => T[];