@hailin-zheng/editor-core 1.0.1 → 1.0.3

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=element-util.js.map