zzz-pc-view 0.0.1

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

@@ -0,0 +1,14 @@
+/**
+ * 根据 enableFourRoundSix 参数决定是否使用四舍六入五成双的函数
+ * 如果 enableFourRoundSix 为 true，则使用四舍六入五成双的函数
+ * 如果 enableFourRoundSix 为 false，则使用 Number.prototype.toFixed 方法
+ * @param enableFourRoundSix - 是否启用四舍六入五成双
+ * @returns 返回一个函数，该函数接受一个数字和可选的小数位数，并根据 enableFourRoundSix 的值返回相应的结果
+ */
+export declare const getToFixed: (enableFourRoundSix: boolean) => (number: number, fractionDigits?: number) => number;
+/**
+ * 创建一个新对象，并将其原型设置为指定对象的原型
+ * @param data - 要复制原型的对象
+ * @returns 返回一个新对象，其原型与 data 对象相同
+ */
+export declare const createPrototype: <T>(data: T) => any;

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

@@ -0,0 +1,65 @@
+import { KeyMatch } from '../DeclareType';
+import { UnitKey } from '../math/unitConvertor';
+/**
+ * 格式化列表中的值，根据配置进行单位转换和四舍六入五成双处理。
+ *
+ * @template T - 列表中元素的类型。
+ * @template U - 单位配置对象的类型。
+ * @param {T[]} list - 要格式化的列表。
+ * @param {[KeyMatch<T, PropertyKey>, KeyMatch<T, number>]} props - 包含键和值的属性匹配数组。
+ * @param {Object} unitConfig - 单位配置对象。
+ * @param {Record<PropertyKey, U>} unitConfig.map - 键到单位配置的映射。
+ * @param {KeyMatch<U, UnitKey | null>} unitConfig.inputUnitProp - 输入单位的属性匹配。
+ * @param {KeyMatch<U, UnitKey | null>} unitConfig.outputUnitProp - 输出单位的属性匹配。
+ * @param {KeyMatch<U, number | undefined | null>} [unitConfig.weightProp] - 权重的属性匹配。
+ * @param {KeyMatch<U, number | undefined | null>} unitConfig.fractionDigitsProp - 小数位数的属性匹配。
+ * @param {number} [unitConfig.mol] - 摩尔数。
+ * @param {boolean} [enableFourRoundSix=true] - 是否启用四舍六入五成双。
+ * @returns {T[]} - 格式化后的列表。
+ *
+ * @example
+    formatValue(
+      [
+        { factorId: '1001', value: 10.71523 },
+        { factorId: '1002', value: 9}
+      ],
+      [ 'factorId', 'value' ],
+      {
+        map: {
+          '1001': {
+            id: '1001',
+            name: 'SO₂',
+            unit: 'μg/m³',
+            units: ['μg/m³', 'ppb'],
+            weight: 64,
+            digitalCount: 0
+          },
+          '1002': {
+            id: '1002',
+            name: 'NO',
+            unit: 'μg/m³',
+            units: ['μg/m³', 'ppb'],
+            weight: 64,
+            digitalCount: 30
+          }
+        },
+        inputUnitProp: 'unit',
+        outputUnitProp: 'convertUnit',
+        weightProp: 'weight',
+        fractionDigitsProp: 'digitalCount'
+      }
+    )
+ * // 输出
+    [
+      { factorId: '1001', value: 4 },
+      { factorId: '1002', value: 3.4382812499999997}
+    ]
+ */
+export declare const formatValue: <T, U>(list: T[], props: [KeyMatch<T, PropertyKey>, KeyMatch<T, number>], unitConfig: {
+    map: Record<PropertyKey, U>;
+    inputUnitProp: KeyMatch<U, UnitKey | null>;
+    outputUnitProp: KeyMatch<U, UnitKey | null>;
+    weightProp?: KeyMatch<U, number | undefined | null>;
+    fractionDigitsProp: KeyMatch<U, number | undefined | null>;
+    mol?: number;
+}, enableFourRoundSix?: boolean) => T[];

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

