@univerjs/sheets-data-validation 0.4.2 → 0.5.0-beta.0

package/lib/types/controllers/dv-formula-ref-range.controller.d.ts

@@ -0,0 +1,13 @@
+import { ISheetDataValidationRule, Disposable } from '@univerjs/core';
+import { FormulaRefRangeService } from '@univerjs/sheets-formula';
+import { SheetDataValidationModel } from '../models/sheet-data-validation-model';
+export declare class DataValidationFormulaRefRangeController extends Disposable {
+    private _dataValidationModel;
+    private _formulaRefRangeService;
+    private _disposableMap;
+    constructor(_dataValidationModel: SheetDataValidationModel, _formulaRefRangeService: FormulaRefRangeService);
+    private _getIdWithUnitId;
+    registerRule: (unitId: string, subUnitId: string, rule: ISheetDataValidationRule) => void;
+    register(unitId: string, subUnitId: string, rule: ISheetDataValidationRule): void;
+    private _initRefRange;
+}

package/lib/types/facade/f-data-validation-builder.d.ts

@@ -0,0 +1,247 @@
+import { IDataValidationRule, IDataValidationRuleOptions, DataValidationOperator, DataValidationType } from '@univerjs/core';
+import { FRange } from '@univerjs/sheets/facade';
+import { FDataValidation } from './f-data-validation';
+/**
+ * Builder for data validation rules.
+ *
+ *     Set the data validation for cell A1 to require a value from B1:B10.
+ *     var rule = FUniver.newDataValidation().requireValueInRange(range).build();
+ *     cell.setDataValidation(rule);
+ */
+export declare class FDataValidationBuilder {
+    private _rule;
+    constructor(rule?: IDataValidationRule);
+    /**
+     * Builds an FDataValidation instance based on the _rule property of the current class
+     *
+     * @returns {FDataValidation} A new instance of the FDataValidation class
+     */
+    build(): FDataValidation;
+    /**
+     * Creates a duplicate of the current DataValidationBuilder object
+     *
+     * @return {FDataValidationBuilder} A new instance of the DataValidationBuilder class
+     */
+    copy(): FDataValidationBuilder;
+    /**
+     * Determines whether invalid data is allowed
+     *
+     * @returns {boolean} True if invalid data is allowed, False otherwise
+     */
+    getAllowInvalid(): boolean;
+    /**
+     * Gets the data validation type of the rule
+     *
+     * @returns {DataValidationType} The data validation type
+     */
+    getCriteriaType(): DataValidationType;
+    /**
+     * Gets the values used for criteria evaluation
+     *
+     * @returns {any[]} An array containing the operator, formula1, and formula2 values
+     */
+    getCriteriaValues(): any[];
+    /**
+     * 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(): string | undefined;
+    /**
+     * 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?: string, uncheckedValue?: string): FDataValidationBuilder;
+    /**
+     * 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: Date): FDataValidationBuilder;
+    /**
+     * 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: Date): FDataValidationBuilder;
+    /**
+     * 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: Date, end: Date): FDataValidationBuilder;
+    /**
+     * 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: Date): FDataValidationBuilder;
+    /**
+     * 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: Date, end: Date): FDataValidationBuilder;
+    /**
+     * 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: Date): FDataValidationBuilder;
+    /**
+     * 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: Date): FDataValidationBuilder;
+    /**
+     * 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: string): FDataValidationBuilder;
+    /**
+     * 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: number, end: number, isInteger?: boolean): FDataValidationBuilder;
+    /**
+     * 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: number, isInteger?: boolean): FDataValidationBuilder;
+    /**
+     * 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: number, isInteger?: boolean): FDataValidationBuilder;
+    /**
+     * 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: number, isInteger?: boolean): FDataValidationBuilder;
+    /**
+     * 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: number, isInteger?: boolean): FDataValidationBuilder;
+    /**
+     * 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: number, isInteger?: boolean): FDataValidationBuilder;
+    /**
+     * 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: number, end: number, isInteger?: boolean): FDataValidationBuilder;
+    /**
+     * 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: number, isInteger?: boolean): FDataValidationBuilder;
+    /**
+     * 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: string[], multiple?: boolean, showDropdown?: boolean): FDataValidationBuilder;
+    /**
+     * 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: FRange, multiple?: boolean, showDropdown?: boolean): FDataValidationBuilder;
+    /**
+     * 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: boolean): FDataValidationBuilder;
+    /**
+     * 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: string): FDataValidationBuilder;
+    /**
+     * 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: DataValidationType, values: [DataValidationOperator, string, string]): 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: Partial<IDataValidationRuleOptions>): this;
+}

package/lib/types/facade/f-data-validation.d.ts

@@ -0,0 +1,88 @@
+import { DataValidationOperator, DataValidationType, IDataValidationRule, IDataValidationRuleOptions } from '@univerjs/core';
+import { FWorksheet, FRange } from '@univerjs/sheets/facade';
+import { FDataValidationBuilder } from './f-data-validation-builder';
+export declare class FDataValidation {
+    rule: IDataValidationRule;
+    private _worksheet;
+    constructor(rule: IDataValidationRule, worksheet?: FWorksheet);
+    /**
+     * Gets whether invalid data is allowed based on the error style value.
+     *
+     * @return true if invalid data is allowed, false otherwise.
+     */
+    getAllowInvalid(): boolean;
+    /**
+     * Gets the data validation type of the rule
+     *
+     * @returns The data validation type
+     */
+    getCriteriaType(): DataValidationType;
+    /**
+     * Gets the values used for criteria evaluation
+     *
+     * @returns An array containing the operator, formula1, and formula2 values
+     */
+    getCriteriaValues(): (string | undefined)[];
+    /**
+     * 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(): string | undefined;
+    /**
+     * 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(): FDataValidationBuilder;
+    /**
+     * Gets whether the data validation rule is applied to the worksheet.
+     *
+     * @returns true if the rule is applied, false otherwise.
+     */
+    getApplied(): boolean;
+    /**
+     * 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(): FRange[];
+    /**
+     * Gets the title of the error message dialog box.
+     *
+     * @returns The title of the error message dialog box.
+     */
+    getUnitId(): string | undefined;
+    /**
+     * Gets the sheetId of the worksheet.
+     *
+     * @returns The sheetId of the worksheet.
+     */
+    getSheetId(): string | undefined;
+    /**
+     * 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: DataValidationType, values: [DataValidationOperator, string, string]): boolean;
+    /**
+     * 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: Partial<IDataValidationRuleOptions>): boolean;
+    /**
+     * 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: FRange[]): boolean;
+    /**
+     * Delete the data validation rule from the worksheet.
+     * @returns true if the rule is deleted successfully, false otherwise.
+     */
+    delete(): boolean;
+}

