@publishfx/publish-chart 1.3.0

package/dist/utils/__tests__/formatters.test.js

@@ -0,0 +1,333 @@
+import { BigNumberUtil, IndicatorUnit, formatBigNumber, formatIndicatorV2, formatNumberV2, formatPercentage } from "../formatters.js";
+describe('formatters', ()=>{
+    describe('formatNumberV2', ()=>{
+        it('应该格式化基本数字', ()=>{
+            expect(formatNumberV2(1234.56)).toBe('1,234.56');
+            expect(formatNumberV2(1000)).toBe('1,000.00');
+            expect(formatNumberV2(0)).toBe('0.00');
+        });
+        it('应该处理负数', ()=>{
+            expect(formatNumberV2(-1234.56)).toBe('-1,234.56');
+            expect(formatNumberV2(-1000)).toBe('-1,000.00');
+        });
+        it('应该支持自定义小数位数', ()=>{
+            expect(formatNumberV2(1234.5678, {
+                fractionDigits: 0
+            })).toBe('1,235');
+            expect(formatNumberV2(1234.5678, {
+                fractionDigits: 1
+            })).toBe('1,234.6');
+            expect(formatNumberV2(1234.5678, {
+                fractionDigits: 4
+            })).toBe('1,234.5678');
+        });
+        it('应该支持前缀和后缀', ()=>{
+            expect(formatNumberV2(1000, {
+                prefix: '$'
+            })).toBe('$1,000.00');
+            expect(formatNumberV2(1000, {
+                suffix: '%'
+            })).toBe('1,000.00%');
+            expect(formatNumberV2(1000, {
+                prefix: '￥',
+                suffix: '元'
+            })).toBe('￥1,000.00元');
+        });
+        it('应该支持长格式（k/m/b）', ()=>{
+            expect(formatNumberV2(1000, {
+                longFormat: true
+            })).toBe('1.00k');
+            expect(formatNumberV2(1000000, {
+                longFormat: true
+            })).toBe('1.00m');
+            expect(formatNumberV2(1000000000, {
+                longFormat: true
+            })).toBe('1.00b');
+        });
+        it('应该处理空值和无效值', ()=>{
+            expect(formatNumberV2(void 0)).toBe('-');
+            expect(formatNumberV2(null)).toBe('-');
+            expect(formatNumberV2('')).toBe('-');
+            expect(formatNumberV2('-')).toBe('-');
+            expect(formatNumberV2(NaN)).toBe('-');
+        });
+        it('应该支持自定义空值占位符', ()=>{
+            expect(formatNumberV2(void 0, void 0, 'N/A')).toBe('N/A');
+            expect(formatNumberV2(null, void 0, '0')).toBe('0');
+        });
+        it('应该处理字符串数字', ()=>{
+            expect(formatNumberV2('1234.56')).toBe('1,234.56');
+            expect(formatNumberV2('1000')).toBe('1,000.00');
+            expect(formatNumberV2('-1234.56')).toBe('-1,234.56');
+        });
+        it('应该处理大数字', ()=>{
+            expect(formatNumberV2(1234567890.12)).toBe('1,234,567,890.12');
+            expect(formatNumberV2(999999999.99)).toBe('999,999,999.99');
+        });
+        it('应该处理小数', ()=>{
+            expect(formatNumberV2(0.123)).toBe('0.12');
+            expect(formatNumberV2(0.001)).toBe('0.00');
+            expect(formatNumberV2(0.001, {
+                fractionDigits: 3
+            })).toBe('0.001');
+        });
+    });
+    describe('formatPercentage', ()=>{
+        it('应该格式化百分比', ()=>{
+            expect(formatPercentage(0.1234)).toBe('0.12%');
+            expect(formatPercentage(1)).toBe('1.00%');
+            expect(formatPercentage(100)).toBe('100.00%');
+        });
+        it('应该处理负数百分比', ()=>{
+            expect(formatPercentage(-0.1234)).toBe('-0.12%');
+            expect(formatPercentage(-1)).toBe('-1.00%');
+        });
+        it('应该处理空值和无效值', ()=>{
+            expect(formatPercentage(void 0)).toBe('-');
+            expect(formatPercentage(null)).toBe('-');
+            expect(formatPercentage('')).toBe('-');
+            expect(formatPercentage(NaN)).toBe('-');
+        });
+        it('应该支持自定义空值占位符', ()=>{
+            expect(formatPercentage(void 0, 'N/A')).toBe('N/A');
+            expect(formatPercentage(null, '0%')).toBe('0%');
+        });
+        it('应该处理字符串数字', ()=>{
+            expect(formatPercentage('0.1234')).toBe('0.12%');
+            expect(formatPercentage('1')).toBe('1.00%');
+        });
+    });
+    describe('formatBigNumber', ()=>{
+        const createIndicatorInfo = (indicatorID, indicatorFormat)=>({
+                indicatorID,
+                indicatorFormat
+            });
+        it('应该处理空值和无效值', ()=>{
+            expect(formatBigNumber('')).toBe('-');
+            expect(formatBigNumber('-')).toBe('-');
+            expect(formatBigNumber(void 0)).toBe('-');
+            expect(formatBigNumber(null)).toBe('0.00');
+        });
+        it('应该格式化普通数字（无指标信息）', ()=>{
+            expect(formatBigNumber(1234.56)).toBe('1,234.56');
+            expect(formatBigNumber(1000)).toBe('1,000.00');
+        });
+        it('应该格式化百分比类型', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Percentage,
+                indicatorDecimal: 2
+            });
+            expect(formatBigNumber(0.1234, indicatorInfo)).toBe('12.34%');
+            expect(formatBigNumber(0.5, indicatorInfo)).toBe('50.00%');
+        });
+        it('应该格式化美元类型', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Dollar,
+                indicatorDecimal: 2
+            });
+            expect(formatBigNumber(1234.56, indicatorInfo)).toBe('$1,234.56');
+            expect(formatBigNumber(1000, indicatorInfo)).toBe('$1,000.00');
+        });
+        it('应该格式化人民币类型', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.RMB,
+                indicatorDecimal: 2
+            });
+            expect(formatBigNumber(1234.56, indicatorInfo)).toBe('￥1,234.56');
+            expect(formatBigNumber(1000, indicatorInfo)).toBe('￥1,000.00');
+        });
+        it('应该自动转换大数字单位（k/m/b）', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Number,
+                indicatorDecimal: 2
+            });
+            expect(formatBigNumber(10000, indicatorInfo)).toBe('10.00k');
+            expect(formatBigNumber(1000000, indicatorInfo)).toBe('1.00m');
+            expect(formatBigNumber(1000000000, indicatorInfo)).toBe('1.00b');
+        });
+        it('应该支持长格式', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Number,
+                indicatorDecimal: 2
+            });
+            expect(formatBigNumber(10000, indicatorInfo, void 0, true)).toBe('10.00k');
+            expect(formatBigNumber(1000000, indicatorInfo, void 0, true)).toBe('1.00m');
+        });
+        it('应该支持自定义小数位数', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Number,
+                indicatorDecimal: 4
+            });
+            expect(formatBigNumber(1234.5678, indicatorInfo)).toBe('1,234.5678');
+        });
+        it('应该处理 NaN 值', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Number,
+                indicatorDecimal: 2
+            });
+            expect(formatBigNumber('invalid', indicatorInfo)).toBe('-');
+            expect(formatBigNumber(NaN, indicatorInfo)).toBe('-');
+        });
+        it('应该使用默认格式（当没有提供指标格式时）', ()=>{
+            const indicatorInfo = createIndicatorInfo(1);
+            expect(formatBigNumber(1234.56, indicatorInfo)).toBe('1,234.56');
+        });
+        it('应该处理边界值', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Number,
+                indicatorDecimal: 2
+            });
+            expect(formatBigNumber(9999, indicatorInfo)).toBe('9,999.00');
+            expect(formatBigNumber(10000, indicatorInfo)).toBe('10.00k');
+            expect(formatBigNumber(999999, indicatorInfo)).toBe('1,000.00k');
+            expect(formatBigNumber(1000000, indicatorInfo)).toBe('1.00m');
+            expect(formatBigNumber(999999999, indicatorInfo)).toBe('1,000.00m');
+            expect(formatBigNumber(1000000000, indicatorInfo)).toBe('1.00b');
+        });
+        it('应该支持自定义空值占位符', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Number,
+                indicatorDecimal: 2
+            });
+            expect(formatBigNumber(void 0, indicatorInfo, 'N/A')).toBe('N/A');
+        });
+    });
+    describe('formatIndicatorV2', ()=>{
+        const createIndicatorInfo = (indicatorID, indicatorFormat)=>({
+                indicatorID,
+                indicatorFormat
+            });
+        it('应该处理空值和无效值', ()=>{
+            expect(formatIndicatorV2('')).toBe('-');
+            expect(formatIndicatorV2('-')).toBe('-');
+            expect(formatIndicatorV2(void 0)).toBe('-');
+            expect(formatIndicatorV2(null)).toBe('-');
+        });
+        it('应该格式化普通数字（无指标信息）', ()=>{
+            expect(formatIndicatorV2(1234.56)).toBe('1,234.56');
+            expect(formatIndicatorV2(1000)).toBe('1,000.00');
+        });
+        it('应该格式化百分比类型', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Percentage,
+                indicatorDecimal: 2
+            });
+            expect(formatIndicatorV2(0.1234, indicatorInfo)).toBe('12.34%');
+            expect(formatIndicatorV2(0.5, indicatorInfo)).toBe('50.00%');
+        });
+        it('应该格式化美元类型', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Dollar,
+                indicatorDecimal: 2
+            });
+            expect(formatIndicatorV2(1234.56, indicatorInfo)).toBe('$1,234.56');
+            expect(formatIndicatorV2(1000, indicatorInfo)).toBe('$1,000.00');
+        });
+        it('应该格式化人民币类型', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.RMB,
+                indicatorDecimal: 2
+            });
+            expect(formatIndicatorV2(1234.56, indicatorInfo)).toBe('￥1,234.56');
+            expect(formatIndicatorV2(1000, indicatorInfo)).toBe('￥1,000.00');
+        });
+        it('应该支持自定义小数位数', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Number,
+                indicatorDecimal: 4
+            });
+            expect(formatIndicatorV2(1234.5678, indicatorInfo)).toBe('1,234.5678');
+        });
+        it('应该支持长格式', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Number,
+                indicatorDecimal: 2
+            });
+            expect(formatIndicatorV2(1000, indicatorInfo, void 0, true)).toBe('1.00k');
+        });
+        it('应该使用默认格式（当没有提供指标格式时）', ()=>{
+            const indicatorInfo = createIndicatorInfo(1);
+            expect(formatIndicatorV2(1234.56, indicatorInfo)).toBe('1,234.56');
+        });
+        it('应该支持自定义空值占位符', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Number,
+                indicatorDecimal: 2
+            });
+            expect(formatIndicatorV2(void 0, indicatorInfo, 'N/A')).toBe('N/A');
+        });
+        it('应该处理字符串数字', ()=>{
+            const indicatorInfo = createIndicatorInfo(1, {
+                indicatorUnit: IndicatorUnit.Number,
+                indicatorDecimal: 2
+            });
+            expect(formatIndicatorV2('1234.56', indicatorInfo)).toBe('1,234.56');
+        });
+    });
+    describe('BigNumberUtil', ()=>{
+        describe('from', ()=>{
+            it('应该从数字创建 BigNumber 实例', ()=>{
+                const bn = BigNumberUtil.from(123.45);
+                expect(bn.toString()).toBe('123.45');
+            });
+            it('应该从字符串创建 BigNumber 实例', ()=>{
+                const bn = BigNumberUtil.from('123.45');
+                expect(bn.toString()).toBe('123.45');
+            });
+            it('应该处理空值，默认为 0', ()=>{
+                const bn1 = BigNumberUtil.from(null);
+                expect(bn1.toString()).toBe('0');
+                const bn2 = BigNumberUtil.from(void 0);
+                expect(bn2.toString()).toBe('0');
+                const bn3 = BigNumberUtil.from('');
+                expect(bn3.toString()).toBe('0');
+            });
+        });
+        describe('lt', ()=>{
+            it('应该正确比较小于关系', ()=>{
+                expect(BigNumberUtil.lt(1, 2)).toBe(true);
+                expect(BigNumberUtil.lt(2, 1)).toBe(false);
+                expect(BigNumberUtil.lt(1, 1)).toBe(false);
+            });
+            it('应该处理小数比较', ()=>{
+                expect(BigNumberUtil.lt(1.1, 1.2)).toBe(true);
+                expect(BigNumberUtil.lt(1.2, 1.1)).toBe(false);
+            });
+            it('应该处理字符串数字', ()=>{
+                expect(BigNumberUtil.lt('1', '2')).toBe(true);
+                expect(BigNumberUtil.lt('2', '1')).toBe(false);
+            });
+            it('应该处理大数字', ()=>{
+                expect(BigNumberUtil.lt(999999, 1000000)).toBe(true);
+                expect(BigNumberUtil.lt(1000000, 999999)).toBe(false);
+            });
+        });
+        describe('gt', ()=>{
+            it('应该正确比较大于关系', ()=>{
+                expect(BigNumberUtil.gt(2, 1)).toBe(true);
+                expect(BigNumberUtil.gt(1, 2)).toBe(false);
+                expect(BigNumberUtil.gt(1, 1)).toBe(false);
+            });
+            it('应该处理小数比较', ()=>{
+                expect(BigNumberUtil.gt(1.2, 1.1)).toBe(true);
+                expect(BigNumberUtil.gt(1.1, 1.2)).toBe(false);
+            });
+            it('应该处理字符串数字', ()=>{
+                expect(BigNumberUtil.gt('2', '1')).toBe(true);
+                expect(BigNumberUtil.gt('1', '2')).toBe(false);
+            });
+            it('应该处理大数字', ()=>{
+                expect(BigNumberUtil.gt(1000000, 999999)).toBe(true);
+                expect(BigNumberUtil.gt(999999, 1000000)).toBe(false);
+            });
+        });
+    });
+    describe('IndicatorUnit 枚举', ()=>{
+        it('应该包含正确的枚举值', ()=>{
+            expect(IndicatorUnit.Number).toBe(1);
+            expect(IndicatorUnit.Percentage).toBe(2);
+            expect(IndicatorUnit.Dollar).toBe(3);
+            expect(IndicatorUnit.RMB).toBe(4);
+        });
+    });
+});

