@guiexpert/table 0.0.1

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

@@ -0,0 +1,46 @@
+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";
+export declare class ColumnDef<T> implements ColumnDefIf {
+    property: string;
+    headerLabel: string;
+    width: SizeIf;
+    classes: AreaObjectMapType<string[]>;
+    rendererMap: AreaObjectMapType<CellRendererIf>;
+    minWidth: SizeIf;
+    maxWidth: SizeIf;
+    sortable?: BooleanFunction | undefined;
+    sortComparator?: (<T_1>(a: T_1, b: T_1) => number) | undefined;
+    sortState?: SortState | undefined;
+    sortStatesOrder?: SortState[] | undefined;
+    sortIconVisible?: BooleanFunction | undefined;
+    editable?: BooleanFunction | undefined;
+    getEditRenderer?: GetEditRenderer | undefined;
+    constructor(property: string, headerLabel: string, width?: SizeIf, classes?: AreaObjectMapType<string[]>, rendererMap?: AreaObjectMapType<CellRendererIf>, minWidth?: SizeIf, maxWidth?: SizeIf, sortable?: BooleanFunction | undefined, sortComparator?: (<T_1>(a: T_1, b: T_1) => number) | undefined, sortState?: SortState | undefined, sortStatesOrder?: SortState[] | undefined, sortIconVisible?: BooleanFunction | undefined, editable?: BooleanFunction | undefined, getEditRenderer?: GetEditRenderer | undefined);
+    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;
+        getEditRenderer?: GetEditRenderer;
+    }): ColumnDefIf;
+}

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

@@ -0,0 +1,22 @@
+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";
+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;
+    getEditRenderer?: GetEditRenderer;
+}

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,60 @@
+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";
+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 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);
+    init(): void;
+    getColumnCount(): number;
+    setColumnWidth(columnIndex: number, width: number): void;
+    getColumnWidth(columnIndex: number): number;
+    getXPosByColumnIndex(columnIndex: number): number;
+    recalcSize(clientWidth: number): 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 arrayMove;
+    private recalcContentWidthInPx;
+    private calcXPositions;
+}

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

@@ -0,0 +1,34 @@
+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";
+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;
+    getPadding(): Padding;
+    getContentHeightInPixel(): number;
+    getContentWidthInPixel(): number;
+    externalFilterChanged<T>(predictFn: FilterFunction<T>): void;
+    doSort(sortItems: SortItem[]): boolean;
+}

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-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/focus/focus-model.d.ts

@@ -0,0 +1,12 @@
+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;
+    constructor(selectionType?: FocusType);
+    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,6 @@
+export interface FocusModelIf {
+    clear(): void;
+    setFocus(rowIndex: number, columnIndex: number): void;
+    hasFocus(rowIndex: number, columnIndex: number): boolean;
+    getFocus(): [number, number];
+}

package/lib/table/focus/focus.type.d.ts

@@ -0,0 +1 @@
+export declare 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,27 @@
+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 lastRowIndex;
+    private lastColumnIndex;
+    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,77 @@
+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";
+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 rangeEles: HTMLDivElement[];
+    protected colAndRowspanModel?: ColAndRowspanModel;
+    protected firstVisibleRowIndex: number;
+    protected draggingTargetColumnIndex: number;
+    private debounceTimeout?;
+    private editorRenderer?;
+    private editorRendererColumn?;
+    private editorRendererRow?;
+    constructor(hostElement: HTMLDivElement, tableModel: TableModelIf, dom: ConvenienceDomService, tableOptions: TableOptionsIf);
+    resetEditorRenderer(): void;
+    clearSelection(): void;
+    initRenderEditor(rowIdx: number, colIdx: number): void;
+    repaint(): void;
+    adjustAfterScrolling(): void;
+    checkForScrollPosSaving(): 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 mouseEvent?: GeMouseEvent;
+    protected adjustArea(areaIdent: AreaIdent, yStart?: number): void;
+    /**
+     * Draws big cells (rowspan and or colspan) in body/center
+     * @param range
+     * @param yStart
+     * @protected
+     */
+    protected drawBigCell(range: CellRange, xStart: number, yStart: number, areaModel: AreaModelIf, parentDiv: HTMLDivElement): void;
+    protected findRowOfImportantRowspanCell(areaModel: AreaModelIf, rowIndex: number, colIndex: number): number;
+    protected adjustColumnsToRowParent({ areaIdent, sideIdent, areaModel, geo, parent, rowIndex, columnIndexStart, columnIndexEnd, verticalFixed, firstVisibleRow }: ArgsAdjustColumnsToRowParentParams): void;
+    protected getTreeArrowColumnIndex(): 0 | 1;
+    protected addAndRenderCellDiv({ areaModel, areaIdent, rowIndex, index, left, width, height, top, parent }: 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;
+    private sum;
+}

