@guiexpert/table 1.0.2 → 1.0.5

package/lib/table/data/tablemodel/column/column-def.d.ts

@@ -0,0 +1,52 @@
+import { SizeIf } from "../../common/size.if";
+import { ColumnDefIf } from "./column-def.if";
+import { CellRendererIf } from "../../../renderer/cell-render.if";
+import { AreaObjectMapType } from "../../common/area-map.type";
+import { AreaObjectMap } from "../../common/area-map";
+import { BooleanFunction } from "../../common/boolean-function";
+import { SortState } from "../../common/sort-state.type";
+import { GetEditRenderer } from "../../../renderer/edit/edit-cell-renderer.type";
+import { editInputPipe } from "../../../renderer/edit/edit-input-pipe.if";
+export declare class ColumnDef implements ColumnDefIf {
+    property: string;
+    headerLabel: string;
+    width: SizeIf;
+    classes: AreaObjectMapType<string[]>;
+    rendererMap: AreaObjectMapType<CellRendererIf>;
+    minWidth: SizeIf;
+    maxWidth: SizeIf;
+    sortable?: BooleanFunction | undefined;
+    sortComparator?: (<T>(a: T, b: T) => number) | undefined;
+    sortState?: SortState | undefined;
+    sortStatesOrder?: SortState[] | undefined;
+    sortIconVisible?: BooleanFunction | undefined;
+    editable?: BooleanFunction | undefined;
+    getEditRenderer?: GetEditRenderer | undefined;
+    editInputPipe?: editInputPipe | undefined;
+    isVisible: BooleanFunction;
+    visible: boolean;
+    constructor(property: string, headerLabel: string, width?: SizeIf, classes?: AreaObjectMapType<string[]>, rendererMap?: AreaObjectMapType<CellRendererIf>, minWidth?: SizeIf, maxWidth?: SizeIf, sortable?: BooleanFunction | undefined, sortComparator?: (<T>(a: T, b: T) => number) | undefined, sortState?: SortState | undefined, sortStatesOrder?: SortState[] | undefined, sortIconVisible?: BooleanFunction | undefined, editable?: BooleanFunction | undefined, getEditRenderer?: GetEditRenderer | undefined, editInputPipe?: editInputPipe | undefined, isVisible?: BooleanFunction);
+    static bodyRenderer(bodyRenderer: CellRendererIf): AreaObjectMap<CellRendererIf>;
+    static create(param: {
+        property?: string;
+        headerLabel?: string;
+        width?: SizeIf;
+        minWidth?: SizeIf;
+        maxWidth?: SizeIf;
+        headerRenderer?: CellRendererIf;
+        bodyRenderer?: CellRendererIf;
+        footerRenderer?: CellRendererIf;
+        headerClasses?: string[];
+        bodyClasses?: string[];
+        footerClasses?: string[];
+        sortable?: BooleanFunction;
+        sortIconVisible?: BooleanFunction;
+        sortComparator?: <T>(a: T, b: T) => number;
+        sortState?: SortState;
+        sortStatesOrder?: SortState[];
+        editable?: BooleanFunction;
+        isVisible?: BooleanFunction;
+        getEditRenderer?: GetEditRenderer;
+        editInputPipe?: editInputPipe;
+    }): ColumnDefIf;
+}

package/lib/table/data/tablemodel/column/column-def.if.d.ts

@@ -0,0 +1,25 @@
+import { SizeIf } from "../../common/size.if";
+import { CellRendererIf } from "../../../renderer/cell-render.if";
+import { AreaObjectMapType } from "../../common/area-map.type";
+import { BooleanFunction } from "../../common/boolean-function";
+import { SortState } from "../../common/sort-state.type";
+import { GetEditRenderer } from "../../../renderer/edit/edit-cell-renderer.type";
+import { editInputPipe } from "../../../renderer/edit/edit-input-pipe.if";
+export interface ColumnDefIf {
+    property: string;
+    headerLabel: string;
+    width: SizeIf;
+    minWidth: SizeIf;
+    maxWidth: SizeIf;
+    rendererMap: AreaObjectMapType<CellRendererIf>;
+    classes: AreaObjectMapType<string[]>;
+    sortable?: BooleanFunction;
+    sortIconVisible?: BooleanFunction;
+    sortComparator?: <T>(a: T, b: T) => number;
+    sortState?: SortState;
+    sortStatesOrder?: SortState[];
+    editable?: BooleanFunction;
+    isVisible?: BooleanFunction;
+    getEditRenderer?: GetEditRenderer;
+    editInputPipe?: editInputPipe;
+}

