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

package/lib/es/facade.js

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