@progress/kendo-vue-grid 3.8.4-dev.202302210950 → 3.8.4-dev.202302221749

package/dist/es/Grid.d.ts

@@ -6,7 +6,7 @@ import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } fr
 import { Page, TableKeyboardNavigationContextType, TableKeyboardNavigationStateType } from '@progress/kendo-vue-data-tools';
 import { ExtendedColumnProps } from './interfaces/ExtendedColumnProps';
 import { SortDescriptor, CompositeFilterDescriptor, GroupDescriptor, State } from '@progress/kendo-data-query';
-import { VirtualScroll } from './VirtualScroll';
+import { VirtualScrollInterface } from './interfaces/VirtualScrollInterface';
 import { ColumnResize } from './drag/ColumnResize';
 import { CommonDragLogic } from './drag/CommonDragLogic';
 import { DataItemWrapper } from './utils/main';
@@ -120,10 +120,14 @@ export interface GridData {
 export interface GridState {
     initialHeight: String | null;
     dragLogic: CommonDragLogic;
-    vs: VirtualScroll;
+    slicedCurrentData: Array<DataItemWrapper> | undefined;
+    containerRef: any;
+    tableBodyRef: any;
+    vs: VirtualScrollInterface;
     columnResize: ColumnResize;
     _gridId: string;
     v3: boolean;
+    _prevTotal: number | undefined;
 }
 /**
  * @hidden

package/dist/es/Grid.js

@@ -54,11 +54,12 @@ import { FooterRow } from './footer/FooterRow';
 import { GridCellValue } from './GridCellValue';
 import { operators } from './filterCommon';
 import { VirtualScroll } from './VirtualScroll';
+import { RowHeightService, VirtualScrollFixed } from './VirtualScrollFixed';
 import { ColumnResize } from './drag/ColumnResize';
 import { CommonDragLogic } from './drag/CommonDragLogic';
 import { DragClue } from './drag/DragClue';
 import { DropClue } from './drag/DropClue';
-import { flatData, mapColumns, readColumns, autoGenerateColumns, applyExpandedState, groupedFirstItemValue } from './utils/main';
+import { flatData, mapColumns, readColumns, firefox, firefoxMaxHeight, autoGenerateColumns, applyExpandedState, groupedFirstItemValue } from './utils/main';
 import { GridCell } from './cells/GridCell';
 import { GridGroupCell } from './cells/GridGroupCell';
 import { GridRow } from './rows/GridRow';
@@ -126,6 +127,7 @@ var GridVue2 = {
     },
     pager: templateDefinition,
     rowHeight: Number,
+    detailRowHeight: Number,
     detail: templateDefinition,
     columnMenu: [Boolean, String, Function, Object],
     columnMenuAnimate: {
@@ -166,7 +168,8 @@ var GridVue2 = {
     this.initialHeight = null;
     this._columns = [];
     var groupable = this.currentGroupable;
-    this.vs = new VirtualScroll(groupable || this.$props.rowHeight === undefined || this.$props.rowHeight === 0, this.$props.topCacheCount);
+    var VS = this.getVirtualScroll();
+    this.vs = new VS(groupable || this.$props.rowHeight === undefined || this.$props.rowHeight === 0, this.$props.topCacheCount);
     this.dragLogic = new CommonDragLogic(this.columnReorder.bind(this), this.groupReorder.bind(this), this.columnToGroup.bind(this));
     this.columnResize = new ColumnResize(this.onResize.bind(this));
     this._columnsMap = [[]];
@@ -175,11 +178,13 @@ var GridVue2 = {
     this.forceUpdateTimeout = undefined;
     this._gridId = guid();
     this._gridRoleElementId = guid(); // Needed for aria-control accessibility attribute
+    this.slicedCurrentData = undefined;
+    this._prevTotal = undefined;
   },
-
   mounted: function mounted() {
     this.setRefs();
     var rtl = isRtl(this._element);
+    this._prevTotal = this.$props.total;
     this.isRtl = rtl;
     // @ts-ignore
     this.initialHeight = this._element.style ? this._element.style.height : null;
@@ -188,6 +193,11 @@ var GridVue2 = {
     this.setRefs();
     var rtl = isRtl(this._element);
     this.isRtl = rtl;
+    this._prevTotal = this.$props.total;
+    if (this.vs.tableTransform && this.vs.table) {
+      this.vs.table.style.transform = this.vs.tableTransform;
+      this.vs.tableTransform = '';
+    }
   },
   destroyed: !!isV3 ? undefined : function () {
     this.gridUnmounted();
@@ -329,10 +339,10 @@ var GridVue2 = {
       this.columnResize.colGroupMain = getRef(this, 'colGroup');
       this._header = getRef(this, 'header');
       this._footer = getRef(this, 'footer');
-      this.vs.container = getRef(this, 'scrollContainer');
+      this.vs.containerRef = getRef(this, 'scrollContainer');
       this.vs.table = getRef(this, 'scrollTable');
       this.resetTableWidth();
-      this.vs.tableBody = getRef(this, 'scrollTableBody');
+      this.vs.tableBodyRef = getRef(this, 'scrollTableBody');
     },
     gridUnmounted: function gridUnmounted() {
       clearTimeout(this.forceUpdateTimeout);
@@ -352,6 +362,62 @@ var GridVue2 = {
       this.vs.scrollableVirtual = this.$props.scrollable === 'virtual';
       this.vs.propsSkip = (this.$props.skip || 0) + (this.$props.scrollable === 'virtual' ? this.vs.topCacheCount + (this.vs.attendedSkip - (this.$props.skip || 0)) : 0);
     },
+    getVirtualScroll: function getVirtualScroll() {
+      return VirtualScroll;
+    },
+    isAllData: function isAllData() {
+      var _a = this.$props,
+        dataItems = _a.dataItems,
+        total = _a.total;
+      if (Array.isArray(dataItems)) {
+        return dataItems.length === total;
+      } else if (dataItems) {
+        return total === dataItems.total;
+      }
+      return false;
+    },
+    initializeVirtualization: function initializeVirtualization(total) {
+      if (this.$props.total !== this._prevTotal || this.$props.scrollable === 'virtual' !== this.vs.scrollableVirtual) {
+        this.vs.reset();
+      }
+      this.resetVirtual();
+      this.vs.total = total;
+      if (this.$props.rowHeight !== undefined && this.$props.rowHeight > 0 && !this.currentGroupable) {
+        this.vs.containerHeight = Math.min(1533915, this.$props.rowHeight * (total || 0));
+      } else {
+        if (this.$props.totalGroupedHeight) {
+          this.vs.containerHeight = Math.min(1533915, this.$props.totalGroupedHeight);
+        } else if (this.$props.allGroupedItems && this.$props.allGroupedItems.data) {
+          var allGroupedTotal = this.totalGroupedRows(applyExpandedState(this.$props.allGroupedItems, this.computedCollapsed, this.$props.uniqueField).data);
+          this.vs.containerHeight = Math.min(1533915, this.$props.rowHeight * allGroupedTotal);
+        } else {
+          this.vs.containerHeight = 1533915;
+        }
+      }
+      this.vs.containerRef = this.containerRef;
+      this.vs.tableBodyRef = this.tableBodyRef;
+      this.vs.table = this.tableElement;
+      this.slicedCurrentData = undefined;
+      if (this.vs instanceof VirtualScrollFixed) {
+        var _a = this.$props,
+          _b = _a.rowHeight,
+          rowHeight = _b === void 0 ? 0 : _b,
+          detail = _a.detail,
+          expandField = _a.expandField;
+        var _c = this.$props.detailRowHeight,
+          detailRowHeight = _c === void 0 ? 0 : _c;
+        detailRowHeight = Boolean(detail && expandField) ? detailRowHeight : rowHeight;
+        if (this.isAllData()) {
+          this.vs.total = this.currentData.length;
+          this.slicedCurrentData = this.currentData.slice(this.vs.realSkip, this.vs.realSkip + this.vs.pageSize);
+          this.vs.rowHeightService = this.rowHeightService(this.vs, this.currentData.length, rowHeight, detailRowHeight, this.currentData);
+        } else {
+          this.vs.rowHeightService = new RowHeightService(total, rowHeight, detailRowHeight);
+        }
+        var containerHeight = this.vs.rowHeightService.totalHeight();
+        this.vs.containerHeight = firefox ? Math.min(firefoxMaxHeight, containerHeight) : containerHeight;
+      }
+    },
     onSkipChanged: function onSkipChanged(value, _oldValue) {
       if (Math.max(0, this.vs.attendedSkip) !== value && value !== undefined) {
         this.vs.attendedSkip = value;
@@ -784,7 +850,7 @@ var GridVue2 = {
         if (item.expanded !== false && item.items) {
           allRowsCount = _this.addSubItems(item.items, allRowsCount);
         }
-        if (_this.group && _this.group.length && (_this.$props.groupable.footer === 'always' || item.expanded !== false && _this.$props.groupable.footer === 'visible')) {
+        if (_this.group && _this.group.length && (_this.$props.groupable.footer === 'always' || item.expanded !== false && item.items && _this.$props.groupable.footer === 'visible')) {
           allRowsCount++;
         }
       });
@@ -837,26 +903,13 @@ var GridVue2 = {
     this.columnResize.resizable = this.$props.resizable || false;
     this.dragLogic.reorderable = this.$props.reorderable || false;
     this.dragLogic.groupable = groupable;
-    this.resetVirtual();
-    this.vs.total = total;
-    if (this.$props.rowHeight !== undefined && this.$props.rowHeight > 0 && !this.currentGroupable) {
-      this.vs.containerHeight = Math.min(1533915, this.$props.rowHeight * (total || 0));
-    } else {
-      if (this.$props.totalGroupedHeight) {
-        this.vs.containerHeight = Math.min(1533915, this.$props.totalGroupedHeight);
-      } else if (this.$props.allGroupedItems && this.$props.allGroupedItems.data) {
-        var allGroupedTotal = this.totalGroupedRows(applyExpandedState(this.$props.allGroupedItems, this.computedCollapsed, this.$props.uniqueField).data);
-        this.vs.containerHeight = Math.min(1533915, this.$props.rowHeight * allGroupedTotal);
-      } else {
-        this.vs.containerHeight = 1533915;
-      }
-    }
-    var children = defaultSlot || [];
+    this.initializeVirtualization(total);
     var groupingFooter = isObject(this.$props.groupable) && this.$props.groupable.footer || 'none';
     this.currentData = [];
     var resolvedGroupsCount = flatData(this.currentData, gridData, groupingFooter, {
       index: this.$props.skip || 0
     }, this.$props.group !== undefined, this.$props.expandField);
+    var children = defaultSlot || [];
     var notHiddenColumns = this.$props.columns ? this.$props.columns.filter(function (column) {
       return !column.hidden;
     }) : this.$props.columns;
@@ -1698,7 +1751,8 @@ var GridVue2 = {
         key: detailRowId,
         "class": isAlt ? 'k-table-row k-table-alt-row k-detail-row k-alt' : 'k-table-row k-detail-row',
         style: {
-          visibility: hidden(rowIndex) ? 'hidden' : ''
+          visibility: hidden(rowIndex) ? 'hidden' : '',
+          height: this.$props.detailRowHeight + 'px'
         },
         role: "row",
         attrs: this.v3 ? undefined : {

package/dist/es/VirtualScroll.d.ts

@@ -1,10 +1,11 @@
 import { Page } from '@progress/kendo-vue-data-tools';
+import { VirtualScrollInterface } from './interfaces/VirtualScrollInterface';
+import { RowHeightService } from './VirtualScrollFixed';
 /**
  * @hidden
  */
-export declare class VirtualScroll {
-    container: any;
-    table: any;
+export declare class VirtualScroll implements VirtualScrollInterface {
+    table: HTMLTableElement | null;
     containerHeight: number;
     topCacheCount: number;
     attendedSkip: number;
@@ -14,10 +15,13 @@ export declare class VirtualScroll {
     realSkip: number;
     pageSize: number;
     PageChange: (page: Page, event: any) => void;
-    tableBody: any;
-    heightContainer: any;
+    tableBodyRef: any;
     fixedScroll: boolean;
     askedSkip: number | undefined;
+    containerRef: any;
+    tableTransform: string;
+    rowHeightService?: RowHeightService;
+    get container(): HTMLDivElement | null;
     private prevScrollPos;
     private tableTranslate;
     private scrollSyncing;

package/dist/es/VirtualScroll.js

@@ -4,6 +4,7 @@
 var VirtualScroll = /** @class */ (function () {
     function VirtualScroll(cached, topCacheCount) {
         var _this = this;
+        this.table = null;
         this.containerHeight = 0;
         this.topCacheCount = 0; // 4;
         this.attendedSkip = 0; // -4;
@@ -12,9 +13,9 @@ var VirtualScroll = /** @class */ (function () {
         this.scrollableVirtual = false;
         this.realSkip = 0;
         this.pageSize = 0;
-        this.heightContainer = null;
         this.fixedScroll = false;
         this.askedSkip = undefined;
+        this.tableTransform = '';
         this.prevScrollPos = 0;
         this.tableTranslate = 0;
         this.scrollSyncing = false;
@@ -23,8 +24,9 @@ var VirtualScroll = /** @class */ (function () {
                 return { topItemsCount: 0, topItemsHeight: 0 };
             }
             var screenHeight = _this.container.clientHeight;
+            var footerRowsCount = _this.container.querySelectorAll('.k-group-footer').length;
             var itemsOnScreen = Math.ceil(screenHeight / heights[0].line);
-            var topItemsCount = Math.ceil((heights.length - itemsOnScreen) / 2);
+            var topItemsCount = Math.max(itemsOnScreen / 2, Math.ceil((heights.length - itemsOnScreen) / 2));
             var topItemsHeight = 0;
             for (var i = 0; i < topItemsCount; i++) {
                 topItemsHeight += heights[i].line + heights[i].acc;
@@ -32,7 +34,7 @@ var VirtualScroll = /** @class */ (function () {
             return {
                 topItemsCount: topItemsCount,
                 topItemsHeight: topItemsHeight,
-                itemsNeededOnScreen: itemsOnScreen + itemsOnScreen / 2
+                itemsNeededOnScreen: itemsOnScreen + itemsOnScreen / 2 + footerRowsCount
             };
         };
         this.horizontalScrollbarHeight = function () {
@@ -47,13 +49,20 @@ var VirtualScroll = /** @class */ (function () {
         }
         this.scrollHandler = this.scrollHandler.bind(this);
     }
+    Object.defineProperty(VirtualScroll.prototype, "container", {
+        get: function () {
+            return this.containerRef;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(VirtualScroll.prototype, "rowHeights", {
         /**
          * @return - The row heights in an array.
          */
         get: function () {
             var result = [];
-            var allRows = this.tableBody && this.tableBody.children || [];
+            var allRows = this.tableBodyRef && this.tableBodyRef.children || [];
             var accumulate = 0;
             for (var i = 0; i < allRows.length; i++) {
                 if (allRows[i].className.indexOf('k-grouping-row') > -1) {

package/dist/es/VirtualScrollFixed.d.ts

@@ -0,0 +1,47 @@
+import { Page } from '@progress/kendo-vue-data-tools';
+import { VirtualScrollInterface } from './interfaces/VirtualScrollInterface';
+import { DataItemWrapper } from './utils/main';
+/**
+ * @hidden
+ */
+export declare class RowHeightService {
+    private total;
+    private offsets;
+    private heights;
+    constructor(total: number, rowHeight: number, detailRowHeight: number, data?: DataItemWrapper[]);
+    height(rowIndex: number): number;
+    index(position: number): number | undefined;
+    offset(rowIndex: number): number;
+    totalHeight(): number;
+}
+/**
+ * @hidden
+ */
+export declare class VirtualScrollFixed implements VirtualScrollInterface {
+    table: HTMLTableElement | null;
+    containerHeight: number;
+    topCacheCount: number;
+    attendedSkip: number;
+    propsSkip: number;
+    total: number;
+    scrollableVirtual: boolean;
+    realSkip: number;
+    pageSize: number;
+    PageChange: ((event: Page, evnet: any) => void) | null;
+    tableBodyRef: any;
+    fixedScroll: boolean;
+    askedSkip: number | undefined;
+    containerRef: any;
+    tableTransform: string;
+    rowHeightService?: RowHeightService;
+    private scrollSyncing;
+    private lastLoaded;
+    private firstLoaded;
+    private lastScrollTop;
+    get container(): HTMLDivElement | null;
+    constructor(_cached: boolean);
+    translate(dY: number): void;
+    changePage(skip: number, e: any): void;
+    reset(): void;
+    scrollHandler(e: any): void;
+}

package/dist/es/VirtualScrollFixed.js

@@ -0,0 +1,144 @@
+/**
+ * @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;
+}());
+export { 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.fixedScroll = false;
+        this.askedSkip = undefined;
+        this.tableTransform = '';
+        this.scrollSyncing = false;
+        this.lastLoaded = 0;
+        this.firstLoaded = 0;
+        this.lastScrollTop = 0;
+        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;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    VirtualScrollFixed.prototype.translate = function (dY) {
+        if (this.scrollableVirtual && this.table) {
+            this.table.style.transform = '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);
+    };
+    VirtualScrollFixed.prototype.scrollHandler = function (e) {
+        if (!this.scrollableVirtual || !this.container || !this.table ||
+            !this.rowHeightService || !this.containerRef) {
+            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.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;
+}());
+export { VirtualScrollFixed };

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

@@ -222,6 +222,10 @@ export interface GridProps {
      * ([see example]({% slug scrollmmodes_grid %})).
      */
     rowHeight?: number;
+    /**
+     * @hidden
+     */
+    detailRowHeight?: number;
     /**
      * Specifies a custom rendering that will be cloned and rendered inside the detail rows
      * of the currently expanded items ([see example]({% slug master_detail_grid %}).

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

@@ -0,0 +1,26 @@
+import { Page } from '@progress/kendo-vue-data-tools';
+import { RowHeightService } from '../VirtualScrollFixed';
+/**
+ * @hidden
+ */
+export interface VirtualScrollInterface {
+    PageChange: ((page: Page, e: any) => void) | null;
+    reset: () => void;
+    askedSkip: number | undefined;
+    total: number;
+    table: HTMLTableElement | null;
+    tableBodyRef: any;
+    fixedScroll: boolean;
+    realSkip: number;
+    pageSize: number;
+    scrollableVirtual: boolean;
+    propsSkip: number;
+    topCacheCount: number;
+    attendedSkip: number;
+    containerHeight: number;
+    containerRef: any;
+    tableTransform: string;
+    rowHeightService?: RowHeightService;
+    get container(): HTMLDivElement | null;
+    scrollHandler(e: any): void;
+}

package/dist/es/interfaces/VirtualScrollInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/es/package-metadata.js

@@ -5,7 +5,7 @@ export var packageMetadata = {
     name: '@progress/kendo-vue-grid',
     productName: 'Kendo UI for Vue',
     productCodes: ['KENDOUIVUE', 'KENDOUICOMPLETE'],
-    publishDate: 1676972347,
+    publishDate: 1677087515,
     version: '',
     licensingDocsUrl: 'https://www.telerik.com/kendo-vue-ui/my-license/?utm_medium=product&utm_source=kendovue&utm_campaign=kendo-ui-vue-purchase-license-keys-warning'
 };

package/dist/es/utils/main.d.ts

@@ -89,3 +89,11 @@ export declare function applyExpandedState(sdata: DataResult, collapsed: any[],
  * @hidden
  */
 export declare function groupedFirstItemValue(item: any, field: string): any;
+/**
+ * @hidden
+ */
+export declare const firefox: boolean;
+/**
+ * @hidden
+ */
+export declare const firefoxMaxHeight = 17895697;

package/dist/es/utils/main.js

@@ -391,3 +391,12 @@ export function groupedFirstItemValue(item, field) {
     }
     return field ? resultItem[field] : item.value;
 }
+/**
+ * @hidden
+ */
+export var firefox = typeof window !== 'undefined' &&
+    /Firefox/.test(window.navigator.userAgent);
+/**
+ * @hidden
+ */
+export var firefoxMaxHeight = 17895697;

package/dist/esm/Grid.d.ts

@@ -6,7 +6,7 @@ import { DefineComponent, RecordPropsDefinition, ComponentOptions, Vue2type } fr
 import { Page, TableKeyboardNavigationContextType, TableKeyboardNavigationStateType } from '@progress/kendo-vue-data-tools';
 import { ExtendedColumnProps } from './interfaces/ExtendedColumnProps';
 import { SortDescriptor, CompositeFilterDescriptor, GroupDescriptor, State } from '@progress/kendo-data-query';
-import { VirtualScroll } from './VirtualScroll';
+import { VirtualScrollInterface } from './interfaces/VirtualScrollInterface';
 import { ColumnResize } from './drag/ColumnResize';
 import { CommonDragLogic } from './drag/CommonDragLogic';
 import { DataItemWrapper } from './utils/main';
@@ -120,10 +120,14 @@ export interface GridData {
 export interface GridState {
     initialHeight: String | null;
     dragLogic: CommonDragLogic;
-    vs: VirtualScroll;
+    slicedCurrentData: Array<DataItemWrapper> | undefined;
+    containerRef: any;
+    tableBodyRef: any;
+    vs: VirtualScrollInterface;
     columnResize: ColumnResize;
     _gridId: string;
     v3: boolean;
+    _prevTotal: number | undefined;
 }
 /**
  * @hidden