@guiexpert/table 1.0.3 → 1.0.6

package/esm2022/lib/table/table-scope.mjs

@@ -0,0 +1,364 @@
+import { GeMouseEvent } from "./data/common/event/ge-mouse-event";
+import { ConvenienceDomService } from "./service/convenience-dom.service";
+import { MouseHandler } from "./mouse-handler";
+import { TableApi } from "./table-api";
+import { AreaModelTree } from "./data/tablemodel/areamodel/area-model-tree";
+import { StoreStateScrollPosService } from "./service/store-state-scroll-pos.service";
+import { StoreStateCollapsedExpandService } from "./service/store-state-collapsed-expand.service";
+import { StoreStateSortingService } from "./service/store-state-sorting.service";
+import { RenderScope } from "./render-scope";
+import { SortItem } from "./data/common/sort-item";
+import { InputHandler } from "./input-handler";
+import { GeModelChangeEvent } from "./data/common/event/ge-model-change-event";
+import { SelectionService } from "./selection/selection-service";
+import { ShortcutService } from "./action/shortcut.service";
+import { EventAdapter } from "./event-adapter";
+export class TableScope extends RenderScope {
+    eventListener;
+    mouseHandler;
+    inputHandler;
+    shortcutService;
+    storeStateCollapsedExpandService;
+    storeSortingService;
+    selectionService = new SelectionService(this);
+    keyEvent;
+    api = new TableApi(this);
+    mouseStartAction = "";
+    mouseStartWidth = -1;
+    mouseStartColumnIndex = -1;
+    dragFrom = -1;
+    dragTo = -1;
+    constructor(hostElement, tableModel, domService, tableOptions, eventListener) {
+        super(hostElement, tableModel, new ConvenienceDomService(domService), tableOptions);
+        this.eventListener = eventListener;
+        if (!eventListener) {
+            this.eventListener = new EventAdapter();
+        }
+        if (this.tableOptions?.autoRestoreOptions) {
+            const autoRestoreOptions = this.tableOptions.autoRestoreOptions;
+            const keyFn = autoRestoreOptions.getStorageKeyFn;
+            if (keyFn) {
+                if (autoRestoreOptions.autoRestoreScrollPosition) {
+                    this.storeScrollPosStateService = new StoreStateScrollPosService(keyFn);
+                }
+                if (autoRestoreOptions.autoRestoreCollapsedExpandedState) {
+                    this.storeStateCollapsedExpandService = new StoreStateCollapsedExpandService(keyFn);
+                }
+                if (autoRestoreOptions.autoRestoreSortingState) {
+                    this.storeSortingService = new StoreStateSortingService(keyFn);
+                }
+            }
+        }
+        this.mouseHandler = new MouseHandler(this);
+        this.inputHandler = new InputHandler(this);
+        this.shortcutService = new ShortcutService(this);
+        this.shortcutService.addListener(this.selectionService);
+    }
+    onActionTriggered(actionId) {
+        if (actionId === "NAVIGATE_DOWN") {
+            if (this.changeFocusCell(0, 1)) {
+                return true;
+            }
+        }
+        if (actionId === "NAVIGATE_UP") {
+            if (this.changeFocusCell(0, -1)) {
+                return true;
+            }
+        }
+        if (actionId === "NAVIGATE_LEFT") {
+            if (this.changeFocusCell(-1, 0)) {
+                return true;
+            }
+        }
+        if (actionId === "NAVIGATE_RIGHT") {
+            if (this.changeFocusCell(1, 0)) {
+                return true;
+            }
+        }
+        if (actionId === "START_EDITING") {
+            if (this.getFocusModel) {
+                const fm = this.getFocusModel();
+                if (fm) {
+                    const [rowIdx, colIdx] = fm.getFocus();
+                    if (this.tableModel.getBodyModel().isEditable(rowIdx, colIdx)) {
+                        this.clearSelection();
+                        this.initRenderEditor(rowIdx, colIdx);
+                    }
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    updateModelValueAfterEdit(areaIdent, rowIndex, columnIndex, value) {
+        if (areaIdent === "body") {
+            const bodyAreaModel = this.tableModel.getAreaModel(areaIdent);
+            const ok = bodyAreaModel.setValue(rowIndex, columnIndex, value);
+            if (ok) {
+                this.resetEditorRenderer();
+                this.repaint();
+                this.eventListener.onModelChanged(GeModelChangeEvent.createSingle(rowIndex, columnIndex));
+                this.hostElement.focus();
+            }
+        }
+    }
+    getApi() {
+        return this.api;
+    }
+    /*
+     * Called by the table component
+     */
+    firstInit() {
+        this.tableModel.init();
+        if (this.tableOptions?.externalFilterFunction) {
+            this.externalFilterChanged(false);
+        }
+        this.autoRestoreCollapsedExpandedState();
+        this.autoRestoreSortingState();
+        this.resetSizeOfWrapperDiv();
+        this.adjustContainersAndRows();
+        this.autoRestoreScrollPosition();
+    }
+    createGeMouseEvent(mouseEvent) {
+        const ret = new GeMouseEvent();
+        ret.originalEvent = mouseEvent;
+        if (mouseEvent) {
+            const target = mouseEvent.target;
+            [ret.areaIdent, ret.sideIdent] = this.getAreaAndSideIdentByAttr(target);
+            ret.rowIndex = this.getNumberByAttr(target, "data-row-index");
+            ret.columnIndex = this.getNumberByAttr(target, "data-col-index");
+            ret.action = this.getStringByAttr(target, "data-ge-action");
+            // const bodyY = mouseEvent.clientY - this.hostElement.offsetTop - this.areaHeaderCenter.parent.clientHeight;
+            // const bodyX = mouseEvent.clientX - this.hostElement.offsetLeft - this.areaBodyWestGeo.width;
+            if (ret.areaIdent) {
+                const am = this.tableModel.getAreaModel(ret.areaIdent);
+                ret.rowTop = am.getYPosByRowIndex(ret.rowIndex);
+            }
+            ret.columnLeft = this.tableModel.getXPosByColumnIndex(ret.columnIndex);
+            if (mouseEvent.ctrlKey && mouseEvent.altKey) {
+                const bodyY = mouseEvent.clientY - this.hostElement.offsetTop - this.areaHeaderCenter.parent.clientHeight;
+                const bodyX = mouseEvent.clientX - this.hostElement.offsetLeft - this.areaBodyWestGeo.width;
+                this.debugOnce(bodyX, bodyY);
+            }
+        }
+        return ret;
+    }
+    onMouseDown(mouseEvent) {
+        if (mouseEvent.columnIndex > -1
+            && mouseEvent.action
+            && ["resize-column", "drag-column"].includes(mouseEvent.action)) {
+            this.mouseStartWidth = this.tableModel.getColumnWidth(mouseEvent.columnIndex);
+            this.mouseStartAction = mouseEvent.action;
+            this.mouseStartColumnIndex = mouseEvent.columnIndex;
+            if (this.mouseStartAction === "drag-column") {
+                this.dragFrom = this.mouseStartColumnIndex;
+            }
+        }
+    }
+    mouseDraggingOnFrame(mouseEvent) {
+        this.eventListener.onMouseDragging(mouseEvent);
+        this.mouseEvent = mouseEvent;
+        if (this.mouseStartColumnIndex > -1
+            && this.mouseStartAction === "resize-column"
+            && this.tableOptions.columnsResizable) {
+            this.resizeColumn(mouseEvent);
+        }
+        else if (this.mouseStartAction === "drag-column"
+            && mouseEvent.columnIndex > -1
+            && this.tableOptions.columnsDraggable) {
+            this.draggingTargetColumnIndex = mouseEvent.columnIndex;
+            this.dragTo = this.draggingTargetColumnIndex;
+            if (this.dragFrom > -1 && this.dragTo > -1 && this.dragFrom !== this.dragTo) {
+                this.tableModel.changeColumnOrder(this.dragFrom, this.dragTo);
+                this.dragFrom = this.dragTo;
+                this.resetSizeOfWrapperDiv();
+                this.adjustContainersAndRows();
+            }
+            this.repaint();
+        }
+    }
+    mouseDraggingEndOnFrame(mouseEvent) {
+        this.eventListener.onMouseDraggingEnd(mouseEvent);
+        this.draggingTargetColumnIndex = -1;
+        if (this.mouseStartAction === "resize-column") {
+            this.resizeColumn(mouseEvent);
+        }
+        else if (this.mouseStartAction === "drag-column") {
+            this.repaint();
+        }
+        this.mouseStartWidth = -1;
+        this.mouseStartColumnIndex = -1;
+        this.dragFrom = -1;
+        this.dragTo = -1;
+        this.mouseStartAction = "";
+    }
+    mouseMove(mouseMoveEvent) {
+        this.eventListener.onMouseMoved(mouseMoveEvent);
+        this.adjustHoverRows(mouseMoveEvent);
+        this.adjustHoverColumns(mouseMoveEvent);
+    }
+    contextmenu(mouseMoveEvent) {
+        this.eventListener.onContextmenu(mouseMoveEvent);
+    }
+    toggleExpandCollapseAll(expand = true) {
+        const bodyAreaModel = this.tableModel.getBodyModel();
+        if (bodyAreaModel instanceof AreaModelTree) {
+            const amt = bodyAreaModel;
+            amt.toggleExpandCollapseAll(expand);
+            this.repaint();
+            this.storeStateCollapsedExpandService?.collapsedStateAll(expand);
+        }
+    }
+    toggleRowCheckbox(rowIdx, _colIdx, areaIdent) {
+        const areaModel = this.tableModel.getAreaModel(areaIdent);
+        const state = areaModel.isRowChecked(rowIdx);
+        const unsel = (state === undefined || state === "semi" || state === "none");
+        areaModel.setRowChecked(rowIdx, unsel);
+        this.repaint(); // TODO repaint cell only
+        const selectedRows = areaModel.rowSelectionModel?.getCheckedRows();
+        this.eventListener.onCheckboxChanged(selectedRows ? selectedRows : []);
+    }
+    onMouseClicked(evt, previousEvt) {
+        let dirty = this.selectionService.onMouseClicked(evt, previousEvt);
+        if (!dirty && this.getFocusModel) {
+            const fm = this.getFocusModel();
+            if (fm) {
+                dirty = fm.hasChanged();
+                fm.clearChanged();
+                if (dirty) {
+                    this.resetEditorRenderer();
+                }
+            }
+        }
+        this.eventListener.onMouseClicked(evt);
+        if (dirty) {
+            this.debounce(this.repaint.bind(this), 10);
+        }
+    }
+    externalFilterChanged(clearSelection = true) {
+        const predictFn = this.tableOptions.externalFilterFunction;
+        if (predictFn) {
+            if (clearSelection) {
+                this.clearSelectionModel();
+            }
+            this.tableModel.externalFilterChanged(predictFn);
+            this.scrollViewport.scrollTo(0, 0);
+            this.tableModel.recalcHeightAndPadding();
+            this.resetSizeOfWrapperDiv();
+            this.repaint();
+        }
+    }
+    onHeaderDblClicked(event, _rowIdx, colIdx) {
+        const colDef = this.tableModel.getColumnDef(colIdx);
+        if (colDef?.sortable && colDef.sortable()) {
+            event.preventDefault();
+            event.stopPropagation();
+            const states = colDef.sortStatesOrder ? colDef.sortStatesOrder : this.tableOptions.sortOrder;
+            const currentState = colDef.sortState ?? "";
+            const newState = states[(states.indexOf(currentState) + 1) % states.length];
+            const sortItem = new SortItem(colIdx, newState);
+            const done = this.tableModel.doSort([sortItem]);
+            if (done) {
+                this.tableModel.getColumnDefs()?.forEach(cd => cd.sortState = "");
+                colDef.sortState = newState;
+            }
+            this.repaint();
+            this.storeSortingService?.setSortItems([sortItem]);
+        }
+    }
+    changeFocusCell(dx, dy) {
+        if (!this.isEditing() && this.getFocusModel) {
+            const fm = this.getFocusModel();
+            if (fm) {
+                const [rowIdx, colIdx] = fm.getFocus();
+                fm.setFocus(rowIdx + dy, colIdx + dx);
+                this.repaint();
+                return true;
+            }
+        }
+        return false;
+    }
+    resizeColumn(mouseEvent) {
+        this.tableModel.setColumnWidth(this.mouseStartColumnIndex, this.mouseStartWidth + mouseEvent.draggingX);
+        this.tableModel.recalcPadding();
+        this.resetSizeOfWrapperDiv();
+        this.adjustContainersAndRows();
+    }
+    clearSelectionModel() {
+        if (this.getSelectionModel) {
+            this.getSelectionModel()?.clear();
+        }
+    }
+    debugOnce(bodyX, bodyY) {
+        console.clear();
+        console.info("this.hostElement.offsetTop", this.hostElement.offsetTop); // pageY of table tag
+        console.info("this.hostElement.scrollHeight", this.hostElement.scrollHeight); // height of visible scroll area
+        console.info("this.scrollViewportTop", this.scrollTop); // amount of px scrolled to top (initial : 0)
+        console.info("this.areaHeaderCenter.parent.clientHeight", this.areaHeaderCenter.parent.clientHeight);
+        console.info("bodyY", bodyY);
+        console.info("bodyX", bodyX);
+        console.info("rows", this.firstVisibleRowIndex);
+        console.info("");
+        console.info("this.tableModel", this.tableModel);
+        console.info("");
+        console.info("this.mouseMoveEvent.clientX", this.mouseHandler.mouseEvent?.clientX);
+        console.info("this.hostElement.offsetLeft", this.hostElement.offsetLeft);
+        console.info("this.areaBodyWestGeo.width", this.areaBodyWestGeo.width);
+    }
+    autoRestoreScrollPosition() {
+        if (this.tableOptions?.autoRestoreOptions && this.storeScrollPosStateService) {
+            const autoRestoreOptions = this.tableOptions.autoRestoreOptions;
+            if (autoRestoreOptions.autoRestoreScrollPosition) {
+                const scrollOffset = this.storeScrollPosStateService.getScrollOffset();
+                if (scrollOffset) {
+                    this.scrollViewport.scrollTo(...scrollOffset);
+                }
+            }
+        }
+    }
+    autoRestoreSortingState() {
+        if (this.tableOptions?.autoRestoreOptions?.autoRestoreSortingState && this.storeSortingService) {
+            const sortItems = this.storeSortingService.getSortItems();
+            if (sortItems?.length) {
+                const areaModel = this.tableModel.getBodyModel();
+                areaModel.doSort(sortItems);
+            }
+        }
+    }
+    autoRestoreCollapsedExpandedState() {
+        if (this.tableOptions?.autoRestoreOptions?.getRowId && this.storeStateCollapsedExpandService) {
+            const autoRestoreOptions = this.tableOptions.autoRestoreOptions;
+            const getRowId = autoRestoreOptions.getRowId;
+            if (autoRestoreOptions.autoRestoreCollapsedExpandedState && getRowId) {
+                const state = this.storeStateCollapsedExpandService.collapsedExpandedStateGet();
+                const areaModel = this.tableModel.getAreaModel("body");
+                if (areaModel instanceof AreaModelTree) {
+                    const amtr = areaModel;
+                    const rowCount = areaModel.getRowCount();
+                    for (let i = 0; i < rowCount; i++) {
+                        const row = areaModel.getRowByIndex(i);
+                        if (row) {
+                            if (state.allExpanded) {
+                                row.expanded = true;
+                            }
+                            else if (state.allCollapsed) {
+                                row.expanded = false;
+                            }
+                            else {
+                                const rowId = getRowId(row.data);
+                                if (state.mode === "expanded") {
+                                    row.expanded = (this.storeStateCollapsedExpandService.collapsedExpandedStateIncludes(rowId));
+                                }
+                                else if (state.mode === "collapsed") {
+                                    row.expanded = (!this.storeStateCollapsedExpandService.collapsedExpandedStateIncludes(rowId));
+                                }
+                            }
+                        }
+                    }
+                    amtr.recalcVisibleTreeRows();
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-scope.js","sourceRoot":"","sources":["../../../../../../libs/table/src/lib/table/table-scope.ts"],"names":[],"mappings":"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","sourcesContent":["import { TableModelIf } from \"./data/tablemodel/table-model.if\";\nimport { AreaIdent } from \"./data/tablemodel/area-ident.type\";\nimport { GeMouseEvent } from \"./data/common/event/ge-mouse-event\";\nimport { DomServiceIf } from \"./service/dom-service.if\";\nimport { ConvenienceDomService } from \"./service/convenience-dom.service\";\nimport { TableOptionsIf } from \"./data/options/table-options.if\";\nimport { TreeRow } from \"./data/common/tree-row\";\nimport { MouseHandler } from \"./mouse-handler\";\nimport { EventListenerIf } from \"./event-listener.if\";\nimport { TableApi } from \"./table-api\";\nimport { SortState } from \"./data/common/sort-state.type\";\nimport { AreaModelTree } from \"./data/tablemodel/areamodel/area-model-tree\";\nimport { StoreStateScrollPosService } from \"./service/store-state-scroll-pos.service\";\nimport { StoreStateCollapsedExpandService } from \"./service/store-state-collapsed-expand.service\";\nimport { StoreStateSortingService } from \"./service/store-state-sorting.service\";\nimport { RenderScope } from \"./render-scope\";\nimport { SortItem } from \"./data/common/sort-item\";\nimport { InputHandler } from \"./input-handler\";\nimport { GeModelChangeEvent } from \"./data/common/event/ge-model-change-event\";\nimport { SelectionService } from \"./selection/selection-service\";\nimport { GeKeyEvent } from \"./data/common/event/ge-key-event\";\nimport { OnActionTriggeredIf } from \"./action/on-action-triggered.if\";\nimport { ActionId } from \"./action/action-id.type\";\nimport { ShortcutService } from \"./action/shortcut.service\";\nimport { EventAdapter } from \"./event-adapter\";\n\n\nexport class TableScope extends RenderScope implements OnActionTriggeredIf {\n\n  public mouseHandler: MouseHandler;\n  public inputHandler: InputHandler;\n  public shortcutService: ShortcutService;\n\n  public storeStateCollapsedExpandService?: StoreStateCollapsedExpandService;\n  public storeSortingService?: StoreStateSortingService;\n\n  protected selectionService: SelectionService = new SelectionService(this);\n  protected keyEvent?: GeKeyEvent;\n  private api = new TableApi(this);\n\n  private mouseStartAction = \"\";\n  private mouseStartWidth = -1;\n  private mouseStartColumnIndex = -1;\n  private dragFrom = -1;\n  private dragTo = -1;\n\n  constructor(\n    hostElement: HTMLDivElement,\n    tableModel: TableModelIf,\n    domService: DomServiceIf,\n    tableOptions: TableOptionsIf,\n    protected readonly eventListener: EventListenerIf\n  ) {\n    super(\n      hostElement,\n      tableModel,\n      new ConvenienceDomService(domService),\n      tableOptions\n    );\n    if (!eventListener) {\n      this.eventListener = new EventAdapter();\n    }\n    if (this.tableOptions?.autoRestoreOptions) {\n      const autoRestoreOptions = this.tableOptions.autoRestoreOptions;\n      const keyFn = autoRestoreOptions.getStorageKeyFn;\n      if (keyFn) {\n        if (autoRestoreOptions.autoRestoreScrollPosition) {\n          this.storeScrollPosStateService = new StoreStateScrollPosService(keyFn);\n        }\n        if (autoRestoreOptions.autoRestoreCollapsedExpandedState) {\n          this.storeStateCollapsedExpandService = new StoreStateCollapsedExpandService(keyFn);\n        }\n        if (autoRestoreOptions.autoRestoreSortingState) {\n          this.storeSortingService = new StoreStateSortingService(keyFn);\n        }\n      }\n    }\n    this.mouseHandler = new MouseHandler(this);\n    this.inputHandler = new InputHandler(this);\n\n    this.shortcutService = new ShortcutService(this);\n    this.shortcutService.addListener(this.selectionService);\n  }\n\n  onActionTriggered(actionId: ActionId): boolean {\n    if (actionId === \"NAVIGATE_DOWN\") {\n      if (this.changeFocusCell(0, 1)) {\n        return true;\n      }\n    }\n    if (actionId === \"NAVIGATE_UP\") {\n      if (this.changeFocusCell(0, -1)){\n        return true;\n      }\n    }\n    if (actionId === \"NAVIGATE_LEFT\") {\n      if (this.changeFocusCell(-1, 0)){\n        return true;\n      }\n    }\n    if (actionId === \"NAVIGATE_RIGHT\") {\n      if (this.changeFocusCell(1, 0)){\n        return true;\n      }\n    }\n    if (actionId === \"START_EDITING\") {\n      if (this.getFocusModel) {\n        const fm = this.getFocusModel();\n        if (fm) {\n          const [rowIdx, colIdx] = fm.getFocus();\n          if (this.tableModel.getBodyModel().isEditable(rowIdx, colIdx)) {\n            this.clearSelection();\n            this.initRenderEditor(rowIdx, colIdx);\n          }\n        }\n        return true;\n      }\n    }\n    return false;\n  }\n\n  updateModelValueAfterEdit(areaIdent: AreaIdent, rowIndex: number, columnIndex: number, value: string) {\n    if (areaIdent === \"body\") {\n      const bodyAreaModel = this.tableModel.getAreaModel(areaIdent);\n      const ok: boolean = bodyAreaModel.setValue(rowIndex, columnIndex, value);\n      if (ok) {\n        this.resetEditorRenderer();\n        this.repaint();\n        this.eventListener.onModelChanged(GeModelChangeEvent.createSingle(rowIndex, columnIndex));\n        this.hostElement.focus();\n      }\n    }\n  }\n\n  getApi(): TableApi {\n    return this.api;\n  }\n\n  /*\n   * Called by the table component\n   */\n  firstInit() {\n    this.tableModel.init();\n    if (this.tableOptions?.externalFilterFunction) {\n      this.externalFilterChanged(false);\n    }\n    this.autoRestoreCollapsedExpandedState();\n    this.autoRestoreSortingState();\n    this.resetSizeOfWrapperDiv();\n    this.adjustContainersAndRows();\n    this.autoRestoreScrollPosition();\n  }\n\n  createGeMouseEvent(mouseEvent: MouseEvent): GeMouseEvent {\n    const ret: GeMouseEvent = new GeMouseEvent();\n    ret.originalEvent = mouseEvent;\n\n    if (mouseEvent) {\n      const target = mouseEvent.target as HTMLElement;\n      [ret.areaIdent, ret.sideIdent] = this.getAreaAndSideIdentByAttr(target);\n      ret.rowIndex = this.getNumberByAttr(target, \"data-row-index\");\n      ret.columnIndex = this.getNumberByAttr(target, \"data-col-index\");\n      ret.action = this.getStringByAttr(target, \"data-ge-action\");\n\n      // const bodyY = mouseEvent.clientY - this.hostElement.offsetTop - this.areaHeaderCenter.parent.clientHeight;\n      // const bodyX = mouseEvent.clientX - this.hostElement.offsetLeft - this.areaBodyWestGeo.width;\n\n      if (ret.areaIdent) {\n        const am = this.tableModel.getAreaModel(ret.areaIdent);\n        ret.rowTop = am.getYPosByRowIndex(ret.rowIndex);\n      }\n      ret.columnLeft = this.tableModel.getXPosByColumnIndex(ret.columnIndex);\n\n      if (mouseEvent.ctrlKey && mouseEvent.altKey) {\n        const bodyY = mouseEvent.clientY - this.hostElement.offsetTop - this.areaHeaderCenter.parent.clientHeight;\n        const bodyX = mouseEvent.clientX - this.hostElement.offsetLeft - this.areaBodyWestGeo.width;\n        this.debugOnce(bodyX, bodyY);\n      }\n    }\n    return ret;\n  }\n\n  onMouseDown(mouseEvent: GeMouseEvent) {\n    if (mouseEvent.columnIndex > -1\n      && mouseEvent.action\n      && [\"resize-column\", \"drag-column\"].includes(mouseEvent.action)) {\n\n      this.mouseStartWidth = this.tableModel.getColumnWidth(mouseEvent.columnIndex);\n      this.mouseStartAction = mouseEvent.action;\n      this.mouseStartColumnIndex = mouseEvent.columnIndex;\n\n      if (this.mouseStartAction === \"drag-column\") {\n        this.dragFrom = this.mouseStartColumnIndex;\n      }\n    }\n  }\n\n  mouseDraggingOnFrame(mouseEvent: GeMouseEvent) {\n    this.eventListener.onMouseDragging(mouseEvent);\n    this.mouseEvent = mouseEvent;\n\n    if (\n      this.mouseStartColumnIndex > -1\n      && this.mouseStartAction === \"resize-column\"\n      && this.tableOptions.columnsResizable) {\n      this.resizeColumn(mouseEvent);\n\n    } else if (\n      this.mouseStartAction === \"drag-column\"\n      && mouseEvent.columnIndex > -1\n      && this.tableOptions.columnsDraggable) {\n\n      this.draggingTargetColumnIndex = mouseEvent.columnIndex;\n      this.dragTo = this.draggingTargetColumnIndex;\n\n      if (this.dragFrom > -1 && this.dragTo > -1 && this.dragFrom !== this.dragTo) {\n        this.tableModel.changeColumnOrder(this.dragFrom, this.dragTo);\n        this.dragFrom = this.dragTo;\n        this.resetSizeOfWrapperDiv();\n        this.adjustContainersAndRows();\n      }\n      this.repaint();\n    }\n  }\n\n  mouseDraggingEndOnFrame(mouseEvent: GeMouseEvent) {\n    this.eventListener.onMouseDraggingEnd(mouseEvent);\n    this.draggingTargetColumnIndex = -1;\n\n    if (this.mouseStartAction === \"resize-column\") {\n      this.resizeColumn(mouseEvent);\n\n    } else if (this.mouseStartAction === \"drag-column\") {\n      this.repaint();\n    }\n    this.mouseStartWidth = -1;\n    this.mouseStartColumnIndex = -1;\n    this.dragFrom = -1;\n    this.dragTo = -1;\n    this.mouseStartAction = \"\";\n  }\n\n  mouseMove(mouseMoveEvent: GeMouseEvent) {\n    this.eventListener.onMouseMoved(mouseMoveEvent);\n    this.adjustHoverRows(mouseMoveEvent);\n    this.adjustHoverColumns(mouseMoveEvent);\n  }\n\n  contextmenu(mouseMoveEvent: GeMouseEvent) {\n    this.eventListener.onContextmenu(mouseMoveEvent);\n  }\n\n  toggleExpandCollapseAll(expand: boolean = true) {\n    const bodyAreaModel = this.tableModel.getBodyModel();\n    if (bodyAreaModel instanceof AreaModelTree) {\n      const amt: AreaModelTree<any> = bodyAreaModel;\n      amt.toggleExpandCollapseAll(expand);\n      this.repaint();\n      this.storeStateCollapsedExpandService?.collapsedStateAll(expand);\n    }\n  }\n\n  toggleRowCheckbox(rowIdx: number, _colIdx: number, areaIdent: AreaIdent) {\n    const areaModel = this.tableModel.getAreaModel(areaIdent);\n    const state = areaModel.isRowChecked(rowIdx);\n    const unsel = (state === undefined || state === \"semi\" || state === \"none\");\n    areaModel.setRowChecked(rowIdx, unsel);\n    this.repaint(); // TODO repaint cell only\n    const selectedRows = areaModel.rowSelectionModel?.getCheckedRows();\n    this.eventListener.onCheckboxChanged(selectedRows ? selectedRows : []);\n  }\n\n  onMouseClicked(evt: GeMouseEvent, previousEvt: GeMouseEvent | undefined) {\n    let dirty = this.selectionService.onMouseClicked(evt, previousEvt);\n    if (!dirty && this.getFocusModel) {\n      const fm = this.getFocusModel();\n      if (fm) {\n        dirty = fm.hasChanged();\n        fm.clearChanged();\n        if (dirty) {\n          this.resetEditorRenderer();\n        }\n      }\n    }\n    this.eventListener.onMouseClicked(evt);\n    if (dirty) {\n      this.debounce(this.repaint.bind(this), 10);\n    }\n  }\n\n  externalFilterChanged(clearSelection: boolean = true) {\n    const predictFn = this.tableOptions.externalFilterFunction;\n    if (predictFn) {\n      if (clearSelection) {\n        this.clearSelectionModel();\n      }\n      this.tableModel.externalFilterChanged(predictFn);\n      this.scrollViewport.scrollTo(0, 0);\n      this.tableModel.recalcHeightAndPadding();\n      this.resetSizeOfWrapperDiv();\n      this.repaint();\n    }\n  }\n\n  onHeaderDblClicked(event: MouseEvent, _rowIdx: number, colIdx: number) {\n    const colDef = this.tableModel.getColumnDef(colIdx);\n    if (colDef?.sortable && colDef.sortable()) {\n      event.preventDefault();\n      event.stopPropagation();\n      const states: SortState[] = colDef.sortStatesOrder ? colDef.sortStatesOrder : this.tableOptions.sortOrder;\n      const currentState: SortState = colDef.sortState ?? \"\";\n      const newState = states[(states.indexOf(currentState) + 1) % states.length];\n\n      const sortItem = new SortItem(colIdx, newState);\n      const done = this.tableModel.doSort([sortItem]);\n      if (done) {\n        this.tableModel.getColumnDefs()?.forEach(cd => cd.sortState = \"\");\n        colDef.sortState = newState;\n      }\n      this.repaint();\n      this.storeSortingService?.setSortItems([sortItem]);\n    }\n  }\n\n\n  private changeFocusCell(dx: number, dy: number) : boolean{\n    if (!this.isEditing() && this.getFocusModel) {\n      const fm = this.getFocusModel();\n      if (fm) {\n        const [rowIdx, colIdx] = fm.getFocus();\n        fm.setFocus(rowIdx + dy, colIdx + dx);\n        this.repaint();\n        return true;\n      }\n    }\n    return false;\n  }\n\n  private resizeColumn(mouseEvent: GeMouseEvent) {\n    this.tableModel.setColumnWidth(this.mouseStartColumnIndex, this.mouseStartWidth + mouseEvent.draggingX);\n    this.tableModel.recalcPadding();\n    this.resetSizeOfWrapperDiv();\n    this.adjustContainersAndRows();\n  }\n\n  private clearSelectionModel() {\n    if (this.getSelectionModel) {\n      this.getSelectionModel()?.clear();\n    }\n  }\n\n  private debugOnce(\n    bodyX: number,\n    bodyY: number\n  ) {\n    console.clear();\n    console.info(\"this.hostElement.offsetTop\", this.hostElement.offsetTop); // pageY of table tag\n    console.info(\"this.hostElement.scrollHeight\", this.hostElement.scrollHeight); // height of visible scroll area\n    console.info(\"this.scrollViewportTop\", this.scrollTop); // amount of px scrolled to top (initial : 0)\n    console.info(\"this.areaHeaderCenter.parent.clientHeight\", this.areaHeaderCenter.parent.clientHeight);\n    console.info(\"bodyY\", bodyY);\n    console.info(\"bodyX\", bodyX);\n    console.info(\"rows\", this.firstVisibleRowIndex);\n    console.info(\"\");\n    console.info(\"this.tableModel\", this.tableModel);\n    console.info(\"\");\n    console.info(\"this.mouseMoveEvent.clientX\", this.mouseHandler.mouseEvent?.clientX);\n    console.info(\"this.hostElement.offsetLeft\", this.hostElement.offsetLeft);\n    console.info(\"this.areaBodyWestGeo.width\", this.areaBodyWestGeo.width);\n  }\n\n  private autoRestoreScrollPosition() {\n    if (this.tableOptions?.autoRestoreOptions && this.storeScrollPosStateService) {\n      const autoRestoreOptions = this.tableOptions.autoRestoreOptions;\n      if (autoRestoreOptions.autoRestoreScrollPosition) {\n        const scrollOffset = this.storeScrollPosStateService.getScrollOffset();\n        if (scrollOffset) {\n          this.scrollViewport.scrollTo(...scrollOffset);\n        }\n      }\n    }\n  }\n\n  private autoRestoreSortingState() {\n    if (this.tableOptions?.autoRestoreOptions?.autoRestoreSortingState && this.storeSortingService) {\n      const sortItems = this.storeSortingService.getSortItems();\n      if (sortItems?.length) {\n        const areaModel = this.tableModel.getBodyModel();\n        areaModel.doSort(sortItems);\n      }\n    }\n  }\n\n  private autoRestoreCollapsedExpandedState() {\n    if (this.tableOptions?.autoRestoreOptions?.getRowId && this.storeStateCollapsedExpandService) {\n      const autoRestoreOptions = this.tableOptions.autoRestoreOptions;\n      const getRowId = autoRestoreOptions.getRowId;\n      if (autoRestoreOptions.autoRestoreCollapsedExpandedState && getRowId) {\n        const state = this.storeStateCollapsedExpandService.collapsedExpandedStateGet();\n        const areaModel = this.tableModel.getAreaModel(\"body\");\n        if (areaModel instanceof AreaModelTree) {\n          const amtr: AreaModelTree<any> = areaModel;\n          const rowCount = areaModel.getRowCount();\n\n\n          for (let i = 0; i < rowCount; i++) {\n            const row: TreeRow<any> | undefined = areaModel.getRowByIndex(i);\n            if (row) {\n              if (state.allExpanded) {\n                row.expanded = true;\n\n              } else if (state.allCollapsed) {\n                row.expanded = false;\n\n              } else {\n                const rowId = getRowId(row.data);\n                if (state.mode === \"expanded\") {\n                  row.expanded = (this.storeStateCollapsedExpandService.collapsedExpandedStateIncludes(rowId));\n\n                } else if (state.mode === \"collapsed\") {\n                  row.expanded = (!this.storeStateCollapsedExpandService.collapsedExpandedStateIncludes(rowId));\n                }\n              }\n            }\n          }\n          amtr.recalcVisibleTreeRows();\n        }\n      }\n    }\n  }\n}\n\n\n"]}

package/{src/index.ts → index.d.ts}

@@ -1,4 +1,3 @@
-
 export * from './lib/table/table-scope';
 export * from './lib/table/table-api';
 export * from './lib/table/ele-scope';
@@ -8,24 +7,23 @@ export * from './lib/table/input-handler';
 export * from './lib/table/event-listener.if';
 export * from './lib/table/event-adapter';
 export * from './lib/table/css-vars';
-
 export * from './lib/table/factory/tree-factory';
 export * from './lib/table/factory/table-factory';
-
-
 export * from './lib/table/action/action-id.type';
 export * from './lib/table/action/shortcut.service';
 export * from './lib/table/action/shortcut-actionid-mapping.type';
 export * from './lib/table/action/windows-shortcut-actionId-mapping';
 export * from './lib/table/action/osx-shortcut-actionId-mapping';
 export * from './lib/table/action/on-action-triggered.if';
-
 export * from './lib/table/data/side-ident.type';
 export * from './lib/table/data/div-scope.type';
 export * from './lib/table/data/geo-data';
 export * from './lib/table/data/table-model-and-options.if';
 export * from './lib/table/data/table-model-and-options';
-
+export * from './lib/table/data/chunk/chunk.data-event';
+export * from './lib/table/data/chunk/chunk.data-event.if';
+export * from './lib/table/data/chunk/request-chunk';
+export * from './lib/table/data/chunk/request-chunk.if';
 export * from './lib/table/data/common/get-t';
 export * from './lib/table/data/common/value-label.if';
 export * from './lib/table/data/common/value-label';
@@ -48,25 +46,19 @@ export * from "./lib/table/data/common/area-map-factory";
 export * from "./lib/table/data/common/filter-function";
 export * from "./lib/table/data/common/args-render-cell-div";
 export * from "./lib/table/data/common/args-adjust-columns-to-row-parent-params";
-
 export * from "./lib/table/data/common/event/ge-mouse-event";
 export * from "./lib/table/data/common/event/ge-model-change-event";
 export * from "./lib/table/data/common/event/ge-cell-indices";
 export * from "./lib/table/data/common/event/ge-key-event";
-
 export * from "./lib/table/data/common/event/input/table-cell-update-event";
 export * from "./lib/table/data/common/event/input/table-cell-update-event.if";
-
 export * from "./lib/table/data/event/mouse-target-data";
-
 export * from "./lib/table/focus/focus-model";
 export * from "./lib/table/focus/focus-model.if";
 export * from "./lib/table/focus/focus.type";
-
 export * from "./lib/table/checkbox/checkbox-model";
 export * from "./lib/table/checkbox/tree-checkbox-model";
 export * from "./lib/table/checkbox/checkbox-model.if";
-
 export * from "./lib/table/data/options/auto-restore-options.if";
 export * from './lib/table/data/options/auto-restore-options';
 export * from './lib/table/data/options/table-options';
@@ -79,20 +71,16 @@ export * from './lib/table/data/options/icon';
 export * from './lib/table/data/options/icon.if';
 export * from './lib/table/data/options/sorted-options.if';
 export * from './lib/table/data/options/sorted-options';
-
 export * from './lib/table/data/tablemodel/padding';
 export * from './lib/table/data/tablemodel/table-model.if';
 export * from './lib/table/data/tablemodel/table-model';
 export * from './lib/table/data/tablemodel/area-ident.type';
-
 export * from './lib/table/data/tablemodel/column/column-def';
 export * from './lib/table/data/tablemodel/column/column-def.if';
-
 export * from './lib/table/data/tablemodel/cellgroup/cell-group';
 export * from './lib/table/data/tablemodel/cellgroup/cell-group.if';
 export * from './lib/table/data/tablemodel/cellgroup/cellgroup-factory';
 export * from './lib/table/data/tablemodel/cellgroup/cell-group-ext';
-
 export * from './lib/table/data/tablemodel/areamodel/area-model.if';
 export * from './lib/table/data/tablemodel/areamodel/area-model';
 export * from './lib/table/data/tablemodel/areamodel/area-model-cell-groups';
@@ -103,12 +91,10 @@ export * from './lib/table/data/tablemodel/areamodel/area-model-object-array';
 export * from './lib/table/data/tablemodel/areamodel/area-model-tree';
 export * from './lib/table/data/tablemodel/areamodel/col-and-rowspan-model';
 export * from './lib/table/data/tablemodel/areamodel/has-default-row-height-if';
-
 export * from './lib/table/data/common/tree-row';
 export * from './lib/table/data/common/tree-row-if';
 export * from './lib/table/data/common/tree-arrow.type';
 export * from './lib/table/data/tablemodel/areamodel/area-model-object-array-with-columndefs';
-
 export * from './lib/table/service/convenience-dom.service';
 export * from "./lib/table/service/dom-service.if";
 export * from "./lib/table/service/simple-dom-service";
@@ -119,8 +105,6 @@ export * from "./lib/table/service/store-state-sorting.service";
 export * from "./lib/table/service/data/collapsed-expanded.data";
 export * from "./lib/table/service/data/html-style.type";
 export * from "./lib/table/service/ge-filter.service";
-
-
 export * from "./lib/table/renderer/renderer";
 export * from "./lib/table/renderer/cell-render.if";
 export * from "./lib/table/renderer/cell-group-ext-cell-renderer";
@@ -136,18 +120,15 @@ export * from "./lib/table/renderer/renderer-cleanup-fn.type";
 export * from "./lib/table/renderer/number-cell-renderer";
 export * from "./lib/table/renderer/star-rating-cell-renderer";
 export * from "./lib/table/renderer/progress-bar-cell-renderer";
-
 export * from "./lib/table/renderer/edit/edit-cell-renderer.type";
 export * from "./lib/table/renderer/edit/edit-input-pipe.if";
 export * from "./lib/table/renderer/edit/edit-input-pipe-for-number";
 export * from "./lib/table/renderer/edit/input-cell-renderer";
 export * from './lib/table/renderer/edit/select-cell-renderer';
-
 export * from './lib/table/selection/selection-model';
 export * from './lib/table/selection/selection-model.if';
 export * from './lib/table/selection/selection.type';
 export * from './lib/table/selection/selection-service';
-
 export * from './lib/table/color/color-rgb';
 export * from './lib/table/color/color-rgb.if';
 export * from './lib/table/color/ge-css-color-util';
@@ -156,4 +137,3 @@ export * from './lib/table/color/three-color-gradient-arg';
 export * from './lib/table/color/two-color-gradient-arg.if';
 export * from './lib/table/color/two-color-gradient-arg';
 export * from "./lib/table/data/tablemodel/areamodel/has-default-row-height-if";
-

package/lib/table/action/action-id.type.d.ts

@@ -0,0 +1,2 @@
+export declare const actionIds: readonly ["START_EDITING", "TOGGLE_SELECTION", "SELECT_ALL", "DESELECT_ALL", "NAVIGATE_LEFT", "NAVIGATE_RIGHT", "NAVIGATE_UP", "NAVIGATE_DOWN"];
+export type ActionId = typeof actionIds[number];

package/{src/lib/table/action/on-action-triggered.if.ts → lib/table/action/on-action-triggered.if.d.ts}

@@ -1,7 +1,4 @@
 import { ActionId } from "./action-id.type";
-
 export interface OnActionTriggeredIf {
-
-  onActionTriggered(actionId: ActionId): boolean;
-
+    onActionTriggered(actionId: ActionId): boolean;
 }

package/lib/table/action/osx-shortcut-actionId-mapping.d.ts

@@ -0,0 +1,6 @@
+import { ActionId } from "./action-id.type";
+export declare class OsxShortcutActionIdMapping {
+    get(): {
+        [key: string]: ActionId;
+    };
+}

package/lib/table/action/shortcut-actionid-mapping.type.d.ts

@@ -0,0 +1,4 @@
+import { ActionId } from "./action-id.type";
+export type ShortcutActionIdMapping = {
+    [key: string]: ActionId;
+};

package/lib/table/action/shortcut.service.d.ts

@@ -0,0 +1,18 @@
+import { TableScope } from "../table-scope";
+import { OnActionTriggeredIf } from "./on-action-triggered.if";
+export declare class ShortcutService {
+    protected tableScope: TableScope;
+    private shortcutActionIdMapping;
+    private listener;
+    constructor(tableScope: TableScope);
+    addListener(listener: OnActionTriggeredIf): void;
+    init(): void;
+    private isMacintosh;
+    private isDebug;
+    private isLocalhost;
+    private onKeyDown;
+    private emit;
+    private findEnty;
+    private areTokensEquals;
+    private getTokenByEvent;
+}

package/lib/table/action/windows-shortcut-actionId-mapping.d.ts

@@ -0,0 +1,6 @@
+import { ActionId } from "./action-id.type";
+export declare class WindowsShortcutActionIdMapping {
+    get(): {
+        [key: string]: ActionId;
+    };
+}

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

@@ -0,0 +1,12 @@
+import { CheckedType } from "../data/common/checked-type";
+import { CheckboxModelIf } from "./checkbox-model.if";
+export declare class CheckboxModel<T> implements CheckboxModelIf<T> {
+    protected checkedRows: Array<T>;
+    getCheckedRows(): T[];
+    setCheckedRows(rows: T[]): void;
+    addCheckedRows(rows: T[]): void;
+    checkRow(row: T, sel: boolean): void;
+    isRowChecked(row: T): CheckedType;
+    checkAll(_rows: T[]): void;
+    private removeSelectedRow;
+}

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

@@ -0,0 +1,9 @@
+import { CheckedType } from "../data/common/checked-type";
+export interface CheckboxModelIf<T> {
+    getCheckedRows(): T[];
+    setCheckedRows(value: T[]): void;
+    addCheckedRows(value: T[]): void;
+    checkRow(row: T, check: boolean): void;
+    isRowChecked(row: T): CheckedType;
+    checkAll(value: T[]): void;
+}