@univerjs/engine-render 1.0.0-insiders.20260809-70eefdd → 1.0.0-rc.0

package/lib/types/components/docs/layout/tools.d.ts

@@ -14,14 +14,17 @@
  * limitations under the License.
  */
 import type { DocumentDataModel, ICustomRangeForInterceptor, INumberUnit, IObjectPositionH, IObjectPositionV, IParagraph, IParagraphStyle, ITextStyle, Nullable, PositionedObjectLayoutType } from '@univerjs/core';
-import type { IDocumentSkeletonCached, IDocumentSkeletonColumn, IDocumentSkeletonDivide, IDocumentSkeletonFontStyle, IDocumentSkeletonGlyph, IDocumentSkeletonLine, IDocumentSkeletonPage, IDocumentSkeletonRow, IDocumentSkeletonSection, IDocumentSkeletonTable, ISkeletonResourceReference } from '../../../basics/i-document-skeleton-cached';
+import type { IDocumentSkeletonCached, IDocumentSkeletonColumn, IDocumentSkeletonDivide, IDocumentSkeletonFontStyle, IDocumentSkeletonGlyph, IDocumentSkeletonLine, IDocumentSkeletonPage, IDocumentSkeletonParagraphBorders, IDocumentSkeletonRow, IDocumentSkeletonSection, IDocumentSkeletonTable, ISkeletonResourceReference } from '../../../basics/i-document-skeleton-cached';
 import type { IDocsConfig, IParagraphConfig, ISectionBreakConfig } from '../../../basics/interfaces';
 import type { IBoundRectNoAngle } from '../../../basics/vector2';
 import type { IDocumentCompatibilityPolicy } from '../document-compatibility';
 import type { DataStreamTreeNode } from '../view-model/data-stream-tree-node';
 import type { DocumentViewModel } from '../view-model/document-view-model';
+import type { DocumentEndnoteLayout } from './endnote-layout';
+import type { DocumentFootnoteLayout } from './footnote-layout';
 import type { Hyphen } from './hyphenation/hyphen';
 import type { LanguageDetector } from './hyphenation/language-detector';
+import type { INoteReferenceLayout } from './note-numbering';
 import { BooleanNumber, GridType, SpacingRule } from '@univerjs/core';
 export declare function getLastPage(pages: IDocumentSkeletonPage[]): IDocumentSkeletonPage;
 export declare function getLastSection(page: IDocumentSkeletonPage): IDocumentSkeletonSection;
@@ -50,6 +53,7 @@ export declare function isBlankColumn(column: IDocumentSkeletonColumn): boolean;
 export declare function getNumberUnitValue(unitValue: Nullable<INumberUnit>, benchMark: number): number;
 export declare function getCharSpaceApply(charSpace: number | undefined, defaultTabStop: number, gridType?: GridType, snapToGrid?: BooleanNumber): number;
 export declare function validationGrid(gridType?: GridType, snapToGrid?: BooleanNumber): boolean;
