@progress/kendo-react-grid 5.11.0 → 5.11.1-dev.202302071533

package/dist/npm/VirtualScrollFixed.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtualScrollFixed = exports.RowHeightService = void 0;
+var React = require("react");
+/**
+ * @hidden
+ */
+var RowHeightService = /** @class */ (function () {
+    function RowHeightService(total, rowHeight, detailRowHeight, data) {
+        if (total === void 0) { total = 0; }
+        this.total = total;
+        this.offsets = [];
+        this.heights = [];
+        var agg = 0;
+        for (var idx = 0; idx < total; idx++) {
+            this.offsets.push(agg);
+            var currHeight = (data && data[idx].expanded && data[idx].rowType === 'data') ? detailRowHeight : rowHeight;
+            agg += currHeight;
+            this.heights.push(currHeight);
+        }
+    }
+    RowHeightService.prototype.height = function (rowIndex) {
+        return this.heights[rowIndex];
+    };
+    RowHeightService.prototype.index = function (position) {
+        if (position < 0) {
+            return undefined;
+        }
+        var result = this.offsets.reduce(function (prev, current, idx) {
+            if (prev !== undefined) {
+                return prev;
+            }
+            else if (current === position) {
+                return idx;
+            }
+            else if (current > position) {
+                return idx - 1;
+            }
+            return undefined;
+        }, undefined);
+        return result === undefined ? this.total - 1 : result;
+    };
+    RowHeightService.prototype.offset = function (rowIndex) {
+        return this.offsets[rowIndex];
+    };
+    RowHeightService.prototype.totalHeight = function () {
+        var lastOffset = this.offsets[this.offsets.length - 1];
+        var lastHeight = this.heights[this.heights.length - 1];
+        return lastOffset + lastHeight;
+        // return this.heights.reduce((prev, curr) => prev + curr, 0);
+    };
+    return RowHeightService;
+}());
+exports.RowHeightService = RowHeightService;
+/**
+ * @hidden
+ */
+var VirtualScrollFixed = /** @class */ (function () {
+    function VirtualScrollFixed(_cached) {
+        this.table = null;
+        this.containerHeight = 0;
+        this.topCacheCount = 0;
+        this.attendedSkip = 0;
+        this.propsSkip = 0;
+        this.total = 0;
+        this.scrollableVirtual = false;
+        this.realSkip = 0;
+        this.pageSize = 0;
+        this.PageChange = null;
+        this.tableBodyRef = React.createRef();
+        this.fixedScroll = false;
+        this.askedSkip = undefined;
+        this.containerRef = React.createRef();
+        this.tableTransform = '';
+        this.scrollSyncing = false;
+        this.lastLoaded = 0;
+        this.firstLoaded = 0;
+        this.lastScrollTop = 0;
+        this.reactVersion = Number.parseFloat(React.version);
+        this.firstLoaded = this.pageSize;
+        this.lastLoaded = this.realSkip + this.pageSize;
+        this.scrollHandler = this.scrollHandler.bind(this);
+    }
+    Object.defineProperty(VirtualScrollFixed.prototype, "container", {
+        get: function () {
+            return this.containerRef.current;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VirtualScrollFixed.prototype.translate = function (dY, forceSet) {
+        if (this.scrollableVirtual && this.table) {
+            if (this.reactVersion <= 17 || forceSet) {
+                this.table.style.transform = 'translateY(' + dY + 'px)';
+            }
+            else {
+                this.tableTransform = 'translateY(' + dY + 'px)';
+            }
+        }
+    };
+    VirtualScrollFixed.prototype.changePage = function (skip, e) {
+        if (this.PageChange) {
+            this.PageChange({ skip: Math.max(0, skip), take: this.pageSize }, e);
+        }
+    };
+    VirtualScrollFixed.prototype.reset = function () {
+        this.scrollSyncing = true;
+        if (this.fixedScroll) {
+            return;
+        }
+        if (this.container) {
+            this.container.scrollTop = 0;
+        }
+        this.translate(0, true);
+    };
+    VirtualScrollFixed.prototype.scrollHandler = function (e) {
+        if (!this.scrollableVirtual || !this.container || !this.table ||
+            !this.rowHeightService || !this.containerRef.current) {
+            return;
+        }
+        if (this.scrollSyncing) {
+            this.scrollSyncing = false;
+            return;
+        }
+        var scrollTop = this.container.scrollTop;
+        var up = this.lastScrollTop >= scrollTop;
+        var down = !up;
+        this.lastScrollTop = scrollTop;
+        var firstItemIndex = this.rowHeightService.index(scrollTop);
+        var firstItemOffset = this.rowHeightService.offset(firstItemIndex);
+        var offsetHeight = this.containerRef.current.offsetHeight;
+        var lastItemIndex = this.rowHeightService.index(scrollTop + offsetHeight);
+        if (down && lastItemIndex >= this.lastLoaded && this.lastLoaded < this.total) {
+            var overflow = (firstItemIndex + this.pageSize) - this.total;
+            if (overflow > 0) {
+                firstItemIndex = firstItemIndex - overflow;
+                firstItemOffset = this.rowHeightService.offset(firstItemIndex);
+            }
+            this.firstLoaded = firstItemIndex;
+            this.translate(firstItemOffset);
+            var nextTake = this.firstLoaded + this.pageSize;
+            this.lastLoaded = Math.min(nextTake, this.total);
+            this.changePage(this.firstLoaded, e);
+        }
+        else if (up && firstItemIndex < this.firstLoaded) {
+            var nonVisibleBuffer = Math.floor(this.pageSize * 0.3);
+            this.firstLoaded = Math.max(firstItemIndex - nonVisibleBuffer, 0);
+            this.translate(this.rowHeightService.offset(this.firstLoaded));
+            this.lastLoaded = Math.min(this.firstLoaded + this.pageSize, this.total);
+            this.changePage(this.firstLoaded, e);
+        }
+    };
+    return VirtualScrollFixed;
+}());
+exports.VirtualScrollFixed = VirtualScrollFixed;

package/dist/npm/interfaces/GridProps.d.ts

@@ -212,6 +212,10 @@ export interface GridProps extends KendoReactComponentBaseProps {
      * Defines the row height and forces an equal height to all rows ([see example]({% slug scrollmodes_grid %})).
      */
     rowHeight?: number;
+    /**
+     * Defines the detail row height and forces an equal height to all detail rows.
+     */
+    detailRowHeight?: number;
     /**
      * Specifies a React element that will be cloned and rendered inside the detail rows of the currently expanded items ([see example]({% slug hierarchy_grid %})). An item will be rendered as expanded if the value of its `expandField` is `true`.
      */

package/dist/npm/interfaces/VirtualScrollInterface.d.ts

@@ -0,0 +1,27 @@
+import { Page } from '../paging/Page';
+import { SyntheticEvent, RefObject } from 'react';
+import { RowHeightService } from '../VirtualScrollFixed';
+/**
+ * @hidden
+ */
+export interface VirtualScrollInterface {
+    get container(): HTMLDivElement | null;
+    askedSkip: number | undefined;
+    total: number;
+    reset: () => void;
+    table: HTMLTableElement | null;
+    tableBodyRef: RefObject<HTMLTableSectionElement>;
+    fixedScroll: boolean;
+    PageChange: ((event: Page, syntheticEvent: SyntheticEvent<any>) => void) | null;
+    realSkip: number;
+    pageSize: number;
+    scrollableVirtual: boolean;
+    propsSkip: number;
+    topCacheCount: number;
+    attendedSkip: number;
+    containerHeight: number;
+    containerRef: RefObject<HTMLDivElement>;
+    scrollHandler(e: SyntheticEvent<HTMLDivElement>): void;
+    rowHeightService?: RowHeightService;
+    tableTransform: string;
+}

package/dist/npm/interfaces/VirtualScrollInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/npm/package-metadata.js

@@ -8,7 +8,7 @@ exports.packageMetadata = {
     name: '@progress/kendo-react-grid',
     productName: 'KendoReact',
     productCodes: ['KENDOUIREACT', 'KENDOUICOMPLETE'],
-    publishDate: 1675429179,
+    publishDate: 1675783223,
     version: '',
     licensingDocsUrl: 'https://www.telerik.com/kendo-react-ui/my-license/?utm_medium=product&utm_source=kendoreact&utm_campaign=kendo-ui-react-purchase-license-keys-warning'
 };