package/dist/utils/chartHelpers.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 图表工具函数
+ */
+import type { G2 } from 'bizcharts';
+import type { IndicatorInfo } from '../core/ChartTypes';
+/**
+ * 计算文本宽度
+ */
+export declare const calTextWidth: (text: string, fontSize: number) => number;
+/**
+ * 计算柱状图的估算宽度
+ */
+export declare const calculateBarWidth: (chart: G2.Chart, data: any[], xField: string, widthRatio?: number) => number | undefined;
+/**
+ * 根据y轴文本宽度计算图表水平方向padding
+ */
+export declare const getAxisHorPaddingByText: (value: number | string, indicatorMap: Record<string, IndicatorInfo>, y: string | number) => number;
+/**
+ * 通用处理轴信息格式化
+ */
+export declare const getAxisFormat: (val: string | number, indicatorMap: Record<string, IndicatorInfo>, y: string | number) => string;
+/**
+ * 截断文本
+ */
+export declare const truncateText: (text: string, maxWidth: number) => string;
+/**
+ * 标记样式（用于图例）
+ */
+export declare const markerStyle: (baseColor: string, isCompare: boolean) => {
+    width: number;
+    height: number;
+    display: string;
+    borderRadius: string;
+    marginRight: number;
+    backgroundColor: string;
+    backgroundImage: string;
+    backgroundSize: string;
+} | {
+    width: number;
+    height: number;
+    display: string;
+    borderRadius: string;
+    marginRight: number;
+    backgroundColor: string;
+    backgroundImage?: undefined;
+    backgroundSize?: undefined;
+};
+/**
+ * 创建斜纹图案 Canvas
+ */
+export declare const createStripePatternCanvas: (baseColor: string, spaceUnit?: number) => HTMLCanvasElement;
+export declare const getChartKey: (config: any) => string;