package/lib/types/facade/f-range.d.ts

@@ -0,0 +1,33 @@
+import { DataValidationStatus, Nullable } from '@univerjs/core';
+import { FRange } from '@univerjs/sheets/facade';
+import { FDataValidation } from './f-data-validation';
+interface IFRangeDataValidationMixin {
+    /**
+     * set a data validation rule to current range
+     * @param rule data validation rule, build by `FUniver.newDataValidation`
+     * @returns current range
+     */
+    setDataValidation(this: FRange, rule: Nullable<FDataValidation>): Promise<FRange>;
+    /**
+     * get first data validation rule in current range
+     * @returns data validation rule
+     */
+    getDataValidation(this: FRange): Nullable<FDataValidation>;
+    /**
+     * get all data validation rules in current range
+     * @returns all data validation rules
+     */
+    getDataValidations(this: FRange): FDataValidation[];
+    getValidatorStatus(): Promise<Promise<DataValidationStatus>[][]>;
+}
+export declare class FRangeDataValidationMixin extends FRange implements IFRangeDataValidationMixin {
+    setDataValidation(rule: Nullable<FDataValidation>): Promise<FRange>;
+    getDataValidation(): Nullable<FDataValidation>;
+    getDataValidations(): FDataValidation[];
+    getValidatorStatus(): Promise<Promise<DataValidationStatus>[][]>;
+}
+declare module '@univerjs/sheets/facade' {
+    interface FRange extends IFRangeDataValidationMixin {
+    }
+}
+export {};

package/lib/types/facade/f-univer.d.ts

@@ -0,0 +1,6 @@
+import { FDataValidationBuilder } from './f-data-validation-builder';
+declare module '@univerjs/core' {
+    namespace FUniver {
+        function newDataValidation(): FDataValidationBuilder;
+    }
+}

package/lib/types/facade/f-workbook.d.ts