+export declare function reachesNextDocumentGridLine(lineSpacing: number, spaceBelow: number, linePitch: number): boolean;
 export declare function getLineHeightConfig(sectionBreakConfig: ISectionBreakConfig, paragraphConfig: IParagraphConfig): {
     paragraphLineGapDefault: number;
     linePitch: number;
@@ -67,7 +71,9 @@ export declare function getCharSpaceConfig(sectionBreakConfig: ISectionBreakConf
     snapToGrid: BooleanNumber;
 };
 export declare function updateBlockIndex(pages: IDocumentSkeletonPage[], start?: number, documentCompatibilityPolicy?: IDocumentCompatibilityPolicy): void;
+export declare function hasSameParagraphBorderSet(first: IDocumentSkeletonParagraphBorders, second: IDocumentSkeletonParagraphBorders): boolean;
 export declare function updateInlineDrawingCoordsAndBorder(ctx: ILayoutContext, pages: IDocumentSkeletonPage[]): void;
+export declare function updateParagraphBorders(ctx: ILayoutContext, pages: IDocumentSkeletonPage[], targetPages?: IDocumentSkeletonPage[]): void;
 export declare function glyphIterator(pages: IDocumentSkeletonPage[], cb: (glyph: IDocumentSkeletonGlyph, divide: IDocumentSkeletonDivide, line: IDocumentSkeletonLine, column: IDocumentSkeletonColumn, section: IDocumentSkeletonSection, page: IDocumentSkeletonPage) => void): void;
 export declare function lineIterator(pagesOrCells: (IDocumentSkeletonPage)[], cb: (line: IDocumentSkeletonLine, column: IDocumentSkeletonColumn, section: IDocumentSkeletonSection, page: IDocumentSkeletonPage) => void): void;
 export type DocumentSkeletonLineSource = 'page' | 'table-cell' | 'column';
@@ -154,6 +160,7 @@ export declare function getPositionHorizon(positionH: IObjectPositionH, column:
 export declare function getPositionVertical(positionV: IObjectPositionV, page: IDocumentSkeletonPage, lineTop: number, lineHeight: number, objectHeight: number, blockAnchorTop?: number, isPageBreak?: boolean): number | undefined;
 export declare function getGlyphGroupWidth(divide: IDocumentSkeletonDivide): number;
 interface IFontCreateConfig {
+    documentCompatibilityPolicy?: IDocumentCompatibilityPolicy;
     fontStyle: IDocumentSkeletonFontStyle;
     textStyle: ITextStyle;
     charSpace: number;
@@ -163,6 +170,7 @@ interface IFontCreateConfig {
 }
 export declare function clearFontCreateConfigCache(): void;
 export declare function getFontConfigFromLastGlyph(glyph: IDocumentSkeletonGlyph, sectionBreakConfig: ISectionBreakConfig, paragraphStyle: IParagraphStyle): {
+    documentCompatibilityPolicy: IDocumentCompatibilityPolicy;
     fontStyle: IDocumentSkeletonFontStyle;
     textStyle: ITextStyle;
     charSpace: number;
@@ -226,6 +234,18 @@ export interface IDocumentPaginationMetrics {
     peakCheckpointLineCount: number;
 }
 export interface ILayoutContext {
+    noteReferences?: ReadonlyMap<number, INoteReferenceLayout>;
+    footnoteLayout?: DocumentFootnoteLayout;
+    endnoteLayout?: DocumentEndnoteLayout;
+    /** Virtual marker in a note body; it never consumes a persisted character. */
+    noteLabel?: string;
+    noteReferenceTextStyle?: ITextStyle;
+    /** Preserve the local note segment when the paragraph/table pipeline opens a continuation page. */
+    noteSegmentId?: string;
+    footnoteFirstColumn?: {
+        index: number;
+        top: number;
+    };
     viewModel: DocumentViewModel;
     dataModel: DocumentDataModel;
     docsConfig: IDocsConfig;
@@ -242,6 +262,18 @@ export interface ILayoutContext {
     sectionBreakConfigCache: Map<number, ISectionBreakConfig>;
     paragraphsOpenNewPage: Set<number>;
     paginationMetrics?: IDocumentPaginationMetrics;
+    /**
+     * Incremental layout may defer an expensive split-table calculation after
+     * the normal line-layout path has resolved its exact pagination context.
+     * Synchronous callers leave this unset.
+     */
+    deferSlicedTableLayout?: (request: {
+        curPage: IDocumentSkeletonPage;
+        viewModel: DocumentViewModel;
+        tableNode: DataStreamTreeNode;
+        sectionBreakConfig: ISectionBreakConfig;
+        availableHeight: number;
+    }) => boolean;
     hyphen: Hyphen;
     languageDetector: LanguageDetector;
 }

package/lib/types/components/docs/view-model/document-view-model.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { DocumentDataModel, IColumnGroup, ICustomBlock, ICustomColumnGroup, ICustomDecorationForInterceptor, ICustomRangeForInterceptor, ICustomTable, IDisposable, IParagraph, ISectionBreak, ITable, ITextRun, Nullable } from '@univerjs/core';
+import type { DocumentDataModel, IColumnGroup, ICustomBlock, ICustomColumnGroup, ICustomDecorationForInterceptor, ICustomRangeForInterceptor, ICustomTable, IDisposable, IParagraph, ISectionBreak, ITable, ITextRun, JSONXActions, Nullable } from '@univerjs/core';
 import { DataStreamTreeNode } from './data-stream-tree-node';
 interface ITableNodeCache {
     table: DataStreamTreeNode;
@@ -52,11 +52,23 @@ export declare class DocumentViewModel implements IDisposable {
     private _columnGroupCache;
     private _tableNodeCache;
     private _children;
+    private _treeNodes;
+    private _treeNodesByStartIndex;
+    private _plainTopLevelParagraphNodes;
+    private _metadataCachesDirty;
+    private _textRunsOrderedAndDisjoint;
+    private _paragraphsOrdered;
+    private _sectionBreaksOrdered;
+    private _customBlocksOrdered;
+    private _tablesOrdered;
+    private _columnGroupsOrdered;
+    private _lastTextRun;
     private _editArea;
     private readonly _editAreaChange$;
     readonly editAreaChange$: import("rxjs").Observable<Nullable<DocumentEditArea>>;
     private _headerTreeMap;
     private _footerTreeMap;
+    private _noteTreeMap;
     private readonly _segmentViewModels$;
     readonly segmentViewModels$: import("rxjs").Observable<DocumentViewModel[]>;
     constructor(_documentDataModel: DocumentDataModel, _tableSource?: Record<string, ITable> | undefined);
@@ -66,6 +78,7 @@ export declare class DocumentViewModel implements IDisposable {
         headerTreeMap: Map<string, DocumentViewModel>;
         footerTreeMap: Map<string, DocumentViewModel>;
     };
+    getNoteTreeMap(): ReadonlyMap<string, DocumentViewModel>;
     getEditArea(): DocumentEditArea;
     setEditArea(editArea: DocumentEditArea): void;
     getChildren(): DataStreamTreeNode[];
@@ -74,6 +87,8 @@ export declare class DocumentViewModel implements IDisposable {
     getDataModel(): DocumentDataModel;
     getSelfOrHeaderFooterViewModel(segmentId?: string): DocumentViewModel;
     reset(documentDataModel: DocumentDataModel): void;
+    resetByValidatedTextMutation(documentDataModel: DocumentDataModel, actions: JSONXActions): boolean;
+    resetByValidatedMetadataMutation(documentDataModel: DocumentDataModel, actions: JSONXActions): boolean;
     getSectionBreak(index: number): ISectionBreak | undefined;
     getParagraph(index: number): IParagraph | undefined;
     getTextRun(index: number): Nullable<ITextRun>;
@@ -87,6 +102,11 @@ export declare class DocumentViewModel implements IDisposable {
     getCustomDecorationRaw(index: number): import("@univerjs/core").ICustomDecoration | undefined;
     getCustomDecoration(index: number): Nullable<ICustomDecorationForInterceptor>;
     private _buildAllCache;
+    private _insertPlainText;
+    private _deletePlainText;
+    private _findParagraphNode;
+    private _rebuildTreeNodes;
+    private _collectNodePath;
     private _buildParagraphCache;
     private _buildSectionBreakCache;
     private _buildCustomBlockCache;

package/lib/types/components/sheets/constants.d.ts

@@ -19,6 +19,8 @@ export declare const FONT_EXTENSION_Z_INDEX = 45;
 export declare const BG_Z_INDEX = 21;
 export declare const PRINTING_BG_Z_INDEX = 21;
 export declare const EXPAND_SIZE_FOR_RENDER_OVERFLOW = 20;
+export declare const MIN_TEXT_RENDER_HEIGHT_IN_SCREEN_PX = 4;
+export declare function shouldRenderRowText(rowHeight: number, scaleY?: number): boolean;
 export declare const sheetContentViewportKeys: SHEET_VIEWPORT_KEY[];
 export declare const sheetHeaderViewportKeys: SHEET_VIEWPORT_KEY[];
 export declare const MEASURE_EXTENT = 10000;

package/lib/types/components/sheets/extensions/column-header-layout.d.ts

@@ -35,7 +35,7 @@ export declare class ColumnHeaderLayout extends SheetExtension {
     constructor(cfg?: IColumnsHeaderCfgParam);
     configHeaderColumn(cfg: IColumnsHeaderCfgParam, sheetId?: string): void;
     getColumnsCfg(sheetId: string): Record<number, IAColumnCfg>;
-    getHeaderStyle(sheetId: string): IHeaderStyleCfg;
+    getHeaderStyle(sheetId: string, isPrinting?: boolean): IHeaderStyleCfg;
     getCfgOfCurrentColumn(columnsCfg: Record<number, IAColumnCfg>, headerStyle: IHeaderStyleCfg, colIndex: number): [IAColumnCfgObj, boolean];
     setStyleToCtx(ctx: UniverRenderingContext, columnStyle: Partial<IHeaderStyleCfg>): void;
     draw(ctx: UniverRenderingContext, parentScale: IScale, spreadsheetSkeleton: SpreadsheetSkeleton): void;

package/lib/types/components/sheets/extensions/row-header-layout.d.ts

@@ -32,7 +32,7 @@ export declare class RowHeaderLayout extends SheetExtension {
     constructor(cfg?: IRowsHeaderCfgParam);
     configHeaderRow(cfg: IRowsHeaderCfgParam, sheetId?: string): void;
     getRowsCfg(sheetId: string): Record<number, IARowCfg>;
-    getHeaderStyle(sheetId: string): IRowStyleCfg;
+    getHeaderStyle(sheetId: string, isPrinting?: boolean): IRowStyleCfg;
     getCfgOfCurrentRow(rowsCfg: Record<number, IARowCfg>, headerStyle: IHeaderStyleCfg, rowIndex: number): [IARowCfgObj, boolean];
     setStyleToCtx(ctx: UniverRenderingContext, rowStyle: Partial<IHeaderStyleCfg>): void;
     draw(ctx: UniverRenderingContext, parentScale: IScale, spreadsheetSkeleton: SpreadsheetSkeleton): void;

package/lib/types/components/sheets/sheet.render-skeleton.d.ts

@@ -52,6 +52,10 @@ interface ISetStylesCacheForOneCellOptions {
     reuseExisting?: boolean;
     hasMergeData?: boolean;
     rowVisible?: boolean;
+    skipFontCache?: boolean;
+}
+export interface ISetStylesCacheOptions {
+    scaleY?: number;
 }
 export interface IGetPosByRowColOptions {
     closeFirst?: boolean;
@@ -78,6 +82,7 @@ export declare class SpreadsheetSkeleton extends SheetSkeleton {
     private _handleBorderMatrix;
     private _showGridlines;
     private _gridlinesColor;
+    private _defaultGridlinesColor;
     private _scene;
     constructor(worksheet: Worksheet, _styles: Styles, _localeService: LocaleService, _contextService: IContextService, _configService: IConfigService, _injector: Injector);
     registerGetCellHeight(): void;
@@ -98,6 +103,7 @@ export declare class SpreadsheetSkeleton extends SheetSkeleton {
     get incrementalFontRenderRanges(): IRange[];
     get showGridlines(): BooleanNumber;
     get gridlinesColor(): string | undefined;
+    get defaultGridlinesColor(): string;
     dispose(): void;
     setOverflowCache(value: ObjectMatrix<IRange>): void;
     getFont(rowIndex: number, columnIndex: number): Nullable<IFontCacheItem>;
@@ -116,8 +122,9 @@ export declare class SpreadsheetSkeleton extends SheetSkeleton {
     /**
      * Set border background and font to this._stylesCache by visible range, which derives from bounds)
      * @param vpInfo viewBounds
+     * @param options screen scale
      */
-    setStylesCache(vpInfo?: IViewportInfo): Nullable<SpreadsheetSkeleton>;
+    setStylesCache(vpInfo?: IViewportInfo, options?: ISetStylesCacheOptions): Nullable<SpreadsheetSkeleton>;
     /**
      * Calc all auto height by getDocsSkeletonPageSize in ranges
      * @param ranges

package/lib/types/components/sheets/spreadsheet.d.ts

@@ -15,7 +15,6 @@
  */
 import type { IPosition, IRange } from '@univerjs/core';
 import type { IBoundRectNoAngle, IViewportInfo, Vector2 } from '../../basics/vector2';
-import type { Canvas } from '../../canvas';
 import type { UniverRenderingContext2D } from '../../context';
 import type { Scene } from '../../scene';
 import type { Background } from './extensions/background';
@@ -23,10 +22,12 @@ import type { Border } from './extensions/border';
 import type { Font } from './extensions/font';
 import type { IPaintForRefresh, IPaintForScrolling } from './interfaces';
 import type { SpreadsheetSkeleton } from './sheet.render-skeleton';
+import { Canvas } from '../../canvas';
 import { Documents } from '../docs/document';
 import { SheetComponent } from './sheet-component';
 export declare class Spreadsheet extends SheetComponent {
     private _allowCache;
+    private _scrollBufferCanvases;
     private _backgroundExtension;
     private _borderExtension;
     private _fontExtension;
@@ -79,7 +80,9 @@ export declare class Spreadsheet extends SheetComponent {
     renderByViewports(mainCtx: UniverRenderingContext2D, viewportInfo: IViewportInfo, spreadsheetSkeleton: SpreadsheetSkeleton): void;
     private _getMergeRepairBounds;
     private _getRepaintBounds;
-    paintNewAreaForScrolling(viewportInfo: IViewportInfo, param: IPaintForScrolling, mergeRepairBounds?: IBoundRectNoAngle[]): void;
+    paintNewAreaForScrolling(viewportInfo: IViewportInfo, param: IPaintForScrolling, mergeRepairBounds?: IBoundRectNoAngle[]): Canvas;
+    private _copyCacheForScrolling;
+    private _getScrollBufferCanvas;
     /**
      * Redraw the entire viewport.
      */

package/lib/types/components/sheets/watermark/watermark-layer.d.ts

@@ -15,13 +15,14 @@
  */
 import type { IUser } from '@univerjs/core';
 import type { UniverRenderingContext } from '../../../context';
+import type { ILayerRenderOptions } from '../../../layer';
 import type { IWatermarkConfigWithType } from './type';
 import { Layer } from '../../../layer';
 export declare class WatermarkLayer extends Layer {
     private _config;
     private _image;
     private _user;
-    render(ctx?: UniverRenderingContext, isMaxLayer?: boolean): this;
+    render(ctx?: UniverRenderingContext, isMaxLayer?: boolean, options?: ILayerRenderOptions): this;
     updateConfig(config?: IWatermarkConfigWithType, user?: IUser): void;
     private _renderWatermark;
 }

package/lib/types/context.d.ts

@@ -21,6 +21,8 @@ export interface IUniverRenderingContextOptions {
 export declare class UniverRenderingContext2D implements CanvasRenderingContext2D {
     __mode: string;
     private _transformCache;
+    private _bitmapMutationId;
+    private _bitmapMutationTrackingDepth;
     readonly canvas: HTMLCanvasElement;
     _context: CanvasRenderingContext2D;
     private _systemType;
@@ -31,6 +33,8 @@ export declare class UniverRenderingContext2D implements CanvasRenderingContext2
     private _id;
     getId(): string;
     setId(id: string): void;
+    detectBitmapMutation(callback: () => void): boolean;
+    private _markBitmapMutation;
     isContextLost(): boolean;
     get globalAlpha(): number;
     set globalAlpha(val: number);

package/lib/types/engine.d.ts

@@ -171,6 +171,7 @@ export declare class Engine extends Disposable {
      * @returns a number representing the delta time in ms
      */
     getDeltaTime(): number;
+    getEstimatedFrameInterval(): number;
     /**
      * Exec all function in _renderFrameTasks
      */

package/lib/types/index.d.ts

@@ -25,6 +25,7 @@ export * from './components';
 export type { DocsCustomBlockRenderViewportProvider, IDocsCustomBlockRenderViewport, IDocsCustomBlockRenderViewportInput } from './components/docs/custom-block-render-viewport';
 export { getDocsCustomBlockRenderViewport, setDocsCustomBlockRenderViewportProvider } from './components/docs/custom-block-render-viewport';
 export { DocBackground } from './components/docs/doc-background';
+export { DOCS_EXTENSION_TYPE } from './components/docs/doc-extension';
 export { Documents } from './components/docs/document';
 export type { IPageRenderConfig } from './components/docs/document';
 export type { IDocumentOffsetConfig } from './components/docs/document';
@@ -33,6 +34,9 @@ export { measureDocumentNoWrapTextRangeWidth, measureDocumentNoWrapTextWidth, me
 export * from './components/docs/layout/doc-simple-skeleton';
 export { DocumentSkeleton } from './components/docs/layout/doc-skeleton';
 export type { IFindNodeRestrictions } from './components/docs/layout/doc-skeleton';
+export type { IDocumentLayoutPagePublication } from './components/docs/layout/document-layout-publication';
+export type { DocumentLayoutMode, DocumentLayoutReason, IDocumentLayoutApplyResult, IDocumentLayoutInvalidation, IDocumentLayoutPageRange, IDocumentLayoutProgress, IDocumentLayoutProtectedContinuousRange, IDocumentLayoutProtectedPageRange, IDocumentLayoutProtectedRange, } from './components/docs/layout/document-layout-types';
+export { invalidateDocumentFontMetrics } from './components/docs/layout/shaping-engine/font-cache';
 export { compareDocumentSkeletonNestedPagePathOrder, documentSkeletonLineIterator, documentSkeletonTableIterator, getCharSpaceApply, getDocumentSkeletonColumnPagePathInfo, getDocumentSkeletonNestedPageOffset, getLastLine, getNumberUnitValue, getPageFromPath, glyphIterator, lineIterator, } from './components/docs/layout/tools';
 export type { IDocumentSkeletonColumnPagePathInfo, IDocumentSkeletonLineContext, IDocumentSkeletonLineIteratorOptions, IDocumentSkeletonTableCellGeometry, IDocumentSkeletonTableContext, IDocumentSkeletonTableIteratorOptions } from './components/docs/layout/tools';
 export { getLastColumn } from './components/docs/layout/tools';
@@ -64,3 +68,5 @@ export * from './scroll-timer';
 export { CanvasColorService, DumbCanvasColorService, ICanvasColorService } from './services/canvas-color.service';
 export * from './shape';
 export * from './viewport';
+export { DocumentLayoutSession } from './worker-layout';
+export type { IDocumentLayoutSessionStartOptions, IDocumentLayoutStepResult } from './worker-layout';

package/lib/types/layer.d.ts

@@ -13,16 +13,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { IBoundRectNoAngle, IViewportInfo } from './basics/vector2';
 import type { UniverRenderingContext } from './context';
 import type { Scene } from './scene';
 import { Disposable } from '@univerjs/core';
 import { BaseObject } from './base-object';
+export interface IScrollRenderInfo {
+    bounds: IBoundRectNoAngle;
+    offsetX: number;
+    offsetY: number;
+}
+export interface ILayerRenderOptions {
+    dirtyBounds?: IBoundRectNoAngle[];
+    preserveCache?: boolean;
+    viewportInfos?: Map<string, IViewportInfo>;
+}
+export declare function scrollAndClearCanvas(ctx: UniverRenderingContext, pixelRatio: number, scrollRenderInfos: IScrollRenderInfo[], dirtyBounds: IBoundRectNoAngle[]): void;
 export declare class Layer extends Disposable {
     private _scene;
     private _zIndex;
     private _allowCache;
     private _objects;
     private _cacheCanvas;
+    private _cacheValid;
     protected _dirty: boolean;
     private _debounceDirtyFunc;
     constructor(_scene: Scene, objects?: BaseObject[], _zIndex?: number, _allowCache?: boolean);
@@ -59,7 +72,7 @@ export declare class Layer extends Disposable {
     makeDirty(state?: boolean): this;
     makeDirtyWithDebounce(state?: boolean): void;
     isDirty(): boolean;
-    render(parentCtx?: UniverRenderingContext, isMaxLayer?: boolean): this;
+    render(parentCtx?: UniverRenderingContext, isMaxLayer?: boolean, options?: ILayerRenderOptions): this;
     private _layerBehavior;
     private _initialCacheCanvas;
     private _draw;

package/lib/types/render-manager/render-manager.service.d.ts

@@ -50,6 +50,7 @@ export interface IRenderManagerService extends IDisposable {
      * @param dep
      */
     registerRenderModule<T extends UnitModel>(type: UniverInstanceType, dep: Dependency<T>): IDisposable;
+    registerRenderModule(type: UniverInstanceType, dep: Dependency): IDisposable;
 }
 export declare class RenderManagerService extends Disposable implements IRenderManagerService {
     protected readonly _injector: Injector;
@@ -71,6 +72,7 @@ export declare class RenderManagerService extends Disposable implements IRenderM
      * @param type
      * @param depCtor
      */
+    registerRenderModule<T extends UnitModel>(type: UniverInstanceType, depCtor: Dependency<T>): IDisposable;
     registerRenderModule(type: UniverInstanceType, depCtor: Dependency): IDisposable;
     /**
      * get render dependencies from _renderDependencies
@@ -78,7 +80,7 @@ export declare class RenderManagerService extends Disposable implements IRenderM
      * @returns Dependency[]
      */
     private _getRenderDepsByType;
-    private _initDarkModeListener;
+    private _initThemeListener;
     /**
      * create renderUnit & init deps from renderDependencies
      * @param unitId

package/lib/types/scene.d.ts

@@ -55,6 +55,14 @@ export declare class Scene extends Disposable {
     private _evented;
     private _layers;
     private _viewports;
+    private _preserveEngineOnRender;
+    private _hasPostRenderCanvasMutation;
+    private _scrollbarDragViewport;
+    private _isScrollbarSeeking;
+    private _isScrollbarPreviewDirty;
+    private _lastScrollbarSeekInputAt;
+    private _estimatedFullRenderDuration;
+    private _renderedViewportScrollPositions;
     private _cursor;
     private _defaultCursor;
     private _addObject$;
@@ -121,6 +129,11 @@ export declare class Scene extends Disposable {
     attachControl(options?: ISceneInputControlOptions): this | undefined;
     detachControl(): this;
     makeDirty(state?: boolean): this;
+    makeDirtyForScrolling(): this;
+    beginScrollbarDrag(viewport: Viewport): void;
+    updateScrollbarDrag(viewport: Viewport): void;
+    endScrollbarDrag(viewport: Viewport): void;
+    isScrollRenderPending(): boolean;
     makeDirtyNoParent(state?: boolean): this;
     enableLayerCache(...layerIndexes: number[]): void;
     disableLayerCache(...layerIndexes: number[]): void;
@@ -218,6 +231,12 @@ export declare class Scene extends Disposable {
     getViewports(): Viewport[];
     getMainViewport(): Viewport;
     getViewport(key: string): Viewport | undefined;
+    private _createScrollRenderState;
+    private _renderScrollbarSeekPreview;
+    private _shouldDeferScrollbarSeekRender;
+    private _recordRenderedViewportScrollPositions;
+    private _recordFullRenderDuration;
+    private _notifyAfterRender;
     render(parentCtx?: UniverRenderingContext): void;
     requestRender(parentCtx?: UniverRenderingContext): Promise<unknown>;
     /**

package/lib/types/scene.input-manager.d.ts

@@ -24,6 +24,8 @@ export declare class InputManager extends Disposable {
     static LongPressDelay: number;
     /** Time in milliseconds with two consecutive clicks will be considered as a double or triple click */
     static DoubleClickDelay: number;
+    /** The allowed distance between two consecutive touch taps. */
+    static TouchDoubleClickMovementThreshold: number;
     static TripleClickDelay: number;
     /** If you need to check double click without raising a single click at first click, enable this flag */
     static ExclusiveDoubleClickMode: boolean;
@@ -33,6 +35,8 @@ export declare class InputManager extends Disposable {
     private _onInput$;
     private _currentMouseEnterPicked;
     private _startingPosition;
+    private _pointerDownPosition;
+    private _pointerDragged;
     private _delayedTimeout;
     private _delayedTripeTimeout;
     private _doubleClickOccurred;
@@ -86,5 +90,6 @@ export declare class InputManager extends Disposable {
     private _isPointerSwiping;
     private _prePointerDoubleOrTripleClick;
     private _resetDoubleClickParam;
+    private _resetClickSequence;
     get capturedObject(): BaseObject | null;
 }

package/lib/types/scene.transformer.d.ts

@@ -46,6 +46,7 @@ export declare class Transformer extends Disposable implements ITransformerConfi
     hoverEnabled: boolean;
     hoverEnterFunc: Nullable<(e: IPointerEvent | IMouseEvent) => void>;
     hoverLeaveFunc: Nullable<(e: IPointerEvent | IMouseEvent) => void>;
+    moveEnabled: boolean;
     resizeEnabled: boolean;
     rotateEnabled: boolean;
     rotationSnaps: number[];
@@ -183,6 +184,7 @@ export declare class Transformer extends Disposable implements ITransformerConfi
     private _getSouthWestPoints;
     private _checkTransformerType;
     private _updateControlIterator;
+    private _getControlState;
     private _updateControl;
     private _hideControl;
     private _attachHover;

package/lib/types/services/canvas-color.service.d.ts

@@ -31,11 +31,12 @@ export declare class DumbCanvasColorService implements ICanvasColorService {
  */
 export declare class CanvasColorService extends Disposable implements ICanvasColorService {
     private readonly _themeService;
-    private readonly _cache;
+    private readonly _darkModeCache;
+    private readonly _resolvedThemeColors;
     private _invertAlgo;
     constructor(_themeService: ThemeService);
-    getRenderColor(color: string): string;
+    getRenderColor(inputColor: string): string;
+    private _cacheThemeColors;
 }
-export declare function getDarkRenderColorOverride(color: string): string | null;
 export declare function hexToRgb(_hex: string): RGBColorType;
 export declare function rgbToHex(rgbColor: RGBColorType): string;

package/lib/types/shape/checkbox.d.ts

@@ -20,6 +20,8 @@ export interface ICheckboxShapeProps extends IShapeProps {
     checked?: boolean;
 }
 export declare const CHECK_OBJECT_ARRAY: string[];
+export declare function isCheckboxGlyph(content: string): boolean;
+export declare function getCheckboxShapeSize(fontSize?: number): number;
 export declare class CheckboxShape extends Shape<ICheckboxShapeProps> {
     _checked: boolean;
     constructor(key: string, props: ICheckboxShapeProps);

package/lib/types/shape/image.d.ts

@@ -63,6 +63,8 @@ export declare class Image extends Shape<IImageProps> {
     private _renderByCropper;
     private _transformCalculateSrcRect;
     private _clipService;
+    private _rasterCacheSource;
+    private _autoRasterCache;
     objectType: ObjectType;
     isDrawingObject: boolean;
     constructor(id: string, config: IImageProps);
@@ -70,6 +72,7 @@ export declare class Image extends Shape<IImageProps> {
     get prstGeom(): Nullable<string>;
     get opacity(): number;
     get clipBounds(): Nullable<IShapeClipBounds>;
+    private _shouldRasterCache;
     setOpacity(opacity: number): void;
     setClipBounds(clipBounds?: Nullable<IShapeClipBounds>): void;
     setClipService(clipService: Nullable<IImageShapeClipService>): void;
@@ -100,6 +103,7 @@ export declare class Image extends Shape<IImageProps> {
     private _transformBySrcRect;
     render(mainCtx: UniverRenderingContext, bounds?: IViewportInfo): this;
     protected _draw(ctx: UniverRenderingContext, _bounds?: IViewportInfo, renderWidth?: number, renderHeight?: number): void;
+    private _drawNative;
     private _init;
     private _updateSrcRectByTransform;
     set transform(trans: Transform);

package/lib/types/shape/scroll-bar.d.ts

@@ -75,7 +75,6 @@ export declare class ScrollBar extends Disposable {
     private _pendingBarDeltaX;
     private _pendingBarDeltaY;
     private _pendingBarScrollFrameId;
-    private _pendingBarScrollThrottleId;
     private _horizonPointerMoveSub;
     private _horizonPointerUpSub;
     private _verticalPointerMoveSub;
@@ -85,6 +84,8 @@ export declare class ScrollBar extends Disposable {
     private _thumbActiveBackgroundColor;
     private _trackBackgroundColor;
     private _trackBorderColor;
+    private _trackBackgroundOpacity;
+    private _trackBorderOpacity;
     /**
      * The thickness of a scrolling track
      * ThumbSize = trackSize - thumbMargin * 2
@@ -143,7 +144,6 @@ export declare class ScrollBar extends Disposable {
     static attachTo(view: Viewport, props?: IScrollBarProps): ScrollBar;
     dispose(): void;
     private _scheduleBarScrollDelta;
-    private _requestPendingBarScrollFrame;
     private _flushPendingBarScroll;
     private _applyPendingBarScroll;
     render(ctx: UniverRenderingContext, left?: number, top?: number): void;

package/lib/types/shape/shape.d.ts

@@ -33,8 +33,10 @@ export interface IShapeProps extends IObjectFullState, ISize, IOffset, IScale {
     visible?: boolean;
     paintFirst?: PaintFirst;
     stroke?: Nullable<string | CanvasGradient>;
+    strokeOpacity?: number;
     strokeScaleEnabled?: boolean;
     fill?: Nullable<string | CanvasGradient>;
+    fillOpacity?: number;
     fillAfterStrokeEnabled?: boolean;
     hitStrokeWidth?: number | string;
     strokeLineJoin?: LineJoin;
@@ -58,14 +60,17 @@ export declare abstract class Shape<T extends IShapeProps> extends BaseObject {
     private _renderCacheCanvas;
     private _renderCacheBounds;
     private _renderCachePixelRatio;
+    private _renderCacheTransformSize;
     private _hoverCursor;
     private _moveCursor;
     private _fillRule;
     private _globalCompositeOperation;
     private _paintFirst;
     private _stroke;
+    private _strokeOpacity?;
     private _strokeScaleEnabled;
     private _fill;
+    private _fillOpacity?;
     private _fillAfterStrokeEnabled;
     private _hitStrokeWidth;
     private _strokeLineJoin;
@@ -90,8 +95,10 @@ export declare abstract class Shape<T extends IShapeProps> extends BaseObject {
     get globalCompositeOperation(): string;
     get paintFirst(): PaintFirst;
     get stroke(): Nullable<string | CanvasGradient>;
+    get strokeOpacity(): number | undefined;
     get strokeScaleEnabled(): boolean;
     get fill(): Nullable<string | CanvasGradient>;
+    get fillOpacity(): number | undefined;
     get fillAfterStrokeEnabled(): boolean;
     get hitStrokeWidth(): string | number;
     get strokeLineJoin(): LineJoin;
@@ -132,7 +139,9 @@ export declare abstract class Shape<T extends IShapeProps> extends BaseObject {
     toJson(): {
         [x: string]: any;
     };
-    protected _renderWithCache(ctx: UniverRenderingContext, bounds: IBoundRectNoAngle, draw: (cacheContext: UniverRenderingContext) => void): void;
+    transformByState(option: IObjectFullState): this | undefined;
+    translate(x?: number | string, y?: number | string): this;
+    protected _renderWithCache(ctx: UniverRenderingContext, bounds: IBoundRectNoAngle, draw: (cacheContext: UniverRenderingContext) => void, fixedPixelRatio?: number): void;
     protected _releaseRenderCache(): void;
     protected _draw(ctx: UniverRenderingContext, bounds?: IViewportInfo): void;
     private _initialProps;

package/lib/types/viewport.d.ts

@@ -253,6 +253,7 @@ export declare class Viewport {
     get _deltaViewportScrollX(): number;
     get _deltaViewportScrollY(): number;
     get canvas(): UniverCanvas | null;
+    swapCacheCanvas(cacheCanvas: UniverCanvas): UniverCanvas | null;
     enable(): void;
     disable(): void;
     /**
@@ -343,7 +344,7 @@ export declare class Viewport {
      * @param objects
      * @param isMaxLayer
      */
-    render(parentCtx?: UniverRenderingContext, objects?: BaseObject[], isMaxLayer?: boolean): void;
+    render(parentCtx?: UniverRenderingContext, objects?: BaseObject[], isMaxLayer?: boolean, viewportInfo?: IViewportInfo): void;
     private _makeDefaultViewport;
     calcViewportInfo(): IViewportInfo;
     /**
@@ -431,6 +432,7 @@ export declare class Viewport {
     private _diffViewBound;
     private _calcDiffCacheBound;
     private _drawScrollbar;
+    renderScrollbarOnly(ctx: UniverRenderingContext, pixelRatio: number): void;
     setViewportSize(props?: IViewProps): void;
 }
 export {};