@univerjs/sheets-conditional-formatting 0.5.0 → 0.5.1

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

@@ -60,6 +60,6 @@ export declare enum CFValueType {
 }
 export declare const DEFAULT_BG_COLOR = "#fff";
 export declare const DEFAULT_FONT_COLOR = "#000000";
-export declare const createDefaultRule: () => IConditionFormattingRule<import('..').IConditionalFormattingRuleConfig>;
+export declare const createDefaultRule: () => IConditionFormattingRule;
 export declare const createDefaultValue: (subType: CFSubRuleType, operator: CFTextOperator | CFNumberOperator | CFTimePeriodOperator) => "" | 10 | [number, number];
 export declare const createDefaultValueByValueType: (type: CFValueType, defaultValue?: number) => number | "" | "=";

package/lib/types/controllers/config.schema.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const PLUGIN_CONFIG_KEY = "ssheets-conditional-formatting.config";
+export declare const SHEETS_CONDITIONAL_FORMATTING_PLUGIN_CONFIG_KEY = "ssheets-conditional-formatting.config";
 export declare const configSymbol: unique symbol;
 export interface IUniverSheetsConditionalFormattingConfig {
 }

package/lib/types/index.d.ts

@@ -22,10 +22,9 @@ export { UniverSheetsConditionalFormattingPlugin } from './plugin';
 export * from './render/data-bar.render';
 export * from './render/icon.render';
 export * from './render/type';
-export * from './services/calculate-unit/type';
-export * from './services/calculate-unit/utils';
 export * from './services/conditional-formatting.service';
 export * from './services/conditional-formatting-formula.service';
+export * from './models/calculate-unit-v2/utils';
 export * from './utils/anchor';
 export * from './utils/create-cf-id';
 export * from './utils/is-ranges-equal';

package/lib/types/models/calculate-unit-v2/__test__/calculate.databar.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/models/calculate-unit-v2/__test__/calculate.highlight.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 → models/calculate-unit-v2}/__test__/test.util.d.ts

@@ -1,7 +1,7 @@
 import { Dependency, ICommandService, Univer } from '@univerjs/core';
