@univerjs/engine-render 0.1.0-beta.0 → 0.1.0-beta.2

package/lib/types/components/sheets/sheet-component.d.ts

@@ -15,6 +15,7 @@
  */
 import type { IRange, Nullable } from '@univerjs/core';
 import type { IViewportBound, Vector2 } from '../../basics/vector2';
+import type { UniverRenderingContext } from '../../context';
 import { RenderComponent } from '../component';
 import type { SHEET_EXTENSION_TYPE } from './extensions/sheet-extension';
 import type { SpreadsheetSkeleton } from './sheet-skeleton';
@@ -23,7 +24,7 @@ export declare class SheetComponent extends RenderComponent<SpreadsheetSkeleton,
     constructor(oKey: string, _skeleton?: SpreadsheetSkeleton | undefined);
     getSkeleton(): SpreadsheetSkeleton | undefined;
     updateSkeleton(spreadsheetSkeleton: SpreadsheetSkeleton): void;
-    render(mainCtx: CanvasRenderingContext2D, bounds?: IViewportBound): this | undefined;
+    render(mainCtx: UniverRenderingContext, bounds?: IViewportBound): this | undefined;
     getParentScale(): {
         scaleX: number;
         scaleY: number;
@@ -45,8 +46,8 @@ export declare class SheetComponent extends RenderComponent<SpreadsheetSkeleton,
         endRow: number;
         endColumn: number;
     }>;
