@univerjs/engine-render 1.0.0-alpha.8 → 1.0.0-beta.1

package/lib/types/scene.d.ts

@@ -55,6 +55,13 @@ export declare class Scene extends Disposable {
     private _evented;
     private _layers;
     private _viewports;
+    private _preserveEngineOnRender;
+    private _scrollbarDragViewport;
+    private _isScrollbarSeeking;
+    private _isScrollbarPreviewDirty;
+    private _lastScrollbarSeekInputAt;
+    private _estimatedFullRenderDuration;
+    private _renderedViewportScrollPositions;
     private _cursor;
     private _defaultCursor;
     private _addObject$;
@@ -121,6 +128,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 +230,11 @@ 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;
     render(parentCtx?: UniverRenderingContext): void;
     requestRender(parentCtx?: UniverRenderingContext): Promise<unknown>;
     /**

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

@@ -95,6 +95,7 @@ export declare class Transformer extends Disposable implements ITransformerConfi
     boundBoxFunc: Nullable<(oldBox: BaseObject, newBox: BaseObject) => BaseObject>;
     useSingleNodeRotation: boolean;
     shouldOverdrawWholeArea: boolean;
+    controlLayerIndex: number | undefined;
     private readonly _changeStart$;
     /**
      * actually pointer down on a object,

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

@@ -31,10 +31,13 @@ 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 _resolvedColorCache;
     private _invertAlgo;
     constructor(_themeService: ThemeService);
-    getRenderColor(color: string): string;
+    getRenderColor(inputColor: string): string;
+    private _resolveColor;
+    private _resolveThemeColor;
 }
 export declare function getDarkRenderColorOverride(color: string): string | null;
 export declare function hexToRgb(_hex: string): RGBColorType;

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

@@ -43,14 +43,18 @@ export interface IScrollBarProps {
     enableHorizontal?: boolean;
     /** Enable the vertical scroll bar. True by default. */
     enableVertical?: boolean;
+    /** Hide the track when the corresponding content axis does not overflow. False by default. */
+    hideTrackWhenUnscrollable?: boolean;
     /** The min width of horizon thumb. Default is 17 px. */
     minThumbSizeH?: number;
     /** The min height of vertical thumb. Default is 17 px. */
     minThumbSizeV?: number;
 }
 export declare class ScrollBar extends Disposable {
+    static readonly DEFAULT_TOTAL_SIZE: number;
     _enableHorizontal: boolean;
     _enableVertical: boolean;
+    private _hideTrackWhenUnscrollable;
     horizontalThumbSize: number;
     horizontalMinusMiniThumb: number;
     horizontalTrackWidth: number;
@@ -71,7 +75,6 @@ export declare class ScrollBar extends Disposable {
     private _pendingBarDeltaX;
     private _pendingBarDeltaY;
     private _pendingBarScrollFrameId;
-    private _pendingBarScrollThrottleId;
     private _horizonPointerMoveSub;
     private _horizonPointerUpSub;
     private _verticalPointerMoveSub;
@@ -109,6 +112,8 @@ export declare class ScrollBar extends Disposable {
     set enableHorizontal(val: boolean);
     get enableVertical(): boolean;
     set enableVertical(val: boolean);
+    get hideTrackWhenUnscrollable(): boolean;
+    set hideTrackWhenUnscrollable(val: boolean);
     get limitX(): number;
     get limitY(): number;
     get ratioScrollX(): number;
@@ -137,7 +142,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

@@ -58,6 +58,7 @@ export declare abstract class Shape<T extends IShapeProps> extends BaseObject {
     private _renderCacheCanvas;
     private _renderCacheBounds;
     private _renderCachePixelRatio;
+    private _renderCacheTransformSize;
     private _hoverCursor;
     private _moveCursor;
     private _fillRule;
@@ -132,7 +133,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 {};