@univerjs/sheets 0.10.3 → 0.10.4

package/lib/types/controllers/zebar-crossing.controller.d.ts

@@ -0,0 +1,18 @@
+import { Disposable, ICommandService, IUniverInstanceService } from '@univerjs/core';
+import { SheetRangeThemeModel } from '../model/range-theme-model';
+export declare class ZebraCrossingCacheController extends Disposable {
+    private readonly _commandService;
+    private readonly _sheetRangeThemeModel;
+    private readonly _univerInstanceService;
+    private _zebraCacheUpdateSubject;
+    constructor(_commandService: ICommandService, _sheetRangeThemeModel: SheetRangeThemeModel, _univerInstanceService: IUniverInstanceService);
+    private _init;
+    /**
+     * Update the zebra crossing cache for a specific unit and sub-unit.
+     * @param {string} unitId - The ID of the unit.
+     * @param {string} subUnitId - The ID of the sub-unit.
+     */
+    updateZebraCrossingCache(unitId: string, subUnitId: string): void;
+    private _initializeCommandListener;
+    private _initTriggerCacheUpdateListener;
+}

package/lib/types/index.d.ts

@@ -161,6 +161,7 @@ export { getAddMergeMutationRangeByType } from './controllers/merge-cell.control
 export { MERGE_CELL_INTERCEPTOR_CHECK, MergeCellController } from './controllers/merge-cell.controller';
 export { SheetPermissionCheckController } from './controllers/permission/sheet-permission-check.controller';
 export { SheetPermissionInitController } from './controllers/permission/sheet-permission-init.controller';
+export { ZebraCrossingCacheController } from './controllers/zebar-crossing.controller';
 export { type ICellPermission, RangeProtectionRenderModel } from './model/range-protection-render.model';
 export { EditStateEnum, type IModel, type IObjectModel, type IRangeProtectionRule, RangeProtectionRuleModel, ViewStateEnum } from './model/range-protection-rule.model';
 export { RangeProtectionCache } from './model/range-protection.cache';

package/lib/types/model/range-theme-model.d.ts