package/lib/table/data/tablemodel/padding.d.ts

@@ -0,0 +1,7 @@
+export declare class Padding {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    constructor(top?: number, right?: number, bottom?: number, left?: number);
+}

package/lib/table/data/tablemodel/table-model.d.ts

@@ -0,0 +1,88 @@
+import { TableModelIf } from "./table-model.if";
+import { Padding } from "./padding";
+import { AreaIdent } from "./area-ident.type";
+import { AreaModelIf } from "./areamodel/area-model.if";
+import { SideIdent } from "../side-ident.type";
+import { DefaultRowHeightsIf } from "../options/default-row-heights.if";
+import { ColumnDefIf } from "./column/column-def.if";
+import { FilterFunction } from "../common/filter-function";
+import { SortItem } from "../common/sort-item";
+import { SelectionModelIf } from "../../selection/selection-model.if";
+import { GetT } from "../common/get-t";
+/**
+ * This is a default implementation of TableModelIf.
+ * Ths TableModel is on one hand a container for the header, body, and footer models
+ * (see : #getAreaModel, and #AreaModelIf), and on the other hand the master of
+ * the column information (#getColumnCount(), #getColumnWidth(columnIndex: number)).
+ *
+ * If getFixedLeftColumnCount() returns a value greater than 0, a fixed west area will be rendered in the
+ * header, body, and footer. A value greater than 0 for getFixedLeftColumnCount()
+ * will result in the presence of an east area.
+ *
+ * <pre>
+ *  +----------------+-------------------+--------------+
+ *  |  header/west   |  header/center    | header/east  |
+ *  +----------------+-------------------+--------------+
+ *  |  body/west     |  body/center      | body/east    |
+ *  +----------------+-------------------+--------------+
+ *  |  footer/west   |  footer/center    | footer/east  |
+ *  +----------------+-------------------+--------------+ </pre>
+ *
+ */
+export declare class TableModel implements TableModelIf {
+    readonly headerAreaModel: AreaModelIf;
+    readonly bodyAreaModel: AreaModelIf;
+    readonly footerAreaModel: AreaModelIf;
+    readonly fixedLeftColumnCount: number;
+    readonly fixedRightColumnCount: number;
+    readonly rowCheckboxVisible: boolean;
+    readonly defaultRowHeights: DefaultRowHeightsIf;
+    columnDefs: ColumnDefIf[];
+    columnSizes: number[];
+    protected overridingColumnWidth: number;
+    protected columnCount: number;
+    protected parentSize: number;
+    readonly getSelectionModel: GetT<SelectionModelIf>;
+    protected rowCount: number;
+    protected contentHeightInPx: number;
+    protected contentWidthInPx: number;
+    protected padding: Padding;
+    protected xPositions: number[];
+    constructor(headerAreaModel: AreaModelIf, bodyAreaModel: AreaModelIf, footerAreaModel: AreaModelIf, fixedLeftColumnCount?: number, fixedRightColumnCount?: number, rowCheckboxVisible?: boolean, defaultRowHeights?: DefaultRowHeightsIf, columnDefs?: ColumnDefIf[], columnSizes?: number[], overridingColumnWidth?: number, columnCount?: number, parentSize?: number, // can be important when we have percentage widthes,
+    getSelectionModel?: GetT<SelectionModelIf>);
+    init(): void;
+    getColumnCount(): number;
+    setColumnWidth(columnIndex: number, width: number): void;
+    getColumnWidth(columnIndex: number): number;
+    getXPosByColumnIndex(columnIndex: number): number;
+    recalcSize(clientWidth: number): void;
+    recalcHeightAndPadding(): void;
+    recalcPadding(): void;
+    getPadding(): Padding;
+    getContentHeightInPixel(): number;
+    getContentWidthInPixel(): number;
+    getRowHeight(rowAreaIdent: AreaIdent, rowIndex: number): number;
+    getModel(rowAreaIdent: AreaIdent): AreaModelIf;
+    getAreaHeight(areaIdent: AreaIdent): number;
+    getSideAreaWidth(sideIdent: SideIdent): number;
+    getSideStartAndEndColumnIndex(sideIdent: SideIdent): [number, number];
+    getColumnDef(index: number): ColumnDefIf | undefined;
+    getFixedLeftColumnCount(): number;
+    getFixedRightColumnCount(): number;
+    getAreaModel(area: AreaIdent): AreaModelIf;
+    getBodyModel(): AreaModelIf;
+    isFooterVisibe(): boolean;
+    isHeaderVisibe(): boolean;
+    isRowCheckboxVisible(): boolean;
+    externalFilterChanged<T>(predictFn: FilterFunction<T>): void;
+    doSort(sortItems: SortItem[]): boolean;
+    getColumnDefs(): ColumnDefIf[] | undefined;
+    getColumnProperty(columnIndex: number): string;
+    getBodyRowByIndex(rowIndex: number): any;
+    isSortable(columnIndex: number): boolean;
+    changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
+    private recalcColumnWidthes;
+    private arrayMove;
+    private recalcContentWidthInPx;
+    private calcXPositions;
+}

