@univerjs/sheets-data-validation 0.5.5-experimental.20250122-3362a4a → 0.5.5-nightly.202501201606

package/lib/es/facade.js

@@ -1,20 +1,19 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
-import { UpdateSheetDataValidationSettingCommand, UpdateSheetDataValidationOptionsCommand, UpdateSheetDataValidationRangeCommand, RemoveSheetDataValidationCommand, ClearRangeDataValidationCommand, AddSheetDataValidationCommand, SheetsDataValidationValidatorService, SheetDataValidationModel, RemoveSheetAllDataValidationCommand } from "@univerjs/sheets-data-validation";
-import { FRange, FWorkbook, FWorksheet } from "@univerjs/sheets/facade";
-import { generateRandomId, DataValidationType, DataValidationErrorStyle, DataValidationOperator, IUniverInstanceService, ICommandService, FUniver, CanceledError, toDisposable, FEventName } from "@univerjs/core";
-import { DataValidationModel, getRuleOptions } from "@univerjs/data-validation";
-import { serializeRangeToRefString } from "@univerjs/engine-formula";
-import { filter } from "rxjs";
-const _FDataValidationBuilder = class _FDataValidationBuilder {
-  constructor(rule) {
-    __publicField(this, "_rule");
-    this._rule = rule != null ? rule : {
-      uid: generateRandomId(),
+var j = Object.defineProperty;
+var q = (c, e, t) => e in c ? j(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var f = (c, e, t) => q(c, typeof e != "symbol" ? e + "" : e, t);
+import { UpdateSheetDataValidationSettingCommand as U, UpdateSheetDataValidationOptionsCommand as v, UpdateSheetDataValidationRangeCommand as C, RemoveSheetDataValidationCommand as T, ClearRangeDataValidationCommand as W, AddSheetDataValidationCommand as A, SheetsDataValidationValidatorService as S, SheetDataValidationModel as V, RemoveSheetAllDataValidationCommand as O } from "@univerjs/sheets-data-validation";
+import { FRange as y, FWorkbook as M, FWorksheet as N } from "@univerjs/sheets/facade";
+import { generateRandomId as B, DataValidationType as o, DataValidationErrorStyle as w, DataValidationOperator as h, IUniverInstanceService as H, ICommandService as p, FUniver as x, CanceledError as _, toDisposable as g, FEventName as $ } from "@univerjs/core";
+import { DataValidationModel as b, getRuleOptions as F } from "@univerjs/data-validation";
+import { serializeRangeToRefString as P } from "@univerjs/engine-formula";
+import { filter as R } from "rxjs";
+class D {
+  constructor(e) {
+    f(this, "_rule");
+    this._rule = e != null ? e : {
+      uid: B(),
       ranges: void 0,
-      type: DataValidationType.CUSTOM
+      type: o.CUSTOM
     };
   }
   /**
@@ -27,7 +26,7 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * ```
    */
   build() {
-    return new FDataValidation(this._rule);
+    return new m(this._rule);
   }
   /**
    * Creates a duplicate of the current DataValidationBuilder object
@@ -39,9 +38,9 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * ```
    */
   copy() {
-    return new _FDataValidationBuilder({
+    return new D({
       ...this._rule,
-      uid: generateRandomId()
+      uid: B()
     });
   }
   /**
@@ -54,7 +53,7 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * ```
    */
   getAllowInvalid() {
-    return this._rule.errorStyle !== DataValidationErrorStyle.STOP;
+    return this._rule.errorStyle !== w.STOP;
   }
   /**
    * Gets the data validation type of the rule
@@ -103,8 +102,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireCheckbox('Yes', 'No').build();
    * ```
    */
-  requireCheckbox(checkedValue, uncheckedValue) {
-    return this._rule.type = DataValidationType.CHECKBOX, this._rule.formula1 = checkedValue, this._rule.formula2 = uncheckedValue, this;
+  requireCheckbox(e, t) {
+    return this._rule.type = o.CHECKBOX, this._rule.formula1 = e, this._rule.formula2 = t, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be after a specific date
@@ -116,8 +115,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireDateAfter(new Date('2024-01-01')).build();
    * ```
    */
-  requireDateAfter(date) {
-    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = date.toLocaleDateString(), this._rule.operator = DataValidationOperator.GREATER_THAN, this;
+  requireDateAfter(e) {
+    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.operator = h.GREATER_THAN, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be before a specific date
@@ -129,8 +128,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireDateBefore(new Date('2024-12-31')).build();
    * ```
    */
-  requireDateBefore(date) {
-    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = date.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.LESS_THAN, this;
+  requireDateBefore(e) {
+    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = h.LESS_THAN, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be within a specific date range
@@ -145,8 +144,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    *   .build();
    * ```
    */
-  requireDateBetween(start, end) {
-    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = start.toLocaleDateString(), this._rule.formula2 = end.toLocaleDateString(), this._rule.operator = DataValidationOperator.BETWEEN, this;
+  requireDateBetween(e, t) {
+    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = t.toLocaleDateString(), this._rule.operator = h.BETWEEN, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be equal to a specific date
@@ -158,8 +157,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireDateEqualTo(new Date('2024-01-01')).build();
    * ```
    */
-  requireDateEqualTo(date) {
-    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = date.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.EQUAL, this;
+  requireDateEqualTo(e) {
+    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = h.EQUAL, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be not within a specific date range
@@ -174,8 +173,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    *   .build();
    * ```
    */
-  requireDateNotBetween(start, end) {
-    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = start.toLocaleDateString(), this._rule.formula2 = end.toLocaleDateString(), this._rule.operator = DataValidationOperator.NOT_BETWEEN, this;
+  requireDateNotBetween(e, t) {
+    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = t.toLocaleDateString(), this._rule.operator = h.NOT_BETWEEN, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be on or after a specific date
@@ -187,8 +186,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireDateOnOrAfter(new Date('2024-01-01')).build();
    * ```
    */
-  requireDateOnOrAfter(date) {
-    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = date.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.GREATER_THAN_OR_EQUAL, this;
+  requireDateOnOrAfter(e) {
+    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = h.GREATER_THAN_OR_EQUAL, this;
   }
   /**
    * Set the data validation type to DATE and configure the validation rules to be on or before a specific date
@@ -200,8 +199,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireDateOnOrBefore(new Date('2024-12-31')).build();
    * ```
    */
-  requireDateOnOrBefore(date) {
-    return this._rule.type = DataValidationType.DATE, this._rule.formula1 = date.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.LESS_THAN_OR_EQUAL, this;
+  requireDateOnOrBefore(e) {
+    return this._rule.type = o.DATE, this._rule.formula1 = e.toLocaleDateString(), this._rule.formula2 = void 0, this._rule.operator = h.LESS_THAN_OR_EQUAL, this;
   }
   /**
    * Requires that a custom formula be satisfied
@@ -213,8 +212,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireFormulaSatisfied('=A1>0').build();
    * ```
    */
-  requireFormulaSatisfied(formula) {
-    return this._rule.type = DataValidationType.CUSTOM, this._rule.formula1 = formula, this._rule.formula2 = void 0, this;
+  requireFormulaSatisfied(e) {
+    return this._rule.type = o.CUSTOM, this._rule.formula1 = e, this._rule.formula2 = void 0, this;
   }
   /**
    * Requires the user to enter a number within a specific range, which can be integer or decimal
@@ -228,8 +227,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireNumberBetween(1, 10).build();
    * ```
    */
-  requireNumberBetween(start, end, isInteger) {
-    return this._rule.formula1 = `${start}`, this._rule.formula2 = `${end}`, this._rule.operator = DataValidationOperator.BETWEEN, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
+  requireNumberBetween(e, t, r) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = `${t}`, this._rule.operator = h.BETWEEN, this._rule.type = r ? o.WHOLE : o.DECIMAL, this;
   }
   /**
    * Requires the user to enter a number that is equal to a specific value, which can be an integer or a decimal
@@ -242,8 +241,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireNumberEqualTo(10).build();
    * ```
    */
-  requireNumberEqualTo(num, isInteger) {
-    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.EQUAL, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
+  requireNumberEqualTo(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = h.EQUAL, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
   }
   /**
    * Requires the user to enter a number that is greater than a specific value, which can be an integer or a decimal
@@ -256,8 +255,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireNumberGreaterThan(10).build();
    * ```
    */
-  requireNumberGreaterThan(num, isInteger) {
-    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.GREATER_THAN, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
+  requireNumberGreaterThan(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = h.GREATER_THAN, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
   }
   /**
    * Requires the user to enter a number that is greater than or equal to a specific value, which can be an integer or a decimal
@@ -270,8 +269,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireNumberGreaterThanOrEqualTo(10).build();
    * ```
    */
-  requireNumberGreaterThanOrEqualTo(num, isInteger) {
-    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.GREATER_THAN_OR_EQUAL, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
+  requireNumberGreaterThanOrEqualTo(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = h.GREATER_THAN_OR_EQUAL, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
   }
   /**
    * Requires the user to enter a number that is less than a specific value, which can be an integer or a decimal
@@ -284,8 +283,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireNumberLessThan(10).build();
    * ```
    */
-  requireNumberLessThan(num, isInteger) {
-    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.LESS_THAN, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
+  requireNumberLessThan(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = h.LESS_THAN, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
   }
   /**
    * Sets the data validation rule to require a number less than or equal to a specified value
@@ -299,8 +298,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireNumberLessThanOrEqualTo(10).build();
    * ```
    */
-  requireNumberLessThanOrEqualTo(num, isInteger) {
-    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.LESS_THAN_OR_EQUAL, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
+  requireNumberLessThanOrEqualTo(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = h.LESS_THAN_OR_EQUAL, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
   }
   /**
    * Sets a data validation rule that requires the user to enter a number outside a specified range
@@ -315,8 +314,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireNumberNotBetween(1, 10).build();
    * ```
    */
-  requireNumberNotBetween(start, end, isInteger) {
-    return this._rule.formula1 = `${start}`, this._rule.formula2 = `${end}`, this._rule.operator = DataValidationOperator.NOT_BETWEEN, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
+  requireNumberNotBetween(e, t, r) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = `${t}`, this._rule.operator = h.NOT_BETWEEN, this._rule.type = r ? o.WHOLE : o.DECIMAL, this;
   }
   /**
    * Creates a data validation rule that requires the user to enter a number that is not equal to a specific value
@@ -330,8 +329,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireNumberNotEqualTo(10).build();
    * ```
    */
-  requireNumberNotEqualTo(num, isInteger) {
-    return this._rule.formula1 = `${num}`, this._rule.formula2 = void 0, this._rule.operator = DataValidationOperator.NOT_EQUAL, this._rule.type = isInteger ? DataValidationType.WHOLE : DataValidationType.DECIMAL, this;
+  requireNumberNotEqualTo(e, t) {
+    return this._rule.formula1 = `${e}`, this._rule.formula2 = void 0, this._rule.operator = h.NOT_EQUAL, this._rule.type = t ? o.WHOLE : o.DECIMAL, this;
   }
   /**
    * Sets a data validation rule that requires the user to enter a value from a list of specific values
@@ -346,8 +345,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireValueInList(['Yes', 'No']).build();
    * ```
    */
-  requireValueInList(values, multiple, showDropdown) {
-    return this._rule.type = multiple ? DataValidationType.LIST_MULTIPLE : DataValidationType.LIST, this._rule.formula1 = values.join(","), this._rule.formula2 = void 0, this._rule.showDropDown = showDropdown != null ? showDropdown : !0, this;
+  requireValueInList(e, t, r) {
+    return this._rule.type = t ? o.LIST_MULTIPLE : o.LIST, this._rule.formula1 = e.join(","), this._rule.formula2 = void 0, this._rule.showDropDown = r != null ? r : !0, this;
   }
   /**
    * Sets a data validation rule that requires the user to enter a value within a specific range
@@ -363,12 +362,12 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.requireValueInRange(range).build();
    * ```
    */
-  requireValueInRange(range, multiple, showDropdown) {
-    return this._rule.type = multiple ? DataValidationType.LIST_MULTIPLE : DataValidationType.LIST, this._rule.formula1 = `=${serializeRangeToRefString({
-      unitId: range.getUnitId(),
-      sheetName: range.getSheetName(),
-      range: range.getRange()
-    })}`, this._rule.formula2 = void 0, this._rule.showDropDown = showDropdown != null ? showDropdown : !0, this;
+  requireValueInRange(e, t, r) {
+    return this._rule.type = t ? o.LIST_MULTIPLE : o.LIST, this._rule.formula1 = `=${P({
+      unitId: e.getUnitId(),
+      sheetName: e.getSheetName(),
+      range: e.getRange()
+    })}`, this._rule.formula2 = void 0, this._rule.showDropDown = r != null ? r : !0, this;
   }
   /**
    * Sets whether to allow invalid data and configures the error style
@@ -382,8 +381,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.setAllowInvalid(true).build();
    * ```
    */
-  setAllowInvalid(allowInvalidData) {
-    return this._rule.errorStyle = allowInvalidData ? DataValidationErrorStyle.WARNING : DataValidationErrorStyle.STOP, this;
+  setAllowInvalid(e) {
+    return this._rule.errorStyle = e ? w.WARNING : w.STOP, this;
   }
   /**
    * Sets whether to allow blank values
@@ -395,8 +394,8 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * const rule = builder.setAllowBlank(true).build();
    * ```
    */
-  setAllowBlank(allowBlank) {
-    return this._rule.allowBlank = allowBlank, this;
+  setAllowBlank(e) {
+    return this._rule.allowBlank = e, this;
   }
   /**
    * Sets the options for the data validation rule
@@ -412,18 +411,16 @@ const _FDataValidationBuilder = class _FDataValidationBuilder {
    * }).build();
    * ```
    */
-  setOptions(options) {
-    return Object.assign(this._rule, options), this;
+  setOptions(e) {
+    return Object.assign(this._rule, e), this;
   }
-};
-__name(_FDataValidationBuilder, "FDataValidationBuilder");
-let FDataValidationBuilder = _FDataValidationBuilder;
-const _FDataValidation = class _FDataValidation {
-  constructor(rule, worksheet, _injector) {
-    __publicField(this, "rule");
-    __publicField(this, "_worksheet");
-    __publicField(this, "_injector");
-    this._injector = _injector, this.rule = rule, this._worksheet = worksheet;
+}
+class m {
+  constructor(e, t, r) {
+    f(this, "rule");
+    f(this, "_worksheet");
+    f(this, "_injector");
+    this._injector = r, this.rule = e, this._worksheet = t;
   }
   /**
    * Gets whether invalid data is allowed based on the error style value
@@ -439,7 +436,7 @@ const _FDataValidation = class _FDataValidation {
    * ```
    */
   getAllowInvalid() {
-    return this.rule.errorStyle !== DataValidationErrorStyle.STOP;
+    return this.rule.errorStyle !== w.STOP;
   }
   /**
    * Gets the data validation type of the rule
@@ -504,7 +501,7 @@ const _FDataValidation = class _FDataValidation {
    * ```
    */
   copy() {
-    return new FDataValidationBuilder(this.rule);
+    return new D(this.rule);
   }
   /**
    * Gets whether the data validation rule is applied to the worksheet
@@ -522,8 +519,8 @@ const _FDataValidation = class _FDataValidation {
   getApplied() {
     if (!this._worksheet)
       return !1;
-    const currentRule = this._injector.get(DataValidationModel).getRuleById(this._worksheet.getUnitId(), this._worksheet.getSheetId(), this.rule.uid);
-    return !!(currentRule && currentRule.ranges.length);
+    const t = this._injector.get(b).getRuleById(this._worksheet.getUnitId(), this._worksheet.getSheetId(), this.rule.uid);
+    return !!(t && t.ranges.length);
   }
   /**
    * Gets the ranges to which the data validation rule is applied
@@ -541,8 +538,8 @@ const _FDataValidation = class _FDataValidation {
   getRanges() {
     if (!this.getApplied())
       return [];
-    const workbook = this._injector.get(IUniverInstanceService).getUnit(this._worksheet.getUnitId());
-    return this.rule.ranges.map((range) => this._injector.createInstance(FRange, workbook, this._worksheet, range));
+    const e = this._injector.get(H).getUnit(this._worksheet.getUnitId());
+    return this.rule.ranges.map((t) => this._injector.createInstance(y, e, this._worksheet, t));
   }
   /**
    * Gets the unit ID of the worksheet
@@ -558,8 +555,8 @@ const _FDataValidation = class _FDataValidation {
    * ```
    */
   getUnitId() {
-    var _a;
-    return (_a = this._worksheet) == null ? void 0 : _a.getUnitId();
+    var e;
+    return (e = this._worksheet) == null ? void 0 : e.getUnitId();
   }
   /**
    * Gets the sheet ID of the worksheet
@@ -575,8 +572,8 @@ const _FDataValidation = class _FDataValidation {
    * ```
    */
   getSheetId() {
-    var _a;
-    return (_a = this._worksheet) == null ? void 0 : _a.getSheetId();
+    var e;
+    return (e = this._worksheet) == null ? void 0 : e.getSheetId();
   }
   /**
    * Set Criteria for the data validation rule
@@ -598,21 +595,21 @@ const _FDataValidation = class _FDataValidation {
    * );
    * ```
    */
-  setCriteria(type, values, allowBlank = !0) {
-    if (this.getApplied() && !this._injector.get(ICommandService).syncExecuteCommand(UpdateSheetDataValidationSettingCommand.id, {
+  setCriteria(e, t, r = !0) {
+    if (this.getApplied() && !this._injector.get(p).syncExecuteCommand(U.id, {
       unitId: this.getUnitId(),
       subUnitId: this.getSheetId(),
       ruleId: this.rule.uid,
       setting: {
-        operator: values[0],
-        formula1: values[1],
-        formula2: values[2],
+        operator: t[0],
+        formula1: t[1],
+        formula2: t[2],
         type: this.rule.type,
-        allowBlank
+        allowBlank: r
       }
     }))
       throw new Error("setCriteria failed");
-    return this.rule.operator = values[0], this.rule.formula1 = values[1], this.rule.formula2 = values[2], this.rule.type = type, this.rule.allowBlank = allowBlank, this;
+    return this.rule.operator = t[0], this.rule.formula1 = t[1], this.rule.formula2 = t[2], this.rule.type = e, this.rule.allowBlank = r, this;
   }
   /**
    * Set the options for the data validation rule
@@ -632,18 +629,18 @@ const _FDataValidation = class _FDataValidation {
    * });
    * ```
    */
-  setOptions(options) {
-    if (this.getApplied() && !this._injector.get(ICommandService).syncExecuteCommand(UpdateSheetDataValidationOptionsCommand.id, {
+  setOptions(e) {
+    if (this.getApplied() && !this._injector.get(p).syncExecuteCommand(v.id, {
       unitId: this.getUnitId(),
       subUnitId: this.getSheetId(),
       ruleId: this.rule.uid,
       options: {
-        ...getRuleOptions(this.rule),
-        ...options
+        ...F(this.rule),
+        ...e
       }
     }))
       throw new Error("setOptions failed");
-    return Object.assign(this.rule, options), this;
+    return Object.assign(this.rule, e), this;
   }
   /**
    * Set the ranges to the data validation rule
@@ -660,15 +657,15 @@ const _FDataValidation = class _FDataValidation {
    * dataValidation.setRanges([range]);
    * ```
    */
-  setRanges(ranges) {
-    if (this.getApplied() && !this._injector.get(ICommandService).syncExecuteCommand(UpdateSheetDataValidationRangeCommand.id, {
+  setRanges(e) {
+    if (this.getApplied() && !this._injector.get(p).syncExecuteCommand(C.id, {
       unitId: this.getUnitId(),
       subUnitId: this.getSheetId(),
       ruleId: this.rule.uid,
-      ranges: ranges.map((range) => range.getRange())
+      ranges: e.map((a) => a.getRange())
     }))
       throw new Error("setRanges failed");
-    return this.rule.ranges = ranges.map((range) => range.getRange()), this;
+    return this.rule.ranges = e.map((t) => t.getRange()), this;
   }
   /**
    * Delete the data validation rule from the worksheet
@@ -684,67 +681,63 @@ const _FDataValidation = class _FDataValidation {
    * ```
    */
   delete() {
-    return this.getApplied() ? this._injector.get(ICommandService).syncExecuteCommand(RemoveSheetDataValidationCommand.id, {
+    return this.getApplied() ? this._injector.get(p).syncExecuteCommand(T.id, {
       unitId: this.getUnitId(),
       subUnitId: this.getSheetId(),
       ruleId: this.rule.uid
     }) : !1;
   }
-};
-__name(_FDataValidation, "FDataValidation");
-let FDataValidation = _FDataValidation;
-const _FRangeDataValidationMixin = class _FRangeDataValidationMixin extends FRange {
-  setDataValidation(rule) {
-    if (!rule)
-      return this._commandService.syncExecuteCommand(ClearRangeDataValidationCommand.id, {
+}
+class G extends y {
+  setDataValidation(e) {
+    if (!e)
+      return this._commandService.syncExecuteCommand(W.id, {
         unitId: this._workbook.getUnitId(),
         subUnitId: this._worksheet.getSheetId(),
         ranges: [this._range]
       }), this;
-    const params = {
+    const t = {
       unitId: this._workbook.getUnitId(),
       subUnitId: this._worksheet.getSheetId(),
       rule: {
-        ...rule.rule,
+        ...e.rule,
         ranges: [this._range]
       }
     };
-    return this._commandService.syncExecuteCommand(AddSheetDataValidationCommand.id, params), this;
+    return this._commandService.syncExecuteCommand(A.id, t), this;
   }
   getDataValidation() {
-    const rule = this._injector.get(SheetsDataValidationValidatorService).getDataValidation(
+    const t = this._injector.get(S).getDataValidation(
       this._workbook.getUnitId(),
       this._worksheet.getSheetId(),
       [this._range]
     );
-    return rule && new FDataValidation(rule, this._worksheet, this._injector);
+    return t && new m(t, this._worksheet, this._injector);
   }
   getDataValidations() {
-    return this._injector.get(SheetsDataValidationValidatorService).getDataValidations(
+    return this._injector.get(S).getDataValidations(
       this._workbook.getUnitId(),
       this._worksheet.getSheetId(),
       [this._range]
-    ).map((rule) => new FDataValidation(rule, this._worksheet, this._injector));
+    ).map((t) => new m(t, this._worksheet, this._injector));
   }
   async getValidatorStatus() {
-    return this._injector.get(SheetsDataValidationValidatorService).validatorRanges(
+    return this._injector.get(S).validatorRanges(
       this._workbook.getUnitId(),
       this._worksheet.getSheetId(),
       [this._range]
     );
   }
-};
-__name(_FRangeDataValidationMixin, "FRangeDataValidationMixin");
-let FRangeDataValidationMixin = _FRangeDataValidationMixin;
-FRange.extend(FRangeDataValidationMixin);
-const _FUnvierDataValidationMixin = class _FUnvierDataValidationMixin extends FUniver {
+}
+y.extend(G);
+class Q extends x {
   // eslint-disable-next-line jsdoc/require-returns
   /**
   /**
    * @deprecated use `univerAPI.newDataValidation()` as instead.
    */
   static newDataValidation() {
-    return new FDataValidationBuilder();
+    return new D();
   }
   /**
    * Creates a new instance of FDataValidationBuilder
@@ -756,241 +749,234 @@ const _FUnvierDataValidationMixin = class _FUnvierDataValidationMixin extends FU
    * ```
    */
   newDataValidation() {
-    return new FDataValidationBuilder();
+    return new D();
   }
-  /**
-   * @ignore
-   */
   // eslint-disable-next-line max-lines-per-function
-  _initialize(injector) {
-    if (!injector.has(SheetDataValidationModel)) return;
-    const sheetDataValidationModel = injector.get(SheetDataValidationModel), commadnService = injector.get(ICommandService);
-    this.disposeWithMe(sheetDataValidationModel.ruleChange$.subscribe((ruleChange) => {
-      const { unitId, subUnitId, rule, oldRule, type } = ruleChange, target = this.getSheetTarget(unitId, subUnitId);
-      if (!target)
+  _initialize(e) {
+    if (!e.has(V)) return;
+    const t = e.get(V), r = e.get(p);
+    this.disposeWithMe(t.ruleChange$.subscribe((a) => {
+      const { unitId: i, subUnitId: n, rule: d, oldRule: u, type: s } = a, l = this.getSheetTarget(i, n);
+      if (!l)
         return;
-      const { workbook, worksheet } = target, fRule = new FDataValidation(rule, worksheet.getSheet(), this._injector);
+      const { workbook: I, worksheet: k } = l, E = new m(d, k.getSheet(), this._injector);
       this.fireEvent(this.Event.SheetDataValidationChanged, {
-        origin: ruleChange,
-        worksheet,
-        workbook,
-        changeType: type,
-        oldRule,
-        rule: fRule
+        origin: a,
+        worksheet: k,
+        workbook: I,
+        changeType: s,
+        oldRule: u,
+        rule: E
       });
-    })), this.disposeWithMe(sheetDataValidationModel.validStatusChange$.subscribe((statusChange) => {
-      const { unitId, subUnitId, ruleId, status, row, col } = statusChange, target = this.getSheetTarget(unitId, subUnitId);
-      if (!target)
+    })), this.disposeWithMe(t.validStatusChange$.subscribe((a) => {
+      const { unitId: i, subUnitId: n, ruleId: d, status: u, row: s, col: l } = a, I = this.getSheetTarget(i, n);
+      if (!I)
         return;
-      const { workbook, worksheet } = target, rule = worksheet.getDataValidation(ruleId);
-      rule && this.fireEvent(this.Event.SheetDataValidatorStatusChanged, {
-        workbook,
-        worksheet,
-        row,
-        column: col,
-        rule,
-        status
+      const { workbook: k, worksheet: E } = I, L = E.getDataValidation(d);
+      L && this.fireEvent(this.Event.SheetDataValidatorStatusChanged, {
+        workbook: k,
+        worksheet: E,
+        row: s,
+        column: l,
+        rule: L,
+        status: u
       });
-    })), this.disposeWithMe(commadnService.beforeCommandExecuted((commandInfo) => {
-      switch (commandInfo.id) {
-        case AddSheetDataValidationCommand.id: {
-          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
-          if (!target)
+    })), this.disposeWithMe(r.beforeCommandExecuted((a) => {
+      switch (a.id) {
+        case A.id: {
+          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
+          if (!n)
             return;
-          const { workbook, worksheet } = target, eventParams = {
-            worksheet,
-            workbook,
-            rule: params.rule
+          const { workbook: d, worksheet: u } = n, s = {
+            worksheet: u,
+            workbook: d,
+            rule: i.rule
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationAdd, eventParams), eventParams.cancel)
-            throw new CanceledError();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationAdd, s), s.cancel)
+            throw new _();
           break;
         }
-        case UpdateSheetDataValidationSettingCommand.id: {
-          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
-          if (!target)
+        case U.id: {
+          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
+          if (!n)
             return;
-          const { workbook, worksheet } = target, rule = worksheet.getDataValidation(params.ruleId);
-          if (!rule)
+          const { workbook: d, worksheet: u } = n, s = u.getDataValidation(i.ruleId);
+          if (!s)
             return;
-          const eventParams = {
-            worksheet,
-            workbook,
-            rule,
-            ruleId: params.ruleId,
-            newCriteria: params.setting
+          const l = {
+            worksheet: u,
+            workbook: d,
+            rule: s,
+            ruleId: i.ruleId,
+            newCriteria: i.setting
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationCriteriaUpdate, eventParams), eventParams.cancel)
-            throw new CanceledError();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationCriteriaUpdate, l), l.cancel)
+            throw new _();
           break;
         }
-        case UpdateSheetDataValidationRangeCommand.id: {
-          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
-          if (!target)
+        case C.id: {
+          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
+          if (!n)
             return;
-          const { workbook, worksheet } = target, rule = worksheet.getDataValidation(params.ruleId);
-          if (!rule)
+          const { workbook: d, worksheet: u } = n, s = u.getDataValidation(i.ruleId);
+          if (!s)
             return;
-          const eventParams = {
-            worksheet,
-            workbook,
-            rule,
-            ruleId: params.ruleId,
-            newRanges: params.ranges
+          const l = {
+            worksheet: u,
+            workbook: d,
+            rule: s,
+            ruleId: i.ruleId,
+            newRanges: i.ranges
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationRangeUpdate, eventParams), eventParams.cancel)
-            throw new CanceledError();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationRangeUpdate, l), l.cancel)
+            throw new _();
           break;
         }
-        case UpdateSheetDataValidationOptionsCommand.id: {
-          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
-          if (!target)
+        case v.id: {
+          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
+          if (!n)
             return;
-          const { workbook, worksheet } = target, rule = worksheet.getDataValidation(params.ruleId);
-          if (!rule)
+          const { workbook: d, worksheet: u } = n, s = u.getDataValidation(i.ruleId);
+          if (!s)
             return;
-          const eventParams = {
-            worksheet,
-            workbook,
-            rule,
-            ruleId: params.ruleId,
-            newOptions: params.options
+          const l = {
+            worksheet: u,
+            workbook: d,
+            rule: s,
+            ruleId: i.ruleId,
+            newOptions: i.options
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationOptionsUpdate, eventParams), eventParams.cancel)
-            throw new CanceledError();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationOptionsUpdate, l), l.cancel)
+            throw new _();
           break;
         }
-        case RemoveSheetDataValidationCommand.id: {
-          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
-          if (!target)
+        case T.id: {
+          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
+          if (!n)
             return;
-          const { workbook, worksheet } = target, rule = worksheet.getDataValidation(params.ruleId);
-          if (!rule)
+          const { workbook: d, worksheet: u } = n, s = u.getDataValidation(i.ruleId);
+          if (!s)
             return;
-          const eventParams = {
-            worksheet,
-            workbook,
-            rule,
-            ruleId: params.ruleId
+          const l = {
+            worksheet: u,
+            workbook: d,
+            rule: s,
+            ruleId: i.ruleId
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationDelete, eventParams), eventParams.cancel)
-            throw new CanceledError();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationDelete, l), l.cancel)
+            throw new _();
           break;
         }
-        case RemoveSheetAllDataValidationCommand.id: {
-          const params = commandInfo.params, target = this.getSheetTarget(params.unitId, params.subUnitId);
-          if (!target)
+        case O.id: {
+          const i = a.params, n = this.getSheetTarget(i.unitId, i.subUnitId);
+          if (!n)
             return;
-          const { workbook, worksheet } = target, eventParams = {
-            worksheet,
-            workbook,
-            rules: worksheet.getDataValidations()
+          const { workbook: d, worksheet: u } = n, s = {
+            worksheet: u,
+            workbook: d,
+            rules: u.getDataValidations()
           };
-          if (this.fireEvent(this.Event.BeforeSheetDataValidationDeleteAll, eventParams), eventParams.cancel)
-            throw new CanceledError();
+          if (this.fireEvent(this.Event.BeforeSheetDataValidationDeleteAll, s), s.cancel)
+            throw new _();
           break;
         }
       }
     }));
   }
-};
-__name(_FUnvierDataValidationMixin, "FUnvierDataValidationMixin");
-let FUnvierDataValidationMixin = _FUnvierDataValidationMixin;
-FUniver.extend(FUnvierDataValidationMixin);
-const _FWorkbookDataValidationMixin = class _FWorkbookDataValidationMixin extends FWorkbook {
+}
+x.extend(Q);
+class z extends M {
   _initialize() {
     Object.defineProperty(this, "_dataValidationModel", {
       get() {
-        return this._injector.get(SheetDataValidationModel);
+        return this._injector.get(V);
       }
     });
   }
   getValidatorStatus() {
-    return this._injector.get(SheetsDataValidationValidatorService).validatorWorkbook(this._workbook.getUnitId());
+    return this._injector.get(S).validatorWorkbook(this._workbook.getUnitId());
   }
   // region DataValidationHooks
-  onDataValidationChange(callback) {
-    return toDisposable(this._dataValidationModel.ruleChange$.pipe(filter((change) => change.unitId === this._workbook.getUnitId())).subscribe(callback));
+  onDataValidationChange(e) {
+    return g(this._dataValidationModel.ruleChange$.pipe(R((t) => t.unitId === this._workbook.getUnitId())).subscribe(e));
   }
-  onDataValidationStatusChange(callback) {
-    return toDisposable(this._dataValidationModel.validStatusChange$.pipe(filter((change) => change.unitId === this._workbook.getUnitId())).subscribe(callback));
+  onDataValidationStatusChange(e) {
+    return g(this._dataValidationModel.validStatusChange$.pipe(R((t) => t.unitId === this._workbook.getUnitId())).subscribe(e));
   }
-  onBeforeAddDataValidation(callback) {
-    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
-      const params = commandInfo.params;
-      if (commandInfo.id === AddSheetDataValidationCommand.id) {
-        if (params.unitId !== this._workbook.getUnitId())
+  onBeforeAddDataValidation(e) {
+    return g(this._commandService.beforeCommandExecuted((t, r) => {
+      const a = t.params;
+      if (t.id === A.id) {
+        if (a.unitId !== this._workbook.getUnitId())
           return;
-        if (callback(params, options) === !1)
+        if (e(a, r) === !1)
           throw new Error("Command is stopped by the hook onBeforeAddDataValidation");
       }
     }));
   }
-  onBeforeUpdateDataValidationCriteria(callback) {
-    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
-      const params = commandInfo.params;
-      if (commandInfo.id === UpdateSheetDataValidationSettingCommand.id) {
-        if (params.unitId !== this._workbook.getUnitId())
+  onBeforeUpdateDataValidationCriteria(e) {
+    return g(this._commandService.beforeCommandExecuted((t, r) => {
+      const a = t.params;
+      if (t.id === U.id) {
+        if (a.unitId !== this._workbook.getUnitId())
           return;
-        if (callback(params, options) === !1)
+        if (e(a, r) === !1)
           throw new Error("Command is stopped by the hook onBeforeUpdateDataValidationCriteria");
       }
     }));
   }
-  onBeforeUpdateDataValidationRange(callback) {
-    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
-      const params = commandInfo.params;
-      if (commandInfo.id === UpdateSheetDataValidationRangeCommand.id) {
-        if (params.unitId !== this._workbook.getUnitId())
+  onBeforeUpdateDataValidationRange(e) {
+    return g(this._commandService.beforeCommandExecuted((t, r) => {
+      const a = t.params;
+      if (t.id === C.id) {
+        if (a.unitId !== this._workbook.getUnitId())
           return;
-        if (callback(params, options) === !1)
+        if (e(a, r) === !1)
           throw new Error("Command is stopped by the hook onBeforeUpdateDataValidationRange");
       }
     }));
   }
-  onBeforeUpdateDataValidationOptions(callback) {
-    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
-      const params = commandInfo.params;
-      if (commandInfo.id === UpdateSheetDataValidationOptionsCommand.id) {
-        if (params.unitId !== this._workbook.getUnitId())
+  onBeforeUpdateDataValidationOptions(e) {
+    return g(this._commandService.beforeCommandExecuted((t, r) => {
+      const a = t.params;
+      if (t.id === v.id) {
+        if (a.unitId !== this._workbook.getUnitId())
           return;
-        if (callback(params, options) === !1)
+        if (e(a, r) === !1)
           throw new Error("Command is stopped by the hook onBeforeUpdateDataValidationOptions");
       }
     }));
   }
-  onBeforeDeleteDataValidation(callback) {
-    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
-      const params = commandInfo.params;
-      if (commandInfo.id === RemoveSheetDataValidationCommand.id) {
-        if (params.unitId !== this._workbook.getUnitId())
+  onBeforeDeleteDataValidation(e) {
+    return g(this._commandService.beforeCommandExecuted((t, r) => {
+      const a = t.params;
+      if (t.id === T.id) {
+        if (a.unitId !== this._workbook.getUnitId())
           return;
-        if (callback(params, options) === !1)
+        if (e(a, r) === !1)
           throw new Error("Command is stopped by the hook onBeforeDeleteDataValidation");
       }
     }));
   }
-  onBeforeDeleteAllDataValidation(callback) {
-    return toDisposable(this._commandService.beforeCommandExecuted((commandInfo, options) => {
-      const params = commandInfo.params;
-      if (commandInfo.id === RemoveSheetAllDataValidationCommand.id) {
-        if (params.unitId !== this._workbook.getUnitId())
+  onBeforeDeleteAllDataValidation(e) {
+    return g(this._commandService.beforeCommandExecuted((t, r) => {
+      const a = t.params;
+      if (t.id === O.id) {
+        if (a.unitId !== this._workbook.getUnitId())
           return;
-        if (callback(params, options) === !1)
+        if (e(a, r) === !1)
           throw new Error("Command is stopped by the hook onBeforeDeleteAllDataValidation");
       }
     }));
   }
-};
-__name(_FWorkbookDataValidationMixin, "FWorkbookDataValidationMixin");
-let FWorkbookDataValidationMixin = _FWorkbookDataValidationMixin;
-FWorkbook.extend(FWorkbookDataValidationMixin);
-const _FWorksheetDataValidationMixin = class _FWorksheetDataValidationMixin extends FWorksheet {
+}
+M.extend(z);
+class K extends N {
   getDataValidations() {
-    return this._injector.get(DataValidationModel).getRules(this._workbook.getUnitId(), this._worksheet.getSheetId()).map((rule) => new FDataValidation(rule, this._worksheet, this._injector));
+    return this._injector.get(b).getRules(this._workbook.getUnitId(), this._worksheet.getSheetId()).map((t) => new m(t, this._worksheet, this._injector));
   }
   getValidatorStatus() {
-    return this._injector.get(SheetsDataValidationValidatorService).validatorWorksheet(
+    return this._injector.get(S).validatorWorksheet(
       this._workbook.getUnitId(),
       this._worksheet.getSheetId()
     );
@@ -998,15 +984,13 @@ const _FWorksheetDataValidationMixin = class _FWorksheetDataValidationMixin exte
   getValidatorStatusAsync() {
     return this.getValidatorStatus();
   }
-  getDataValidation(ruleId) {
-    const rule = this._injector.get(DataValidationModel).getRuleById(this._workbook.getUnitId(), this._worksheet.getSheetId(), ruleId);
-    return rule ? new FDataValidation(rule, this._worksheet, this._injector) : null;
+  getDataValidation(e) {
+    const r = this._injector.get(b).getRuleById(this._workbook.getUnitId(), this._worksheet.getSheetId(), e);
+    return r ? new m(r, this._worksheet, this._injector) : null;
   }
-};
-__name(_FWorksheetDataValidationMixin, "FWorksheetDataValidationMixin");
-let FWorksheetDataValidationMixin = _FWorksheetDataValidationMixin;
-FWorksheet.extend(FWorksheetDataValidationMixin);
-const _FDataValidationEvent = class _FDataValidationEvent {
+}
+N.extend(K);
+class X {
   get SheetDataValidationChanged() {
     return "SheetDataValidationChanged";
   }
@@ -1031,11 +1015,9 @@ const _FDataValidationEvent = class _FDataValidationEvent {
   get BeforeSheetDataValidationOptionsUpdate() {
     return "BeforeSheetDataValidationOptionsUpdate";
   }
-};
-__name(_FDataValidationEvent, "FDataValidationEvent");
-let FDataValidationEvent = _FDataValidationEvent;
-FEventName.extend(FDataValidationEvent);
+}
+$.extend(X);
 export {
-  FDataValidation,
-  FDataValidationBuilder
+  m as FDataValidation,
+  D as FDataValidationBuilder
 };