editor-svg 1.0.2 → 1.0.3

package/dist/src/editor/core/draw/Draw.d.ts

@@ -0,0 +1,252 @@
+import { IAppendElementListOption, IComputeRowListPayload, IDrawOption, IDrawRowPayload, IGetImageOption, IGetOriginValueOption, IGetValueOption, IPainterOption } from '../../interface/Draw';
+import { IEditorData, IEditorOption, IEditorResult, ISetValueOption } from '../../interface/Editor';
+import { IElement, IElementStyle, ISpliceElementListOption, IInsertElementListOption } from '../../interface/Element';
+import { IRow } from '../../interface/Row';
+import { Cursor } from '../cursor/Cursor';
+import { CanvasEvent } from '../event/CanvasEvent';
+import { GlobalEvent } from '../event/GlobalEvent';
+import { HistoryManager } from '../history/HistoryManager';
+import { Listener } from '../listener/Listener';
+import { Position } from '../position/Position';
+import { RangeManager } from '../range/RangeManager';
+import { Search } from './interactive/Search';
+import { ImageParticle } from './particle/ImageParticle';
+import { TextParticle } from './particle/TextParticle';
+import { TableParticle } from './particle/table/TableParticle';
+import { TableTool } from './particle/table/TableTool';
+import { HyperlinkParticle } from './particle/HyperlinkParticle';
+import { Header } from './frame/Header';
+import { EditorMode, PageMode, PaperDirection } from '../../dataset/enum/Editor';
+import { Control } from './control/Control';
+import { CheckboxParticle } from './particle/CheckboxParticle';
+import { RadioParticle } from './particle/RadioParticle';
+import { DeepRequired, IPadding } from '../../interface/Common';
+import { WorkerManager } from '../worker/WorkerManager';
+import { Previewer } from './particle/previewer/Previewer';
+import { DateParticle } from './particle/date/DateParticle';
+import { IMargin } from '../../interface/Margin';
+import { I18n } from '../i18n/I18n';
+import { ImageObserver } from '../observer/ImageObserver';
+import { Zone } from '../zone/Zone';
+import { Footer } from './frame/Footer';
+import { ListParticle } from './particle/ListParticle';
+import { EventBus } from '../event/eventbus/EventBus';
+import { EventBusMap } from '../../interface/EventBus';
+import { Group } from './interactive/Group';
+import { Override } from '../override/Override';
+import { LineBreakParticle } from './particle/LineBreakParticle';
+import { ITd } from '../../interface/table/Td';
+import { TableOperate } from './particle/table/TableOperate';
+import { Area } from './interactive/Area';
+import { Badge } from './frame/Badge';
+import { Graffiti } from './graffiti/Graffiti';
+export declare class Draw {
+    private container;
+    private pageContainer;
+    private pageList;
+    private ctxList;
+    private pageNo;
+    private renderCount;
+    private pagePixelRatio;
+    private mode;
+    private options;
+    private position;
+    private zone;
+    private elementList;
+    private listener;
+    private eventBus;
+    private override;
+    private i18n;
+    private canvasEvent;
+    private globalEvent;
+    private cursor;
+    private range;
+    private margin;
+    private background;
+    private badge;
+    private search;
+    private group;
+    private area;
+    private underline;
+    private strikeout;
+    private highlight;
+    private historyManager;
+    private previewer;
+    private imageParticle;
+    private laTexParticle;
+    private textParticle;
+    private tableParticle;
+    private tableTool;
+    private tableOperate;
+    private pageNumber;
+    private lineNumber;
+    private waterMark;
+    private placeholder;
+    private header;
+    private footer;
+    private hyperlinkParticle;
+    private labelParticle;
+    private dateParticle;
+    private separatorParticle;
+    private pageBreakParticle;
+    private superscriptParticle;
+    private subscriptParticle;
+    private checkboxParticle;
+    private radioParticle;
+    private blockParticle;
+    private listParticle;
+    private lineBreakParticle;
+    private whiteSpaceParticle;
+    private control;
+    private pageBorder;
+    private workerManager;
+    private scrollObserver;
+    private selectionObserver;
+    private imageObserver;
+    private graffiti;
+    private LETTER_REG;
+    private WORD_LIKE_REG;
+    private rowList;
+    private pageRowList;
+    private painterStyle;
+    private painterOptions;
+    private visiblePageNoList;
+    private intersectionPageNo;
+    private lazyRenderIntersectionObserver;
+    private printModeData;
+    constructor(rootContainer: HTMLElement, options: DeepRequired<IEditorOption>, data: IEditorData, listener: Listener, eventBus: EventBus<EventBusMap>, override: Override);
+    setPrintData(): void;
+    clearPrintData(): void;
+    getLetterReg(): RegExp;
+    getMode(): EditorMode;
+    setMode(payload: EditorMode): void;
+    isReadonly(): boolean;
+    isDisabled(): boolean;
+    isDesignMode(): boolean;
+    isPrintMode(): boolean;
+    isGraffitiMode(): boolean;
+    getOriginalWidth(): number;
+    getOriginalHeight(): number;
+    getWidth(): number;
+    getHeight(): number;
+    getMainHeight(): number;
+    getMainOuterHeight(): number;
+    getCanvasWidth(pageNo?: number): number;
+    getCanvasHeight(pageNo?: number): number;
+    getInnerWidth(): number;
+    getOriginalInnerWidth(): number;
+    getContextInnerWidth(): number;
+    getMargins(): IMargin;
+    getOriginalMargins(): number[];
+    getPageGap(): number;
+    getOriginalPageGap(): number;
+    getPageNumberBottom(): number;
+    getMarginIndicatorSize(): number;
+    getDefaultBasicRowMarginHeight(): number;
+    getHighlightMarginHeight(): number;
+    getTdPadding(): IPadding;
+    getContainer(): HTMLDivElement;
+    getPageContainer(): HTMLDivElement;
+    getVisiblePageNoList(): number[];
+    setVisiblePageNoList(payload: number[]): void;
+    getIntersectionPageNo(): number;
+    setIntersectionPageNo(payload: number): void;
+    getPageNo(): number;
+    setPageNo(payload: number): void;
+    getRenderCount(): number;
+    getPage(pageNo?: number): HTMLCanvasElement;
+    getPageList(): HTMLCanvasElement[];
+    getPageCount(): number;
+    getTableRowList(sourceElementList: IElement[]): IRow[];
+    getOriginalRowList(): IRow[];
+    getRowList(): IRow[];
+    getPageRowList(): IRow[][];
+    getCtx(): CanvasRenderingContext2D;
+    getOptions(): DeepRequired<IEditorOption>;
+    getSearch(): Search;
+    getGroup(): Group;
+    getArea(): Area;
+    getBadge(): Badge;
+    getHistoryManager(): HistoryManager;
+    getPosition(): Position;
+    getZone(): Zone;
+    getRange(): RangeManager;
+    getLineBreakParticle(): LineBreakParticle;
+    getTextParticle(): TextParticle;
+    getHeaderElementList(): IElement[];
+    getTableElementList(sourceElementList: IElement[]): IElement[];
+    getElementList(): IElement[];
+    getMainElementList(): IElement[];
+    getOriginalElementList(): IElement[];
+    getOriginalMainElementList(): IElement[];
+    getFooterElementList(): IElement[];
+    getTd(): ITd | null;
+    insertElementList(payload: IElement[], options?: IInsertElementListOption): void;
+    appendElementList(elementList: IElement[], options?: IAppendElementListOption): void;
+    spliceElementList(elementList: IElement[], start: number, deleteCount: number, items?: IElement[], options?: ISpliceElementListOption): void;
+    getCanvasEvent(): CanvasEvent;
+    getGlobalEvent(): GlobalEvent;
+    getListener(): Listener;
+    getEventBus(): EventBus<EventBusMap>;
+    getOverride(): Override;
+    getCursor(): Cursor;
+    getPreviewer(): Previewer;
+    getImageParticle(): ImageParticle;
+    getTableTool(): TableTool;
+    getTableOperate(): TableOperate;
+    getTableParticle(): TableParticle;
+    getHeader(): Header;
+    getFooter(): Footer;
+    getHyperlinkParticle(): HyperlinkParticle;
+    getDateParticle(): DateParticle;
+    getListParticle(): ListParticle;
+    getCheckboxParticle(): CheckboxParticle;
+    getRadioParticle(): RadioParticle;
+    getControl(): Control;
+    getWorkerManager(): WorkerManager;
+    getImageObserver(): ImageObserver;
+    getI18n(): I18n;
+    getGraffiti(): Graffiti;
+    getRowCount(): number;
+    getDataURL(payload?: IGetImageOption): Promise<string[]>;
+    getPainterStyle(): IElementStyle | null;
+    getPainterOptions(): IPainterOption | null;
+    setPainterStyle(payload: IElementStyle | null, options?: IPainterOption): void;
+    setDefaultRange(): void;
+    getIsPagingMode(): boolean;
+    setPageMode(payload: PageMode): void;
+    setPageScale(payload: number): void;
+    getPagePixelRatio(): number;
+    setPagePixelRatio(payload: number | null): void;
+    setPageDevicePixel(): void;
+    setPaperSize(width: number, height: number): void;
+    setPaperDirection(payload: PaperDirection): void;
+    setPaperMargin(payload: IMargin): void;
+    getOriginValue(options?: IGetOriginValueOption): Required<IEditorData>;
+    getValue(options?: IGetValueOption): IEditorResult;
+    setValue(payload: Partial<IEditorData>, options?: ISetValueOption): void;
+    setEditorData(payload: Partial<Omit<IEditorData, 'graffiti'>>): void;
+    private _wrapContainer;
+    private _formatContainer;
+    private _createPageContainer;
+    private _createPage;
+    private _initPageContext;
+    getElementFont(el: IElement, scale?: number): string;
+    getElementSize(el: IElement): number;
+    getElementRowMargin(el: IElement): number;
+    computeRowList(payload: IComputeRowListPayload): IRow[];
+    private _computePageList;
+    private _drawHighlight;
+    drawRow(ctx: CanvasRenderingContext2D, payload: IDrawRowPayload): void;
+    private _drawFloat;
+    private _clearPage;
+    private _drawPage;
+    private _disconnectLazyRender;
+    private _lazyRender;
+    private _immediateRender;
+    render(payload?: IDrawOption): void;
+    setCursor(curIndex: number | undefined): number | undefined;
+    submitHistory(curIndex: number | undefined): void;
+    destroy(): void;
+    clearSideEffect(): void;
+}