package/lib/table/data/tablemodel/table-model.if.d.ts

@@ -0,0 +1,56 @@
+import { Padding } from "./padding";
+import { AreaIdent } from "./area-ident.type";
+import { ColumnDefIf } from "./column/column-def.if";
+import { AreaModelIf } from "./areamodel/area-model.if";
+import { FilterFunction } from "../common/filter-function";
+import { SortItem } from "../common/sort-item";
+import { SelectionModelIf } from "../../selection/selection-model.if";
+/**
+ * The TableModelIf is on one hand a container for the header, body, and footer models
+ * (see : #getAreaModel, and #AreaModelIf), and on the other hand the master of
+ * the column information (#getColumnCount(), #getColumnWidth(columnIndex: number)).
+ *
+ * If getFixedLeftColumnCount() returns a value greater than 0, a fixed west area will be rendered in the
+ * header, body, and footer. A value greater than 0 for getFixedLeftColumnCount()
+ * will result in the presence of an east area.
+ * <pre>
+ *  +----------------+-------------------+--------------+
+ *  |  header/west   |  header/center    | header/east  |
+ *  +----------------+-------------------+--------------+
+ *  |  body/west     |  body/center      | body/east    |
+ *  +----------------+-------------------+--------------+
+ *  |  footer/west   |  footer/center    | footer/east  |
+ *  +----------------+-------------------+--------------+</pre>
+ *
+ */
+export interface TableModelIf {
+    changeColumnOrder(sourceColumnIndex: number, targetColumnIndex: number): void;
+    isSortable(colIdx: number): boolean;
+    init(): void;
+    getColumnCount(): number;
+    getColumnWidth(columnIndex: number): number;
+    getXPosByColumnIndex(columnIndex: number): number;
+    getAreaModel(rowAreaIdent: AreaIdent): AreaModelIf;
+    getBodyModel(): AreaModelIf;
+    getFixedLeftColumnCount(): number;
+    getFixedRightColumnCount(): number;
+    isHeaderVisibe(): boolean;
+    isFooterVisibe(): boolean;
+    isRowCheckboxVisible(): boolean;
+    getRowHeight(rowAreaIdent: AreaIdent, rowIndex: number): number;
+    getColumnDef(index: number): ColumnDefIf | undefined;
+    getColumnDefs(): ColumnDefIf[] | undefined;
+    getColumnProperty(columnIndex: number): string;
+    getBodyRowByIndex(rowIndex: number): any;
+    getColumnWidth(columnIndex: number): number;
+    setColumnWidth(columnIndex: number, width: number): void;
+    recalcSize(clientWidth: number): void;
+    recalcPadding(): void;
+    recalcHeightAndPadding(): void;
+    getPadding(): Padding;
+    getContentHeightInPixel(): number;
+    getContentWidthInPixel(): number;
+    externalFilterChanged<T>(predictFn: FilterFunction<T>): void;
+    doSort(sortItems: SortItem[]): boolean;
+    getSelectionModel(): SelectionModelIf | undefined;
+}

package/lib/table/ele-scope.d.ts