-import { ConditionalFormattingService } from '../conditional-formatting.service';
-import { ConditionalFormattingRuleModel } from '../../models/conditional-formatting-rule-model';
-import { ConditionalFormattingViewModel } from '../../models/conditional-formatting-view-model';
+import { ConditionalFormattingRuleModel } from '../../../models/conditional-formatting-rule-model';
+import { ConditionalFormattingService } from '../../../services/conditional-formatting.service';
+import { ConditionalFormattingViewModel } from '../../conditional-formatting-view-model';
 export declare const createTestBed: (dependencies?: Dependency[]) => {
     univer: Univer;
     get: {

package/lib/types/models/calculate-unit-v2/base-calculate-unit.d.ts

@@ -0,0 +1,53 @@
+import { IAccessor, ICellData, Nullable, Workbook, Worksheet } from '@univerjs/core';
+import { IConditionFormattingRule } from '../type';
+import { BehaviorSubject } from 'rxjs';
+export declare enum CalculateEmitStatus {
+    preComputingStart = "preComputingStart",
+    preComputing = "preComputing",
+    preComputingEnd = "preComputingEnd",
+    preComputingError = "preComputingError"
+}
+export interface IContext {
+    unitId: string;
+    subUnitId: string;
+    workbook: Workbook;
+    worksheet: Worksheet;
+    accessor: IAccessor;
+    rule: IConditionFormattingRule;
+    getCellValue: (row: number, col: number) => ICellData;
+    limit: number;
+}
+/**
+ * Processing Main Path Calculation Logic
+ */
+export declare abstract class BaseCalculateUnit<C = any, S = any> {
+    private _context;
+    /**
+     * 3nd-level cache
+     */
+    private _cache;
+    protected _preComputingStatus$: BehaviorSubject<CalculateEmitStatus>;
+    preComputingStatus$: import('rxjs').Observable<CalculateEmitStatus>;
+    /**
+     * 2nd-level cache
+     */
+    private _preComputingCache;
+    private _rule;
+    constructor(_context: IContext);
+    setCacheLength(length: number): void;
+    clearCache(): void;
+    resetPreComputingCache(): void;
+    updateRule(rule: IConditionFormattingRule): void;
+    getCell(row: number, col: number): Nullable<S>;
+    abstract preComputing(row: number, col: number, context: IContext): void;
+    /**
+     * If a null value is returned, it indicates that caching is not required.
+     */
+    protected abstract getCellResult(row: number, col: number, preComputingResult: Nullable<C>, context: IContext): Nullable<S>;
+    protected setPreComputingCache(v: C): void;
+    protected getPreComputingResult(_row: number, _col: number): Nullable<C>;
+    private _createKey;
+    private _setCache;
+    private _getContext;
+    private _initClearCacheListener;
+}

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

@@ -0,0 +1,11 @@
+import { IContext, BaseCalculateUnit } from './base-calculate-unit';
+import { ColorKit } from '@univerjs/core';
+interface IConfigItem {
+    value: number;
+    color: ColorKit;
+}
+export declare class ColorScaleCalculateUnit extends BaseCalculateUnit<IConfigItem[], string> {
+    preComputing(_row: number, _col: number, context: IContext): void;
+    protected getCellResult(row: number, col: number, preComputingResult: IConfigItem[], context: IContext): string | null | undefined;
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { IContext, BaseCalculateUnit } from './base-calculate-unit';
+interface IConfig {
+    min: number;
+    max: number;
+    startPoint: number;
+}
+export declare class DataBarCalculateUnit extends BaseCalculateUnit<IConfig> {
+    preComputing(row: number, col: number, context: IContext): void;
+    protected getCellResult(row: number, col: number, preComputingResult: IConfig, context: IContext): {
+        color: string;
+        startPoint: number;
+        value: number;
+        isGradient: boolean;
+        isShowValue: boolean;
+    } | undefined;
+}
+export {};

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

@@ -0,0 +1,12 @@
+import { IStyleData, Nullable } from '@univerjs/core';
+import { IContext, BaseCalculateUnit } from './base-calculate-unit';
+import { CFSubRuleType } from '../../base/const';
+interface IConfig {
+    value: any;
+    type: CFSubRuleType;
+}
+export declare class HighlightCellCalculateUnit extends BaseCalculateUnit<Nullable<IConfig>, Nullable<IStyleData>> {
+    preComputing(row: number, col: number, context: IContext): void;
+    protected getCellResult(row: number, col: number, preComputingResult: Nullable<IConfig>, context: IContext): import('@univerjs/core').IStyleBase;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { Nullable } from '@univerjs/core';
+import { CFNumberOperator } from '../../base/const';
+import { IContext, BaseCalculateUnit } from './base-calculate-unit';
+interface IConfigItem {
+    operator: CFNumberOperator;
+    value: number;
+    iconType: string;
+    iconId: string;
+}
+export declare class IconSetCalculateUnit extends BaseCalculateUnit<IConfigItem[]> {
+    preComputing(_row: number, _col: number, context: IContext): void;
+    protected getCellResult(row: number, col: number, preComputingResult: Nullable<IConfigItem[]>, context: IContext): {
+        iconId: string;
+        iconType: string;
+        isShowValue: boolean;
+    } | null | undefined;
+}
+export {};

package/lib/types/{services/calculate-unit → models/calculate-unit-v2}/utils.d.ts

@@ -1,8 +1,8 @@
 import { CellValue, ICellData, IObjectMatrixPrimitiveType, IRange, Nullable, ColorKit, ObjectMatrix } from '@univerjs/core';
 import { IConditionFormattingRule, IValueConfig } from '../../models/type';
-import { IContext } from './type';
+import { IContext } from './base-calculate-unit';
 import { CFNumberOperator } from '../../base/const';
-import { FormulaResultStatus } from '../conditional-formatting-formula.service';
+import { FormulaResultStatus } from '../../services/conditional-formatting-formula.service';
 export declare function isFloatsEqual(a: number, b: number): boolean;
 export declare const isNullable: (v: any) => boolean;
 export declare const getCellValue: (cell?: ICellData) => Nullable<CellValue>;

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

@@ -1,20 +1,16 @@
-import { Injector } from '@univerjs/core';
-import { Observable } from 'rxjs';
 import { IAnchor } from '../utils/anchor';
 import { IConditionFormattingRule } from './type';
 type RuleOperatorType = 'delete' | 'set' | 'add' | 'sort';
 export declare class ConditionalFormattingRuleModel {
-    private _injector;
     private _model;
     private _ruleChange$;
-    $ruleChange: Observable<{
+    $ruleChange: import('rxjs').Observable<{
         rule: IConditionFormattingRule;
         oldRule?: IConditionFormattingRule;
         unitId: string;
         subUnitId: string;
         type: RuleOperatorType;
     }>;
-    constructor(_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;

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

@@ -1,29 +1,57 @@
-import { ObjectMatrix } from '@univerjs/core';
-import { IDataBarRenderParams } from '../render/type';
-import { IConditionFormattingRule, IHighlightCell } from './type';
-interface ICacheItem {
-    cfId: string;
-    ruleCache?: IHighlightCell['style'] | IDataBarRenderParams;
-    isDirty: boolean;
-}
-interface ICellItem {
-    cfList: ICacheItem[];
-}
-export declare class ConditionalFormattingViewModel {
-    private _model;
+import { Disposable, Injector, IUniverInstanceService } from '@univerjs/core';
+import { ConditionalFormattingFormulaService } from '../services/conditional-formatting-formula.service';
+import { ConditionalFormattingRuleModel } from './conditional-formatting-rule-model';
+export declare const CONDITIONAL_FORMATTING_VIEWPORT_CACHE_LENGTH: number;
+export declare class ConditionalFormattingViewModel extends Disposable {
+    private _injector;
+    private _conditionalFormattingRuleModel;
+    private _conditionalFormattingFormulaService;
+    private _univerInstanceService;
+    private _calculateUnitManagers;
+    private _rTreeManager;
+    /**
+     * 1nd-level cache
+     */
+    private _cellCache;
     private _markDirty$;
+    /**
+     * The rendering layer listens to this variable to determine whether a reRender is necessary.
+     * @memberof ConditionalFormattingViewModel
+     */
     markDirty$: import('rxjs').Observable<{
-        rule: IConditionFormattingRule;
+        cfId: string;
         unitId: string;
         subUnitId: string;
+        isImmediately?: boolean;
     }>;
-    private _ensureMatrix;
-    getMatrix(unitId: string, subUnitId: string): ObjectMatrix<ICellItem> | undefined;
-    getCellCf(unitId: string, subUnitId: string, row: number, col: number, matrix?: ObjectMatrix<ICellItem>): import('@univerjs/core').Nullable<ICellItem>;
-    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;
+    constructor(_injector: Injector, _conditionalFormattingRuleModel: ConditionalFormattingRuleModel, _conditionalFormattingFormulaService: ConditionalFormattingFormulaService, _univerInstanceService: IUniverInstanceService);
+    private _initCFFormulaListener;
+    getCellCfs(unitId: string, subUnitId: string, row: number, col: number): {
+        cfId: string;
+        result: any;
+        priority: number;
+    }[] | undefined;
+    private _getCellCfs;
+    /**
+     `isNeedResetPreComputingCache` indicates whether it is necessary to remove the 2nd-level cache for each rule individually.
+     Generally, when the logic of a rule calculation is modified, the cache for that rule needs to be removed.
+     Changes in style/priority do not require the clearing of the 2nd-level cache.
+     Rule changes/region changes require the removal of the 2nd-level cache.
+     There is also a situation where preComputing is asynchronously calculated.
+     After the calculation is finished, it is only for marking as dirty, and the 2nd-level cache need to be cleared.
+     * @param {boolean} [isNeedResetPreComputingCache]
+     */
+    private _markRuleDirtyAtOnce;
+    /**
+     * For the same condition format being marked dirty multiple times at the same time,
+     * it will cause the style cache to be cleared, thereby causing the screen to flicker.
+     * Here,multiple dirties are merged into one..
+     */
+    markRuleDirty: (unitId: string, subUnitId: string, cfId: string, isNeedResetPreComputingCache?: boolean) => void;
+    private _handleCustomFormulasSeparately;
+    private _initRuleListener;
+    private _ensureCalculateUnitManager;
+    private _createRuleCalculateUnitInstance;
+    private _createCacheKey;
+    setCacheLength(length?: number): void;
 }
-export {};

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

@@ -3,6 +3,7 @@ import { SpreadsheetSkeleton, UniverRenderingContext, SheetExtension } from '@un
 export declare const dataBarUKey = "sheet-conditional-rule-data-bar";
 export declare const defaultDataBarPositiveColor = "#ffbe38";
 export declare const defaultDataBarNativeColor = "#abd91a";
+export declare const defaultPlaceholderColor = "#000";
 export declare class DataBar extends SheetExtension {
     private _paddingRightAndLeft;
     private _paddingTopAndBottom;

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

@@ -1,11 +1,12 @@
-import { IRange, Nullable, Disposable, ICommandService, Injector, ObjectMatrix, RefAlias } from '@univerjs/core';
+import { IRange, Nullable, Disposable, ICommandService, ObjectMatrix, RefAlias } from '@univerjs/core';
 import { IActiveDirtyManagerService } from '@univerjs/engine-formula';
 import { ConditionalFormattingRuleModel } from '../models/conditional-formatting-rule-model';
-import { ConditionalFormattingViewModel } from '../models/conditional-formatting-view-model';
 type IFormulaItem = {
     formulaText: string;
     cfId: string;
     id: string;
+    unitId: string;
+    subUnitId: string;
     ranges: IRange[];
     status: FormulaResultStatus;
     formulaId: string;
@@ -19,31 +20,46 @@ export declare enum FormulaResultStatus {
 }
 export declare class ConditionalFormattingFormulaService extends Disposable {
     private _commandService;
-    private _injector;
     private _activeDirtyManagerService;
-    private _conditionalFormattingViewModel;
     private _conditionalFormattingRuleModel;
     private _formulaMap;
-    private _cache;
-    constructor(_commandService: ICommandService, _injector: Injector, _activeDirtyManagerService: IActiveDirtyManagerService, _conditionalFormattingViewModel: ConditionalFormattingViewModel, _conditionalFormattingRuleModel: ConditionalFormattingRuleModel);
-    private _initCache;
+    private _result$;
+    result$: import('rxjs').Observable<IFormulaItem & {
+        isAllFinished: boolean;
+    }>;
+    constructor(_commandService: ICommandService, _activeDirtyManagerService: IActiveDirtyManagerService, _conditionalFormattingRuleModel: ConditionalFormattingRuleModel);
     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, "id" | "formulaId"> | undefined;
     registerFormulaWithRange(unitId: string, subUnitId: string, cfId: string, formulaText: string, ranges?: IRange[]): void;
     private _removeFormulaByCfId;
-    getFormulaResult(unitId: string, subUnitId: string, cfId: string, formulaText: string, row?: number, col?: number): {
+    getFormulaResultWithCoords(unitId: string, subUnitId: string, cfId: string, formulaText: string, row?: number, col?: number): {
         status: FormulaResultStatus;
         result?: undefined;
     } | {
         result: Nullable<string | number | boolean | void | null | undefined>;
         status: FormulaResultStatus;
     };
+    getFormulaMatrix(unitId: string, subUnitId: string, cfId: string, formulaText: string): {
+        status: FormulaResultStatus;
+        result?: undefined;
+    } | {
+        result: ObjectMatrix<string | number | boolean | void | null | undefined>;
+        status: FormulaResultStatus;
+    } | undefined;
+    /**
+     * If `formulaText` is not provided, then all caches related to `cfId` will be deleted.
+     */
+    deleteCache(unitId: string, subUnitId: string, cfId: string, formulaText?: string): IFormulaItem[];
+    private _getAllFormulaResultByCfId;
+    /**
+     * The external environment is not aware of`formulaId`;it communicates internally with the formula engine.
+     */
     private _createFormulaId;
+    /**
+     * A conditional formatting may have multiple formulas;if the formulas are identical,then the results will be consistent.
+     */
     createCFormulaId(cfId: string, formulaText: string): string;
 }
 export {};

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

@@ -1,37 +1,18 @@
 import { IHighlightCell } from '../models/type';
 import { IDataBarCellData, IIconSetCellData } from '../render/type';
-import { Disposable, ICommandService, Injector, InterceptorManager, IResourceManagerService, IUniverInstanceService, ObjectMatrix } from '@univerjs/core';
+import { Disposable, ICommandService, Injector, IResourceManagerService, IUniverInstanceService } from '@univerjs/core';
 import { SheetInterceptorService } from '@univerjs/sheets';
 import { ConditionalFormattingRuleModel } from '../models/conditional-formatting-rule-model';
 import { ConditionalFormattingViewModel } from '../models/conditional-formatting-view-model';
-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 _calculateUnit$;
-    private _ruleComputeStatus$;
-    ruleComputeStatus$: import('rxjs').Observable<{
-        status: ComputeStatus;
-        result?: ObjectMatrix<any>;
-        unitId: string;
-        subUnitId: string;
-        cfId: string;
-    }>;
-    interceptorManager: InterceptorManager<{
-        beforeUpdateRuleResult: import('@univerjs/core').IInterceptor<{
-            subUnitId: string;
-            unitId: string;
-            cfId: string;
-        }, undefined>;
-    }>;
-    private _calculationUnitMap;
-    constructor(_conditionalFormattingRuleModel: ConditionalFormattingRuleModel, _injector: Injector, _conditionalFormattingViewModel: ConditionalFormattingViewModel, _univerInstanceService: IUniverInstanceService, _resourceManagerService: IResourceManagerService, _sheetInterceptorService: SheetInterceptorService, _commandService: ICommandService);
+    get _conditionalFormattingViewModelV2(): ConditionalFormattingViewModel;
+    constructor(_conditionalFormattingRuleModel: ConditionalFormattingRuleModel, _injector: Injector, _univerInstanceService: IUniverInstanceService, _resourceManagerService: IResourceManagerService, _sheetInterceptorService: SheetInterceptorService, _commandService: ICommandService);
     composeStyle(unitId: string, subUnitId: string, row: number, col: number): ({
         style?: IHighlightCell["style"];
     } & IDataBarCellData & IIconSetCellData & {
@@ -39,13 +20,5 @@ export declare class ConditionalFormattingService extends Disposable {
     }) | 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/is-ranges-equal.d.ts

@@ -1,2 +1,16 @@
-import { IRange } from '@univerjs/core';
-export declare const isRangesEqual: (oldRanges: IRange[], ranges: IRange[]) => boolean;
+/**
+ * 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 { isRangesEqual } from '@univerjs/core';