package/dist/src/editor/core/draw/control/Control.d.ts

@@ -0,0 +1,73 @@
+import { ControlState } from '../../../dataset/enum/Control';
+import { IControl, IControlChangeOption, IControlContext, IControlHighlight, IControlInitOption, IControlInstance, IDestroyControlOption, IGetControlValueOption, IGetControlValueResult, IInitNextControlOption, INextControlContext, IRepaintControlOption, ISetControlExtensionOption, ISetControlProperties, ISetControlRowFlexOption, ISetControlValueOption } from '../../../interface/Control';
+import { IElement, IElementPosition } from '../../../interface/Element';
+import { IRange } from '../../../interface/Range';
+import { Draw } from '../Draw';
+interface IMoveCursorResult {
+    newIndex: number;
+    newElement: IElement;
+}
+export declare class Control {
+    private controlBorder;
+    private draw;
+    private range;
+    private listener;
+    private eventBus;
+    private controlSearch;
+    private options;
+    private controlOptions;
+    private activeControl;
+    private activeControlValue;
+    private preElement;
+    constructor(draw: Draw);
+    setHighlightList(payload: IControlHighlight[]): void;
+    computeHighlightList(): void;
+    renderHighlightList(ctx: CanvasRenderingContext2D, pageNo: number): void;
+    getDraw(): Draw;
+    filterAssistElement(elementList: IElement[]): IElement[];
+    getIsRangeCanCaptureEvent(): boolean;
+    getIsRangeInPostfix(): boolean;
+    getIsRangeWithinControl(): boolean;
+    getIsElementListContainFullControl(elementList: IElement[]): boolean;
+    getIsDisabledControl(context?: IControlContext): boolean;
+    getIsDisabledPasteControl(context?: IControlContext): boolean;
+    getIsExistValueByElementListIndex(elementList: IElement[], index: number): boolean;
+    getControlHighlight(elementList: IElement[], index: number): string;
+    getContainer(): HTMLDivElement;
+    getElementList(): IElement[];
+    getPosition(): IElementPosition | null;
+    getPreY(): number;
+    getRange(): IRange;
+    getValueRange(context?: IControlContext): IRange | null;
+    shrinkBoundary(context?: IControlContext): void;
+    getActiveControl(): IControlInstance | null;
+    getControlElementList(context?: IControlContext): IElement[];
+    updateActiveControlValue(): void;
+    emitControlChange(state: ControlState): void;
+    initControl(): void;
+    destroyControl(options?: IDestroyControlOption): void;
+    repaintControl(options?: IRepaintControlOption): void;
+    emitControlContentChange(options?: IControlChangeOption): void;
+    reAwakeControl(): void;
+    selectValue(): boolean;
+    moveCursor(position: IControlInitOption): IMoveCursorResult;
+    removeControl(startIndex: number, context?: IControlContext): number | null;
+    removePlaceholder(startIndex: number, context?: IControlContext): void;
+    addPlaceholder(startIndex: number, context?: IControlContext): void;
+    setValue(data: IElement[]): number;
+    setControlProperties(properties: Partial<IControl>, context?: IControlContext): void;
+    keydown(evt: KeyboardEvent): number | null;
+    cut(): number;
+    getValueById(payload: IGetControlValueOption): IGetControlValueResult;
+    setValueListById(payload: ISetControlValueOption[]): void;
+    setExtensionListById(payload: ISetControlExtensionOption[]): void;
+    setPropertiesListById(payload: ISetControlProperties[]): void;
+    getList(): IElement[];
+    recordBorderInfo(x: number, y: number, width: number, height: number): void;
+    drawBorder(ctx: CanvasRenderingContext2D): void;
+    getPreControlContext(): INextControlContext | null;
+    getNextControlContext(): INextControlContext | null;
+    initNextControl(option?: IInitNextControlOption): void;
+    setMinWidthControlInfo(option: ISetControlRowFlexOption): void;
+}
+export {};