@@ -0,0 +1,37 @@
+import { ConvenienceDomService } from "./service/convenience-dom.service";
+import { DivScope } from "./data/div-scope.type";
+import { TableModelIf } from "./data/tablemodel/table-model.if";
+import { TableOptionsIf } from "./data/options/table-options.if";
+import { GeoData } from "./data/geo-data";
+export declare class EleScope {
+    readonly hostElement: HTMLDivElement;
+    readonly tableModel: TableModelIf;
+    protected readonly dom: ConvenienceDomService;
+    readonly tableOptions: TableOptionsIf;
+    scrollViewport: HTMLDivElement;
+    protected contentWrapperDiv: HTMLDivElement;
+    protected contentDiv: HTMLDivElement;
+    protected areaHeaderCenter: DivScope;
+    protected areaHeaderWest: DivScope;
+    protected areaHeaderEast: DivScope;
+    protected areaBodyCenter: DivScope;
+    protected areaBodyWest: DivScope;
+    protected areaBodyEast: DivScope;
+    protected areaFooterCenter: DivScope;
+    protected areaFooterWest: DivScope;
+    protected areaFooterEast: DivScope;
+    protected borderHeaderBottom: HTMLDivElement;
+    protected borderFooterTop: HTMLDivElement;
+    protected borderFixedWest: HTMLDivElement;
+    protected borderFixedEast: HTMLDivElement;
+    protected hoverRow: HTMLDivElement;
+    protected hoverColumn: HTMLDivElement;
+    protected scrollTop: number;
+    protected areaBodyWestGeo: GeoData;
+    protected areaBodyCenterGeo: GeoData;
+    protected areaBodyEastGeo: GeoData;
+    constructor(hostElement: HTMLDivElement, tableModel: TableModelIf, dom: ConvenienceDomService, tableOptions: TableOptionsIf);
+    adjustContainersAndRows(): void;
+    adjustAfterScrolling(): void;
+    protected resetSizeOfWrapperDiv(): void;
+}

package/lib/table/event-adapter.d.ts

@@ -0,0 +1,12 @@
+import { GeModelChangeEvent } from "./data/common/event/ge-model-change-event";
+import { GeMouseEvent } from "./data/common/event/ge-mouse-event";
+import { EventListenerIf } from "./event-listener.if";
+export declare class EventAdapter implements EventListenerIf {
+    onCheckboxChanged(_evt: any[]): void;
+    onContextmenu(_evt: GeMouseEvent): void;
+    onModelChanged(_evt: GeModelChangeEvent): void;
+    onMouseClicked(_evt: GeMouseEvent): void;
+    onMouseDragging(_evt: GeMouseEvent): void;
+    onMouseDraggingEnd(_evt: GeMouseEvent): void;
+    onMouseMoved(_evt: GeMouseEvent): void;
+}

package/lib/table/event-listener.if.d.ts

@@ -0,0 +1,11 @@
+import { GeMouseEvent } from "./data/common/event/ge-mouse-event";
+import { GeModelChangeEvent } from "./data/common/event/ge-model-change-event";
+export interface EventListenerIf {
+    onContextmenu(evt: GeMouseEvent): void;
+    onMouseMoved(evt: GeMouseEvent): void;
+    onMouseDraggingEnd(evt: GeMouseEvent): void;
+    onMouseDragging(evt: GeMouseEvent): void;
+    onMouseClicked(evt: GeMouseEvent): void;
+    onCheckboxChanged(evt: any[]): void;
+    onModelChanged(evt: GeModelChangeEvent): void;
+}

package/lib/table/factory/table-factory.d.ts

