@hailin-zheng/editor-core 1.0.7 → 1.0.10

package/{lib/framework/document-change.js → src/med_editor/framework/document-change.ts}

@@ -1,6 +1,17 @@
-import { SelectionRange } from "./document-selection";
+import { ICompositionStartInfo, InputData } from "./document-input-cursor";
+import { SelectionRange, SelectionState } from "./document-selection";
 import { ElementUtil } from "./element-util";
-import { BlockContainerElement, BlockContentElement, BranchElement, DocMode, InlineGroupElement, LeafElement } from "./element-define";
+import {
+    BlockContainerElement,
+    BlockContentElement,
+    BranchElement,
+    DocMode,
+    Element,
+    InlineGroupElement,
+    LeafElement,
+    SelectionContentRange,
+    ViewOptions
+} from "./element-define";
 import { TextGroupElement } from "./impl/text/text-impl";
 import { PSymbolElement } from "./impl/symbol/p-symbol-impl";
 import { ParagraphElement } from "./impl/paragraph/p-impl";
@@ -8,48 +19,49 @@ import { RangeUtil } from "./range-util";
 import { TableElement } from "./impl/table/table-impl";
 import { DocumentEvent } from "./document-event";
 import { KeyboradElementEvent } from "./element-event-define";
+import { DataEleBaseProps, ParagraphProps, TextProps } from "./element-props";
 import { ElementSerialize } from "./element-serialize";
+import { ElementReader } from "./element-reader";
 import { BreakElement } from "./impl/symbol/br-symbol-impl";
 import { DataDecorateElement } from "./impl/data-element/data-decorate-impl";
-import { DataElementInlineGroup, InlineGroupInputElement, IsInSideDataElement, IsInSideInlineGroupInputElement } from "./impl/data-element/data-element-base-impl";
+import { EditorContext } from "./document-context";
+import {
+    DataElementInlineGroup,
+    InlineGroupInputElement,
+    IsInSideDataElement,
+    IsInSideInlineGroupInputElement
+} from "./impl/data-element/data-element-base-impl";
+import { DocumentComment } from "./document-comment";
 import { CommentElement } from "./impl/comments/comment-element-impl";
 import { nanoid } from "nanoid";
 import { CommContentElement } from "./impl/comments/comment-content-impl";
-import { ValidateElement } from "@/med_editor/framework/impl/comments/validate-msg-impl";
+import { ValidateElement } from "./impl/comments/validate-msg-impl";
 import { CommonUtil } from "./common-util";
 import { TrackRunElement, TrackRunTypeEnum } from "./impl/text/track-run-impl";