package/dist/utils/chartHelpers.js

@@ -0,0 +1,112 @@
+import { formatBigNumber } from "./formatters.js";
+const calTextWidth = (text, fontSize)=>{
+    const canvas = document.createElement('canvas');
+    const context = canvas.getContext('2d');
+    if (!context) return 0;
+    context.font = `${fontSize}px PingFangSC-Regular, PingFangSC, 'Helvetica Neue', Arial, 'Lucida Grande', Verdana, 'Hiragino Sans GB', 'Microsoft YaHei', hei`;
+    return context.measureText(text).width;
+};
+const calculateBarWidth = (chart, data, xField, widthRatio = 0.5)=>{
+    try {
+        const coordinateWidth = chart.coordinateBBox?.width || chart.view?.coordinateBBox?.width || 0;
+        const uniqueXValues = new Set(data.map((item)=>item[xField]));
+        const xCount = uniqueXValues.size;
+        if (coordinateWidth > 0 && xCount > 0) {
+            const xValueWidth = coordinateWidth / xCount;
+            const estimatedBarWidth = xValueWidth * widthRatio;
+            return estimatedBarWidth;
+        }
+    } catch (error) {
+        console.error('计算主图柱状图宽度失败', error);
+    }
+};
+const getAxisHorPaddingByText = (value, indicatorMap, y)=>7 * getAxisFormat(value, indicatorMap, y).length + 26;
+const getAxisFormat = (val, indicatorMap, y)=>{
+    if ('-' === val || '' === val) return val;
+    const cur = Number(val) || 0;
+    const indicator = indicatorMap && indicatorMap[y];
+    return formatBigNumber(cur, indicator);
+};
+const truncateText = (text, maxWidth)=>{
+    if (!text) return text;
+    const span = document.createElement('span');
+    span.style.whiteSpace = 'nowrap';
+    span.style.visibility = 'hidden';
+    span.style.position = 'absolute';
+    span.innerText = text;
+    document.body.appendChild(span);
+    let result = text;
+    if (span.offsetWidth > maxWidth) {
+        let low = 0;
+        let high = text.length;
+        while(low <= high){
+            const mid = Math.floor((low + high) / 2);
+            span.innerText = text.slice(0, mid) + '...';
+            if (span.offsetWidth <= maxWidth) low = mid + 1;
+            else high = mid - 1;
+        }
+        result = text.slice(0, high) + '...';
+    }
+    document.body.removeChild(span);
+    return result;
+};
+const markerStyle = (baseColor, isCompare)=>isCompare ? {
+        width: 8,
+        height: 8,
+        display: 'inline-block',
+        borderRadius: '50%',
+        marginRight: 8,
+        backgroundColor: 'transparent',
+        backgroundImage: `repeating-linear-gradient(
+      45deg,
+      rgba(255,255,255,0.95) 0,
+      rgba(255,255,255,0.95) 1px,
+      transparent 1px,
+      transparent 3px
+    )`,
+        backgroundSize: '4px 4px'
+    } : {
+        width: 8,
+        height: 8,
+        display: 'inline-block',
+        borderRadius: '50%',
+        marginRight: 8,
+        backgroundColor: baseColor
+    };
+const createStripePatternCanvas = (baseColor, spaceUnit = 24)=>{
+    const patternCanvas = document.createElement('canvas');
+    patternCanvas.width = spaceUnit;
+    patternCanvas.height = spaceUnit;
+    const patternCtx = patternCanvas.getContext('2d', {
+        willReadFrequently: false,
+        alpha: true
+    });
+    if (!patternCtx) return patternCanvas;
+    patternCtx.imageSmoothingEnabled = true;
+    patternCtx.imageSmoothingQuality = 'high';
+    patternCtx.fillStyle = baseColor;
+    patternCtx.globalAlpha = 0.9;
+    patternCtx.fillRect(0, 0, spaceUnit, spaceUnit);
+    const lineWidth = spaceUnit <= 12 ? 2 : 4;
+    patternCtx.strokeStyle = 'rgba(255, 255, 255, 1)';
+    patternCtx.lineWidth = lineWidth;
+    patternCtx.lineCap = 'square';
+    patternCtx.lineJoin = 'miter';
+    const stripeSpacing = spaceUnit / 2;
+    const startIndex = -2;
+    const endIndex = 4;
+    for(let i = startIndex; i <= endIndex; i++){
+        const offset = i * stripeSpacing;
+        const x1 = offset;
+        const y1 = 0;
+        const x2 = offset + spaceUnit;
+        const y2 = spaceUnit;
+        patternCtx.beginPath();
+        patternCtx.moveTo(x1, y1);
+        patternCtx.lineTo(x2, y2);
+        patternCtx.stroke();
+    }
+    return patternCanvas;
+};
+const getChartKey = (config)=>JSON.stringify(config);
+export { calTextWidth, calculateBarWidth, createStripePatternCanvas, getAxisFormat, getAxisHorPaddingByText, getChartKey, markerStyle, truncateText };