@@ -0,0 +1,80 @@
+import { KeyMatch } from '../DeclareType';
+/**
+ * 定义一个类型别名 `DimensionKey<T>`，它表示一个联合类型，包含 `T` 类型中所有属性的键，这些键的类型是 `PropertyKey`。
+ * 这个类型别名通常用于表示数据对象中的维度键。
+ */
+type DimensionKey<T> = KeyMatch<T, PropertyKey>;
+/**
+ * 定义一个类型别名 `OneDimension<T>`，它表示一个数组，数组中包含一个元素，这个元素的类型是 `DimensionKey<T>`。
+ * 这个类型别名通常用于表示只有一个维度键的数据对象。
+ */
+type OneDimension<T> = [DimensionKey<T>];
+/**
+ * 定义一个类型别名 `ThreeDimension<T>`，它表示一个数组，数组中包含三个元素，分别是 `DimensionKey<T>`、`DimensionKey<T>` 和 `keyof T`。
+ * 这个类型别名通常用于表示有三个维度键的数据对象。
+ */
+type ThreeDimension<T> = [DimensionKey<T>, DimensionKey<T>, keyof T];
+/**
+ * 定义一个类型别名 `DimensionKeys<T>`，它表示一个联合类型，包含 `OneDimension<T>` 和 `ThreeDimension<T>`。
+ * 这个类型别名通常用于表示数据对象中的维度键，可以是一个或三个。
+ */
+type DimensionKeys<T> = OneDimension<T> | ThreeDimension<T>;
+/**
+ * 定义一个类型别名 `ResponseData<T, K extends keyof T>`，它表示一个对象类型，包含 `T` 类型中所有 `K` 类型的属性，以及其他任意属性。
+ * 这个类型别名通常用于表示转换后的数据对象。
+ */
+type ResponseData<T, K extends keyof T> = Pick<T, K> & Record<PropertyKey, any>;
+/**
+ * 定义一个类型别名 `Formatter<T, K extends DimensionKeys<T>>`，它表示一个函数类型，根据 `K` 的类型不同，函数的参数和返回值也不同。
+ * 这个类型别名通常用于表示格式化函数，用于在转换数据时对数据进行格式化。
+ */
+type Formatter<T, K extends DimensionKeys<T>> = K extends ThreeDimension<T> ? (convertData: ResponseData<T, K[0]>, data: T, valueKey: T[K[1]], valueProp: K[2]) => void : (convertData: ResponseData<T, K[0]>, data: T) => void;
+/**
+ * 定义一个函数 `verticalToHorizontal`，它接受三个参数：`list`、`keys` 和 `formatter`。
+ * 这个函数通常用于将垂直结构的数据转换为水平结构的数据，并返回一个包含转换后数据的数组。
+ *
+ * @param list - 原始数据数组，类型为 `T[]`。
+ * @param keys - 维度键数组，类型为 `K`，`K` 是 `DimensionKeys<T>` 的子类型。
+ * @param formatter - 可选的格式化函数，类型为 `Formatter<T, K>`，默认值为 `undefined`。
+ * @returns 一个包含转换后数据的数组，类型为 `ResponseData<T, K[0]>[]`。
+ *
+ * @example
+    verticalToHorizontal(
+      [
+        { dataTime: '2024/01/01 00:00:00', factorId: '1001', value: 12 },
+        { dataTime: '2024/01/01 00:00:00', factorId: '1003', value: 10 },
+        { dataTime: '2024/01/01 01:00:00', factorId: '1001', value: 3 },
+        { dataTime: '2024/01/01 01:00:00', factorId: '1003', value: 20 },
+      ],
+      ['dataTime', 'factorId', 'value'],
+      (convertData, data, valueKey, valueProp) => {
+        convertData[valueKey] = data[valueProp]
+        convertData.a = 33
+      }
+    )
+ * // 输出
+    [
+      { dataTime: '2024/01/01 00:00:00', 1001: 12, 1003: 10, a: 33 },
+      { dataTime: '2024/01/01 01:00:00', 1001: 3, 1003: 20, a: 33 },
+    ]
+ * @example
+    verticalToHorizontal(
+      [
+        { dataTime: '2024/01/01 00:00:00', factorId: '1001', value: 12 },
+        { dataTime: '2024/01/01 00:00:00', factorId: '1003', value: 10 },
+        { dataTime: '2024/01/01 01:00:00', factorId: '1001', value: 3 },
+        { dataTime: '2024/01/01 01:00:00', factorId: '1003', value: 20 },
+      ],
+      ['dataTime'],
+      (convertData, data) => {
+        convertData[data.factorId] = data.value
+      }
+    )
+ * // 输出
+    [
+      { dataTime: '2024/01/01 00:00:00', 1001: 12, 1003: 10, a: 33 },
+      { dataTime: '2024/01/01 01:00:00', 1001: 3, 1003: 20, a: 33 },
+    ]
+ */
+export declare const verticalToHorizontal: <T, K extends DimensionKeys<T>>(list: T[], keys: K, formatter?: Formatter<T, K>) => ResponseData<T, K[0]>[];
+export {};