@fundamental-ngx/platform 0.43.36 → 0.43.38

package/esm2020/table-helpers/directives/table-virtual-scroll.directive.mjs

@@ -1,11 +1,14 @@
-import { Directive, inject, Input } from '@angular/core';
-import { DestroyedService } from '@fundamental-ngx/cdk/utils';
+import { Directive, HostListener, inject, Input } from '@angular/core';
+import { DestroyedService, KeyUtil } from '@fundamental-ngx/cdk/utils';
 import { ContentDensityMode } from '@fundamental-ngx/core/content-density';
 import { BehaviorSubject, filter } from 'rxjs';
 import { takeUntil } from 'rxjs/operators';
 import { FDP_TABLE_VIRTUAL_SCROLL_DIRECTIVE, ROW_HEIGHT } from '../constants';
 import { TableVirtualScroll } from '../models';
 import { TableScrollDispatcherService } from '../services/table-scroll-dispatcher.service';
+import { DOWN_ARROW, UP_ARROW } from '@angular/cdk/keycodes';
+import { TableRowService } from '../services/table-row.service';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
 import * as i0 from "@angular/core";
 export class TableVirtualScrollDirective extends TableVirtualScroll {
     constructor() {
@@ -30,7 +33,103 @@ export class TableVirtualScrollDirective extends TableVirtualScroll {
         /** @hidden */
         this._tableScrollDispatcher = inject(TableScrollDispatcherService);
         /** @hidden */
+        this._tableRowService = inject(TableRowService);
+        /** @hidden */
         this._destroy$ = inject(DestroyedService);
+        /** @hidden */
+        this._lastMockScrollPosition = 0;
+        /** @hidden */
+        this._previousStartNodeIndex = null;
+        /** @hidden */
+        this._scrollWholeRows = false;
+        /**
+         * @hidden
+         * This function is called when the user performs a wheel event. It determines whether or not the user has scrolled
+         * up or down using the event's deltaX property, and scrolls the table by one row.
+         */
+        this._wheelScrollListenerFunction = (event) => {
+            if (Math.abs(event.deltaX) < Math.abs(event.deltaY)) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                if (this._wheelTimeout) {
+                    window.cancelAnimationFrame(this._wheelTimeout);
+                }
+                const deltaY = event.deltaY;
+                if (deltaY) {
+                    this._wheelTimeout = window.requestAnimationFrame(() => {
+                        this._scrollRow(deltaY > 0 ? 1 : -1);
+                    });
+                }
+            }
+        };
+        /**
+         * @hidden
+         * This function is called when the mock scrollbar (when using 'scrollWholeRows') is moved. It determines if the
+         * scroll was up or down by comparing the current scroll top to the previous scroll top and scrolls rows accordingly.
+         */
+        this._mockScrollbarListenerFunction = (event) => {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            if (this._scrollMockTimeout) {
+                window.cancelAnimationFrame(this._scrollMockTimeout);
+            }
+            const tableScrollMockContainer = this._table.tableScrollMockContainer.nativeElement;
+            let deltaY = tableScrollMockContainer.scrollTop - this._lastMockScrollPosition;
+            deltaY = Math.ceil(deltaY / this.rowHeight);
+            this._scrollMockTimeout = window.requestAnimationFrame(() => {
+                this._scrollRow(deltaY, true);
+                this._lastMockScrollPosition = tableScrollMockContainer.scrollTop;
+                if (tableScrollMockContainer.scrollTop === 0) {
+                    // Always display the first row of the table when the user scrolls all the way to the top
+                    this._setRows(0);
+                }
+                if (tableScrollMockContainer.scrollTop + tableScrollMockContainer.getBoundingClientRect().height ===
+                    tableScrollMockContainer.scrollHeight) {
+                    // Always display the last rows of the table when the user scrolls all the way to the bottom
+                    const startingNodeIndex = this._table._tableRowsVisible.length - this._getNumberOfRowsToDisplay();
+                    this._setRows(startingNodeIndex);
+                }
+            });
+        };
+    }
+    /**
+     * Whether to scroll whole rows rather than pixel by pixel when the user performs a scroll.
+     * This gives greater performance improvements but also lends to some potentially undesirable UX changes.
+     * A "rowHeight" must be provided when using this feature.
+     */
+    set scrollWholeRows(value) {
+        this._scrollWholeRows = coerceBooleanProperty(value);
+        if (this._scrollWholeRows) {
+            this.virtualScroll = true;
+        }
+    }
+    get scrollWholeRows() {
+        return this._scrollWholeRows;
+    }
+    /** @hidden */
+    _keydownHandler(event) {
+        if (this.scrollWholeRows) {
+            if (this._focusedCell?.rowIndex === 0 && KeyUtil.isKeyCode(event, UP_ARROW)) {
+                if (this._table.tableContainer.nativeElement.querySelectorAll('tr')[1].ariaRowIndex !== '0') {
+                    const cellToFocus = {
+                        colIndex: this._focusedCell.colIndex,
+                        rowIndex: 1
+                    };
+                    this._table._focusableGrid.focusCell(cellToFocus);
+                }
+                this._scrollRow(-1);
+            }
+            else if (this._focusedCell?.rowIndex === this._getNumberOfRowsToDisplay() &&
+                KeyUtil.isKeyCode(event, DOWN_ARROW)) {
+                this._scrollRow(1);
+            }
+        }
+    }
+    /** @hidden */
+    ngOnInit() {
+        if (this.scrollWholeRows && !this.virtualScroll) {
+            this.virtualScroll = true;
+        }
     }
     /** @hidden */
     ngOnChanges(changes) {
@@ -41,58 +140,158 @@ export class TableVirtualScrollDirective extends TableVirtualScroll {
             this.calculateVirtualScrollRows();
         }
     }
+    /** @hidden */
+    ngOnDestroy() {
+        this._focusableGridSubscription?.unsubscribe();
+    }
     /** Sets table reference. */
     setTable(table) {
         this._table = table;
     }
     /**
-     * Calculates rows in viewport.
+     * This function determines how many rows can be displayed in the table, and sets the rows in the table based on the
+     * start node index, which may come from the table state
      */
     calculateVirtualScrollRows() {
-        if (!this.virtualScroll || !this.bodyHeight) {
-            return;
+        if (this.scrollWholeRows) {
+            if (!this._focusableGridSubscription) {
+                this._focusableGridSubscription = this._table._focusableGrid.itemFocused.subscribe((event) => {
+                    this._focusedCell = event;
+                });
+            }
+            if (!this.virtualScroll || !this.bodyHeight) {
+                return;
+            }
+            let startNodeIndex = 0;
+            const scrollTop = this._table.getTableState().scrollTopPosition;
+            if (scrollTop !== 0) {
+                startNodeIndex = Math.floor(scrollTop / this.rowHeight);
+                if (startNodeIndex > this._table._tableRowsVisible.length) {
+                    startNodeIndex = 0;
+                }
+            }
+            const totalNodeCount = this._table._tableRowsVisible.length;
+            let visibleNodeCount = Math.floor(this._table.tableContainer.nativeElement.clientHeight / this.rowHeight);
+            visibleNodeCount = Math.min(totalNodeCount - startNodeIndex, visibleNodeCount);
+            this.virtualScrollTotalHeight = totalNodeCount * this.rowHeight - visibleNodeCount * this.rowHeight;
+            this._setRows(startNodeIndex);
+            const scrollMockContainer = this._table.tableScrollMockContainer.nativeElement;
+            scrollMockContainer.style.maxHeight = this.bodyHeight;
         }
-        const rowHeight = this.rowHeight + 1;
-        const rowsVisible = this._table._tableRowsVisible;
-        const rowsInViewPort = this._table.getRowsInViewport();
-        const totalNodeCount = rowsVisible.length;
-        const scrollTop = this._table.tableScrollable.getScrollTop();
-        let startNodeIndex = Math.floor(scrollTop / rowHeight) - this.renderAhead;
-        startNodeIndex = Math.max(0, startNodeIndex);
-        let visibleNodeCount = Math.ceil(this._table.tableContainer.nativeElement.clientHeight / rowHeight) + 2 * this.renderAhead;
-        visibleNodeCount = Math.min(totalNodeCount - startNodeIndex, visibleNodeCount);
-        this.virtualScrollTransform$.next(startNodeIndex * rowHeight);
-        // Simple caching to avoid unnecessary re-renderings
-        const isCached = startNodeIndex === this._virtualScrollCache.startNodeIndex &&
-            visibleNodeCount === this._virtualScrollCache.visibleNodeCount &&
-            totalNodeCount === this._virtualScrollCache.totalNodeCount &&
-            // On rows change, even if the total number of rows is the same, the row object will be different
-            startNodeIndex === rowsInViewPort[0];
-        if (isCached) {
-            return;
+        else {
+            if (!this.virtualScroll || !this.bodyHeight) {
+                return;
+            }
+            const rowHeight = this.rowHeight + 1;
+            const rowsVisible = this._table._tableRowsVisible;
+            const rowsInViewPort = this._table.getRowsInViewport();
+            const totalNodeCount = rowsVisible.length;
+            const scrollTop = this._table.tableScrollable.getScrollTop();
+            let startNodeIndex = Math.floor(scrollTop / rowHeight) - this.renderAhead;
+            startNodeIndex = Math.max(0, startNodeIndex);
+            let visibleNodeCount = Math.ceil(this._table.tableContainer.nativeElement.clientHeight / rowHeight) + 2 * this.renderAhead;
+            visibleNodeCount = Math.min(totalNodeCount - startNodeIndex, visibleNodeCount);
+            this.virtualScrollTransform$.next(startNodeIndex * rowHeight);
+            // Simple caching to avoid unnecessary re-renderings
+            const isCached = startNodeIndex === this._virtualScrollCache.startNodeIndex &&
+                visibleNodeCount === this._virtualScrollCache.visibleNodeCount &&
+                totalNodeCount === this._virtualScrollCache.totalNodeCount &&
+                // On rows change, even if the total number of rows is the same, the row object will be different
+                startNodeIndex === rowsInViewPort[0];
+            if (isCached) {
+                return;
+            }
+            this._virtualScrollCache = { startNodeIndex, visibleNodeCount, totalNodeCount };
+            this.virtualScrollTotalHeight = totalNodeCount * rowHeight - visibleNodeCount * rowHeight;
+            this._table.setRowsInViewport(startNodeIndex, rowsVisible.slice(startNodeIndex, startNodeIndex + visibleNodeCount).length);
         }
-        this._virtualScrollCache = { startNodeIndex, visibleNodeCount, totalNodeCount };
-        this.virtualScrollTotalHeight = totalNodeCount * rowHeight - visibleNodeCount * rowHeight;
-        this._table.setRowsInViewport(startNodeIndex, rowsVisible.slice(startNodeIndex, startNodeIndex + visibleNodeCount).length);
     }
     /**
-     * Initialises scroll listener.
+     * @hidden
+     * Initialises scroll listeners.
      */
     listenOnVirtualScroll() {
-        this._tableScrollDispatcher
-            .verticallyScrolled()
-            .pipe(filter(() => this.virtualScroll && !!this.bodyHeight), takeUntil(this._destroy$))
-            .subscribe((scrollable) => {
-            this.calculateVirtualScrollRows();
-            this._table.setTableState({
-                ...this._table.getTableState(),
-                scrollTopPosition: scrollable.getScrollTop()
+        if (this.scrollWholeRows) {
+            this._table.tableContainer.nativeElement.addEventListener('wheel', this._wheelScrollListenerFunction, {
+                passive: false
             });
+            this._table.tableScrollMockContainer.nativeElement.addEventListener('scroll', this._mockScrollbarListenerFunction, { passive: false });
+        }
+        else {
+            this._tableScrollDispatcher
+                .verticallyScrolled()
+                .pipe(filter(() => this.virtualScroll && !!this.bodyHeight), takeUntil(this._destroy$))
+                .subscribe((scrollable) => {
+                this.calculateVirtualScrollRows();
+                this._table.setTableState({
+                    ...this._table.getTableState(),
+                    scrollTopPosition: scrollable.getScrollTop()
+                });
+            });
+        }
+    }
+    /** @hidden */
+    _getNumberOfRowsToDisplay() {
+        const tableContainer = this._table.tableContainer.nativeElement;
+        let tableHeight = tableContainer.clientHeight;
+        tableHeight = tableHeight - tableContainer.querySelector('thead').clientHeight;
+        const numberOfRows = Math.floor(tableHeight / (this.rowHeight + 2));
+        if (this._table._tableRowsVisible.length < numberOfRows) {
+            return this._table._tableRowsVisible.length;
+        }
+        else {
+            return numberOfRows;
+        }
+    }
+    /**
+     * @hidden
+     * This function, used only when 'scrollWholeRows' is truthy, calculates what should be the new starting node, based
+     * off the previous starting node and the provided 'count' parameter. For example if the previous start node was 10
+     * and the count parameter is -2, the new starting node will be 8. This function also programmatically moves the
+     * mock scrollbar.
+     */
+    _scrollRow(count, fromMockScrollbarListener = false) {
+        let startingNode = 0;
+        if (this._previousStartNodeIndex !== null && this._previousStartNodeIndex >= 0) {
+            startingNode = this._previousStartNodeIndex;
+        }
+        if (startingNode + count + this._getNumberOfRowsToDisplay() <= this._table._tableRowsVisible.length ||
+            count < 0) {
+            startingNode = Math.ceil(startingNode + count);
+        }
+        if (startingNode < 0) {
+            startingNode = 0;
+        }
+        // This next 'if' statement is for triggering new page loads when 'pageScrolling' is true
+        if (count > 0 &&
+            startingNode === this._previousStartNodeIndex &&
+            this._table.pageScrolling &&
+            this._table._tableRowsVisible.length === this._table._tableRows.length) {
+            this._table._onSpyIntersect(true);
+        }
+        this._setRows(startingNode);
+        const tableScrollMockContainer = this._table.tableScrollMockContainer.nativeElement;
+        if (!fromMockScrollbarListener) {
+            tableScrollMockContainer.scrollBy({ top: count * this.rowHeight });
+        }
+        this._lastMockScrollPosition = tableScrollMockContainer.scrollTop;
+    }
+    /**
+     * @hidden
+     * This function sets rows in the table's viewport depending on the provided starting node. It also sets the table
+     * state.
+     */
+    _setRows(startingNode) {
+        this._table.setRowsInViewport(startingNode, this._getNumberOfRowsToDisplay());
+        this._previousStartNodeIndex = startingNode;
+        this._table.setTableState({
+            ...this._table.getTableState(),
+            scrollTopPosition: this.rowHeight * startingNode
         });
     }
 }
 TableVirtualScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TableVirtualScrollDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
-TableVirtualScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: TableVirtualScrollDirective, isStandalone: true, selector: "fdp-table[virtualScroll]", inputs: { virtualScroll: "virtualScroll", renderAhead: "renderAhead", bodyHeight: "bodyHeight", rowHeight: "rowHeight" }, providers: [
+TableVirtualScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: TableVirtualScrollDirective, isStandalone: true, selector: "fdp-table[virtualScroll]", inputs: { virtualScroll: "virtualScroll", scrollWholeRows: "scrollWholeRows", renderAhead: "renderAhead", bodyHeight: "bodyHeight", rowHeight: "rowHeight" }, host: { listeners: { "keydown": "_keydownHandler($event)" } }, providers: [
         DestroyedService,
         {
             provide: FDP_TABLE_VIRTUAL_SCROLL_DIRECTIVE,
@@ -115,11 +314,16 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImpor
                 }]
         }], propDecorators: { virtualScroll: [{
                 type: Input
+            }], scrollWholeRows: [{
+                type: Input
             }], renderAhead: [{
                 type: Input
             }], bodyHeight: [{
                 type: Input
             }], rowHeight: [{
                 type: Input
+            }], _keydownHandler: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-virtual-scroll.directive.js","sourceRoot":"","sources":["../../../../../../libs/platform/src/lib/table-helpers/directives/table-virtual-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, inject, Input, OnChanges, SimpleChanges } from '@angular/core';\nimport { DestroyedService } from '@fundamental-ngx/cdk/utils';\nimport { ContentDensityMode } from '@fundamental-ngx/core/content-density';\nimport { BehaviorSubject, filter } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { FDP_TABLE_VIRTUAL_SCROLL_DIRECTIVE, ROW_HEIGHT } from '../constants';\nimport { TableVirtualScroll } from '../models';\nimport { TableScrollDispatcherService } from '../services/table-scroll-dispatcher.service';\nimport { Table } from '../table';\n\n@Directive({\n    // eslint-disable-next-line @angular-eslint/directive-selector\n    selector: 'fdp-table[virtualScroll]',\n    standalone: true,\n    providers: [\n        DestroyedService,\n        {\n            provide: FDP_TABLE_VIRTUAL_SCROLL_DIRECTIVE,\n            useExisting: TableVirtualScrollDirective\n        }\n    ]\n})\nexport class TableVirtualScrollDirective extends TableVirtualScroll implements OnChanges {\n    /** Whether to show only visible rows in matter of performance\n     * false by default, when true setting bodyHeight and rowHeight is required.\n     */\n    @Input()\n    virtualScroll = false;\n\n    /** Cache size for the virtualScroll, default is 40 in each direction */\n    @Input()\n    renderAhead = 40;\n\n    /** Body height. */\n    @Input()\n    bodyHeight: string;\n\n    /**\n     * Height of the row, required for the virtualScroll,\n     * default is 44px in cozy, 32px in compact and 24px in condensed (set automatically)\n     */\n    @Input()\n    rowHeight = ROW_HEIGHT.get(ContentDensityMode.COZY)!;\n\n    /** @hidden */\n    virtualScrollTotalHeight = 0;\n\n    /** @hidden */\n    virtualScrollTransform$ = new BehaviorSubject<number>(0);\n\n    /** @hidden */\n    private _table: Table;\n\n    /** @hidden */\n    private _virtualScrollCache = { startNodeIndex: -1, visibleNodeCount: -1, totalNodeCount: -1 };\n\n    /** @hidden */\n    private readonly _tableScrollDispatcher = inject(TableScrollDispatcherService);\n\n    /** @hidden */\n    private readonly _destroy$ = inject(DestroyedService);\n\n    /** @hidden */\n    ngOnChanges(changes: SimpleChanges): void {\n        if (!this._table.tableScrollable) {\n            return;\n        }\n        if (this.virtualScroll && (changes['rowHeight'] || changes['virtualScroll'] || changes['renderAhead'])) {\n            this.calculateVirtualScrollRows();\n        }\n    }\n\n    /** Sets table reference. */\n    setTable(table: Table): void {\n        this._table = table;\n    }\n\n    /**\n     * Calculates rows in viewport.\n     */\n    calculateVirtualScrollRows(): void {\n        if (!this.virtualScroll || !this.bodyHeight) {\n            return;\n        }\n\n        const rowHeight = this.rowHeight + 1;\n\n        const rowsVisible = this._table._tableRowsVisible;\n        const rowsInViewPort = this._table.getRowsInViewport();\n        const totalNodeCount = rowsVisible.length;\n        const scrollTop = this._table.tableScrollable.getScrollTop();\n\n        let startNodeIndex = Math.floor(scrollTop / rowHeight) - this.renderAhead;\n        startNodeIndex = Math.max(0, startNodeIndex);\n\n        let visibleNodeCount =\n            Math.ceil(this._table.tableContainer.nativeElement.clientHeight / rowHeight) + 2 * this.renderAhead;\n        visibleNodeCount = Math.min(totalNodeCount - startNodeIndex, visibleNodeCount);\n\n        this.virtualScrollTransform$.next(startNodeIndex * rowHeight);\n\n        // Simple caching to avoid unnecessary re-renderings\n        const isCached =\n            startNodeIndex === this._virtualScrollCache.startNodeIndex &&\n            visibleNodeCount === this._virtualScrollCache.visibleNodeCount &&\n            totalNodeCount === this._virtualScrollCache.totalNodeCount &&\n            // On rows change, even if the total number of rows is the same, the row object will be different\n            startNodeIndex === rowsInViewPort[0];\n\n        if (isCached) {\n            return;\n        }\n\n        this._virtualScrollCache = { startNodeIndex, visibleNodeCount, totalNodeCount };\n        this.virtualScrollTotalHeight = totalNodeCount * rowHeight - visibleNodeCount * rowHeight;\n        this._table.setRowsInViewport(\n            startNodeIndex,\n            rowsVisible.slice(startNodeIndex, startNodeIndex + visibleNodeCount).length\n        );\n    }\n\n    /**\n     * Initialises scroll listener.\n     */\n    listenOnVirtualScroll(): void {\n        this._tableScrollDispatcher\n            .verticallyScrolled()\n            .pipe(\n                filter(() => this.virtualScroll && !!this.bodyHeight),\n                takeUntil(this._destroy$)\n            )\n            .subscribe((scrollable) => {\n                this.calculateVirtualScrollRows();\n                this._table.setTableState({\n                    ...this._table.getTableState(),\n                    scrollTopPosition: scrollable.getScrollTop()\n                });\n            });\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-virtual-scroll.directive.js","sourceRoot":"","sources":["../../../../../../libs/platform/src/lib/table-helpers/directives/table-virtual-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, HostListener, inject, Input, OnInit, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';\nimport { DestroyedService, FocusableItemPosition, KeyUtil } from '@fundamental-ngx/cdk/utils';\nimport { ContentDensityMode } from '@fundamental-ngx/core/content-density';\nimport { BehaviorSubject, filter, Subscription } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { FDP_TABLE_VIRTUAL_SCROLL_DIRECTIVE, ROW_HEIGHT } from '../constants';\nimport { TableVirtualScroll } from '../models';\nimport { TableScrollDispatcherService } from '../services/table-scroll-dispatcher.service';\nimport { Table } from '../table';\nimport { DOWN_ARROW, UP_ARROW } from '@angular/cdk/keycodes';\nimport { TableRowService } from '../services/table-row.service';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\n\n@Directive({\n    // eslint-disable-next-line @angular-eslint/directive-selector\n    selector: 'fdp-table[virtualScroll]',\n    standalone: true,\n    providers: [\n        DestroyedService,\n        {\n            provide: FDP_TABLE_VIRTUAL_SCROLL_DIRECTIVE,\n            useExisting: TableVirtualScrollDirective\n        }\n    ]\n})\nexport class TableVirtualScrollDirective extends TableVirtualScroll implements OnInit, OnChanges, OnDestroy {\n    /** Whether to show only visible rows in matter of performance\n     * false by default, when true setting bodyHeight and rowHeight is required.\n     */\n    @Input()\n    virtualScroll = false;\n\n    /**\n     * Whether to scroll whole rows rather than pixel by pixel when the user performs a scroll.\n     * This gives greater performance improvements but also lends to some potentially undesirable UX changes.\n     * A \"rowHeight\" must be provided when using this feature.\n     */\n    @Input()\n    set scrollWholeRows(value: boolean) {\n        this._scrollWholeRows = coerceBooleanProperty(value);\n        if (this._scrollWholeRows) {\n            this.virtualScroll = true;\n        }\n    }\n\n    get scrollWholeRows(): boolean {\n        return this._scrollWholeRows;\n    }\n\n    /** Cache size for the virtualScroll, default is 40 in each direction */\n    @Input()\n    renderAhead = 40;\n\n    /** Body height. */\n    @Input()\n    bodyHeight: string;\n\n    /**\n     * Height of the row, required for the virtualScroll,\n     * default is 44px in cozy, 32px in compact and 24px in condensed (set automatically)\n     */\n    @Input()\n    rowHeight = ROW_HEIGHT.get(ContentDensityMode.COZY)!;\n\n    /** @hidden */\n    virtualScrollTotalHeight = 0;\n\n    /** @hidden */\n    virtualScrollTransform$ = new BehaviorSubject<number>(0);\n\n    /** @hidden */\n    private _table: Table;\n\n    /** @hidden */\n    private _virtualScrollCache = { startNodeIndex: -1, visibleNodeCount: -1, totalNodeCount: -1 };\n\n    /** @hidden */\n    private readonly _tableScrollDispatcher = inject(TableScrollDispatcherService);\n\n    /** @hidden */\n    private readonly _tableRowService = inject(TableRowService);\n\n    /** @hidden */\n    private readonly _destroy$ = inject(DestroyedService);\n\n    /** @hidden */\n    private _wheelTimeout: any;\n\n    /** @hidden */\n    private _scrollMockTimeout: any;\n\n    /** @hidden */\n    private _lastMockScrollPosition = 0;\n\n    /** @hidden */\n    private _focusableGridSubscription: Subscription;\n\n    /** @hidden */\n    private _focusedCell: FocusableItemPosition;\n\n    /** @hidden */\n    private _previousStartNodeIndex: number | null = null;\n\n    /** @hidden */\n    private _scrollWholeRows = false;\n\n    /** @hidden */\n    @HostListener('keydown', ['$event'])\n    _keydownHandler(event: KeyboardEvent): void {\n        if (this.scrollWholeRows) {\n            if (this._focusedCell?.rowIndex === 0 && KeyUtil.isKeyCode(event, UP_ARROW)) {\n                if (this._table.tableContainer.nativeElement.querySelectorAll('tr')[1].ariaRowIndex !== '0') {\n                    const cellToFocus = {\n                        colIndex: this._focusedCell.colIndex,\n                        rowIndex: 1\n                    };\n                    this._table._focusableGrid.focusCell(cellToFocus);\n                }\n                this._scrollRow(-1);\n            } else if (\n                this._focusedCell?.rowIndex === this._getNumberOfRowsToDisplay() &&\n                KeyUtil.isKeyCode(event, DOWN_ARROW)\n            ) {\n                this._scrollRow(1);\n            }\n        }\n    }\n\n    /** @hidden */\n    ngOnInit(): void {\n        if (this.scrollWholeRows && !this.virtualScroll) {\n            this.virtualScroll = true;\n        }\n    }\n\n    /** @hidden */\n    ngOnChanges(changes: SimpleChanges): void {\n        if (!this._table.tableScrollable) {\n            return;\n        }\n        if (this.virtualScroll && (changes['rowHeight'] || changes['virtualScroll'] || changes['renderAhead'])) {\n            this.calculateVirtualScrollRows();\n        }\n    }\n\n    /** @hidden */\n    ngOnDestroy(): void {\n        this._focusableGridSubscription?.unsubscribe();\n    }\n\n    /** Sets table reference. */\n    setTable(table: Table): void {\n        this._table = table;\n    }\n\n    /**\n     * This function determines how many rows can be displayed in the table, and sets the rows in the table based on the\n     * start node index, which may come from the table state\n     */\n    calculateVirtualScrollRows(): void {\n        if (this.scrollWholeRows) {\n            if (!this._focusableGridSubscription) {\n                this._focusableGridSubscription = this._table._focusableGrid.itemFocused.subscribe((event) => {\n                    this._focusedCell = event;\n                });\n            }\n            if (!this.virtualScroll || !this.bodyHeight) {\n                return;\n            }\n\n            let startNodeIndex = 0;\n            const scrollTop = this._table.getTableState().scrollTopPosition;\n            if (scrollTop !== 0) {\n                startNodeIndex = Math.floor(scrollTop / this.rowHeight);\n                if (startNodeIndex > this._table._tableRowsVisible.length) {\n                    startNodeIndex = 0;\n                }\n            }\n\n            const totalNodeCount = this._table._tableRowsVisible.length;\n            let visibleNodeCount = Math.floor(this._table.tableContainer.nativeElement.clientHeight / this.rowHeight);\n            visibleNodeCount = Math.min(totalNodeCount - startNodeIndex, visibleNodeCount);\n            this.virtualScrollTotalHeight = totalNodeCount * this.rowHeight - visibleNodeCount * this.rowHeight;\n\n            this._setRows(startNodeIndex);\n            const scrollMockContainer = this._table.tableScrollMockContainer.nativeElement;\n            scrollMockContainer.style.maxHeight = this.bodyHeight;\n        } else {\n            if (!this.virtualScroll || !this.bodyHeight) {\n                return;\n            }\n\n            const rowHeight = this.rowHeight + 1;\n\n            const rowsVisible = this._table._tableRowsVisible;\n            const rowsInViewPort = this._table.getRowsInViewport();\n            const totalNodeCount = rowsVisible.length;\n            const scrollTop = this._table.tableScrollable.getScrollTop();\n\n            let startNodeIndex = Math.floor(scrollTop / rowHeight) - this.renderAhead;\n            startNodeIndex = Math.max(0, startNodeIndex);\n\n            let visibleNodeCount =\n                Math.ceil(this._table.tableContainer.nativeElement.clientHeight / rowHeight) + 2 * this.renderAhead;\n            visibleNodeCount = Math.min(totalNodeCount - startNodeIndex, visibleNodeCount);\n\n            this.virtualScrollTransform$.next(startNodeIndex * rowHeight);\n\n            // Simple caching to avoid unnecessary re-renderings\n            const isCached =\n                startNodeIndex === this._virtualScrollCache.startNodeIndex &&\n                visibleNodeCount === this._virtualScrollCache.visibleNodeCount &&\n                totalNodeCount === this._virtualScrollCache.totalNodeCount &&\n                // On rows change, even if the total number of rows is the same, the row object will be different\n                startNodeIndex === rowsInViewPort[0];\n\n            if (isCached) {\n                return;\n            }\n\n            this._virtualScrollCache = { startNodeIndex, visibleNodeCount, totalNodeCount };\n            this.virtualScrollTotalHeight = totalNodeCount * rowHeight - visibleNodeCount * rowHeight;\n            this._table.setRowsInViewport(\n                startNodeIndex,\n                rowsVisible.slice(startNodeIndex, startNodeIndex + visibleNodeCount).length\n            );\n        }\n    }\n\n    /**\n     * @hidden\n     * Initialises scroll listeners.\n     */\n    listenOnVirtualScroll(): void {\n        if (this.scrollWholeRows) {\n            this._table.tableContainer.nativeElement.addEventListener('wheel', this._wheelScrollListenerFunction, {\n                passive: false\n            });\n            this._table.tableScrollMockContainer.nativeElement.addEventListener(\n                'scroll',\n                this._mockScrollbarListenerFunction,\n                { passive: false }\n            );\n        } else {\n            this._tableScrollDispatcher\n                .verticallyScrolled()\n                .pipe(\n                    filter(() => this.virtualScroll && !!this.bodyHeight),\n                    takeUntil(this._destroy$)\n                )\n                .subscribe((scrollable) => {\n                    this.calculateVirtualScrollRows();\n                    this._table.setTableState({\n                        ...this._table.getTableState(),\n                        scrollTopPosition: scrollable.getScrollTop()\n                    });\n                });\n        }\n    }\n\n    /** @hidden */\n    private _getNumberOfRowsToDisplay(): number {\n        const tableContainer = this._table.tableContainer.nativeElement;\n        let tableHeight = tableContainer.clientHeight;\n        tableHeight = tableHeight - tableContainer.querySelector('thead').clientHeight;\n        const numberOfRows = Math.floor(tableHeight / (this.rowHeight + 2));\n        if (this._table._tableRowsVisible.length < numberOfRows) {\n            return this._table._tableRowsVisible.length;\n        } else {\n            return numberOfRows;\n        }\n    }\n\n    /**\n     * @hidden\n     * This function is called when the user performs a wheel event. It determines whether or not the user has scrolled\n     * up or down using the event's deltaX property, and scrolls the table by one row.\n     */\n    private _wheelScrollListenerFunction = (event: WheelEvent): void => {\n        if (Math.abs(event.deltaX) < Math.abs(event.deltaY)) {\n            event.preventDefault();\n            event.stopImmediatePropagation();\n            if (this._wheelTimeout) {\n                window.cancelAnimationFrame(this._wheelTimeout);\n            }\n            const deltaY = event.deltaY;\n            if (deltaY) {\n                this._wheelTimeout = window.requestAnimationFrame(() => {\n                    this._scrollRow(deltaY > 0 ? 1 : -1);\n                });\n            }\n        }\n    };\n\n    /**\n     * @hidden\n     * This function is called when the mock scrollbar (when using 'scrollWholeRows') is moved. It determines if the\n     * scroll was up or down by comparing the current scroll top to the previous scroll top and scrolls rows accordingly.\n     */\n    private _mockScrollbarListenerFunction = (event: Event): void => {\n        event.preventDefault();\n        event.stopImmediatePropagation();\n        if (this._scrollMockTimeout) {\n            window.cancelAnimationFrame(this._scrollMockTimeout);\n        }\n        const tableScrollMockContainer = this._table.tableScrollMockContainer.nativeElement;\n        let deltaY = tableScrollMockContainer.scrollTop - this._lastMockScrollPosition;\n        deltaY = Math.ceil(deltaY / this.rowHeight);\n        this._scrollMockTimeout = window.requestAnimationFrame(() => {\n            this._scrollRow(deltaY, true);\n            this._lastMockScrollPosition = tableScrollMockContainer.scrollTop;\n            if (tableScrollMockContainer.scrollTop === 0) {\n                // Always display the first row of the table when the user scrolls all the way to the top\n                this._setRows(0);\n            }\n            if (\n                tableScrollMockContainer.scrollTop + tableScrollMockContainer.getBoundingClientRect().height ===\n                tableScrollMockContainer.scrollHeight\n            ) {\n                // Always display the last rows of the table when the user scrolls all the way to the bottom\n                const startingNodeIndex = this._table._tableRowsVisible.length - this._getNumberOfRowsToDisplay();\n                this._setRows(startingNodeIndex);\n            }\n        });\n    };\n\n    /**\n     * @hidden\n     * This function, used only when 'scrollWholeRows' is truthy, calculates what should be the new starting node, based\n     * off the previous starting node and the provided 'count' parameter. For example if the previous start node was 10\n     * and the count parameter is -2, the new starting node will be 8. This function also programmatically moves the\n     * mock scrollbar.\n     */\n    private _scrollRow(count: number, fromMockScrollbarListener = false): void {\n        let startingNode = 0;\n        if (this._previousStartNodeIndex !== null && this._previousStartNodeIndex >= 0) {\n            startingNode = this._previousStartNodeIndex;\n        }\n        if (\n            startingNode + count + this._getNumberOfRowsToDisplay() <= this._table._tableRowsVisible.length ||\n            count < 0\n        ) {\n            startingNode = Math.ceil(startingNode + count);\n        }\n        if (startingNode < 0) {\n            startingNode = 0;\n        }\n        // This next 'if' statement is for triggering new page loads when 'pageScrolling' is true\n        if (\n            count > 0 &&\n            startingNode === this._previousStartNodeIndex &&\n            this._table.pageScrolling &&\n            this._table._tableRowsVisible.length === this._table._tableRows.length\n        ) {\n            this._table._onSpyIntersect(true);\n        }\n        this._setRows(startingNode);\n        const tableScrollMockContainer = this._table.tableScrollMockContainer.nativeElement;\n        if (!fromMockScrollbarListener) {\n            tableScrollMockContainer.scrollBy({ top: count * this.rowHeight });\n        }\n        this._lastMockScrollPosition = tableScrollMockContainer.scrollTop;\n    }\n\n    /**\n     * @hidden\n     * This function sets rows in the table's viewport depending on the provided starting node. It also sets the table\n     * state.\n     */\n    private _setRows(startingNode: number): void {\n        this._table.setRowsInViewport(startingNode, this._getNumberOfRowsToDisplay());\n        this._previousStartNodeIndex = startingNode;\n        this._table.setTableState({\n            ...this._table.getTableState(),\n            scrollTopPosition: this.rowHeight * startingNode\n        });\n    }\n}\n"]}

package/esm2020/table-helpers/models/directives.mjs

@@ -4,4 +4,4 @@ export class TableInitialState {
 }
 export class TableVirtualScroll {
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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