@@ -0,0 +1,64 @@
+import { IRuleChange } from '@univerjs/data-validation';
+import { IAddSheetDataValidationCommandParams, IDataValidationResCache, IRemoveSheetAllDataValidationCommandParams, IRemoveSheetDataValidationCommandParams, IUpdateSheetDataValidationOptionsCommandParams, IUpdateSheetDataValidationRangeCommandParams, IUpdateSheetDataValidationSettingCommandParams, IValidStatusChange } from '@univerjs/sheets-data-validation';
+import { IDisposable, IExecutionOptions, Nullable, ObjectMatrix } from '@univerjs/core';
+import { FWorkbook } from '@univerjs/sheets/facade';
+interface IFWorkbookDataValidationMixin {
+    /**
+     * get data validation validator status for current workbook
+     * @returns matrix of validator status
+     */
+    getValidatorStatus(this: FWorkbook): Promise<Record<string, ObjectMatrix<Nullable<IDataValidationResCache>>>>;
+    /**
+     * 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: (ruleChange: IRuleChange) => void): IDisposable;
+    /**
+     * 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: (statusChange: IValidStatusChange) => void): IDisposable;
+    /**
+     * 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(this: FWorkbook, callback: (params: IAddSheetDataValidationCommandParams, options: IExecutionOptions | undefined) => void | false): IDisposable;
+    /**
+     * The onBeforeUpdateDataValidationCriteria event is fired before the data validation rule is updated.
+     * @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
+     */
+    onBeforeUpdateDataValidationCriteria(this: FWorkbook, callback: (params: IUpdateSheetDataValidationSettingCommandParams, options: IExecutionOptions | undefined) => void | false): IDisposable;
+    /**
+     * The onBeforeUpdateDataValidationRange event is fired before the data validation rule is updated.
+     * @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
+     */
+    onBeforeUpdateDataValidationRange(this: FWorkbook, callback: (params: IUpdateSheetDataValidationRangeCommandParams, options: IExecutionOptions | undefined) => void | false): IDisposable;
+    /**
+     * The onBeforeUpdateDataValidationOptions event is fired before the data validation rule is updated.
+     * @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
+     */
+    onBeforeUpdateDataValidationOptions(this: FWorkbook, callback: (params: IUpdateSheetDataValidationOptionsCommandParams, options: IExecutionOptions | undefined) => void | false): IDisposable;
+    /**
+     * The onBeforeDeleteDataValidation event is fired before the data validation rule is deleted.
+     * @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
+     */
+    onBeforeDeleteDataValidation(this: FWorkbook, callback: (params: IRemoveSheetDataValidationCommandParams, options: IExecutionOptions | undefined) => void | false): IDisposable;
+    /**
+     * The onBeforeDeleteAllDataValidation event is fired before delete all data validation rules.
+     * @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
+     */
+    onBeforeDeleteAllDataValidation(this: FWorkbook, callback: (params: IRemoveSheetAllDataValidationCommandParams, options: IExecutionOptions | undefined) => void | false): IDisposable;
+}
+declare module '@univerjs/sheets/facade' {
+    interface FWorkbook extends IFWorkbookDataValidationMixin {
+    }
+}
+export {};

package/lib/types/facade/f-worksheet.d.ts

@@ -0,0 +1,20 @@
+import { Nullable, ObjectMatrix } from '@univerjs/core';
+import { IDataValidationResCache } from '@univerjs/sheets-data-validation';
+import { FDataValidation } from './f-data-validation';
+interface IFWorksheetDataValidationMixin {
+    /**
+     * get all data validation rules in current sheet
+     * @returns all data validation rules
+     */
+    getDataValidations(): FDataValidation[];
+    /**
+     * get data validation validator status for current sheet
+     * @returns matrix of validator status
+     */
+    getValidatorStatus(): Promise<ObjectMatrix<Nullable<IDataValidationResCache>>>;
+}
+declare module '@univerjs/sheets/facade' {
+    interface FWorksheet extends IFWorksheetDataValidationMixin {
+    }
+}
+export {};

package/lib/types/facade/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import './f-range';
+import './f-univer';
+import './f-workbook';
+import './f-worksheet';
+export { FDataValidation } from './f-data-validation';
+export { FDataValidationBuilder } from './f-data-validation-builder';

package/lib/types/models/sheet-data-validation-model.d.ts

@@ -1,4 +1,4 @@
-import { ISheetDataValidationRule, DataValidationStatus, DataValidationType, Disposable, ICommandService, IUniverInstanceService } from '@univerjs/core';
+import { DataValidationType, ISheetDataValidationRule, DataValidationStatus, Disposable, ICommandService, IUniverInstanceService } from '@univerjs/core';
 import { IRuleChange, DataValidationModel, DataValidatorRegistryService } from '@univerjs/data-validation';
 import { ISheetLocation } from '@univerjs/sheets';
 import { DataValidationCacheService } from '../services/dv-cache.service';