package/dist/src/editor/core/draw/control/checkbox/CheckboxControl.d.ts

@@ -0,0 +1,16 @@
+import { IControlContext, IControlInstance, IControlRuleOption } from '../../../../interface/Control';
+import { IElement } from '../../../../interface/Element';
+import { Control } from '../Control';
+export declare class CheckboxControl implements IControlInstance {
+    protected element: IElement;
+    protected control: Control;
+    constructor(element: IElement, control: Control);
+    setElement(element: IElement): void;
+    getElement(): IElement;
+    getCode(): string | null;
+    getValue(): IElement[];
+    setValue(): number;
+    setSelect(codes: string[], context?: IControlContext, options?: IControlRuleOption): void;
+    keydown(evt: KeyboardEvent): number | null;
+    cut(): number;
+}

package/dist/src/editor/core/draw/control/date/DateControl.d.ts

@@ -0,0 +1,24 @@
+import { IControlContext, IControlInstance, IControlRuleOption } from '../../../../interface/Control';
+import { IElement } from '../../../../interface/Element';
+import { Control } from '../Control';
+export declare class DateControl implements IControlInstance {
+    private draw;
+    private element;
+    private control;
+    private isPopup;
+    private datePicker;
+    private options;
+    constructor(element: IElement, control: Control);
+    setElement(element: IElement): void;
+    getElement(): IElement;
+    getIsPopup(): boolean;
+    getValue(context?: IControlContext): IElement[];
+    setValue(data: IElement[], context?: IControlContext, options?: IControlRuleOption): number;
+    clearSelect(context?: IControlContext, options?: IControlRuleOption): number;
+    setSelect(date: string, context?: IControlContext, options?: IControlRuleOption): void;
+    keydown(evt: KeyboardEvent): number | null;
+    cut(): number;
+    awake(): void;
+    destroy(): void;
+    private _setDate;
+}

