@univerjs/sheets-conditional-formatting 0.21.1 → 0.22.0

package/lib/es/index.js

@@ -78,37 +78,37 @@ const createDefaultRule = () => ({
 	ranges: [],
 	stopIfTrue: false,
 	rule: {
-		type: CFRuleType.highlightCell,
-		subType: CFSubRuleType.text,
-		operator: CFTextOperator.containsText
+		type: "highlightCell",
+		subType: "text",
+		operator: "containsText"
 	}
 });
 const createDefaultValue = (subType, operator) => {
 	switch (subType) {
-		case CFSubRuleType.text:
+		case "text":
 			if ([
-				CFTextOperator.beginsWith,
-				CFTextOperator.containsText,
-				CFTextOperator.endsWith,
-				CFTextOperator.equal,
-				CFTextOperator.notContainsText,
-				CFTextOperator.notEqual
+				"beginsWith",
+				"containsText",
+				"endsWith",
+				"equal",
+				"notContainsText",
+				"notEqual"
 			].includes(operator)) return "";
 			break;
-		case CFSubRuleType.number:
-			if ([CFNumberOperator.between, CFNumberOperator.notBetween].includes(operator)) return [10, 100];
+		case "number":
+			if (["between", "notBetween"].includes(operator)) return [10, 100];
 			return 10;
 	}
 	return "";
 };
 const createDefaultValueByValueType = (type, defaultValue) => {
 	switch (type) {
-		case CFValueType.formula: return "=";
-		case CFValueType.max:
-		case CFValueType.min: return "";
-		case CFValueType.percent:
-		case CFValueType.percentile:
-		case CFValueType.num: return defaultValue !== void 0 ? defaultValue : 10;
+		case "formula": return "=";
+		case "max":
+		case "min": return "";
+		case "percent":
+		case "percentile":
+		case "num": return defaultValue !== void 0 ? defaultValue : 10;
 	}
 	return "";
 };