@@ -0,0 +1,65 @@
+import { AreaModelIf } from "../data/tablemodel/areamodel/area-model.if";
+import { DefaultRowHeightsIf } from "../data/options/default-row-heights.if";
+import { ColumnDefIf } from "../data/tablemodel/column/column-def.if";
+import { GetT } from "../data/common/get-t";
+import { TableOptionsIf } from "../data/options/table-options.if";
+import { TableModelIf } from "../data/tablemodel/table-model.if";
+import { TableModel } from "../data/tablemodel/table-model";
+import { SelectionModelIf } from "../selection/selection-model.if";
+export declare class TableFactory {
+    static createTableModel(p: Partial<{
+        headerAreaModel: AreaModelIf;
+        bodyAreaModel: AreaModelIf;
+        footerAreaModel: AreaModelIf;
+        fixedLeftColumnCount: number;
+        fixedRightColumnCount: number;
+        rowCheckboxVisible: boolean;
+        defaultRowHeights: DefaultRowHeightsIf;
+        columnDefs: ColumnDefIf[];
+        columnSizes: number[];
+        overridingColumnWidth: number;
+        columnCount: number;
+        parentSize: number;
+        getSelectionModel: GetT<SelectionModelIf>;
+        rows: any[];
+        properties: string[];
+        bodyData: any[][];
+        headerData: string[][];
+        footerData: string[][];
+        tableOptions: TableOptionsIf;
+    }>): TableModelIf;
+    static buildByTypedRowsParam<T>(param: {
+        rows: T[];
+        columnDefs: ColumnDefIf[];
+        tableOptions?: TableOptionsIf;
+        fixedLeftColumnCount?: number;
+        fixedRightColumnCount?: number;
+    }): TableModelIf;
+    static buildByTypedRows<T>(rows: T[], columnDefs: ColumnDefIf[], tableOptions?: TableOptionsIf, fixedLeftColumnCount?: number, fixedRightColumnCount?: number): TableModelIf;
+    static createByObjectArrayParam<T>(param: {
+        rows: T[];
+        header?: string[][];
+        footer?: string[][];
+        fixedLeftColumnCount?: number;
+        fixedRightColumnCount?: number;
+        rowCheckboxVisible?: boolean;
+        defaultRowHeights?: DefaultRowHeightsIf;
+        columnDefs?: ColumnDefIf[];
+        columnSizes?: number[];
+    }): TableModel;
+    static createByAreaModels(headerAreaModel: AreaModelIf | undefined, bodyAreaModel: AreaModelIf, footerAreaModel: AreaModelIf | undefined, fixedLeftColumnCount: number | undefined, fixedRightColumnCount: number | undefined, rowCheckboxVisible: boolean | undefined, defaultRowHeights: DefaultRowHeightsIf | undefined, columnDefs: ColumnDefIf[], columnSizes: number[] | undefined, overridingColumnWidth: number | undefined, columnCount: number): TableModel;
+    static createByAreaModelsParam(param: {
+        headerAreaModel?: AreaModelIf;
+        bodyAreaModel: AreaModelIf;
+        footerAreaModel?: AreaModelIf;
+        fixedLeftColumnCount?: number;
+        fixedRightColumnCount?: number;
+        rowCheckboxVisible?: boolean;
+        defaultRowHeights?: DefaultRowHeightsIf;
+        columnDefs?: ColumnDefIf[];
+        columnSizes?: number[];
+        overridingColumnWidth?: number;
+        columnCount?: number;
+    }): TableModel;
+    static createByObjectArray<T>(rows: T[], header: string[][] | undefined, footer: string[][] | undefined, fixedLeftColumnCount: number | undefined, fixedRightColumnCount: number | undefined, rowCheckboxVisible: boolean | undefined, defaultRowHeights: DefaultRowHeightsIf | undefined, columnDefs: ColumnDefIf[], columnSizes?: number[]): TableModel;
+}

package/lib/table/factory/tree-factory.d.ts

@@ -0,0 +1,6 @@
+import { TreeRow } from "../data/common/tree-row";
+export declare class TreeFactory {
+    static buildTreeRows<T>(data: T[], childrenProperty?: string, deepMaxLimit?: number): TreeRow<T>[];
+    static buildTreeRow<T>(data: T, childrenProperty?: string, parent?: TreeRow<T>, //, false , '0', '0'),
+    deep?: number, deepMaxLimit?: number): TreeRow<T>;
+}

package/lib/table/focus/focus-model.d.ts

@@ -0,0 +1,15 @@
+import { FocusType } from "./focus.type";
+import { FocusModelIf } from "./focus-model.if";
+export declare class FocusModel implements FocusModelIf {
+    selectionType: FocusType;
+    protected rowIndex: number;
+    protected columnIndex: number;
+    protected changed: boolean;
+    constructor(selectionType?: FocusType);
+    clearChanged(): void;
+    hasChanged(): boolean;
+    clear(): void;
+    setFocus(rowIndex: number, columnIndex: number): void;
+    hasFocus(rowIndex: number, columnIndex: number): boolean;
+    getFocus(): [number, number];
+}

package/lib/table/focus/focus-model.if.d.ts

@@ -0,0 +1,8 @@
+export interface FocusModelIf {
+    clear(): void;
+    setFocus(rowIndex: number, columnIndex: number): void;
+    hasFocus(rowIndex: number, columnIndex: number): boolean;
+    getFocus(): [number, number];
+    hasChanged(): boolean;
+    clearChanged(): void;
+}

package/{src/lib/table/focus/focus.type.ts → lib/table/focus/focus.type.d.ts}

@@ -1,4 +1 @@
 export type FocusType = "none" | "cell" | "row";
-
-
-

package/lib/table/input-handler.d.ts

@@ -0,0 +1,6 @@
+import { TableScope } from "./table-scope";
+export declare class InputHandler {
+    protected tableScope: TableScope;
+    constructor(tableScope: TableScope);
+    private onHostElementChanged;
+}

package/lib/table/mouse-handler.d.ts

