@univerjs/sheets-conditional-formatting 0.1.5

package/lib/types/locale/zh-CN.d.ts

@@ -0,0 +1,169 @@
+/**
+ * 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.
+ */
+declare const locale: {
+    sheet: {
+        cf: {
+            title: string;
+            menu: {
+                manageConditionalFormatting: string;
+                createConditionalFormatting: string;
+                clearRangeRules: string;
+                clearWorkSheetRules: string;
+            };
+            form: {
+                lessThan: string;
+                lessThanOrEqual: string;
+                greaterThan: string;
+                greaterThanOrEqual: string;
+                rangeSelector: string;
+            };
+            iconSet: {
+                direction: string;
+                shape: string;
+                mark: string;
+                rank: string;
+                rule: string;
+                icon: string;
+                type: string;
+                value: string;
+                reverseIconOrder: string;
+                and: string;
+                when: string;
+                onlyShowIcon: string;
+            };
+            symbol: {
+                greaterThan: string;
+                greaterThanOrEqual: string;
+                lessThan: string;
+                lessThanOrEqual: string;
+            };
+            panel: {
+                createRule: string;
+                clear: string;
+                range: string;
+                styleType: string;
+                submit: string;
+                cancel: string;
+                rankAndAverage: string;
+                styleRule: string;
+                isNotBottom: string;
+                isBottom: string;
+                greaterThanAverage: string;
+                lessThanAverage: string;
+                medianValue: string;
+                fillType: string;
+                pureColor: string;
+                gradient: string;
+                colorSet: string;
+                positive: string;
+                native: string;
+                workSheet: string;
+                selectedRange: string;
+                managerRuleSelect: string;
+            };
+            preview: {
+                describe: {
+                    beginsWith: string;
+                    endsWith: string;
+                    containsText: string;
+                    notContainsText: string;
+                    equal: string;
+                    notEqual: string;
+                    containsBlanks: string;
+                    notContainsBlanks: string;
+                    containsErrors: string;
+                    notContainsErrors: string;
+                    greaterThan: string;
+                    greaterThanOrEqual: string;
+                    lessThan: string;
+                    lessThanOrEqual: string;
+                    notBetween: string;
+                    between: string;
+                    yesterday: string;
+                    tomorrow: string;
+                    last7Days: string;
+                    thisMonth: string;
+                    lastMonth: string;
+                    nextMonth: string;
+                    thisWeek: string;
+                    lastWeek: string;
+                    nextWeek: string;
+                    today: string;
+                    topN: string;
+                    bottomN: string;
+                    topNPercent: string;
+                    bottomNPercent: string;
+                };
+            };
+            operator: {
+                beginsWith: string;
+                endsWith: string;
+                containsText: string;
+                notContainsText: string;
+                equal: string;
+                notEqual: string;
+                containsBlanks: string;
+                notContainsBlanks: string;
+                containsErrors: string;
+                notContainsErrors: string;
+                greaterThan: string;
+                greaterThanOrEqual: string;
+                lessThan: string;
+                lessThanOrEqual: string;
+                notBetween: string;
+                between: string;
+                yesterday: string;
+                tomorrow: string;
+                last7Days: string;
+                thisMonth: string;
+                lastMonth: string;
+                nextMonth: string;
+                thisWeek: string;
+                lastWeek: string;
+                nextWeek: string;
+                today: string;
+            };
+            ruleType: {
+                highlightCell: string;
+                dataBar: string;
+                colorScale: string;
+                formula: string;
+                iconSet: string;
+                duplicateValues: string;
+                uniqueValues: string;
+            };
+            subRuleType: {
+                uniqueValues: string;
+                duplicateValues: string;
+                rank: string;
+                text: string;
+                timePeriod: string;
+                number: string;
+                average: string;
+            };
+            valueType: {
+                num: string;
+                min: string;
+                max: string;
+                percent: string;
+                percentile: string;
+                formula: string;
+                none: string;
+            };
+        };
+    };
+};
+export default locale;

