office-viewer 0.2.1 → 0.3.1

package/esm/excel/sheet/cfRule/colorScale.js

@@ -0,0 +1,141 @@
+import { __values, __read } from 'tslib';
+import { Color, interpolateColor } from '../../../util/color.js';
+import { getMinMax } from './getMinMax.js';
+
+/**
+ * 色阶
+ */
+function colorScale(sheet, cellInfo, ranges, cfRule) {
+    var e_1, _a, e_2, _b;
+    var rangeCache = sheet.getRangeCache();
+    var ruleKey = JSON.stringify(cfRule);
+    var rangeColorScale = rangeCache.get(ranges, ruleKey);
+    var colorScale = cfRule.colorScale;
+    if (!colorScale) {
+        return false;
+    }
+    if (!rangeColorScale) {
+        var dataProvider = sheet.workbook.getDataProvider();
+        var cfvo = colorScale.cfvo;
+        var color = colorScale.color;
+        if (!cfvo || !color) {
+            console.warn('色阶规则不完整');
+            return false;
+        }
+        if (cfvo.length !== color.length) {
+            console.warn('色阶规则不匹配');
+            return false;
+        }
+        var rangeValues = sheet.getCellValueByRanges(ranges);
+        var _c = getMinMax(rangeValues), min = _c.min, max = _c.max;
+        if (min === undefined || max === undefined) {
+            return false;
+        }
+        var colors = [];
+        try {
+            for (var _d = __values(cfvo.entries()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var _f = __read(_e.value, 2), i = _f[0], cfvoItem = _f[1];
+                var type = cfvoItem.type;
+                switch (type) {
+                    case 'min': {
+                        var colorValue = dataProvider.getColor(color[i]);
+                        if (colorValue !== 'none') {
+                            colors.push({
+                                percent: 0,
+                                color: new Color(colorValue)
+                            });
+                        }
+                        break;
+                    }
+                    case 'max': {
+                        var colorValue = dataProvider.getColor(color[i]);
+                        if (colorValue !== 'none') {
+                            colors.push({
+                                percent: 1,
+                                color: new Color(colorValue)
+                            });
+                        }
+                        break;
+                    }
+                    case 'percentile': {
+                        var val = parseInt(cfvoItem.val || '50', 10);
+                        var percent_1 = val / 100;
+                        var colorValue = dataProvider.getColor(color[i]);
+                        if (colorValue !== 'none') {
+                            colors.push({
+                                percent: percent_1,
+                                color: new Color(colorValue)
+                            });
+                        }
+                        break;
+                    }
+                    default:
+                        console.warn('未知的 cfvo type', type);
+                        break;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (colors.length < 2) {
+            console.warn('色彩数量不足');
+        }
+        // 排序一下避免 xml 里乱序
+        colors.sort(function (a, b) { return a.percent - b.percent; });
+        rangeColorScale = {
+            min: min,
+            max: max,
+            colors: colors
+        };
+        rangeCache.set(ranges, ruleKey, rangeColorScale);
+    }
+    var value = parseFloat(cellInfo.value);
+    // 当前值所在的百分比
+    var percent = (value - rangeColorScale.min) / (rangeColorScale.max - rangeColorScale.min);
+    // 查找所属色阶
+    var endColor;
+    var endPercent = 1;
+    var startPercent = 0;
+    var startColor = rangeColorScale.colors[0].color;
+    try {
+        for (var _g = __values(rangeColorScale.colors), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var color = _h.value;
+            if (percent >= startPercent && percent < color.percent) {
+                endColor = color.color;
+                endPercent = color.percent;
+                break;
+            }
+            startColor = color.color;
+            startPercent = color.percent;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (endColor === undefined) {
+        endColor = rangeColorScale.colors[rangeColorScale.colors.length - 1].color;
+    }
+    var percentRange = endPercent - startPercent;
+    // 避免除 0
+    if (percentRange === 0) {
+        percentRange = 1;
+    }
+    var backgroundColor = interpolateColor(startColor, endColor, (percent - startPercent) / percentRange);
+    cellInfo.fill = {
+        patternFill: {
+            bgColor: { rgb: 'FF' + backgroundColor }
+        }
+    };
+    return true;
+}
+
+export { colorScale };

package/esm/excel/sheet/cfRule/containsBlanks.d.ts

@@ -0,0 +1,7 @@
+import { CT_CfRule } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { Sheet } from '../Sheet';
+/**
+ * 空内容
+ */
+export declare function containsBlanks(sheet: Sheet, cellInfo: CellInfo, cfRule: CT_CfRule): boolean;

package/esm/excel/sheet/cfRule/containsBlanks.js

@@ -0,0 +1,14 @@
+import { applyCfRuleDxf } from './applyCfRuleDxf.js';
+
+/**
+ * 空内容
+ */
+function containsBlanks(sheet, cellInfo, cfRule) {
+    if (cellInfo.value.trim() === '') {
+        applyCfRuleDxf(cfRule, sheet, cellInfo);
+        return true;
+    }
+    return false;
+}
+
+export { containsBlanks };

package/esm/excel/sheet/cfRule/containsErrors.d.ts

@@ -0,0 +1,7 @@
+import { CT_CfRule } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { Sheet } from '../Sheet';
+/**
+ * 包含错误
+ */
+export declare function containsErrors(sheet: Sheet, cellInfo: CellInfo, cfRule: CT_CfRule): boolean;

package/esm/excel/sheet/cfRule/containsErrors.js

@@ -0,0 +1,15 @@
+import { applyCfRuleDxf } from './applyCfRuleDxf.js';
+
+/**
+ * 包含错误
+ */
+function containsErrors(sheet, cellInfo, cfRule) {
+    if (typeof cellInfo.cellData === 'object' &&
+        cellInfo.cellData.type === 'error') {
+        applyCfRuleDxf(cfRule, sheet, cellInfo);
+        return true;
+    }
+    return false;
+}
+
+export { containsErrors };

package/esm/excel/sheet/cfRule/containsText.d.ts

@@ -0,0 +1,7 @@
+import { CT_CfRule } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { Sheet } from '../Sheet';
+/**
+ * 包含文本
+ */
+export declare function containsText(sheet: Sheet, cellInfo: CellInfo, cfRule: CT_CfRule): boolean;

package/esm/excel/sheet/cfRule/containsText.js

@@ -0,0 +1,17 @@
+import { applyCfRuleDxf } from './applyCfRuleDxf.js';
+
+/**
+ * 包含文本
+ */
+function containsText(sheet, cellInfo, cfRule) {
+    if (!cfRule.text) {
+        return false;
+    }
+    if (cellInfo.value.includes(cfRule.text)) {
+        applyCfRuleDxf(cfRule, sheet, cellInfo);
+        return true;
+    }
+    return false;
+}
+
+export { containsText };

package/esm/excel/sheet/cfRule/dataBar.d.ts

@@ -0,0 +1,8 @@
+import { CT_CfRule } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { RangeRef } from '../../types/RangeRef';
+import { Sheet } from '../Sheet';
+/**
+ * dataBar
+ */
+export declare function dataBar(sheet: Sheet, cellInfo: CellInfo, ranges: RangeRef[], cfRule: CT_CfRule): boolean;

package/esm/excel/sheet/cfRule/dataBar.js

@@ -0,0 +1,232 @@
+import { __values } from 'tslib';
+import { getMinMax } from './getMinMax.js';
+import { Color } from '../../../util/color.js';
+import { lt, gt } from '../../../util/number.js';
+
+/**
+ * 查找对应的扩展
+ */
+function findExt(extLst, sheetExtLst) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e;
+    var _f;
+    if (!sheetExtLst) {
+        return null;
+    }
+    try {
+        for (var _g = __values(extLst || []), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var exts = _h.value;
+            try {
+                for (var _j = (e_2 = void 0, __values(exts.ext || [])), _k = _j.next(); !_k.done; _k = _j.next()) {
+                    var ext = _k.value;
+                    var x14Id = ext['x14:id'];
+                    if (x14Id) {
+                        try {
+                            for (var _l = (e_3 = void 0, __values(sheetExtLst.ext || [])), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                var sheetExt = _m.value;
+                                var x14CFs = (_f = sheetExt['x14:conditionalFormattings']) === null || _f === void 0 ? void 0 : _f['x14:conditionalFormatting'];
+                                try {
+                                    for (var _o = (e_4 = void 0, __values(x14CFs || [])), _p = _o.next(); !_p.done; _p = _o.next()) {
+                                        var x14CFItem = _p.value;
+                                        var x14CfRules = x14CFItem['x14:cfRule'];
+                                        try {
+                                            for (var _q = (e_5 = void 0, __values(x14CfRules || [])), _r = _q.next(); !_r.done; _r = _q.next()) {
+                                                var x14CfRule = _r.value;
+                                                if (x14CfRule.id === x14Id) {
+                                                    return x14CfRule['x14:dataBar'];
+                                                }
+                                            }
+                                        }
+                                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                                        finally {
+                                            try {
+                                                if (_r && !_r.done && (_e = _q.return)) _e.call(_q);
+                                            }
+                                            finally { if (e_5) throw e_5.error; }
+                                        }
+                                    }
+                                }
+                                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                                finally {
+                                    try {
+                                        if (_p && !_p.done && (_d = _o.return)) _d.call(_o);
+                                    }
+                                    finally { if (e_4) throw e_4.error; }
+                                }
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (_m && !_m.done && (_c = _l.return)) _c.call(_l);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_k && !_k.done && (_b = _j.return)) _b.call(_j);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_h && !_h.done && (_a = _g.return)) _a.call(_g);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return null;
+}
+function getGradientColor(c) {
+    var color = new Color(c);
+    // 根据 Excel 里的展现判断的
+    color.changeHsl(0.93, 'l', 'set');
+    return color.toHex();
+}
+/**
+ * 构建展现配置
+ */
+function buildDataBarDisplay(min, max, worksheet, cfRule) {
+    var dataBarDisplay = {
+        showValue: true,
+        gradient: true,
+        border: false,
+        percent: 0,
+        color: '',
+        colorGradient: '',
+        borderColor: '',
+        negativeFillColor: '',
+        negativeFillColorGradient: '',
+        negativeBorderColor: '',
+        axisColor: '',
+        direction: 'leftToRight',
+        biDirectional: false
+    };
+    var dataBar = cfRule.dataBar;
+    var dataProvider = worksheet.workbook.getDataProvider();
+    if (dataBar.color) {
+        dataBarDisplay.color = dataProvider.getColor(dataBar.color);
+        if (dataBarDisplay.color !== 'none') {
+            dataBarDisplay.colorGradient = getGradientColor(dataBarDisplay.color);
+        }
+    }
+    if (dataBar.showValue === false) {
+        dataBarDisplay.showValue = false;
+    }
+    // Excel 2010 之后的版本才有的扩展
+    if (cfRule.extLst) {
+        var x14DataBar = findExt(cfRule.extLst, worksheet.getExtLst());
+        if (!x14DataBar) {
+            console.warn('cx14DataBar not found', cfRule.extLst);
+            return dataBarDisplay;
+        }
+        if (x14DataBar.gradient === false) {
+            dataBarDisplay.gradient = false;
+        }
+        if (lt(min, 0) && gt(max, 0)) {
+            dataBarDisplay.biDirectional = true;
+        }
+        if (x14DataBar.direction) {
+            dataBarDisplay.direction = x14DataBar.direction;
+        }
+        if (x14DataBar.border === true) {
+            dataBarDisplay.border = true;
+        }
+        if (x14DataBar['x14:borderColor']) {
+            dataBarDisplay.borderColor = dataProvider.getColor(x14DataBar['x14:borderColor']);
+        }
+        if (x14DataBar['x14:negativeFillColor']) {
+            dataBarDisplay.negativeFillColor = dataProvider.getColor(x14DataBar['x14:negativeFillColor']);
+            if (dataBarDisplay.negativeFillColor !== 'none') {
+                dataBarDisplay.negativeFillColorGradient = getGradientColor(dataBarDisplay.negativeFillColor);
+            }
+        }
+        if (x14DataBar.negativeBarColorSameAsPositive === true) {
+            dataBarDisplay.negativeFillColor = dataBarDisplay.color;
+            dataBarDisplay.negativeFillColorGradient = dataBarDisplay.colorGradient;
+        }
+        if (x14DataBar.negativeBarBorderColorSameAsPositive === false) {
+            if (x14DataBar['x14:negativeBorderColor']) {
+                dataBarDisplay.negativeBorderColor = dataProvider.getColor(x14DataBar['x14:negativeBorderColor']);
+            }
+        }
+        else {
+            dataBarDisplay.negativeBorderColor = dataBarDisplay.borderColor;
+        }
+        if (x14DataBar['x14:axisColor']) {
+            dataBarDisplay.axisColor = dataProvider.getColor(x14DataBar['x14:axisColor']);
+        }
+    }
+    return dataBarDisplay;
+}
+/**
+ * dataBar
+ */
+function dataBar(sheet, cellInfo, ranges, cfRule) {
+    var _a, _b, _c;
+    if (!cfRule.dataBar) {
+        return false;
+    }
+    if (((_a = cfRule.dataBar.cfvo) === null || _a === void 0 ? void 0 : _a.length) !== 2) {
+        console.warn('dataBar cfvo length !== 2', cfRule.dataBar.cfvo);
+        return false;
+    }
+    var rangeCache = sheet.getRangeCache();
+    var ruleKey = JSON.stringify(cfRule);
+    var dataBarCache = rangeCache.get(ranges, ruleKey);
+    if (!dataBarCache) {
+        var rangeValues = sheet.getCellValueByRanges(ranges);
+        var _d = getMinMax(rangeValues), min = _d.min, max = _d.max;
+        var cfvo1 = (_b = cfRule.dataBar.cfvo) === null || _b === void 0 ? void 0 : _b[0];
+        var cfvo2 = (_c = cfRule.dataBar.cfvo) === null || _c === void 0 ? void 0 : _c[1];
+        if (cfvo1.type === 'num') {
+            min = parseFloat(cfvo1.val || '0');
+        }
+        if (cfvo2.type === 'num') {
+            max = parseFloat(cfvo2.val || '1');
+        }
+        // todo，还得支持 percent percentile formula
+        if (min === undefined || max === undefined) {
+            return false;
+        }
+        // 避免除数为 0
+        if (min === max) {
+            return false;
+        }
+        var dataBarDisplay_1 = buildDataBarDisplay(min, max, sheet, cfRule);
+        dataBarCache = {
+            min: min,
+            max: max,
+            dataBarDisplay: dataBarDisplay_1
+        };
+        rangeCache.set(ranges, ruleKey, dataBarCache);
+    }
+    var value = parseFloat(cellInfo.value);
+    var dataBarDisplay = dataBarCache.dataBarDisplay;
+    if (dataBarDisplay.biDirectional) {
+        if (lt(value, 0)) {
+            var percent = value / dataBarCache.min;
+            dataBarDisplay.percent = -percent;
+        }
+        else if (gt(value, 0)) {
+            var percent = value / dataBarCache.max;
+            dataBarDisplay.percent = percent;
+        }
+        else {
+            dataBarDisplay.percent = 0;
+        }
+    }
+    else {
+        var percent = (value - dataBarCache.min) / (dataBarCache.max - dataBarCache.min);
+        dataBarDisplay.percent = percent;
+    }
+    cellInfo.dataBarDisplay = dataBarDisplay;
+    return true;
+}
+
+export { dataBar };

package/esm/excel/sheet/cfRule/duplicateValues.d.ts

@@ -0,0 +1,8 @@
+import { CT_CfRule } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { RangeRef } from '../../types/RangeRef';
+import { Sheet } from '../Sheet';
+/**
+ * 对重复值应用样式
+ */
+export declare function duplicateValues(sheet: Sheet, cellInfo: CellInfo, ranges: RangeRef[], cfRule: CT_CfRule): boolean;

package/esm/excel/sheet/cfRule/duplicateValues.js

@@ -0,0 +1,45 @@
+import { __values } from 'tslib';
+import { applyCfRuleDxf } from './applyCfRuleDxf.js';
+
+/**
+ * 对重复值应用样式
+ */
+function duplicateValues(sheet, cellInfo, ranges, cfRule) {
+    var e_1, _a;
+    var rangeCache = sheet.getRangeCache();
+    var rangeDuplicateValues = rangeCache.get(ranges, 'duplicateValues');
+    if (!rangeDuplicateValues) {
+        rangeDuplicateValues = new Set();
+        var allValues = new Set();
+        var rangeValues = sheet.getCellValueByRanges(ranges);
+        try {
+            for (var rangeValues_1 = __values(rangeValues), rangeValues_1_1 = rangeValues_1.next(); !rangeValues_1_1.done; rangeValues_1_1 = rangeValues_1.next()) {
+                var value = rangeValues_1_1.value;
+                if (value.text === '') {
+                    continue;
+                }
+                if (allValues.has(value.text)) {
+                    rangeDuplicateValues.add(value.text);
+                }
+                else {
+                    allValues.add(value.text);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (rangeValues_1_1 && !rangeValues_1_1.done && (_a = rangeValues_1.return)) _a.call(rangeValues_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        rangeCache.set(ranges, 'duplicateValues', rangeDuplicateValues);
+    }
+    if (rangeDuplicateValues.has(cellInfo.value)) {
+        applyCfRuleDxf(cfRule, sheet, cellInfo);
+        return true;
+    }
+    return false;
+}
+
+export { duplicateValues };

package/esm/excel/sheet/cfRule/getMinMax.d.ts

@@ -0,0 +1,5 @@
+import { CellValue } from '../../types/CellValue';
+export declare function getMinMax(rangeValues: CellValue[]): {
+    min: number | undefined;
+    max: number | undefined;
+};

package/esm/excel/sheet/cfRule/getMinMax.js

@@ -0,0 +1,37 @@
+import { __values } from 'tslib';
+import { lt, gt } from '../../../util/number.js';
+
+function getMinMax(rangeValues) {
+    var e_1, _a;
+    var min;
+    var max;
+    try {
+        for (var rangeValues_1 = __values(rangeValues), rangeValues_1_1 = rangeValues_1.next(); !rangeValues_1_1.done; rangeValues_1_1 = rangeValues_1.next()) {
+            var value = rangeValues_1_1.value;
+            var val = value.value;
+            if (val === '' || val === undefined) {
+                continue;
+            }
+            var num = parseFloat(val);
+            if (min === undefined || lt(num, min)) {
+                min = num;
+            }
+            if (max === undefined || gt(num, max)) {
+                max = num;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (rangeValues_1_1 && !rangeValues_1_1.done && (_a = rangeValues_1.return)) _a.call(rangeValues_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return {
+        min: min,
+        max: max
+    };
+}
+
+export { getMinMax };

package/esm/excel/sheet/cfRule/iconSet.d.ts

@@ -0,0 +1,8 @@
+import { CT_CfRule } from '../../../openxml/ExcelTypes';
+import { CellInfo } from '../../types/CellInfo';
+import { RangeRef } from '../../types/RangeRef';
+import { Sheet } from '../Sheet';
+/**
+ * 应用图标样式
+ */
+export declare function iconSet(sheet: Sheet, cellInfo: CellInfo, ranges: RangeRef[], cfRule: CT_CfRule): boolean;

package/esm/excel/sheet/cfRule/iconSet.js

@@ -0,0 +1,109 @@
+import { __values, __read } from 'tslib';
+import { presetIconSet } from '../../io/excel/preset/presetIconSet.js';
+import { getMinMax } from './getMinMax.js';
+import { getPercent } from '../../../util/number.js';
+
+/**
+ * 应用图标样式
+ */
+function iconSet(sheet, cellInfo, ranges, cfRule) {
+    var e_1, _a, e_2, _b;
+    var rangeCache = sheet.getRangeCache();
+    JSON.stringify(cfRule);
+    var rangeIconSet = rangeCache.get(ranges, 'ruleKey');
+    if (!rangeIconSet) {
+        var iconSet_1 = cfRule.iconSet;
+        if (!iconSet_1) {
+            return false;
+        }
+        var iconSetName = iconSet_1.iconSet || '3TrafficLights1';
+        var cfvo = iconSet_1.cfvo;
+        if (!cfvo) {
+            console.warn('图标集规则不完整');
+            return false;
+        }
+        var rangeValues = sheet.getCellValueByRanges(ranges);
+        var icons = [];
+        var presetIcon = presetIconSet[iconSetName];
+        if (!presetIcon) {
+            console.warn('未知的图标集', iconSetName);
+            return false;
+        }
+        if (iconSet_1.reverse === true) {
+            presetIcon = presetIcon.slice().reverse();
+        }
+        try {
+            for (var _c = __values(cfvo.entries()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var _e = __read(_d.value, 2), i = _e[0], cfvoItem = _e[1];
+                var type = cfvoItem.type;
+                switch (type) {
+                    // 目前还不知道这两个啥区别
+                    case 'percentile':
+                    case 'percent': {
+                        var val = parseInt(cfvoItem.val || '50', 10);
+                        var percent_1 = val / 100;
+                        var icon = presetIcon[i];
+                        if (typeof icon === 'undefined') {
+                            console.warn('未知的图标', iconSetName);
+                            return false;
+                        }
+                        icons.push({
+                            percent: percent_1,
+                            icon: icon
+                        });
+                        break;
+                    }
+                    default:
+                        console.warn('未知的 cfvo type', type);
+                        break;
+                }
+                var _f = getMinMax(rangeValues), min = _f.min, max = _f.max;
+                if (min === undefined || max === undefined) {
+                    return false;
+                }
+                if (icons.length === 0) {
+                    console.warn('图标集为空');
+                    return false;
+                }
+                rangeIconSet = {
+                    min: min,
+                    max: max,
+                    icons: icons
+                };
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    var value = parseFloat(cellInfo.value);
+    // 当前值所在的百分比
+    var percent = getPercent(value, rangeIconSet.min, rangeIconSet.max);
+    // 查找所属 icon
+    var startIcon = rangeIconSet.icons[0].icon;
+    try {
+        for (var _g = __values(rangeIconSet.icons), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var icon = _h.value;
+            if (percent <= icon.percent) {
+                break;
+            }
+            startIcon = icon.icon;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    // 应用图标
+    cellInfo.icon = startIcon;
+    return true;
+}
+
+export { iconSet };