@@ -0,0 +1,25 @@
+import { TableScope } from "./table-scope";
+import { GeMouseEvent } from "./data/common/event/ge-mouse-event";
+export declare class MouseHandler {
+    protected tableScope: TableScope;
+    mouseEvent?: MouseEvent;
+    startMouseEvent?: GeMouseEvent;
+    geMouseEvent?: GeMouseEvent;
+    geMouseEventOld?: GeMouseEvent;
+    private expandedAll;
+    private mouseDown;
+    private dragging;
+    constructor(tableScope: TableScope);
+    private onContextmenu;
+    private onHostElementClicked;
+    private onHostElementDblClicked;
+    private publishGeMouseEvent;
+    private updateCollapsedExpandedState;
+    private getArrowColumnIndex;
+    private onMouseDown;
+    private onMouseMove;
+    private onMouseUp;
+    private mouseDraggingOnFrame;
+    private mouseDraggingEndOnFrame;
+    private mouseMoveOnFrame;
+}

package/lib/table/render-scope.d.ts

@@ -0,0 +1,86 @@
+import { EleScope } from "./ele-scope";
+import { TableModelIf } from "./data/tablemodel/table-model.if";
+import { ConvenienceDomService } from "./service/convenience-dom.service";
+import { TableOptionsIf } from "./data/options/table-options.if";
+import { CellRange } from "./data/common/cell-range";
+import { RendererCleanupFnType } from "./renderer/renderer-cleanup-fn.type";
+import { AreaIdent } from "./data/tablemodel/area-ident.type";
+import { SideIdent } from "./data/side-ident.type";
+import { DivScope } from "./data/div-scope.type";
+import { AreaModelIf } from "./data/tablemodel/areamodel/area-model.if";
+import { ArgsAdjustColumnsToRowParentParams } from "./data/common/args-adjust-columns-to-row-parent-params";
+import { ArgsRenderCellDiv } from "./data/common/args-render-cell-div";
+import { StoreStateScrollPosService } from "./service/store-state-scroll-pos.service";
+import { GeMouseEvent } from "./data/common/event/ge-mouse-event";
+import { SelectionModelIf } from "./selection/selection-model.if";
+import { GetT } from "./data/common/get-t";
+import { FocusModelIf } from "./focus/focus-model.if";
+import { ColAndRowspanModel } from "./data/tablemodel/areamodel/col-and-rowspan-model";
+import { AreaObjectMapType } from "./data/common/area-map.type";
+import { TableCellUpdateEventIf } from "./data/common/event/input/table-cell-update-event.if";
+export declare class RenderScope extends EleScope {
+    protected storeScrollPosStateService?: StoreStateScrollPosService;
+    protected getSelectionModel?: GetT<SelectionModelIf>;
+    protected getFocusModel?: GetT<FocusModelIf>;
+    protected scrollLeft: number;
+    protected scrollViewportLeft: number;
+    protected scrollFactorY: number;
+    protected scrollFactorX: number;
+    protected readonly cleanupFunctions: {
+        header: (RendererCleanupFnType)[];
+        body: (RendererCleanupFnType)[];
+        footer: (RendererCleanupFnType)[];
+    };
+    protected tree: boolean;
+    protected colAndRowspanModels: AreaObjectMapType<ColAndRowspanModel>;
+    protected firstVisibleRowIndex: number;
+    protected draggingTargetColumnIndex: number;
+    protected mouseEvent?: GeMouseEvent;
+    private debounceTimeout?;
+    private editorRenderer?;
+    private editorRendererColumn?;
+    private editorRendererRow?;
+    private removables;
+    constructor(hostElement: HTMLDivElement, tableModel: TableModelIf, dom: ConvenienceDomService, tableOptions: TableOptionsIf);
+    protected editing: boolean;
+    isEditing(): boolean;
+    resetEditorRenderer(): void;
+    clearSelection(): void;
+    initRenderEditor(rowIdx: number, colIdx: number): void;
+    repaint(): void;
+    adjustAfterScrolling(): void;
+    checkForScrollPosSaving(): void;
+    updateCells(events: TableCellUpdateEventIf[]): void;
+    protected getAreaAndSideIdentByAttr(srcElement: HTMLElement): [AreaIdent | undefined, SideIdent | undefined];
+    protected getArea(rowIdent: AreaIdent, sideIdent: SideIdent): DivScope;
+    protected adjustBody(): void;
+    protected getNumberByAttr(srcElement: HTMLElement, key: string): number;
+    protected getStringByAttr(srcElement: HTMLElement, key: string): string;
+    protected adjustArea(areaIdent: AreaIdent, yStart?: number): void;
+    /**
+     * Draws big cells (rowspan and or colspan) in body/center
+     * @param range CellRange
+     * @param xStart X position in pixel for top left corner
+     * @param yStart Y position in pixel for top left corner
+     * @param areaModel AreaModelIf
+     * @param parentDiv Parent div as HTMLDivElement
+     * @param sideIdent SideIdent (west,center,east)
+     * @protected
+     */
+    protected drawBigCell(range: CellRange, xStart: number, yStart: number, areaModel: AreaModelIf, parentDiv: HTMLDivElement, sideIdent: SideIdent): void;
+    protected findRowOfImportantRowspanCell(areaModel: AreaModelIf, rowIndex: number, colIndex: number): number;
+    protected adjustColumnsToRowParent({ areaIdent, sideIdent, areaModel, geo, parent, rowIndex, columnIndexStart, columnIndexEnd, verticalFixed, lastRowOfModel }: ArgsAdjustColumnsToRowParentParams): void;
+    protected getTreeArrowColumnIndex(): 0 | 1;
+    protected addAndRenderCellDiv({ areaModel, areaIdent, sideIdent, rowIndex, index, left, width, height, top, parent, lastRowOfModel }: ArgsRenderCellDiv): [HTMLDivElement, RendererCleanupFnType | undefined];
+    protected getColumnWidths(startIndex: number, endIndex: number): number[];
+    protected getRowHeights(startIndex: number, endIndex: number, areaModel: AreaModelIf): number[];
+    protected adjustHoverRows(mouseMoveEvent: GeMouseEvent): void;
+    protected hideHoverRow(): void;
+    protected adjustHoverColumns(mouseMoveEvent: GeMouseEvent): void;
+    protected hideHoverColumn(): void;
+    protected debounce(fn: Function, delay?: number): void;
+    private renderDragTargetDiv;
+    private renderSelectedBackgroundDiv;
+    private renderCell;
+    private renderHeaderCellResizeHandle;
+}

