@hufe921/canvas-editor 1.0.5 → 1.1.0

package/dist/src/editor/core/draw/particle/LineBreakParticle.d.ts

@@ -1,4 +1,5 @@
 import { IRowElement } from '../../../interface/Row';
+import { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export declare class LineBreakParticle {
     private options;
@@ -6,5 +7,5 @@ export declare class LineBreakParticle {
     static readonly HEIGHT = 9;
     static readonly GAP = 3;
     constructor(draw: Draw);
-    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    render(ctx: IRenderContext, element: IRowElement, x: number, y: number): void;
 }

package/dist/src/editor/core/draw/particle/ListParticle.d.ts

@@ -1,6 +1,7 @@
 import { ListStyle, ListType } from '../../../dataset/enum/List';
 import { IElement, IElementPosition } from '../../../interface/Element';
 import { IRow } from '../../../interface/Row';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export declare class ListParticle {
     private draw;
@@ -26,5 +27,5 @@ export declare class ListParticle {
     private findStyledElement;
     private getListFontStyle;
     getListStyleWidth(ctx: CanvasRenderingContext2D, listElementList: IElement[]): number;
-    drawListStyle(ctx: CanvasRenderingContext2D, row: IRow, position: IElementPosition): void;
+    drawListStyle(ctx: IRenderContext, row: IRow, position: IElementPosition): void;
 }

package/dist/src/editor/core/draw/particle/PageBreakParticle.d.ts

@@ -1,9 +1,10 @@
 import { IRowElement } from '../../../interface/Row';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export declare class PageBreakParticle {
     private draw;
     private options;
     private i18n;
     constructor(draw: Draw);
-    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    render(ctx: IRenderContext, element: IRowElement, x: number, y: number): void;
 }

package/dist/src/editor/core/draw/particle/RadioParticle.d.ts

@@ -1,8 +1,9 @@
 import { IElement } from '../../../interface/Element';
 import { IRow } from '../../../interface/Row';
+import { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 interface IRadioRenderOption {
-    ctx: CanvasRenderingContext2D;
+    ctx: IRenderContext;
     x: number;
     y: number;
     row: IRow;

package/dist/src/editor/core/draw/particle/SeparatorParticle.d.ts

@@ -1,7 +1,8 @@
 import { IRowElement } from '../../../interface/Row';
+import { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export declare class SeparatorParticle {
     private options;
     constructor(draw: Draw);
-    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    render(ctx: IRenderContext, element: IRowElement, x: number, y: number): void;
 }

package/dist/src/editor/core/draw/particle/SubscriptParticle.d.ts

@@ -1,5 +1,6 @@
 import { IRowElement } from '../../../interface/Row';
+import { IRenderContext } from '../../render/model/RenderContext';
 export declare class SubscriptParticle {
     getOffsetY(element: IRowElement): number;
-    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    render(ctx: IRenderContext, element: IRowElement, x: number, y: number): void;
 }

package/dist/src/editor/core/draw/particle/SuperscriptParticle.d.ts

@@ -1,5 +1,6 @@
 import { IRowElement } from '../../../interface/Row';
+import { IRenderContext } from '../../render/model/RenderContext';
 export declare class SuperscriptParticle {
     getOffsetY(element: IRowElement): number;
-    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    render(ctx: IRenderContext, element: IRowElement, x: number, y: number): void;
 }

package/dist/src/editor/core/draw/particle/TextParticle.d.ts

@@ -1,6 +1,7 @@
 import { IElement } from '../../..';
 import { IRowElement } from '../../../interface/Row';
 import { ITextMetrics } from '../../../interface/Text';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export interface IMeasureWordResult {
     width: number;
@@ -15,7 +16,10 @@ export declare class TextParticle {
     private text;
     private curStyle;
     private curColor?;
-    cacheMeasureText: Map<string, TextMetrics>;
+    private curSourceElement?;
+    private sourceKeys;
+    private sourceKeyId;
+    private textMeasurer;
     constructor(draw: Draw);
     measureBasisWord(ctx: CanvasRenderingContext2D, font: string): ITextMetrics;
     measureWord(ctx: CanvasRenderingContext2D, elementList: IElement[], curIndex: number): IMeasureWordResult;
@@ -23,7 +27,9 @@ export declare class TextParticle {
     measureText(ctx: CanvasRenderingContext2D, element: IElement): ITextMetrics;
     getBasisWordBoundingBoxAscent(ctx: CanvasRenderingContext2D, font: string): number;
     complete(): void;
-    record(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    renderTabLeader(ctx: IRenderContext, element: IRowElement, x: number, y: number): void;
+    record(ctx: IRenderContext, element: IRowElement, x: number, y: number): void;
     private _setCurXY;
+    private _getSourceKey;
     private _render;
 }

package/dist/src/editor/core/draw/particle/TraceParticle.d.ts

@@ -1,9 +1,10 @@
 import { IElement, IElementMetrics, IElementPosition } from '../../../interface/Element';
 import { IRow, IRowElement } from '../../../interface/Row';
 import { IMarkElementListDeletedOption } from '../../../interface/Trace';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 interface ITraceRenderContext {
-    ctx: CanvasRenderingContext2D;
+    ctx: IRenderContext;
     element: IRowElement;
     x: number;
     y: number;
@@ -29,7 +30,7 @@ export declare class TraceParticle {
     handleMouseMove(evt: MouseEvent): void;
     private _getTraceFlags;
     render(context: ITraceRenderContext): void;
-    flush(ctx: CanvasRenderingContext2D): void;
+    flush(ctx: IRenderContext): void;
     private _flushStrikeout;
     private _flushUnderline;
     isTraceHidden(element: IElement): boolean;

package/dist/src/editor/core/draw/particle/WhiteSpaceParticle.d.ts

@@ -1,7 +1,8 @@
 import { IRowElement } from '../../../interface/Row';
+import { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export declare class WhiteSpaceParticle {
     private options;
     constructor(draw: Draw);
-    render(ctx: CanvasRenderingContext2D, element: IRowElement, x: number, y: number): void;
+    render(ctx: IRenderContext, element: IRowElement, x: number, y: number): void;
 }

package/dist/src/editor/core/draw/particle/block/BlockParticle.d.ts

@@ -1,5 +1,6 @@
 import { IIframeInfo } from '../../../../interface/Block';
 import { IRowElement } from '../../../../interface/Row';
+import type { IRenderContext } from '../../../render/model/RenderContext';
 import { Draw } from '../../Draw';
 export declare class BlockParticle {
     private draw;
@@ -11,9 +12,10 @@ export declare class BlockParticle {
     private _createBlockContainer;
     getDraw(): Draw;
     getBlockContainer(): HTMLDivElement;
-    render(ctx: CanvasRenderingContext2D, pageNo: number, element: IRowElement, x: number, y: number): void;
+    render(ctx: IRenderContext, pageNo: number, element: IRowElement, x: number, y: number): void;
     clear(): void;
     update(): void;
     drawIframeToPage(pageList: HTMLCanvasElement[], snapDomFunction: (iframe: HTMLIFrameElement) => Promise<string>): Promise<void>;
+    drawIframeToSvgPage(pageList: SVGSVGElement[], snapDomFunction: (iframe: HTMLIFrameElement) => Promise<string>): Promise<void>;
     pickIframeInfo(): IIframeInfo[][];
 }

package/dist/src/editor/core/draw/particle/block/modules/BaseBlock.d.ts

@@ -1,4 +1,5 @@
 import { IRowElement } from '../../../../../interface/Row';
+import type { IRenderContext } from '../../../../render/model/RenderContext';
 import { BlockParticle } from '../BlockParticle';
 import { IFrameBlock } from './IFrameBlock';
 import { VideoBlock } from './VideoBlock';
@@ -33,7 +34,7 @@ export declare class BaseBlock {
     private _updateResizerRect;
     private _mousedown;
     private _mousemove;
-    snapshot(ctx: CanvasRenderingContext2D, pageNo: number, x: number, y: number): void;
+    snapshot(ctx: IRenderContext, pageNo: number, x: number, y: number): void;
     render(): void;
     setClientRects(pageNo: number, x: number, y: number): void;
     setStatus(): void;

package/dist/src/editor/core/draw/particle/block/modules/VideoBlock.d.ts

@@ -1,8 +1,9 @@
 import { IRowElement } from '../../../../../interface/Row';
+import type { IRenderContext } from '../../../../render/model/RenderContext';
 export declare class VideoBlock {
     private element;
     protected videoCache: Map<string, HTMLVideoElement>;
     constructor(element: IRowElement);
-    snapshot(ctx: CanvasRenderingContext2D, x: number, y: number): Promise<unknown>;
+    snapshot(ctx: IRenderContext, x: number, y: number): Promise<unknown>;
     render(blockItemContainer: HTMLDivElement): void;
 }

package/dist/src/editor/core/draw/particle/date/DatePicker.d.ts

@@ -59,6 +59,7 @@ export declare class DatePicker {
     private _bindEvent;
     private _setPosition;
     isInvalidDate(value: Date): boolean;
+    parseDate(value: string, format: string): Date | null;
     private _setValue;
     private _getDatePickerType;
     private _getLang;

package/dist/src/editor/core/draw/particle/latex/LaTexParticle.d.ts

@@ -1,7 +1,12 @@
 import { IElement } from '../../../../interface/Element';
+import { IRenderContext } from '../../../render/model/RenderContext';
+import { Draw } from '../../Draw';
 import { ImageParticle } from '../ImageParticle';
 import { LaTexSVG } from './utils/LaTexUtils';
 export declare class LaTexParticle extends ImageParticle {
+    private latexDraw;
+    private pendingLaTexMap;
+    constructor(draw: Draw);
     static convertLaTextToSVG(laTex: string): LaTexSVG;
-    render(ctx: CanvasRenderingContext2D, element: IElement, x: number, y: number): void;
+    render(ctx: IRenderContext, element: IElement, x: number, y: number): void;
 }

package/dist/src/editor/core/draw/particle/table/TableOperate.d.ts

@@ -26,6 +26,8 @@ export declare class TableOperate {
     tableBorderType(payload: TableBorder): void;
     tableBorderColor(payload: string): void;
     tableTdBorderType(payload: TdBorder): void;
+    tableTdBorderColor(payload: string): void;
+    tableTdBorderWidth(payload: number): void;
     tableTdSlashType(payload: TdSlash): void;
     tableTdBackgroundColor(payload: string): void;
     private _measureTdContentWidth;

package/dist/src/editor/core/draw/particle/table/TableParticle.d.ts

@@ -3,6 +3,7 @@ import { ITableRowFragment } from '../../../../interface/Element';
 import { IRow } from '../../../../interface/Row';
 import { ITd } from '../../../../interface/table/Td';
 import { ITr } from '../../../../interface/table/Tr';
+import { IRenderContext } from '../../../render/model/RenderContext';
 import { Draw } from '../../Draw';
 export declare class TableParticle {
     private draw;
@@ -36,6 +37,6 @@ export declare class TableParticle {
     getTdListByColIndex(trList: ITr[], colIndex: number): ITd[];
     getTdListByRowIndex(trList: ITr[], rowIndex: number): ITd[];
     computeRowColInfo(element: IElement): void;
-    drawRange(ctx: CanvasRenderingContext2D, element: IElement, startX: number, startY: number, fragment?: ITableRowFragment): void;
-    render(ctx: CanvasRenderingContext2D, element: IElement, startX: number, startY: number, fragment?: ITableRowFragment): void;
+    drawRange(ctx: IRenderContext, element: IElement, startX: number, startY: number, fragment?: ITableRowFragment): void;
+    render(ctx: IRenderContext, element: IElement, startX: number, startY: number, fragment?: ITableRowFragment): void;
 }

package/dist/src/editor/core/draw/richtext/AbstractRichText.d.ts

@@ -1,11 +1,12 @@
 import { TextDecorationStyle } from '../../../dataset/enum/Text';
 import { IElementFillRect } from '../../../interface/Element';
+import type { IRenderContext } from '../../render/model/RenderContext';
 export declare abstract class AbstractRichText {
     protected fillRect: IElementFillRect;
     protected fillColor?: string;
     protected fillDecorationStyle?: TextDecorationStyle;
     constructor();
     clearFillInfo(): IElementFillRect;
-    recordFillInfo(ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height?: number, color?: string, decorationStyle?: TextDecorationStyle): void;
-    abstract render(ctx: CanvasRenderingContext2D): void;
+    recordFillInfo(ctx: IRenderContext, x: number, y: number, width: number, height?: number, color?: string, decorationStyle?: TextDecorationStyle): void;
+    abstract render(ctx: IRenderContext): void;
 }

package/dist/src/editor/core/draw/richtext/Highlight.d.ts

@@ -1,7 +1,8 @@
 import { AbstractRichText } from './AbstractRichText';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export declare class Highlight extends AbstractRichText {
     private options;
     constructor(draw: Draw);
-    render(ctx: CanvasRenderingContext2D): void;
+    render(ctx: IRenderContext): void;
 }

package/dist/src/editor/core/draw/richtext/Strikeout.d.ts

@@ -1,7 +1,8 @@
 import { AbstractRichText } from './AbstractRichText';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export declare class Strikeout extends AbstractRichText {
     private options;
     constructor(draw: Draw);
-    render(ctx: CanvasRenderingContext2D): void;
+    render(ctx: IRenderContext): void;
 }

package/dist/src/editor/core/draw/richtext/Underline.d.ts

@@ -1,4 +1,5 @@
 import { AbstractRichText } from './AbstractRichText';
+import type { IRenderContext } from '../../render/model/RenderContext';
 import { Draw } from '../Draw';
 export declare class Underline extends AbstractRichText {
     private options;
@@ -6,5 +7,5 @@ export declare class Underline extends AbstractRichText {
     private _drawLine;
     private _drawDouble;
     private _drawWave;
-    render(ctx: CanvasRenderingContext2D): void;
+    render(ctx: IRenderContext): void;
 }

package/dist/src/editor/core/draw/ruler/Ruler.d.ts

@@ -3,6 +3,7 @@ export declare class Ruler {
     private readonly MM_PX;
     private readonly HANDLE_HIT_TOLERANCE;
     private readonly MIN_INNER_SIZE;
+    private readonly MIN_INNER_SIZE_INDENT;
     private draw;
     private options;
     private container;
@@ -14,6 +15,17 @@ export declare class Ruler {
     private dragSide;
     private dragStartPosition;
     private dragOriginMargins;
+    private dragIndentTarget;
+    private dragOriginIndents;
+    private isIndentApplied;
+    private dragTabStopIndex;
+    private dragOriginTabStops;
+    private dragOriginTabStopX;
+    private isTabStopApplied;
+    private isTabStopDragOutside;
+    private guideline;
+    private indentMarkerPositionCache;
+    private tabStopPositionCache;
     private mousemoveHandler;
     private mouseupHandler;
     constructor(draw: Draw);
@@ -24,18 +36,35 @@ export declare class Ruler {
     render(): void;
     private _renderX;
     private _renderY;
-    private _drawXHandle;
-    private _drawYHandle;
+    private _getParagraphElementList;
+    private _getParagraphIndents;
+    private _getFirstParagraphElementList;
+    private _getIndentAnchor;
+    private _getParagraphTabStops;
+    private _getIndentMarkerPositions;
+    private _drawIndentMarker;
+    private _drawTabStopMark;
+    private _getHitIndentTarget;
+    private _getHitTabStopIndex;
+    private _addTabStop;
+    private _showGuideline;
+    private _removeGuideline;
     private _getHitMarginSideX;
     private _getHitMarginSideY;
     private _getRelativeX;
     private _getRelativeY;
+    private _getRelativeYOnCanvasX;
     private _isMarginDragDisabled;
     private _startDrag;
+    private _startIndentDrag;
+    private _startTabStopDrag;
     private _mousedownX;
     private _mousedownY;
     private _updateCursorX;
     private _updateCursorY;
+    private _resetCursor;
+    private _dragIndent;
+    private _dragTabStop;
     private _dragMargin;
     private _stopDrag;
     clampMargin(value: number, max: number): number;

package/dist/src/editor/core/event/GlobalEvent.d.ts

@@ -8,6 +8,7 @@ export declare class GlobalEvent {
     private range;
     private previewer;
     private tableTool;
+    private areaTool;
     private hyperlinkParticle;
     private hintParticle;
     private control;

package/dist/src/editor/core/event/pagePointer.d.ts

@@ -0,0 +1,8 @@
+import type { RenderPage } from '../render/RenderBackend';
+export interface IPagePointer {
+    x: number;
+    y: number;
+    pageNo: number;
+    page: RenderPage;
+}
+export declare function getPagePointer(evt: MouseEvent, pageContainer: HTMLElement): IPagePointer | null;

package/dist/src/editor/core/layout/LayoutEngine.d.ts

@@ -0,0 +1,31 @@
+import { PageMode, PaperDirection } from '../../dataset/enum/Editor';
+import { IComputeRowListPayload } from '../../interface/Draw';
+import { IElement } from '../../interface/Element';
+import { IRow } from '../../interface/Row';
+import type { Draw } from '../draw/Draw';
+export interface IComputePageListPayload {
+    rowList: IRow[];
+    elementList: IElement[];
+    pageMode: PageMode;
+    paperDirection: PaperDirection;
+    maxPageNo?: number | null;
+}
+export interface IComputePageListResult {
+    pageRowList: IRow[][];
+    pageDirectionList: PaperDirection[];
+    elementList: IElement[];
+    isElementListTruncated: boolean;
+}
+export declare class LayoutEngine {
+    private draw;
+    private controlMinWidthPlaceholderElementListSet;
+    constructor(draw: Draw);
+    consumeControlMinWidthPlaceholders(elementList: IElement[]): void;
+    markControlMinWidthPlaceholders(elementList: IElement[]): void;
+    getIsControlMinWidthPlaceholder(elementList: IElement[]): boolean;
+    computeRowList(payload: IComputeRowListPayload): IRow[];
+    computePageList(payload: IComputePageListPayload): IComputePageListResult;
+    private _getHitTabStop;
+    private _isHangPunctuation;
+    private _getTabRunWidth;
+}

package/dist/src/editor/core/layout/TextMeasurer.d.ts

@@ -0,0 +1,10 @@
+import { IElement } from '../../interface/Element';
+import { ITextMetrics } from '../../interface/Text';
+export declare class TextMeasurer {
+    private ctx;
+    private cache;
+    constructor(ctx?: CanvasRenderingContext2D);
+    measure(element: IElement, font: string, ctx?: CanvasRenderingContext2D): ITextMetrics;
+    measureText(value: string, font: string, ctx?: CanvasRenderingContext2D): ITextMetrics;
+    measureBasis(font: string, ctx?: CanvasRenderingContext2D): ITextMetrics;
+}

package/dist/src/editor/core/range/RangeManager.d.ts

@@ -2,6 +2,7 @@ import { IControlContext } from '../../interface/Control';
 import { IElement } from '../../interface/Element';
 import { IRange, IRangeElementStyle, IRangeParagraphInfo, RangeRowArray, RangeRowMap } from '../../interface/Range';
 import { Draw } from '../draw/Draw';
+import type { IRenderContext } from '../render/model/RenderContext';
 export declare class RangeManager {
     private draw;
     private options;
@@ -40,6 +41,6 @@ export declare class RangeManager {
     setRangeStyle(): void;
     recoveryRangeStyle(): void;
     shrinkBoundary(context?: IControlContext): void;
-    render(ctx: CanvasRenderingContext2D, x: number, y: number, width: number, height: number): void;
+    render(ctx: IRenderContext, x: number, y: number, width: number, height: number): void;
     toString(): string;
 }

package/dist/src/editor/core/render/BackendFactory.d.ts

@@ -0,0 +1,3 @@
+import { BackendType } from '../../dataset/enum/Editor';
+import type { IRenderBackend } from './RenderBackend';
+export declare function createBackend(type: BackendType | undefined, pageContainer: HTMLElement): IRenderBackend;

package/dist/src/editor/core/render/RenderBackend.d.ts

@@ -0,0 +1,24 @@
+import type { DisplayList } from './model/DisplayList';
+export type RenderPage = HTMLElement | SVGSVGElement;
+export interface IPageResizeOption {
+    gap?: number;
+    updateCssHeight?: boolean;
+}
+export interface ICanvasCapability {
+    getPage(pageNo: number): HTMLCanvasElement;
+    getPageList(): HTMLCanvasElement[];
+    getContext(pageNo: number): CanvasRenderingContext2D;
+}
+export interface IRenderBackend {
+    readonly canvas: ICanvasCapability | null;
+    create(pageNo: number, width: number, height: number, gap: number, dpr: number): void;
+    resize(pageNo: number, width: number, height: number, dpr: number, options?: IPageResizeOption): void;
+    resizeHeight(pageNo: number, height: number, dpr: number): void;
+    renderPage(pageNo: number, displayList: DisplayList): void;
+    flush?(): void;
+    observeVisibility(callback: (pageNo: number) => void): void;
+    disconnectVisibility(): void;
+    getPage(pageNo: number): RenderPage;
+    getPageList(): RenderPage[];
+    destroy(): void;
+}

package/dist/src/editor/core/render/canvas/CanvasBackend.d.ts

@@ -0,0 +1,19 @@
+import type { DisplayList } from '../model/DisplayList';
+import type { ICanvasCapability, IPageResizeOption, IRenderBackend } from '../RenderBackend';
+export declare class CanvasBackend implements IRenderBackend, ICanvasCapability {
+    readonly canvas: ICanvasCapability;
+    private surface;
+    private renderer;
+    private pageList;
+    constructor(pageContainer: HTMLElement);
+    create(pageNo: number, width: number, height: number, gap: number, dpr: number): void;
+    resize(pageNo: number, width: number, height: number, dpr: number, options?: IPageResizeOption): void;
+    resizeHeight(pageNo: number, height: number, dpr: number): void;
+    renderPage(pageNo: number, displayList: DisplayList): void;
+    observeVisibility(callback: (pageNo: number) => void): void;
+    disconnectVisibility(): void;
+    getPage(pageNo: number): HTMLCanvasElement;
+    getPageList(): HTMLCanvasElement[];
+    getContext(pageNo: number): CanvasRenderingContext2D;
+    destroy(): void;
+}

package/dist/src/editor/core/render/canvas/CanvasRenderer.d.ts

@@ -0,0 +1,5 @@
+import { DisplayList } from '../model/DisplayList';
+export declare class CanvasRenderer {
+    render(ctx: CanvasRenderingContext2D, displayList: DisplayList): void;
+    private _isRenderPattern;
+}

package/dist/src/editor/core/render/canvas/CanvasSurface.d.ts

@@ -0,0 +1,17 @@
+export declare class CanvasSurface {
+    private pageContainer;
+    private visibilityObserver;
+    constructor(pageContainer: HTMLElement);
+    create(pageNo: number, width: number, height: number, gap: number, dpr: number): {
+        page: HTMLCanvasElement;
+        ctx: CanvasRenderingContext2D;
+    };
+    private initializeContext;
+    resize(page: HTMLCanvasElement, ctx: CanvasRenderingContext2D, width: number, height: number, dpr: number, options?: {
+        gap?: number;
+        updateCssHeight?: boolean;
+    }): void;
+    resizeHeight(page: HTMLCanvasElement, ctx: CanvasRenderingContext2D, height: number, dpr: number): void;
+    observeVisibility(pageList: Element[], callback: (pageNo: number) => void): void;
+    disconnectVisibility(): void;
+}

package/dist/src/editor/core/render/model/DisplayList.d.ts

@@ -0,0 +1,62 @@
+import type { ISceneResourceIdentity, SceneGroupKind } from '../svg/scene/SceneNode';
+import { IRenderContext, IRenderPattern, IRenderSource } from './RenderContext';
+export type IRenderMethodName = 'save' | 'restore' | 'fillRect' | 'beginPath' | 'moveTo' | 'lineTo' | 'arc' | 'quadraticCurveTo' | 'bezierCurveTo' | 'rect' | 'closePath' | 'fill' | 'strokeRect' | 'scale' | 'rotate' | 'clip' | 'fillText' | 'translate' | 'stroke' | 'drawImage' | 'setLineDash';
+export type IRenderOperation = {
+    type: 'set';
+    property: string;
+    value: unknown;
+} | {
+    type: IRenderMethodName;
+    args: unknown[];
+} | {
+    type: 'beginGroup';
+    key: string;
+    kind: SceneGroupKind;
+} | {
+    type: 'endGroup';
+};
+export declare class DisplayList implements IRenderContext {
+    private operations;
+    private state;
+    private stateStack;
+    constructor();
+    getOperations(): readonly IRenderOperation[];
+    get lineWidth(): number;
+    set lineWidth(value: number);
+    set fillStyle(value: string | CanvasGradient | CanvasPattern | IRenderPattern);
+    set strokeStyle(value: string | CanvasGradient | CanvasPattern);
+    set font(value: string);
+    set globalAlpha(value: number);
+    set textAlign(value: 'center' | 'end' | 'left' | 'right' | 'start');
+    set textBaseline(value: CanvasTextBaseline);
+    set lineCap(value: 'butt' | 'round' | 'square');
+    set lineJoin(value: 'bevel' | 'miter' | 'round');
+    setLineDash(segments: number[]): void;
+    getLineDash(): number[];
+    createPattern(image: CanvasImageSource, repetition: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat', resource?: ISceneResourceIdentity): IRenderPattern;
+    beginGroup(key: string, kind: SceneGroupKind): void;
+    endGroup(): void;
+    save(): void;
+    restore(): void;
+    fillRect(x: number, y: number, width: number, height: number): void;
+    beginPath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    rect(x: number, y: number, width: number, height: number): void;
+    closePath(): void;
+    fill(): void;
+    strokeRect(x: number, y: number, width: number, height: number): void;
+    scale(x: number, y: number): void;
+    rotate(angle: number): void;
+    clip(): void;
+    fillText(text: string, x: number, y: number): void;
+    fillTextWithSource(text: string, x: number, y: number, source: IRenderSource): void;
+    translate(x: number, y: number): void;
+    stroke(): void;
+    drawImage(image: CanvasImageSource, ...args: [number, number, number, number] | [number, number, number, number, number, number, number, number]): void;
+    private set;
+    private record;
+}

package/dist/src/editor/core/render/model/RenderContext.d.ts

@@ -0,0 +1,48 @@
+import type { ISceneResourceIdentity, SceneGroupKind } from '../svg/scene/SceneNode';
+export interface IRenderPattern {
+    type: 'pattern';
+    image: CanvasImageSource;
+    repetition: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
+    resource?: ISceneResourceIdentity;
+}
+export interface IRenderSource {
+    key: string;
+}
+export interface IRenderContext {
+    fillStyle: any;
+    strokeStyle: string | CanvasGradient | CanvasPattern;
+    font: string;
+    globalAlpha: number;
+    textAlign: 'center' | 'end' | 'left' | 'right' | 'start';
+    textBaseline: CanvasTextBaseline;
+    lineWidth: number;
+    lineCap: 'butt' | 'round' | 'square';
+    lineJoin: 'bevel' | 'miter' | 'round';
+    beginGroup?(key: string, kind: SceneGroupKind): void;
+    endGroup?(): void;
+    save(): void;
+    restore(): void;
+    setLineDash(segments: number[]): void;
+    getLineDash(): number[];
+    createPattern(image: CanvasImageSource, repetition: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat', resource?: ISceneResourceIdentity): CanvasPattern | IRenderPattern | null;
+    fillRect(x: number, y: number, width: number, height: number): void;
+    strokeRect(x: number, y: number, width: number, height: number): void;
+    beginPath(): void;
+    closePath(): void;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;
+    quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;
+    bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;
+    rect(x: number, y: number, width: number, height: number): void;
+    fill(): void;
+    stroke(): void;
+    clip(): void;
+    fillText(text: string, x: number, y: number): void;
+    fillTextWithSource?(text: string, x: number, y: number, source: IRenderSource): void;
+    translate(x: number, y: number): void;
+    scale(x: number, y: number): void;
+    rotate(angle: number): void;
+    drawImage(image: CanvasImageSource, x: number, y: number, width: number, height: number): void;
+    drawImage(image: CanvasImageSource, sx: number, sy: number, sWidth: number, sHeight: number, dx: number, dy: number, dWidth: number, dHeight: number): void;
+}