@@ -38,7 +38,6 @@ export declare class SheetDataValidationModel extends Disposable {
     getRuleIdByLocation(unitId: string, subUnitId: string, row: number, col: number): string | undefined;
     getRuleByLocation(unitId: string, subUnitId: string, row: number, col: number): ISheetDataValidationRule | undefined;
     validator(rule: ISheetDataValidationRule, pos: ISheetLocation, _onCompete?: (status: DataValidationStatus, changed: boolean) => void): DataValidationStatus;
-    getRuleErrorMsg(unitId: string, subUnitId: string, ruleId: string): string;
     getRuleObjectMatrix(unitId: string, subUnitId: string): RuleMatrix;
     getRuleById(unitId: string, subUnitId: string, ruleId: string): ISheetDataValidationRule | undefined;
     getRuleIndex(unitId: string, subUnitId: string, ruleId: string): number;

package/lib/types/services/dv-custom-formula.service.d.ts

@@ -1,41 +1,34 @@
-import { IRange, ISheetDataValidationRule, Disposable, Injector, IUniverInstanceService } from '@univerjs/core';
+import { ISheetDataValidationRule, Disposable, IUniverInstanceService } from '@univerjs/core';
 import { DataValidationModel } from '@univerjs/data-validation';
-import { LexerTreeBuilder } from '@univerjs/engine-formula';
 import { RegisterOtherFormulaService } from '@univerjs/sheets-formula';
 import { DataValidationCacheService } from './dv-cache.service';
 interface IFormulaData {
     formula: string;
     originRow: number;
     originCol: number;
-    isTransformable: boolean;
-    formulaId?: string;
+    formulaId: string;
 }
 export declare class DataValidationCustomFormulaService extends Disposable {
     private readonly _instanceSrv;
     private _registerOtherFormulaService;
-    private _lexerTreeBuilder;
     private readonly _dataValidationModel;
     private readonly _dataValidationCacheService;
-    private readonly _injector;
-    private _formulaMap;
     /**
      * Map of origin formula of rule
      */
     private _ruleFormulaMap;
-    /**
-     * reflect of formulaId to cell, only store transformable formula
-     */
-    private _formulaCellMap;
-    constructor(_instanceSrv: IUniverInstanceService, _registerOtherFormulaService: RegisterOtherFormulaService, _lexerTreeBuilder: LexerTreeBuilder, _dataValidationModel: DataValidationModel, _dataValidationCacheService: DataValidationCacheService, _injector: Injector);
+    private _ruleFormulaMap2;
+    constructor(_instanceSrv: IUniverInstanceService, _registerOtherFormulaService: RegisterOtherFormulaService, _dataValidationModel: DataValidationModel, _dataValidationCacheService: DataValidationCacheService);
     private _initFormulaResultHandler;
     private _ensureMaps;
     private _registerFormula;
     deleteByRuleId(unitId: string, subUnitId: string, ruleId: string): void;
     private _addFormulaByRange;
     addRule(unitId: string, subUnitId: string, rule: ISheetDataValidationRule): void;
-    updateRuleRanges(unitId: string, subUnitId: string, ruleId: string, oldRanges: IRange[], newRanges: IRange[]): void;
-    updateRuleFormula(unitId: string, subUnitId: string, ruleId: string, ranges: IRange[], formula: string): void;
-    getCellFormulaValue(unitId: string, subUnitId: string, row: number, col: number): Promise<import('@univerjs/core').Nullable<import('@univerjs/sheets-formula').IOtherFormulaResult>>;
+    getCellFormulaValue(unitId: string, subUnitId: string, ruleId: string, row: number, column: number): Promise<import('@univerjs/core').Nullable<import('@univerjs/core').ICellData>>;
+    getCellFormula2Value(unitId: string, subUnitId: string, ruleId: string, row: number, column: number): Promise<import('@univerjs/core').Nullable<import('@univerjs/core').ICellData>>;
+    getCellFormulaValueSync(unitId: string, subUnitId: string, ruleId: string, row: number, column: number): import('@univerjs/core').Nullable<import('@univerjs/core').ICellData>;
+    getCellFormula2ValueSync(unitId: string, subUnitId: string, ruleId: string, row: number, column: number): import('@univerjs/core').Nullable<import('@univerjs/core').ICellData>;
     getRuleFormulaInfo(unitId: string, subUnitId: string, ruleId: string): IFormulaData | undefined;
 }
 export {};

package/lib/types/services/dv-formula.service.d.ts

@@ -1,4 +1,4 @@
-import { Nullable, Disposable, IUniverInstanceService } from '@univerjs/core';
+import { ISheetDataValidationRule, Nullable, Disposable, IUniverInstanceService } from '@univerjs/core';
 import { IFormulaInfo, IOtherFormulaResult, RegisterOtherFormulaService } from '@univerjs/sheets-formula';
 import { DataValidationModel } from '@univerjs/data-validation';
 import { DataValidationCacheService } from './dv-cache.service';
@@ -11,9 +11,9 @@ export declare class DataValidationFormulaService extends Disposable {
     constructor(_instanceService: IUniverInstanceService, _registerOtherFormulaService: RegisterOtherFormulaService, _dataValidationCacheService: DataValidationCacheService, _dataValidationModel: DataValidationModel);
     private _initFormulaResultHandler;
     private _ensureRuleFormulaMap;
-    addRule(unitId: string, subUnitId: string, ruleId: string, formula1: string | undefined, formula2: string | undefined): void;
+    private _registerSingleFormula;
+    addRule(unitId: string, subUnitId: string, rule: ISheetDataValidationRule): void;
     removeRule(unitId: string, subUnitId: string, ruleId: string): void;
-    updateRuleFormulaText(unitId: string, subUnitId: string, ruleId: string, formula1: string | undefined, formula2: string | undefined): void;
     getRuleFormulaResult(unitId: string, subUnitId: string, ruleId: string): Promise<Nullable<[Nullable<IOtherFormulaResult>, Nullable<IOtherFormulaResult>]>>;
     getRuleFormulaResultSync(unitId: string, subUnitId: string, ruleId: string): Nullable<IOtherFormulaResult>[] | undefined;
     getRuleFormulaInfo(unitId: string, subUnitId: string, ruleId: string): [IFormulaInfo | undefined, IFormulaInfo | undefined] | undefined;

package/lib/types/utils/formula.d.ts

@@ -1,4 +1,8 @@
-import { ICellData, Nullable } from '@univerjs/core';
+import { DataValidationType, ICellData, Nullable } from '@univerjs/core';
 export declare function getFormulaResult(result: Nullable<Nullable<ICellData>[][]>): Nullable<import('@univerjs/core').CellValue>;
 export declare function getFormulaCellData(result: Nullable<Nullable<ICellData>[][]>): Nullable<ICellData>;
 export declare function isLegalFormulaResult(res: string): boolean;
+/**
+ * Judge if the data-validation's formula need to be offseted by ranges
+ */
+export declare function isCustomFormulaType(type: DataValidationType): type is DataValidationType.CUSTOM | DataValidationType.NONE | DataValidationType.TEXT_LENGTH | DataValidationType.DATE | DataValidationType.TIME | DataValidationType.WHOLE | DataValidationType.DECIMAL;

package/lib/types/validators/checkbox-validator.d.ts

@@ -16,18 +16,15 @@ export declare class CheckboxValidator extends BaseDataValidator {
     skipDefaultFontRender: (rule: ISheetDataValidationRule, cellValue: Nullable<CellValue>, pos: {
         unitId: string;
         subUnitId: string;
+        row: number;
+        column: number;
     }) => boolean;
     validatorFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): IFormulaValidResult;
     parseFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): Promise<ICheckboxFormulaResult>;
     getExtraStyle(rule: IDataValidationRule, value: Nullable<CellValue>): {
         tb: WrapStrategy;
     };
-    parseFormulaSync(rule: IDataValidationRule, unitId: string, subUnitId: string): {
-        formula1: Nullable<CellValue>;
-        formula2: Nullable<CellValue>;
-        originFormula1: Nullable<CellValue>;
-        originFormula2: Nullable<CellValue>;
-    };
+    parseFormulaSync(rule: IDataValidationRule, unitId: string, subUnitId: string): ICheckboxFormulaResult;
     isValidType(cellInfo: IValidatorCellInfo<CellValue>, formula: IFormulaResult, rule: IDataValidationRule): Promise<boolean>;
     generateRuleErrorMessage(rule: IDataValidationRuleBase): string;
 }

package/lib/types/validators/const.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare const FORMULA1 = "{FORMULA1}";
+export declare const FORMULA2 = "{FORMULA2}";

package/lib/types/validators/custom-validator.d.ts

@@ -5,7 +5,7 @@ export declare class CustomFormulaValidator extends BaseDataValidator {
     title: string;
     operators: DataValidationOperator[];
     scopes: string | string[];
-    private _customFormulaService;
+    private readonly _customFormulaService;
     validatorFormula(rule: IDataValidationRule, unitId: string, subUnitId: string): IFormulaValidResult;
     parseFormula(_rule: IDataValidationRule, _unitId: string, _subUnitId: string): Promise<IFormulaResult>;
     isValidType(cellInfo: IValidatorCellInfo<CellValue>, _formula: IFormulaResult, _rule: IDataValidationRule): Promise<boolean>;