@hailin-zheng/editor-core 1.0.6 → 1.0.9

package/{lib/framework/impl/table/table-impl.js → src/med_editor/framework/impl/table/table-impl.ts}

@@ -1,59 +1,71 @@
-import { BlockContainerElement, ElementFactory } from "@/med_editor/framework/element-define";
-import { TableProps } from "@/med_editor/framework/element-props";
-import { ElementUtil } from "@/med_editor/framework/element-util";
-import { MuiltBlockLineRenderObject } from "@/med_editor/framework/render-define";
-import { ParagraphElement } from "../paragraph/p-impl";
-import { TableRowElement } from "./table-row-impl";
+import {
+    BlockContainerElement,
+    Element,
+    ElementFactory,
+    Position,
+    SerializeProps,
+    ViewOptions
+} from "../../element-define";
+import { ContentMenuItem, ContextMenuElementEvent, KeyboradElementEvent } from "../../element-event-define";
+import { TableProps } from "../../element-props";
+import { ElementUtil } from "../../element-util";
+import { RenderContenxtType } from "../../render-context";
+import { MuiltBlockLineRenderObject, RenderObject } from "../../render-define";
+import { ParagraphElement, ParagraphRenderObject } from "../paragraph/p-impl";
+import { TableCellRenderObject } from "./table-cell-impl";
+import { TableRowElement, TableRowRenderObject } from "./table-row-impl";
 import { TableSplitCell } from "./table-split-cell";
 import { TableUtil } from "./table-util";
+
 /**
  * 计算表格列
  */
