@hailin-zheng/editor-core 1.0.10 → 1.0.14

package/lib/framework/element-util.js

@@ -0,0 +1,1463 @@
+import { nanoid } from "nanoid";
+import { BranchElement, LeafElement, Rect } from "./element-define";
+import { TextProps } from "./element-props";
+import { CommsContainerElement } from "./impl/comments/comments-container-impl";
+import { DataElementInlineGroup } from "./impl/data-element/data-element-base-impl";
+import { DocumentBodyElement } from "./impl/document/doc-body-impl";
+import { DocumentFooterElement } from "./impl/document/doc-footer-impl";
+import { DocumentHeaderElement } from "./impl/document/doc-header-impl";
+import { DocumentRenderObject } from "./impl/document/doc-impl";
+import { ParagraphElement, ParagraphLineRectRenderObject, ParagraphRenderObject } from "./impl/paragraph/p-impl";
+import { PSymbolElement } from "./impl/symbol/p-symbol-impl";
+import { TableCellElement } from "./impl/table/table-cell-impl";
+import { TableRenderObject } from "./impl/table/table-impl";
+import { TableRowRenderObject } from "./impl/table/table-row-impl";
+import { TextGroupElement, TextGroupRenderObject } from "./impl/text/text-impl";
+import { TrackRunElement } from "./impl/text/track-run-impl";
+import { BranchRenderObject, LeafRenderObject } from "./render-define";
+export class ElementUtil {
+    static setCanvasProps(canvas, ctx, viewOptions, scale = 1) {
+        // if (canvas instanceof OffscreenCanvas) {
+        //     this.setOffscreenCanvas(canvas, ctx as OffscreenCanvasRenderingContext2D, viewOptions, scale);
+        //     return
+        // }
+        const { width, height } = viewOptions;
+        let dpr = window.devicePixelRatio || 1;
+        if (scale > 1) {
+            dpr *= scale;
+        }
+        dpr = Math.ceil(dpr);
+        const scaleWidth = Math.floor(width * dpr) / dpr;
+        const scaleHeight = Math.floor(height * dpr) / dpr;
+        canvas.style.width = scaleWidth + 'px';
+        canvas.style.height = scaleHeight + 'px';
+        canvas.width = scaleWidth * dpr;
+        canvas.height = scaleHeight * dpr;
+        ctx.scale(dpr, dpr);
+    }
+    // static setOffscreenCanvas(canvas: OffscreenCanvas, ctx: OffscreenCanvasRenderingContext2D, viewOptions: { width: number, height: number }, scale: number = 1): void {
+    //     const { width, height } = viewOptions;
+    //     let dpr = window.devicePixelRatio || 1;
+    //     if (scale > 1) {
+    //         dpr *= scale;
+    //     }
+    //     dpr = Math.ceil(dpr);
+    //     const scaleWidth = Math.floor(width * dpr) / dpr;
+    //     const scaleHeight = Math.floor(height * dpr) / dpr;
+    //     canvas.width = scaleWidth * dpr;
+    //     canvas.height = scaleHeight * dpr;
+    //     ctx.scale(dpr, dpr);
+    // }
+    static getDprNumber(val, scale = 1) {
+        let dpr = window.devicePixelRatio || 1;
+        if (scale > 1) {
+            dpr *= scale;
+        }
+        dpr = Math.ceil(dpr);
+        return Math.floor(val * dpr) / dpr;
+    }
+    static readTextProps(dest, props, options) {
+        if (!props) {
+            return this.createTextProps(dest, options);
+        }
+        const textProps = dest ?? new TextProps();
+        textProps.color = props.color || options.defaultColor;
+        textProps.fontName = props.fontName || options.defaultFontName;
+        textProps.fontSize = props.fontSize || options.defaultFontSize;
+        textProps.border = props.border;
+        if (props.fontWeight) {
+            textProps.fontWeight = props.fontWeight;
+        }
+        if (props.fontStyle) {
+            textProps.fontStyle = props.fontStyle;
+        }
+        if (props.underline) {
+            textProps.underline = props.underline;
+        }
+        if (props.linethrough) {
+            textProps.linethrough = props.linethrough;
+        }
+        if (props.overline) {
+            textProps.overline = props.overline;
+        }
+        if (props.background) {
+            textProps.background = props.background;
+        }
+        if (props.letterSpace) {
+            textProps.letterSpace = props.letterSpace;
+        }
+        if (props.vertAlign) {
+            textProps.vertAlign = props.vertAlign;
+        }
+        return textProps;
+    }
+    static readEleBaseProps(dest, props) {
+        dest.id = props.id ?? nanoid(5);
+        dest.name = props.name;
+        dest.caption = props.caption;
+        dest.editable = props.editable ?? true;
+        dest.fieldName = props.fieldName;
+        dest.minLength = props.minLength;
+        dest.printable = props.printable ?? true;
+        dest.required = props.required;
+        dest.secretBrowse = props.secretBrowse;
+        dest.deleteable = props.deleteable;
+        dest.underline = props.underline;
+        dest.type = props.type;
+        return dest;
+    }
+    /**
+     * 获取内容区域最大高度
+     * @param render
+     * @param renderHeight
+     * @returns
+     */
+    static innerRectMaxHeight(render, renderHeight) {
+        const { padding } = render;
+        return renderHeight - padding.top - padding.bottom;
+    }
+    /**
+     * 根据内框内容高度，更新外框框体高度
+     * @param render
+     * @param innerRect
+     */
+    static updateRenderHeightByInnerRect(render, innerRect) {
+        const { padding, margin } = render;
+        //外层容器高度等于内容高度+外边距+内边距
+        render.rect.height = innerRect.height + margin.top + margin.bottom + padding.top + padding.bottom;
+    }
+    /**
+     * 设置块级元素限制尺寸
+     * @param render
+     * @param parentLimitRect
+     */
+    static setBlockElementLimitSize(render, parentLimitRect) {
+        render.rect.x = parentLimitRect.x;
+        render.rect.y = parentLimitRect.y + parentLimitRect.height;
+        render.rect.width = parentLimitRect.maxWidth ?? 0;
+        render.rect.maxWidth = parentLimitRect.maxWidth;
+        if (parentLimitRect.maxHeight) {
+            render.rect.maxHeight = parentLimitRect.maxHeight - parentLimitRect.height;
+        }
+    }
+    /**
+     * 克隆框体
+     * @param rect
+     * @returns
+     */
+    static cloneRect(rect) {
+        const cloneRect = new Rect();
+        cloneRect.x = rect.x;
+        cloneRect.y = rect.y;
+        cloneRect.width = rect.width;
+        cloneRect.height = rect.height;
+        cloneRect.maxHeight = rect.maxHeight;
+        cloneRect.maxWidth = rect.maxWidth;
+        return cloneRect;
+    }
+    /**
+     * 重新限定子元素以及当前高度值,并返回内边框内容高度
+     * @param render
+     * @param resetX 测量段落外框时，内框不需要重置x，因为内框已经存在对齐
+     * @returns
+     */
+    static remeasure(render, resetX = true) {
+        if (render.rect.width === 0) {
+            return -1;
+        }
+        if (render instanceof TableRowRenderObject) {
+            return this.remeasureTableRow(render);
+        }
+        if (render instanceof TableRenderObject) {
+            this.remeasureTableMerge(render);
+        }
+        const innerRect = render.getInnnerRect();
+        for (let i = 0; i < render.length; i++) {
+            const line = render.getChild(i);
+            if (resetX) {
+                line.rect.x = innerRect.x;
+            }
+            line.rect.y = innerRect.height + innerRect.y + line.margin.top;
+            line.rect.maxWidth = innerRect.maxWidth;
+            innerRect.height += line.rect.height + line.margin.top + line.margin.bottom;
+        }
+        render.updateRenderHeight(innerRect);
+        return innerRect.height;
+    }
+    static remeasureTableRow(rowRender, foreceColIndex = -1) {
+        const rowEle = rowRender.element;
+        const rowMinHeight = rowEle.props.minHeight > 19 ? rowEle.props.minHeight : 19;
+        let maxCellheight = rowMinHeight;
+        //限制行最小高度
+        maxCellheight = maxCellheight < 19 ? 19 : maxCellheight;
+        //获取行内非纵向合并单元格的最高单元格高度
+        for (let i = 0; i < rowRender.length; i++) {
+            const cellRender = rowRender.getChild(i);
+            const { vMerge } = cellRender.element.props;
+            if (cellRender.rect.height > maxCellheight && (vMerge !== 'restart' || i === foreceColIndex)) {
+                maxCellheight = cellRender.rect.height;
+            }
+        }
+        //循环设置单元格高度为行内最大单元格高度
+        for (let i = 0; i < rowRender.length; i++) {
+            const cellRender = rowRender.getChild(i);
+            const cellElement = cellRender.element;
+            const { vMerge } = cellElement.props;
+            if ((vMerge !== 'restart' || i === foreceColIndex) || cellRender.rect.height < maxCellheight) {
+                cellRender.rect.height = maxCellheight;
+            }
+            //处理单元格内容纵向居中
+            this.measureCellVAlign(cellRender);
+        }
+        //设置行高
+        rowRender.updateRenderHeight(maxCellheight);
+        return maxCellheight;
+    }
+    /**
+     * 获取表格行绘制元素的内容高度，用于缩放行高度时，获取最小内容高度，缩放的高度不能小于内容最小高度
+     */
+    static getTableRowRenderContentHeight(rowRender) {
+        const rowEle = rowRender.element;
+        let maxCellheight = 19;
+        //限制行最小高度
+        //获取行内非纵向合并单元格的最高单元格高度
+        for (let i = 0; i < rowRender.length; i++) {
+            const cellRender = rowRender.getChild(i);
+            const cellContentHeight = this.getTableCellRenderContentHeight(cellRender);
+            const { vMerge } = cellRender.element.props;
+            if (cellContentHeight > maxCellheight && vMerge !== 'restart') {
+                maxCellheight = cellContentHeight;
+            }
+        }
+        return maxCellheight;
+    }
+    /**
+     * 获取单元格内容高度
+     * 单元格暂不处理上下margin、padding
+     * @param cellRender
+     * @returns
+     */
+    static getTableCellRenderContentHeight(cellRender) {
+        let contentHeight = 0;
+        for (let i = 0; i < cellRender.length; i++) {
+            contentHeight += cellRender.getChild(i).rect.height;
+        }
+        return contentHeight;
+    }
+    /**
+     * 处理单元格内容纵向对齐
+     * @param render
+     */
+    static measureCellVAlign(render) {
+        const tcElement = render.element;
+        const { vAlign } = tcElement.props;
+        if (!vAlign || vAlign === 'top') {
+            return;
+        }
+        let sumHeight = 0;
+        for (let i = 0; i < render.length; i++) {
+            sumHeight += render.getChild(i).rect.height;
+        }
+        let spaceHeight = 0;
+        spaceHeight = vAlign === 'middle' ? Math.floor((render.rect.height - sumHeight) / 2) : vAlign === 'bottom' ? render.rect.height - sumHeight : 0;
+        if (spaceHeight <= 0) {
+            return;
+        }
+        let y = spaceHeight;
+        for (let i = 0; i < render.length; i++) {
+            render.getChild(i).rect.y = y;
+            y += render.getChild(i).rect.height;
+        }
+    }
+    /**
+     * 重新测量合并单元格高度
+     * @param tbRender
+     * @returns
+     */
+    static remeasureTableMerge(tbRender) {
+        //是否需要重新计算,主要解决：之前合并计算的列，可能会被后面合并计算的列所影响，需要再次重新计算测量
+        let needReCalc = false;
+        for (let i = 0; i < tbRender.length; i++) {
+            const row = tbRender.getChild(i);
+            for (let j = 0; j < row.length; j++) {
+                const cellRender = row.getChild(j);
+                const ele = cellRender.element;
+                const { vMerge } = ele.props;
+                if (vMerge === 'restart') {
+                    const eleIndex = ele.getIndex();
+                    const continueRows = this.getContinueVMergeRenderRows(tbRender, i, eleIndex);
+                    if (!continueRows.length) {
+                        //向下不存在合并的单元格，当前合并的单元格是被cut过来的，并且当前单元格高度高于行内高度需要remeasure当前行
+                        if (cellRender.rect.height > row.rect.height) {
+                            this.remeasureTableRow(row, j);
+                            needReCalc = true;
+                        }
+                        continue;
+                    }
+                    const continueCellHeight = continueRows.reduce((prev, curr) => prev + curr.rect.height, 0);
+                    const overflowHeight = cellRender.rect.height - row.rect.height - continueCellHeight;
+                    //溢出的高度加到最后一个合并单元格中
+                    if (overflowHeight > 0) {
+                        const lastRow = continueRows[continueRows.length - 1];
+                        lastRow.rect.height += overflowHeight;
+                        this.resizeCellToFillRow(lastRow);
+                        needReCalc = true;
+                    }
+                    else {
+                        cellRender.rect.height = row.rect.height + continueCellHeight;
+                    }
+                }
+            }
+        }
+        if (needReCalc) {
+            this.remeasureTableMerge(tbRender);
+            return;
+        }
+    }
+    /**
+     * 获取向下纵向合并的行
+     * @param render
+     * @param rowIndex
+     * @param colIndex
+     * @returns
+     */
+    static getContinueVMergeRenderRows(render, rowIndex, colIndex) {
+        const rows = [];
+        for (let i = rowIndex + 1; i < render.length; i++) {
+            const rowRender = render.getChild(i);
+            const rowEle = rowRender.element;
+            const ele = rowEle.getChild(colIndex);
+            const { vMerge } = ele.props;
+            if (vMerge !== 'continue') {
+                break;
+            }
+            rows.push(rowRender);
+        }
+        return rows;
+    }
+    /**
+     * 根据横向当前被合并的单元格
+     * @param tb
+     * @param rowIndex
+     * @param colIndex
+     */
+    static getHorizontalRestartCellIndex(tb, rowIndex, colIndex) {
+        const row = tb.getChild(rowIndex);
+        for (let i = colIndex - 1; i >= 0; i--) {
+            const cell = row.getChild(i);
+            if (cell.props.hMerge === 'restart') {
+                return i;
+            }
+        }
+        throw new Error('未找到主合并单元格');
+    }
+    /**
+     * 根据横向当前被合并的单元格
+     * @param tb
+     * @param rowIndex
+     * @param colIndex
+     */
+    static getVerticalRestartCellIndex(tb, rowIndex, colIndex) {
+        for (let i = rowIndex - 1; i >= 0; i--) {
+            const row = tb.getChild(i);
+            const cell = row.getChild(colIndex);
+            if (cell.props.vMerge === 'restart') {
+                return i;
+            }
+        }
+        throw new Error('未找到横向当前被合并的单元格');
+    }
+    /**
+     * 获取合并单元格主单元格
+     * @param tb
+     * @param rowIndex
+     * @param colIndex
+     * @returns
+     */
+    static getRestartCellPosition(tb, rowIndex, colIndex) {
+        const row = tb.getChild(rowIndex);
+        const cell = row.getChild(colIndex);
+        if (cell.props.hMerge === 'continue') {
+            const restartCellIndex = this.getHorizontalRestartCellIndex(tb, rowIndex, colIndex);
+            return this.getRestartCellPosition(tb, rowIndex, restartCellIndex);
+        }
+        if (cell.props.vMerge === 'continue') {
+            const restartRowIndex = this.getVerticalRestartCellIndex(tb, rowIndex, colIndex);
+            return this.getRestartCellPosition(tb, restartRowIndex, colIndex);
+        }
+        return { rowIndex, colIndex };
+    }
+    /**
+     * 调整单元格高度填满整个行的高度
+     */
+    static resizeCellToFillRow(row) {
+        for (let i = 0; i < row.length; i++) {
+            const cell = row.getChild(i);
+            cell.rect.height = row.rect.height;
+        }
+    }
+    /**
+     * 获取元素的全局索引位置
+     * @param control
+     * @returns
+     */
+    static getControlIndex(control) {
+        const parent = control.parent;
+        if (parent) {
+            const index = control.getIndex();
+            let counter = 1;
+            for (let i = 0; i < index; i++) {
+                const child = parent.getChild(i);
+                counter += child.getSelfLength();
+            }
+            return counter + this.getControlIndex(parent);
+        }
+        else {
+            return 0;
+        }
+    }
+    /**
+     * 根据全局索引位置获取元素
+     * @param control
+     * @param counter
+     * @returns
+     */
+    static getControlByIndex(control, counter) {
+        counter.currIndex++;
+        if (counter.currIndex === counter.index) {
+            return control;
+        }
+        if (control instanceof LeafElement) {
+            return null;
+        }
+        else if (control instanceof BranchElement) {
+            for (let i = 0; i < control.length; i++) {
+                const res = this.getControlByIndex(control.getChild(i), counter);
+                if (res) {
+                    return res;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * 获取同级紧挨前方的兄弟元素
+     * @param element
+     * @returns
+     */
+    static getPrevSiblingElement(element) {
+        const parent = element.parent;
+        if (!parent) {
+            return null;
+        }
+        if (parent) {
+            const index = parent.getChildIndex(element);
+            if (index > 0) {
+                return parent.getChild(index - 1);
+            }
+        }
+        return null;
+    }
+    /**
+     * 获取同级紧挨下方的元素
+     * @param element
+     * @returns
+     */
+    static getNextSiblingElement(element) {
+        const parent = element.parent;
+        if (!parent) {
+            return null;
+        }
+        if (parent) {
+            const index = parent.getChildIndex(element);
+            if (index < parent.length - 1) {
+                return parent.getChild(index + 1);
+            }
+        }
+        return null;
+    }
+    static getNextSiblingTrackElement(element, type, userId) {
+        const nextSiblingEle = this.getNextSiblingElement(element);
+        if (nextSiblingEle instanceof TrackRunElement) {
+            if (nextSiblingEle.type === type && nextSiblingEle.props.userId === userId) {
+                return nextSiblingEle;
+            }
+        }
+        return null;
+    }
+    static getPrevSiblingTrackElement(element, type, userId) {
+        const prevSiblingEle = this.getPrevSiblingElement(element);
+        if (prevSiblingEle instanceof TrackRunElement) {
+            if (prevSiblingEle.type === type && prevSiblingEle.props.userId === userId) {
+                return prevSiblingEle;
+            }
+        }
+        return null;
+    }
+    /**
+     * 根据默认配置创建长文本
+     * @param viewOptions
+     * @returns
+     */
+    static getNewTextGroup(textProps) {
+        const text = new TextGroupElement();
+        textProps.clone(text.props);
+        return text;
+    }
+    static createTextProps(dest, viewOptions) {
+        const textProps = dest ?? new TextProps();
+        textProps.fontSize = viewOptions.defaultFontSize;
+        textProps.fontName = viewOptions.defaultFontName;
+        textProps.color = viewOptions.defaultColor;
+        return textProps;
+    }
+    /**
+     * 获取容器内的最小渲染元素集合
+     * @param parPos
+     * @param array
+     */
+    static getAvailHitLeafRenderObjects(render, parPos) {
+        if (!this.checkAvailHitRender(render)) {
+            return [];
+        }
+        const renderObjectRect = {
+            x: parPos.x + render.rect.x,
+            y: parPos.y + render.rect.y,
+            width: render.rect.width,
+            height: render.rect.height,
+            maxWidth: 0,
+            maxHeight: 0
+        };
+        const array = [];
+        if (render instanceof BranchRenderObject) {
+            for (let i = 0; i < render.length; i++) {
+                const child = render.getChild(i);
+                array.push(...this.getAvailHitLeafRenderObjects(child, { x: renderObjectRect.x, y: renderObjectRect.y }));
+            }
+        }
+        else if (render instanceof LeafRenderObject) {
+            array.push({ render: render, rect: renderObjectRect });
+        }
+        else {
+            throw new Error('未实现');
+        }
+        return array;
+    }
+    /**
+     * 获取容器内的最小渲染元素集合
+     * @param parPos
+     * @param array
+     */
+    static getAvailHitRenderObjects(render, parPos) {
+        if (!this.checkAvailHitRender(render)) {
+            return [];
+        }
+        const renderObjectRect = this.getRenderObjectAbsoluteRect(render, parPos);
+        const array = [];
+        if (render instanceof BranchRenderObject) {
+            for (let i = 0; i < render.length; i++) {
+                const child = render.getChild(i);
+                if (this.checkAvailHitRender(child)) {
+                    array.push({ render: child, rect: this.getRenderObjectAbsoluteRect(child, renderObjectRect) });
+                }
+            }
+        }
+        else if (render instanceof LeafRenderObject) {
+            array.push({ render: render, rect: renderObjectRect });
+        }
+        else {
+            throw new Error('未实现');
+        }
+        return array;
+    }
+    /**
+     * 获取绘制元素的绝对位置框
+     */
+    static getRenderObjectAbsoluteRect(render, parPos) {
+        const renderObjectRect = {
+            x: parPos.x + render.rect.x,
+            y: parPos.y + render.rect.y,
+            width: render.rect.width,
+            height: render.rect.height,
+            maxWidth: 0,
+            maxHeight: 0
+        };
+        return renderObjectRect;
+    }
+    /**
+     * 检查当前绘制元素是否属于有效点击元素
+     */
+    static checkAvailHitRender(render) {
+        if (render.element && render.element.disableClick) {
+            return false;
+        }
+        if (render instanceof TableRowRenderObject) {
+            const rowEle = render.element;
+            if (rowEle.props.headerRow) {
+                return rowEle.paintRenders.indexOf(render) === 0;
+            }
+        }
+        return !render.disableClick;
+    }
+    /**
+     * 验证点击可操作性
+     * 主要限制页眉页脚的编辑模式
+     */
+    static verifyHitable(sourceElement) {
+        if (!sourceElement) {
+            return false;
+        }
+        const parents = ElementUtil.getParentElements(sourceElement);
+        for (let i = parents.length - 1; i >= 0; i--) {
+            const child = parents[i];
+            if (child.disableClick) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * 获取一个点到一个矩形最短的距离
+     * @param rect
+     * @param p
+     * @returns
+     */
+    static getDistanceToRect(rect, p) {
+        const lines = [];
+        lines.push({
+            f: {
+                x: rect.x,
+                y: rect.y
+            },
+            s: {
+                x: rect.x + rect.width,
+                y: rect.y
+            }
+        }, {
+            f: {
+                x: rect.x,
+                y: rect.y
+            },
+            s: {
+                x: rect.x,
+                y: rect.y + rect.height
+            }
+        }, {
+            f: {
+                x: rect.x,
+                y: rect.y + rect.height
+            },
+            s: {
+                x: rect.x + rect.width,
+                y: rect.y + rect.height
+            }
+        }, {
+            f: {
+                x: rect.x + rect.width,
+                y: rect.y
+            },
+            s: {
+                x: rect.x + rect.width,
+                y: rect.y + rect.height
+            }
+        });
+        const distances = lines.map(item => this.minDistance(item.f, item.s, p));
+        return Math.min(...distances);
+    }
+    static minDistance(A, B, E) {
+        const AB = { x: B.x - A.x, y: B.y - A.y };
+        const BE = { x: E.x - B.x, y: E.y - B.y };
+        const AE = { x: E.x - A.x, y: E.y - A.y };
+        const AB_BE = (AB.x * BE.x + AB.y * BE.y);
+        const AB_AE = (AB.x * AE.x + AB.y * AE.y);
+        let reqAns = 0;
+        if (AB_BE > 0) {
+            const y = E.y - B.y;
+            const x = E.x - B.x;
+            reqAns = Math.sqrt(x * x + y * y);
+        }
+        else if (AB_AE < 0) {
+            const y = E.y - A.y;
+            const x = E.x - A.x;
+            reqAns = Math.sqrt(x * x + y * y);
+        }
+        else {
+            const x1 = AB.x;
+            const y1 = AB.y;
+            const x2 = AE.x;
+            const y2 = AE.y;
+            const mod = Math.sqrt(x1 * x1 + y1 * y1);
+            reqAns = Math.abs(x1 * y2 - y1 * x2) / mod;
+        }
+        return reqAns;
+    }
+    /**
+     * 获取父级层级渲染对象
+     * @param render
+     * @returns
+     */
+    static getParentRenders(render) {
+        if (render) {
+            return [render, ...this.getParentRenders(render.parent)];
+        }
+        else {
+            return [];
+        }
+    }
+    static getRenderMapElements(render) {
+        const renders = this.getParentRenders(render);
+        return renders.map(render => render.element).filter(ele => ele);
+    }
+    static getParentRender(child, parentType) {
+        if (!child) {
+            return null;
+        }
+        if (child instanceof parentType) {
+            return child;
+        }
+        else {
+            return this.getParentRender(child.parent, parentType);
+        }
+    }
+    static getParentRenderByPredicate(child, predicate) {
+        if (!child) {
+            return null;
+        }
+        if (predicate(child)) {
+            return child;
+        }
+        else {
+            return this.getParentRenderByPredicate(child.parent, predicate);
+        }
+    }
+    /**
+     * 获取父级层级元素对象
+     * @param element
+     * @returns
+     */
+    static getParentElements(element) {
+        if (element) {
+            return [element, ...this.getParentElements(element.parent)];
+        }
+        else {
+            return [];
+        }
+    }
+    /**
+     * 获取最后一个子元素
+     * @param element
+     * @returns
+     */
+    static getLastLeafElement(element, predicate = null) {
+        if (element instanceof LeafElement && (!predicate || predicate(element))) {
+            return element;
+        }
+        else if (element instanceof BranchElement) {
+            for (let i = element.length - 1; i >= 0; i--) {
+                const res = this.getLastLeafElement(element.getChild(i), predicate);
+                if (res) {
+                    return res;
+                }
+            }
+            return null;
+        }
+        return null;
+    }
+    /**
+     * 获取第一个子元素
+     * @param element
+     * @returns
+     */
+    static getFirstLeafElement(element) {
+        if (element instanceof LeafElement) {
+            return element;
+        }
+        else if (element instanceof BranchElement) {
+            for (let i = 0; i < element.length; i++) {
+                const res = this.getFirstLeafElement(element.getChild(i));
+                if (res) {
+                    return res;
+                }
+            }
+            return null;
+        }
+        return null;
+    }
+    /**
+     * 校验两个元素是否在同一个段落中
+     * @param element1
+     * @param element2
+     */
+    static isInSameParagraph(element1, element2) {
+        const par1 = this.getParentByType(element1, ParagraphElement);
+        const par2 = this.getParentByType(element2, ParagraphElement);
+        return par1 === par2;
+    }
+    static getBorderCursor(borderType) {
+        switch (borderType) {
+            case 'none':
+                return 'text';
+            case 'top':
+                return 'row-resize';
+            case 'left':
+                return 'col-resize';
+            case 'right':
+                return 'col-resize';
+            case 'bottom':
+                return 'row-resize';
+            case 'left-middle':
+            case 'right-middle':
+                return 'w-resize';
+            case 'top-middle':
+            case 'bottom-middle':
+                return 's-resize';
+            case 'left-top':
+            case 'right-bottom':
+                return 'se-resize';
+            case 'right-top':
+            case 'left-bottom':
+                return 'ne-resize';
+            default:
+                return 'text';
+        }
+    }
+    static getParentByType(child, parentType) {
+        if (!child) {
+            return null;
+        }
+        if (child instanceof parentType) {
+            return child;
+        }
+        else {
+            return this.getParentByType(child.parent, parentType);
+        }
+    }
+    static getParent(child, predicate) {
+        if (!child) {
+            return null;
+        }
+        if (predicate(child)) {
+            return child;
+        }
+        else {
+            return this.getParent(child.parent, predicate);
+        }
+    }
+    /**
+     * 修正段落内容
+     * @returns
+     */
+    static fixParagraphContent(control) {
+        //如果最后一个元素不是段落符号，则补足
+        if (!(control.getChild(control.length - 1) instanceof PSymbolElement)) {
+            control.addChild(new PSymbolElement());
+        }
+        const items = [];
+        for (let i = 0; i < control.length - 1; i++) {
+            const child = control.getChild(i);
+            if (child instanceof PSymbolElement) {
+                items.push(child);
+            }
+        }
+        items.forEach(item => {
+            control.removeChild(item);
+        });
+    }
+    /**
+     * 修正块级容器内容
+     * @param control
+     */
+    static fixBlockContainer(control) {
+        if (control.length === 0) {
+            if (control instanceof TableCellElement && (control.props.vMerge === 'continue' || control.props.hMerge === 'continue')) {
+                return;
+            }
+            if (control.noFillEmpty) {
+                return;
+            }
+            control.addChild(new ParagraphElement());
+        }
+    }
+    /**
+     * 获取绘制元素相对于整个画布的绝对位置
+     * 整个画布绘制的时候不一定从x=0,y=0时绘制的，下拉滚动时，上面从负y坐标开始绘制
+     * 如果计算某个元素相对画布的左上角的绝对坐标位置，需要childPos的y值减去translateY
+     * @param render
+     * @param refPos 参照位置
+     * @returns
+     */
+    static getRenderAbsolutePaintPos(render, refPos = null) {
+        refPos = refPos ?? { x: 0, y: 0 };
+        const currPos = { x: render.rect.x + refPos.x, y: render.rect.y + refPos.y };
+        if (!render.parent) {
+            return currPos;
+        }
+        return this.getRenderAbsolutePaintPos(render.parent, currPos);
+    }
+    static getRenderAbsolutePaintRect(render, childPos = null) {
+        const pos = this.getRenderAbsolutePaintPos(render, childPos);
+        return { ...pos, width: render.rect.width, height: render.rect.height, maxWidth: 0, maxHeight: 0 };
+    }
+    /**
+     * 获取选中区域的开始区域
+     * @param range
+     * @returns
+     */
+    static getFirstSelectedRange(range) {
+        if (range.selectedChildren.length === 0 || range.target instanceof TextGroupElement) {
+            return range;
+        }
+        else {
+            return this.getFirstSelectedRange(range.selectedChildren[0]);
+        }
+    }
+    /**
+     * 获取选中区域的开始区域
+     * @param range \
+     * @returns
+     */
+    static getLastSelectedRange(range) {
+        if (range.selectedChildren.length === 0 || range.target instanceof TextGroupElement) {
+            return range;
+        }
+        else {
+            return this.getLastSelectedRange(range.selectedChildren[range.selectedChildren.length - 1]);
+        }
+    }
+    /**
+     * 克隆选区内容
+     * @param range
+     * @param isDelete
+     * @returns
+     */
+    static cloneRange(range, isDelete, cloneMode = 'clone') {
+        const { target, isFullSelected, startOffset, endOffset, selectedChildren } = range;
+        if (isFullSelected) {
+            //修饰元素不能复制 审阅标记、数据元NullText
+            if (cloneMode === 'copy' && target.isDecorate) {
+                return null;
+            }
+            const clone = cloneMode === 'source' ? target : target.clone(true);
+            if (isDelete) {
+                target.remove();
+            }
+            return clone;
+        }
+        else {
+            if (target instanceof LeafElement) {
+                if (target instanceof TextGroupElement && startOffset !== endOffset) {
+                    if (isDelete) {
+                        const copyTarget = target.spliceText(startOffset, endOffset, true);
+                        if (target.text.length === 0) {
+                            target.remove();
+                        }
+                        return copyTarget;
+                    }
+                    else {
+                        const copyTarget = target.spliceText(startOffset, endOffset, false);
+                        return copyTarget;
+                    }
+                }
+                return null;
+            }
+            else if (target instanceof BranchElement) {
+                const array = [];
+                for (let i = 0; i < selectedChildren.length; i++) {
+                    const copyChild = this.cloneRange(selectedChildren[i], isDelete, cloneMode);
+                    if (copyChild) {
+                        array.push(copyChild);
+                    }
+                }
+                if (!array.length) {
+                    return null;
+                }
+                else {
+                    const copyTarget = target.clone(false);
+                    array.forEach(item => {
+                        copyTarget.addChild(item);
+                    });
+                    return copyTarget;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * 获取所有的子级元素
+     * @param branchEle
+     * @returns
+     */
+    static getChildrenElements(branchEle) {
+        const array = [];
+        for (let i = 0; i < branchEle.length; i++) {
+            array.push(branchEle.getChild(i));
+        }
+        return array;
+    }
+    /**
+     * 递归向前寻找最近的元素
+     * @param currElement
+     * @param inPara  是否在同一段落中寻找
+     * @param forCursor 查找结果是否用于光标定位
+     * @returns
+     */
+    static getRecursionPrevSiblingElement(currElement, inPara = false, forCursor = false) {
+        const parent = currElement?.parent;
+        //删除留痕块的measureRender在不显示留痕模式下，不生成render
+        if (!currElement || !parent || (!currElement.measureRender && !(currElement instanceof TrackRunElement))) {
+            return null;
+        }
+        //如果当前数据元不可编辑，则直接跳过
+        if (parent instanceof DataElementInlineGroup && !parent.props.editable) {
+            return this.getRecursionPrevSiblingElement(parent, inPara, forCursor);
+        }
+        if (forCursor && parent.disableClick) {
+            return this.getRecursionPrevSiblingElement(parent, inPara, forCursor);
+        }
+        const index = parent.getChildIndex(currElement);
+        if (!index) {
+            if (inPara && parent.type === 'p') {
+                return null;
+            }
+            return this.getRecursionPrevSiblingElement(parent, inPara, forCursor);
+        }
+        else {
+            let prevElement = null;
+            for (let i = index - 1; i >= 0; i--) {
+                prevElement = parent.getChild(i);
+                if (prevElement && !prevElement.disableClick) {
+                    break;
+                }
+            }
+            if (!prevElement || prevElement.disableClick) {
+                return this.getRecursionPrevSiblingElement(parent, inPara, forCursor);
+            }
+            const lastLeafElement = ElementUtil.getLastLeafElement(prevElement);
+            //用于光标定位
+            if (forCursor && lastLeafElement && lastLeafElement.disableClick) {
+                return this.getRecursionPrevSiblingElement(lastLeafElement, inPara, forCursor);
+            }
+            if (lastLeafElement) {
+                return lastLeafElement;
+            }
+            else {
+                return this.getRecursionPrevSiblingElement(prevElement.parent, inPara, forCursor);
+            }
+        }
+    }
+    /**
+     * 循环向前寻找可定位的数据元
+     * @param currElement
+     */
+    static getPrevDataElement(ctx, currElement) {
+        const dataEle = ctx.getCurrentCtx(currElement).getControlInstanceList().filter(item => item instanceof DataElementInlineGroup);
+        const index = dataEle.indexOf(currElement);
+        if (index > 0) {
+            for (let i = index - 1; i >= 0; i--) {
+                if (!dataEle[i].disableClick && dataEle[i].props.editable) {
+                    return dataEle[i];
+                }
+            }
+        }
+        return null;
+    }
+    // /**
+    // * 递归向前寻找最近的可点击元素
+    // */
+    // static getRecursionPrevSiblingElementForHit(currElement: Element | null): LeafElement | null {
+    //     let ele: LeafElement | null = null;
+    //     do {
+    //         ele = this.getRecursionPrevSiblingElement(currElement);
+    //     } while (ele && ele.disableClick)
+    //     return ele;
+    // }
+    // /**
+    // * 在同一段落中，递归向前寻找最近的元素
+    // */
+    // static getRecursionPrevSiblingElementInPara(currElement: Element | null): LeafElement | null {
+    //     const parent = currElement?.parent;
+    //     if (!currElement || !parent) {
+    //         return null;
+    //     }
+    //     const index = parent.getChildIndex(currElement);
+    //     if (!index) {
+    //         if (parent.type === 'p') {
+    //             return null;
+    //         }
+    //         return this.getRecursionPrevSiblingElementInPara(parent);
+    //     } else {
+    //         const prevElement = parent.getChild(index - 1);
+    //         const lastLeafElement = ElementUtil.getLastLeafElement(prevElement);
+    //         if (lastLeafElement) {
+    //             return lastLeafElement;
+    //         } else {
+    //             return this.getRecursionPrevSiblingElementInPara(prevElement?.parent);
+    //         }
+    //     }
+    // }
+    // /**
+    // * 在同一段落中，递归向前寻找最近的可点击元素
+    // */
+    // static getRecursionPrevSiblingElementInParaForHit(currElement: Element | null): LeafElement | null {
+    //     let ele: LeafElement | null = null;
+    //     do {
+    //         ele = this.getRecursionPrevSiblingElementInPara(currElement);
+    //     } while (ele && ele.disableClick)
+    //     return ele;
+    // }
+    /**
+     * 递归向后寻找最近的元素
+     */
+    static getRecursionNextSiblingElement(currElement, inPara = false, forCursor = false) {
+        const parent = currElement?.parent;
+        if (!currElement || !parent || !currElement.measureRender) {
+            return null;
+        }
+        //如果当前数据元不可编辑，则直接跳过
+        if (parent instanceof DataElementInlineGroup && !parent.props.editable) {
+            return this.getRecursionNextSiblingElement(parent, inPara, forCursor);
+        }
+        if (forCursor && parent.disableClick) {
+            return this.getRecursionNextSiblingElement(parent, inPara, forCursor);
+        }
+        const index = parent.getChildIndex(currElement);
+        if (index === parent.length - 1) {
+            if (inPara && parent.type === 'p') {
+                return null;
+            }
+            return this.getRecursionNextSiblingElement(parent, inPara, forCursor);
+        }
+        else {
+            let nextElement = null;
+            for (let i = index + 1; i < parent.length; i++) {
+                nextElement = parent.getChild(i);
+                if (nextElement && !nextElement.disableClick) {
+                    break;
+                }
+            }
+            if (!nextElement || nextElement.disableClick) {
+                return this.getRecursionNextSiblingElement(parent, inPara, forCursor);
+            }
+            const lastLeafElement = ElementUtil.getFirstLeafElement(nextElement);
+            //用于光标定位
+            if (forCursor && lastLeafElement && lastLeafElement.disableClick) {
+                return this.getRecursionNextSiblingElement(lastLeafElement, inPara, forCursor);
+            }
+            if (lastLeafElement) {
+                return lastLeafElement;
+            }
+            else {
+                return this.getRecursionNextSiblingElement(nextElement.parent, inPara, forCursor);
+            }
+        }
+    }
+    // /**
+    // * 在同一段落中，递归向后寻找最近的元素
+    // */
+    // static getRecursionNextSiblingElementInPara(currElement: Element | null): LeafElement | null {
+    //     const parent = currElement?.parent;
+    //     if (!currElement || !parent) {
+    //         return null;
+    //     }
+    //     const index = parent.getChildIndex(currElement);
+    //     if (index === parent.length - 1) {
+    //         if (parent.type === 'p') {
+    //             return null;
+    //         }
+    //         return this.getRecursionNextSiblingElementInPara(parent);
+    //     } else {
+    //         const nextElement = parent.getChild(index + 1);
+    //         const lastLeafElement = ElementUtil.getFirstLeafElement(nextElement);
+    //         if (lastLeafElement) {
+    //             return lastLeafElement;
+    //         } else {
+    //             return this.getRecursionNextSiblingElementInPara(nextElement.parent);
+    //         }
+    //     }
+    // }
+    // /**
+    // * 在同一段落中，递归向后寻找最近的可点击元素
+    // */
+    // static getRecursionNextSiblingElementInParaForHit(currElement: Element | null): LeafElement | null {
+    //     let ele: LeafElement | null = null;
+    //     do {
+    //         ele = this.getRecursionNextSiblingElementInPara(currElement);
+    //     } while (ele && ele.disableClick)
+    //     return ele;
+    // }
+    // /**
+    // * 在同一段落中，递归向后寻找最近的可点击元素
+    // */
+    // static getRecursionNextSiblingElementForHit(currElement: Element | null): LeafElement | null {
+    //     let ele: LeafElement | null = null;
+    //     do {
+    //         ele = this.getRecursionNextSiblingElement(currElement);
+    //     } while (ele && ele.disableClick)
+    //     return ele;
+    // }
+    /**
+     * 获取行内最大渲染单元格高度，主要处理纵向合并单元格问题
+     * @param row
+     * @returns
+     */
+    static getRowMaxCellHeight(row) {
+        let maxHeight = 0;
+        for (let i = 0; i < row.length; i++) {
+            if (row.getChild(i).rect.height > maxHeight) {
+                maxHeight = row.getChild(i).rect.height;
+            }
+        }
+        return maxHeight;
+    }
+    /**
+     * 校验是否为空内容
+     * @param ele
+     */
+    static checkEmptyContent(ele) {
+        if (ele.length === 1) {
+            const firstRender = ele.getChild(0);
+            if (firstRender instanceof ParagraphRenderObject) {
+                if ((firstRender.element).length === 1) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * 测量行内编组元素
+     * @param render
+     */
+    static remeasureInlineGroupRender(render) {
+        let x = 0;
+        let maxHeight = 0;
+        for (let i = 0; i < render.length; i++) {
+            const item = render.getChild(i);
+            item.rect.x = x;
+            if (item.rect.height > maxHeight) {
+                maxHeight = item.rect.height;
+            }
+            x += item.rect.width;
+        }
+        for (let i = 0; i < render.length; i++) {
+            const item = render.getChild(i);
+            item.rect.y = maxHeight - item.rect.height;
+        }
+        render.rect.width = x;
+        render.rect.height = maxHeight;
+    }
+    static getParaLinePos(childRender, childRenderPos) {
+        const parent = childRender.parent;
+        const rect = ElementUtil.cloneRect(parent.rect);
+        rect.x = childRenderPos.x - childRender.rect.x;
+        rect.y = childRenderPos.y - childRender.rect.y;
+        if (parent instanceof ParagraphLineRectRenderObject) {
+            return rect;
+        }
+        else {
+            return this.getParaLinePos(parent, rect);
+        }
+    }
+    static getParentRenderPos(parentRender, childRender, childRenderPos) {
+        const parent = childRender.parent;
+        const rect = ElementUtil.cloneRect(parent.rect);
+        rect.x = childRenderPos.x - childRender.rect.x;
+        rect.y = childRenderPos.y - childRender.rect.y;
+        if (parent === parentRender) {
+            return rect;
+        }
+        else {
+            return this.getParentRenderPos(parentRender, parent, rect);
+        }
+    }
+    /**
+     * 获取绘制元素所在的区域
+     */
+    static getRenderObjectRegion(render) {
+        if (!render) {
+            return undefined;
+        }
+        if (render.element) {
+            return this.getElementRegion(render.element);
+        }
+        return this.getRenderObjectRegion(render.parent);
+    }
+    /**
+     * 获取文档元素所在的区域
+     * @param element
+     * @returns
+     */
+    static getElementRegion(element) {
+        const regionTarget = this.getElementRegionTarget(element);
+        return regionTarget?.type;
+    }
+    static getElementRegionTarget(element) {
+        if (!element) {
+            return null;
+        }
+        if (element instanceof DocumentBodyElement) {
+            return { type: 'body', target: element };
+        }
+        if (element instanceof DocumentFooterElement) {
+            return { type: 'footer', target: element };
+        }
+        if (element instanceof DocumentHeaderElement) {
+            return { type: 'header', target: element };
+        }
+        if (element instanceof CommsContainerElement) {
+            return { type: 'review', target: element };
+        }
+        return this.getElementRegionTarget(element.parent);
+    }
+    /**
+     * 根据坐标系统偏移位获取所在的文本偏移位置
+     * @param textRender
+     * @param x
+     * @returns
+     */
+    static getTextRenderOffset(textRender, x) {
+        const ele = textRender.element;
+        const docRender = ElementUtil.getParentRender(textRender, DocumentRenderObject);
+        if (!docRender) {
+            throw new Error('docRender is null');
+        }
+        const elePaintRenders = ele.paintRenders.filter(item => ElementUtil.getParentRender(item, DocumentRenderObject) === docRender);
+        let count = 0;
+        for (let i = 0; i < elePaintRenders.length; i++) {
+            const render = elePaintRenders[i];
+            if (render !== textRender) {
+                count += render.textMeasures.length;
+            }
+            else {
+                let horX = 0;
+                for (let j = 0; j < render.textMeasures.length; j++) {
+                    if (horX + render.textMeasures[j].actualSize >= x) {
+                        if (horX + Math.floor(render.textMeasures[j].actualSize / 2) > x) {
+                            if (j === 0 && i > 0) {
+                                j += 0.5;
+                            }
+                        }
+                        else {
+                            j += 1;
+                        }
+                        return j + count;
+                    }
+                    horX += render.textMeasures[j].actualSize;
+                }
+                return count + render.textMeasures.length;
+            }
+        }
+        throw new Error('未找到当前文本元素的光标偏移量');
+    }
+    static getHitRenderOffset(render, x) {
+        if (render instanceof TextGroupRenderObject) {
+            return this.getTextRenderOffset(render, x);
+        }
+        else {
+            if (render.element && render.element.type === 'psym') {
+                return 0;
+            }
+            return (render.rect.width / 2) >= x ? 0 : 1;
+        }
+    }
+    static getTextRenderHorX(currRender, startOffset, endOffset) {
+        const textEle = currRender.element;
+        let endX = 0;
+        let startX = 0;
+        let count = 0;
+        for (let i = 0; i < textEle.paintRenders.length; i++) {
+            const paintRender = textEle.paintRenders[i];
+            if (paintRender !== currRender) {
+                count += paintRender.textMeasures.length;
+            }
+            else {
+                if (count + paintRender.textMeasures.length < startOffset) {
+                    continue;
+                }
+                if (count > endOffset) {
+                    continue;
+                }
+                for (let j = 0; j < paintRender.textMeasures.length; j++) {
+                    if (endOffset === count + j) {
+                        break;
+                    }
+                    if (count + j === startOffset) {
+                        startX = endX;
+                    }
+                    endX += paintRender.textMeasures[j].actualSize;
+                }
+            }
+        }
+        return { startX, endX };
+    }
+    /**
+     * 获取一个元素结尾偏移量
+     * 文本以字符长度进行确定
+     * @param ele
+     * @returns
+     */
+    static getElementEndOffset(ele) {
+        if (ele instanceof TextGroupElement) {
+            return ele.textMeasures.length;
+        }
+        return 1;
+    }
+    /**
+     * 判断当前偏移量是否是最终偏移量
+     * @param ele
+     * @param offset
+     */
+    static isElementEndOffset(ele, offset) {
+        return this.getElementEndOffset(ele) === offset;
+    }
+    /**
+     * 获取直接子节点的所有渲染元素
+     * @param ele
+     * @returns
+     */
+    static getChildRenders(ele) {
+        const items = [];
+        for (let i = 0; i < ele.length; i++) {
+            items.push(ele.getChild(i));
+        }
+        return items;
+    }
+    /**
+     * 获取当前单元格内所有的段落行
+     * @param cell
+     * @returns
+     */
+    static getCellParaLines(cell) {
+        const items = [];
+        for (let i = 0; i < cell.length; i++) {
+            const para = cell.getChild(i);
+            for (let j = 0; j < para.length; j++) {
+                items.push(para.getChild(j));
+            }
+        }
+        return items;
+    }
+    static getRandomColor(seed) {
+        let letters = '0123456789ABCDEF';
+        let color = '#';
+        for (let i = 0; i < 6; i++) {
+            color += letters[Math.floor(this.getSeedRandom(seed) * 16)];
+        }
+        return color;
+    }
+    static getSeedRandom(seed) {
+        return Number("0." + Math.sin(seed * Math.random()).toString().substr(6));
+    }
+    static findChildRender(render, predicate) {
+        for (let i = 0; i < render.length; i++) {
+            if (predicate(render.getChild(i))) {
+                return render.getChild(i);
+            }
+        }
+        return null;
+    }
+    static getDataElement(ele) {
+        return this.getParent(ele, item => item instanceof DataElementInlineGroup);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"element-util.js","sourceRoot":"lib/","sources":["framework/element-util.ts"],"names":[],"mappings":"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"}