package/dist/src/editor/core/draw/control/interactive/ControlSearch.d.ts

@@ -0,0 +1,20 @@
+import { IControlHighlight, IControlHighlightRule } from '../../../../interface/Control';
+import { IElement } from '../../../../interface/Element';
+import { ISearchResult } from '../../../../interface/Search';
+import { Control } from '../Control';
+type IHighlightMatchResult = (ISearchResult & IControlHighlightRule)[];
+export declare class ControlSearch {
+    private draw;
+    private control;
+    private options;
+    private highlightList;
+    private highlightMatchResult;
+    constructor(control: Control);
+    getControlHighlight(elementList: IElement[], index: number): string;
+    getHighlightMatchResult(): IHighlightMatchResult;
+    getHighlightList(): IControlHighlight[];
+    setHighlightList(payload: IControlHighlight[]): void;
+    computeHighlightList(): void;
+    renderHighlightList(ctx: CanvasRenderingContext2D, pageIndex: number): void;
+}
+export {};

package/dist/src/editor/core/draw/control/number/Calculator.d.ts

@@ -0,0 +1,16 @@
+import { Control } from '../Control';
+interface CalculatorOptions {
+    control: Control;
+    onCalculate: (result: number) => void;
+}
+export declare class Calculator {
+    private control;
+    private calculatorDom;
+    private onCalculate;
+    private currentExpression;
+    constructor(options: CalculatorOptions);
+    createPopup(): void;
+    destroy(): void;
+    private calculate;
+}
+export {};

