@hailin-zheng/editor-core 1.0.7 → 1.0.10

package/{lib/framework/element-reader.js → src/med_editor/framework/element-reader.ts}

@@ -1,4 +1,5 @@
-import { BranchElement, PageOptions } from "./element-define";
+import { EditorContext } from "./document-context";
+import { BranchElement, ElementFactory, Element, ViewOptions, PageOptions } from "./element-define";
 import { CheckBoxFactory } from "./impl/checkbox/checkbox-impl";
 import { CommentContentFactory } from "./impl/comments/comment-content-impl";
 import { CommentFactory } from "./impl/comments/comment-element-impl";
@@ -22,27 +23,27 @@ import { TableFactory } from "./impl/table/table-impl";
 import { TableRowFactory } from "./impl/table/table-row-impl";
 import { RunElementFactory } from "./impl/text/track-run-impl";
 import { TextGroupFactory } from "./impl/text/text-impl";
+import { RenderContenxtType } from "./render-context";
 import { INotifyPropertyChanged, TrackRunProps } from "./element-props";
-import { DataElementGroupFactory } from "@/med_editor/framework/impl/data-element/data-element-group-impl";
+import { DataElementGroupFactory } from "./impl/data-element/data-element-group-impl";
 import { DocumentBodyPartFactory } from "./impl/document/doc-body-part-impl";
 import { DataElementBarcodeFactory } from "./impl/data-element/data-element-barcode";