-import { DocumentBodyElement } from "@/med_editor/framework/impl/document/doc-body-impl";
+import { DocumentBodyElement } from "./impl/document/doc-body-impl";
+
 /**
  * 文档内容改变
  */
 export class DocumentChange {
-    selectionState;
-    viewOptions;
-    eleReader;
-    docCtx;
-    docComment;
-    constructor(selectionState, viewOptions, eleReader, docCtx, docComment) {
-        this.selectionState = selectionState;
-        this.viewOptions = viewOptions;
-        this.eleReader = eleReader;
-        this.docCtx = docCtx;
-        this.docComment = docComment;
+    constructor(private selectionState: SelectionState, private viewOptions: ViewOptions, private eleReader: ElementReader, private docCtx: EditorContext, private docComment: DocumentComment) {
     }
-    newInput(data) {
+
+    newInput(data: InputData): void {
         const { startControl, startOffset, collapsed, enableTrackChanges } = this.selectionState;
         if (!collapsed) {
             this.onInputBySelection(data);
             return;
         }
         //判断是否需要创建新的留痕区域
-        if (enableTrackChanges && !this.isInCorrectTrackRegion(startControl, TrackRunTypeEnum.Inserted)) {
-            this.newInputTrackChanges(data, startControl, startOffset);
+        if (enableTrackChanges && !this.isInCorrectTrackRegion(startControl as Element, TrackRunTypeEnum.Inserted)) {
+            this.newInputTrackChanges(data, startControl as LeafElement, startOffset);
             return;
         }
         //当前输入节点是在留痕区域中，但是当前关闭了审阅模式，需要拆分留痕区域，创建新输入节点
         if (!enableTrackChanges && this.isInTrackBlock(startControl)) {
             const newInput = this.splitTrackElement(startControl, startOffset);
-            const comp = data.compositionStartInfo;
+            const comp = data.compositionStartInfo as ICompositionStartInfo;
             comp.element = newInput;
             comp.offset = 0;
             this.inputTextGroup(newInput, data);
@@ -63,8 +75,7 @@ export class DocumentChange {
             if (siblingTextEle instanceof TextGroupElement) {
                 data.compositionStartInfo.offset = startOffset === 0 ? siblingTextEle.text.length : 0;
                 this.inputTextGroup(siblingTextEle, data);
-            }
-            else {
+            } else {
                 const inputTextProps = this.getDefaultTextProps(startControl, startOffset);
                 const newTextGroup = ElementUtil.getNewTextGroup(inputTextProps);
                 startControl.parent.addChild(newTextGroup, startControl.getIndex() + startOffset);
@@ -74,24 +85,28 @@ export class DocumentChange {
         }
         this.inputTextGroup(startControl, data);
     }
+
+
     /**
      * 选中区域后进行输入
      * 需要处理将选中的区域删除后，进行输入的情况
      */
-    onInputBySelection(data) {
+    onInputBySelection(data: InputData): void {
         this.onRangeDelete();
         this.selectionState.afterSelectionChanged = (newVal) => {
             const { startControl, startOffset, editable } = newVal;
             if (!editable) {
                 return false;
             }
-            const comp = data.compositionStartInfo;
+            const comp = data.compositionStartInfo as ICompositionStartInfo;
             comp.element = startControl;
             comp.offset = startOffset;
             this.newInput(data);
             return true;
         };
+
     }
+
     /**
      * 当前元素是否在正确的留痕区域(ins-run、del-run)，情况分为以下情况
      * 1.留痕块类型为新增，但是留痕块的创建者为其他用户，此时需要拆分留痕区域
@@ -100,22 +115,24 @@ export class DocumentChange {
      * @param trackType
      * @returns
      */
-    isInCorrectTrackRegion(startControl, trackType) {
+    isInCorrectTrackRegion(startControl: Element, trackType: TrackRunTypeEnum): boolean {
         const parent = startControl.parent;
         return parent instanceof TrackRunElement
             && parent.props.userId === this.viewOptions.editUser.id
             && parent.type === trackType
             && CommonUtil.getNowDiffSeconds(parent.props.date) <= this.viewOptions.trackChangePeriod;
     }
+
     /**
      * 当前元素是否在留痕区域(ins-run、del-run)中
      * @param target
      * @param trackType
      * @returns
      */
-    isInTrackBlock(target, trackType = null) {
+    isInTrackBlock(target: Element, trackType: TrackRunTypeEnum | null = null): boolean {
         return target.parent instanceof TrackRunElement && (trackType === null || target.parent.type === trackType);
     }
+
     /**
      * 留痕输入
      * @param data
@@ -123,9 +140,9 @@ export class DocumentChange {
      * @param startOffset
      * @returns
      */
-    newInputTrackChanges(data, startControl, startOffset) {
+    newInputTrackChanges(data: InputData, startControl: LeafElement, startOffset: number): void {
         const userId = this.viewOptions.editUser.id;
-        const compInfo = data.compositionStartInfo;
+        const compInfo = data.compositionStartInfo as ICompositionStartInfo;
         if (this.isInCorrectTrackRegion(startControl, TrackRunTypeEnum.Inserted)) {
             return;
         }
@@ -135,16 +152,20 @@ export class DocumentChange {
             compInfo.element = newInput;
             this.inputTextGroup(newInput, data);
             return;
-        }
-        else {
-            const { trackElement, newTextGroup } = this.createTextTrackElement(startControl, null, TrackRunTypeEnum.Inserted);
-            this.insertElement(startControl, startOffset, [trackElement]);
+        } else {
+            const {
+                trackElement,
+                newTextGroup
+            } = this.createTextTrackElement(startControl, null, TrackRunTypeEnum.Inserted);
+            this.insertElement(startControl, startOffset, [trackElement])
             compInfo.offset = 0;
             compInfo.element = newTextGroup;
             this.inputTextGroup(newTextGroup, data);
             return;
         }
     }
+
+
     /**
      * 创建新的留痕块,并返回留痕块输入定位文本
      * @param startControl
@@ -152,11 +173,11 @@ export class DocumentChange {
      * @param trackType
      * @returns
      */
-    createNewTrackInput(startControl, startOffset, trackType) {
+    createNewTrackInput(startControl: LeafElement, startOffset: number, trackType: TrackRunTypeEnum): TextGroupElement {
         const textProps = this.getDefaultTextProps(startControl, startOffset);
-        const currTrackEle = startControl.parent;
+        const currTrackEle = startControl.parent as TrackRunElement;
         if (startControl instanceof TextGroupElement && startOffset > 0 && startOffset < startControl.textMeasures.length) {
-            const splitText = startControl.spliceText(startOffset, startControl.textMeasures.length, true);
+            const splitText = startControl.spliceText(startOffset, startControl.textMeasures.length, true) as TextGroupElement;
             startControl.parent.addChild(splitText, startControl.getIndex() + 1);
             startOffset = startControl.textMeasures.length;
         }
@@ -164,74 +185,75 @@ export class DocumentChange {
         const index = startControl.getIndex() + startOffset;
         //切割留痕块
         if (index > 0 && index < currTrackEle.length) {
-            const splitTrack = currTrackEle.split(startControl.getIndex() + startOffset);
+            const splitTrack = currTrackEle.split(startControl.getIndex() + startOffset) as TrackRunElement;
             currTrackEle.parent.addChild(splitTrack, currTrackEle.getIndex() + 1);
             const { trackElement, newTextGroup } = this.createTextTrackElement(startControl, textProps, trackType);
             currTrackEle.parent.addChild(trackElement, currTrackEle.getIndex() + 1);
             return newTextGroup;
-        }
-        else {
+        } else {
             const { trackElement, newTextGroup } = this.createTextTrackElement(startControl, textProps, trackType);
             currTrackEle.parent.addChild(trackElement, currTrackEle.getIndex() + (index === 0 ? 0 : 1));
             return newTextGroup;
         }
     }
+
     /**
      * 获取当前输入节点的文本属性
      * @param startControl
      * @returns
      */
-    getDefaultTextProps(startControl, offset) {
-        const para = ElementUtil.getParentByType(startControl, ParagraphElement);
+    getDefaultTextProps(startControl: LeafElement, offset: number): TextProps {
+        const para = ElementUtil.getParentByType(startControl, ParagraphElement) as ParagraphElement;
         let textProps = para.props.textProps;
         if (startControl instanceof TextGroupElement) {
             textProps = startControl.props;
         }
-        const dataEle = ElementUtil.getDataElement(startControl);
+        const dataEle = ElementUtil.getDataElement(startControl) as DataElementInlineGroup;
         if (dataEle && IsInSideDataElement(startControl, offset)) {
             return dataEle.props.valueTextProps;
         }
         return textProps;
     }
+
     /**
      * 当前元素位于留痕区域内，但是当前编辑模式为非留痕模式，需要将当前留痕元素分割开来，插入新普通文本元素对象,并返回
      * @param startControl
      * @param startOffset
      * @returns
      */
-    splitTrackElement(startControl, startOffset) {
+    splitTrackElement(startControl: LeafElement, startOffset: number): TextGroupElement {
         if (!(startControl.parent instanceof TrackRunElement) && startControl instanceof TextGroupElement) {
             return startControl;
         }
         const textProps = this.getDefaultTextProps(startControl, startOffset);
-        const currTrackEle = startControl.parent;
+        const currTrackEle = startControl.parent as TrackRunElement;
         if (startControl instanceof TextGroupElement && startOffset > 0 && startOffset < startControl.textMeasures.length) {
-            const splitText = startControl.spliceText(startOffset, startControl.textMeasures.length, true);
+            const splitText = startControl.spliceText(startOffset, startControl.textMeasures.length, true) as TextGroupElement;
             startControl.parent.addChild(splitText, startControl.getIndex() + 1);
             startOffset = startControl.textMeasures.length;
         }
         startOffset = startOffset > 0 ? 1 : 0;
         const index = startControl.getIndex() + startOffset;
         if (index > 0 && index < currTrackEle.length) {
-            const splitTrack = currTrackEle.split(startControl.getIndex() + startOffset);
+            const splitTrack = currTrackEle.split(startControl.getIndex() + startOffset) as TrackRunElement;
             currTrackEle.parent.addChild(splitTrack, currTrackEle.getIndex() + 1);
             const newInput = ElementUtil.getNewTextGroup(textProps);
             currTrackEle.parent.addChild(newInput, currTrackEle.getIndex() + 1);
             return this.splitTrackElement(newInput, 0);
-        }
-        else {
+        } else {
             const newInput = ElementUtil.getNewTextGroup(textProps);
             currTrackEle.parent.addChild(newInput, currTrackEle.getIndex() + (index === 0 ? 0 : 1));
             return this.splitTrackElement(newInput, 0);
         }
     }
+
     /**
      * 创建插入(ins-run) 留痕,并且返回留痕的文本元素对象
      * @param startControl
      * @returns
      */
-    createTextTrackElement(startControl, textProps, trackType) {
-        const para = ElementUtil.getParentByType(startControl, ParagraphElement);
+    private createTextTrackElement(startControl: Element, textProps: TextProps | null, trackType: TrackRunTypeEnum): { trackElement: TrackRunElement, newTextGroup: TextGroupElement } {
+        const para = ElementUtil.getParentByType(startControl, ParagraphElement) as ParagraphElement;
         const trackElement = this.createTrackElement(trackType);
         textProps = textProps || para.props.textProps;
         const newTextGroup = ElementUtil.getNewTextGroup(textProps);
@@ -240,9 +262,11 @@ export class DocumentChange {
         return {
             trackElement,
             newTextGroup
-        };
+        }
+
     }
-    createTrackElement(trackType) {
+
+    private createTrackElement(trackType: TrackRunTypeEnum): TrackRunElement {
         const trackElement = new TrackRunElement(trackType);
         trackElement.props.userId = this.viewOptions.editUser.id;
         trackElement.props.userName = this.viewOptions.editUser.name;
@@ -250,12 +274,14 @@ export class DocumentChange {
         trackElement.props.id = nanoid(5);
         return trackElement;
     }
-    inputTextGroup(text, data) {
+
+    private inputTextGroup(text: TextGroupElement, data: InputData): void {
         const prevInputData = data.prevInputData || '';
         const prevInputDataLength = prevInputData.length;
         if (!data.compositionStartInfo) {
-            throw new Error('compositionStartInfo is null');
+            throw new Error('compositionStartInfo is null')
         }
+
         const { element, offset } = data.compositionStartInfo;
         let startInputOffset = offset;
         //startInputOffset -= prevInputDataLength;
@@ -263,8 +289,7 @@ export class DocumentChange {
             //当前选中元素位于输入元素是起始还是结束位置，如果位于起始位置，则输入偏移量为0,否则为未变更之前的内容length
             if (ElementUtil.getNextSiblingElement(element) === text) {
                 startInputOffset = 0;
-            }
-            else {
+            } else {
                 startInputOffset = text.textMeasures.length - prevInputDataLength;
             }
         }
@@ -272,18 +297,19 @@ export class DocumentChange {
         //输入后撤销，导致文本组内为空
         if (!text.text.length) {
             this.removeEmptyText(text);
-        }
-        else {
+        } else {
             this.selectionState.resetRange(text, startInputOffset + data.data.length);
         }
     }
+
+
     /**
      * backspace,向前删除
      */
-    onBackspace(evt) {
+    onBackspace(evt: KeyboardEvent): void {
         const { startControl, startOffset, collapsed } = this.selectionState;
         if (!startControl) {
-            throw new Error('startControl is null');
+            throw new Error('startControl is null')
         }
         const eventElement = new KeyboradElementEvent(this.docCtx);
         eventElement.key = 'backspace';
@@ -297,16 +323,16 @@ export class DocumentChange {
         this.docComment.updateComments();
         if (collapsed) {
             this.onBackspaceElement(startControl, startOffset);
-        }
-        else {
+        } else {
             this.onRangeDelete();
         }
     }
+
     /**
      * delete,向后删除
      * @param evt
      */
-    onDeleteKeyHandler(evt) {
+    onDeleteKeyHandler(evt: KeyboardEvent): void {
         const { startControl, startOffset, collapsed } = this.selectionState;
         const eventElement = new KeyboradElementEvent(this.docCtx);
         eventElement.key = 'delete';
@@ -319,21 +345,21 @@ export class DocumentChange {
         }
         if (collapsed) {
             this.onKeyDeleteElement(startControl, startOffset);
-        }
-        else {
+        } else {
             this.onRangeDelete();
         }
     }
+
     /**
      * 根据选择范围删除
      */
-    onRangeDelete() {
+    private onRangeDelete(): { cursorEle: Element, cursorOffset: number } {
         const { selectedRange } = this.selectionState;
         if (!selectedRange) {
-            throw new Error('selectionRange is null');
+            throw new Error('selectionRange is null')
         }
         //用于刷新后定位光标
-        let startPointElement;
+        let startPointElement: Element;
         let startPointOffset = 0;
         if (selectedRange.isFullSelected) {
             //某个容器的内容被全部选中
@@ -343,24 +369,21 @@ export class DocumentChange {
             }
             //内容块被选中,需要向上寻找内容块容器
             else if (selectedRange.target instanceof BlockContentElement) {
-                const parentContainer = ElementUtil.getParent(selectedRange.target, (item) => item instanceof BlockContainerElement);
+                const parentContainer = ElementUtil.getParent(selectedRange.target, (item) => item instanceof BlockContainerElement) as BlockContainerElement;
                 if (parentContainer) {
                     startPointElement = parentContainer;
                     startPointOffset = 0;
+                } else {
+                    throw new Error('未能向上寻找到定位的内容块容器')
                 }
-                else {
-                    throw new Error('未能向上寻找到定位的内容块容器');
-                }
-            }
-            else {
-                throw new Error('未知条件区间');
+            } else {
+                throw new Error('未知条件区间')
             }
-        }
-        else {
-            const startRange = RangeUtil.getStartRangeTarget(selectedRange);
-            const endRange = RangeUtil.getEndRangeTarget(selectedRange);
+        } else {
+            const startRange = RangeUtil.getStartRangeTarget(selectedRange) as SelectionContentRange;
+            const endRange = RangeUtil.getEndRangeTarget(selectedRange) as SelectionContentRange;
             if (startRange.isFullSelected) {
-                startPointElement = ElementUtil.getRecursionPrevSiblingElement(startRange.target, false, true);
+                startPointElement = ElementUtil.getRecursionPrevSiblingElement(startRange.target, false, true) as LeafElement;
                 startPointOffset = -1;
                 //判断结束选区和开始选区是否在一个段落中，尽量落在同一段落中
                 if (!startPointElement || ElementUtil.isInSameParagraph(startRange.target, endRange.target)) {
@@ -369,28 +392,27 @@ export class DocumentChange {
                         startPointOffset = 0;
                     }
                 }
-            }
-            else {
-                startPointElement = startRange.target;
+            } else {
+                startPointElement = startRange.target as LeafElement;
                 startPointOffset = startRange.startOffset;
             }
         }
         if (this.viewOptions.docMode === DocMode.FormEdit) {
-            this.deleteRangeInFormEdit(selectedRange);
-        }
-        else {
+            this.deleteRangeInFormEdit(selectedRange)
+        } else {
             this.deleteRange(selectedRange);
         }
         this.selectionState.resetRange(startPointElement, startPointOffset);
         return { cursorEle: startPointElement, cursorOffset: startPointOffset };
     }
+
     /**
      * backspace删除
      * @param control
      * @param offset
      * @returns
      */
-    onBackspaceElement(control, offset) {
+    private onBackspaceElement(control: LeafElement, offset: number): void {
         this.selectionState.clear();
         if (offset === 0) {
             const prevEle = ElementUtil.getRecursionPrevSiblingElement(control, false, true);
@@ -401,15 +423,13 @@ export class DocumentChange {
             if (ElementUtil.isInSameParagraph(control, prevEle)) {
                 if (ElementUtil.getPrevSiblingElement(control) === prevEle) {
                     this.onBackspaceElement(prevEle, ElementUtil.getElementEndOffset(prevEle));
-                }
-                else {
+                } else {
                     this.selectionState.resetRange(prevEle, -1);
                 }
-            }
-            else {
+            } else {
                 //需要判断是否是兄弟段落，兄弟段落，需要合并
-                const prevPara = ElementUtil.getParentByType(prevEle, ParagraphElement);
-                const currPara = ElementUtil.getParentByType(control, ParagraphElement);
+                const prevPara = ElementUtil.getParentByType(prevEle, ParagraphElement) as ParagraphElement;
+                const currPara = ElementUtil.getParentByType(control, ParagraphElement) as ParagraphElement;
                 //表明是紧挨着的两个段落，要进行段落合并
                 if (ElementUtil.getPrevSiblingElement(currPara) === prevPara) {
                     if (this.selectionState.enableTrackChanges) {
@@ -417,25 +437,21 @@ export class DocumentChange {
                         return;
                     }
                     this.combineParagraph(prevPara, currPara, control);
-                }
-                else {
+                } else {
                     //不是紧挨着的段落，则前一个段落是位于另一个容器里，例如：处于单元格内的段落
                     //则不向前定位
-                    this.selectionState.resetRange(control, offset);
+                    this.selectionState.resetRange(control, offset)
                 }
             }
-        }
-        else {
+        } else {
             if (control instanceof TextGroupElement) {
                 this.onDeleteText(control, offset - 1, 1);
                 if (!control.textMeasures.length) {
                     this.removeEmptyText(control);
-                }
-                else {
+                } else {
                     this.selectionState.resetRange(control, offset - 1);
                 }
-            }
-            else {
+            } else {
                 if (control.parent instanceof InlineGroupInputElement && control instanceof DataDecorateElement) {
                     const dataEle = control.parent;
                     //空数据元，并且当前光标处于数据元开始位置
@@ -458,15 +474,16 @@ export class DocumentChange {
             }
         }
     }
+
     /**
      * 跳到上一个数据元中
      * @param currEle
      */
-    jumpToPrevDataElement(currEle) {
+    private jumpToPrevDataElement(currEle: InlineGroupInputElement): boolean {
         if (this.viewOptions.docMode !== DocMode.FormEdit) {
             return false;
         }
-        const prevEle = ElementUtil.getPrevDataElement(this.docCtx, currEle);
+        const prevEle = ElementUtil.getPrevDataElement(this.docCtx, currEle as DataElementInlineGroup);
         if (!prevEle) {
             return false;
         }
@@ -476,13 +493,14 @@ export class DocumentChange {
         }
         return false;
     }
+
     /**
      * delete删除
      * @param control
      * @param offset
      * @returns
      */
-    onKeyDeleteElement(control, offset) {
+    private onKeyDeleteElement(control: LeafElement, offset: number): void {
         this.selectionState.clear();
         if (offset === ElementUtil.getElementEndOffset(control)) {
             const nextEle = ElementUtil.getRecursionNextSiblingElement(control, false, true);
@@ -493,15 +511,13 @@ export class DocumentChange {
             if (ElementUtil.isInSameParagraph(control, nextEle)) {
                 if (ElementUtil.getNextSiblingElement(control) === nextEle) {
                     this.onKeyDeleteElement(nextEle, 0);
-                }
-                else {
+                } else {
                     this.selectionState.resetRange(nextEle, 0);
                 }
-            }
-            else {
+            } else {
                 //需要判断是否是兄弟段落，兄弟段落，需要合并
-                const nextPara = ElementUtil.getParentByType(nextEle, ParagraphElement);
-                const currPara = ElementUtil.getParentByType(control, ParagraphElement);
+                const nextPara = ElementUtil.getParentByType(nextEle, ParagraphElement) as ParagraphElement;
+                const currPara = ElementUtil.getParentByType(control, ParagraphElement) as ParagraphElement;
                 //表明是紧挨着的两个段落，要进行段落合并
                 if (ElementUtil.getNextSiblingElement(currPara) === nextPara) {
                     if (this.selectionState.enableTrackChanges) {
@@ -509,39 +525,33 @@ export class DocumentChange {
                         return;
                     }
                     this.combineParagraph(nextPara, currPara, control);
-                }
-                else {
+                } else {
                     //不是紧挨着的段落，则前一个段落是位于另一个容器里，例如：处于单元格内的段落
                     //则不向前定位
-                    this.selectionState.resetRange(control, offset);
+                    this.selectionState.resetRange(control, offset)
                 }
             }
-        }
-        else {
+        } else {
             if (control instanceof TextGroupElement) {
                 this.onDeleteText(control, offset, 1);
                 if (!control.textMeasures.length) {
                     this.removeEmptyText(control);
-                }
-                else {
+                } else {
                     this.selectionState.resetRange(control, offset);
                 }
-            }
-            else {
+            } else {
                 if (control.parent instanceof DataElementInlineGroup && control instanceof DataDecorateElement) {
-                    const dataEle = control.parent;
+                    const dataEle = control.parent as DataElementInlineGroup;
                     //空数据元，并且当前光标处于数据元开始位置
                     if (control.isPrefix) {
                         if (this.canDeleteInlineGroup(dataEle)) {
                             this.setCurosrForDeleteAction(dataEle);
                             dataEle.remove();
-                        }
-                        else {
+                        } else {
                             this.selectionState.resetRange(control, -1);
                         }
                         return;
-                    }
-                    else if (!control.isPrefix && dataEle.length === 2) {
+                    } else if (!control.isPrefix && dataEle.length === 2) {
                         this.selectionState.resetRange(dataEle.endDecorate, -1);
                         return;
                     }
@@ -554,61 +564,67 @@ export class DocumentChange {
             }
         }
     }
+
     /**
      * 判断是否可以删除数据组
      * @param dataEle
      * @private
      */
-    canDeleteInlineGroup(dataEle) {
+    private canDeleteInlineGroup(dataEle: InlineGroupInputElement): boolean {
         if (this.viewOptions.docMode === DocMode.FormEdit) {
             return false;
         }
         return dataEle.length === 2;
     }
-    onDeleteText(text, offset, len) {
+
+    private onDeleteText(text: TextGroupElement, offset: number, len: number): void {
         if (this.selectionState.enableTrackChanges) {
-            this.updateDeletedTrackText(text, offset, len);
-        }
-        else {
-            text.splice(offset, len);
+            this.updateDeletedTrackText(text, offset, len)
+        } else {
+            text.splice(offset, len)
         }
     }
-    onDeleteItem(item) {
+
+    private onDeleteItem(item: LeafElement): void {
         if (this.selectionState.enableTrackChanges) {
             //删除符号不进行留痕
             if (item.type === 'psym') {
-                return;
+                return
             }
             this.onTrackDeleteElement(item);
-        }
-        else {
+        } else {
             item.remove();
             item.destroy();
         }
     }
+
+
     /**
      * 当前元素是否在留痕元素内
      * @param target
      * @param trackType
      * @returns
      */
-    isInCurrentUserTrack(target, trackType) {
+    private isInCurrentUserTrack(target: Element, trackType: TrackRunTypeEnum): boolean {
         if (target.parent instanceof TrackRunElement && target.parent.type === trackType && target.parent.props.userId === this.viewOptions.editUser.id) {
             return true;
         }
         return false;
     }
-    isInTrackElement(target, trackType) {
+
+    private isInTrackElement(target: Element, trackType: TrackRunTypeEnum): boolean {
         if (target.parent instanceof TrackRunElement && target.parent.type === trackType) {
             return true;
         }
         return false;
     }
+
+
     /**
      * 留痕除文本以外的其他元素
      * @param control
      */
-    onTrackDeleteElement(target) {
+    private onTrackDeleteElement(target: LeafElement): void {
         const parent = target.parent;
         if (this.isInTrackElement(target, TrackRunTypeEnum.Deleted)) {
             return;
@@ -625,10 +641,11 @@ export class DocumentChange {
         target.remove();
         this.removeEmtpyInlineBlock(parent);
     }
+
     /**
      * 更新文本删除留痕
      */
-    updateDeletedTrackText(target, offset, len) {
+    private updateDeletedTrackText(target: TextGroupElement, offset: number, len: number): void {
         if (this.isInTrackElement(target, TrackRunTypeEnum.Deleted)) {
             return;
         }
@@ -646,45 +663,52 @@ export class DocumentChange {
             return;
         }
         const { leftElement } = this.splitText(target, offset + len);
-        target = leftElement;
-        let trackText = this.getNextTrackInputElement(target, TrackRunTypeEnum.Deleted);
+        target = leftElement as never;
+        let trackText: TextGroupElement = this.getNextTrackInputElement(target, TrackRunTypeEnum.Deleted);
         const spText = target.spliceText(target.textMeasures.length - len, target.textMeasures.length, true);
         trackText.splice(0, 0, spText?.text);
     }
-    getNextTrackInputElement(target, trackType) {
-        const trackElement = ElementUtil.getNextSiblingTrackElement(target, trackType, this.viewOptions.editUser.id);
+
+
+    private getNextTrackInputElement(target: Element, trackType: TrackRunTypeEnum): TextGroupElement {
+        const trackElement = ElementUtil.getNextSiblingTrackElement(target, trackType, this.viewOptions.editUser.id)
         if (trackElement) {
             const firstEle = trackElement.getChild(0);
             if (firstEle && firstEle instanceof TextGroupElement) {
                 return firstEle;
-            }
-            else {
+            } else {
                 const newInput = new TextGroupElement();
                 trackElement.addChild(newInput, 0);
                 target.props.clone(newInput.props);
                 return newInput;
             }
-        }
-        else {
-            const { trackElement, newTextGroup } = this.createTextTrackElement(target, target.props, TrackRunTypeEnum.Deleted);
+        } else {
+            const {
+                trackElement,
+                newTextGroup
+            } = this.createTextTrackElement(target, target.props, TrackRunTypeEnum.Deleted);
             target.parent.addChild(trackElement, target.getIndex() + 1);
             return newTextGroup;
         }
     }
-    getNextTrackElement(target, trackType) {
-        let trackElement = ElementUtil.getNextSiblingTrackElement(target, trackType, this.viewOptions.editUser.id);
+
+
+    private getNextTrackElement(target: Element, trackType: TrackRunTypeEnum): TrackRunElement {
+        let trackElement = ElementUtil.getNextSiblingTrackElement(target, trackType, this.viewOptions.editUser.id)
         if (!trackElement) {
             trackElement = this.createTrackElement(trackType);
             target.parent.addChild(trackElement, target.getIndex() + 1);
         }
         return trackElement;
     }
+
+
     /**
      * 删除元素并定位光标
      * @param control
      * @returns
      */
-    removeElement(control) {
+    private removeElement(control: LeafElement): void {
         const prevEle = ElementUtil.getRecursionPrevSiblingElement(control, false, true);
         if (!prevEle) {
             const nextEle = ElementUtil.getRecursionNextSiblingElement(control, true, true);
@@ -699,27 +723,27 @@ export class DocumentChange {
             this.selectionState.resetRange(prevEle, -1);
             control.remove();
             return;
-        }
-        else {
+        } else {
             const nextEle = ElementUtil.getRecursionNextSiblingElement(control, true, true);
             if (nextEle && ElementUtil.getPrevSiblingElement(nextEle) === control) {
                 this.selectionState.resetRange(nextEle, 0);
                 control.remove();
                 return;
-            }
-            else {
+            } else {
                 this.selectionState.resetRange(prevEle, -1);
                 control.remove();
                 return;
             }
         }
     }
+
+
     /**
      * 回车事件
      */
-    onEnter() {
+    onEnter(): void {
         const { startControl } = this.selectionState;
-        const paragraph = ElementUtil.getParentByType(startControl, ParagraphElement);
+        const paragraph = ElementUtil.getParentByType(startControl, ParagraphElement) as ParagraphElement;
         const breakPara = this.splitCurrentParagraph();
         //选中的是一个元素
         if (breakPara === paragraph) {
@@ -727,24 +751,27 @@ export class DocumentChange {
             breakPara.parent.addChild(clonePara, breakPara.getIndex());
         }
         this.selectionState.resetRange(breakPara, 0);
+
     }
+
     /**
      * 插入表格
      * @param tb
      * @returns
      */
-    insertTable(tb) {
+    insertTable(tb: TableElement): void {
         const breakPara = this.splitCurrentParagraph();
         breakPara.parent.addChild(tb, breakPara.getIndex());
         this.selectionState.resetRange(tb, 0);
     }
+
     /**
      * 分割当前段落用于插入表格或者粘贴的内容
      * @param insertItems 分割后插入的内容，内容需要是block或者表格对象
      */
-    splitCurrentParagraph() {
+    private splitCurrentParagraph(): ParagraphElement {
         const { startControl, startOffset } = this.selectionState;
-        const paragraph = ElementUtil.getParentByType(startControl, ParagraphElement);
+        const paragraph = ElementUtil.getParentByType(startControl, ParagraphElement) as ParagraphElement;
         const paraContainer = paragraph.parent;
         //如果选中的是段落第一个元素
         const firstLeaf = ElementUtil.getFirstLeafElement(paragraph);
@@ -752,10 +779,10 @@ export class DocumentChange {
             //this.selectionState.resetRange(paragraph, 0);
             return paragraph;
         }
-        const last = ElementUtil.getLastLeafElement(paragraph);
+        const last = ElementUtil.getLastLeafElement(paragraph) as LeafElement;
         const selectedParaRange = RangeUtil.getSelctionRange(startControl, startOffset, last, 1, paragraph);
         selectedParaRange.isFullSelected = false;
-        const breakPara = ElementUtil.cloneRange(selectedParaRange, true);
+        const breakPara = ElementUtil.cloneRange(selectedParaRange, true) as ParagraphElement;
         ElementUtil.fixParagraphContent(paragraph);
         ElementUtil.fixParagraphContent(breakPara);
         paraContainer.addChild(breakPara, paragraph.getIndex() + 1);
@@ -763,10 +790,11 @@ export class DocumentChange {
         //this.selectionState.resetRange(breakPara, 0);
         return breakPara;
     }
+
     /**
      * 合并段落
      */
-    combineParagraph(prevPara, currPara, currElement) {
+    combineParagraph(prevPara: ParagraphElement, currPara: ParagraphElement, currElement: Element): void {
         const prevParaLength = prevPara.length;
         for (let i = 0; i < currPara.length; i++) {
             const child = currPara.getChild(i).clone(true);
@@ -778,11 +806,12 @@ export class DocumentChange {
         currParaContainer.removeChild(currPara);
         this.selectionState.resetRange(prevPara.getChild(prevParaLength), 0);
     }
+
     /**
      * 删除选中的区域内容
      * @param range
      */
-    deleteRange(range) {
+    deleteRange(range: SelectionContentRange): void {
         const { selectedChildren } = range;
         for (let i = selectedChildren.length - 1; i >= 0; i--) {
             const childRange = selectedChildren[i];
@@ -790,18 +819,15 @@ export class DocumentChange {
             if (childTarget instanceof LeafElement && !childTarget.isDecorate) {
                 if (childFullSelected) {
                     this.onDeleteItem(childTarget);
-                }
-                else if (childTarget instanceof TextGroupElement) {
+                } else if (childTarget instanceof TextGroupElement) {
                     const { startOffset, endOffset } = childRange;
                     this.onDeleteText(childTarget, startOffset, endOffset - startOffset);
                 }
-            }
-            else if (childTarget instanceof BranchElement) {
+            } else if (childTarget instanceof BranchElement) {
                 //留痕模式
                 if (this.selectionState.enableTrackChanges) {
                     this.deleteRange(childRange);
-                }
-                else {
+                } else {
                     //表格全选状态时，执行删除操作
                     if (childTarget instanceof TableElement && childFullSelected) {
                         childTarget.remove();
@@ -811,24 +837,24 @@ export class DocumentChange {
                     else if (childTarget instanceof BlockContentElement && childFullSelected) {
                         childTarget.remove();
                         childTarget.destroy();
-                    }
-                    else if (childTarget instanceof InlineGroupElement && childFullSelected) {
+                    } else if (childTarget instanceof InlineGroupElement && childFullSelected) {
                         childTarget.remove();
                         childTarget.destroy();
-                    }
-                    else {
+                    } else {
                         this.deleteRange(childRange);
                     }
                 }
             }
         }
     }
+
+
     /**
      * 表单区域删除处理
      * @param range
      * @returns
      */
-    deleteRangeInFormEdit(range) {
+    private deleteRangeInFormEdit(range: SelectionContentRange): void {
         const dataElement = ElementUtil.getDataElement(range.target);
         //在数据元内删除，调用普通的删除处理
         if (dataElement) {
@@ -840,57 +866,58 @@ export class DocumentChange {
             this.loopForDelDataEleRange(range);
         }
     }
+
     /**
      * 表单模式:删除选中的区域内容
      */
-    loopForDelDataEleRange(range) {
+    private loopForDelDataEleRange(range: SelectionContentRange): void {
         const { selectedChildren } = range;
         for (let i = selectedChildren.length - 1; i >= 0; i--) {
             const childRange = selectedChildren[i];
             const { target: childTarget } = childRange;
             if (childTarget instanceof BranchElement) {
                 if (childTarget instanceof DataElementInlineGroup) {
-                    const dataEleProps = childTarget.props;
+                    const dataEleProps = childTarget.props as DataEleBaseProps;
                     //数据元可编辑
                     if (dataEleProps.editable) {
                         this.deleteRange(childRange);
                     }
-                }
-                else {
-                    this.loopForDelDataEleRange(childRange);
+                } else {
+                    this.loopForDelDataEleRange(childRange)
                 }
             }
         }
     }
+
+
     /**
      * 向目标移动元素
      * @param sourceElement
      * @param moveElement
      */
-    moveElement(targetElement, targetOffset, moveElement, moveOffset, ss) {
+    moveElement(targetElement: Element, targetOffset: number, moveElement: Element, moveOffset: number, ss: SelectionState): void {
         moveElement.remove();
         if (targetElement instanceof TextGroupElement) {
             const { leftElement, rightElement } = this.splitText(targetElement, targetOffset);
             if (leftElement) {
-                leftElement.parent.addChild(moveElement, leftElement.getIndex() + 1);
-            }
-            else if (rightElement) {
-                rightElement.parent.addChild(moveElement, rightElement.getIndex());
+                leftElement.parent.addChild(moveElement, leftElement.getIndex() + 1)
+            } else if (rightElement) {
+                rightElement.parent.addChild(moveElement, rightElement.getIndex())
             }
-        }
-        else {
+        } else {
             targetElement.parent.addChild(moveElement, targetElement.getIndex() + targetOffset);
         }
         ss.resetRange(moveElement, moveOffset);
     }
+
     /**
      * 向指定的目标插入元素
      * @param targetElement
      * @param targetOffset
      * @param destEleArray
      */
-    insertElement(targetElement, targetOffset, destEleArray) {
-        let lastEle;
+    insertElement(targetElement: Element, targetOffset: number, destEleArray: Array<Element>): Element | null {
+        let lastEle!: Element | null;
         if (targetElement instanceof TextGroupElement) {
             const { leftElement, rightElement } = this.splitText(targetElement, targetOffset);
             if (leftElement) {
@@ -898,22 +925,22 @@ export class DocumentChange {
                     lastEle = destEleArray[i];
                     leftElement.parent.addChild(lastEle, leftElement.getIndex() + 1 + i);
                 }
-            }
-            else if (rightElement) {
+            } else if (rightElement) {
                 for (let i = 0; i < destEleArray.length; i++) {
-                    lastEle = destEleArray[i];
+                    lastEle = destEleArray[i]
                     rightElement.parent.addChild(lastEle, rightElement.getIndex());
                 }
             }
-        }
-        else {
+        } else {
             for (let i = 0; i < destEleArray.length; i++) {
-                lastEle = destEleArray[i];
+                lastEle = destEleArray[i]
                 targetElement.parent.addChild(lastEle, targetElement.getIndex() + targetOffset);
             }
         }
         return lastEle;
     }
+
+
     /**
      * 根据开始位置和结束位置，将字符切割成指定的区间
      * @param splitTextUnit
@@ -921,7 +948,7 @@ export class DocumentChange {
      * @param end
      * @returns
      */
-    static splitTextGroupByRange(text, start, end) {
+    static splitTextGroupByRange(text: TextGroupElement, start: number, end: number): TextGroupElement | null {
         end = end === -1 ? text.textMeasures.length : end;
         if (start === end) {
             return null;
@@ -941,31 +968,33 @@ export class DocumentChange {
             throw new Error('middleText is null');
         }
         text.parent.addChild(middleTextGroup, text.getIndex() + 1);
+
         if (text.textMeasures.length === 0) {
             text.remove();
             text.destroy();
         }
         return middleTextGroup;
     }
-    splitText(text, offset) {
+
+    splitText(text: TextGroupElement, offset: number): { leftElement: TextGroupElement | null, rightElement: TextGroupElement | null } {
         offset = offset == -1 ? text.textMeasures.length : offset;
         if (offset === text.textMeasures.length) {
             return {
                 leftElement: text,
                 rightElement: null
-            };
+            }
         }
         if (offset === 0) {
             return {
                 leftElement: null,
                 rightElement: text
-            };
+            }
         }
         const rightText = text.spliceText(offset, -1, true);
         if (rightText) {
             text.parent.addChild(rightText, text.getIndex() + 1);
         }
-        let leftText = text;
+        let leftText: TextGroupElement | null = text;
         if (text.textMeasures.length === 0) {
             text.remove();
             leftText = null;
@@ -973,15 +1002,16 @@ export class DocumentChange {
         return {
             leftElement: leftText,
             rightElement: rightText
-        };
+        }
     }
+
     /**
      * 设置选中的文本样式
      * @param ss
      * @param setterFunc
      * @returns
      */
-    static setTextStyle(ss, setterFunc) {
+    static setTextStyle(ss: SelectionState, setterFunc: (tp: TextProps) => void): void {
         const range = ss.selectedRange;
         if (!range || ss.collapsed) {
             return;
@@ -1005,62 +1035,58 @@ export class DocumentChange {
                     newSelectionRange.setEnd(middleElement, -1);
                 }
             }
-        }
-        else {
+        } else {
             if (startRange.isFullSelected) {
                 newSelectionRange.setStart(startRange.target, 0);
-            }
-            else {
+            } else {
                 if (startRange.target instanceof TextGroupElement) {
                     const middleElement = this.splitTextGroupByRange(startRange.target, startRange.startOffset, -1);
                     if (middleElement) {
                         setterFunc(middleElement.props);
                         newSelectionRange.setStart(middleElement, 0);
-                    }
-                    else {
+                    } else {
                         newSelectionRange.setStart(startRange.target, 0);
                     }
-                }
-                else {
+                } else {
                     newSelectionRange.setStart(startRange.target, startRange.startOffset);
                 }
             }
             if (endRange.isFullSelected) {
                 newSelectionRange.setEnd(endRange.target, -1);
-            }
-            else {
+            } else {
                 if (endRange.target instanceof TextGroupElement) {
                     const middleElement = this.splitTextGroupByRange(endRange.target, 0, endRange.endOffset);
                     if (middleElement) {
                         setterFunc(middleElement.props);
                         newSelectionRange.setEnd(middleElement, -1);
-                    }
-                    else {
+                    } else {
                         newSelectionRange.setStart(endRange.target, 0);
                     }
-                }
-                else {
+
+                } else {
                     newSelectionRange.setEnd(endRange.target, endRange.endOffset);
                 }
             }
         }
         ss.addRange(newSelectionRange);
     }
-    static recursionSetRangeTextStyle(range, setterFunc) {
+
+    private static recursionSetRangeTextStyle(range: SelectionContentRange, setterFunc: (tp: TextProps) => void): void {
         RangeUtil.recursionTraversalRangeHandler(range, (itemRange) => {
             if (itemRange.target instanceof TextGroupElement && itemRange.isFullSelected) {
-                setterFunc(itemRange.target.props);
+                setterFunc(itemRange.target.props)
             }
-        });
+        })
     }
-    static setParaAlign(ss, setterFunc) {
+
+
+    static setParaAlign(ss: SelectionState, setterFunc: (tp: ParagraphProps) => void): void {
         if (ss.collapsed && ss.startControl) {
             const para = ElementUtil.getParentByType(ss.startControl, ParagraphElement);
             if (para) {
                 setterFunc(para.props);
             }
-        }
-        else {
+        } else {
             const range = ss.selectedRange;
             if (!range) {
                 return;
@@ -1069,15 +1095,18 @@ export class DocumentChange {
                 if (itemRange.target instanceof ParagraphElement) {
                     setterFunc(itemRange.target.props);
                 }
-            });
+            })
         }
+
     }
+
+
     /**
      * 复制
      * @param evt
      * @returns
      */
-    onCopy(evt) {
+    onCopy(evt: ClipboardEvent): void {
         evt.preventDefault();
         const copySerializeStr = ElementSerialize.getSelectedJSON(this.selectionState, this.viewOptions);
         if (!copySerializeStr) {
@@ -1087,20 +1116,22 @@ export class DocumentChange {
         const copyStr = ElementSerialize.getSelectedText(this.selectionState, this.viewOptions);
         evt.clipboardData?.setData('text/plain', copyStr);
     }
+
     /**
      * 剪切
      * @param evt
      */
-    onCut(evt) {
+    onCut(evt: ClipboardEvent): void {
         this.onCopy(evt);
         this.onRangeDelete();
     }
+
     /**
      * 粘贴
      * @param evt
      * @returns
      */
-    onPaste(evt) {
+    onPaste(evt: ClipboardEvent): void {
         evt.preventDefault();
         let pasteText = evt.clipboardData?.getData('text/plain');
         const pasteData = evt.clipboardData?.getData('doc/plain');
@@ -1135,35 +1166,37 @@ export class DocumentChange {
             return;
         }
         if (pasteElement instanceof ParagraphElement || pasteElement instanceof InlineGroupElement) {
-            const children = [];
+            const children: Array<Element> = [];
             if (pasteElement instanceof ParagraphElement) {
                 children.push(...ElementUtil.getChildrenElements(pasteElement));
-            }
-            else if (pasteElement instanceof InlineGroupElement) {
+            } else if (pasteElement instanceof InlineGroupElement) {
                 children.push(pasteElement);
             }
             if (!children.length) {
                 throw new Error('段落子元素为空');
             }
-            const lastEle = this.insertElement(startControl, startOffset, children);
+            const lastEle = this.insertElement(startControl, startOffset, children) as Element;
             this.selectionState.resetRange(lastEle, -1);
             return;
         }
         console.log('粘贴:' + pasteData);
     }
-    insertSoftBr() {
+
+    insertSoftBr(): void {
         let { startControl, startOffset } = this.selectionState;
-        const lastEle = this.insertElement(startControl, startOffset, [new BreakElement()]);
+        const lastEle = this.insertElement(startControl, startOffset, [new BreakElement()]) as Element;
         const focusEle = ElementUtil.getNextSiblingElement(lastEle);
         if (focusEle) {
             this.selectionState.resetRange(focusEle, 0);
         }
+
     }
+
     /**
      * 处理黏贴的纯文本
      * @param text
      */
-    pastePlainText(text) {
+    private pastePlainText(text: string): void {
         const textItems = text.split(/\r?\n/);
         const { startControl, startOffset } = this.selectionState;
         if (this.viewOptions.docMode === DocMode.FormEdit || textItems.length === 1 || IsInSideInlineGroupInputElement(startControl, startOffset)) {
@@ -1174,12 +1207,11 @@ export class DocumentChange {
                     element: startControl,
                     offset: startOffset
                 }
-            });
-        }
-        else {
+            })
+        } else {
             const breakPara = this.splitCurrentParagraph();
             for (let i = 0; i < textItems.length; i++) {
-                const newPara = breakPara.clone(false);
+                const newPara = breakPara.clone(false) as ParagraphElement;
                 const inputTextProps = newPara.props.textProps;
                 const newTextEle = ElementUtil.getNewTextGroup(inputTextProps);
                 newTextEle.text = textItems[i];
@@ -1189,28 +1221,29 @@ export class DocumentChange {
             this.selectionState.resetRange(breakPara, 0);
         }
     }
+
     /**
      * 设置当前段落项目符号类型
      */
-    setParagraphNumberType() {
+    setParagraphNumberType(): void {
         const { startControl } = this.selectionState;
         if (!startControl) {
             return;
         }
-        const para = ElementUtil.getParentByType(startControl, ParagraphElement);
+        const para = ElementUtil.getParentByType(startControl, ParagraphElement) as ParagraphElement;
         if (para.props.numberType >= 0) {
             para.props.numberType = -1;
             para.props.indent = 0;
-        }
-        else {
+        } else {
             para.props.numberType = 0;
             para.props.indent = 15;
         }
     }
+
     /**
      * 插入批注
      */
-    insertComment() {
+    insertComment(): void {
         const { startControl, startOffset, endControl, endOffset, collapsed } = this.selectionState;
         if (collapsed || !startControl || !endControl) {
             return;
@@ -1219,11 +1252,14 @@ export class DocumentChange {
         const startCommMark = new CommentElement();
         startCommMark.props.id = id;
         startCommMark.props.markType = 'start';
+
         const endCommMark = new CommentElement();
         endCommMark.props.id = id;
         endCommMark.props.markType = 'end';
-        this.insertElement(endControl, endOffset, [endCommMark]);
-        this.insertElement(startControl, startOffset, [startCommMark]);
+
+        this.insertElement(endControl, endOffset, [endCommMark])
+        this.insertElement(startControl, startOffset, [startCommMark])
+
         const commContent = new CommContentElement();
         commContent.props.id = id;
         commContent.props.createId = this.viewOptions.editUser.id;
@@ -1235,10 +1271,12 @@ export class DocumentChange {
         }
         this.docCtx.document.commentsContainerElement.addChild(commContent, pos);
         this.selectionState.clear();
+
         this.docComment.afterCommentsChanged();
     }
-    validate() {
-        const dataEleList = this.docCtx.document.treeFilter(item => item instanceof DataElementInlineGroup);
+
+    validate(): boolean {
+        const dataEleList = this.docCtx.document.treeFilter(item => item instanceof DataElementInlineGroup) as Array<DataElementInlineGroup>;
         const errorEleList = dataEleList.map(item => ({ error: item.validate(), ele: item })).filter(item => item.error);
         if (!errorEleList.length) {
             return true;
@@ -1248,51 +1286,59 @@ export class DocumentChange {
             const startCommMark = new CommentElement();
             startCommMark.props.id = id;
             startCommMark.props.markType = 'start';
+
             const endCommMark = new CommentElement();
             endCommMark.props.id = id;
             endCommMark.props.markType = 'end';
+
             item.ele.addChild(startCommMark, 0);
-            item.ele.addChild(endCommMark, item.ele.length);
+            item.ele.addChild(endCommMark, item.ele.length)
             const caption = CommonUtil.nullToString(item.ele.props.caption);
             const validateElement = new ValidateElement();
             validateElement.props.title = caption + '验证';
             validateElement.props.id = id;
             validateElement.setContent(item.error);
+
             const pos = this.docComment.getCommMarkIndex(startCommMark);
             this.docCtx.document.commentsContainerElement.addChild(validateElement, pos);
-        });
+
+
+        })
         this.docCtx.selectionState.clear();
         this.docComment.afterCommentsChanged();
+
         return false;
     }
+
     /**
      * 移除空字符串
      * @param text
      */
-    removeEmptyText(text) {
+    removeEmptyText(text: TextGroupElement): void {
         //const nextLeafElementInPara = ElementUtil.getRecursionNextSiblingElement(text, true, true); getComputedStyle
         this.setCurosrForDeleteAction(text);
         const parent = text.parent;
         text.remove();
         this.removeEmtpyInlineBlock(parent);
     }
-    setCurosrForDeleteAction(control) {
+
+    setCurosrForDeleteAction(control: Element): void {
         const cursorInfo = this.getCursorElementByDeleteAction(control);
         if (cursorInfo) {
             this.selectionState.resetRange(cursorInfo.ele, cursorInfo.offset);
-        }
-        else {
+        } else {
             this.selectionState.clear();
         }
     }
-    getCursorElementByDeleteAction(control) {
+
+    getCursorElementByDeleteAction(control: Element): { ele: LeafElement, offset: number } | null {
         const prevLeafElementInPara = ElementUtil.getRecursionPrevSiblingElement(control, false, true);
         //判断是否为同一段落
         if (prevLeafElementInPara && ElementUtil.isInSameParagraph(prevLeafElementInPara, control)) {
             return {
                 ele: prevLeafElementInPara,
                 offset: ElementUtil.getElementEndOffset(prevLeafElementInPara)
-            };
+            }
         }
         //同一段落其他元素
         const nextLeafElementInPara = ElementUtil.getRecursionNextSiblingElement(control, true, true);
@@ -1300,34 +1346,36 @@ export class DocumentChange {
             return {
                 ele: nextLeafElementInPara,
                 offset: 0
-            };
+            }
         }
         //上一段落
         if (prevLeafElementInPara) {
             return {
                 ele: prevLeafElementInPara,
                 offset: prevLeafElementInPara instanceof PSymbolElement ? 0 : ElementUtil.getElementEndOffset(prevLeafElementInPara)
-            };
+            }
         }
         return null;
     }
+
     /**
      * 移除空行内标签
      * @param ele
      */
-    removeEmtpyInlineBlock(ele) {
+    removeEmtpyInlineBlock(ele: Element): void {
         if (ele instanceof InlineGroupElement && ele.length === 0) {
             const parent = ele.parent;
             ele.remove();
             this.removeEmtpyInlineBlock(parent);
         }
     }
+
     /**
      * 插入强制换页符号
      */
-    insertPageBreakPara() {
+    insertPageBreakPara(): void {
         const { startControl } = this.selectionState;
-        const currPara = ElementUtil.getParentByType(startControl, ParagraphElement);
+        const currPara = ElementUtil.getParentByType(startControl, ParagraphElement)
         if (!currPara) {
             return;
         }
@@ -1338,5 +1386,6 @@ export class DocumentChange {
             pageBreak.parent.addChild(pageBreak);
         }
     }
+
+
 }
-//# sourceMappingURL=document-change.js.map