package/dist/utils/dataTransform.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 转换对比指标数据
+ */
+export declare function transformIndicatorList(indicators: Array<string>, indicatorData: any): any;
+/**
+ * 变化率
+ */
+export declare const getIntervalRatio: (ratio: string) => string;
+/**
+ * 两两分组
+ */
+export declare const groupArray: (arr: Array<any>) => any;

package/dist/utils/dataTransform.js

@@ -0,0 +1,64 @@
+import { isNil } from "lodash";
+import { BigNumberUtil, formatPercentage } from "./formatters.js";
+const formatValue = (val)=>{
+    if ('' === val || isNaN(Number(val))) return '-';
+    return Number(val);
+};
+function transformIndicatorList(indicators, indicatorData) {
+    const result = {};
+    for (const indicatorType of indicators){
+        result[indicatorType] = [];
+        for(let i = 0; i < indicatorData.length; i++){
+            const groupName = indicatorData[i].groupName;
+            const indicatorValue = indicatorData[i][indicatorType];
+            const compareKey = `${indicatorType}_compare`;
+            const changeKey = `${indicatorType}_change`;
+            const compareTimeKey = `${indicatorType}_compare_time`;
+            const compareValue = indicatorData[i][compareKey];
+            const changeValue = indicatorData[i][changeKey];
+            const compareTimeValue = indicatorData[i][compareTimeKey];
+            const nodeInfos = indicatorData[i]['nodeInfos'];
+            const item = {
+                groupName,
+                groupType: indicatorType,
+                groupValue: formatValue(indicatorValue),
+                indicatorType,
+                indicatorValue: formatValue(indicatorValue),
+                change: formatValue(changeValue),
+                nodeInfos
+            };
+            result[indicatorType].push(item);
+            if (!isNil(compareValue)) {
+                const compareItem = {
+                    groupName,
+                    groupType: compareKey,
+                    groupValue: formatValue(compareValue),
+                    change: formatValue(changeValue),
+                    indicatorType: compareKey,
+                    indicatorValue: formatValue(compareValue),
+                    compareTime: compareTimeValue || '对比时间',
+                    nodeInfos
+                };
+                result[indicatorType].push(compareItem);
+            }
+        }
+    }
+    return result;
+}
+const getIntervalRatio = (ratio)=>{
+    const intervalRatio = formatValue(ratio);
+    if ('-' === intervalRatio) return intervalRatio;
+    const percentageStr = formatPercentage(100 * intervalRatio, '0');
+    const percentage = intervalRatio <= 0 ? percentageStr.split('-')[1] : percentageStr;
+    if (BigNumberUtil.lt(intervalRatio, 0)) return `下降${percentage}`;
+    if (BigNumberUtil.gt(intervalRatio, 0)) return `上升${percentage}`;
+    return '持平';
+};
+const groupArray = (arr)=>arr.reduce((result, current, index)=>{
+        if (index % 2 === 0) result.push([
+            current
+        ]);
+        else result[result.length - 1].push(current);
+        return result;
+    }, []);
+export { getIntervalRatio, groupArray, transformIndicatorList };