package/lib/types/menu/manage-rule.d.ts

@@ -0,0 +1,4 @@
+import { IAccessor } from '@wendellhu/redi';
+import { ComponentManager, IMenuSelectorItem } from '@univerjs/ui';
+
+export declare const FactoryManageConditionalFormattingRule: (componentManager: ComponentManager) => (_accessor: IAccessor) => IMenuSelectorItem<import('@univerjs/ui/services/menu/menu.js').MenuItemDefaultValueType, undefined>;

package/lib/types/models/conditional-formatting-rule-model.d.ts

@@ -0,0 +1,32 @@
+import { ConditionalFormattingViewModel } from './conditional-formatting-view-model';
+import { IConditionFormattingRule } from './type';
+import { Injector } from '@wendellhu/redi';
+
+type RuleOperatorType = 'delete' | 'set' | 'add' | 'sort';
+export declare class ConditionalFormattingRuleModel {
+    private _conditionalFormattingViewModel;
+    private _injector;
+    private _model;
+    private _ruleChange$;
+    $ruleChange: import('rxjs').Observable<{
+        rule: IConditionFormattingRule;
+        unitId: string;
+        subUnitId: string;
+        type: RuleOperatorType;
+    }>;
+    constructor(_conditionalFormattingViewModel: ConditionalFormattingViewModel, _injector: Injector);
+    private _ensureList;
+    getRule(unitId: string, subUnitId: string, cfId?: string): IConditionFormattingRule<import('./type').IConditionalFormattingRuleConfig> | null | undefined;
+    getUnitRules(unitId: string): Map<string, IConditionFormattingRule<import('./type').IConditionalFormattingRuleConfig>[]> | null;
+    getSubunitRules(unitId: string, subUnitId: string): IConditionFormattingRule<import('./type').IConditionalFormattingRuleConfig>[] | null;
+    deleteRule(unitId: string, subUnitId: string, cfId: string): void;
+    setRule(unitId: string, subUnitId: string, rule: IConditionFormattingRule): void;
+    addRule(unitId: string, subUnitId: string, rule: IConditionFormattingRule): void;
+    /**
+     * example [1,2,3,4,5,6],if you move behind 5 to 2, then cfId=5,targetId=2.
+     * if targetId does not exist, it defaults to top
+     */
+    moveRulePriority(unitId: string, subUnitId: string, cfId: string, targetCfId: string): void;
+    createCfId(unitId: string, subUnitId: string): string;
+}
+export {};

package/lib/types/models/conditional-formatting-view-model.d.ts

@@ -0,0 +1,29 @@
+import { IConditionFormattingRule, IHighlightCell } from './type';
+import { IDataBarRenderParams } from '../render/type';
+import { ObjectMatrix } from '@univerjs/core';
+
+interface ICellItem {
+    cfList: {
+        cfId: string;
+        ruleCache?: IHighlightCell['style'] | IDataBarRenderParams;
+        isDirty: boolean;
+    }[];
+}
+export declare class ConditionalFormattingViewModel {
+    private _model;
+    private _markDirty$;
+    markDirty$: import('rxjs').Observable<{
+        rule: IConditionFormattingRule;
+        unitId: string;
+        subUnitId: string;
+    }>;
+    private _ensureMatrix;
+    getMatrix(unitId: string, subUnitId: string): ObjectMatrix<ICellItem> | undefined;
+    getCellCf(unitId: string, subUnitId: string, row: number, col: number, matrix?: ObjectMatrix<ICellItem>): ICellItem | null;
+    setCellCfRuleCache(unitId: string, subUnitId: string, row: number, col: number, cfId: string, value: any): void;
+    deleteCellCf(unitId: string, subUnitId: string, row: number, col: number, cfId: string, matrix?: ObjectMatrix<ICellItem>): void;
+    pushCellCf(unitId: string, subUnitId: string, row: number, col: number, cfId: string): void;
+    sortCellCf(unitId: string, subUnitId: string, row: number, col: number, cfPriorityMap: Map<string, number>): void;
+    markRuleDirty(unitId: string, subUnitId: string, rule: IConditionFormattingRule, row?: number, col?: number): void;
+}
+export {};