@@ -220,7 +220,7 @@ const isAnchorEqual = (anchor1, anchor2) => {
 const createCfId = () => `${generateRandomId(8)}`;
 
 //#endregion
-//#region \0@oxc-project+runtime@0.124.0/helpers/typeof.js
+//#region \0@oxc-project+runtime@0.129.0/helpers/typeof.js
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -231,7 +231,7 @@ function _typeof(o) {
 }
 
 //#endregion
-//#region \0@oxc-project+runtime@0.124.0/helpers/toPrimitive.js
+//#region \0@oxc-project+runtime@0.129.0/helpers/toPrimitive.js
 function toPrimitive(t, r) {
 	if ("object" != _typeof(t) || !t) return t;
 	var e = t[Symbol.toPrimitive];
@@ -244,14 +244,14 @@ function toPrimitive(t, r) {
 }
 
 //#endregion
-//#region \0@oxc-project+runtime@0.124.0/helpers/toPropertyKey.js
+//#region \0@oxc-project+runtime@0.129.0/helpers/toPropertyKey.js
 function toPropertyKey(t) {
 	var i = toPrimitive(t, "string");
 	return "symbol" == _typeof(i) ? i : i + "";
 }
 
 //#endregion
-//#region \0@oxc-project+runtime@0.124.0/helpers/defineProperty.js
+//#region \0@oxc-project+runtime@0.129.0/helpers/defineProperty.js
 function _defineProperty(e, r, t) {
 	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 		value: t,
@@ -750,7 +750,7 @@ const SetCfCommand = {
 };
 
 //#endregion
-//#region \0@oxc-project+runtime@0.124.0/helpers/decorateParam.js
+//#region \0@oxc-project+runtime@0.129.0/helpers/decorateParam.js
 function __decorateParam(paramIndex, decorator) {
 	return function(target, key) {
 		decorator(target, key, paramIndex);
@@ -758,7 +758,7 @@ function __decorateParam(paramIndex, decorator) {
 }
 
 //#endregion
-//#region \0@oxc-project+runtime@0.124.0/helpers/decorate.js
+//#region \0@oxc-project+runtime@0.129.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -782,9 +782,9 @@ let ConditionalFormattingFormulaService = class ConditionalFormattingFormulaServ
 	_initRuleChange() {
 		const isNeedMarkFormulaDirty = (rule) => {
 			switch (rule.type) {
-				case CFRuleType.colorScale: return rule.config.some((item) => item.value.type === CFValueType.formula);
-				case CFRuleType.dataBar: return [rule.config.max, rule.config.min].some((item) => item.type === CFValueType.formula);
-				case CFRuleType.iconSet: return rule.config.some((item) => item.value.type === CFValueType.formula);
+				case "colorScale": return rule.config.some((item) => item.value.type === "formula");
+				case "dataBar": return [rule.config.max, rule.config.min].some((item) => item.type === "formula");
+				case "iconSet": return rule.config.some((item) => item.value.type === "formula");
 			}
 		};
 		this.disposeWithMe(this._conditionalFormattingRuleModel.$ruleChange.subscribe((option) => {
@@ -801,8 +801,8 @@ let ConditionalFormattingFormulaService = class ConditionalFormattingFormulaServ
 	*/
 	_registerRuleFormulas(unitId, subUnitId, rule) {
 		switch (rule.rule.type) {
-			case CFRuleType.highlightCell:
-				if (rule.rule.subType === CFSubRuleType.formula) {
+			case "highlightCell":
+				if (rule.rule.subType === "formula") {
 					const formulaText = rule.rule.value;
 					if (formulaText) this.registerFormulaWithRange(unitId, subUnitId, rule.cfId, formulaText, rule.ranges);
 				}
@@ -945,13 +945,6 @@ ConditionalFormattingFormulaService = __decorate([__decorateParam(0, Inject(Regi
 
 //#endregion
 //#region src/models/calculate-unit-v2/base-calculate-unit.ts
-let CalculateEmitStatus = /* @__PURE__ */ function(CalculateEmitStatus) {
-	CalculateEmitStatus["preComputingStart"] = "preComputingStart";
-	CalculateEmitStatus["preComputing"] = "preComputing";
-	CalculateEmitStatus["preComputingEnd"] = "preComputingEnd";
-	CalculateEmitStatus["preComputingError"] = "preComputingError";
-	return CalculateEmitStatus;
-}({});
 /**
 * Processing Main Path Calculation Logic
 */
@@ -959,7 +952,7 @@ var BaseCalculateUnit = class {
 	constructor(_context) {
 		this._context = _context;
 		_defineProperty(this, "_cache", void 0);
-		_defineProperty(this, "_preComputingStatus$", new BehaviorSubject(CalculateEmitStatus.preComputingStart));
+		_defineProperty(this, "_preComputingStatus$", new BehaviorSubject("preComputingStart"));
 		_defineProperty(this, "preComputingStatus$", this._preComputingStatus$.asObservable().pipe(distinctUntilChanged()));
 		_defineProperty(this, "_preComputingCache", void 0);
 		_defineProperty(this, "_rule", void 0);
@@ -975,7 +968,7 @@ var BaseCalculateUnit = class {
 		this._cache.clear();
 	}
 	resetPreComputingCache() {
-		this._preComputingStatus$.next(CalculateEmitStatus.preComputingStart);
+		this._preComputingStatus$.next("preComputingStart");
 		this._preComputingCache = null;
 	}
 	updateRule(rule) {
@@ -984,15 +977,15 @@ var BaseCalculateUnit = class {
 	}
 	getCell(row, col) {
 		const key = this._createKey(row, col);
-		if (this._preComputingStatus$.getValue() === CalculateEmitStatus.preComputing) return this._cache.get(key);
+		if (this._preComputingStatus$.getValue() === "preComputing") return this._cache.get(key);
 		let preComputingResult = this.getPreComputingResult(row, col);
 		if (preComputingResult === null) {
-			this._preComputingStatus$.next(CalculateEmitStatus.preComputingStart);
+			this._preComputingStatus$.next("preComputingStart");
 			this.preComputing(row, col, this._getContext());
 			preComputingResult = this.getPreComputingResult(row, col);
 			if (preComputingResult === null) return this._cache.get(key);
 		}
-		this._preComputingStatus$.next(CalculateEmitStatus.preComputingEnd);
+		this._preComputingStatus$.next("preComputingEnd");
 		if (this._cache.has(key)) return this._cache.get(key);
 		const result = this.getCellResult(row, col, preComputingResult, this._getContext());
 		if (result !== null) this._setCache(row, col, result);
@@ -1019,7 +1012,7 @@ var BaseCalculateUnit = class {
 	}
 	_initClearCacheListener() {
 		this.preComputingStatus$.subscribe((e) => {
-			if (e === CalculateEmitStatus.preComputingEnd) this.clearCache();
+			if (e === "preComputingEnd") this.clearCache();
 		});
 	}
 };
@@ -1031,7 +1024,7 @@ var ColorScaleCalculateUnit = class extends BaseCalculateUnit {
 		const rule = context.rule;
 		const worksheet = context.worksheet;
 		const matrix = new ObjectMatrix();
-		if (!rule.rule.config.every((item) => item.value.type === CFValueType.num)) filterRange(rule.ranges, worksheet.getMaxRows() - 1, worksheet.getMaxColumns() - 1).forEach((range) => {
+		if (!rule.rule.config.every((item) => item.value.type === "num")) filterRange(rule.ranges, worksheet.getMaxRows() - 1, worksheet.getMaxColumns() - 1).forEach((range) => {
 			Range.foreach(range, (row, col) => {
 				const cell = context.getCellValue(row, col);
 				const v = cell && cell.v;
@@ -1062,10 +1055,10 @@ var ColorScaleCalculateUnit = class extends BaseCalculateUnit {
 				sortValue: _configList.map((item) => item.value.result).sort((a, b) => a - b)
 			}).result;
 			this.setPreComputingCache(colorList);
-			this._preComputingStatus$.next(CalculateEmitStatus.preComputingEnd);
+			this._preComputingStatus$.next("preComputingEnd");
 			return;
 		}
-		this._preComputingStatus$.next(CalculateEmitStatus.preComputing);
+		this._preComputingStatus$.next("preComputing");
 	}
 	getCellResult(row, col, preComputingResult, context) {
 		if (!preComputingResult) return null;
@@ -1193,7 +1186,7 @@ var DataBarCalculateUnit = class extends BaseCalculateUnit {
 		const ruleConfig = rule.rule;
 		const worksheet = context.worksheet;
 		const matrix = new ObjectMatrix();
-		if (![rule.rule.config.max, rule.rule.config.min].every((e) => e.type === CFValueType.num)) filterRange(rule.ranges, worksheet.getMaxRows() - 1, worksheet.getMaxColumns() - 1).forEach((range) => {
+		if (![rule.rule.config.max, rule.rule.config.min].every((e) => e.type === "num")) filterRange(rule.ranges, worksheet.getMaxRows() - 1, worksheet.getMaxColumns() - 1).forEach((range) => {
 			Range.foreach(range, (row, col) => {
 				const cell = context.getCellValue(row, col);
 				const v = cell && cell.v;
@@ -1217,7 +1210,7 @@ var DataBarCalculateUnit = class extends BaseCalculateUnit {
 			const v = Number(_min.result);
 			min = Number.isNaN(v) ? 0 : v;
 		} else {
-			this._preComputingStatus$.next(CalculateEmitStatus.preComputing);
+			this._preComputingStatus$.next("preComputing");
 			return;
 		}
 		if (_max.status === FormulaResultStatus.SUCCESS) {
@@ -1236,10 +1229,10 @@ var DataBarCalculateUnit = class extends BaseCalculateUnit {
 				max,
 				startPoint
 			});
-			this._preComputingStatus$.next(CalculateEmitStatus.preComputingEnd);
+			this._preComputingStatus$.next("preComputingEnd");
 			return;
 		}
-		this._preComputingStatus$.next(CalculateEmitStatus.preComputing);
+		this._preComputingStatus$.next("preComputing");
 	}
 	getCellResult(row, col, preComputingResult, context) {
 		const { min, max, startPoint } = preComputingResult;
@@ -1316,7 +1309,7 @@ var HighlightCellCalculateUnit = class extends BaseCalculateUnit {
 		const ranges = filterRange(context.rule.ranges, context.worksheet.getMaxRows() - 1, context.worksheet.getMaxColumns() - 1);
 		const getCache = () => {
 			switch (ruleConfig.subType) {
-				case CFSubRuleType.average: {
+				case "average": {
 					let sum = 0;
 					let count = 0;
 					ranges.forEach((range) => {
@@ -1334,8 +1327,8 @@ var HighlightCellCalculateUnit = class extends BaseCalculateUnit {
 						type: ruleConfig.subType
 					};
 				}
-				case CFSubRuleType.uniqueValues:
-				case CFSubRuleType.duplicateValues: {
+				case "uniqueValues":
+				case "duplicateValues": {
 					const cacheMap = /* @__PURE__ */ new Map();
 					ranges.forEach((range) => {
 						Range.foreach(range, (row, col) => {
@@ -1352,7 +1345,7 @@ var HighlightCellCalculateUnit = class extends BaseCalculateUnit {
 						type: ruleConfig.subType
 					};
 				}
-				case CFSubRuleType.rank: {
+				case "rank": {
 					let allValue = [];
 					ranges.forEach((range) => {
 						Range.foreach(range, (row, col) => {
@@ -1383,86 +1376,86 @@ var HighlightCellCalculateUnit = class extends BaseCalculateUnit {
 						type: ruleConfig.subType
 					};
 				}
-				case CFSubRuleType.formula: {
+				case "formula": {
 					const _ruleConfig = ruleConfig;
 					const conditionalFormattingFormulaService = context.accessor.get(ConditionalFormattingFormulaService);
 					const normalizedRanges = sortRangesByTopLeft(context.rule.ranges);
 					conditionalFormattingFormulaService.registerFormulaWithRange(context.unitId, context.subUnitId, context.rule.cfId, _ruleConfig.value, normalizedRanges);
 					const result = conditionalFormattingFormulaService.getFormulaMatrix(context.unitId, context.subUnitId, context.rule.cfId, _ruleConfig.value);
 					if (result && result.status === FormulaResultStatus.SUCCESS) {
-						this._preComputingStatus$.next(CalculateEmitStatus.preComputingEnd);
+						this._preComputingStatus$.next("preComputingEnd");
 						return {
 							value: result.result,
 							type: ruleConfig.subType
 						};
-					} else this._preComputingStatus$.next(CalculateEmitStatus.preComputing);
+					} else this._preComputingStatus$.next("preComputing");
 					return null;
 				}
-				case CFSubRuleType.timePeriod: switch (ruleConfig.operator) {
-					case CFTimePeriodOperator.last7Days: return {
+				case "timePeriod": switch (ruleConfig.operator) {
+					case "last7Days": return {
 						value: {
 							start: dateKit().subtract(7, "day").valueOf(),
 							end: dateKit().valueOf()
 						},
 						type: ruleConfig.subType
 					};
-					case CFTimePeriodOperator.lastMonth: return {
+					case "lastMonth": return {
 						value: {
 							start: dateKit().startOf("month").subtract(1, "month").valueOf(),
 							end: dateKit().endOf("month").subtract(1, "month").valueOf()
 						},
 						type: ruleConfig.subType
 					};
-					case CFTimePeriodOperator.lastWeek: return {
+					case "lastWeek": return {
 						value: {
 							start: dateKit().startOf("week").subtract(1, "week").valueOf(),
 							end: dateKit().endOf("week").subtract(1, "week").valueOf()
 						},
 						type: ruleConfig.subType
 					};
-					case CFTimePeriodOperator.nextMonth: return {
+					case "nextMonth": return {
 						value: {
 							start: dateKit().startOf("month").add(1, "month").valueOf(),
 							end: dateKit().endOf("month").add(1, "month").valueOf()
 						},
 						type: ruleConfig.subType
 					};
-					case CFTimePeriodOperator.nextWeek: return {
+					case "nextWeek": return {
 						value: {
 							start: dateKit().startOf("week").add(1, "week").valueOf(),
 							end: dateKit().endOf("week").add(1, "week").valueOf()
 						},
 						type: ruleConfig.subType
 					};
-					case CFTimePeriodOperator.thisMonth: return {
+					case "thisMonth": return {
 						value: {
 							start: dateKit().startOf("month").valueOf(),
 							end: dateKit().endOf("month").valueOf()
 						},
 						type: ruleConfig.subType
 					};
-					case CFTimePeriodOperator.thisWeek: return {
+					case "thisWeek": return {
 						value: {
 							start: dateKit().startOf("week").valueOf(),
 							end: dateKit().endOf("week").valueOf()
 						},
 						type: ruleConfig.subType
 					};
-					case CFTimePeriodOperator.today: return {
+					case "today": return {
 						value: {
 							start: dateKit().startOf("day").valueOf(),
 							end: dateKit().endOf("day").valueOf()
 						},
 						type: ruleConfig.subType
 					};
-					case CFTimePeriodOperator.tomorrow: return {
+					case "tomorrow": return {
 						value: {
 							start: dateKit().startOf("day").add(1, "day").valueOf(),
 							end: dateKit().endOf("day").add(1, "day").valueOf()
 						},
 						type: ruleConfig.subType
 					};
-					case CFTimePeriodOperator.yesterday: return {
+					case "yesterday": return {
 						value: {
 							start: dateKit().startOf("day").subtract(1, "day").valueOf(),
 							end: dateKit().endOf("day").subtract(1, "day").valueOf()
@@ -1480,12 +1473,12 @@ var HighlightCellCalculateUnit = class extends BaseCalculateUnit {
 		const ruleConfig = context.rule.rule;
 		const run = () => {
 			switch (ruleConfig.subType) {
-				case CFSubRuleType.number: {
+				case "number": {
 					const v = cellValue && Number(cellValue.v);
 					const isNumber = (cellValue === null || cellValue === void 0 ? void 0 : cellValue.t) === CellValueType.NUMBER;
 					const subRuleConfig = ruleConfig;
 					if (!isNumber) {
-						if ([CFNumberOperator.notEqual, CFNumberOperator.notBetween].includes(subRuleConfig.operator)) return true;
+						if (["notEqual", "notBetween"].includes(subRuleConfig.operator)) return true;
 						return false;
 					}
 					if (isNullable(v) || Number.isNaN(v)) return;
@@ -1494,54 +1487,54 @@ var HighlightCellCalculateUnit = class extends BaseCalculateUnit {
 						value: subRuleConfig.value || 0
 					}, v || 0);
 				}
-				case CFSubRuleType.text: {
+				case "text": {
 					const subRuleConfig = ruleConfig;
 					const value = getCellValue(cellValue);
 					const v = isNullable(value) ? "" : String(value);
 					const condition = subRuleConfig.value || "";
 					switch (subRuleConfig.operator) {
-						case CFTextOperator.beginsWith: return v.startsWith(condition);
-						case CFTextOperator.containsBlanks: return /^\s*$/.test(v);
-						case CFTextOperator.notContainsBlanks: return !/^\s*$/.test(v);
-						case CFTextOperator.containsErrors: return ERROR_TYPE_SET.has(v);
-						case CFTextOperator.notContainsErrors: return !ERROR_TYPE_SET.has(v);
-						case CFTextOperator.containsText: return v.indexOf(condition) > -1;
-						case CFTextOperator.notContainsText: return v.indexOf(condition) === -1;
-						case CFTextOperator.endsWith: return v.endsWith(condition);
-						case CFTextOperator.equal: return v === condition;
-						case CFTextOperator.notEqual: return v !== condition;
+						case "beginsWith": return v.startsWith(condition);
+						case "containsBlanks": return /^\s*$/.test(v);
+						case "notContainsBlanks": return !/^\s*$/.test(v);
+						case "containsErrors": return ERROR_TYPE_SET.has(v);
+						case "notContainsErrors": return !ERROR_TYPE_SET.has(v);
+						case "containsText": return v.indexOf(condition) > -1;
+						case "notContainsText": return v.indexOf(condition) === -1;
+						case "endsWith": return v.endsWith(condition);
+						case "equal": return v === condition;
+						case "notEqual": return v !== condition;
 						default: return false;
 					}
 				}
-				case CFSubRuleType.timePeriod: {
+				case "timePeriod": {
 					const value = getCellValue(cellValue);
 					if (isNullable(value) || Number.isNaN(Number(value)) || (cellValue === null || cellValue === void 0 ? void 0 : cellValue.t) !== CellValueType.NUMBER || !preComputingResult) return;
 					const v = serialTimeToTimestamp(Number(value));
 					const { start, end } = preComputingResult.value;
 					return v >= start && v <= end;
 				}
-				case CFSubRuleType.average: {
+				case "average": {
 					const value = cellValue && cellValue.v;
 					const v = Number(value);
 					const isNumber = (cellValue === null || cellValue === void 0 ? void 0 : cellValue.t) === CellValueType.NUMBER;
 					const subRuleConfig = ruleConfig;
 					if (!isNumber) {
-						if (CFNumberOperator.notEqual === subRuleConfig.operator) return true;
+						if ("notEqual" === subRuleConfig.operator) return true;
 						return false;
 					}
 					if (isNullable(value) || Number.isNaN(v) || !preComputingResult) return false;
 					const average = preComputingResult.value;
 					switch (subRuleConfig.operator) {
-						case CFNumberOperator.greaterThan: return v > average;
-						case CFNumberOperator.greaterThanOrEqual: return v >= average;
-						case CFNumberOperator.lessThan: return v < average;
-						case CFNumberOperator.lessThanOrEqual: return v <= average;
-						case CFNumberOperator.equal: return isFloatsEqual(v, average);
-						case CFNumberOperator.notEqual: return !isFloatsEqual(v, average);
+						case "greaterThan": return v > average;
+						case "greaterThanOrEqual": return v >= average;
+						case "lessThan": return v < average;
+						case "lessThanOrEqual": return v <= average;
+						case "equal": return isFloatsEqual(v, average);
+						case "notEqual": return !isFloatsEqual(v, average);
 						default: return false;
 					}
 				}
-				case CFSubRuleType.rank: {
+				case "rank": {
 					const value = getCellValue(cellValue);
 					const v = Number(value);
 					if (isNullable(value) || Number.isNaN(v) || (cellValue === null || cellValue === void 0 ? void 0 : cellValue.t) !== CellValueType.NUMBER || !preComputingResult) return false;
@@ -1549,18 +1542,18 @@ var HighlightCellCalculateUnit = class extends BaseCalculateUnit {
 					if (ruleConfig.isBottom) return v <= targetValue;
 					else return v >= targetValue;
 				}
-				case CFSubRuleType.uniqueValues: {
+				case "uniqueValues": {
 					const value = getCellValue(cellValue);
 					if (isNullable(value) || !preComputingResult) return false;
 					return preComputingResult.value.get(value) === 1;
 				}
-				case CFSubRuleType.duplicateValues: {
+				case "duplicateValues": {
 					const value = getCellValue(cellValue);
 					if (isNullable(value) || !preComputingResult) return false;
 					const uniqueCacheValue = preComputingResult.value.get(value);
 					return uniqueCacheValue && uniqueCacheValue !== 1;
 				}
-				case CFSubRuleType.formula: {
+				case "formula": {
 					const _ruleConfig = ruleConfig;
 					const conditionalFormattingFormulaService = context.accessor.get(ConditionalFormattingFormulaService);
 					const firstRange = sortRangesByTopLeft(context.rule.ranges)[0];
@@ -1593,7 +1586,7 @@ var IconSetCalculateUnit = class extends BaseCalculateUnit {
 		const ruleConfig = context.rule.rule;
 		const worksheet = context.worksheet;
 		const matrix = new ObjectMatrix();
-		if (!ruleConfig.config.every((e) => e.value.type === CFValueType.num)) filterRange(context.rule.ranges, worksheet.getMaxRows() - 1, worksheet.getMaxColumns() - 1).forEach((range) => {
+		if (!ruleConfig.config.every((e) => e.value.type === "num")) filterRange(context.rule.ranges, worksheet.getMaxRows() - 1, worksheet.getMaxColumns() - 1).forEach((range) => {
 			Range.foreach(range, (row, col) => {
 				const cell = context.getCellValue(row, col);
 				const v = cell && cell.v;
@@ -1629,10 +1622,10 @@ var IconSetCalculateUnit = class extends BaseCalculateUnit {
 				return result;
 			}, []);
 			this.setPreComputingCache(splitValue);
-			this._preComputingStatus$.next(CalculateEmitStatus.preComputingEnd);
+			this._preComputingStatus$.next("preComputingEnd");
 			return;
 		}
-		this._preComputingStatus$.next(CalculateEmitStatus.preComputing);
+		this._preComputingStatus$.next("preComputing");
 	}
 	getCellResult(row, col, preComputingResult, context) {
 		if (!preComputingResult) return null;
@@ -1787,7 +1780,7 @@ let ConditionalFormattingViewModel = class ConditionalFormattingViewModel extend
 			if (e.type === "set") {
 				const { unitId, subUnitId } = e;
 				const oldRule = e.oldRule;
-				if (oldRule.rule.type === CFRuleType.highlightCell && oldRule.rule.subType === CFSubRuleType.formula) this._conditionalFormattingFormulaService.deleteCache(unitId, subUnitId, oldRule.cfId);
+				if (oldRule.rule.type === "highlightCell" && oldRule.rule.subType === "formula") this._conditionalFormattingFormulaService.deleteCache(unitId, subUnitId, oldRule.cfId);
 			}
 		}));
 	}
@@ -1875,10 +1868,10 @@ let ConditionalFormattingViewModel = class ConditionalFormattingViewModel extend
 			getCellValue: (row, col) => worksheet.getCellRaw(row, col) || {}
 		};
 		switch (rule.rule.type) {
-			case CFRuleType.colorScale: return new ColorScaleCalculateUnit(context);
-			case CFRuleType.dataBar: return new DataBarCalculateUnit(context);
-			case CFRuleType.highlightCell: return new HighlightCellCalculateUnit(context);
-			case CFRuleType.iconSet: return new IconSetCalculateUnit(context);
+			case "colorScale": return new ColorScaleCalculateUnit(context);
+			case "dataBar": return new DataBarCalculateUnit(context);
+			case "highlightCell": return new HighlightCellCalculateUnit(context);
+			case "iconSet": return new IconSetCalculateUnit(context);
 		}
 	}
 	_createCacheKey(unitId, subUnitId, row, col) {
@@ -1968,7 +1961,7 @@ const serialTimeToTimestamp = (value) => {
 };
 const getValueByType = (value, matrix, context) => {
 	switch (value.type) {
-		case CFValueType.max: {
+		case "max": {
 			let max = 0;
 			matrix.forValue((row, col, value) => {
 				if (value > max) max = value;
@@ -1978,7 +1971,7 @@ const getValueByType = (value, matrix, context) => {
 				result: max
 			};
 		}
-		case CFValueType.min: {
+		case "min": {
 			let min;
 			matrix.forValue((row, col, value) => {
 				if (min === void 0) min = value;
@@ -1989,7 +1982,7 @@ const getValueByType = (value, matrix, context) => {
 				result: min
 			};
 		}
-		case CFValueType.percent: {
+		case "percent": {
 			let max;
 			let min;
 			matrix.forValue((row, col, value) => {
@@ -2007,7 +2000,7 @@ const getValueByType = (value, matrix, context) => {
 				result: length * (v / 100) + (min || 0)
 			};
 		}
-		case CFValueType.percentile: {
+		case "percentile": {
 			const list = matrix.toNativeArray().sort((a, b) => a - b);
 			const v = Math.max(Math.min(Number(value.value) || 0, 100), 0);
 			const index = (list.length - 1) * v / 100;
@@ -2019,14 +2012,14 @@ const getValueByType = (value, matrix, context) => {
 				result
 			};
 		}
-		case CFValueType.formula: {
+		case "formula": {
 			const { accessor, unitId, subUnitId, cfId } = context;
 			const formulaText = String(value.value);
 			const conditionalFormattingFormulaService = accessor.get(ConditionalFormattingFormulaService);
 			conditionalFormattingFormulaService.registerFormulaWithRange(unitId, subUnitId, cfId, formulaText);
 			return conditionalFormattingFormulaService.getFormulaResultWithCoords(unitId, subUnitId, cfId, formulaText);
 		}
-		case CFValueType.num:
+		case "num":
 		default: {
 			const v = Number(value.value);
 			return {
@@ -2053,33 +2046,33 @@ const getCacheStyleMatrix = (unitId, subUnitId, rule, context) => {
 };
 const compareWithNumber = (config, v) => {
 	switch (config.operator) {
-		case CFNumberOperator.between: {
+		case "between": {
 			if (typeof config.value !== "object" || !config.value.length) return;
 			const start = Math.min(...config.value);
 			const end = Math.max(...config.value);
 			return v >= start && v <= end;
 		}
-		case CFNumberOperator.notBetween: {
+		case "notBetween": {
 			if (typeof config.value !== "object" || !config.value.length) return;
 			const start = Math.min(...config.value);
 			const end = Math.max(...config.value);
 			return !(v >= start && v <= end);
 		}
-		case CFNumberOperator.equal: return isFloatsEqual(config.value || 0, v);
-		case CFNumberOperator.notEqual: return !isFloatsEqual(config.value || 0, v);
-		case CFNumberOperator.greaterThan: return v > (config.value || 0);
-		case CFNumberOperator.greaterThanOrEqual: return v >= (config.value || 0);
-		case CFNumberOperator.lessThan: return v < (config.value || 0);
-		case CFNumberOperator.lessThanOrEqual: return v <= (config.value || 0);
+		case "equal": return isFloatsEqual(config.value || 0, v);
+		case "notEqual": return !isFloatsEqual(config.value || 0, v);
+		case "greaterThan": return v > (config.value || 0);
+		case "greaterThanOrEqual": return v >= (config.value || 0);
+		case "lessThan": return v < (config.value || 0);
+		case "lessThanOrEqual": return v <= (config.value || 0);
 		default: return false;
 	}
 };
 const getOppositeOperator = (operator) => {
 	switch (operator) {
-		case CFNumberOperator.greaterThan: return CFNumberOperator.lessThanOrEqual;
-		case CFNumberOperator.greaterThanOrEqual: return CFNumberOperator.lessThan;
-		case CFNumberOperator.lessThan: return CFNumberOperator.greaterThanOrEqual;
-		case CFNumberOperator.lessThanOrEqual: return CFNumberOperator.greaterThan;
+		case "greaterThan": return "lessThanOrEqual";
+		case "greaterThanOrEqual": return "lessThan";
+		case "lessThan": return "greaterThanOrEqual";
+		case "lessThanOrEqual": return "greaterThan";
 	}
 	return operator;
 };
@@ -2452,7 +2445,7 @@ const EMPTY_ICON_TYPE = "EMPTY_ICON_TYPE";
 //#endregion
 //#region package.json
 var name = "@univerjs/sheets-conditional-formatting";
-var version = "0.21.1";
+var version = "0.22.0";
 
 //#endregion
 //#region src/config/config.ts
@@ -2483,18 +2476,18 @@ let ConditionalFormattingService = class ConditionalFormattingService extends Di
 	}
 	_mergeComposeResult(result, rule, ruleResult) {
 		const type = rule.rule.type;
-		if (type === CFRuleType.highlightCell) {
+		if (type === "highlightCell") {
 			ruleResult && merge(result, { style: ruleResult });
 			return;
 		}
-		if (type === CFRuleType.colorScale) {
+		if (type === "colorScale") {
 			if (ruleResult && typeof ruleResult === "string") result.style = {
 				...result.style || {},
 				bg: { rgb: ruleResult }
 			};
 			return;
 		}
-		if (type === CFRuleType.dataBar) {
+		if (type === "dataBar") {
 			const ruleCache = ruleResult;
 			if (ruleCache) {
 				result.dataBar = ruleCache;
@@ -2502,7 +2495,7 @@ let ConditionalFormattingService = class ConditionalFormattingService extends Di
 			}
 			return;
 		}
-		if (type === CFRuleType.iconSet) {
+		if (type === "iconSet") {
 			const ruleCache = ruleResult;
 			if (ruleCache) {
 				result.iconSet = ruleCache;
@@ -2546,7 +2539,7 @@ let ConditionalFormattingService = class ConditionalFormattingService extends Di
 		return result;
 	}
 	_isRuleMatched(rule, ruleResult) {
-		if (rule.rule.type === CFRuleType.highlightCell) return !!ruleResult && typeof ruleResult === "object" && Object.keys(ruleResult).length > 0;
+		if (rule.rule.type === "highlightCell") return !!ruleResult && typeof ruleResult === "object" && Object.keys(ruleResult).length > 0;
 		return !!ruleResult;
 	}
 	_initSnapshot() {