@univerjs/sheets-data-validation 0.6.0-nightly.202502181606 → 0.6.0-nightly.202502201606

package/lib/es/facade.js

@@ -1,16 +1,16 @@
 var H = Object.defineProperty;
 var j = (g, e, t) => e in g ? H(g, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : g[e] = t;
-var _ = (g, e, t) => j(g, typeof e != "symbol" ? e + "" : e, t);
-import { UpdateSheetDataValidationSettingCommand as b, UpdateSheetDataValidationOptionsCommand as U, UpdateSheetDataValidationRangeCommand as C, RemoveSheetDataValidationCommand as A, ClearRangeDataValidationCommand as q, AddSheetDataValidationCommand as T, SheetsDataValidationValidatorService as S, SheetDataValidationModel as w, RemoveSheetAllDataValidationCommand as O } from "@univerjs/sheets-data-validation";
+var f = (g, e, t) => j(g, typeof e != "symbol" ? e + "" : e, t);
+import { UpdateSheetDataValidationSettingCommand as b, UpdateSheetDataValidationOptionsCommand as U, UpdateSheetDataValidationRangeCommand as C, RemoveSheetDataValidationCommand as A, ClearRangeDataValidationCommand as q, AddSheetDataValidationCommand as T, SheetsDataValidationValidatorService as S, SheetDataValidationModel as k, RemoveSheetAllDataValidationCommand as O } from "@univerjs/sheets-data-validation";
 import { FRange as y, FWorkbook as x, FWorksheet as N } from "@univerjs/sheets/facade";
-import { generateRandomId as L, DataValidationType as o, DataValidationErrorStyle as k, DataValidationOperator as h, IUniverInstanceService as W, ICommandService as p, CanceledError as f, toDisposable as c } from "@univerjs/core";
-import { DataValidationModel as v, getRuleOptions as $ } from "@univerjs/data-validation";
+import { DataValidationType as o, generateRandomId as L, DataValidationErrorStyle as V, DataValidationOperator as h, IUniverInstanceService as W, ICommandService as p, CanceledError as m, toDisposable as c } from "@univerjs/core";
+import { DataValidationModel as w, getRuleOptions as $ } from "@univerjs/data-validation";
 import { serializeRangeToRefString as F } from "@univerjs/engine-formula";
 import { FUniver as M, FEventName as P } from "@univerjs/core/facade";
 import { filter as R } from "rxjs";
 class E {
   constructor(e) {
-    _(this, "_rule");
+    f(this, "_rule");
     this._rule = e != null ? e : {
       uid: L(),
       ranges: void 0,
@@ -22,20 +22,31 @@ class E {
    * @returns {FDataValidation} A new instance of the FDataValidation class
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const validation = builder.requireNumberBetween(1, 10).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number between 1 and 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   build() {
-    return new m(this._rule);
+    return new _(this._rule);
   }
   /**
    * Creates a duplicate of the current DataValidationBuilder object
    * @returns {FDataValidationBuilder} A new instance of the DataValidationBuilder class
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const copy = builder.requireNumberBetween(1, 10).copy();
+   * const builder = univerAPI.newDataValidation().requireNumberBetween(1, 10);
+   * const copyBuilder = builder.copy();
+   * console.log(copyBuilder);
    * ```
    */
   copy() {
@@ -49,12 +60,12 @@ class E {
    * @returns {boolean} True if invalid data is allowed, False otherwise
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const allowsInvalid = builder.getAllowInvalid();
+   * const builder = univerAPI.newDataValidation().requireNumberBetween(1, 10);
+   * console.log(builder.getAllowInvalid());
    * ```
    */
   getAllowInvalid() {
-    return this._rule.errorStyle !== k.STOP;
+    return this._rule.errorStyle !== V.STOP;
   }
   /**
    * Gets the data validation type of the rule
@@ -62,7 +73,13 @@ class E {
    * @example
    * ```typescript
    * const builder = univerAPI.newDataValidation();
-   * const type = builder.getCriteriaType();
+   * console.log(builder.getCriteriaType());
+   *
+   * builder.requireNumberBetween(1, 10);
+   * console.log(builder.getCriteriaType());
+   *
+   * builder.requireValueInList(['Yes', 'No']);
+   * console.log(builder.getCriteriaType());
    * ```
    */
   getCriteriaType() {
@@ -73,8 +90,12 @@ class E {
    * @returns {[string | undefined, string | undefined, string | undefined]} An array containing the operator, formula1, and formula2 values
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
+   * const builder = univerAPI.newDataValidation().requireNumberBetween(1, 10);
    * const [operator, formula1, formula2] = builder.getCriteriaValues();
+   * console.log(operator, formula1, formula2);
+   *
+   * builder.requireValueInList(['Yes', 'No']);
+   * console.log(builder.getCriteriaValues());
    * ```
    */
   getCriteriaValues() {
@@ -85,8 +106,11 @@ class E {
    * @returns {string | undefined} Returns the help text information. If there is no error message, it returns an undefined value
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const helpText = builder.getHelpText();
+   * const builder = univerAPI.newDataValidation().setOptions({
+   *   showErrorMessage: true,
+   *   error: 'Please enter a valid value'
+   * });
+   * console.log(builder.getHelpText()); // 'Please enter a valid value'
    * ```
    */
   getHelpText() {
@@ -99,8 +123,22 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireCheckbox('Yes', 'No').build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set the data validation for cell A1:A10 to require a checkbox with default 1 and 0 values
+   * const fRange = fWorksheet.getRange('A1:A10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireCheckbox()
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Set the data validation for cell B1:B10 to require a checkbox with 'Yes' and 'No' values
+   * const fRange2 = fWorksheet.getRange('B1:B10');
+   * const rule2 = univerAPI.newDataValidation()
+   *   .requireCheckbox('Yes', 'No')
+   *   .build();
+   * fRange2.setDataValidation(rule2);
    * ```
    */
   requireCheckbox(e, t) {
@@ -112,8 +150,20 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireDateAfter(new Date('2024-01-01')).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateAfter(new Date('2025-01-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['invalid', 'invalid', 'invalid', 'valid']]
    * ```
    */
   requireDateAfter(e) {
@@ -125,8 +175,20 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireDateBefore(new Date('2024-12-31')).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateBefore(new Date('2025-01-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['valid', 'valid', 'invalid', 'invalid']]
    * ```
    */
   requireDateBefore(e) {
@@ -139,10 +201,20 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder
-   *   .requireDateBetween(new Date('2024-01-01'), new Date('2024-12-31'))
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateBetween(new Date('2024-06-01'), new Date('2025-06-01'))
    *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['invalid', 'valid', 'valid', 'invalid']]
    * ```
    */
   requireDateBetween(e, t) {
@@ -154,8 +226,23 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireDateEqualTo(new Date('2024-01-01')).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateEqualTo(new Date('2025-01-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const status = await fWorksheet.getRange('A2').getValidatorStatus();
+   * console.log(status?.[0]?.[0]); // 'valid'
+   *
+   * const status2 = await fWorksheet.getRange('B2').getValidatorStatus();
+   * console.log(status2?.[0]?.[0]); // 'invalid'
    * ```
    */
   requireDateEqualTo(e) {
@@ -168,10 +255,20 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder
-   *   .requireDateNotBetween(new Date('2024-01-01'), new Date('2024-12-31'))
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateNotBetween(new Date('2024-06-01'), new Date('2025-06-01'))
    *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['valid', 'invalid', 'invalid', 'valid']]
    * ```
    */
   requireDateNotBetween(e, t) {
@@ -183,8 +280,20 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireDateOnOrAfter(new Date('2024-01-01')).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateOnOrAfter(new Date('2025-01-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['invalid', 'invalid', 'valid', 'valid']]
    * ```
    */
   requireDateOnOrAfter(e) {
@@ -196,8 +305,20 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireDateOnOrBefore(new Date('2024-12-31')).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * fRange.setValues([
+   *   ['2024-01-01', '2024-12-31'],
+   *   ['2025-01-01', '2025-12-31']
+   * ]);
+   * const rule = univerAPI.newDataValidation()
+   *   .requireDateOnOrBefore(new Date('2025-01-01'))
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['valid', 'valid', 'valid', 'invalid']]
    * ```
    */
   requireDateOnOrBefore(e) {
@@ -205,12 +326,33 @@ class E {
   }
   /**
    * Requires that a custom formula be satisfied
-   * @param {string} formula - The formula string that needs to be satisfied
+   * @param {string} formula - The formula string that needs to be satisfied, formula result should be TRUE or FALSE, and references range will relative offset
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireFormulaSatisfied('=A1>0').build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const cell = fWorksheet.getRange('A1:B2');
+   * cell.setValues([
+   *   [4, 3],
+   *   [2, 1]
+   * ]);
+   * const fRange = fWorksheet.getRange('C1:D2');
+   * fRange.setValues([
+   *   [1, 2],
+   *   [3, 4]
+   * ]);
+   * const rule = univerAPI.newDataValidation()
+   *   .requireFormulaSatisfied('=A1>2')
+   *   .setOptions({
+   *     showErrorMessage: true,
+   *     error: 'Please enter a value equal to A1'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const status = await fRange.getValidatorStatus();
+   * console.log(status); // [['valid', 'valid', 'invalid', 'invalid']]
    * ```
    */
   requireFormulaSatisfied(e) {
@@ -224,8 +366,18 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireNumberBetween(1, 10).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number between 1 and 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   requireNumberBetween(e, t, i) {
@@ -238,8 +390,18 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireNumberEqualTo(10).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberEqualTo(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number equal to 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   requireNumberEqualTo(e, t) {
@@ -252,8 +414,18 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireNumberGreaterThan(10).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberGreaterThan(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number greater than 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   requireNumberGreaterThan(e, t) {
@@ -266,8 +438,18 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireNumberGreaterThanOrEqualTo(10).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberGreaterThanOrEqualTo(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number greater than 10 or equal to 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   requireNumberGreaterThanOrEqualTo(e, t) {
@@ -280,8 +462,18 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireNumberLessThan(10).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberLessThan(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number less than 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   requireNumberLessThan(e, t) {
@@ -295,8 +487,18 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireNumberLessThanOrEqualTo(10).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberLessThanOrEqualTo(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number less than 10 or equal to 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   requireNumberLessThanOrEqualTo(e, t) {
@@ -311,8 +513,18 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireNumberNotBetween(1, 10).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberNotBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number not between 1 and 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   requireNumberNotBetween(e, t, i) {
@@ -326,8 +538,18 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireNumberNotEqualTo(10).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberNotEqualTo(10)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number not equal to 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   requireNumberNotEqualTo(e, t) {
@@ -342,8 +564,18 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.requireValueInList(['Yes', 'No']).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a value from the list'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   requireValueInList(e, t, i) {
@@ -358,9 +590,24 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const range = FRange.create('Sheet1', 'B1:B10');
-   * const rule = builder.requireValueInRange(range).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('B1:B2');
+   * fRange.setValues([
+   *   ['Yes'],
+   *   ['No']
+   * ]);
+   *
+   * const rule = univerAPI.newDataValidation()
+   *   .requireValueInRange(fRange)
+   *   .setOptions({
+   *     allowBlank: false,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a value from the list'
+   *   })
+   *   .build();
+   * const cell = fWorksheet.getRange('A1');
+   * cell.setDataValidation(rule);
    * ```
    */
   requireValueInRange(e, t, i) {
@@ -378,12 +625,28 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.setAllowInvalid(true).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set the data validation for cell A1:B2 to allow invalid data, so A1:B2 will display a warning when invalid data is entered
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setAllowInvalid(true)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Set the data validation for cell C1:D2 to not allow invalid data, so C1:D2 will stop data entry when invalid data is entered
+   * const fRange2 = fWorksheet.getRange('C1:D2');
+   * const rule2 = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setAllowInvalid(false)
+   *   .build();
+   * fRange2.setDataValidation(rule2);
    * ```
    */
   setAllowInvalid(e) {
-    return this._rule.errorStyle = e ? k.WARNING : k.STOP, this;
+    return this._rule.errorStyle = e ? V.WARNING : V.STOP, this;
   }
   /**
    * Sets whether to allow blank values
@@ -391,8 +654,25 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.setAllowBlank(true).build();
+   * // Assume current sheet is empty data
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   *
+   * // Set the data validation for cell A1:B2 to allow blank values
+   * const fRange = fWorksheet.getRange('A1:B2');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setAllowBlank(true)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * // Set the data validation for cell C1:D2 to not allow blank values
+   * const fRange2 = fWorksheet.getRange('C1:D2');
+   * const rule2 = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setAllowBlank(false)
+   *   .build();
+   * fRange2.setDataValidation(rule2);
    * ```
    */
   setAllowBlank(e) {
@@ -404,23 +684,29 @@ class E {
    * @returns {FDataValidationBuilder} The current instance for method chaining
    * @example
    * ```typescript
-   * const builder = univerAPI.newDataValidation();
-   * const rule = builder.setOptions({
-   *   allowBlank: true,
-   *   showErrorMessage: true,
-   *   error: 'Please enter a valid value'
-   * }).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireValueInList(['Yes', 'No'])
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a value from the list'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
    * ```
    */
   setOptions(e) {
     return Object.assign(this._rule, e), this;
   }
 }
-class m {
+class _ {
   constructor(e, t, i) {
-    _(this, "rule");
-    _(this, "_worksheet");
-    _(this, "_injector");
+    f(this, "rule");
+    f(this, "_worksheet");
+    f(this, "_injector");
     this._injector = i, this.rule = e, this._worksheet = t;
   }
   /**
@@ -428,28 +714,28 @@ class m {
    * @returns {boolean} true if invalid data is allowed, false otherwise
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const allowsInvalid = dataValidation.getAllowInvalid();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const rules = fWorksheet.getDataValidations();
+   * rules.forEach((rule) => {
+   *   console.log(rule, rule.getAllowInvalid());
+   * });
    * ```
    */
   getAllowInvalid() {
-    return this.rule.errorStyle !== k.STOP;
+    return this.rule.errorStyle !== V.STOP;
   }
   /**
    * Gets the data validation type of the rule
    * @returns {DataValidationType | string} The data validation type
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const type = dataValidation.getCriteriaType();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const rules = fWorksheet.getDataValidations();
+   * rules.forEach((rule) => {
+   *   console.log(rule, rule.getCriteriaType());
+   * });
    * ```
    */
   getCriteriaType() {
@@ -460,12 +746,15 @@ class m {
    * @returns {[string | undefined, string | undefined, string | undefined]} An array containing the operator, formula1, and formula2 values
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const [operator, formula1, formula2] = dataValidation.getCriteriaValues();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const rules = fWorksheet.getDataValidations();
+   * rules.forEach((rule) => {
+   *   console.log(rule);
+   *   const criteriaValues = rule.getCriteriaValues();
+   *   const [operator, formula1, formula2] = criteriaValues;
+   *   console.log(operator, formula1, formula2);
+   * });
    * ```
    */
   getCriteriaValues() {
@@ -476,12 +765,19 @@ class m {
    * @returns {string | undefined} Returns the help text information. If there is no error message, it returns an undefined value
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const helpText = dataValidation.getHelpText();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number between 1 and 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   * console.log(fRange.getDataValidation().getHelpText()); // 'Please enter a number between 1 and 10'
    * ```
    */
   getHelpText() {
@@ -492,13 +788,27 @@ class m {
    * @returns {FDataValidationBuilder} A new FDataValidationBuilder instance with the same rule configuration
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const builder = dataValidation.copy();
-   * const newRule = builder.setAllowInvalid(true).build();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberBetween(1, 10)
+   *   .setOptions({
+   *     allowBlank: true,
+   *     showErrorMessage: true,
+   *     error: 'Please enter a number between 1 and 10'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const builder = fRange.getDataValidation().copy();
+   * const newRule = builder
+   *   .requireNumberBetween(1, 5)
+   *   .setOptions({
+   *     error: 'Please enter a number between 1 and 5'
+   *   })
+   *   .build();
+   * fRange.setDataValidation(newRule);
    * ```
    */
   copy() {
@@ -509,18 +819,21 @@ class m {
    * @returns {boolean} true if the rule is applied, false otherwise
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const isApplied = dataValidation.getApplied();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const rules = fWorksheet.getDataValidations();
+   * rules.forEach((rule) => {
+   *   console.log(rule, rule.getApplied());
+   * });
+   *
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * console.log(fRange.getDataValidation()?.getApplied());
    * ```
    */
   getApplied() {
     if (!this._worksheet)
       return !1;
-    const t = this._injector.get(v).getRuleById(this._worksheet.getUnitId(), this._worksheet.getSheetId(), this.rule.uid);
+    const t = this._injector.get(w).getRuleById(this._worksheet.getUnitId(), this._worksheet.getSheetId(), this.rule.uid);
     return !!(t && t.ranges.length);
   }
   /**
@@ -528,12 +841,16 @@ class m {
    * @returns {FRange[]} An array of FRange objects representing the ranges to which the data validation rule is applied
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const ranges = dataValidation.getRanges();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const rules = fWorksheet.getDataValidations();
+   * rules.forEach((rule) => {
+   *   console.log(rule);
+   *   const ranges = rule.getRanges();
+   *   ranges.forEach((range) => {
+   *     console.log(range.getA1Notation());
+   *   });
+   * });
    * ```
    */
   getRanges() {
@@ -547,12 +864,10 @@ class m {
    * @returns {string | undefined} The unit ID of the worksheet
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const unitId = dataValidation.getUnitId();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * console.log(fRange.getDataValidation().getUnitId());
    * ```
    */
   getUnitId() {
@@ -564,12 +879,10 @@ class m {
    * @returns {string | undefined} The sheet ID of the worksheet
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const sheetId = dataValidation.getSheetId();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * console.log(fRange.getDataValidation().getSheetId());
    * ```
    */
   getSheetId() {
@@ -584,15 +897,17 @@ class m {
    * @returns {FDataValidation} The current instance for method chaining
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * dataValidation.setCriteria(
-   *   DataValidationType.DECIMAL,
-   *   [DataValidationOperator.BETWEEN, '1', '10'],
-   *   true
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberEqualTo(20)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * fRange.getDataValidation().setCriteria(
+   *   univerAPI.Enum.DataValidationType.DECIMAL,
+   *   [univerAPI.Enum.DataValidationOperator.BETWEEN, '1', '10']
    * );
    * ```
    */
@@ -618,12 +933,15 @@ class m {
    * @returns {FDataValidation} The current instance for method chaining
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * dataValidation.setOptions({
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberEqualTo(20)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * fRange.getDataValidation().setOptions({
    *   allowBlank: true,
    *   showErrorMessage: true,
    *   error: 'Please enter a valid value'
@@ -649,13 +967,16 @@ class m {
    * @returns {FDataValidation} The current instance for method chaining
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const range = FRange.create('Sheet1', 'A1:B10');
-   * dataValidation.setRanges([range]);
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberEqualTo(20)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * const newRuleRange = fWorksheet.getRange('C1:D10');
+   * fRange.getDataValidation().setRanges([newRuleRange]);
    * ```
    */
   setRanges(e) {
@@ -673,12 +994,15 @@ class m {
    * @returns {boolean} true if the rule is deleted successfully, false otherwise
    * @example
    * ```typescript
-   * const dataValidation = univerAPI
-   *   .getActiveWorkbook()
-   *   .getActiveWorksheet()
-   *   .getActiveRange()
-   *   .getDataValidation();
-   * const isDeleted = dataValidation.delete();
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const fWorksheet = fWorkbook.getActiveSheet();
+   * const fRange = fWorksheet.getRange('A1:B10');
+   * const rule = univerAPI.newDataValidation()
+   *   .requireNumberEqualTo(20)
+   *   .build();
+   * fRange.setDataValidation(rule);
+   *
+   * fRange.getDataValidation().delete();
    * ```
    */
   delete() {
@@ -713,14 +1037,14 @@ class G extends y {
       this._worksheet.getSheetId(),
       [this._range]
     );
-    return t && new m(t, this._worksheet, this._injector);
+    return t && new _(t, this._worksheet, this._injector);
   }
   getDataValidations() {
     return this._injector.get(S).getDataValidations(
       this._workbook.getUnitId(),
       this._worksheet.getSheetId(),
       [this._range]
-    ).map((t) => new m(t, this._worksheet, this._injector));
+    ).map((t) => new _(t, this._worksheet, this._injector));
   }
   async getValidatorStatus() {
     return this._injector.get(S).validatorRanges(
@@ -747,22 +1071,22 @@ class Q extends M {
    */
   // eslint-disable-next-line max-lines-per-function
   _initialize(e) {
-    if (!e.has(w)) return;
-    const t = e.get(w), i = e.get(p);
+    if (!e.has(k)) return;
+    const t = e.get(k), i = e.get(p);
     this.registerEventHandler(
       this.Event.SheetDataValidationChanged,
       () => t.ruleChange$.subscribe((r) => {
         const { unitId: a, subUnitId: n, rule: u, oldRule: l, type: s } = r, d = this.getSheetTarget(a, n);
         if (!d)
           return;
-        const { workbook: D, worksheet: I } = d, V = new m(u, I.getSheet(), this._injector);
+        const { workbook: D, worksheet: I } = d, v = new _(u, I.getSheet(), this._injector);
         this.fireEvent(this.Event.SheetDataValidationChanged, {
           origin: r,
           worksheet: I,
           workbook: D,
           changeType: s,
           oldRule: l,
-          rule: V
+          rule: v
         });
       })
     ), this.registerEventHandler(
@@ -771,10 +1095,10 @@ class Q extends M {
         const { unitId: a, subUnitId: n, ruleId: u, status: l, row: s, col: d } = r, D = this.getSheetTarget(a, n);
         if (!D)
           return;
-        const { workbook: I, worksheet: V } = D, B = V.getDataValidation(u);
+        const { workbook: I, worksheet: v } = D, B = v.getDataValidation(u);
         B && this.fireEvent(this.Event.SheetDataValidatorStatusChanged, {
           workbook: I,
-          worksheet: V,
+          worksheet: v,
           row: s,
           column: d,
           rule: B,
@@ -794,7 +1118,7 @@ class Q extends M {
             rule: a.rule
           };
           if (this.fireEvent(this.Event.BeforeSheetDataValidationAdd, s), s.cancel)
-            throw new f();
+            throw new m();
         }
       })
     ), this.registerEventHandler(
@@ -815,7 +1139,7 @@ class Q extends M {
             newCriteria: a.setting
           };
           if (this.fireEvent(this.Event.BeforeSheetDataValidationCriteriaUpdate, d), d.cancel)
-            throw new f();
+            throw new m();
         }
       })
     ), this.registerEventHandler(
@@ -836,7 +1160,7 @@ class Q extends M {
             newRanges: a.ranges
           };
           if (this.fireEvent(this.Event.BeforeSheetDataValidationRangeUpdate, d), d.cancel)
-            throw new f();
+            throw new m();
         }
       })
     ), this.registerEventHandler(
@@ -857,7 +1181,7 @@ class Q extends M {
             newOptions: a.options
           };
           if (this.fireEvent(this.Event.BeforeSheetDataValidationOptionsUpdate, d), d.cancel)
-            throw new f();
+            throw new m();
         }
       })
     ), this.registerEventHandler(
@@ -877,7 +1201,7 @@ class Q extends M {
             ruleId: a.ruleId
           };
           if (this.fireEvent(this.Event.BeforeSheetDataValidationDelete, d), d.cancel)
-            throw new f();
+            throw new m();
         }
       })
     ), this.registerEventHandler(
@@ -893,7 +1217,7 @@ class Q extends M {
             rules: l.getDataValidations()
           };
           if (this.fireEvent(this.Event.BeforeSheetDataValidationDeleteAll, s), s.cancel)
-            throw new f();
+            throw new m();
         }
       })
     );
@@ -904,7 +1228,7 @@ class z extends x {
   _initialize() {
     Object.defineProperty(this, "_dataValidationModel", {
       get() {
-        return this._injector.get(w);
+        return this._injector.get(k);
       }
     });
   }
@@ -988,7 +1312,7 @@ class z extends x {
 x.extend(z);
 class K extends N {
   getDataValidations() {
-    return this._injector.get(v).getRules(this._workbook.getUnitId(), this._worksheet.getSheetId()).map((t) => new m(t, this._worksheet, this._injector));
+    return this._injector.get(w).getRules(this._workbook.getUnitId(), this._worksheet.getSheetId()).map((t) => new _(t, this._worksheet, this._injector));
   }
   getValidatorStatus() {
     return this._injector.get(S).validatorWorksheet(
@@ -1000,8 +1324,8 @@ class K extends N {
     return this.getValidatorStatus();
   }
   getDataValidation(e) {
-    const i = this._injector.get(v).getRuleById(this._workbook.getUnitId(), this._worksheet.getSheetId(), e);
-    return i ? new m(i, this._worksheet, this._injector) : null;
+    const i = this._injector.get(w).getRuleById(this._workbook.getUnitId(), this._worksheet.getSheetId(), e);
+    return i ? new _(i, this._worksheet, this._injector) : null;
   }
 }
 N.extend(K);
@@ -1033,6 +1357,6 @@ class X {
 }
 P.extend(X);
 export {
-  m as FDataValidation,
+  _ as FDataValidation,
   E as FDataValidationBuilder
 };