package/lib/types/models/icon-map.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 type IIconItem = string;
+export declare const iconGroup: {
+    title: string;
+    group: {
+        name: string;
+        list: string[];
+    }[];
+}[];
+export declare const iconMap: Record<string, string[]>;
+export type IIconType = keyof typeof iconMap;
+export declare const EMPTY_ICON_TYPE = "EMPTY_ICON_TYPE";

package/lib/types/models/type.d.ts

@@ -0,0 +1,91 @@
+import { IIconType } from './icon-map';
+import { CFNumberOperator, CFRuleType, CFSubRuleType, CFTextOperator, CFTimePeriodOperator, CFValueType } from '../base/const';
+import { IRange, IStyleBase } from '@univerjs/core';
+
+export interface IBaseCfRule {
+    type: string;
+}
+export interface IHighlightCell extends IBaseCfRule {
+    style: IStyleBase;
+    type: CFRuleType.highlightCell;
+    subType: CFSubRuleType;
+}
+export interface IValueConfig {
+    type: CFValueType;
+    value?: number | string;
+}
+export interface IUniqueValuesHighlightCell extends IHighlightCell {
+    subType: CFSubRuleType.uniqueValues;
+}
+export interface IDuplicateValuesHighlightCell extends IHighlightCell {
+    subType: CFSubRuleType.duplicateValues;
+}
+export interface IRankHighlightCell extends IHighlightCell {
+    subType: CFSubRuleType.rank;
+    isBottom: boolean;
+    isPercent: boolean;
+    value: number;
+}
+export interface ITextHighlightCell extends IHighlightCell {
+    subType: CFSubRuleType.text;
+    operator: CFTextOperator;
+    value?: string;
+}
+export interface ITimePeriodHighlightCell extends IHighlightCell {
+    subType: CFSubRuleType.timePeriod;
+    operator: CFTimePeriodOperator;
+}
+export interface IFormulaHighlightCell extends IHighlightCell {
+    subType: CFSubRuleType.formula;
+    value: string;
+}
+export type INumberHighlightCell = ({
+    subType: CFSubRuleType.number;
+    operator: CFNumberOperator.between | CFNumberOperator.notBetween;
+    value: [number, number];
+} & IHighlightCell) | ({
+    subType: CFSubRuleType.number;
+    operator: CFNumberOperator.equal | CFNumberOperator.notEqual | CFNumberOperator.greaterThan | CFNumberOperator.greaterThanOrEqual | CFNumberOperator.lessThanOrEqual | CFNumberOperator.lessThan;
+    value?: number;
+} & IHighlightCell);
+export interface IAverageHighlightCell extends IHighlightCell {
+    subType: CFSubRuleType.average;
+    operator: CFNumberOperator.greaterThan | CFNumberOperator.greaterThanOrEqual | CFNumberOperator.lessThan | CFNumberOperator.lessThanOrEqual | CFNumberOperator.equal | CFNumberOperator.notEqual;
+}
+export interface IDataBar extends IBaseCfRule {
+    type: CFRuleType.dataBar;
+    config: {
+        min: IValueConfig;
+        max: IValueConfig;
+        isGradient: boolean;
+        positiveColor: string;
+        nativeColor: string;
+    };
+}
+export interface IColorScale extends IBaseCfRule {
+    type: CFRuleType.colorScale;
+    config: {
+        index: number;
+        color: string;
+        value: IValueConfig;
+    }[];
+}
+export interface IIconSet extends IBaseCfRule {
+    type: CFRuleType.iconSet;
+    isShowValue: boolean;
+    config: {
+        operator: CFNumberOperator;
+        value: IValueConfig;
+        iconType: IIconType;
+        iconId: string;
+    }[];
+}
+export type IConditionalFormattingRuleConfig = IColorScale | IDataBar | IUniqueValuesHighlightCell | IDuplicateValuesHighlightCell | IRankHighlightCell | ITextHighlightCell | ITimePeriodHighlightCell | INumberHighlightCell | IAverageHighlightCell | IFormulaHighlightCell | IIconSet;
+export interface IConditionFormattingRule<C = IConditionalFormattingRuleConfig> {
+    ranges: IRange[];
+    cfId: string;
+    stopIfTrue: boolean;
+    rule: C;
+}
+export type IRuleModel = Map<string, Map<string, IConditionFormattingRule[]>>;
+export type IRuleModelJson = Record<string, Record<string, IConditionFormattingRule[]>>;

