@hailin-zheng/editor-core 1.0.3 → 1.0.6

package/dist/framework/document-change.js

@@ -1,1342 +0,0 @@
-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 "@/med_editor/framework/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";
-/**
- * 文档内容改变
- */
-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=document-change.js.map