package/dist/src/editor/core/draw/control/number/NumberControl.d.ts

@@ -0,0 +1,13 @@
+import { IControlContext, IControlRuleOption } from '../../../../interface/Control';
+import { IElement } from '../../../../interface/Element';
+import { TextControl } from '../text/TextControl';
+export declare class NumberControl extends TextControl {
+    private isPopup;
+    private calculator;
+    constructor(element: IElement, control: any);
+    getIsPopup(): boolean;
+    setValue(data: IElement[], context?: IControlContext, options?: IControlRuleOption): number;
+    private _setCalculatedValue;
+    awake(): void;
+    destroy(): void;
+}

package/dist/src/editor/core/draw/control/radio/RadioControl.d.ts

@@ -0,0 +1,5 @@
+import { IControlContext, IControlRuleOption } from '../../../../interface/Control';
+import { CheckboxControl } from '../checkbox/CheckboxControl';
+export declare class RadioControl extends CheckboxControl {
+    setSelect(codes: string[], context?: IControlContext, options?: IControlRuleOption): void;
+}

package/dist/src/editor/core/draw/control/richtext/Border.d.ts

@@ -0,0 +1,10 @@
+import { IElementFillRect } from '../../../../interface/Element';
+import { Draw } from '../../Draw';
+export declare class ControlBorder {
+    protected borderRect: IElementFillRect;
+    private options;
+    constructor(draw: Draw);
+    clearBorderInfo(): IElementFillRect;
+    recordBorderInfo(x: number, y: number, width: number, height: number): void;
+    render(ctx: CanvasRenderingContext2D): void;
+}

package/dist/src/editor/core/draw/control/select/SelectControl.d.ts