package/lib/types/plugin.d.ts

@@ -0,0 +1,13 @@
+import { Injector } from '@wendellhu/redi';
+import { ICommandService, Plugin, PluginType } from '@univerjs/core';
+
+export declare class SheetsConditionalFormattingPlugin extends Plugin {
+    readonly _injector: Injector;
+    private _commandService;
+    static type: PluginType;
+    static commandList: import('@univerjs/core').ICommand<object, boolean>[];
+    static mutationList: (import('@univerjs/core').IMutation<import("./commands/mutations/add-conditional-rule.mutation").IAddConditionalRuleMutationParams, boolean> | import('@univerjs/core').IMutation<import("./commands/mutations/delete-conditional-rule.mutation").IDeleteConditionalRuleMutationParams, boolean> | import('@univerjs/core').IMutation<import("./commands/mutations/formula-mark-dirty.mutation").IConditionalFormattingFormulaMarkDirtyParams, boolean>)[];
+    constructor(_config: unknown, _injector: Injector, _commandService: ICommandService);
+    onStarting(): void;
+    _initCommand(): void;
+}

package/lib/types/render/data-bar.render.d.ts

@@ -0,0 +1,13 @@
+import { SpreadsheetSkeleton, UniverRenderingContext, SheetExtension } from '@univerjs/engine-render';
+import { IRange, IScale } from '@univerjs/core';
+
+export declare const dataBarUKey = "sheet-conditional-rule-data-bar";
+export declare class DataBar extends SheetExtension {
+    private _paddingRightAndLeft;
+    private _paddingTopAndBottom;
+    uKey: string;
+    Z_INDEX: number;
+    _radius: number;
+    draw(ctx: UniverRenderingContext, parentScale: IScale, spreadsheetSkeleton: SpreadsheetSkeleton, diffRanges?: IRange[]): false | undefined;
+    private _drawRectWithRoundedCorner;
+}

package/lib/types/render/icon.render.d.ts

@@ -0,0 +1,18 @@
+import { SpreadsheetSkeleton, UniverRenderingContext, SheetExtension } from '@univerjs/engine-render';
+import { IRange, IScale } from '@univerjs/core';
+
+export declare const IconUKey = "sheet-conditional-rule-icon";
+export declare const DEFAULT_WIDTH = 15;
+export declare const DEFAULT_PADDING = 2;
+export declare class ConditionalFormattingIcon extends SheetExtension {
+    private _paddingRightAndLeft;
+    private _width;
+    private _imageMap;
+    uKey: string;
+    Z_INDEX: number;
+    _radius: number;
+    constructor();
+    draw(ctx: UniverRenderingContext, parentScale: IScale, spreadsheetSkeleton: SpreadsheetSkeleton, diffRanges?: IRange[]): false | undefined;
+    private _init;
+    private _createKey;
+}

package/lib/types/render/type.d.ts