-function calcTableCols(element) {
-    const percentCols = [];
+function calcTableCols(element: TableElement): Array<{ width: number, offset: number }> {
+    const percentCols: Array<{ width: string | number }> = [];
     let sum = 0;
     let percentSum = 0;
     for (const col of element.props.cols) {
         if (typeof col.width === 'string') {
             percentCols.push(col);
             percentSum += Number.parseFloat(col.width);
-        }
-        else {
-            sum += col.width;
+        } else {
+            sum += col.width as number;
         }
     }
-    const measureRender = element.measureRender;
-    const tbWidth = measureRender.rect.maxWidth;
+    const measureRender = element.measureRender as RenderObject;
+    const tbWidth = measureRender.rect.maxWidth as number;
     if (percentCols.length > 0) {
         const remainWidth = tbWidth - sum;
         let remainSum = 0;
         for (const percentCol of percentCols) {
             const percentWidth = Number.parseFloat(percentCol.width.toString());
+
             percentCol.width = Math.floor(remainWidth * percentWidth / percentSum);
-            remainSum += percentCol.width;
+            remainSum += percentCol.width as number;
         }
         if (remainWidth - remainSum > 0) {
-            const colWidth = percentCols[percentCols.length - 1].width;
+            const colWidth = percentCols[percentCols.length - 1].width as number;
             percentCols[percentCols.length - 1].width = colWidth + (remainWidth - remainSum);
         }
     }
-    const array = [];
+    const array: Array<{ width: number, offset: number }> = [];
     let offset = 0;
     for (let i = 0; i < element.props.cols.length; i++) {
-        const width = element.props.cols[i].width;
+        const width = element.props.cols[i].width as number;
         array.push({ width, offset });
         offset += width;
     }
     return array;
 }
-export class TableElement extends BlockContainerElement {
+
+export class TableElement extends BlockContainerElement<TableProps> {
     //props: TableProps;
-    _actualColsProps;
+    private _actualColsProps!: Array<{ width: number, offset: number }> | null;
     constructor() {
         super('tb');
         this.props = new TableProps();
         //this.addPropValueChangedSub(this.props);
-        this.addEvent('ElementContextMenu', (evt) => {
+        this.addEvent<ContextMenuElementEvent>('ElementContextMenu', (evt) => {
             const { selectionState } = evt;
             if (TableUtil.canDeleteTable(selectionState)) {
                 evt.menus.push({
@@ -71,17 +83,20 @@ export class TableElement extends BlockContainerElement {
                 });
             }
             if (TableUtil.canMergeCells(selectionState)) {
-                evt.menus.push({ icon: 'MergeDuplicate', caption: '合并单元格', eventObj: { onClick: (cevt) => { TableUtil.mergeCells(selectionState); } } });
+                evt.menus.push({ icon: 'MergeDuplicate', caption: '合并单元格', eventObj: { onClick: (cevt) => { TableUtil.mergeCells(selectionState) } } });
             }
             if (TableUtil.canSplitCell(selectionState)) {
-                evt.menus.push({ icon: 'Split', caption: '拆分单元格', eventObj: { onClick: (cevt) => { TableSplitCell.splitCell(selectionState, 0, 2); } } });
-                evt.menus.push({ icon: 'Combine', caption: '合并单元格还原', eventObj: { onClick: (cevt) => { TableUtil.restoreCell(selectionState); } } });
+                evt.menus.push({ icon: 'Split', caption: '拆分单元格', eventObj: { onClick: (cevt) => { TableSplitCell.splitCell(selectionState, 0, 2) } } });
+                evt.menus.push({ icon: 'Combine', caption: '合并单元格还原', eventObj: { onClick: (cevt) => { TableUtil.restoreCell(selectionState) } } });
+
             }
-            evt.menus.push({ icon: "Insert", caption: '上方插入段落', eventObj: { onClick: (cevt) => { this.parent.addChild(ParagraphElement.createElement(), this.getIndex()); this.refreshView(); } } });
-            evt.menus.push({ icon: "Insert", caption: '下方插入段落', eventObj: { onClick: (cevt) => { this.parent.addChild(ParagraphElement.createElement(), this.getIndex() + 1); this.refreshView(); } } });
+            evt.menus.push({ icon: "Insert", caption: '上方插入段落', eventObj: { onClick: (cevt) => { this.parent.addChild(ParagraphElement.createElement(), this.getIndex()); this.refreshView() } } });
+            evt.menus.push({ icon: "Insert", caption: '下方插入段落', eventObj: { onClick: (cevt) => { this.parent.addChild(ParagraphElement.createElement(), this.getIndex() + 1); this.refreshView() } } });
+
+
             evt.menus = removeDuplicatesEvent(evt.menus);
         }, true);
-        this.addEvent('ElementKeyDown', (evt) => {
+        this.addEvent<KeyboradElementEvent>('ElementKeyDown', (evt) => {
             //console.log('表格ElementKeyDown', evt);
             const sourceEvent = evt.sourceEvent;
             //按下tab键
@@ -101,42 +116,48 @@ export class TableElement extends BlockContainerElement {
         }
         return this._actualColsProps;
     }
-    getCellWidth(cellIndex) {
+
+    getCellWidth(cellIndex: number): number {
         if (cellIndex >= this.actualColsProps.length || cellIndex < 0) {
             return -1;
         }
         return this.actualColsProps[cellIndex].width;
     }
-    getCellOffsetX(cellIndex) {
+
+    getCellOffsetX(cellIndex: number): number {
         return this.actualColsProps[cellIndex].offset;
     }
-    setCellWidth(cellIndex, width) {
+
+    setCellWidth(cellIndex: number, width: number): void {
         //this.actualColsProps[index].width = width;
         if (cellIndex >= this.actualColsProps.length || cellIndex < 0) {
             return;
         }
         this.props.cols[cellIndex].width = width;
     }
+
     /**
      * 插入列的定义
-     * @param index
-     * @param width
+     * @param index 
+     * @param width 
      */
-    insertCol(index, width) {
+    insertCol(index: number, width: number | string): void {
         this.props.cols.splice(index, 0, { width });
         this._actualColsProps = null;
     }
+
     /**
      * 移除列的定义
-     * @param index
+     * @param index 
      */
-    removeCol(index) {
+    removeCol(index: number): void {
         this.props.cols.splice(index, 1);
     }
-    getColsCount() {
+
+    getColsCount(): number {
         return this.actualColsProps.length;
     }
-    clone(data) {
+    clone(data: boolean): Element {
         const clone = new TableElement();
         this.props.clone(clone.props);
         if (data) {
@@ -146,23 +167,27 @@ export class TableElement extends BlockContainerElement {
         }
         return clone;
     }
-    createRenderObject(options, renderCtx) {
+
+    createRenderObject(options: ViewOptions, renderCtx: RenderContenxtType): RenderObject {
         return new TableRenderObject(this);
     }
-    beginMeasure() {
+
+    beginMeasure(): void {
         super.beginMeasure();
         this._actualColsProps = null;
     }
-    serialize(options) {
+
+    serialize(options: ViewOptions): SerializeProps {
         //this.props.width = this.measureRender?.rect.width as number;
         const props = {
             type: 'tb',
             props: { ...this.props.getSerializeProps(options) }
-        };
-        props.props.width = this.measureRender?.rect.width;
+        }
+        props.props.width = this.measureRender?.rect.width as number;
         return props;
     }
-    static createTable(rows, cols) {
+
+    static createTable(rows: number, cols: number): TableElement {
         const table = new TableElement();
         const tbProps = new TableProps();
         table.props = tbProps;
@@ -177,8 +202,9 @@ export class TableElement extends BlockContainerElement {
         return table;
     }
 }
-function removeDuplicatesEvent(events) {
-    let arr = [];
+
+function removeDuplicatesEvent(events: ContentMenuItem[]): ContentMenuItem[] {
+    let arr: ContentMenuItem[] = [];
     for (let i = events.length - 1; i >= 0; i--) {
         let keys = arr.map(item => item.caption);
         if (!keys.includes(events[i].caption)) {
@@ -187,21 +213,23 @@ function removeDuplicatesEvent(events) {
     }
     return arr;
 }
-export class TableRenderObject extends MuiltBlockLineRenderObject {
-    setRenderWidth(maxWidth) {
+
+export class TableRenderObject extends MuiltBlockLineRenderObject<TableElement> {
+    setRenderWidth(maxWidth: number): void {
         super.setRenderWidth(maxWidth);
     }
-    beginRender(ctx, position) {
+
+    beginRender(ctx: RenderContenxtType, position: { x: number; y: number; }): void {
         //绘制表格线
         if (this.element.props.border !== 'all') {
             return;
         }
         for (let i = 0; i < this.length; i++) {
-            const rowRender = this.getChild(i);
-            const rowPos = { x: rowRender.rect.x + position.x, y: rowRender.rect.y + position.y };
+            const rowRender = this.getChild(i) as TableRowRenderObject;
+            const rowPos: Position = { x: rowRender.rect.x + position.x, y: rowRender.rect.y + position.y };
             for (let j = 0; j < rowRender.length; j++) {
-                const cellRender = rowRender.getChild(j);
-                const cellPos = { x: cellRender.rect.x + rowPos.x, y: cellRender.rect.y + rowPos.y };
+                const cellRender = rowRender.getChild(j) as TableCellRenderObject;
+                const cellPos: Position = { x: cellRender.rect.x + rowPos.x, y: cellRender.rect.y + rowPos.y };
                 //绘制单元格上边框
                 if (i === 0) {
                     //ctx.contentContext.fillRect(cellPos.x, cellPos.y, cellRender.rect.width, 1);
@@ -226,9 +254,10 @@ export class TableRenderObject extends MuiltBlockLineRenderObject {
             }
         }
     }
-    endRender(ctx, position) {
+
+    endRender(ctx: RenderContenxtType, position: { x: number; y: number; }): void {
     }
-    clone() {
+    clone(): RenderObject {
         const cloneRender = new TableRenderObject(this.element);
         cloneRender.rect = ElementUtil.cloneRect(this.rect);
         for (let i = 0; i < this.length; i++) {
@@ -237,12 +266,14 @@ export class TableRenderObject extends MuiltBlockLineRenderObject {
         return cloneRender;
     }
 }
-export class TableFactory extends ElementFactory {
-    match(type) {
+
+
+export class TableFactory extends ElementFactory<TableProps> {
+    match(type: string): boolean {
         return type === 'tb';
     }
-    createElement(data, renderCtx) {
-        const props = data.props;
+    createElement(data: any, renderCtx: RenderContenxtType): Element {
+        const props = data.props as TableProps;
         const tb = new TableElement();
         const cols = props.cols;
         const tbProps = tb.props;
@@ -256,17 +287,19 @@ export class TableFactory extends ElementFactory {
         tb.props = tbProps;
         return tb;
     }
+
 }
+
 /**
  * 行-表格渲染模式
  */
-export function textLineRenderMode(ele, options, renderCtx) {
-    const tb = ele.measureRender;
-    const rows = [];
+export function textLineRenderMode(ele: TableElement, options: ViewOptions, renderCtx: RenderContenxtType): boolean {
+    const tb = ele.measureRender as TableRenderObject;
+    const rows: Array<TableRowRenderObject> = []
     for (let i = 0; i < tb.length; i++) {
-        const row = tb.getChild(i);
+        const row = tb.getChild(i) as TableRowRenderObject;
         //表格头不做处理
-        if (row.element.props.headerRow) {
+        if ((<TableRowElement>row.element).props.headerRow) {
             continue;
         }
         rows.push(row);
@@ -277,16 +310,16 @@ export function textLineRenderMode(ele, options, renderCtx) {
         const maxLinesCount = getRowMaxTextLines(row);
         if (maxLinesCount > 1) {
             for (let j = 1; j < maxLinesCount; j++) {
-                const newRow = row.element.createRenderObject();
+                const newRow = row.element.createRenderObject() as TableRowRenderObject;
                 newRow.rect = ElementUtil.cloneRect(row.rect);
                 tb.insertChild(newRow, row.getIndex() + 1);
                 //复制行文字到新行中
                 for (let k = 0; k < row.length; k++) {
-                    const cell = row.getChild(k);
-                    const newCell = cell.element.createRenderObject(options, renderCtx);
+                    const cell = row.getChild(k) as TableCellRenderObject;
+                    const newCell = cell.element.createRenderObject(options, renderCtx) as TableCellRenderObject
                     newCell.rect = ElementUtil.cloneRect(cell.rect);
                     if (newCell) {
-                        newRow.addChild(newCell);
+                        newRow.addChild(newCell)
                     }
                 }
             }
@@ -296,68 +329,73 @@ export function textLineRenderMode(ele, options, renderCtx) {
     ElementUtil.remeasure(tb);
     return true;
 }
+
 /**
  * 获取当前行的文字行数
- * @param row
- * @returns
+ * @param row 
+ * @returns 
  */
-function getRowMaxTextLines(row) {
+function getRowMaxTextLines(row: TableRowRenderObject): number {
     let count = 0;
     for (let j = 0; j < row.length; j++) {
-        const cell = row.getChild(j);
+        const cell = row.getChild(j) as TableCellRenderObject;
         let cellMaxLines = 0;
         for (let k = 0; k < cell.length; k++) {
-            const paraRender = cell.getChild(k);
+            const paraRender = cell.getChild(k) as ParagraphRenderObject;
             cellMaxLines += paraRender.length;
         }
         count = cellMaxLines > count ? cellMaxLines : count;
     }
     return count;
 }
+
 /**
  * 将多行文本移动到新行中
- * @param row
- * @param maxLinesCount
- * @returns
+ * @param row 
+ * @param maxLinesCount 
+ * @returns 
  */
-function splitTextlineToNewRow(row, maxLinesCount, options, renderCtx) {
+function splitTextlineToNewRow(row: TableRowRenderObject, maxLinesCount: number, options: ViewOptions, renderCtx: RenderContenxtType): void {
     if (maxLinesCount === 1) {
         return;
     }
     for (let i = 0; i < row.length; i++) {
-        const cell = row.getChild(i);
+        const cell = row.getChild(i) as TableCellRenderObject;
         const paraLines = ElementUtil.getCellParaLines(cell);
         if (paraLines.length === 1) {
             continue;
         }
         for (let j = 1; j < paraLines.length; j++) {
             const outterLineRect = paraLines[j];
-            const paraRender = outterLineRect.parent;
-            const newParaRender = paraRender.element.createRenderObject(options, renderCtx);
+            const paraRender = outterLineRect.parent as ParagraphRenderObject;
+
+            const newParaRender = paraRender.element.createRenderObject(options, renderCtx) as ParagraphRenderObject;
             newParaRender.rect = ElementUtil.cloneRect(paraRender.rect);
+
             const newOutterLineRect = outterLineRect.clone();
             newOutterLineRect.rect = ElementUtil.cloneRect(outterLineRect.rect);
             newParaRender.addChild(newOutterLineRect);
+
             paraRender.removeChild(outterLineRect);
             ElementUtil.remeasure(paraRender);
+
             if (paraRender.length === 0) {
                 cell.removeChild(paraRender);
             }
-            const splitRow = row.parent.getChild(row.getIndex() + j);
-            const splitCell = splitRow.getChild(i);
+            const splitRow = row.parent.getChild(row.getIndex() + j) as TableRowRenderObject;
+            const splitCell = splitRow.getChild(i) as TableCellRenderObject;
             splitCell.addChild(newParaRender);
             ElementUtil.remeasure(newParaRender);
         }
     }
-    const tb = row.parent;
+    const tb = row.parent as TableRenderObject;
     const rowIndex = row.getIndex();
     for (let i = 0; i < maxLinesCount; i++) {
-        const row = tb.getChild(rowIndex + i);
+        const row = tb.getChild(rowIndex + i) as TableRowRenderObject;
         for (let j = 0; j < row.length; j++) {
-            const cell = row.getChild(j);
+            const cell = row.getChild(j) as TableCellRenderObject;
             ElementUtil.remeasure(cell);
         }
         ElementUtil.remeasure(row);
     }
 }
-//# sourceMappingURL=table-impl.js.map

package/{lib/framework/impl/table/table-row-impl.js → src/med_editor/framework/impl/table/table-row-impl.ts}

@@ -1,9 +1,11 @@
-import { BlockContainerElement, ElementFactory, ModifyFlag } from "@/med_editor/framework/element-define";
-import { TableRowProps } from "@/med_editor/framework/element-props";
-import { ElementUtil } from "@/med_editor/framework/element-util";
-import { MuiltBlockLineRenderObject } from "@/med_editor/framework/render-define";
+import { BlockContainerElement, Element, ElementFactory, ModifyFlag, readElementProps, SerializeProps, ViewOptions } from "../../element-define";
+import { TableRowProps } from "../../element-props";
+import { ElementUtil } from "../../element-util";
+import { RenderContenxtType } from "../../render-context";
+import { MuiltBlockLineRenderObject, RenderObject } from "../../render-define";
 import { TableCellElement } from "./table-cell-impl";
-export class TableRowElement extends BlockContainerElement {
+
+export class TableRowElement extends BlockContainerElement<TableRowProps> {
     //props: TableRowProps;
     constructor() {
         super('tr');
@@ -17,10 +19,12 @@ export class TableRowElement extends BlockContainerElement {
         });
         this.addsubscribe(this, changeSub);
     }
-    createRenderObject() {
+
+    createRenderObject(): RenderObject {
         return new TableRowRenderObject(this);
     }
-    serialize(viewOptions) {
+
+    serialize(viewOptions: ViewOptions): SerializeProps {
         return {
             type: 'tr',
             props: {
@@ -28,7 +32,7 @@ export class TableRowElement extends BlockContainerElement {
             }
         };
     }
-    clone(data) {
+    clone(data: boolean): Element {
         const clone = new TableRowElement();
         this.props.clone(clone.props);
         if (data) {
@@ -38,7 +42,8 @@ export class TableRowElement extends BlockContainerElement {
         }
         return clone;
     }
-    static createRow(cols) {
+
+    static createRow(cols: number): TableRowElement {
         const tr = new TableRowElement();
         for (let i = 0; i < cols; i++) {
             tr.addChild(TableCellElement.createCell());
@@ -46,12 +51,14 @@ export class TableRowElement extends BlockContainerElement {
         return tr;
     }
 }
-export class TableRowRenderObject extends MuiltBlockLineRenderObject {
-    beginRender(ctx, position) {
+
+export class TableRowRenderObject extends MuiltBlockLineRenderObject<TableRowElement> {
+    beginRender(ctx: RenderContenxtType, position: { x: number; y: number; }): void {
     }
-    endRender(ctx, position) {
+    endRender(ctx: RenderContenxtType, position: { x: number; y: number; }): void {
     }
-    clone() {
+
+    clone(): RenderObject {
         const cloneRender = new TableRowRenderObject(this.element);
         cloneRender.rect = ElementUtil.cloneRect(this.rect);
         for (let i = 0; i < this.length; i++) {
@@ -60,16 +67,17 @@ export class TableRowRenderObject extends MuiltBlockLineRenderObject {
         return cloneRender;
     }
 }
-export class TableRowFactory extends ElementFactory {
-    match(type) {
+
+export class TableRowFactory extends ElementFactory<TableRowProps> {
+    match(type: string): boolean {
         return type === 'tr';
     }
-    createElement(data, renderCtx) {
-        const props = data.props;
+    createElement(data: readElementProps<TableRowProps>, renderCtx: RenderContenxtType): Element {
+        const props = data.props as TableRowProps;
         const tr = new TableRowElement();
         tr.props.minHeight = props?.minHeight ?? -1;
         tr.props.headerRow = props?.headerRow;
         return tr;
     }
+
 }
-//# sourceMappingURL=table-row-impl.js.map

package/{lib/framework/impl/table/table-split-cell-patch.js → src/med_editor/framework/impl/table/table-split-cell-patch.ts}

@@ -1,9 +1,12 @@
+export interface ColumnPartOffset extends ColumnPart { offset: number }
+export interface ColumnPart { index: number, width: number }
+export interface ColumnPatch { type: 'modify' | 'insert', data: ColumnPart }
 export class ColumnPatchUtil {
-    static getPatchPacks(cols, splitCols) {
+    static getPatchPacks(cols: Array<ColumnPart>, splitCols: Array<ColumnPart>): [Array<{ part: ColumnPartOffset, patchs: Array<ColumnPatch> }>, Array<Array<ColumnPart>>] {
         const oldLinePointMap = this.getLinePointMap(cols);
         //要分割的列坐标
         const newLinePointMap = this.getLinePointMap(splitCols);
-        const resArray = new Set();
+        const resArray: Set<number> = new Set();
         const allPointMap = oldLinePointMap.concat(newLinePointMap);
         for (let i = 0; i < allPointMap.length; i++) {
             const part = allPointMap[i];
@@ -11,7 +14,7 @@ export class ColumnPatchUtil {
             resArray.add(part.offset + part.width);
         }
         const points = Array.from(resArray).sort((first, second) => first - second);
-        const patchs = [];
+        const patchs: Array<{ part: ColumnPartOffset, patchs: Array<ColumnPatch> }> = [];
         //获取其他行的拆分补丁
         for (let i = 0; i < points.length - 1; i++) {
             const partStartOffset = points[i];
@@ -19,11 +22,13 @@ export class ColumnPatchUtil {
             const joinPart = oldLinePointMap.find(item => {
                 const startOffset = item.offset;
                 const endOffset = item.offset + item.width;
-                return ((startOffset >= partStartOffset && startOffset < partEndOffset)
+                return (
+                    (startOffset >= partStartOffset && startOffset < partEndOffset)
                     ||
-                        (endOffset > partStartOffset && endOffset <= partEndOffset)
+                    (endOffset > partStartOffset && endOffset <= partEndOffset)
                     ||
-                        (startOffset <= partStartOffset && endOffset >= partEndOffset));
+                    (startOffset <= partStartOffset && endOffset >= partEndOffset)
+                )
             });
             if (joinPart) {
                 if (joinPart.offset === partStartOffset && joinPart.offset + joinPart.width === partEndOffset) {
@@ -31,18 +36,17 @@ export class ColumnPatchUtil {
                 }
                 const patch = patchs.find(item => item.part === joinPart);
                 if (patch) {
-                    patch.patchs.push({ type: 'insert', data: { width: partEndOffset - partStartOffset, index: joinPart.index } });
-                }
-                else {
+                    patch.patchs.push({ type: 'insert', data: { width: partEndOffset - partStartOffset, index: joinPart.index } })
+                } else {
                     patchs.push({
                         part: joinPart,
                         patchs: [{ type: 'modify', data: { width: partEndOffset - partStartOffset, index: joinPart.index } }]
-                    });
+                    })
                 }
             }
         }
         //获取当前行的拆分补丁
-        const currRowPaths = [];
+        const currRowPaths: Array<Array<ColumnPart>> = [];
         const allColumnMap = this.getLinePointMap(this.getColumn(points));
         for (let i = 0; i < newLinePointMap.length; i++) {
             const partStartOffset = newLinePointMap[i].offset;
@@ -50,33 +54,39 @@ export class ColumnPatchUtil {
             const joinParts = allColumnMap.filter(item => {
                 const startOffset = item.offset;
                 const endOffset = item.offset + item.width;
-                return ((startOffset >= partStartOffset && startOffset < partEndOffset)
+                return (
+                    (startOffset >= partStartOffset && startOffset < partEndOffset)
                     ||
-                        (endOffset > partStartOffset && endOffset <= partEndOffset)
+                    (endOffset > partStartOffset && endOffset <= partEndOffset)
                     ||
-                        (startOffset <= partStartOffset && endOffset >= partEndOffset));
+                    (startOffset <= partStartOffset && endOffset >= partEndOffset)
+                )
             });
             currRowPaths.push(joinParts);
         }
         return [patchs, currRowPaths];
     }
-    static getColumn(points) {
-        const items = [];
+
+
+    private static getColumn(points: Array<number>): Array<ColumnPart> {
+        const items: Array<ColumnPart> = [];
         for (let index = 0; index < points.length - 1; index++) {
             items.push({ index, width: points[index + 1] - points[index] });
         }
         return items;
     }
-    static getSplitCols(width, cols) {
-        const items = [];
+
+    private static getSplitCols(width: number, cols: number): Array<ColumnPart> {
+        const items: Array<ColumnPart> = [];
         for (let i = 0; i < cols; i++) {
             items.push({ width: Math.floor(width / cols), index: i });
         }
         items[items.length - 1].width += width - items.reduce((prev, curr) => prev + curr.width, 0);
         return items;
     }
-    static getLinePointMap(hMergeCols) {
-        const linePointMap = [];
+
+    private static getLinePointMap(hMergeCols: Array<ColumnPart>): Array<ColumnPartOffset> {
+        const linePointMap: Array<ColumnPartOffset> = [];
         let x = 0;
         for (let i = 0; i < hMergeCols.length; i++) {
             const col = hMergeCols[i];
@@ -85,5 +95,4 @@ export class ColumnPatchUtil {
         }
         return linePointMap;
     }
-}
-//# sourceMappingURL=table-split-cell-patch.js.map
+}