@@ -1,4 +1,4 @@
-import { IRange, Nullable, Disposable, IResourceManagerService } from '@univerjs/core';
+import { IRange, Nullable, Disposable, IResourceManagerService, IUniverInstanceService } from '@univerjs/core';
 import { IRangeThemeStyleItem, IRangeThemeStyleJSON, RangeThemeStyle } from './range-theme-util';
 import { SheetInterceptorService } from '../services/sheet-interceptor/sheet-interceptor.service';
 export interface IRangeThemeRangeInfo {
@@ -17,22 +17,32 @@ interface ISheetRangeThemeModelJSON {
 export declare class SheetRangeThemeModel extends Disposable {
     private _sheetInterceptorService;
     private _resourceManagerService;
+    private readonly _univerInstanceService;
     private _rangeThemeStyleMap;
     private _rangeThemeStyleRuleMap;
     private _rTreeCollection;
     private _defaultRangeThemeMap;
+    /**
+     * This map is used to cache zebra crossing toggle ranges for each unitId and subUnitId, IRangeThemeStyleRule id
+     */
+    private _zebraCrossingCacheMap;
+    private _rowVisibleFuncSet;
     private _rangeThemeMapChanged$;
     rangeThemeMapChange$: import('rxjs').Observable<{
         type: "add" | "remove";
         styleName: string;
     }>;
-    constructor(_sheetInterceptorService: SheetInterceptorService, _resourceManagerService: IResourceManagerService);
+    constructor(_sheetInterceptorService: SheetInterceptorService, _resourceManagerService: IResourceManagerService, _univerInstanceService: IUniverInstanceService);
     private _initDefaultTheme;
     private _ensureRangeThemeStyleMap;
     private _ensureRangeThemeStyleRuleMap;
     private _ensureRTreeCollection;
     getDefaultRangeThemeStyle(name: string): RangeThemeStyle;
     getCustomRangeThemeStyle(unitId: string, name: string): RangeThemeStyle | undefined;
+    private _getSheetRowVisibleFuncSet;
+    private _getSheetRowVisibleHasInit;
+    refreshSheetRowVisibleFuncSet(unitId: string, subUnitId: string): void;
+    private _ensureZebraCrossingCache;
     /**
      * Register range theme styles
      * @param {string} themeName
@@ -40,6 +50,7 @@ export declare class SheetRangeThemeModel extends Disposable {
      */
     registerRangeThemeRule(themeName: string, rangeInfo: IRangeThemeRangeInfo): void;
     getRegisteredRangeThemeStyle(rangeInfo: IRangeThemeRangeInfo): string | undefined;
+    refreshZebraCrossingCacheBySheet(unitId: string, subUnitId: string): void;
     removeRangeThemeRule(themeName: string, rangeInfo: IRangeThemeRangeInfo): void;
     registerDefaultRangeTheme(rangeThemeStyle: RangeThemeStyle): void;
     unRegisterDefaultRangeTheme(themeName: string): void;

package/lib/types/model/range-theme-util.d.ts

@@ -88,7 +88,7 @@ export declare class RangeThemeStyle {
     setHeaderRowStyle(style: Nullable<IRangeThemeStyleItem>): void;
     getHeaderColumnStyle(): Nullable<IRangeThemeStyleItem>;
     setHeaderColumnStyle(style: Nullable<IRangeThemeStyleItem>): void;
-    getStyle(offsetRow: number, offsetCol: number, isLastRow: boolean, isLastCol: boolean): IRangeThemeStyleItem | null;
+    getStyle(offsetRow: number, offsetCol: number, isLastRow: boolean, isLastCol: boolean, isToggled: boolean): IRangeThemeStyleItem | null;
     private _getMergeStyle;
     private _mergeStyle;
     private _resetStyleCache;

package/lib/types/model/zebra-crossing-cache.d.ts

@@ -0,0 +1,42 @@
+import { IRange } from '@univerjs/core';
+type IVisibleFunc = (row: number) => boolean;
+type IToggleRange = [number, number];
+/**
+ * This class is used for caching zebra crossing toggle ranges.
+ * `toggleRanges` represents the ranges within the visible area where the original odd/even row state is reversed due to hidden rows.
+ * Based on the following rules:
+ * 1. If there is an odd number of hidden rows before a certain row, the odd/even state of that row will be reversed.
+ * 2. If there is an even number of hidden rows before a certain row, the odd/even state of that row will not be reversed.
+ * 3. If there are no hidden rows before a certain row, the odd/even state of that row will not be reversed.
+ *
+ * Example:
+ * Given rows 1 to 10, where rows 3 and 7 are hidden:
+ * - Rows 1 and 2 remain in their original odd/even state.
+ * - Row 4's state is reversed because there is 1 hidden row (odd) before it.
+ * - Row 8's state is reversed because there are 2 hidden rows (even) before it.
+ * - Rows 9 and 10 remain in their original odd/even state.
+ */
+export declare class ZebraCrossingCache {
+    private _toggleRanges;
+    /**
+     * Refresh the cache based on the given range and visibility function.
+     * This method calculates toggle ranges for rows that are visible within the specified range.
+     * Hidden rows are excluded from the toggle calculation.
+     * @param range The range of rows to refresh (startRow and endRow are required).
+     * @param visibleFunc A function to determine if a row is visible.
+     */
+    refresh(range: IRange, visibleFunc: IVisibleFunc): void;
+    /**
+     * This function returns the toggle ranges. Only for testing purposes. In production, you should use `getIsToggled` to check if a row is toggled.
+     * @returns [IToggleRange[]] The toggle ranges calculated by the last refresh.
+     */
+    getToggleRanges(): IToggleRange[];
+    /**
+     * Check if the given row is toggled (odd/even state).
+     * This method uses binary search to efficiently determine if the row is within a toggle range.
+     * @param row The row to check.
+     * @returns True if the row is toggled (odd), false otherwise (even or hidden).
+     */
+    getIsToggled(row: number): boolean;
+}
+export {};