@hailin-zheng/editor-core 1.0.10 → 1.0.14

package/lib/framework/document-change.js

@@ -0,0 +1,1342 @@
+import { SelectionRange } from "./document-selection";
+import { ElementUtil } from "./element-util";
+import { BlockContainerElement, BlockContentElement, BranchElement, DocMode, InlineGroupElement, LeafElement } 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";
+import { RangeUtil } from "./range-util";
+import { TableElement } from "./impl/table/table-impl";
+import { DocumentEvent } from "./document-event";
+import { KeyboradElementEvent } from "./element-event-define";
+import { ElementSerialize } from "./element-serialize";
+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 { CommentElement } from "./impl/comments/comment-element-impl";
+import { nanoid } from "nanoid";
+import { CommContentElement } from "./impl/comments/comment-content-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 "./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;
+    }
+    newInput(data) {
+        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);
+            return;
+        }
+        //当前输入节点是在留痕区域中，但是当前关闭了审阅模式，需要拆分留痕区域，创建新输入节点
+        if (!enableTrackChanges && this.isInTrackBlock(startControl)) {
+            const newInput = this.splitTrackElement(startControl, startOffset);
+            const comp = data.compositionStartInfo;
+            comp.element = newInput;
+            comp.offset = 0;
+            this.inputTextGroup(newInput, data);
+            return;
+        }
+        if (!(startControl instanceof TextGroupElement)) {
+            if (!data.compositionStartInfo) {
+                throw new Error('compositionStartInfo is null');
+            }
+            const siblingTextEle = startOffset === 1 ? ElementUtil.getNextSiblingElement(startControl) : ElementUtil.getPrevSiblingElement(startControl);
+            if (siblingTextEle instanceof TextGroupElement) {
+                data.compositionStartInfo.offset = startOffset === 0 ? siblingTextEle.text.length : 0;
+                this.inputTextGroup(siblingTextEle, data);
+            }
+            else {
+                const inputTextProps = this.getDefaultTextProps(startControl, startOffset);
+                const newTextGroup = ElementUtil.getNewTextGroup(inputTextProps);
+                startControl.parent.addChild(newTextGroup, startControl.getIndex() + startOffset);
+                this.inputTextGroup(newTextGroup, data);
+            }
+            return;
+        }
+        this.inputTextGroup(startControl, data);
+    }
+    /**
+     * 选中区域后进行输入
+     * 需要处理将选中的区域删除后，进行输入的情况
+     */
+    onInputBySelection(data) {
+        this.onRangeDelete();
+        this.selectionState.afterSelectionChanged = (newVal) => {
+            const { startControl, startOffset, editable } = newVal;
+            if (!editable) {
+                return false;
+            }
+            const comp = data.compositionStartInfo;
+            comp.element = startControl;
+            comp.offset = startOffset;
+            this.newInput(data);
+            return true;
+        };
+    }
+    /**
+     * 当前元素是否在正确的留痕区域(ins-run、del-run)，情况分为以下情况
+     * 1.留痕块类型为新增，但是留痕块的创建者为其他用户，此时需要拆分留痕区域
+     * 2.留痕块为当前用户创建，但是创建时间大于有效的时间，此时需要拆分留痕区域
+     * @param startControl
+     * @param trackType
+     * @returns
+     */
+    isInCorrectTrackRegion(startControl, trackType) {
+        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) {
+        return target.parent instanceof TrackRunElement && (trackType === null || target.parent.type === trackType);
+    }
+    /**
+     * 留痕输入
+     * @param data
+     * @param startControl
+     * @param startOffset
+     * @returns
+     */
+    newInputTrackChanges(data, startControl, startOffset) {
+        const userId = this.viewOptions.editUser.id;
+        const compInfo = data.compositionStartInfo;
+        if (this.isInCorrectTrackRegion(startControl, TrackRunTypeEnum.Inserted)) {
+            return;
+        }
+        if (this.isInTrackBlock(startControl)) {
+            const newInput = this.createNewTrackInput(startControl, startOffset, TrackRunTypeEnum.Inserted);
+            compInfo.offset = 0;
+            compInfo.element = newInput;
+            this.inputTextGroup(newInput, data);
+            return;
+        }
+        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
+     * @param startOffset
+     * @param trackType
+     * @returns
+     */
+    createNewTrackInput(startControl, startOffset, trackType) {
+        const textProps = this.getDefaultTextProps(startControl, startOffset);
+        const currTrackEle = startControl.parent;
+        if (startControl instanceof TextGroupElement && startOffset > 0 && startOffset < startControl.textMeasures.length) {
+            const splitText = startControl.spliceText(startOffset, startControl.textMeasures.length, true);
+            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);
+            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 {
+            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);
+        let textProps = para.props.textProps;
+        if (startControl instanceof TextGroupElement) {
+            textProps = startControl.props;
+        }
+        const dataEle = ElementUtil.getDataElement(startControl);
+        if (dataEle && IsInSideDataElement(startControl, offset)) {
+            return dataEle.props.valueTextProps;
+        }
+        return textProps;
+    }
+    /**
+     * 当前元素位于留痕区域内，但是当前编辑模式为非留痕模式，需要将当前留痕元素分割开来，插入新普通文本元素对象,并返回
+     * @param startControl
+     * @param startOffset
+     * @returns
+     */
+    splitTrackElement(startControl, startOffset) {
+        if (!(startControl.parent instanceof TrackRunElement) && startControl instanceof TextGroupElement) {
+            return startControl;
+        }
+        const textProps = this.getDefaultTextProps(startControl, startOffset);
+        const currTrackEle = startControl.parent;
+        if (startControl instanceof TextGroupElement && startOffset > 0 && startOffset < startControl.textMeasures.length) {
+            const splitText = startControl.spliceText(startOffset, startControl.textMeasures.length, true);
+            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);
+            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 {
+            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);
+        const trackElement = this.createTrackElement(trackType);
+        textProps = textProps || para.props.textProps;
+        const newTextGroup = ElementUtil.getNewTextGroup(textProps);
+        newTextGroup.props.color = '#ff4d4f';
+        trackElement.addChild(newTextGroup);
+        return {
+            trackElement,
+            newTextGroup
+        };
+    }
+    createTrackElement(trackType) {
+        const trackElement = new TrackRunElement(trackType);
+        trackElement.props.userId = this.viewOptions.editUser.id;
+        trackElement.props.userName = this.viewOptions.editUser.name;
+        trackElement.props.date = CommonUtil.formatNow('YYYY-MM-DD HH:mm:ss');
+        trackElement.props.id = nanoid(5);
+        return trackElement;
+    }
+    inputTextGroup(text, data) {
+        const prevInputData = data.prevInputData || '';
+        const prevInputDataLength = prevInputData.length;
+        if (!data.compositionStartInfo) {
+            throw new Error('compositionStartInfo is null');
+        }
+        const { element, offset } = data.compositionStartInfo;
+        let startInputOffset = offset;
+        //startInputOffset -= prevInputDataLength;
+        if (!(element instanceof TextGroupElement)) {
+            //当前选中元素位于输入元素是起始还是结束位置，如果位于起始位置，则输入偏移量为0,否则为未变更之前的内容length
+            if (ElementUtil.getNextSiblingElement(element) === text) {
+                startInputOffset = 0;
+            }
+            else {
+                startInputOffset = text.textMeasures.length - prevInputDataLength;
+            }
+        }
+        text.splice(startInputOffset, prevInputDataLength, data.data);
+        //输入后撤销，导致文本组内为空
+        if (!text.text.length) {
+            this.removeEmptyText(text);
+        }
+        else {
+            this.selectionState.resetRange(text, startInputOffset + data.data.length);
+        }
+    }
+    /**
+     * backspace,向前删除
+     */
+    onBackspace(evt) {
+        const { startControl, startOffset, collapsed } = this.selectionState;
+        if (!startControl) {
+            throw new Error('startControl is null');
+        }
+        const eventElement = new KeyboradElementEvent(this.docCtx);
+        eventElement.key = 'backspace';
+        eventElement.source = startControl;
+        eventElement.sourceEvent = evt;
+        eventElement.sourceOffset = startOffset;
+        const res = DocumentEvent.invokeEvent('BackspaceKey', startControl, eventElement, 'Capture', this.docCtx);
+        if (res && res.isCancel) {
+            return;
+        }
+        this.docComment.updateComments();
+        if (collapsed) {
+            this.onBackspaceElement(startControl, startOffset);
+        }
+        else {
+            this.onRangeDelete();
+        }
+    }
+    /**
+     * delete,向后删除
+     * @param evt
+     */
+    onDeleteKeyHandler(evt) {
+        const { startControl, startOffset, collapsed } = this.selectionState;
+        const eventElement = new KeyboradElementEvent(this.docCtx);
+        eventElement.key = 'delete';
+        eventElement.source = startControl;
+        eventElement.sourceEvent = evt;
+        eventElement.sourceOffset = startOffset;
+        const res = DocumentEvent.invokeEvent('DeleteKey', startControl, eventElement, 'Capture', this.docCtx);
+        if (res && res.isCancel) {
+            return;
+        }
+        if (collapsed) {
+            this.onKeyDeleteElement(startControl, startOffset);
+        }
+        else {
+            this.onRangeDelete();
+        }
+    }
+    /**
+     * 根据选择范围删除
+     */
+    onRangeDelete() {
+        const { selectedRange } = this.selectionState;
+        if (!selectedRange) {
+            throw new Error('selectionRange is null');
+        }
+        //用于刷新后定位光标
+        let startPointElement;
+        let startPointOffset = 0;
+        if (selectedRange.isFullSelected) {
+            //某个容器的内容被全部选中
+            if (selectedRange.target instanceof BlockContainerElement) {
+                startPointElement = selectedRange.target;
+                startPointOffset = 0;
+            }
+            //内容块被选中,需要向上寻找内容块容器
+            else if (selectedRange.target instanceof BlockContentElement) {
+                const parentContainer = ElementUtil.getParent(selectedRange.target, (item) => item instanceof BlockContainerElement);
+                if (parentContainer) {
+                    startPointElement = parentContainer;
+                    startPointOffset = 0;
+                }
+                else {
+                    throw new Error('未能向上寻找到定位的内容块容器');
+                }
+            }
+            else {
+                throw new Error('未知条件区间');
+            }
+        }
+        else {
+            const startRange = RangeUtil.getStartRangeTarget(selectedRange);
+            const endRange = RangeUtil.getEndRangeTarget(selectedRange);
+            if (startRange.isFullSelected) {
+                startPointElement = ElementUtil.getRecursionPrevSiblingElement(startRange.target, false, true);
+                startPointOffset = -1;
+                //判断结束选区和开始选区是否在一个段落中，尽量落在同一段落中
+                if (!startPointElement || ElementUtil.isInSameParagraph(startRange.target, endRange.target)) {
+                    if (!endRange.isFullSelected) {
+                        startPointElement = endRange.target;
+                        startPointOffset = 0;
+                    }
+                }
+            }
+            else {
+                startPointElement = startRange.target;
+                startPointOffset = startRange.startOffset;
+            }
+        }
+        if (this.viewOptions.docMode === DocMode.FormEdit) {
+            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) {
+        this.selectionState.clear();
+        if (offset === 0) {
+            const prevEle = ElementUtil.getRecursionPrevSiblingElement(control, false, true);
+            if (!prevEle) {
+                this.selectionState.resetRange(control, 0);
+                return;
+            }
+            if (ElementUtil.isInSameParagraph(control, prevEle)) {
+                if (ElementUtil.getPrevSiblingElement(control) === prevEle) {
+                    this.onBackspaceElement(prevEle, ElementUtil.getElementEndOffset(prevEle));
+                }
+                else {
+                    this.selectionState.resetRange(prevEle, -1);
+                }
+            }
+            else {
+                //需要判断是否是兄弟段落，兄弟段落，需要合并
+                const prevPara = ElementUtil.getParentByType(prevEle, ParagraphElement);
+                const currPara = ElementUtil.getParentByType(control, ParagraphElement);
+                //表明是紧挨着的两个段落，要进行段落合并
+                if (ElementUtil.getPrevSiblingElement(currPara) === prevPara) {
+                    if (this.selectionState.enableTrackChanges) {
+                        this.selectionState.resetRange(prevEle, -1);
+                        return;
+                    }
+                    this.combineParagraph(prevPara, currPara, control);
+                }
+                else {
+                    //不是紧挨着的段落，则前一个段落是位于另一个容器里，例如：处于单元格内的段落
+                    //则不向前定位
+                    this.selectionState.resetRange(control, offset);
+                }
+            }
+        }
+        else {
+            if (control instanceof TextGroupElement) {
+                this.onDeleteText(control, offset - 1, 1);
+                if (!control.textMeasures.length) {
+                    this.removeEmptyText(control);
+                }
+                else {
+                    this.selectionState.resetRange(control, offset - 1);
+                }
+            }
+            else {
+                if (control.parent instanceof InlineGroupInputElement && control instanceof DataDecorateElement) {
+                    const dataEle = control.parent;
+                    //空数据元，并且当前光标处于数据元开始位置
+                    if (this.canDeleteInlineGroup(dataEle)) {
+                        this.setCurosrForDeleteAction(dataEle);
+                        dataEle.remove();
+                        return;
+                    }
+                    if (control.isPrefix && this.viewOptions.docMode === DocMode.FormEdit) {
+                        if (this.jumpToPrevDataElement(dataEle)) {
+                            return;
+                        }
+                    }
+                }
+                if (control.isDecorate) {
+                    this.onBackspaceElement(control, 0);
+                    return;
+                }
+                this.removeElement(control);
+            }
+        }
+    }
+    /**
+     * 跳到上一个数据元中
+     * @param currEle
+     */
+    jumpToPrevDataElement(currEle) {
+        if (this.viewOptions.docMode !== DocMode.FormEdit) {
+            return false;
+        }
+        const prevEle = ElementUtil.getPrevDataElement(this.docCtx, currEle);
+        if (!prevEle) {
+            return false;
+        }
+        if (prevEle) {
+            this.selectionState.resetRange(prevEle.endDecorate, 0);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * delete删除
+     * @param control
+     * @param offset
+     * @returns
+     */
+    onKeyDeleteElement(control, offset) {
+        this.selectionState.clear();
+        if (offset === ElementUtil.getElementEndOffset(control)) {
+            const nextEle = ElementUtil.getRecursionNextSiblingElement(control, false, true);
+            if (!nextEle) {
+                this.selectionState.resetRange(control, -1);
+                return;
+            }
+            if (ElementUtil.isInSameParagraph(control, nextEle)) {
+                if (ElementUtil.getNextSiblingElement(control) === nextEle) {
+                    this.onKeyDeleteElement(nextEle, 0);
+                }
+                else {
+                    this.selectionState.resetRange(nextEle, 0);
+                }
+            }
+            else {
+                //需要判断是否是兄弟段落，兄弟段落，需要合并
+                const nextPara = ElementUtil.getParentByType(nextEle, ParagraphElement);
+                const currPara = ElementUtil.getParentByType(control, ParagraphElement);
+                //表明是紧挨着的两个段落，要进行段落合并
+                if (ElementUtil.getNextSiblingElement(currPara) === nextPara) {
+                    if (this.selectionState.enableTrackChanges) {
+                        this.selectionState.resetRange(nextEle, 0);
+                        return;
+                    }
+                    this.combineParagraph(nextPara, currPara, control);
+                }
+                else {
+                    //不是紧挨着的段落，则前一个段落是位于另一个容器里，例如：处于单元格内的段落
+                    //则不向前定位
+                    this.selectionState.resetRange(control, offset);
+                }
+            }
+        }
+        else {
+            if (control instanceof TextGroupElement) {
+                this.onDeleteText(control, offset, 1);
+                if (!control.textMeasures.length) {
+                    this.removeEmptyText(control);
+                }
+                else {
+                    this.selectionState.resetRange(control, offset);
+                }
+            }
+            else {
+                if (control.parent instanceof DataElementInlineGroup && control instanceof DataDecorateElement) {
+                    const dataEle = control.parent;
+                    //空数据元，并且当前光标处于数据元开始位置
+                    if (control.isPrefix) {
+                        if (this.canDeleteInlineGroup(dataEle)) {
+                            this.setCurosrForDeleteAction(dataEle);
+                            dataEle.remove();
+                        }
+                        else {
+                            this.selectionState.resetRange(control, -1);
+                        }
+                        return;
+                    }
+                    else if (!control.isPrefix && dataEle.length === 2) {
+                        this.selectionState.resetRange(dataEle.endDecorate, -1);
+                        return;
+                    }
+                }
+                if (control.isDecorate) {
+                    //this.onKeyDeleteElement(control, -1);
+                    return;
+                }
+                this.removeElement(control);
+            }
+        }
+    }
+    /**
+     * 判断是否可以删除数据组
+     * @param dataEle
+     * @private
+     */
+    canDeleteInlineGroup(dataEle) {
+        if (this.viewOptions.docMode === DocMode.FormEdit) {
+            return false;
+        }
+        return dataEle.length === 2;
+    }
+    onDeleteText(text, offset, len) {
+        if (this.selectionState.enableTrackChanges) {
+            this.updateDeletedTrackText(text, offset, len);
+        }
+        else {
+            text.splice(offset, len);
+        }
+    }
+    onDeleteItem(item) {
+        if (this.selectionState.enableTrackChanges) {
+            //删除符号不进行留痕
+            if (item.type === 'psym') {
+                return;
+            }
+            this.onTrackDeleteElement(item);
+        }
+        else {
+            item.remove();
+            item.destroy();
+        }
+    }
+    /**
+     * 当前元素是否在留痕元素内
+     * @param target
+     * @param trackType
+     * @returns
+     */
+    isInCurrentUserTrack(target, trackType) {
+        if (target.parent instanceof TrackRunElement && target.parent.type === trackType && target.parent.props.userId === this.viewOptions.editUser.id) {
+            return true;
+        }
+        return false;
+    }
+    isInTrackElement(target, trackType) {
+        if (target.parent instanceof TrackRunElement && target.parent.type === trackType) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * 留痕除文本以外的其他元素
+     * @param control
+     */
+    onTrackDeleteElement(target) {
+        const parent = target.parent;
+        if (this.isInTrackElement(target, TrackRunTypeEnum.Deleted)) {
+            return;
+        }
+        //当前用户增加的内容，内容直接删除不需要留痕
+        if (this.isInCurrentUserTrack(target, TrackRunTypeEnum.Inserted)) {
+            target.remove();
+            this.removeEmtpyInlineBlock(parent);
+            return;
+        }
+        //target.remove();
+        const trackEle = this.getNextTrackElement(target, TrackRunTypeEnum.Deleted);
+        trackEle.addChild(target.clone(true), 0);
+        target.remove();
+        this.removeEmtpyInlineBlock(parent);
+    }
+    /**
+     * 更新文本删除留痕
+     */
+    updateDeletedTrackText(target, offset, len) {
+        if (this.isInTrackElement(target, TrackRunTypeEnum.Deleted)) {
+            return;
+        }
+        //当前用户增加的内容，当前用户删除时不需要留痕
+        if (this.isInCurrentUserTrack(target, TrackRunTypeEnum.Inserted)) {
+            target.splice(offset, len);
+            return;
+        }
+        //全部被删除
+        if (offset === 0 && len === target.textMeasures.length) {
+            const trackInputText = this.getNextTrackInputElement(target, TrackRunTypeEnum.Deleted);
+            trackInputText.text = target.text + trackInputText.text;
+            target.splice(0, target.textMeasures.length);
+            //target.remove();
+            return;
+        }
+        const { leftElement } = this.splitText(target, offset + len);
+        target = leftElement;
+        let trackText = 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);
+        if (trackElement) {
+            const firstEle = trackElement.getChild(0);
+            if (firstEle && firstEle instanceof TextGroupElement) {
+                return firstEle;
+            }
+            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);
+            target.parent.addChild(trackElement, target.getIndex() + 1);
+            return newTextGroup;
+        }
+    }
+    getNextTrackElement(target, trackType) {
+        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) {
+        const prevEle = ElementUtil.getRecursionPrevSiblingElement(control, false, true);
+        if (!prevEle) {
+            const nextEle = ElementUtil.getRecursionNextSiblingElement(control, true, true);
+            if (nextEle) {
+                this.selectionState.resetRange(nextEle, 0);
+                control.remove();
+                return;
+            }
+            return;
+        }
+        if (ElementUtil.isInSameParagraph(control, prevEle)) {
+            this.selectionState.resetRange(prevEle, -1);
+            control.remove();
+            return;
+        }
+        else {
+            const nextEle = ElementUtil.getRecursionNextSiblingElement(control, true, true);
+            if (nextEle && ElementUtil.getPrevSiblingElement(nextEle) === control) {
+                this.selectionState.resetRange(nextEle, 0);
+                control.remove();
+                return;
+            }
+            else {
+                this.selectionState.resetRange(prevEle, -1);
+                control.remove();
+                return;
+            }
+        }
+    }
+    /**
+     * 回车事件
+     */
+    onEnter() {
+        const { startControl } = this.selectionState;
+        const paragraph = ElementUtil.getParentByType(startControl, ParagraphElement);
+        const breakPara = this.splitCurrentParagraph();
+        //选中的是一个元素
+        if (breakPara === paragraph) {
+            const clonePara = paragraph.clone(false);
+            breakPara.parent.addChild(clonePara, breakPara.getIndex());
+        }
+        this.selectionState.resetRange(breakPara, 0);
+    }
+    /**
+     * 插入表格
+     * @param tb
+     * @returns
+     */
+    insertTable(tb) {
+        const breakPara = this.splitCurrentParagraph();
+        breakPara.parent.addChild(tb, breakPara.getIndex());
+        this.selectionState.resetRange(tb, 0);
+    }
+    /**
+     * 分割当前段落用于插入表格或者粘贴的内容
+     * @param insertItems 分割后插入的内容，内容需要是block或者表格对象
+     */
+    splitCurrentParagraph() {
+        const { startControl, startOffset } = this.selectionState;
+        const paragraph = ElementUtil.getParentByType(startControl, ParagraphElement);
+        const paraContainer = paragraph.parent;
+        //如果选中的是段落第一个元素
+        const firstLeaf = ElementUtil.getFirstLeafElement(paragraph);
+        if ((startControl === firstLeaf && startOffset === 0) || (startControl === firstLeaf && startControl instanceof PSymbolElement)) {
+            //this.selectionState.resetRange(paragraph, 0);
+            return paragraph;
+        }
+        const last = ElementUtil.getLastLeafElement(paragraph);
+        const selectedParaRange = RangeUtil.getSelctionRange(startControl, startOffset, last, 1, paragraph);
+        selectedParaRange.isFullSelected = false;
+        const breakPara = ElementUtil.cloneRange(selectedParaRange, true);
+        ElementUtil.fixParagraphContent(paragraph);
+        ElementUtil.fixParagraphContent(breakPara);
+        paraContainer.addChild(breakPara, paragraph.getIndex() + 1);
+        //paraContainer.addChild(tb, breakPara.getIndex());
+        //this.selectionState.resetRange(breakPara, 0);
+        return breakPara;
+    }
+    /**
+     * 合并段落
+     */
+    combineParagraph(prevPara, currPara, currElement) {
+        const prevParaLength = prevPara.length;
+        for (let i = 0; i < currPara.length; i++) {
+            const child = currPara.getChild(i).clone(true);
+            prevPara.addChild(child);
+        }
+        //currPara.remove();
+        const currParaContainer = currPara.parent;
+        currPara.destroy();
+        currParaContainer.removeChild(currPara);
+        this.selectionState.resetRange(prevPara.getChild(prevParaLength), 0);
+    }
+    /**
+     * 删除选中的区域内容
+     * @param range
+     */
+    deleteRange(range) {
+        const { selectedChildren } = range;
+        for (let i = selectedChildren.length - 1; i >= 0; i--) {
+            const childRange = selectedChildren[i];
+            const { target: childTarget, isFullSelected: childFullSelected } = childRange;
+            if (childTarget instanceof LeafElement && !childTarget.isDecorate) {
+                if (childFullSelected) {
+                    this.onDeleteItem(childTarget);
+                }
+                else if (childTarget instanceof TextGroupElement) {
+                    const { startOffset, endOffset } = childRange;
+                    this.onDeleteText(childTarget, startOffset, endOffset - startOffset);
+                }
+            }
+            else if (childTarget instanceof BranchElement) {
+                //留痕模式
+                if (this.selectionState.enableTrackChanges) {
+                    this.deleteRange(childRange);
+                }
+                else {
+                    //表格全选状态时，执行删除操作
+                    if (childTarget instanceof TableElement && childFullSelected) {
+                        childTarget.remove();
+                        childTarget.destroy();
+                    }
+                    //段落全选状态时，执行删除操作
+                    else if (childTarget instanceof BlockContentElement && childFullSelected) {
+                        childTarget.remove();
+                        childTarget.destroy();
+                    }
+                    else if (childTarget instanceof InlineGroupElement && childFullSelected) {
+                        childTarget.remove();
+                        childTarget.destroy();
+                    }
+                    else {
+                        this.deleteRange(childRange);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * 表单区域删除处理
+     * @param range
+     * @returns
+     */
+    deleteRangeInFormEdit(range) {
+        const dataElement = ElementUtil.getDataElement(range.target);
+        //在数据元内删除，调用普通的删除处理
+        if (dataElement) {
+            this.deleteRange(range);
+            return;
+        }
+        //在数据元外删除
+        else {
+            this.loopForDelDataEleRange(range);
+        }
+    }
+    /**
+     * 表单模式:删除选中的区域内容
+     */
+    loopForDelDataEleRange(range) {
+        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;
+                    //数据元可编辑
+                    if (dataEleProps.editable) {
+                        this.deleteRange(childRange);
+                    }
+                }
+                else {
+                    this.loopForDelDataEleRange(childRange);
+                }
+            }
+        }
+    }
+    /**
+     * 向目标移动元素
+     * @param sourceElement
+     * @param moveElement
+     */
+    moveElement(targetElement, targetOffset, moveElement, moveOffset, ss) {
+        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());
+            }
+        }
+        else {
+            targetElement.parent.addChild(moveElement, targetElement.getIndex() + targetOffset);
+        }
+        ss.resetRange(moveElement, moveOffset);
+    }
+    /**
+     * 向指定的目标插入元素
+     * @param targetElement
+     * @param targetOffset
+     * @param destEleArray
+     */
+    insertElement(targetElement, targetOffset, destEleArray) {
+        let lastEle;
+        if (targetElement instanceof TextGroupElement) {
+            const { leftElement, rightElement } = this.splitText(targetElement, targetOffset);
+            if (leftElement) {
+                for (let i = 0; i < destEleArray.length; i++) {
+                    lastEle = destEleArray[i];
+                    leftElement.parent.addChild(lastEle, leftElement.getIndex() + 1 + i);
+                }
+            }
+            else if (rightElement) {
+                for (let i = 0; i < destEleArray.length; i++) {
+                    lastEle = destEleArray[i];
+                    rightElement.parent.addChild(lastEle, rightElement.getIndex());
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < destEleArray.length; i++) {
+                lastEle = destEleArray[i];
+                targetElement.parent.addChild(lastEle, targetElement.getIndex() + targetOffset);
+            }
+        }
+        return lastEle;
+    }
+    /**
+     * 根据开始位置和结束位置，将字符切割成指定的区间
+     * @param splitTextUnit
+     * @param start
+     * @param end
+     * @returns
+     */
+    static splitTextGroupByRange(text, start, end) {
+        end = end === -1 ? text.textMeasures.length : end;
+        if (start === end) {
+            return null;
+        }
+        if (start === 0 && end === text.textMeasures.length) {
+            return text;
+        }
+        if (start === text.textMeasures.length) {
+            return null;
+        }
+        let lastTextGroup = text.spliceText(end, -1, true);
+        let middleTextGroup = text.spliceText(start, -1, true);
+        if (lastTextGroup) {
+            text.parent.addChild(lastTextGroup, text.getIndex() + 1);
+        }
+        if (!middleTextGroup) {
+            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) {
+        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;
+        if (text.textMeasures.length === 0) {
+            text.remove();
+            leftText = null;
+        }
+        return {
+            leftElement: leftText,
+            rightElement: rightText
+        };
+    }
+    /**
+     * 设置选中的文本样式
+     * @param ss
+     * @param setterFunc
+     * @returns
+     */
+    static setTextStyle(ss, setterFunc) {
+        const range = ss.selectedRange;
+        if (!range || ss.collapsed) {
+            return;
+        }
+        const newSelectionRange = new SelectionRange();
+        const startRange = ElementUtil.getFirstSelectedRange(range);
+        const endRange = ElementUtil.getLastSelectedRange(range);
+        this.recursionSetRangeTextStyle(range, setterFunc);
+        if (startRange === endRange) {
+            if (startRange.isFullSelected) {
+                newSelectionRange.setStart(startRange.target, 0);
+                newSelectionRange.setEnd(startRange.target, -1);
+            }
+            if (startRange.target instanceof TextGroupElement) {
+                const startSelectedOffset = ss.startOffset;
+                const endSelectedOffset = ss.endOffset;
+                const middleElement = this.splitTextGroupByRange(startRange.target, startSelectedOffset, endSelectedOffset);
+                if (middleElement) {
+                    setterFunc(middleElement.props);
+                    newSelectionRange.setStart(middleElement, 0);
+                    newSelectionRange.setEnd(middleElement, -1);
+                }
+            }
+        }
+        else {
+            if (startRange.isFullSelected) {
+                newSelectionRange.setStart(startRange.target, 0);
+            }
+            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 {
+                        newSelectionRange.setStart(startRange.target, 0);
+                    }
+                }
+                else {
+                    newSelectionRange.setStart(startRange.target, startRange.startOffset);
+                }
+            }
+            if (endRange.isFullSelected) {
+                newSelectionRange.setEnd(endRange.target, -1);
+            }
+            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 {
+                        newSelectionRange.setStart(endRange.target, 0);
+                    }
+                }
+                else {
+                    newSelectionRange.setEnd(endRange.target, endRange.endOffset);
+                }
+            }
+        }
+        ss.addRange(newSelectionRange);
+    }
+    static recursionSetRangeTextStyle(range, setterFunc) {
+        RangeUtil.recursionTraversalRangeHandler(range, (itemRange) => {
+            if (itemRange.target instanceof TextGroupElement && itemRange.isFullSelected) {
+                setterFunc(itemRange.target.props);
+            }
+        });
+    }
+    static setParaAlign(ss, setterFunc) {
+        if (ss.collapsed && ss.startControl) {
+            const para = ElementUtil.getParentByType(ss.startControl, ParagraphElement);
+            if (para) {
+                setterFunc(para.props);
+            }
+        }
+        else {
+            const range = ss.selectedRange;
+            if (!range) {
+                return;
+            }
+            RangeUtil.recursionTraversalRangeHandler(range, (itemRange) => {
+                if (itemRange.target instanceof ParagraphElement) {
+                    setterFunc(itemRange.target.props);
+                }
+            });
+        }
+    }
+    /**
+     * 复制
+     * @param evt
+     * @returns
+     */
+    onCopy(evt) {
+        evt.preventDefault();
+        const copySerializeStr = ElementSerialize.getSelectedJSON(this.selectionState, this.viewOptions);
+        if (!copySerializeStr) {
+            return;
+        }
+        evt.clipboardData?.setData('doc/plain', copySerializeStr);
+        const copyStr = ElementSerialize.getSelectedText(this.selectionState, this.viewOptions);
+        evt.clipboardData?.setData('text/plain', copyStr);
+    }
+    /**
+     * 剪切
+     * @param evt
+     */
+    onCut(evt) {
+        this.onCopy(evt);
+        this.onRangeDelete();
+    }
+    /**
+     * 粘贴
+     * @param evt
+     * @returns
+     */
+    onPaste(evt) {
+        evt.preventDefault();
+        let pasteText = evt.clipboardData?.getData('text/plain');
+        const pasteData = evt.clipboardData?.getData('doc/plain');
+        if (!pasteData) {
+            if (pasteText) {
+                this.pastePlainText(pasteText);
+            }
+            return;
+        }
+        const pasteElement = this.eleReader.readElement(JSON.parse(pasteData));
+        if (!pasteElement) {
+            console.log('粘贴反序列化数据失败', pasteData);
+            return;
+        }
+        const { collapsed } = this.selectionState;
+        let { startControl, startOffset } = this.selectionState;
+        if (!collapsed) {
+            //TODO:如果一个容器内的元素被全部删除，则返回 null
+            // const { cursorEle, cursorOffset } = this.onRangeDelete();
+            // startControl = cursorEle;
+            // startOffset = cursorOffset;
+        }
+        if (!startControl) {
+            return;
+        }
+        //表单模式:如果复制的是单格式的文本，需要序列化为纯文本处理
+        if (this.viewOptions.docMode === DocMode.FormEdit) {
+            const pasteString = ElementSerialize.serializeString(pasteElement, { all: false });
+            if (pasteString) {
+                this.pastePlainText(pasteString);
+            }
+            return;
+        }
+        if (pasteElement instanceof ParagraphElement || pasteElement instanceof InlineGroupElement) {
+            const children = [];
+            if (pasteElement instanceof ParagraphElement) {
+                children.push(...ElementUtil.getChildrenElements(pasteElement));
+            }
+            else if (pasteElement instanceof InlineGroupElement) {
+                children.push(pasteElement);
+            }
+            if (!children.length) {
+                throw new Error('段落子元素为空');
+            }
+            const lastEle = this.insertElement(startControl, startOffset, children);
+            this.selectionState.resetRange(lastEle, -1);
+            return;
+        }
+        console.log('粘贴:' + pasteData);
+    }
+    insertSoftBr() {
+        let { startControl, startOffset } = this.selectionState;
+        const lastEle = this.insertElement(startControl, startOffset, [new BreakElement()]);
+        const focusEle = ElementUtil.getNextSiblingElement(lastEle);
+        if (focusEle) {
+            this.selectionState.resetRange(focusEle, 0);
+        }
+    }
+    /**
+     * 处理黏贴的纯文本
+     * @param text
+     */
+    pastePlainText(text) {
+        const textItems = text.split(/\r?\n/);
+        const { startControl, startOffset } = this.selectionState;
+        if (this.viewOptions.docMode === DocMode.FormEdit || textItems.length === 1 || IsInSideInlineGroupInputElement(startControl, startOffset)) {
+            text = text.replace(/[\n\r]/g, '');
+            this.newInput({
+                data: text,
+                compositionStartInfo: {
+                    element: startControl,
+                    offset: startOffset
+                }
+            });
+        }
+        else {
+            const breakPara = this.splitCurrentParagraph();
+            for (let i = 0; i < textItems.length; i++) {
+                const newPara = breakPara.clone(false);
+                const inputTextProps = newPara.props.textProps;
+                const newTextEle = ElementUtil.getNewTextGroup(inputTextProps);
+                newTextEle.text = textItems[i];
+                newPara.addChild(newTextEle, 0);
+                breakPara.parent.addChild(newPara, breakPara.getIndex());
+            }
+            this.selectionState.resetRange(breakPara, 0);
+        }
+    }
+    /**
+     * 设置当前段落项目符号类型
+     */
+    setParagraphNumberType() {
+        const { startControl } = this.selectionState;
+        if (!startControl) {
+            return;
+        }
+        const para = ElementUtil.getParentByType(startControl, ParagraphElement);
+        if (para.props.numberType >= 0) {
+            para.props.numberType = -1;
+            para.props.indent = 0;
+        }
+        else {
+            para.props.numberType = 0;
+            para.props.indent = 15;
+        }
+    }
+    /**
+     * 插入批注
+     */
+    insertComment() {
+        const { startControl, startOffset, endControl, endOffset, collapsed } = this.selectionState;
+        if (collapsed || !startControl || !endControl) {
+            return;
+        }
+        const id = nanoid(5);
+        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]);
+        const commContent = new CommContentElement();
+        commContent.props.id = id;
+        commContent.props.createId = this.viewOptions.editUser.id;
+        commContent.props.createName = this.viewOptions.editUser.name;
+        commContent.props.createDate = new Date();
+        const pos = this.docComment.getCommMarkIndex(startCommMark);
+        if (pos < 0) {
+            throw new Error('获取插入的批注位置不正确');
+        }
+        this.docCtx.document.commentsContainerElement.addChild(commContent, pos);
+        this.selectionState.clear();
+        this.docComment.afterCommentsChanged();
+    }
+    validate() {
+        const dataEleList = this.docCtx.document.treeFilter(item => item instanceof DataElementInlineGroup);
+        const errorEleList = dataEleList.map(item => ({ error: item.validate(), ele: item })).filter(item => item.error);
+        if (!errorEleList.length) {
+            return true;
+        }
+        errorEleList.forEach(item => {
+            const id = nanoid(5);
+            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);
+            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) {
+        //const nextLeafElementInPara = ElementUtil.getRecursionNextSiblingElement(text, true, true); getComputedStyle
+        this.setCurosrForDeleteAction(text);
+        const parent = text.parent;
+        text.remove();
+        this.removeEmtpyInlineBlock(parent);
+    }
+    setCurosrForDeleteAction(control) {
+        const cursorInfo = this.getCursorElementByDeleteAction(control);
+        if (cursorInfo) {
+            this.selectionState.resetRange(cursorInfo.ele, cursorInfo.offset);
+        }
+        else {
+            this.selectionState.clear();
+        }
+    }
+    getCursorElementByDeleteAction(control) {
+        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);
+        if (nextLeafElementInPara) {
+            return {
+                ele: nextLeafElementInPara,
+                offset: 0
+            };
+        }
+        //上一段落
+        if (prevLeafElementInPara) {
+            return {
+                ele: prevLeafElementInPara,
+                offset: prevLeafElementInPara instanceof PSymbolElement ? 0 : ElementUtil.getElementEndOffset(prevLeafElementInPara)
+            };
+        }
+        return null;
+    }
+    /**
+     * 移除空行内标签
+     * @param ele
+     */
+    removeEmtpyInlineBlock(ele) {
+        if (ele instanceof InlineGroupElement && ele.length === 0) {
+            const parent = ele.parent;
+            ele.remove();
+            this.removeEmtpyInlineBlock(parent);
+        }
+    }
+    /**
+     * 插入强制换页符号
+     */
+    insertPageBreakPara() {
+        const { startControl } = this.selectionState;
+        const currPara = ElementUtil.getParentByType(startControl, ParagraphElement);
+        if (!currPara) {
+            return;
+        }
+        if (currPara.parent instanceof DocumentBodyElement) {
+            const pageBreak = new ParagraphElement();
+            pageBreak.props.pageBreak = true;
+            pageBreak.props.textAlign = 'center';
+            pageBreak.parent.addChild(pageBreak);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document-change.js","sourceRoot":"lib/","sources":["framework/document-change.ts"],"names":[],"mappings":"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"}