package/lib/table/renderer/cell-render.if.d.ts

@@ -0,0 +1,7 @@
+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<T>(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, 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/edit/edit-cell-renderer.type.d.ts

@@ -0,0 +1,2 @@
+import { CellRendererIf } from "../cell-render.if";
+export declare type GetEditRenderer = (rowIndex: number, columnIndex: number) => CellRendererIf | 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;
+}

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

@@ -0,0 +1,12 @@
+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";
+import { ValueLabelIf } from "../../data/common/value-label.if";
+export declare class SelectCellRenderer implements CellRendererIf {
+    protected options: ValueLabelIf[];
+    constructor(options: ValueLabelIf[]);
+    static create(values: string[]): SelectCellRenderer;
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/lib/table/renderer/male-female-to-icon-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 MaleFemaleToIconCellRenderer implements CellRendererIf {
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

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

@@ -0,0 +1,11 @@
+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 NumberCellRenderer implements CellRendererIf {
+    protected min: number;
+    protected max: number;
+    constructor(min?: number, max?: number);
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/lib/table/renderer/renderer-cleanup-fn.type.d.ts

@@ -0,0 +1 @@
+export declare type RendererCleanupFnType = Function;

package/lib/table/renderer/renderer.d.ts

@@ -0,0 +1,5 @@
+import { CellRendererIf } from "./cell-render.if";
+import { AreaObjectMap } from "../data/common/area-map";
+export declare class Renderer {
+    static bodyRenderer(bodyCellRenderer: CellRendererIf): AreaObjectMap<CellRendererIf>;
+}

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

@@ -0,0 +1,21 @@
+import { CellRange } from "../data/common/cell-range";
+import { SelectionMode, SelectionType } from "./selection.type";
+import { SelectionModelIf } from "./selection-model.if";
+export declare class SelectionModel implements SelectionModelIf {
+    selectionType: SelectionType;
+    selectionMode: SelectionMode;
+    protected ranges: CellRange[];
+    protected negativeRanges: CellRange[];
+    protected allSelected: boolean;
+    constructor(selectionType?: SelectionType, selectionMode?: SelectionMode);
+    getSelectionCount(rowIndex: number, columnIndex: number): number;
+    isInNegativeRange(rowIndex: number, columnIndex: number): boolean;
+    getRanges(): CellRange[];
+    clear(): void;
+    hasSelection(): boolean;
+    selectAll(): void;
+    addSelection(range: CellRange): void;
+    removeSelection(range: CellRange): void;
+    togglePoint(row: number, col: number): void;
+    private addRange;
+}

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

@@ -0,0 +1,11 @@
+import { CellRange } from "../data/common/cell-range";
+export interface SelectionModelIf {
+    togglePoint(row: number, col: number): void;
+    getRanges(): CellRange[];
+    clear(): void;
+    hasSelection(): boolean;
+    addSelection(range: CellRange): void;
+    removeSelection(range: CellRange): void;
+    getSelectionCount(rowIndex: number, columnIndex: number): number;
+    selectAll(): void;
+}

package/lib/table/selection/selection-service.d.ts

@@ -0,0 +1,17 @@
+import { GeMouseEvent } from "../data/common/event/ge-mouse-event";
+import { TableScope } from "../table-scope";
+import { GetT } from "../data/common/get-t";
+import { SelectionModelIf } from "./selection-model.if";
+import { FocusModelIf } from "../focus/focus-model.if";
+import { OnActionTriggeredIf } from "../action/on-action-triggered.if";
+import { ActionId } from "../action/action-id.type";
+export declare class SelectionService implements OnActionTriggeredIf {
+    protected readonly tableScope: TableScope;
+    protected getSelectionModel?: GetT<SelectionModelIf>;
+    protected getFocusModel?: GetT<FocusModelIf>;
+    protected previousEvt?: GeMouseEvent;
+    constructor(tableScope: TableScope);
+    onMouseClicked(evt: GeMouseEvent, _previousEvt: GeMouseEvent | undefined): boolean;
+    onActionTriggered(actionId: ActionId): boolean;
+    private createRangeByEvents;
+}

package/lib/table/selection/selection.type.d.ts

@@ -0,0 +1,2 @@
+export declare type SelectionType = "none" | "cell" | "row" | "column" | "range";
+export declare type SelectionMode = "single" | "multi";

package/lib/table/service/abstract-store-state.service.d.ts

@@ -0,0 +1,10 @@
+import { GetStorageKeyFn } from "../data/options/auto-restore-options.if";
+export declare abstract class AbstractStoreStateService {
+    protected getStorageKeyFn?: undefined | GetStorageKeyFn;
+    constructor(fn: GetStorageKeyFn | undefined);
+    autoConvertMapToObject(item: any): {};
+    protected abstract load(): void;
+    protected checkAndPersistItem(keySuffix: string, item: any): void;
+    protected persistItem(subKey: string, item: string | object): void;
+    protected loadFromLocalStorage<U>(subKey: string): U | null;
+}

package/lib/table/service/convenience-dom.service.d.ts

@@ -0,0 +1,44 @@
+import { DomServiceIf } from "./dom-service.if";
+import { DivScope } from "./../data/div-scope.type";
+import { GeoData } from "./../data/geo-data";
+import { TreeArrowType } from "../data/common/tree-arrow.type";
+import { TreeOptionsIf } from "../data/options/tree-options.if";
+import { AreaIdent } from "../data/tablemodel/area-ident.type";
+import { TableOptionsIf } from "../data/options/table-options.if";
+import { CheckedType } from "../data/common/checked-type";
+import { SideIdent } from "../data/side-ident.type";
+import { SortState } from "../data/common/sort-state.type";
+import { SortedOptionsIf } from "../data/options/sorted-options.if";
+import { HtmlStyle } from "./data/html-style.type";
+export declare class ConvenienceDomService {
+    readonly domService: DomServiceIf;
+    constructor(domService: DomServiceIf);
+    setStyle(el: any, style: string, value: any): any;
+    applyStyle(ele: HTMLDivElement, style: HtmlStyle): HTMLDivElement;
+    applyDisplayNoneStyle(ele: HTMLDivElement): HTMLDivElement;
+    applyDisplayBlockStyle(ele: HTMLDivElement): HTMLDivElement;
+    applyStyleInPx(ele: HTMLDivElement, geoData: GeoData): HTMLDivElement;
+    applyStylePosistionRelative(ele: HTMLDivElement): HTMLDivElement;
+    applyStylePosistionAbsolute(ele: HTMLDivElement): HTMLDivElement;
+    applyStyleFullSize(ele: HTMLDivElement): HTMLDivElement;
+    applyStyleOverflowAuto(overflowX: "auto" | "scroll" | undefined, overflowY: "auto" | "scroll" | undefined, ele: HTMLDivElement): HTMLDivElement;
+    applyStyleNoPadding(ele: HTMLDivElement): HTMLDivElement;
+    appendRelativeChildDiv(parent: HTMLDivElement): DivScope;
+    appendText(parent: HTMLDivElement, text: string): HTMLElement;
+    addClass(clazz: string, div: HTMLDivElement): HTMLDivElement;
+    addClasses(classes: string[] | undefined, div: HTMLDivElement): HTMLDivElement;
+    setAttribute(div: HTMLDivElement, key: string, value: string): HTMLDivElement;
+    createAreaDivWithClass(clazz: string, parent: HTMLDivElement, areaIdent: AreaIdent, sideIdent: SideIdent): HTMLDivElement;
+    createDivWithClass(clazz: string, parent: HTMLDivElement): HTMLDivElement;
+    addRowDiv(divScope: DivScope, geo: GeoData, rowIndex: number | undefined, areaIdent: AreaIdent, text?: string): HTMLDivElement;
+    addColumnDiv<T>(parent: HTMLDivElement, geo: GeoData, rowIndex: number | undefined, columnIndex: number | undefined, areaIdent: AreaIdent, text?: string, treeArrow?: TreeArrowType, tableOptions?: TableOptionsIf, checkedType?: CheckedType | undefined, sortState?: SortState): HTMLDivElement;
+    addCheckboxToDiv(parent: HTMLDivElement, checkedType: CheckedType, areaIdent: AreaIdent, rowIndex: number): HTMLDivElement;
+    addLabelDiv(parent: HTMLDivElement, text?: string, firstTreeColumn?: boolean, rowIndex?: number, columnIndex?: number, areaIdent?: AreaIdent): HTMLDivElement;
+    addSortedIcon(parent: HTMLDivElement, sorted?: SortState, sortedOptions?: SortedOptionsIf, columnIndex?: number): HTMLDivElement;
+    addArrowDiv(parent: HTMLDivElement, arrow?: TreeArrowType, treeOptions?: TreeOptionsIf, rowIndex?: number, columnIndex?: number, areaIdent?: AreaIdent): HTMLDivElement;
+    addColumnBorderDivs(parent: HTMLDivElement, geo: GeoData): HTMLDivElement;
+    addFocusBorderDivs(parent: HTMLDivElement, geo: GeoData, style: HtmlStyle): HTMLDivElement;
+    addDiv(parent: HTMLDivElement, geo: GeoData, clazz?: string): HTMLDivElement;
+    applyStyleString(div: HTMLDivElement, style: string): void;
+    private getDivOrCreateDiv;
+}

package/lib/table/service/data/collapsed-expanded.data.d.ts

@@ -0,0 +1,7 @@
+export declare class CollapsedExpandedData {
+    mode: 'collapsed' | 'expanded';
+    rowIds: Array<string | number>;
+    allCollapsed: boolean;
+    allExpanded: boolean;
+    constructor(mode?: 'collapsed' | 'expanded', rowIds?: Array<string | number>, allCollapsed?: boolean, allExpanded?: boolean);
+}

package/lib/table/service/data/html-style.type.d.ts

@@ -0,0 +1,3 @@
+export declare type HtmlStyle = {
+    [key: string]: string | number;
+};

package/lib/table/service/dom-service.if.d.ts

@@ -0,0 +1,9 @@
+export interface DomServiceIf {
+    setStyle(el: any, style: string, value: any): any;
+    addClass(div: HTMLElement, clazz: string): HTMLDivElement;
+    createElement<T>(ele: string): T;
+    createText(text: string): HTMLElement;
+    appendText(parent: HTMLDivElement, text: string): HTMLDivElement;
+    appendChild(parent: HTMLElement, child: HTMLElement): void;
+    setAttribute(ele: HTMLElement, key: string, value: string): void;
+}

package/lib/table/service/ge-filter.service.d.ts

@@ -0,0 +1,5 @@
+export declare class GeFilterService {
+    filterPredict<T>(item: T, filterString: string, toString?: (t: T) => string): boolean;
+    filterRows<T>(rows: T[], filterString: string, toString?: (t: T) => string): T[];
+    objectToString<T>(o: T): string;
+}

package/lib/table/service/sorter.service.d.ts

@@ -0,0 +1,3 @@
+export declare class SorterService {
+    genericSortComparator(va: any, vb: any, f: number): number;
+}