+
 export class ElementReader {
-    docCtx;
-    viewOptions;
-    renderCtx;
-    constructor(docCtx, viewOptions, renderCtx) {
-        this.docCtx = docCtx;
-        this.viewOptions = viewOptions;
-        this.renderCtx = renderCtx;
+    constructor(private docCtx: EditorContext, private viewOptions: ViewOptions, private renderCtx: RenderContenxtType) {
         this.initFactory();
     }
-    factories = [];
-    addFactory(c) {
+
+    factories: Array<ElementFactory> = [];
+
+    addFactory<U extends null | object, T extends ElementFactory<U>>(c: new () => T): void {
         const instance = new c();
         instance.options = this.viewOptions;
-        this.factories.push(instance);
+        this.factories.push(instance as ElementFactory);
     }
-    initFactory() {
+
+
+    private initFactory(): void {
         this.addFactory(DocumentFactory);
         this.addFactory(DocumentHeaderFactory);
         this.addFactory(DocumentBodyFactory);
@@ -61,7 +62,7 @@ export class ElementReader {
         this.addFactory(DataElementCheckFactory);
         this.addFactory(DataElementBarcodeFactory);
         this.addFactory(BreakFactory);
-        this.addFactory(CommentsFactory);
+        this.addFactory(CommentsFactory)
         this.addFactory(CommentContentFactory);
         this.addFactory(CommentFactory);
         this.addFactory(DataElementImgFactory);
@@ -69,35 +70,38 @@ export class ElementReader {
         this.addFactory(RunElementFactory);
         this.addFactory(DataElementGroupFactory);
         this.addFactory(DocumentBodyPartFactory);
-        this.registerReadFunc('ins-run', (data) => {
+        this.registerReadFunc<TrackRunProps>('ins-run', (data) => {
             const props = new TrackRunProps(data.type);
             props.userId = data.userId;
             props.userName = data.userName;
             props.date = data.date;
             return props;
-        });
-        this.registerReadFunc('del-run', (data) => {
+        })
+        this.registerReadFunc<TrackRunProps>('del-run', (data) => {
             const props = new TrackRunProps(data.type);
             props.userId = data.userId;
             props.userName = data.userName;
             props.date = data.date;
             return props;
-        });
+        })
     }
-    read(data) {
-        const document = data instanceof DocumentElement ? data.clone() : this.readElement(data);
+
+    read(data: any | DocumentElement): void {
+        const document = data instanceof DocumentElement ? data.clone() : this.readElement(data) as DocumentElement;
         this.setDocument(document);
     }
-    setDocument(document) {
+
+
+    setDocument(document: DocumentElement): void {
         // if (this.docCtx.document) {
         //     this.docCtx.document.destroy();
         // }
         // this.document?.clearItems();
         // document.docProps.clone(this.document.docProps);
-        document.bodyElement = document.find((item) => item instanceof DocumentBodyElement);
-        document.headerElement = document.find((item) => item instanceof DocumentHeaderElement);
-        document.footerElement = document.find((item) => item instanceof DocumentFooterElement);
-        document.commentsContainerElement = document.find((item) => item instanceof CommsContainerElement);
+        document.bodyElement = document.find((item) => item instanceof DocumentBodyElement) as DocumentBodyElement;
+        document.headerElement = document.find((item) => item instanceof DocumentHeaderElement) as DocumentHeaderElement;
+        document.footerElement = document.find((item) => item instanceof DocumentFooterElement) as DocumentFooterElement;
+        document.commentsContainerElement = document.find((item) => item instanceof CommsContainerElement) as CommsContainerElement;
         if (!document.commentsContainerElement) {
             document.commentsContainerElement = new CommsContainerElement();
         }
@@ -113,8 +117,10 @@ export class ElementReader {
         this.viewOptions.docPageSettings = new PageOptions(width, height, document.props.orient);
         //this.viewOptions.viewSettings.width = this.viewOptions.docPageSettings.width + 10;
     }
-    readElement(data) {
-        const type = data.type;
+
+
+    readElement(data: any): Element {
+        const type = data.type as string;
         for (const factory of this.factories) {
             if (factory.match(type)) {
                 const element = factory.createElement(data, this.renderCtx);
@@ -130,11 +136,14 @@ export class ElementReader {
         }
         throw new Error('未知的元素类型:' + type);
     }
-    propsReadFuncs = new Map();
-    registerReadFunc(propName, func) {
+
+    propsReadFuncs: Map<string, (data: any) => any> = new Map();
+
+    registerReadFunc<T>(propName: string, func: (data: T) => T): void {
         this.propsReadFuncs.set(propName, func);
     }
-    readExtendsProps(data, element) {
+
+    readExtendsProps(data: any, element: Element): void {
         if (data.extendsProps && data.extendsProps.length) {
             for (const prop of data.extendsProps) {
                 const func = this.propsReadFuncs.get(prop.name);
@@ -148,4 +157,3 @@ export class ElementReader {
         }
     }
 }
-//# sourceMappingURL=element-reader.js.map

package/{lib/framework/element-render-cut.js → src/med_editor/framework/element-render-cut.ts}

@@ -1,22 +1,28 @@
 import { ElementUtil } from "./element-util";
-import { MuiltBlockLineRenderObject } from "./render-define";
-import { TableRowRenderObject } from "./impl/table/table-row-impl";
-import { TableRenderObject } from "./impl/table/table-impl";
+import { DocumentBodyRenderObject } from "./impl/document/doc-body-impl";
+import { DocumentHeaderRenderObject } from "./impl/document/doc-header-impl";
+import { DocumentElement, DocumentRenderObject } from "./impl/document/doc-impl";
+import { RenderContenxtType } from "./render-context";
+import { BlockContentRenderObject, BlockLineRectRenderObject, MuiltBlockLineRenderObject, RenderObject } from "./render-define";
+import { Rect, ViewOptions } from "./element-define";
+import { TableRowElement, TableRowRenderObject } from "./impl/table/table-row-impl";
+import { DocumentFooterRenderObject } from "./impl/document/doc-footer-impl";
+import { TableCellElement, TableCellRenderObject } from "./impl/table/table-cell-impl";
+import { TableElement, TableRenderObject } from "./impl/table/table-impl";
+import { CommsContainerRenderObject } from "./impl/comments/comments-container-impl";
+import { ParagraphElement } from "./impl/paragraph/p-impl";
+
 export class ElementRenderCut {
-    options;
-    renderContext;
-    constructor(options, renderContext) {
-        this.options = options;
-        this.renderContext = renderContext;
-    }
-    cutPage(documentRender, documentElement) {
+    constructor(private options: ViewOptions, private renderContext: RenderContenxtType) { }
+
+    cutPage(documentRender: DocumentRenderObject, documentElement: DocumentElement): Array<DocumentRenderObject> {
         if (this.options.fullPageView) {
             return this.getFullViewDocRender(documentRender, documentElement);
         }
-        const headerRender = documentRender.getChild(0);
-        const bodyRender = documentRender.getChild(1).clone();
-        const footerRender = documentRender.getChild(2);
-        const commentsRender = documentRender.getChild(3);
+        const headerRender = documentRender.getChild(0) as DocumentHeaderRenderObject;
+        const bodyRender = documentRender.getChild(1).clone() as DocumentBodyRenderObject;
+        const footerRender = documentRender.getChild(2) as DocumentFooterRenderObject;
+        const commentsRender = documentRender.getChild(3) as CommsContainerRenderObject;
         const { headerLine, footerLine } = documentRender;
         let bodyMarginTop = headerLine + headerRender.rect.height + 6;
         let bodyMarginBottom = footerLine + footerRender.rect.height;
@@ -26,16 +32,18 @@ export class ElementRenderCut {
         documentRender.padding.top = bodyMarginTop;
         documentRender.padding.bottom = bodyMarginBottom;
         const bodyLimitRect = documentRender.getInnnerRect();
-        const bodyArray = [];
+        const bodyArray: Array<DocumentBodyRenderObject> = [];
         let { emptyBody: pageBodyRender, innerRect: bodyInnerLimitRect } = this.createEmptyBodyRender(bodyRender, bodyLimitRect);
         bodyArray.push(pageBodyRender);
+
         const createBodyHolder = () => {
             const { emptyBody, innerRect } = this.createEmptyBodyRender(bodyRender, bodyLimitRect);
             pageBodyRender = emptyBody;
             bodyInnerLimitRect = innerRect;
             bodyArray.push(pageBodyRender);
         };
-        const appendToBody = (item) => {
+
+        const appendToBody = (item: BlockContentRenderObject) => {
             item.rect.y = bodyInnerLimitRect.height + item.margin.top;
             pageBodyRender.addChild(item);
             bodyInnerLimitRect.height += item.rect.height + item.margin.top + item.margin.bottom;
@@ -46,8 +54,10 @@ export class ElementRenderCut {
                 createBodyHolder();
             }
         };
+
+
         let i = 0;
-        let cloneBlockContentRender = bodyRender.getChild(i);
+        let cloneBlockContentRender: null | BlockContentRenderObject = bodyRender.getChild(i) as BlockContentRenderObject;
         while (cloneBlockContentRender) {
             if (bodyInnerLimitRect.maxHeight - bodyInnerLimitRect.height - cloneBlockContentRender.rect.height - cloneBlockContentRender.margin.bottom - cloneBlockContentRender.margin.top < 0) {
                 //限制的外框尺寸
@@ -60,19 +70,18 @@ export class ElementRenderCut {
                     appendToBody(cutRenderObject);
                 }
                 createBodyHolder();
-            }
-            else {
+            } else {
                 appendToBody(cloneBlockContentRender);
                 if (++i < bodyRender.length) {
-                    cloneBlockContentRender = bodyRender.getChild(i);
-                }
-                else {
+                    cloneBlockContentRender = bodyRender.getChild(i) as BlockContentRenderObject;
+                } else {
                     cloneBlockContentRender = null;
                 }
             }
         }
-        const docPages = [];
-        let pageY = this.options.docSpace;
+
+        const docPages: Array<DocumentRenderObject> = [];
+        let pageY: number = this.options.docSpace;
         for (let i = 0; i < bodyArray.length; i++) {
             const body = bodyArray[i];
             const documentRender = documentElement.createRenderObject(this.options);
@@ -94,7 +103,7 @@ export class ElementRenderCut {
             documentRender.addChild(cloneFooterRender);
             //审阅模式，添加审阅窗口
             if (this.options.showReviewWindow && commentsRender) {
-                const commentsContainer = commentsRender.element.createRenderObject(this.options, this.renderContext);
+                const commentsContainer = commentsRender.element.createRenderObject(this.options, this.renderContext) as CommsContainerRenderObject;
                 commentsContainer.padding.top = bodyMarginTop;
                 commentsContainer.rect.height = documentRender.rect.height;
                 documentRender.addChild(commentsContainer);
@@ -104,20 +113,22 @@ export class ElementRenderCut {
         }
         return docPages;
     }
-    checkPageBreak(item) {
+
+    private checkPageBreak(item: RenderObject): boolean {
         if (item.element && item.element.type === 'p') {
-            const p = item.element;
+            const p = item.element as ParagraphElement;
             if (p.props.pageBreak) {
                 return true;
             }
         }
         return false;
     }
-    getFullViewDocRender(documentRender, documentElement) {
-        const commentsRender = documentRender.getChild(3);
-        const commentsContainer = commentsRender.element.createRenderObject(this.options, this.renderContext);
+
+    getFullViewDocRender(documentRender: DocumentRenderObject, documentElement: DocumentElement): Array<DocumentRenderObject> {
+        const commentsRender = documentRender.getChild(3) as CommsContainerRenderObject;
+        const commentsContainer = commentsRender.element.createRenderObject(this.options, this.renderContext) as CommsContainerRenderObject;
         documentRender.rect.height -= commentsContainer.rect.height;
-        const bodyRender = documentRender.getChild(1);
+        const bodyRender = documentRender.getChild(1) as DocumentBodyRenderObject;
         if (this.options.showReviewWindow) {
             documentRender.removeChild(commentsRender);
             documentRender.addChild(commentsContainer);
@@ -126,10 +137,11 @@ export class ElementRenderCut {
             commentsContainer.rect.x = documentRender.rect.x + documentRender.rect.width;
             documentRender.rect.width += this.options.reviewWindowWidth;
         }
-        return [documentRender];
+        return [documentRender as DocumentRenderObject]
     }
-    createEmptyBodyRender(bodyRender, limitRect) {
-        const pageBodyRender = bodyRender.element.createRenderObject(this.options, this.renderContext);
+
+    createEmptyBodyRender(bodyRender: DocumentBodyRenderObject, limitRect: Rect): { emptyBody: DocumentBodyRenderObject, innerRect: Rect & { prevMargin: number } } {
+        const pageBodyRender = bodyRender.element.createRenderObject(this.options, this.renderContext) as DocumentBodyRenderObject;
         ElementUtil.setBlockElementLimitSize(pageBodyRender, limitRect);
         const bodyInnerLimitRect = pageBodyRender.getInnnerRect();
         if (this.options.fullPageView) {
@@ -137,21 +149,22 @@ export class ElementRenderCut {
         }
         return { emptyBody: pageBodyRender, innerRect: { ...bodyInnerLimitRect, prevMargin: 0 } };
     }
+
     /**
      * 切割渲染元素
      * @param render 被切割的对象
-     * @param limitHeight
-     * @param addFunc
-     * @returns
+     * @param limitHeight 
+     * @param addFunc 
+     * @returns 
      */
-    cutRenderItem(render, limitHeight) {
+    cutRenderItem(render: BlockContentRenderObject, limitHeight: number): BlockContentRenderObject | null {
         if (render instanceof TableRowRenderObject) {
             return this.cutRowRenderItem(render, limitHeight);
         }
         if (render instanceof TableRenderObject) {
             return this.cutTable(render, limitHeight);
         }
-        const cloneRender = render.element.createRenderObject(this.options, this.renderContext);
+        const cloneRender = render.element.createRenderObject(this.options, this.renderContext) as MuiltBlockLineRenderObject;
         cloneRender.setRenderWidth(render.rect.width);
         if (render instanceof MuiltBlockLineRenderObject) {
             let sumHeight = 0;
@@ -172,16 +185,13 @@ export class ElementRenderCut {
                             cloneRender.addChild(cutRenderObject);
                             sumHeight += cutRenderObject.rect.height;
                             blockLine = children[++j];
-                        }
-                        else {
+                        } else {
                             break;
                         }
-                    }
-                    else {
+                    } else {
                         break;
                     }
-                }
-                else {
+                } else {
                     render.removeChild(blockLine);
                     cloneRender.addChild(blockLine);
                     sumHeight += blockLine.rect.height;
@@ -192,24 +202,23 @@ export class ElementRenderCut {
             ElementUtil.remeasure(render);
             if (cloneRender.length === 0) {
                 return null;
-            }
-            else {
+            } else {
                 return cloneRender;
             }
-        }
-        else {
+        } else {
             throw new Error('未实现');
         }
     }
+
     /**
      * 切割渲染元素
      * @param tbRender 被切割的对象
-     * @param limitHeight
-     * @param addFunc
-     * @returns
+     * @param limitHeight 
+     * @param addFunc 
+     * @returns 
      */
-    cutTable(tbRender, limitHeight) {
-        const cloneTbRender = tbRender.element.createRenderObject(this.options, this.renderContext);
+    cutTable(tbRender: TableRenderObject, limitHeight: number): BlockContentRenderObject | null {
+        const cloneTbRender = tbRender.element.createRenderObject(this.options, this.renderContext) as TableRenderObject;
         cloneTbRender.setRenderWidth(tbRender.rect.width);
         let sumHeight = 0;
         const rows = [...tbRender.getItems()];
@@ -223,7 +232,7 @@ export class ElementRenderCut {
         const copyHeaderRows = headerRows.map(item => item.clone());
         //获取最后一个截断行,需要根据截断行判断最后一个截断的行位置
         const cutOffRows = rows.filter(row => limitHeight >= row.rect.y && limitHeight <= row.rect.y + row.rect.height)
-            .map((row) => ({ rowIndex: row.element.getIndex(), row }))
+            .map((row) => ({ rowIndex: (<TableRowElement>row.element).getIndex(), row }))
             .sort((first, second) => second.rowIndex - first.rowIndex);
         if (cutOffRows.length === 0) {
             throw new Error('无法获取截断行');
@@ -231,7 +240,7 @@ export class ElementRenderCut {
         const joinRow = cutOffRows[0].row;
         let j = 0;
         let currRow = rows[j];
-        const cutRows = [];
+        const cutRows: Array<TableRowRenderObject> = [];
         while (currRow) {
             const rowContentHeight = this.getBlockLineHeight(currRow);
             if (rowContentHeight + sumHeight > limitHeight) {
@@ -240,7 +249,7 @@ export class ElementRenderCut {
                     const availHeight = limitHeight - sumHeight;
                     //限制的内框尺寸
                     const limitRenderInnterHeight = ElementUtil.innerRectMaxHeight(tbRender, availHeight);
-                    const cutRow = this.cutRowRenderItem(currRow, limitRenderInnterHeight);
+                    const cutRow = this.cutRowRenderItem(currRow, limitRenderInnterHeight) as TableRowRenderObject;
                     if (cutRow) {
                         cloneTbRender.addChild(cutRow);
                         sumHeight += cutRow.rect.height;
@@ -249,16 +258,13 @@ export class ElementRenderCut {
                             break;
                         }
                         currRow = rows[++j];
-                    }
-                    else {
+                    } else {
                         break;
                     }
-                }
-                else {
+                } else {
                     break;
                 }
-            }
-            else {
+            } else {
                 tbRender.removeChild(currRow);
                 cloneTbRender.addChild(currRow);
                 sumHeight += currRow.rect.height;
@@ -269,25 +275,25 @@ export class ElementRenderCut {
         ElementUtil.remeasure(cloneTbRender);
         //存在跨页需要重复显示的行头，则需要重新放置行头
         if (copyHeaderRows.length) {
-            copyHeaderRows.forEach((r, i) => tbRender.insertChild(r, i));
+            copyHeaderRows.forEach((r, i) => tbRender.insertChild(r, i))
         }
         ElementUtil.remeasure(tbRender);
         if (cloneTbRender.length === 0) {
             return null;
-        }
-        else {
+        } else {
             return cloneTbRender;
         }
     }
-    cutRowRenderItem(render, limitHeight) {
+
+    cutRowRenderItem(render: TableRowRenderObject, limitHeight: number): TableRowRenderObject | null {
         if (render.element.props.minHeight > 0 && render.rect.height > limitHeight) {
             return null;
         }
-        const cloneRowRender = render.element.createRenderObject();
+        const cloneRowRender = render.element.createRenderObject() as TableRowRenderObject;
         cloneRowRender.rect.width = render.rect.width;
         cloneRowRender.rect.maxWidth = render.rect.height;
-        const cellRenders = [...render.getItems()];
-        const cutCellRenders = [];
+        const cellRenders = [...render.getItems()] as Array<TableCellRenderObject>;
+        const cutCellRenders: Array<RenderObject | null> = [];
         for (let i = 0; i < cellRenders.length; i++) {
             const cellRender = cellRenders[i];
             if (cellRender.rect.height > limitHeight) {
@@ -297,14 +303,12 @@ export class ElementRenderCut {
                 const limitRenderInnterHeight = ElementUtil.innerRectMaxHeight(cellRender, availHeight);
                 const cutCellRender = this.cutRenderItem(cellRender, limitRenderInnterHeight);
                 if (cutCellRender) {
-                    cutCellRenders.push(cutCellRender);
+                    cutCellRenders.push(cutCellRender)
+                } else {
+                    cutCellRenders.push(null)
                 }
-                else {
-                    cutCellRenders.push(null);
-                }
-            }
-            else {
-                const cloneCellRender = cellRender;
+            } else {
+                const cloneCellRender = cellRender as BlockLineRectRenderObject;
                 render.removeChild(cellRender);
                 cutCellRenders.push(cloneCellRender);
             }
@@ -312,13 +316,12 @@ export class ElementRenderCut {
         ElementUtil.remeasure(render);
         if (cutCellRenders.filter(item => item).length === 0) {
             return null;
-        }
-        else {
+        } else {
             //补齐单元格
             for (let i = 0; i < cutCellRenders.length; i++) {
-                let cellRender = cutCellRenders[i];
+                let cellRender = cutCellRenders[i] as TableCellRenderObject;
                 if (!cellRender) {
-                    cellRender = cellRenders[i].clone();
+                    cellRender = cellRenders[i].clone() as TableCellRenderObject;
                     ElementUtil.remeasure(cellRender);
                 }
                 cloneRowRender.addChild(cellRender);
@@ -329,19 +332,19 @@ export class ElementRenderCut {
     }
     /**
      * 修复->已经截断的合并单元格要向下移动到合适的位置
-     * @param tbRender
-     * @param cutRows
-     * @returns
+     * @param tbRender 
+     * @param cutRows 
+     * @returns 
      */
-    fixCutTable(tbRender, cutRows) {
+    private fixCutTable(tbRender: TableRenderObject, cutRows: Array<TableRowRenderObject>): void {
         if (!cutRows.length) {
             return;
         }
-        const tbEle = tbRender.element;
-        const belowMergeRows = new Set();
+        const tbEle = tbRender.element as TableElement;
+        const belowMergeRows = new Set<TableRowRenderObject>();
         for (let i = 0; i < tbRender.length; i++) {
-            const row = tbRender.getChild(i);
-            const nextRow = tbRender.getChild(i + 1);
+            const row = tbRender.getChild(i) as TableRowRenderObject;
+            const nextRow = tbRender.getChild(i + 1) as TableRowRenderObject;
             if (!nextRow) {
                 break;
             }
@@ -355,8 +358,8 @@ export class ElementRenderCut {
                 break;
             }
             for (let j = 0; j < row.length; j++) {
-                const cell = row.getChild(j);
-                const cellEle = cell.element;
+                const cell = row.getChild(j) as TableCellRenderObject;
+                const cellEle = cell.element as TableCellElement;
                 const colIndex = cellEle.getIndex();
                 if (!this.existsCellRender(nextRow, colIndex)) {
                     const insertColIndex = this.getRowInsertCellIndex(cell, nextRow);
@@ -379,11 +382,12 @@ export class ElementRenderCut {
             ElementUtil.remeasure(tbRender);
         }
     }
+
     /**
      * 校验当前是否是一个完整的行，没有Null单元格，检查当前是否还需要向下合并
-     * @param row
+     * @param row 
      */
-    checkFullRow(row) {
+    private checkFullRow(row: TableRowRenderObject): boolean {
         let x = 0;
         for (let i = 0; i < row.length; i++) {
             const cell = row.getChild(i);
@@ -394,17 +398,19 @@ export class ElementRenderCut {
         }
         return x === row.rect.width;
     }
-    existsCellRender(rowRender, cellIndex) {
+
+    private existsCellRender(rowRender: TableRowRenderObject, cellIndex: number): boolean {
         for (let i = 0; i < rowRender.length; i++) {
-            const cellRender = rowRender.getChild(i);
-            const cellEle = cellRender.element;
+            const cellRender = rowRender.getChild(i) as TableCellRenderObject;
+            const cellEle = cellRender.element as TableCellElement;
             if (cellEle.getIndex() === cellIndex) {
                 return true;
             }
         }
         return false;
     }
-    getBlockLineHeight(render) {
+
+    private getBlockLineHeight(render: RenderObject): number {
         if (render instanceof TableRowRenderObject) {
             let maxCellHeight = 0;
             for (let i = 0; i < render.length; i++) {
@@ -417,9 +423,11 @@ export class ElementRenderCut {
         }
         return render.rect.height;
     }
-    getRowInsertCellIndex(sourceCell, destRow) {
+
+
+    getRowInsertCellIndex(sourceCell: TableCellRenderObject, destRow: TableRowRenderObject): number {
         for (let i = 0; i < destRow.length; i++) {
-            const cell = destRow.getChild(i);
+            const cell = destRow.getChild(i) as TableCellRenderObject;
             const rect = cell.rect;
             if (sourceCell.rect.x < rect.x) {
                 return i;
@@ -431,19 +439,18 @@ export class ElementRenderCut {
         }
         return -1;
     }
-    getHeaderRows(tb) {
-        const rows = [];
+
+    private getHeaderRows(tb: TableRenderObject): Array<TableRowRenderObject> {
+        const rows: Array<TableRowRenderObject> = [];
         for (let i = 0; i < tb.length; i++) {
-            const rowRender = tb.getChild(i);
-            const rowEle = rowRender.element;
+            const rowRender = tb.getChild(i) as TableRowRenderObject;
+            const rowEle = rowRender.element as TableRowElement;
             if (rowEle.props.headerRow) {
                 rows.push(rowRender);
-            }
-            else {
+            } else {
                 break;
             }
         }
         return rows;
     }
 }
-//# sourceMappingURL=element-render-cut.js.map