-    protected _draw(ctx: CanvasRenderingContext2D, bounds?: IViewportBound): void;
+    protected _draw(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
 }
 export declare class SpreadsheetHeader extends SheetComponent {
-    protected _draw(ctx: CanvasRenderingContext2D, bounds?: IViewportBound): void;
+    protected _draw(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
 }

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

@@ -144,13 +144,13 @@ export declare class SpreadsheetSkeleton extends Skeleton {
         startColumn: number;
         endColumn: number;
     };
-    getNoMergeCellPositionByIndex(rowIndex: number, columnIndex: number, scaleX: number, scaleY: number): {
+    getNoMergeCellPositionByIndex(rowIndex: number, columnIndex: number): {
         startY: number;
         endY: number;
         startX: number;
         endX: number;
     };
-    getNoMergeCellPositionByIndexWithNoHeader(rowIndex: number, columnIndex: number, scaleX: number, scaleY: number): {
+    getNoMergeCellPositionByIndexWithNoHeader(rowIndex: number, columnIndex: number): {
         startY: number;
         endY: number;
         startX: number;
@@ -224,8 +224,8 @@ export declare class SpreadsheetSkeleton extends Skeleton {
      * @param scaleX render scene scale x-axis, current Horizontal Scale, scene.getAncestorScale
      * @param scaleY render scene scale y-axis, current Vertical Scale, scene.getAncestorScale
      */
-    getCellByIndex(row: number, column: number, scaleX: number, scaleY: number): ISelectionCellWithCoord;
-    getCellByIndexWithNoHeader(row: number, column: number, scaleX: number, scaleY: number): {
+    getCellByIndex(row: number, column: number): ISelectionCellWithCoord;
+    getCellByIndexWithNoHeader(row: number, column: number): {
         actualRow: number;
         actualColumn: number;
         startY: number;
@@ -271,6 +271,12 @@ export declare class SpreadsheetSkeleton extends Skeleton {
         columnOffset: number;
         rowOffset: number;
     };
+    /**
+     * Calculate the overflow of cell text. If there is no value on either side of the cell,
+     * the text content of this cell can be drawn to both sides, not limited by the cell's width.
+     * Overflow on the left or right is aligned according to the text's horizontal alignment.
+     */
+    private _calculateOverflowCell;
     /**
      *
      * @param rowHeightAccumulation Row layout information
@@ -290,6 +296,7 @@ export declare class SpreadsheetSkeleton extends Skeleton {
     intersectMergeRange(row: number, column: number): boolean;
     private _calculateStylesCache;
     private _resetCache;
+    private _makeDocumentSkeletonDirty;
     private _setCellCache;
     private _updateConfigAndGetDocumentModel;
     private _getDocumentDataByStyle;

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

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import type { IViewportBound, Vector2 } from '../../basics/vector2';
+import type { UniverRenderingContext } from '../../context';
 import { Documents } from '../docs/document';
 import type { Background } from './extensions/background';
 import type { Border } from './extensions/border';
@@ -37,7 +38,7 @@ export declare class Spreadsheet extends SheetComponent {
     get borderExtension(): Border;
     get fontExtension(): Font;
     getDocuments(): Documents;
-    draw(ctx: CanvasRenderingContext2D, bounds?: IViewportBound): void;
+    draw(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
     isHit(coord: Vector2): boolean;
     getNoMergeCellPositionByIndex(rowIndex: number, columnIndex: number): {
         startY: number;
@@ -56,22 +57,16 @@ export declare class Spreadsheet extends SheetComponent {
         endRow: number;
         endColumn: number;
     } | undefined;
-    render(mainCtx: CanvasRenderingContext2D, bounds?: IViewportBound): this | undefined;
+    render(mainCtx: UniverRenderingContext, bounds?: IViewportBound): this | undefined;
     private _resizeCacheCanvas;
-    protected _applyCache(ctx?: CanvasRenderingContext2D, sx?: number, sy?: number, sw?: number, sh?: number, dx?: number, dy?: number, dw?: number, dh?: number): void;
-    protected _draw(ctx: CanvasRenderingContext2D, bounds?: IViewportBound): void;
+    protected _applyCache(ctx?: UniverRenderingContext, sx?: number, sy?: number, sw?: number, sh?: number, dx?: number, dy?: number, dw?: number, dh?: number): void;
+    protected _draw(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
     private _getAncestorSize;
     private _getAncestorParent;
     private _initialDefaultExtension;
     private _addMakeDirtyToScroll;
     private _hasScrollViewportOperator;
     private _getHasScrollViewports;
-    /**
-     * Calculate the overflow of cell text. If there is no value on either side of the cell,
-     * the text content of this cell can be drawn to both sides, not limited by the cell's width.
-     * Overflow on the left or right is aligned according to the text's horizontal alignment.
-     */
-    private _calculateOverflow;
     private _drawAuxiliary;
     /**
      * Clear the guide lines within a range in the table, to make room for merged cells and overflow.

package/lib/types/components/slides/slide.d.ts

@@ -15,6 +15,7 @@
  */
 import type { Nullable } from '@univerjs/core';
 import { Observable } from '@univerjs/core';
+import type { UniverRenderingContext } from '../../context';
 import type { Scene } from '../../scene';
 import { SceneViewer } from '../../scene-viewer';
 export declare enum SLIDE_NAVIGATION_KEY {
@@ -34,7 +35,7 @@ export declare class Slide extends SceneViewer {
     disableNav(): void;
     hiddenNav(): void;
     showNav(): void;
-    renderToThumb(mainCtx: CanvasRenderingContext2D, pageId: string, scaleX?: number, scaleY?: number): void;
+    renderToThumb(mainCtx: UniverRenderingContext, pageId: string, scaleX?: number, scaleY?: number): void;
     private _getSubScenesIndex;
     private _addNavTrigger;
     private _getArrowColor;

package/lib/types/context.d.ts

@@ -0,0 +1,399 @@
+/**
+ * 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 declare class UniverRenderingContext2D implements CanvasRenderingContext2D {
+    readonly canvas: HTMLCanvasElement;
+    _context: CanvasRenderingContext2D;
+    constructor(context: CanvasRenderingContext2D);
+    get globalAlpha(): number;
+    set globalAlpha(val: number);
+    get globalCompositeOperation(): GlobalCompositeOperation;
+    set globalCompositeOperation(val: GlobalCompositeOperation);
+    get fillStyle(): string | CanvasGradient | CanvasPattern;
+    set fillStyle(val: string | CanvasGradient | CanvasPattern);
+    get strokeStyle(): string | CanvasGradient | CanvasPattern;
+    set strokeStyle(val: string | CanvasGradient | CanvasPattern);
+    get filter(): string;
+    set filter(val: string);
+    get imageSmoothingEnabled(): boolean;
+    set imageSmoothingEnabled(val: boolean);
+    get imageSmoothingQuality(): ImageSmoothingQuality;
+    set imageSmoothingQuality(val: ImageSmoothingQuality);
+    get lineCap(): CanvasLineCap;
+    set lineCap(val: CanvasLineCap);
+    get lineDashOffset(): number;
+    set lineDashOffset(val: number);
+    get lineJoin(): CanvasLineJoin;
+    set lineJoin(val: CanvasLineJoin);
+    get lineWidth(): number;
+    set lineWidth(val: number);
+    get miterLimit(): number;
+    set miterLimit(val: number);
+    get shadowBlur(): number;
+    set shadowBlur(val: number);
+    get shadowColor(): string;
+    set shadowColor(val: string);
+    get shadowOffsetX(): number;
+    set shadowOffsetX(val: number);
+    get shadowOffsetY(): number;
+    set shadowOffsetY(val: number);
+    get direction(): CanvasDirection;
+    set direction(val: CanvasDirection);
+    get font(): string;
+    set font(val: string);
+    get fontKerning(): CanvasFontKerning;
+    set fontKerning(val: CanvasFontKerning);
+    get textAlign(): CanvasTextAlign;
+    set textAlign(val: CanvasTextAlign);
+    get textBaseline(): CanvasTextBaseline;
+    set textBaseline(val: CanvasTextBaseline);
+    private _getScale;
+    getContextAttributes(): CanvasRenderingContext2DSettings;
+    isPointInStroke(x: number, y: number): boolean;
+    isPointInStroke(path: Path2D, x: number, y: number): boolean;
+    createConicGradient(startAngle: number, x: number, y: number): CanvasGradient;
+    roundRect(x: number, y: number, w: number, h: number, radii?: number | DOMPointInit | Array<number | DOMPointInit>): void;
+    getTransform(): DOMMatrix;
+    resetTransform(): void;
+    drawFocusIfNeeded(element: Element): void;
+    drawFocusIfNeeded(path: Path2D, element: Element): void;
+    /**
+
+     * reset canvas context transform
+
+     * @method
+
+     */
+    reset(): void;
+    /**
+
+     * arc function.
+
+     * @method
+
+     */
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterClockwise?: boolean): void;
+    /**
+
+     * arcTo function.
+
+     * @method
+
+     *
+
+     */
+    arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+    /**
+
+     * beginPath function.
+
+     * @method
+
+     */
+    beginPath(): void;
+    /**
+
+     * bezierCurveTo function.
+
+     * @method
+
+     */
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    /**
+
+     * clearRect function.
+
+     * @method
+
+     */
+    clearRect(x: number, y: number, width: number, height: number): void;
+    /**
+
+     * clip function.
+
+     * @method
+
+     */
+    clip(): void;
+    clip(path: Path2D): void;
+    clip(fillRule?: CanvasFillRule): void;
+    clip(path: Path2D, fillRule?: CanvasFillRule): void;
+    /**
+
+     * closePath function.
+
+     * @method
+
+     */
+    closePath(): void;
+    /**
+
+     * createImageData function.
+
+     * @method
+
+     */
+    createImageData(width: number, height: number, settings?: ImageDataSettings): ImageData;
+    createImageData(imagedata: ImageData): ImageData;
+    /**
+
+     * createLinearGradient function.
+
+     * @method
+
+     */
+    createLinearGradient(x0: number, y0: number, x1: number, y1: number): CanvasGradient;
+    /**
+
+     * createPattern function.
+
+     * @method
+
+     */
+    createPattern(image: CanvasImageSource, repetition: string | null): CanvasPattern | null;
+    /**
+
+     * createRadialGradient function.
+
+     * @method
+
+     */
+    createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): CanvasGradient;
+    /**
+
+     * drawImage function.
+
+     * @method
+
+     */
+    drawImage(image: CanvasImageSource, sx: number, sy: number, sWidth?: number, sHeight?: number, dx?: number, dy?: number, dWidth?: number, dHeight?: number): void;
+    /**
+
+     * ellipse function.
+
+     * @method
+
+     */
+    ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    /**
+
+     * isPointInPath function.
+
+     * @method
+
+     */
+    isPointInPath(x: number, y: number, fillRule?: CanvasFillRule): boolean;
+    isPointInPath(path: Path2D, x: number, y: number, fillRule?: CanvasFillRule): boolean;
+    /**
+
+     * fill function.
+
+     * @method
+
+     */
+    fill(fillRule?: CanvasFillRule): void;
+    fill(path: Path2D, fillRule?: CanvasFillRule): void;
+    /**
+
+     * fillRect function.
+
+     * @method
+
+     */
+    fillRect(x: number, y: number, width: number, height: number): void;
+    /**
+
+     * strokeRect function.
+
+     * @method
+
+     */
+    strokeRect(x: number, y: number, width: number, height: number): void;
+    /**
+
+     * fillText function.
+
+     * @method
+
+     */
+    fillText(text: string, x: number, y: number, maxWidth?: number): void;
+    /**
+
+     * fillText function.
+
+     * @method
+
+     */
+    fillTextPrecision(text: string, x: number, y: number, maxWidth?: number): void;
+    /**
+
+     * measureText function.
+
+     * @method
+
+     */
+    measureText(text: string): TextMetrics;
+    /**
+
+     * getImageData function.
+
+     * @method
+
+     */
+    getImageData(sx: number, sy: number, sw: number, sh: number): ImageData;
+    /**
+
+     * lineTo function.
+
+     * @method
+
+     */
+    lineTo(x: number, y: number): void;
+    /**
+
+     * moveTo function.
+
+     * @method
+
+     */
+    moveTo(x: number, y: number): void;
+    /**
+
+     * rect function.
+
+     * @method
+
+     */
+    rect(x: number, y: number, width: number, height: number): void;
+    /**
+
+     * putImageData function.
+
+     * @method
+
+     */
+    putImageData(imageData: ImageData, dx: number, dy: number): void;
+    /**
+
+     * quadraticCurveTo function.
+
+     * @method
+
+     */
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    /**
+
+     * restore function.
+
+     * @method
+
+     */
+    restore(): void;
+    /**
+
+     * rotate function.
+
+     * @method
+
+     */
+    rotate(angle: number): void;
+    /**
+
+     * save function.
+
+     * @method
+
+     */
+    save(): void;
+    /**
+
+     * scale function.
+
+     * @method
+
+     */
+    scale(x: number, y: number): void;
+    /**
+
+     * setLineDash function.
+
+     * @method
+
+     */
+    setLineDash(segments: number[]): void;
+    /**
+
+     * getLineDash function.
+
+     * @method
+
+     */
+    getLineDash(): number[];
+    /**
+
+     * setTransform function.
+
+     * @method
+
+     */
+    setTransform(transform?: DOMMatrix2DInit): void;
+    setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+    /**
+
+     * stroke function.
+
+     * @method
+
+     */
+    stroke(path2d?: Path2D): void;
+    /**
+
+     * strokeText function.
+
+     * @method
+
+     */
+    strokeText(text: string, x: number, y: number, maxWidth?: number): void;
+    /**
+
+     * transform function.
+
+     * @method
+
+     */
+    transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+    /**
+
+     * translate function.
+
+     * @method
+
+     */
+    translate(x: number, y: number): void;
+    translateWithPrecision(x: number, y: number): void;
+    translateWithPrecisionRatio(x: number, y: number): void;
+}
+/**
+ * TODO
+ */
+export declare class UniverRenderingContextWebGL {
+}
+/**
+ * TODO
+ */
+export declare class UniverRenderingContextWebGPU {
+}
+export declare class UniverRenderingContext extends UniverRenderingContext2D {
+}

package/lib/types/custom/custom-object.d.ts

@@ -15,13 +15,14 @@
  */
 import { BaseObject } from '../base-object';
 import type { IViewportBound, Vector2 } from '../basics/vector2';
+import type { UniverRenderingContext } from '../context';
 export declare class CustomObject extends BaseObject {
     private _render;
     private _isHitCustom?;
-    constructor(key?: string, _render?: (mainCtx: CanvasRenderingContext2D) => void, _isHitCustom?: ((coord: Vector2) => boolean) | undefined);
+    constructor(key?: string, _render?: (mainCtx: UniverRenderingContext) => void, _isHitCustom?: ((coord: Vector2) => boolean) | undefined);
     toJson(): {
         [x: string]: any;
     };
-    render(mainCtx: CanvasRenderingContext2D, bounds?: IViewportBound): this;
+    render(mainCtx: UniverRenderingContext, bounds?: IViewportBound): this;
     isHit(coord: Vector2): boolean;
 }

package/lib/types/group.d.ts

@@ -17,6 +17,7 @@ import { BaseObject } from './base-object';
 import type { CURSOR_TYPE } from './basics/const';
 import { RENDER_CLASS_TYPE } from './basics/const';
 import type { IViewportBound, Vector2 } from './basics/vector2';
+import type { UniverRenderingContext } from './context';
 export declare class Group extends BaseObject {
     private _objects;
     constructor(key?: string, ...objects: BaseObject[]);
@@ -27,7 +28,7 @@ export declare class Group extends BaseObject {
     removeObject(object: BaseObject | string): void;
     getObjectsByOrder(): BaseObject[];
     getObjects(): BaseObject[];
-    render(ctx: CanvasRenderingContext2D, bounds?: IViewportBound): void;
+    render(ctx: UniverRenderingContext, bounds?: IViewportBound): void;
     resize(width?: number | string, height?: number | string): this;
     scale(scaleX?: number, scaleY?: number): this;
     skew(skewX?: number, skewY?: number): this;

package/lib/types/index.d.ts

@@ -18,6 +18,7 @@ export * from './basics';
 export * from './canvas';
 export * from './components';
 export { DocumentViewModel } from './components/docs/view-model/document-view-model';
+export * from './context';
 export * from './custom';
 export * from './engine';
 export * from './group';

package/lib/types/layer.d.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { BaseObject } from './base-object';
+import type { UniverRenderingContext } from './context';
 import type { ThinScene } from './thin-scene';
 export declare class Layer {
     private _scene;
@@ -37,7 +38,7 @@ export declare class Layer {
     removeObjects(objects: BaseObject[] | string[]): void;
     makeDirty(state?: boolean): this;
     isDirty(): boolean;
-    render(parentCtx?: CanvasRenderingContext2D, isMaxLayer?: boolean): this;
+    render(parentCtx?: UniverRenderingContext, isMaxLayer?: boolean): this;
     private _initialCacheCanvas;
     private _draw;
     private _applyCache;

package/lib/types/scene-viewer.d.ts

@@ -18,6 +18,7 @@ import { BaseObject } from './base-object';
 import { RENDER_CLASS_TYPE } from './basics/const';
 import type { IObjectFullState } from './basics/interfaces';
 import type { IViewportBound, Vector2 } from './basics/vector2';
+import type { UniverRenderingContext } from './context';
 import type { ThinScene } from './thin-scene';
 export declare class SceneViewer extends BaseObject {
     private _subScenes;
@@ -25,7 +26,7 @@ export declare class SceneViewer extends BaseObject {
     private _allowSelectedClipElement;
     constructor(key?: string, props?: IObjectFullState);
     get classType(): RENDER_CLASS_TYPE;
-    render(mainCtx: CanvasRenderingContext2D, bounds?: IViewportBound): this;
+    render(mainCtx: UniverRenderingContext, bounds?: IViewportBound): this;
     getSubScenes(): Map<string, ThinScene>;
     getActiveSubScene(): Nullable<ThinScene>;
     getSubScene(sceneKey: string): ThinScene | undefined;

package/lib/types/scene.d.ts

@@ -19,6 +19,7 @@ import { CURSOR_TYPE } from './basics/const';
 import type { IKeyboardEvent, IMouseEvent, IPointerEvent, IWheelEvent } from './basics/i-events';
 import type { ISceneTransformState } from './basics/interfaces';
 import { Vector2 } from './basics/vector2';
+import type { UniverRenderingContext } from './context';
 import { Layer } from './layer';
 import type { ITransformerConfig } from './scene.-transformer';
 import { Transformer } from './scene.-transformer';
@@ -89,8 +90,8 @@ export declare class Scene extends ThinScene {
     getViewports(): Viewport[];
     getViewport(key: string): Viewport | undefined;
     changeObjectOrder(): void;
-    render(parentCtx?: CanvasRenderingContext2D): void;
-    requestRender(parentCtx?: CanvasRenderingContext2D): Promise<unknown>;
+    render(parentCtx?: UniverRenderingContext): void;
+    requestRender(parentCtx?: UniverRenderingContext): Promise<unknown>;
     openTransformer(config?: ITransformerConfig): void;
     closeTransformer(isDestroyed?: boolean): void;
     applyTransformer(o: BaseObject): void;
@@ -117,6 +118,10 @@ export declare class Scene extends ThinScene {
         scaleX: number;
         scaleY: number;
     };
+    getPrecisionScale(): {
+        scaleX: number;
+        scaleY: number;
+    };
     dispose(): void;
     pick(coord: Vector2): Nullable<BaseObject | Scene | ThinScene>;
     triggerKeyDown(evt: IKeyboardEvent): void;

package/lib/types/scroll-timer.d.ts

@@ -14,11 +14,13 @@
  * limitations under the License.
  */
 import type { IPaddingData } from '@univerjs/core';
+import type { Scene } from './scene';
+import type { Viewport } from './viewport';
 export declare enum ScrollTimerType {
-    ALL = 0,
+    NONE = 0,
     X = 1,
     Y = 2,
-    NONE = 3
+    ALL = 3
 }
 export declare class ScrollTimer {
     private _scene;
@@ -35,15 +37,19 @@ export declare class ScrollTimer {
     private _scrollX;
     private _scrollY;
     private _scrollFunction;
-    constructor(_scene: any, _scrollTimerType?: ScrollTimerType, _padding?: IPaddingData | undefined, _smoothRatioX?: number, _smoothRatioY?: number);
+    constructor(_scene: Scene, _scrollTimerType?: ScrollTimerType, _padding?: IPaddingData | undefined, _smoothRatioX?: number, _smoothRatioY?: number);
     static create(scene: any, scrollTimerType?: ScrollTimerType, padding?: IPaddingData): ScrollTimer;
+    set scrollTimerType(type: ScrollTimerType);
+    get scrollTimerType(): ScrollTimerType;
+    setActiveViewport(viewport: Viewport): void;
+    getActiveViewport(): any;
     startScroll(offsetX: number, offsetY: number, targetViewport?: any): void;
     private _scroll;
     scrolling(offsetX: number, offsetY: number, scrollFunction: (x?: number, y?: number) => void): void;
     stopScroll(): void;
     dispose(): void;
-    getViewportByCoord(scene?: any): any;
-    getScene(): any;
+    getViewportByCoord(scene?: Scene): Viewport | undefined;
+    getScene(): Scene;
     private _runRenderLoop;
     private _findAncestorScene;
 }