package/lib/table/renderer/cell-group-ext-cell-renderer.d.ts

@@ -0,0 +1,9 @@
+import { AreaModelIf } from "../data/tablemodel/areamodel/area-model.if";
+import { CellRendererIf } from "./cell-render.if";
+import { DomServiceIf } from "../service/dom-service.if";
+import { AreaIdent } from "../data/tablemodel/area-ident.type";
+import { RendererCleanupFnType } from "./renderer-cleanup-fn.type";
+import { CellGroupExt } from "../data/tablemodel/cellgroup/cell-group-ext";
+export declare class CellGroupExtCellRenderer implements CellRendererIf {
+    render(cellDiv: HTMLDivElement, _rowIndex: number, _columnIndex: number, _areaIdent: AreaIdent, _areaModel: AreaModelIf, cellValue: CellGroupExt | undefined | null, _domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/{src/lib/table/renderer/cell-render.if.ts → lib/table/renderer/cell-render.if.d.ts}

@@ -2,15 +2,6 @@ import { AreaModelIf } from "../data/tablemodel/areamodel/area-model.if";
 import { DomServiceIf } from "../service/dom-service.if";
 import { AreaIdent } from "../data/tablemodel/area-ident.type";
 import { RendererCleanupFnType } from "./renderer-cleanup-fn.type";
-
 export interface CellRendererIf {
-
-  render(
-    cellDiv: HTMLDivElement,
-    rowIndex: number,
-    columnIndex: number,
-    areaIdent: AreaIdent,
-    areaModel: AreaModelIf,
-    cellValue: any,
-    domService: DomServiceIf): RendererCleanupFnType | undefined;
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
 }

package/lib/table/renderer/checkbox-boolean-property-cell-renderer.d.ts

@@ -0,0 +1,15 @@
+import { CellRendererIf } from "./cell-render.if";
+import { DomServiceIf } from "../service/dom-service.if";
+import { AreaIdent } from "../data/tablemodel/area-ident.type";
+import { RendererCleanupFnType } from "./renderer-cleanup-fn.type";
+import { AreaModelObjectyArray } from "../data/tablemodel/areamodel/area-model-object-array";
+/**
+ * Works with AreaModelObjectArray only
+ */
+export declare class CheckboxBooleanPropertyCellRenderer<T> implements CellRendererIf {
+    property: string;
+    skipCheckableCheck: boolean;
+    readonly: boolean;
+    constructor(property: string, skipCheckableCheck?: boolean, readonly?: boolean);
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelObjectyArray<T>, _cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/lib/table/renderer/checkbox-cell-renderer.d.ts

@@ -0,0 +1,8 @@
+import { AreaModelIf } from "../data/tablemodel/areamodel/area-model.if";
+import { CellRendererIf } from "./cell-render.if";
+import { DomServiceIf } from "../service/dom-service.if";
+import { AreaIdent } from "../data/tablemodel/area-ident.type";
+import { RendererCleanupFnType } from "./renderer-cleanup-fn.type";
+export declare class CheckboxCellRenderer implements CellRendererIf {
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, _cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/lib/table/renderer/date-to-int-date-cell-renderer.d.ts

@@ -0,0 +1,9 @@
+import { CellRendererIf } from "./cell-render.if";
+import { AreaModelIf } from "../data/tablemodel/areamodel/area-model.if";
+import { DomServiceIf } from "../service/dom-service.if";
+import { AreaIdent } from "../data/tablemodel/area-ident.type";
+import { RendererCleanupFnType } from "./renderer-cleanup-fn.type";
+export declare class DateToIntlDDMMYYYYCellRenderer implements CellRendererIf {
+    readonly formatter: Intl.DateTimeFormat;
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, _areaModel: AreaModelIf, cellValue: any, _domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/lib/table/renderer/date-to-iso-cell-renderer.d.ts

@@ -0,0 +1,8 @@
+import { CellRendererIf } from "./cell-render.if";
+import { AreaModelIf } from "../data/tablemodel/areamodel/area-model.if";
+import { DomServiceIf } from "../service/dom-service.if";
+import { AreaIdent } from "../data/tablemodel/area-ident.type";
+import { RendererCleanupFnType } from "./renderer-cleanup-fn.type";
+export declare class DateToIsoCellRenderer implements CellRendererIf {
+    render(cellDiv: HTMLDivElement, _rowIndex: number, _columnIndex: number, _areaIdent: AreaIdent, _areaModel: AreaModelIf, cellValue: any, _domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/lib/table/renderer/date-to-locale-date-cell-renderer.d.ts

@@ -0,0 +1,8 @@
+import { CellRendererIf } from "./cell-render.if";
+import { AreaModelIf } from "../data/tablemodel/areamodel/area-model.if";
+import { DomServiceIf } from "../service/dom-service.if";
+import { AreaIdent } from "../data/tablemodel/area-ident.type";
+import { RendererCleanupFnType } from "./renderer-cleanup-fn.type";
+export declare class DateToLocaleDateCellRenderer implements CellRendererIf {
+    render(cellDiv: HTMLDivElement, _rowIndex: number, _columnIndex: number, _areaIdent: AreaIdent, _areaModel: AreaModelIf, cellValue: any, _domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/lib/table/renderer/date-to-tec-cell-renderer.d.ts

@@ -0,0 +1,8 @@
+import { CellRendererIf } from "./cell-render.if";
+import { AreaModelIf } from "../data/tablemodel/areamodel/area-model.if";
+import { DomServiceIf } from "../service/dom-service.if";
+import { AreaIdent } from "../data/tablemodel/area-ident.type";
+import { RendererCleanupFnType } from "./renderer-cleanup-fn.type";
+export declare class DateToTecCellRenderer implements CellRendererIf {
+    render(cellDiv: HTMLDivElement, _rowIndex: number, _columnIndex: number, _areaIdent: AreaIdent, _areaModel: AreaModelIf, cellValue: any, _domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/{src/lib/table/renderer/edit/edit-cell-renderer.type.ts → lib/table/renderer/edit/edit-cell-renderer.type.d.ts}

@@ -1,3 +1,2 @@
 import { CellRendererIf } from "../cell-render.if";
-
 export type GetEditRenderer = (rowIndex: number, columnIndex: number) => CellRendererIf | undefined;

package/lib/table/renderer/edit/edit-input-pipe-for-number.d.ts

@@ -0,0 +1,2 @@
+import { editInputPipe } from "./edit-input-pipe.if";
+export declare const editInputPipeForNumber: editInputPipe;

package/lib/table/renderer/edit/edit-input-pipe.if.d.ts

@@ -0,0 +1,3 @@
+export interface editInputPipe {
+    (input: any, rowIndex: number, columnIndex: number): any | undefined;
+}

package/lib/table/renderer/edit/input-cell-renderer.d.ts

@@ -0,0 +1,8 @@
+import { CellRendererIf } from "../cell-render.if";
+import { AreaIdent } from "../../data/tablemodel/area-ident.type";
+import { AreaModelIf } from "../../data/tablemodel/areamodel/area-model.if";
+import { DomServiceIf } from "../../service/dom-service.if";
+import { RendererCleanupFnType } from "../renderer-cleanup-fn.type";
+export declare class InputCellRenderer implements CellRendererIf {
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, _cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}