package/dist/utils/formatters.d.ts

@@ -0,0 +1,37 @@
+import BigNumber from 'big.js';
+import type { IndicatorInfo } from '../core/ChartTypes';
+export declare enum IndicatorUnit {
+    Number = 1,
+    Percentage = 2,
+    Dollar = 3,
+    RMB = 4
+}
+/**
+ * 格式化数字
+ */
+export declare function formatNumberV2(value?: number | string, options?: {
+    fractionDigits?: number;
+    prefix?: string;
+    suffix?: string;
+    longFormat?: boolean;
+}, emptyStr?: string): string;
+/**
+ * 格式化百分比
+ */
+export declare function formatPercentage(value?: number | string, emptyStr?: string): string;
+/**
+ * 格式化大数（简化版本）
+ */
+export declare function formatBigNumber(value?: number | string, indicatorInfo?: IndicatorInfo, emptyStr?: string, longFormat?: boolean): string;
+/**
+ * 格式化指标值（简化版本）
+ */
+export declare function formatIndicatorV2(value?: number | string, indicatorInfo?: IndicatorInfo, emptyStr?: string, longFormat?: boolean): string;
+/**
+ * BigNumber 工具（简化版本）
+ */
+export declare class BigNumberUtil {
+    static from(value: any): BigNumber;
+    static lt(value1: any, value2: any): boolean;
+    static gt(value1: any, value2: any): boolean;
+}