@@ -0,0 +1,22 @@
+import { IIconType } from '../models/icon-map';
+import { ICellData } from '@univerjs/core';
+
+export interface IDataBarRenderParams {
+    color: string;
+    value: number;
+    startPoint: number;
+    isGradient: boolean;
+}
+export interface IDataBarCellData extends ICellData {
+    dataBar?: IDataBarRenderParams;
+}
+export interface IIconSetRenderParams {
+    iconId: string;
+    iconType: IIconType;
+    isShowValue: boolean;
+}
+export interface IIconSetCellData extends ICellData {
+    iconSet?: IIconSetRenderParams;
+    _originV?: ICellData['v'];
+}
+export type IConditionalFormattingCellData = IDataBarCellData & IIconSetCellData;

package/lib/types/services/__test__/cf.service.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 {};

package/lib/types/services/__test__/test.util.d.ts

@@ -0,0 +1,24 @@
+import { ConditionalFormattingViewModel } from '../../models/conditional-formatting-view-model';
+import { ConditionalFormattingRuleModel } from '../../models/conditional-formatting-rule-model';
+import { ConditionalFormattingService } from '../conditional-formatting.service';
+import { Dependency } from '@wendellhu/redi';
+import { ICommandService, Univer } from '@univerjs/core';
+
+export declare const createTestBed: (dependencies?: Dependency[]) => {
+    univer: Univer;
+    get: {
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, lookUp?: import('@wendellhu/redi').LookUp | undefined): T;
+        <T_1>(id: import('@wendellhu/redi').DependencyIdentifier<T_1>, quantity: import("@wendellhu/redi").Quantity.MANY, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_1[];
+        <T_2>(id: import('@wendellhu/redi').DependencyIdentifier<T_2>, quantity: import("@wendellhu/redi").Quantity.OPTIONAL, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_2 | null;
+        <T_3>(id: import('@wendellhu/redi').DependencyIdentifier<T_3>, quantity: import("@wendellhu/redi").Quantity.REQUIRED, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_3;
+        <T_4>(id: import('@wendellhu/redi').DependencyIdentifier<T_4>, quantity?: import('@wendellhu/redi').Quantity | undefined, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_4 | T_4[] | null;
+        <T_5>(id: import('@wendellhu/redi').DependencyIdentifier<T_5>, quantityOrLookup?: import('@wendellhu/redi').Quantity | import('@wendellhu/redi').LookUp | undefined, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_5 | T_5[] | null;
+    };
+    workbook: import('@univerjs/core').Workbook;
+    unitId: string;
+    subUnitId: string;
+    commandService: ICommandService;
+    getConditionalFormattingRuleModel: () => ConditionalFormattingRuleModel;
+    getConditionalFormattingViewModel: () => ConditionalFormattingViewModel;
+    getConditionalFormattingService: () => ConditionalFormattingService;
+};

package/lib/types/services/calculate-unit/color-scale.d.ts

@@ -0,0 +1,3 @@
+import { ICalculateUnit } from './type';
+
+export declare const colorScaleCellCalculateUnit: ICalculateUnit;

package/lib/types/services/calculate-unit/data-bar.d.ts

@@ -0,0 +1,3 @@
+import { ICalculateUnit } from './type';
+
+export declare const dataBarCellCalculateUnit: ICalculateUnit;

package/lib/types/services/calculate-unit/highlight-cell.d.ts

@@ -0,0 +1,3 @@
+import { ICalculateUnit } from './type';
+
+export declare const highlightCellCalculateUnit: ICalculateUnit;

package/lib/types/services/calculate-unit/icon-set.d.ts

@@ -0,0 +1,3 @@
+import { ICalculateUnit } from './type';
+
+export declare const iconSetCalculateUnit: ICalculateUnit;

package/lib/types/services/calculate-unit/type.d.ts

@@ -0,0 +1,17 @@
+import { IConditionFormattingRule } from '../../models/type';
+import { CFRuleType } from '../../base/const';
+import { ObjectMatrix, Workbook, Worksheet } from '@univerjs/core';
+import { IAccessor } from '@wendellhu/redi';
+
+export interface IContext {
+    accessor: IAccessor;
+    unitId: string;
+    subUnitId: string;
+    workbook: Workbook;
+    worksheet: Worksheet;
+}
+export interface ICalculateUnit<R = any> {
+    type: CFRuleType;
+    handle: (rule: IConditionFormattingRule, context: IContext) => Promise<ObjectMatrix<R>>;
+}
+export declare const EMPTY_STYLE: unknown;

package/lib/types/services/calculate-unit/utils.d.ts

@@ -0,0 +1,33 @@
+import { IContext } from './type';
+import { FormulaResultStatus } from '../conditional-formatting-formula.service';
+import { CFNumberOperator } from '../../base/const';
+import { IConditionFormattingRule, IValueConfig } from '../../models/type';
+import { ICellData, ColorKit, ObjectMatrix } from '@univerjs/core';
+
+export declare function isFloatsEqual(a: number, b: number): boolean;
+export declare const isNullable: (v: any) => boolean;
+export declare const getCellValue: (cell?: ICellData) => import('@univerjs/core').Nullable<import("@univerjs/core").CellValue>;
+export declare function toYMD_1900(ord: number, leap1900?: boolean): number[];
+export declare const serialTimeToTimestamp: (value: number) => number;
+export declare const getValueByType: (value: IValueConfig, matrix: ObjectMatrix<number>, context: IContext & {
+    cfId: string;
+}) => {
+    status: FormulaResultStatus;
+    result?: undefined;
+} | {
+    result: string | number | boolean | undefined;
+    status: FormulaResultStatus;
+};
+export declare const getCacheStyleMatrix: <S = any>(unitId: string, subUnitId: string, rule: IConditionFormattingRule, context: IContext) => ObjectMatrix<S>;
+export declare const compareWithNumber: (config: {
+    operator: CFNumberOperator;
+    value: number | [
+        number,
+        number
+    ];
+}, v: number) => boolean | undefined;
+export declare const getOppositeOperator: (operator: CFNumberOperator) => CFNumberOperator;
+export declare const getColorScaleFromValue: (colorList: {
+    color: ColorKit;
+    value: number;
+}[], value: number) => string | undefined;

package/lib/types/services/conditional-formatting-formula.service.d.ts

@@ -0,0 +1,57 @@
+import { ConditionalFormattingRuleModel } from '../models/conditional-formatting-rule-model';
+import { ConditionalFormattingViewModel } from '../models/conditional-formatting-view-model';
+import { IActiveDirtyManagerService } from '@univerjs/engine-formula';
+import { Injector } from '@wendellhu/redi';
+import { ObjectMatrix, Disposable, ICommandService, RefAlias } from '@univerjs/core';
+
+type IFormulaItem = {
+    formulaText: string;
+    cfId: string;
+    result?: boolean | number | string;
+    status: FormulaResultStatus;
+    count: number;
+    formulaId: string;
+};
+export declare enum FormulaResultStatus {
+    NOT_REGISTER = 1,
+    SUCCESS = 2,
+    WAIT = 3,
+    ERROR = 4
+}
+export declare class ConditionalFormattingFormulaService extends Disposable {
+    private _commandService;
+    private _injector;
+    private _activeDirtyManagerService;
+    private _conditionalFormattingViewModel;
+    private _conditionalFormattingRuleModel;
+    private _formulaMap;
+    private _cache;
+    private _formulaChange$;
+    formulaChange$: import('rxjs').Observable<{
+        unitId: string;
+        subUnitId: string;
+        cfId: string;
+        formulaText: string;
+        formulaId: string;
+    }>;
+    constructor(_commandService: ICommandService, _injector: Injector, _activeDirtyManagerService: IActiveDirtyManagerService, _conditionalFormattingViewModel: ConditionalFormattingViewModel, _conditionalFormattingRuleModel: ConditionalFormattingRuleModel);
+    private _initCache;
+    private _initRuleChange;
+    private _initFormulaCalculationResultChange;
+    private _ensureSubunitFormulaMap;
+    private _ensureCacheMap;
+    private _deleteCache;
+    getCache(unitId: string, subUnitId: string, cfId: string): ObjectMatrix<unknown> | undefined;
+    getSubUnitFormulaMap(unitId: string, subUnitId: string): RefAlias<IFormulaItem, "formulaId" | "formulaText"> | undefined;
+    registerFormula(unitId: string, subUnitId: string, cfId: string, formulaText: string): void;
+    private _removeFormulaByCfId;
+    getFormulaResult(unitId: string, subUnitId: string, formulaText: string): {
+        status: FormulaResultStatus;
+        result?: undefined;
+    } | {
+        result: string | number | boolean | undefined;
+        status: FormulaResultStatus;
+    };
+    _createFormulaId(unitId: string, subUnitId: string): string;
+}
+export {};

package/lib/types/services/conditional-formatting.service.d.ts

@@ -0,0 +1,49 @@
+import { IDataBarCellData, IIconSetCellData } from '../render/type';
+import { ConditionalFormattingViewModel } from '../models/conditional-formatting-view-model';
+import { ConditionalFormattingRuleModel } from '../models/conditional-formatting-rule-model';
+import { Injector } from '@wendellhu/redi';
+import { SheetInterceptorService } from '@univerjs/sheets';
+import { Disposable, ICommandService, InterceptorManager, IResourceManagerService, IUniverInstanceService, ObjectMatrix } from '@univerjs/core';
+
+type ComputeStatus = 'computing' | 'end' | 'error';
+export declare class ConditionalFormattingService extends Disposable {
+    private _conditionalFormattingRuleModel;
+    private _injector;
+    private _conditionalFormattingViewModel;
+    private _univerInstanceService;
+    private _resourceManagerService;
+    private _sheetInterceptorService;
+    private _commandService;
+    private _ruleCacheMap;
+    private _ruleComputeStatus$;
+    ruleComputeStatus$: import('rxjs').Observable<{
+        status: ComputeStatus;
+        result?: ObjectMatrix<any> | undefined;
+        unitId: string;
+        subUnitId: string;
+        cfId: string;
+    }>;
+    interceptorManager: InterceptorManager<{
+        beforeUpdateRuleResult: import('@univerjs/core').IInterceptor<{
+            subUnitId: string;
+            unitId: string;
+            cfId: string;
+        }, any>;
+    }>;
+    private _calculationUnitMap;
+    constructor(_conditionalFormattingRuleModel: ConditionalFormattingRuleModel, _injector: Injector, _conditionalFormattingViewModel: ConditionalFormattingViewModel, _univerInstanceService: IUniverInstanceService, _resourceManagerService: IResourceManagerService, _sheetInterceptorService: SheetInterceptorService, _commandService: ICommandService);
+    composeStyle(unitId: string, subUnitId: string, row: number, col: number): ({
+        style?: import('@univerjs/core').IStyleBase | undefined;
+    } & IDataBarCellData & IIconSetCellData) | null;
+    private _initSnapshot;
+    private _initSheetChange;
+    private _registerCalculationUnit;
+    private _getComputedCache;
+    private _setComputedCache;
+    private _deleteComputeCache;
+    private _initCacheManager;
+    private _initCellChange;
+    private _initRemoteCalculate;
+    private _handleCalculateUnit;
+}
+export {};

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

@@ -0,0 +1,3 @@
+import { IDocumentData } from '@univerjs/core';
+
+export declare const getStringFromDataStream: (data: IDocumentData) => string;

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

@@ -0,0 +1,3 @@
+import { IRange } from '@univerjs/core';
+
+export declare const isRangesEqual: (oldRanges: IRange[], ranges: IRange[]) => boolean;