@univerjs/sheets-data-validation 0.4.1 → 0.4.2-nightly.202410301606

package/lib/es/facade.js

@@ -0,0 +1,654 @@
+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 { FRange, FWorkbook, FWorksheet } from "@univerjs/sheets/facade";
+import { m as UpdateSheetDataValidationSettingCommand, n as UpdateSheetDataValidationOptionsCommand, U as UpdateSheetDataValidationRangeCommand, R as RemoveSheetDataValidationCommand, p as ClearRangeDataValidationCommand, A as AddSheetDataValidationCommand, l as SheetsDataValidationValidatorService, S as SheetDataValidationModel, o as RemoveSheetAllDataValidationCommand } from "../dv-validator-service-9VDfOza1.mjs";
+import { generateRandomId, DataValidationType, DataValidationErrorStyle, DataValidationOperator, ICommandService, FUniver, toDisposable } 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: DataValidationType.CUSTOM
+    };
+  }
+  /**
+   * Builds an FDataValidation instance based on the _rule property of the current class
+   *
+   * @returns {FDataValidation} A new instance of the FDataValidation class
+   */
+  build() {
+    return new FDataValidation(this._rule);
+  }
+  /**
+   * Creates a duplicate of the current DataValidationBuilder object
+   *
+   * @return {FDataValidationBuilder} A new instance of the DataValidationBuilder class
+   */
+  copy() {
+    return new _FDataValidationBuilder({
+      ...this._rule,
+      uid: generateRandomId()
+    });
+  }
+  /**
+   * Determines whether invalid data is allowed
+   *
+   * @returns {boolean} True if invalid data is allowed, False otherwise
+   */
+  getAllowInvalid() {
+    return this._rule.errorStyle !== DataValidationErrorStyle.STOP;
+  }
+  /**
+   * Gets the data validation type of the rule
+   *
+   * @returns {DataValidationType} The data validation type
+   */
+  getCriteriaType() {
+    return this._rule.type;
+  }
+  /**
+   * Gets the values used for criteria evaluation
+   *
+   * @returns {any[]} An array containing the operator, formula1, and formula2 values
+   */
+  getCriteriaValues() {
+    return [this._rule.operator, this._rule.formula1, this._rule.formula2];
+  }
+  /**
+   * Gets the help text information, which is used to provide users with guidance and support
+   *
+   * @returns {string | undefined} Returns the help text information. If there is no error message, it returns an undefined value.
+   */
+  getHelpText() {
+    return this._rule.error;
+  }
+  /**
+   * Sets the data validation type to CHECKBOX and sets the checked and unchecked values
+   *
+   * @param checkedValue The value when the checkbox is checked (Optional)
+   * @param uncheckedValue The value when the checkbox is unchecked (Optional)
+   * @returns The current instance of the FDataValidationBuilder class to allow for method chaining
+   */
+  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
+   *
+   * @param date The date to compare against. The formatted date string will be set as formula1
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   */
+  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
+   *
+   * @param date The date to compare against. The formatted date string will be set as formula1
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   */
+  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
+   *
+   * @param start The starting date of the range. The formatted date string will be set as formula1
+   * @param end The ending date of the range. The formatted date string will be set as formula2
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   */
+  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
+   *
+   * @param date The date to compare against. The formatted date string will be set as formula1
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   */
+  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
+   *
+   * @param start The starting date of the date range
+   * @param end The ending date of the date range
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   */
+  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
+   *
+   * @param date The date to compare against. The formatted date string will be set as formula1
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   */
+  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
+   *
+   * @param date The date to compare against. The formatted date string will be set as formula1
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   */
+  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.
+   * Sets the data validation type to CUSTOM and configures the validation rule based on the provided formula string.
+   *
+   * @param formula The formula string that needs to be satisfied.
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   */
+  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.
+   * Sets the data validation type based on the isInteger parameter and configures the validation rules for the specified number range.
+   *
+   * @param start The starting value of the number range.
+   * @param end The ending value of the number range.
+   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or decimal.
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   */
+  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.
+   * Sets the data validation type based on the isInteger parameter and configures the validation rules for the specified number.
+   *
+   * @param num The number to which the entered number should be equal.
+   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or a decimal.
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   */
+  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.
+   * Sets the data validation type based on the isInteger parameter and configures the validation rules for the specified number.
+   *
+   * @param num The number to which the entered number should be greater.
+   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or a decimal.
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   */
+  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.
+   * Sets the data validation type based on the isInteger parameter and configures the validation rules for the specified number.
+   *
+   * @param num The number to which the entered number should be greater than or equal.
+   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or a decimal.
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   */
+  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.
+   * Sets the data validation type based on the isInteger parameter and configures the validation rules for the specified number.
+   *
+   * @param num The number to which the entered number should be less.
+   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or a decimal.
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   */
+  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
+   * The specified value can be an integer or a decimal
+   *
+   * @param num The number to which the entered number should be less than or equal
+   * @param isInteger Indicates whether the required number is an integer
+   * @return The current instance of the DataValidationBuilder class, allowing for method chaining
+   */
+  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
+   * The specified range includes all integers and decimals
+   *
+   * @param start The starting point of the specified range
+   * @param end The end point of the specified range
+   * @param isInteger Optional parameter, indicating whether the number to be verified is an integer. Default value is false
+   * @return An instance of the FDataValidationBuilder class, allowing for method chaining
+   */
+  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
+   * The specific value can be an integer or a decimal
+   *
+   * @param num The number to which the entered number should not be equal
+   * @param isInteger Indicates whether the required number is an integer. Default is undefined, meaning it can be an integer or a decimal
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining
+   */
+  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.
+   * The list can be displayed in a dropdown, and the user can choose multiple values according to the settings.
+   *
+   * @param values An array containing the specific values that the user can enter.
+   * @param multiple Optional parameter indicating whether the user can select multiple values. Default is false, meaning only one value can be selected.
+   * @param showDropdown Optional parameter indicating whether to display the list in a dropdown. Default is true, meaning the list will be displayed as a dropdown.
+   * @return An instance of the FDataValidationBuilder class, allowing for method chaining.
+   */
+  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.
+   * The range is defined by an FRange object, which contains the unit ID, sheet name, and cell range.
+   *
+   * @param range An FRange object representing the range of values that the user can enter.
+   * @param multiple Optional parameter indicating whether the user can select multiple values. Default is false, meaning only one value can be selected.
+   * @param showDropdown Optional parameter indicating whether to display the list in a dropdown. Default is true, meaning the list will be displayed as a dropdown.
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   */
+  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 for data validation.
+   * If invalid data is not allowed, the error style will be set to STOP, indicating that data entry must stop upon encountering an error.
+   * If invalid data is allowed, the error style will be set to WARNING, indicating that a warning will be displayed when invalid data is entered, but data entry can continue.
+   *
+   * @param allowInvalidData A boolean value indicating whether to allow invalid data.
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   */
+  setAllowInvalid(allowInvalidData) {
+    return this._rule.errorStyle = allowInvalidData ? DataValidationErrorStyle.WARNING : DataValidationErrorStyle.STOP, this;
+  }
+  /**
+   * Sets the help text and enables the display of error messages for data validation.
+   * This method allows you to set a custom help text that will be displayed when the user enters invalid data.
+   *
+   * @param helpText The text to display as help information.
+   * @return The current instance of the FDataValidationBuilder class to allow for method chaining.
+   */
+  setHelpText(helpText) {
+    return this._rule.error = helpText, this._rule.showErrorMessage = !0, this;
+  }
+  /**
+   * Sets the criteria values for data validation.
+   * This method is used to configure the validation rules based on specific criteria values.
+   *
+   * @param type The type of data validation.
+   * @param values An array containing the criteria values.
+   * The array should have three elements: [operator, formula1, formula2].
+   * operator is a DataValidationOperator enum value, formula1 is the first formula, and formula2 is the second formula.
+   * @return The current instance of the FDataValidationBuilder class, allowing for method chaining.
+   */
+  withCriteriaValues(type, values) {
+    return this._rule.type = type, this._rule.operator = values[0], this._rule.formula1 = values[1], this._rule.formula2 = values[2], this;
+  }
+  /**
+   * Sets the options for the data validation rule.
+   * For details of options, please refer to https://univer.ai/typedoc/@univerjs/core/interfaces/IDataValidationRuleOptions
+   *
+   * @param options The options to set for the data validation rule.
+   * @returns The current instance of the FDataValidationBuilder class to allow for method chaining.
+   */
+  setOptions(options) {
+    return Object.assign(this._rule, options), this;
+  }
+};
+__name(_FDataValidationBuilder, "FDataValidationBuilder");
+let FDataValidationBuilder = _FDataValidationBuilder;
+const _FDataValidation = class _FDataValidation {
+  constructor(rule, worksheet) {
+    __publicField(this, "rule");
+    __publicField(this, "_worksheet");
+    this.rule = rule, this._worksheet = worksheet;
+  }
+  /**
+   * Gets whether invalid data is allowed based on the error style value.
+   *
+   * @return true if invalid data is allowed, false otherwise.
+   */
+  getAllowInvalid() {
+    return this.rule.errorStyle !== DataValidationErrorStyle.STOP;
+  }
+  /**
+   * Gets the data validation type of the rule
+   *
+   * @returns The data validation type
+   */
+  getCriteriaType() {
+    return this.rule.type;
+  }
+  /**
+   * Gets the values used for criteria evaluation
+   *
+   * @returns An array containing the operator, formula1, and formula2 values
+   */
+  getCriteriaValues() {
+    return [this.rule.operator, this.rule.formula1, this.rule.formula2];
+  }
+  /**
+   * Gets the help text information, which is used to provide users with guidance and support
+   *
+   * @returns Returns the help text information. If there is no error message, it returns an undefined value.
+   */
+  getHelpText() {
+    return this.rule.error;
+  }
+  /**
+   * Creates a new instance of FDataValidationBuilder using the current rule object.
+   * This method is useful for copying an existing data validation rule configuration.
+   *
+   * @return A new FDataValidationBuilder instance with the same rule configuration.
+   */
+  copy() {
+    return new FDataValidationBuilder(this.rule);
+  }
+  /**
+   * Gets whether the data validation rule is applied to the worksheet.
+   *
+   * @returns true if the rule is applied, false otherwise.
+   */
+  getApplied() {
+    if (!this._worksheet)
+      return !1;
+    const currentRule = this._worksheet.getInject().get(DataValidationModel).getRuleById(this._worksheet.getWorkbook().getUnitId(), this._worksheet.getSheetId(), this.rule.uid);
+    return !!(currentRule && currentRule.ranges.length);
+  }
+  /**
+   * Gets the ranges to which the data validation rule is applied.
+   *
+   * @returns An array of IRange objects representing the ranges to which the data validation rule is applied.
+   */
+  getRanges() {
+    var _a;
+    if (!this.getAllowInvalid())
+      return [];
+    const workbook = (_a = this._worksheet) == null ? void 0 : _a.getWorkbook(), sheetId = this.getSheetId();
+    if (!sheetId)
+      return [];
+    const worksheet = workbook == null ? void 0 : workbook.getSheetBySheetId(sheetId);
+    return !workbook || !worksheet ? [] : this.rule.ranges.map((range) => {
+      var _a2;
+      return (_a2 = this._worksheet) == null ? void 0 : _a2.getInject().createInstance(FRange, workbook, worksheet, range);
+    });
+  }
+  /**
+   * Gets the title of the error message dialog box.
+   *
+   * @returns The title of the error message dialog box.
+   */
+  getUnitId() {
+    var _a;
+    return (_a = this._worksheet) == null ? void 0 : _a.getWorkbook().getUnitId();
+  }
+  /**
+   * Gets the sheetId of the worksheet.
+   *
+   * @returns The sheetId of the worksheet.
+   */
+  getSheetId() {
+    var _a;
+    return (_a = this._worksheet) == null ? void 0 : _a.getSheetId();
+  }
+  /**
+   * Set Criteria for the data validation rule.
+   * @param type The type of data validation criteria.
+   * @param values An array containing the operator, formula1, and formula2 values.
+   * @returns true if the criteria is set successfully, false otherwise.
+   */
+  setCriteria(type, values) {
+    return this.getApplied() && !this._worksheet.getInject().get(ICommandService).syncExecuteCommand(UpdateSheetDataValidationSettingCommand.id, {
+      unitId: this.getUnitId(),
+      subUnitId: this.getSheetId(),
+      ruleId: this.rule.uid,
+      setting: {
+        operator: values[0],
+        formula1: values[1],
+        formula2: values[2],
+        type: this.rule.type
+      }
+    }) ? !1 : (this.rule.operator = values[0], this.rule.formula1 = values[1], this.rule.formula2 = values[2], this.rule.type = type, !0);
+  }
+  /**
+   * Set the options for the data validation rule.
+   * For details of options, please refer to https://univer.ai/typedoc/@univerjs/core/interfaces/IDataValidationRuleOptions
+   * @param options An object containing the options to set. `IDataValidationRuleOptions`
+   * @returns true if the options are set successfully, false otherwise.
+   */
+  setOptions(options) {
+    return this.getApplied() && !this._worksheet.getInject().get(ICommandService).syncExecuteCommand(UpdateSheetDataValidationOptionsCommand.id, {
+      unitId: this.getUnitId(),
+      subUnitId: this.getSheetId(),
+      ruleId: this.rule.uid,
+      options: {
+        ...getRuleOptions(this.rule),
+        ...options
+      }
+    }) ? !1 : (Object.assign(this.rule, options), !0);
+  }
+  /**
+   * Set the ranges to the data validation rule.
+   * @param ranges new ranges array.
+   * @returns true if the ranges are set successfully, false otherwise.
+   */
+  setRanges(ranges) {
+    return this.getApplied() && !this._worksheet.getInject().get(ICommandService).syncExecuteCommand(UpdateSheetDataValidationRangeCommand.id, {
+      unitId: this.getUnitId(),
+      subUnitId: this.getSheetId(),
+      ruleId: this.rule.uid,
+      ranges: ranges.map((range) => range.getRange())
+    }) ? !1 : (this.rule.ranges = ranges, !0);
+  }
+  /**
+   * Delete the data validation rule from the worksheet.
+   * @returns true if the rule is deleted successfully, false otherwise.
+   */
+  delete() {
+    return this.getApplied() ? this._worksheet.getInject().get(ICommandService).syncExecuteCommand(RemoveSheetDataValidationCommand.id, {
+      unitId: this.getUnitId(),
+      subUnitId: this.getSheetId(),
+      ruleId: this.rule.uid
+    }) : !1;
+  }
+};
+__name(_FDataValidation, "FDataValidation");
+let FDataValidation = _FDataValidation;
+const _FRangeDataValidationMixin = class _FRangeDataValidationMixin extends FRange {
+  async setDataValidation(rule) {
+    if (!rule)
+      return this._commandService.executeCommand(ClearRangeDataValidationCommand.id, {
+        unitId: this._workbook.getUnitId(),
+        subUnitId: this._worksheet.getSheetId(),
+        ranges: [this._range]
+      }), this;
+    const params = {
+      unitId: this._workbook.getUnitId(),
+      subUnitId: this._worksheet.getSheetId(),
+      rule: {
+        ...rule.rule,
+        ranges: [this._range]
+      }
+    };
+    return await this._commandService.executeCommand(AddSheetDataValidationCommand.id, params), this;
+  }
+  getDataValidation() {
+    const rule = this._injector.get(SheetsDataValidationValidatorService).getDataValidation(
+      this._workbook.getUnitId(),
+      this._worksheet.getSheetId(),
+      [this._range]
+    );
+    return rule && new FDataValidation(rule);
+  }
+  getDataValidations() {
+    return this._injector.get(SheetsDataValidationValidatorService).getDataValidations(
+      this._workbook.getUnitId(),
+      this._worksheet.getSheetId(),
+      [this._range]
+    ).map((rule) => new FDataValidation(rule));
+  }
+  async getValidatorStatus() {
+    return this._injector.get(SheetsDataValidationValidatorService).validatorRanges(
+      this._workbook.getUnitId(),
+      this._worksheet.getSheetId(),
+      [this._range]
+    );
+  }
+};
+__name(_FRangeDataValidationMixin, "FRangeDataValidationMixin");
+let FRangeDataValidationMixin = _FRangeDataValidationMixin;
+FRange.extend(FRangeDataValidationMixin);
+const _FUnvierDataValidationMixin = class _FUnvierDataValidationMixin {
+  static newDataValidation() {
+    return new FDataValidationBuilder();
+  }
+};
+__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(SheetDataValidationModel);
+      }
+    });
+  }
+  /**
+   * get data validation validator status for current workbook
+   * @returns matrix of validator status
+   */
+  getValidatorStatus() {
+    return this._injector.get(SheetsDataValidationValidatorService).validatorWorkbook(this._workbook.getUnitId());
+  }
+  // region DataValidationHooks
+  /**
+   * The onDataValidationChange event is fired when the data validation rule of this sheet is changed.
+   * @param callback Callback function that will be called when the event is fired
+   * @returns A disposable object that can be used to unsubscribe from the event
+   */
+  onDataValidationChange(callback) {
+    return toDisposable(this._dataValidationModel.ruleChange$.pipe(filter((change) => change.unitId === this._workbook.getUnitId())).subscribe(callback));
+  }
+  /**
+   * The onDataValidationStatusChange event is fired when the data validation status of this sheet is changed.
+   * @param callback Callback function that will be called when the event is fired
+   * @returns A disposable object that can be used to unsubscribe from the event
+   */
+  onDataValidationStatusChange(callback) {
+    return toDisposable(this._dataValidationModel.validStatusChange$.pipe(filter((change) => change.unitId === this._workbook.getUnitId())).subscribe(callback));
+  }
+  /**
+   * The onBeforeAddDataValidation event is fired before the data validation rule is added.
+   * @param callback Callback function that will be called when the event is fired
+   * @returns A disposable object that can be used to unsubscribe from the event
+   */
+  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 (callback(params, options) === !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())
+          return;
+        if (callback(params, options) === !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())
+          return;
+        if (callback(params, options) === !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())
+          return;
+        if (callback(params, options) === !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())
+          return;
+        if (callback(params, options) === !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())
+          return;
+        if (callback(params, options) === !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 {
+  getDataValidations() {
+    return this._injector.get(DataValidationModel).getRules(this._workbook.getUnitId(), this._worksheet.getSheetId()).map((rule) => new FDataValidation(rule));
+  }
+  getValidatorStatus() {
+    return this._injector.get(SheetsDataValidationValidatorService).validatorWorksheet(
+      this._workbook.getUnitId(),
+      this._worksheet.getSheetId()
+    );
+  }
+};
+__name(_FWorksheetDataValidationMixin, "FWorksheetDataValidationMixin");
+let FWorksheetDataValidationMixin = _FWorksheetDataValidationMixin;
+FWorksheet.extend(FWorksheetDataValidationMixin);
+export {
+  FDataValidation,
+  FDataValidationBuilder
+};