@hailin-zheng/editor-core 1.0.32 → 1.0.35

package/med_editor/controls/button.d.ts

@@ -0,0 +1,10 @@
+import { ControlBase, Padding } from "./core";
+import { RenderCtx } from "./render-context";
+export declare class ButtonControl extends ControlBase {
+    constructor();
+    text: string;
+    fontSize: number;
+    fontName: string;
+    padding: Padding;
+    render(renderCtx: RenderCtx): void;
+}

package/med_editor/controls/core.d.ts

@@ -0,0 +1,175 @@
+import { RenderCtx } from "./render-context";
+export declare type EventType = 'MouseDown' | 'MouseMove' | 'MouseUp' | 'MouseEnter' | 'MouseLeave' | 'MouseOver' | 'MouseOut' | 'Click' | 'DblClick' | 'Wheel' | 'ContextMenu';
+export declare type PropsEventMap = "isFocus" | 'isActived' | 'isMouseEnter' | 'isMouseDown' | 'isMouseUp';
+export interface Position {
+    x: number;
+    y: number;
+}
+export interface TextUnits {
+    sourceSize: number;
+    actualSize: number;
+    char: string;
+}
+export declare class TextProps {
+    color: string;
+    fontName: string;
+    fontSize: number;
+    fontWeight: 'normal' | 'bold';
+    fontStyle: 'normal' | 'italic';
+    textDecoration: 'none' | 'underline' | 'overline' | 'line-through';
+    background: string;
+    /**
+     * 字符边框
+     */
+    border: boolean;
+    clearCache(): void;
+    clone(source: TextProps | null): TextProps;
+    protected __cacheFont: string | null;
+    getFont(): string;
+    equals(props: TextProps): boolean;
+}
+export declare function setCanvasProps(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D, viewOptions: {
+    width: number;
+    height: number;
+}, scale?: number): void;
+export declare function getAbsolutePos(control: ControlBase, pos: Position): Position;
+export declare function getOffsetPos(control: ControlBase, pos: Position): Position;
+export declare class Padding {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export interface ControlEvent {
+    type: EventType;
+    position: Position;
+    target: ControlBase;
+    current: ControlBase;
+    prev: ControlBase;
+    stopPropagation?: boolean;
+    event: MouseEvent;
+}
+export interface ListenerFn<T = any> {
+    (event: T): void;
+}
+export declare const eventMap: WeakMap<Object, {
+    [key: string]: Array<ListenerFn>;
+}>;
+export interface RectPos {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare enum ModifyFlag {
+    None = 0,
+    Modify = 1,
+    Track = 2
+}
+export declare type DockStyle = 'none' | 'fill';
+export declare abstract class ControlBase {
+    constructor();
+    supportbinarySearchPoint: boolean;
+    cursor: CursorType;
+    modifyFlag: ModifyFlag;
+    private _dock;
+    get dock(): DockStyle;
+    set dock(value: DockStyle);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get width(): number;
+    set width(value: number);
+    get height(): number;
+    set height(value: number);
+    get isFocus(): boolean;
+    set isFocus(value: boolean);
+    get isMouseEnter(): boolean;
+    set isMouseEnter(value: boolean);
+    get isMouseDown(): boolean;
+    set isMouseDown(value: boolean);
+    get isMouseUp(): boolean;
+    set isMouseUp(value: boolean);
+    get color(): string;
+    set color(value: string);
+    get bgColor(): string;
+    set bgColor(value: string);
+    get visible(): boolean;
+    set visible(value: boolean);
+    get enable(): boolean;
+    set enable(value: boolean);
+    protected _x: number;
+    protected _y: number;
+    protected _width: number;
+    protected _height: number;
+    protected _isFocus: boolean;
+    get isActived(): boolean;
+    protected _isMouseEnter: boolean;
+    protected _isMouseDown: boolean;
+    protected _isMouseUp: boolean;
+    protected _color: string;
+    protected _bgColor: string;
+    protected _visible: boolean;
+    protected _enable: boolean;
+    protected propertyChanged(prop: string, old: any, newV: any): void;
+    protected onChanged(): void;
+    onChildChanged(): void;
+    paintPostion: RectPos;
+    paintVisiable: boolean;
+    protected _parent: ControlBase;
+    get parent(): ControlBase;
+    set parent(value: ControlBase | null);
+    protected controls: Array<ControlBase>;
+    getMeasureItems(): Array<ControlBase>;
+    abstract render(renderCtx: RenderCtx): void;
+    get renderPos(): Position;
+    addChild(control: ControlBase, index?: number): void;
+    removeChild(index: number | ControlBase): void;
+    getChild(index: number): ControlBase;
+    getItems(): Array<ControlBase>;
+    getIndex(): number;
+    clearChildren(): void;
+    get length(): number;
+    measure(): void;
+    addEventListener(eventName: EventType, handler: ListenerFn<ControlEvent>): void;
+    removeEventListener(eventName: EventType, handler: ListenerFn<ControlEvent>): void;
+    dispatchEvent(eventName: EventType, e: ControlEvent): void;
+    hitTest(pos: Position): boolean;
+}
+export declare type CursorType = 'text' | 'row-resize' | 'col-resize' | 'none' | 'default' | 'move' | 'pointer' | 'w-resize' | 's-resize' | 'se-resize' | 'ne-resize';
+export declare function addEventListener(target: object, eventName: string, callback: ListenerFn): void;
+export declare function removeEventListener(target: object, eventName: string, callback: ListenerFn): void;
+export declare function dispatchEvent(target: object, eventName: string, args: ControlEvent): void;
+export interface Rect {
+    width: number;
+    height: number;
+}
+export declare function checkIntersect(posA: Position, posB: Position, rectA: Rect, rectB: Rect): boolean;
+export declare function isInRect(pos: Position, rect: Position, width: number, height: number): boolean;
+export declare function isPointInRect(pos: Position, rect: {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+}): boolean;
+export interface Size {
+    width: number;
+    height: number;
+}
+/**
+ * 横向排列
+ */
+export declare function HorMeasure(control: ControlBase): Size;
+export declare function VerMeasure(control: ControlBase): Size;
+export declare function getParentByType<P extends ControlBase, T>(child: P | null, parentType: {
+    new (...args: any): T;
+}): T | null;
+export declare class RefValueImpl<T> {
+    constructor(initValue: T);
+    private _value;
+    get value(): T;
+    set value(value: T);
+}
+export declare function createRef<T>(value: T): RefValueImpl<T>;
+export declare function pointInPoly(pt: Position, poly: Array<Position>): boolean;

package/med_editor/controls/data-grid.d.ts

@@ -0,0 +1,115 @@
+import { ControlBase, RefValueImpl } from "./core";
+import { LabelControl } from "./label";
+import { PanelControl } from "./panel";
+import { RenderCtx } from "./render-context";
+export declare class GridColumn {
+    name: string;
+    caption: string;
+    width: number;
+    align: string;
+    format: string;
+    fieldName: string;
+    fontSize: number;
+    fontName: string;
+    color: string;
+}
+export declare class GridBandColumn {
+    name: string;
+    caption: string;
+    width: number;
+    align: string;
+    fontSize: number;
+    fontName: string;
+    color: string;
+}
+export declare function createNewColumn(name: string, caption: string, width: number, field: string): GridColumn;
+export declare class DataGridControl extends ControlBase {
+    scroll: {
+        x: number;
+        y: number;
+    };
+    columns: Array<GridColumn>;
+    dataSource: Array<object>;
+    rowHeight: number;
+    headerHeight: number;
+    groups: Array<string>;
+    rowWidthRef: RefValueImpl<number>;
+    constructor();
+    getColumnIndex(column: GridColumn): number;
+    getColumnWidth(index: any): number;
+    measure(): void;
+    render(renderCtx: RenderCtx): void;
+    setColumnWidth(index: number, width: number, resizeBorder?: 'left' | 'right'): void;
+    isGenerateFlag: boolean;
+    generateControls(): void;
+    private generateBody;
+    private generateRows;
+    private generateRow;
+    private generateGroupsRows;
+}
+export declare class DataGridHeadBand extends ControlBase {
+    render(renderCtx: RenderCtx): void;
+}
+export declare class DataGridHeaderRow extends ControlBase {
+    constructor();
+    render(renderCtx: RenderCtx): void;
+    measure(): void;
+}
+export declare class DataGridBodyBand extends ControlBase {
+    constructor();
+    render(renderCtx: RenderCtx): void;
+}
+export declare class DataGridRow extends ControlBase {
+    rowData: object;
+    private _selected;
+    get selected(): boolean;
+    set selected(value: boolean);
+    constructor();
+    render(renderCtx: RenderCtx): void;
+    measure(): void;
+}
+export declare class DataGridGroupPanel extends ControlBase {
+    groupHeadPanel: PanelControl;
+    groupBodyPanel: PanelControl;
+    groupHeadText: LabelControl;
+    groupValue: string;
+    constructor();
+    private _expanded;
+    get expanded(): boolean;
+    set expanded(value: boolean);
+    private _groupFormat;
+    get groupFormat(): string;
+    set groupFormat(value: string);
+    private _fontSize;
+    get fontSize(): number;
+    set fontSize(value: number);
+    private _fontName;
+    get fontName(): string;
+    set fontName(value: string);
+    createGroupHeadPanel(): void;
+    measure(): void;
+    render(renderCtx: RenderCtx): void;
+    changeExpand(): void;
+}
+export declare class DataGridGroupRow extends ControlBase {
+    render(renderCtx: RenderCtx): void;
+}
+export declare class DataGridGroupBody extends PanelControl {
+    measure(): void;
+}
+export declare class DataGridHeaderCell extends ControlBase {
+    column: GridColumn;
+    get width(): number;
+    private enableResize;
+    private mouseDownPos;
+    private mouseDownColIndex;
+    private mouseDownWidth;
+    constructor();
+    render(renderCtx: RenderCtx): void;
+}
+export declare class DataGridRowCell extends ControlBase {
+    value: any;
+    column: GridColumn;
+    get width(): number;
+    render(renderCtx: RenderCtx): void;
+}

package/med_editor/controls/editor.d.ts

@@ -0,0 +1,7 @@
+import { ControlBase } from "./core";
+import { RenderCtx } from "./render-context";
+export declare class EditorControl extends ControlBase {
+    constructor();
+    render(renderCtx: RenderCtx): void;
+    measure(): void;
+}

package/med_editor/controls/event.d.ts

@@ -0,0 +1,22 @@
+import { ControlBase, ControlEvent, EventType, Position, PropsEventMap, RectPos } from "./core";
+import { CanvasSurface } from "./surface";
+export declare class CanvasEvent {
+    canvas: HTMLCanvasElement;
+    surface: CanvasSurface;
+    private mouseDownControl;
+    private mouseEnterControl;
+    constructor(canvas: HTMLCanvasElement, surface: CanvasSurface);
+    initEvent(): void;
+    onMouseMove(evt: MouseEvent): void;
+    onContextMenu(evt: MouseEvent): void;
+    onClick(evt: MouseEvent, clickType: 'DblClick' | 'Click'): void;
+    onWheel(evt: WheelEvent): void;
+    dispatchEvent(control: ControlBase, eventName: EventType, event: ControlEvent): void;
+    onMouseDown(evt: MouseEvent): void;
+    onMouseUp(evt: MouseEvent): void;
+    setControlState<E extends PropsEventMap>(control: ControlBase, pos: Position, evtName: E): ControlBase | undefined;
+    private getHitControl;
+    getMousePos(canvas: HTMLCanvasElement, evt: MouseEvent): Position;
+    binarySearch(arr: number[], value: number): number;
+    binarySearchPoint(arr: Array<RectPos>, value: Position): number;
+}

package/med_editor/controls/grid.d.ts

@@ -0,0 +1,11 @@
+import { ControlBase } from "./core";
+import { RenderCtx } from "./render-context";
+export declare class GridControl extends ControlBase {
+    render(renderCtx: RenderCtx): void;
+}
+export declare class GridRowControl extends ControlBase {
+    render(renderCtx: RenderCtx): void;
+}
+export declare class GridCellControl extends ControlBase {
+    render(renderCtx: RenderCtx): void;
+}

package/med_editor/controls/label.d.ts

@@ -0,0 +1,10 @@
+import { ControlBase, Padding } from "./core";
+import { RenderCtx } from "./render-context";
+export declare class LabelControl extends ControlBase {
+    text: string;
+    fontSize: number;
+    fontName: string;
+    padding: Padding;
+    constructor();
+    render(renderCtx: RenderCtx): void;
+}

package/med_editor/controls/panel.d.ts

@@ -0,0 +1,8 @@
+import { ControlBase } from "./core";
+import { RenderCtx } from "./render-context";
+export declare class PanelControl extends ControlBase {
+    measureFlag: 'None' | 'Hor' | 'Ver';
+    constructor();
+    render(renderCtx: RenderCtx): void;
+    measure(): void;
+}

package/med_editor/controls/render-context.d.ts

@@ -0,0 +1,59 @@
+import { TextProps, TextUnits, Position } from "./core";
+export declare class RenderCtx {
+    ctx: CanvasRenderingContext2D;
+    /**
+     * 限定当前绘制的区域
+     */
+    constructor(ctx: CanvasRenderingContext2D);
+    nextRender: (ctx: {
+        hostRenderCtx?: RenderCtx;
+        translate?: {
+            x: number;
+            y: number;
+        };
+    }) => void;
+    init(): void;
+    setGlobalAlpha(alpha: number): void;
+    getGlobalAlpha(): number;
+    clear(): void;
+    drawText(text: string, textProps: TextProps, x: number, y: number, limitWidth?: number, limitHeight?: number, horAlign?: 'left' | 'center' | 'right', verAlign?: 'top' | 'middle' | 'bottom'): void;
+    fillCircular(x: number, y: number, r: number, color?: string): void;
+    measureText(text: string, textProps: TextProps): {
+        width: number;
+        height: number;
+    };
+    measureTextUnits(units: Array<TextUnits>, textProps: TextProps): void;
+    clearRect(x: number, y: number, width: number, height: number): void;
+    save(): void;
+    restore(): void;
+    strokeRect(x: number, y: number, width: number, height: number, strokeColor?: string, strokeWidth?: number): void;
+    drawLine(x: number, y: number, width: number, lineColor?: string, lineWidth?: number): void;
+    fillRect(x: number, y: number, width: number, height: number, fillColor?: string, shadowBlur?: number, shadowColor?: string): void;
+    clip(pos: Position, width: number, height: number, cb?: (() => void)): void;
+    strokeLines(lines: Array<Position>, width?: number, strokeColor?: string): void;
+    fillLines(lines: Array<Position>, width?: number, fillColor?: string): void;
+    drawCheckBox(x: number, y: number, width: number, height: number, isChecked: boolean): void;
+    drawRadioBox(x: number, y: number, width: number, height: number, isChecked: boolean): void;
+    /**
+     * 绘制图片
+     * @param image
+     * @param sx image的矩形（裁剪）选择框的左上角 X 轴坐标
+     * @param sy image的矩形（裁剪）选择框的左上角 Y 轴坐标
+     * @param sWidth image的矩形（裁剪）选择框的宽度
+     * @param sHeight image的矩形（裁剪）选择框的高度
+     * @param dx image的左上角在目标canvas上 X 轴坐标
+     * @param dy image的左上角在目标canvas上 Y 轴坐标
+     * @param dWidth image在目标canvas上绘制的宽度
+     * @param dHeight image在目标canvas上绘制的高度
+     */
+    drawImage(image: HTMLImageElement, sx: number, sy: number, sWidth: number, sHeight: number, dx: number, dy: number, dWidth: number, dHeight: number): void;
+    drawDashLine(points: Array<Position>, lineDash: Array<number>, lineColor?: string, lineWidth?: number): void;
+    roundRect(x: number, y: number, width: number, height: number, radius: number | {
+        tl: number;
+        tr: number;
+        br: number;
+        bl: number;
+    }, fill: boolean, stroke: boolean, color: string): void;
+    drawLineByPos(points: Array<Position>, color: string, lineWidth: number): void;
+    tran(fn: () => void): void;
+}

package/med_editor/controls/report-sheet.d.ts

@@ -0,0 +1,10 @@
+import { ControlBase } from "./core";
+import { RenderCtx } from "./render-context";
+export declare class ReportSheet {
+}
+export declare class SheetColsProps {
+    width: number;
+}
+export declare class ReportDesignSheet extends ControlBase {
+    render(renderCtx: RenderCtx): void;
+}

package/med_editor/controls/rule.d.ts

@@ -0,0 +1,39 @@
+import { ControlBase, Position } from "./core";
+import { RenderCtx } from "./render-context";
+export declare class RuleControl extends ControlBase {
+    private renderCtx;
+    private indentButton;
+    private hangingButton;
+    pagePL: number;
+    pagePR: number;
+    indent: number;
+    hanging: number;
+    mousedownBtn: ThumbButton | null;
+    mousedownPos: Position | null;
+    private onIndentChanged;
+    private onHangingChanged;
+    private _scale;
+    get scale(): number;
+    set scale(value: number);
+    constructor();
+    private onMouseMove;
+    private getRulePos;
+    render(renderCtx: RenderCtx): void;
+    measure(): void;
+    /**
+     * 绘制
+     */
+    private drawRule;
+}
+declare class ThumbButton extends ControlBase {
+    private drawPoints;
+    constructor(type: 'indent' | 'hanging');
+    type: 'indent' | 'hanging';
+    render(renderCtx: RenderCtx): void;
+    getRuleScale(): number;
+    hitTest(pos: Position): boolean;
+    private drawIndentThumb;
+    private getFillColor;
+    private drawHangThumb;
+}
+export {};

package/med_editor/controls/scroll-viewer.d.ts

@@ -0,0 +1,60 @@
+import { ButtonControl } from "./button";
+import { ControlBase, Position, RefValueImpl } from "./core";
+import { Subject } from "../framework/event-subject";
+import { RenderCtx } from "./render-context";
+export declare class ScrollViewer extends ControlBase {
+    horScrollBar: ScrollBar;
+    verScrollBar: ScrollBar;
+    contentPresenter: ScrollContentPresenter;
+    onValueChanged: Subject<{
+        x: number;
+        y: number;
+    }>;
+    private _overflow;
+    get overflow(): 'auto' | 'scroll';
+    set overflow(value: 'auto' | 'scroll');
+    private _scrollX;
+    get scrollX(): number;
+    set scrollX(value: number);
+    private _scrollY;
+    get scrollY(): number;
+    set scrollY(value: number);
+    getMeasureItems(): ControlBase[];
+    constructor();
+    measure(): void;
+    render(renderCtx: RenderCtx): void;
+}
+export declare class ScrollContentPresenter extends ControlBase {
+    private _scrollX_1;
+    get scrollX(): number;
+    set scrollX(value: number);
+    private _scrollY;
+    get scrollY(): number;
+    set scrollY(value: number);
+    widthRef: RefValueImpl<number>;
+    get width(): number;
+    set width(value: number);
+    constructor();
+    render(renderCtx: RenderCtx): void;
+}
+export declare class ScrollBar extends ControlBase {
+    trackBar: ButtonControl;
+    trackBarWidth: number;
+    mousedownpos: Position;
+    onValueChanged: Subject<number>;
+    orientation: 'horizontal' | 'vertical';
+    private _value;
+    get value(): number;
+    set value(value: number);
+    private _maxValue;
+    get maxValue(): number;
+    set maxValue(value: number);
+    private enableScroll;
+    constructor();
+    updateValue(num: number): void;
+    get valuePropName(): "width" | "height";
+    get scrollValue(): number;
+    getGS(): number;
+    render(renderCtx: RenderCtx): void;
+    measure(): void;
+}

package/med_editor/controls/surface.d.ts

@@ -0,0 +1,23 @@
+import { ControlBase, Position, RectPos } from "./core";
+import { CanvasEvent } from "./event";
+import { RenderCtx } from "./render-context";
+export declare class CanvasSurface extends ControlBase {
+    canvas: HTMLCanvasElement;
+    renderCtx: RenderCtx;
+    event: CanvasEvent;
+    constructor(canvas: HTMLCanvasElement, width: number, height: number);
+    state: boolean;
+    onChildChanged(): void;
+    init(): void;
+    progress: number;
+    update(): void;
+    resharpPoints(points: Array<Position>): Array<Position>;
+    drawBezierCurve(ctx: any, start: any, end: any, end2: any): void;
+    easeOutQuad(x: number): number;
+    render(renderCtx: RenderCtx): void;
+    measure(): void;
+    private measureControls;
+    private renderControls;
+    private getViewPortItemIndex;
+    binarySearchPoint(arr: Array<RectPos>, value: RectPos): number;
+}

package/med_editor/doc-ruler.d.ts

@@ -1,5 +1,6 @@
 import { SelectionState } from "./framework/document-selection";
 import { ViewOptions } from "./framework/element-define";
+import { EditorContext } from "./framework/document-context";
 export interface RuleOptions {
     width: number;
     pagePL: number;
@@ -8,8 +9,7 @@ export interface RuleOptions {
 }
 export declare class DocRule {
     canvas: HTMLCanvasElement;
-    viewOptions: ViewOptions;
-    ss: SelectionState;
+    private docCtx;
     private ctx;
     private options;
     private ruleHeight;
@@ -18,7 +18,9 @@ export declare class DocRule {
     private indentThumbPoints;
     private hangThumbPoints;
     private mouseDownThumbType;
-    constructor(canvas: HTMLCanvasElement, viewOptions: ViewOptions, ss: SelectionState);
+    viewOptions: ViewOptions;
+    ss: SelectionState;
+    constructor(canvas: HTMLCanvasElement, docCtx: EditorContext);
     destroy(): void;
     setRuleOptions(options: RuleOptions): void;
     getParentWidth(): number;
@@ -30,8 +32,6 @@ export declare class DocRule {
     private drawText;
     /**
      * 刷新新的状态
-     * @param indent
-     * @param hang
      */
     refreshRule(): void;
     private canvasMousedown;
@@ -47,5 +47,4 @@ export declare class DocRule {
     private getCurrPara;
     private setParentMarksPos;
     private drawCellMark;
-    scaleView(): void;
 }

package/med_editor/framework/common-util.d.ts

@@ -11,7 +11,7 @@ export declare class CommonUtil {
      * @param position
      * @returns
      */
-    static isInsideRectByPosition(rect: Rect, position: Position): boolean;
+    static isInsideRectByPosition(rect: Omit<Rect, 'maxWidth' | 'maxHeight'>, position: Position): boolean;
     static isInsideRectByRect(rect: Rect, position: Rect): boolean;
     /**
      * 判断坐标是否在矩形的边框上
@@ -59,5 +59,6 @@ export declare class CommonUtil {
     static parseText(text: string, data: object): string;
     static getNowDiffSeconds(date: Date | string): number;
     static isDate(str: string): boolean;
+    static cloneValue(val: any): any;
 }
 export {};

package/med_editor/framework/document-change.d.ts

@@ -1,6 +1,6 @@
-import { InputData } from "./document-input-cursor";
+import { DocumentInput, InputData } from "./document-input-cursor";
 import { SelectionState } from "./document-selection";
-import { Element, LeafElement, SelectionContentRange, ViewOptions } from "./element-define";
+import { Element, LeafElement, SelectionContentRange } from "./element-define";
 import { TextGroupElement } from "./impl/text/text-impl";
 import { ParagraphElement } from "./impl/paragraph/p-impl";
 import { TableElement } from "./impl/table/table-impl";
@@ -13,18 +13,19 @@ import { TrackRunTypeEnum } from "./impl/text/track-run-impl";
  * 文档内容改变
  */
 export declare class DocumentChange {
-    private selectionState;
-    private viewOptions;
     private eleReader;
     private docCtx;
     private docComment;
-    constructor(selectionState: SelectionState, viewOptions: ViewOptions, eleReader: ElementReader, docCtx: EditorContext, docComment: DocumentComment);
+    private documentInput;
+    private selectionState;
+    private viewOptions;
+    constructor(eleReader: ElementReader, docCtx: EditorContext, docComment: DocumentComment, documentInput: DocumentInput);
     newInput(data: InputData): void;
     /**
      * 选中区域后进行输入
      * 需要处理将选中的区域删除后，进行输入的情况
      */
-    onInputBySelection(data: InputData): void;
+    onInputBySelectRange(data: InputData): void;
     /**
      * 当前元素是否在正确的留痕区域(ins-run、del-run)，情况分为以下情况
      * 1.留痕块类型为新增，但是留痕块的创建者为其他用户，此时需要拆分留痕区域
@@ -208,7 +209,7 @@ export declare class DocumentChange {
      * @param setterFunc
      * @returns
      */
-    static setTextStyle(ss: SelectionState, setterFunc: (tp: TextProps) => void): void;
+    static setTextStyle(ss: SelectionState, setterFunc: (text: TextGroupElement) => void): void;
     private static recursionSetRangeTextStyle;
     static setParaAlign(ss: SelectionState, setterFunc: (tp: ParagraphProps) => void): void;
     /**