@@ -0,0 +1,28 @@
+import { IControlContext, IControlInstance, IControlRuleOption } from '../../../../interface/Control';
+import { IElement } from '../../../../interface/Element';
+import { Control } from '../Control';
+export declare class SelectControl implements IControlInstance {
+    private draw;
+    private element;
+    private control;
+    private isPopup;
+    private selectDom;
+    private options;
+    private VALUE_DELIMITER;
+    private DEFAULT_MULTI_SELECT_DELIMITER;
+    constructor(element: IElement, control: Control);
+    setElement(element: IElement): void;
+    getElement(): IElement;
+    getIsPopup(): boolean;
+    getCodes(): string[];
+    getText(codes: string[]): string | null;
+    getValue(context?: IControlContext): IElement[];
+    setValue(data: IElement[], context?: IControlContext, options?: IControlRuleOption): number;
+    keydown(evt: KeyboardEvent): number | null;
+    cut(): number;
+    clearSelect(context?: IControlContext, options?: IControlRuleOption): number;
+    setSelect(code: string, context?: IControlContext, options?: IControlRuleOption): void;
+    private _createSelectPopupDom;
+    awake(): void;
+    destroy(): void;
+}

package/dist/src/editor/core/draw/control/text/TextControl.d.ts

@@ -0,0 +1,18 @@
+import { DeepRequired } from '../../../../interface/Common';
+import { IControlContext, IControlInstance, IControlRuleOption } from '../../../../interface/Control';
+import { IEditorOption } from '../../../../interface/Editor';
+import { IElement } from '../../../../interface/Element';
+import { Control } from '../Control';
+export declare class TextControl implements IControlInstance {
+    protected element: IElement;
+    protected control: Control;
+    protected options: DeepRequired<IEditorOption>;
+    constructor(element: IElement, control: Control);
+    setElement(element: IElement): void;
+    getElement(): IElement;
+    getValue(context?: IControlContext): IElement[];
+    setValue(data: IElement[], context?: IControlContext, options?: IControlRuleOption): number;
+    clearValue(context?: IControlContext, options?: IControlRuleOption): number;
+    keydown(evt: KeyboardEvent): number | null;
+    cut(): number;
+}

package/dist/src/editor/core/draw/frame/Background.d.ts

@@ -0,0 +1,11 @@
+import { Draw } from '../Draw';
+export declare class Background {
+    private draw;
+    private options;
+    private imageCache;
+    constructor(draw: Draw);
+    private _renderBackgroundColor;
+    private _drawImage;
+    private _renderBackgroundImage;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}

package/dist/src/editor/core/draw/frame/Badge.d.ts

@@ -0,0 +1,14 @@
+import { IAreaBadge, IBadge } from '../../../interface/Badge';
+import { Draw } from '../Draw';
+export declare class Badge {
+    private draw;
+    private options;
+    private imageCache;
+    private mainBadge;
+    private areaBadgeMap;
+    constructor(draw: Draw);
+    setMainBadge(payload: IBadge | null): void;
+    setAreaBadgeMap(payload: IAreaBadge[]): void;
+    private _drawImage;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}

package/dist/src/editor/core/draw/frame/Footer.d.ts

@@ -0,0 +1,27 @@
+import { IElement, IElementPosition } from '../../../interface/Element';
+import { IRow } from '../../../interface/Row';
+import { Draw } from '../Draw';
+export declare class Footer {
+    private draw;
+    private position;
+    private zone;
+    private options;
+    private elementList;
+    private rowList;
+    private positionList;
+    constructor(draw: Draw, data?: IElement[]);
+    getRowList(): IRow[];
+    setElementList(elementList: IElement[]): void;
+    getElementList(): IElement[];
+    getPositionList(): IElementPosition[];
+    compute(): void;
+    recovery(): void;
+    private _computeRowList;
+    private _computePositionList;
+    getFooterBottom(): number;
+    getMaxHeight(): number;
+    getHeight(): number;
+    getRowHeight(): number;
+    getExtraHeight(): number;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}

package/dist/src/editor/core/draw/frame/Header.d.ts

@@ -0,0 +1,27 @@
+import { IElement, IElementPosition } from '../../../interface/Element';
+import { IRow } from '../../../interface/Row';
+import { Draw } from '../Draw';
+export declare class Header {
+    private draw;
+    private position;
+    private zone;
+    private options;
+    private elementList;
+    private rowList;
+    private positionList;
+    constructor(draw: Draw, data?: IElement[]);
+    getRowList(): IRow[];
+    setElementList(elementList: IElement[]): void;
+    getElementList(): IElement[];
+    getPositionList(): IElementPosition[];
+    compute(): void;
+    recovery(): void;
+    private _computeRowList;
+    private _computePositionList;
+    getHeaderTop(): number;
+    getMaxHeight(): number;
+    getHeight(): number;
+    getRowHeight(): number;
+    getExtraHeight(): number;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}

package/dist/src/editor/core/draw/frame/LineNumber.d.ts

@@ -0,0 +1,7 @@
+import { Draw } from '../Draw';
+export declare class LineNumber {
+    private draw;
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}

package/dist/src/editor/core/draw/frame/Margin.d.ts

@@ -0,0 +1,7 @@
+import { Draw } from '../Draw';
+export declare class Margin {
+    private draw;
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}

package/dist/src/editor/core/draw/frame/PageBorder.d.ts

@@ -0,0 +1,9 @@
+import { Draw } from '../Draw';
+export declare class PageBorder {
+    private draw;
+    private header;
+    private footer;
+    private options;
+    constructor(draw: Draw);
+    render(ctx: CanvasRenderingContext2D): void;
+}

package/dist/src/editor/core/draw/frame/PageNumber.d.ts

@@ -0,0 +1,9 @@
+import { NumberType } from '../../../dataset/enum/Common';
+import { Draw } from '../Draw';
+export declare class PageNumber {
+    private draw;
+    private options;
+    constructor(draw: Draw);
+    static formatNumberPlaceholder(text: string, pageNo: number, replaceReg: RegExp, numberType: NumberType): string;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}

package/dist/src/editor/core/draw/frame/Placeholder.d.ts

@@ -0,0 +1,20 @@
+import { IPlaceholder } from '../../../interface/Placeholder';
+import { Draw } from '../Draw';
+export interface IPlaceholderRenderOption {
+    placeholder: Required<IPlaceholder>;
+    startY?: number;
+}
+export declare class Placeholder {
+    private draw;
+    private position;
+    private options;
+    private elementList;
+    private rowList;
+    private positionList;
+    constructor(draw: Draw);
+    private _recovery;
+    _compute(options?: IPlaceholderRenderOption): void;
+    private _computeRowList;
+    private _computePositionList;
+    render(ctx: CanvasRenderingContext2D, options?: IPlaceholderRenderOption): void;
+}

package/dist/src/editor/core/draw/frame/Watermark.d.ts

@@ -0,0 +1,10 @@
+import { Draw } from '../Draw';
+export declare class Watermark {
+    private draw;
+    private options;
+    private imageCache;
+    constructor(draw: Draw);
+    renderText(ctx: CanvasRenderingContext2D, pageNo: number): void;
+    renderImage(ctx: CanvasRenderingContext2D): void;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}

package/dist/src/editor/core/draw/graffiti/Graffiti.d.ts

@@ -0,0 +1,19 @@
+import { IGraffitiData } from '../../../interface/Graffiti';
+import { Draw } from '../Draw';
+export declare class Graffiti {
+    private draw;
+    private options;
+    private data;
+    private pageContainer;
+    private isDrawing;
+    private startStroke;
+    constructor(draw: Draw, data?: IGraffitiData[]);
+    private register;
+    private start;
+    private stop;
+    private drawing;
+    getValue(): IGraffitiData[];
+    compute(): void;
+    clear(): void;
+    render(ctx: CanvasRenderingContext2D, pageNo: number): void;
+}