@mui/x-virtualizer 0.2.10 → 0.2.11

package/esm/models/core.d.ts

@@ -62,6 +62,13 @@ export type ScrollPosition = {
   top: number;
   left: number;
 };
+export declare const ScrollPosition: {
+  EMPTY: {
+    top: number;
+    left: number;
+  };
+  equals: (a: ScrollPosition, b: ScrollPosition) => boolean;
+};
 export declare enum ScrollDirection {
   NONE = 0,
   UP = 1,

package/esm/models/core.js

@@ -22,6 +22,13 @@ export const PinnedColumns = {
     right: []
   }
 };
+export const ScrollPosition = {
+  EMPTY: {
+    top: 0,
+    left: 0
+  },
+  equals: (a, b) => a.top === b.top && a.left === b.left
+};
 export let ScrollDirection = /*#__PURE__*/function (ScrollDirection) {
   ScrollDirection[ScrollDirection["NONE"] = 0] = "NONE";
   ScrollDirection[ScrollDirection["UP"] = 1] = "UP";

package/esm/models/dimensions.d.ts

@@ -65,6 +65,14 @@ export interface DimensionsState {
    * Size of the bottom container.
    */
   bottomContainerHeight: number;
+  /**
+   * Indicates that the container takes the height of its content.
+   */
+  autoHeight: boolean;
+  /**
+   * Minimal height to display the content area.
+   */
+  minimalContentHeight: string | number | undefined;
 }
 /**
  * The rows total height and positions.

package/esm/useVirtualizer.d.ts

@@ -1,25 +1,21 @@
 import * as React from 'react';
-import { integer, RefObject } from '@mui/x-internals/types';
+import { integer } from '@mui/x-internals/types';
 import { Store } from '@mui/x-internals/store';
 import { Colspan } from "./features/colspan.js";
 import { Dimensions } from "./features/dimensions.js";
 import { Rowspan } from "./features/rowspan.js";
-import { Virtualization } from "./features/virtualization.js";
+import { Virtualization } from "./features/virtualization/index.js";
+import type { Layout } from "./features/virtualization/layout.js";
 import type { HeightEntry, RowSpacing } from "./models/dimensions.js";
 import type { ColspanParams } from "./features/colspan.js";
 import type { DimensionsParams } from "./features/dimensions.js";
-import type { VirtualizationParams } from "./features/virtualization.js";
+import type { VirtualizationParams } from "./features/virtualization/index.js";
 import { ColumnWithWidth, FocusedCell, Size, PinnedRows, PinnedColumns, RenderContext, Row, RowEntry } from "./models/index.js";
 export type Virtualizer = ReturnType<typeof useVirtualizer>;
-export type VirtualScrollerCompat = Virtualization.State['getters'];
-export type BaseState = Virtualization.State & Dimensions.State;
-export type VirtualizerParams = {
-  refs: {
-    container: RefObject<HTMLDivElement | null>;
-    scroller: RefObject<HTMLDivElement | null>;
-    scrollbarVertical: RefObject<HTMLDivElement | null>;
-    scrollbarHorizontal: RefObject<HTMLDivElement | null>;
-  };
+export type VirtualScrollerCompat<L extends Layout = Layout> = Virtualization.State<L>['getters'];
+export type BaseState<L extends Layout = Layout> = Virtualization.State<L> & Dimensions.State;
+export type VirtualizerParams<L extends Layout = Layout> = {
+  layout: L;
   dimensions: DimensionsParams;
   virtualization: VirtualizationParams;
   colspan?: ColspanParams;
@@ -29,7 +25,7 @@ export type VirtualizerParams = {
       left: number;
     };
     rowSpanning?: Rowspan.State['rowSpanning'];
-    virtualization?: Partial<Virtualization.State['virtualization']>;
+    virtualization?: Partial<Virtualization.State<L>['virtualization']>;
   };
   /** current page rows */
   rows: RowEntry[];
@@ -39,13 +35,11 @@ export type VirtualizerParams = {
     lastRowIndex: integer;
   } | null;
   rowCount: integer;
-  columns: ColumnWithWidth[];
+  columns?: ColumnWithWidth[];
   pinnedRows?: PinnedRows;
   pinnedColumns?: PinnedColumns;
-  autoHeight: boolean;
   disableHorizontalScroll?: boolean;
   disableVerticalScroll?: boolean;
-  minimalContentHeight?: number | string;
   getRowHeight?: (row: RowEntry) => number | null | undefined | 'auto';
   /**
    * Function that returns the estimated height for a row.
@@ -68,7 +62,7 @@ export type VirtualizerParams = {
    */
   applyRowHeight?: (entry: HeightEntry, rowEntry: RowEntry) => void;
   virtualizeColumnsWithAutoRowHeight?: boolean;
-  resizeThrottleMs: number;
+  resizeThrottleMs?: number;
   onResize?: (lastSize: Size) => void;
   onWheel?: (event: React.WheelEvent) => void;
   onTouchMove?: (event: React.TouchEvent) => void;
@@ -94,10 +88,15 @@ export type VirtualizerParams = {
     isVirtualFocusRow: boolean;
     showBottomBorder: boolean;
   }) => React.ReactElement;
-  renderInfiniteLoadingTrigger: (id: any) => React.ReactElement;
+  renderInfiniteLoadingTrigger?: (id: any) => React.ReactElement;
+};
+type RequiredFields<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export type ParamsWithDefaults = RequiredFields<VirtualizerParams, 'resizeThrottleMs' | 'columns'> & {
+  dimensions: RequiredFields<VirtualizerParams['dimensions'], 'columnsTotalWidth' | 'leftPinnedWidth' | 'rightPinnedWidth' | 'topPinnedHeight' | 'bottomPinnedHeight' | 'autoHeight'>;
+  virtualization: RequiredFields<VirtualizerParams['virtualization'], 'isRtl' | 'rowBufferPx' | 'columnBufferPx'>;
 };
-export declare const useVirtualizer: (params: VirtualizerParams) => {
-  store: Store<Dimensions.State & Virtualization.State & Colspan.State & Rowspan.State>;
+export declare const useVirtualizer: <L extends Layout = Layout>(params: VirtualizerParams<L>) => {
+  store: Store<Dimensions.State & Virtualization.State<L> & Colspan.State & Rowspan.State>;
   api: {
     updateDimensions: (firstUpdate?: boolean) => void;
     debouncedUpdateDimensions: (((firstUpdate?: boolean) => void) & import("@mui/x-internals/throttle").Cancelable) | undefined;
@@ -113,57 +112,13 @@ export declare const useVirtualizer: (params: VirtualizerParams) => {
       resetRowHeights: () => void;
     };
   } & {
-    getters: {
-      setPanels: React.Dispatch<React.SetStateAction<Readonly<Map<any, React.ReactNode>>>>;
-      getOffsetTop: () => number;
-      getRows: (rowParams?: {
-        rows?: RowEntry[];
-        position?: import("./models/index.js").PinnedRowPosition;
-        renderContext?: RenderContext;
-      }, unstable_rowTree?: Record<import("./models/index.js").RowId, any>) => React.ReactNode[];
-      rows: RowEntry[];
-      getContainerProps: () => {
-        ref: (node: HTMLDivElement | null) => (() => void | undefined) | undefined;
-      };
-      getScrollerProps: () => {
-        ref: (node: HTMLDivElement | null) => (() => void | undefined) | undefined;
-        style: React.CSSProperties;
-        role: string;
-        tabIndex: number | undefined;
-      };
-      getContentProps: () => {
-        ref: (node: HTMLDivElement | null) => void;
-        style: React.CSSProperties;
-        role: string;
-      };
-      getScrollbarVerticalProps: () => {
-        ref: (node: HTMLDivElement | null) => void;
-        scrollPosition: React.RefObject<{
-          top: number;
-          left: number;
-        }>;
-      };
-      getScrollbarHorizontalProps: () => {
-        ref: (node: HTMLDivElement | null) => void;
-        scrollPosition: React.RefObject<{
-          top: number;
-          left: number;
-        }>;
-      };
-      getScrollAreaProps: () => {
-        scrollPosition: React.RefObject<{
-          top: number;
-          left: number;
-        }>;
-      };
-    };
-    useVirtualization: () => BaseState;
-    setPanels: React.Dispatch<React.SetStateAction<Readonly<Map<any, React.ReactNode>>>>;
-    forceUpdateRenderContext: () => void;
-    scheduleUpdateRenderContext: () => void;
     getCellColSpanInfo: (rowId: import("./models/index.js").RowId, columnIndex: integer) => import("./models/index.js").CellColSpanInfo;
     calculateColSpan: (rowId: import("./models/index.js").RowId, minFirstColumn: integer, maxLastColumn: integer, columns: ColumnWithWidth[]) => void;
     getHiddenCellsOrigin: () => Record<import("./models/index.js").RowId, Record<number, number>>;
+    getters: any;
+    setPanels: React.Dispatch<React.SetStateAction<Readonly<Map<any, React.ReactNode>>>>;
+    forceUpdateRenderContext: () => void;
+    scheduleUpdateRenderContext: () => void;
   } & {
     resetColSpan: () => void;
     getCellColSpanInfo: (rowId: import("./models/index.js").RowId, columnIndex: integer) => import("./models/index.js").CellColSpanInfo | undefined;
@@ -173,4 +128,5 @@ export declare const useVirtualizer: (params: VirtualizerParams) => {
   } & {
     getViewportPageSize: () => number;
   };
-};
+};
+export {};

package/esm/useVirtualizer.js

@@ -1,10 +1,12 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
 import useLazyRef from '@mui/utils/useLazyRef';
 import { Store } from '@mui/x-internals/store';
 import { Colspan } from "./features/colspan.js";
 import { Dimensions } from "./features/dimensions.js";
 import { Keyboard } from "./features/keyboard.js";
 import { Rowspan } from "./features/rowspan.js";
-import { Virtualization } from "./features/virtualization.js";
+import { Virtualization } from "./features/virtualization/index.js";
+import { DEFAULT_PARAMS } from "./constants.js";
 
 /* eslint-disable jsdoc/require-param-type */
 /* eslint-disable jsdoc/require-param-description */
@@ -12,15 +14,30 @@ import { Virtualization } from "./features/virtualization.js";
 
 const FEATURES = [Dimensions, Virtualization, Colspan, Rowspan, Keyboard];
 export const useVirtualizer = params => {
+  const paramsWithDefault = mergeDefaults(params, DEFAULT_PARAMS);
   const store = useLazyRef(() => {
-    return new Store(FEATURES.map(f => f.initialize(params)).reduce((state, partial) => Object.assign(state, partial), {}));
+    return new Store(FEATURES.map(f => f.initialize(paramsWithDefault)).reduce((state, partial) => Object.assign(state, partial), {}));
   }).current;
   const api = {};
   for (const feature of FEATURES) {
-    Object.assign(api, feature.use(store, params, api));
+    Object.assign(api, feature.use(store, paramsWithDefault, api));
   }
   return {
     store,
     api
   };
-};
+};
+function mergeDefaults(params, defaults) {
+  const result = _extends({}, params);
+  for (const key in defaults) {
+    if (Object.hasOwn(defaults, key)) {
+      const value = defaults[key];
+      if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        result[key] = mergeDefaults(params[key] ?? {}, value);
+      } else {
+        result[key] = params[key] ?? value;
+      }
+    }
+  }
+  return result;
+}

package/features/colspan.d.ts

@@ -1,9 +1,9 @@
 import { Store } from '@mui/x-internals/store';
 import type { integer } from '@mui/x-internals/types';
-import type { BaseState, VirtualizerParams } from "../useVirtualizer.js";
+import type { BaseState, ParamsWithDefaults } from "../useVirtualizer.js";
 import type { ColumnWithWidth, RowId } from "../models/index.js";
 import type { CellColSpanInfo } from "../models/colspan.js";
-import { Virtualization } from "./virtualization.js";
+import { Virtualization } from "./virtualization/index.js";
 type ColumnIndex = number;
 type ColspanMap = Map<RowId, Record<ColumnIndex, CellColSpanInfo>>;
 export type ColspanParams = {
@@ -21,10 +21,10 @@ export declare namespace Colspan {
   };
   type API = ReturnType<typeof useColspan>;
 }
-declare function initializeState(_params: VirtualizerParams): {
+declare function initializeState(_params: ParamsWithDefaults): {
   colspanMap: Map<any, any>;
 };
-declare function useColspan(store: Store<BaseState & Colspan.State>, params: VirtualizerParams, api: Virtualization.API): {
+declare function useColspan(store: Store<BaseState & Colspan.State>, params: ParamsWithDefaults, api: Virtualization.API): {
   resetColSpan: () => void;
   getCellColSpanInfo: (rowId: RowId, columnIndex: integer) => CellColSpanInfo | undefined;
   calculateColSpan: (rowId: RowId, minFirstColumn: integer, maxLastColumn: integer, columns: ColumnWithWidth[]) => void;

package/features/dimensions.d.ts

@@ -1,13 +1,15 @@
 import { Store } from '@mui/x-internals/store';
 import { ColumnWithWidth, DimensionsState, RowId, RowsMetaState, Size } from "../models/index.js";
-import type { BaseState, VirtualizerParams } from "../useVirtualizer.js";
+import type { BaseState, ParamsWithDefaults } from "../useVirtualizer.js";
 export type DimensionsParams = {
   rowHeight: number;
-  columnsTotalWidth: number;
-  leftPinnedWidth: number;
-  rightPinnedWidth: number;
-  topPinnedHeight: number;
-  bottomPinnedHeight: number;
+  columnsTotalWidth?: number;
+  leftPinnedWidth?: number;
+  rightPinnedWidth?: number;
+  topPinnedHeight?: number;
+  bottomPinnedHeight?: number;
+  autoHeight?: boolean;
+  minimalContentHeight?: number | string;
   scrollbarSize?: number;
 };
 export declare const Dimensions: {
@@ -17,8 +19,12 @@ export declare const Dimensions: {
     rootSize: (state: BaseState) => Size;
     dimensions: (state: BaseState) => DimensionsState;
     rowHeight: (state: BaseState) => number;
+    columnsTotalWidth: (state: BaseState) => number;
     contentHeight: (state: BaseState) => number;
+    autoHeight: (state: BaseState) => boolean;
+    minimalContentHeight: (state: BaseState) => string | number | undefined;
     rowsMeta: (state: BaseState) => RowsMetaState;
+    rowPositions: (state: BaseState) => number[];
     columnPositions: (_: any, columns: ColumnWithWidth[]) => number[];
     needsHorizontalScrollbar: (state: BaseState) => boolean;
   };
@@ -32,8 +38,8 @@ export declare namespace Dimensions {
   };
   type API = ReturnType<typeof useDimensions>;
 }
-declare function initializeState(params: VirtualizerParams): Dimensions.State;
-declare function useDimensions(store: Store<BaseState>, params: VirtualizerParams, _api: {}): {
+declare function initializeState(params: ParamsWithDefaults): Dimensions.State;
+declare function useDimensions(store: Store<BaseState>, params: ParamsWithDefaults, _api: {}): {
   updateDimensions: (firstUpdate?: boolean) => void;
   debouncedUpdateDimensions: (((firstUpdate?: boolean) => void) & import("@mui/x-internals/throttle").Cancelable) | undefined;
   rowsMeta: {

package/features/dimensions.js

@@ -38,14 +38,20 @@ const EMPTY_DIMENSIONS = {
   leftPinnedWidth: 0,
   rightPinnedWidth: 0,
   topContainerHeight: 0,
-  bottomContainerHeight: 0
+  bottomContainerHeight: 0,
+  autoHeight: false,
+  minimalContentHeight: undefined
 };
 const selectors = {
   rootSize: state => state.rootSize,
   dimensions: state => state.dimensions,
   rowHeight: state => state.dimensions.rowHeight,
+  columnsTotalWidth: state => state.dimensions.columnsTotalWidth,
   contentHeight: state => state.dimensions.contentSize.height,
+  autoHeight: state => state.dimensions.autoHeight,
+  minimalContentHeight: state => state.dimensions.minimalContentHeight,
   rowsMeta: state => state.rowsMeta,
+  rowPositions: state => state.rowsMeta.positions,
   columnPositions: (0, _store.createSelectorMemoized)((_, columns) => {
     const positions = [];
     let currentPosition = 0;
@@ -63,7 +69,10 @@ const Dimensions = exports.Dimensions = {
   selectors
 };
 function initializeState(params) {
-  const dimensions = (0, _extends2.default)({}, EMPTY_DIMENSIONS, params.dimensions);
+  const dimensions = (0, _extends2.default)({}, EMPTY_DIMENSIONS, params.dimensions, {
+    autoHeight: params.dimensions.autoHeight,
+    minimalContentHeight: params.dimensions.minimalContentHeight
+  });
   const {
     rowCount
   } = params;
@@ -89,7 +98,7 @@ function initializeState(params) {
 function useDimensions(store, params, _api) {
   const isFirstSizing = React.useRef(true);
   const {
-    refs,
+    layout,
     dimensions: {
       rowHeight,
       columnsTotalWidth,
@@ -107,7 +116,7 @@ function useDimensions(store, params, _api) {
     if (isFirstSizing.current) {
       return;
     }
-    const containerNode = refs.container.current;
+    const containerNode = layout.refs.container.current;
     const rootSize = selectors.rootSize(store.state);
     const rowsMeta = selectors.rowsMeta(store.state);
 
@@ -125,7 +134,7 @@ function useDimensions(store, params, _api) {
     let viewportInnerSize;
     let hasScrollX = false;
     let hasScrollY = false;
-    if (params.autoHeight) {
+    if (params.dimensions.autoHeight) {
       hasScrollY = false;
       hasScrollX = Math.round(columnsTotalWidth) > Math.round(rootSize.width);
       viewportOuterSize = {
@@ -192,7 +201,9 @@ function useDimensions(store, params, _api) {
       leftPinnedWidth,
       rightPinnedWidth,
       topContainerHeight,
-      bottomContainerHeight
+      bottomContainerHeight,
+      autoHeight: params.dimensions.autoHeight,
+      minimalContentHeight: params.dimensions.minimalContentHeight
     };
     const prevDimensions = store.state.dimensions;
     if ((0, _isDeepEqual.isDeepEqual)(prevDimensions, newDimensions)) {
@@ -202,7 +213,7 @@ function useDimensions(store, params, _api) {
       dimensions: newDimensions
     });
     onResize?.(newDimensions.root);
-  }, [store, refs.container, params.dimensions.scrollbarSize, params.autoHeight, params.disableHorizontalScroll, params.disableVerticalScroll, onResize, rowHeight, columnsTotalWidth, leftPinnedWidth, rightPinnedWidth, topPinnedHeight, bottomPinnedHeight]);
+  }, [store, layout.refs.container, params.dimensions.scrollbarSize, params.dimensions.autoHeight, params.dimensions.minimalContentHeight, params.disableHorizontalScroll, params.disableVerticalScroll, onResize, rowHeight, columnsTotalWidth, leftPinnedWidth, rightPinnedWidth, topPinnedHeight, bottomPinnedHeight]);
   const {
     resizeThrottleMs
   } = params;
@@ -210,6 +221,14 @@ function useDimensions(store, params, _api) {
   const debouncedUpdateDimensions = React.useMemo(() => resizeThrottleMs > 0 ? (0, _throttle.throttle)(updateDimensionCallback, resizeThrottleMs) : undefined, [resizeThrottleMs, updateDimensionCallback]);
   React.useEffect(() => debouncedUpdateDimensions?.clear, [debouncedUpdateDimensions]);
   (0, _useEnhancedEffect.default)(updateDimensions, [updateDimensions]);
+  (0, _useEnhancedEffect.default)(() => {
+    store.update({
+      dimensions: (0, _extends2.default)({}, store.state.dimensions, {
+        autoHeight: params.dimensions.autoHeight,
+        minimalContentHeight: params.dimensions.minimalContentHeight
+      })
+    });
+  }, [store, params.dimensions.autoHeight, params.dimensions.minimalContentHeight]);
   const rowsMeta = useRowsMeta(store, params, updateDimensions);
   return {
     updateDimensions,

package/features/index.d.ts

@@ -2,4 +2,4 @@ export * from "./colspan.js";
 export * from "./dimensions.js";
 export * from "./keyboard.js";
 export * from "./rowspan.js";
-export * from "./virtualization.js";
+export * from "./virtualization/index.js";

package/features/keyboard.d.ts

@@ -1,5 +1,5 @@
 import { Store } from '@mui/x-internals/store';
-import type { BaseState, VirtualizerParams } from "../useVirtualizer.js";
+import type { BaseState, ParamsWithDefaults } from "../useVirtualizer.js";
 export declare const Keyboard: {
   initialize: typeof initializeState;
   use: typeof useKeyboard;
@@ -9,8 +9,8 @@ export declare namespace Keyboard {
   type State = {};
   type API = ReturnType<typeof useKeyboard>;
 }
-declare function initializeState(_params: VirtualizerParams): Keyboard.State;
-declare function useKeyboard(store: Store<BaseState & Keyboard.State>, params: VirtualizerParams, _api: {}): {
+declare function initializeState(_params: ParamsWithDefaults): Keyboard.State;
+declare function useKeyboard(store: Store<BaseState & Keyboard.State>, params: ParamsWithDefaults, _api: {}): {
   getViewportPageSize: () => number;
 };
 export {};

package/features/rowspan.d.ts

@@ -1,7 +1,7 @@
 import { Store } from '@mui/x-internals/store';
-import type { BaseState, VirtualizerParams } from "../useVirtualizer.js";
+import type { BaseState, ParamsWithDefaults } from "../useVirtualizer.js";
 import type { RowSpanningState } from "../models/rowspan.js";
-import { Virtualization } from "./virtualization.js";
+import { Virtualization } from "./virtualization/index.js";
 export declare const Rowspan: {
   initialize: typeof initializeState;
   use: typeof useRowspan;
@@ -18,8 +18,8 @@ export declare namespace Rowspan {
   };
   type API = ReturnType<typeof useRowspan>;
 }
-declare function initializeState(params: VirtualizerParams): Rowspan.State;
-declare function useRowspan(store: Store<BaseState & Rowspan.State>, _params: VirtualizerParams, _api: Virtualization.API): {
+declare function initializeState(params: ParamsWithDefaults): Rowspan.State;
+declare function useRowspan(store: Store<BaseState & Rowspan.State>, _params: ParamsWithDefaults, _api: Virtualization.API): {
   getHiddenCellsOrigin: () => Record<number, Record<number, number>>;
 };
 export {};

package/features/virtualization/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./layout.js";
+export * from "./virtualization.js";

package/features/virtualization/index.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _layout = require("./layout");
+Object.keys(_layout).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _layout[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _layout[key];
+    }
+  });
+});
+var _virtualization = require("./virtualization");
+Object.keys(_virtualization).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _virtualization[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _virtualization[key];
+    }
+  });
+});

package/features/virtualization/layout.d.ts

@@ -0,0 +1,129 @@
+import * as React from 'react';
+import { Store } from '@mui/x-internals/store';
+import { Dimensions } from "../dimensions.js";
+import { Virtualization, type VirtualizationLayoutParams } from "./virtualization.js";
+import type { BaseState, ParamsWithDefaults } from "../../useVirtualizer.js";
+type RequiredAPI = Dimensions.API;
+type BaseElements = {
+  scroller: React.RefObject<HTMLElement | null>;
+  container: React.RefObject<HTMLElement | null>;
+};
+type AnyElements = BaseElements & Record<string, React.RefObject<HTMLElement | null>>;
+export declare abstract class Layout<E extends AnyElements = AnyElements> {
+  static elements: readonly (keyof AnyElements)[];
+  refs: E;
+  constructor(refs: E);
+  abstract use(store: Store<BaseState>, params: ParamsWithDefaults, api: RequiredAPI, layoutParams: VirtualizationLayoutParams): any;
+  refSetter(name: keyof E): (node: HTMLDivElement | null) => void;
+}
+type DataGridElements = BaseElements & {
+  scrollbarVertical: React.RefObject<HTMLElement | null>;
+  scrollbarHorizontal: React.RefObject<HTMLElement | null>;
+};
+export declare class LayoutDataGrid extends Layout<DataGridElements> {
+  static elements: readonly ["scroller", "container", "content", "positioner", "scrollbarVertical", "scrollbarHorizontal"];
+  use(store: Store<BaseState>, _params: ParamsWithDefaults, _api: RequiredAPI, layoutParams: VirtualizationLayoutParams): void;
+  static selectors: {
+    containerProps: (args_0: Virtualization.State<Layout<AnyElements>> & Dimensions.State) => {
+      ref: any;
+    };
+    scrollerProps: (args_0: Virtualization.State<Layout<AnyElements>> & Dimensions.State) => {
+      ref: any;
+      style: {
+        overflowX: string | undefined;
+        overflowY: string | undefined;
+      };
+      role: string;
+      tabIndex: number | undefined;
+    };
+    contentProps: (args_0: Virtualization.State<Layout<AnyElements>> & Dimensions.State) => {
+      style: React.CSSProperties;
+      role: string;
+    };
+    positionerProps: (args_0: Virtualization.State<Layout<AnyElements>> & Dimensions.State) => {
+      style: {
+        transform: string;
+      };
+    };
+    scrollbarHorizontalProps: (args_0: Virtualization.State<Layout<AnyElements>> & Dimensions.State) => {
+      ref: any;
+      scrollPosition: {
+        current: import("../../models/index.js").ScrollPosition;
+      };
+    };
+    scrollbarVerticalProps: (args_0: Virtualization.State<Layout<AnyElements>> & Dimensions.State) => {
+      ref: any;
+      scrollPosition: {
+        current: import("../../models/index.js").ScrollPosition;
+      };
+    };
+    scrollAreaProps: (args_0: Virtualization.State<Layout<AnyElements>> & Dimensions.State) => {
+      scrollPosition: {
+        current: import("../../models/index.js").ScrollPosition;
+      };
+    };
+  };
+}
+export declare class LayoutDataGridLegacy extends LayoutDataGrid {
+  use(store: Store<BaseState>, _params: ParamsWithDefaults, _api: RequiredAPI, layoutParams: VirtualizationLayoutParams): {
+    getContainerProps: () => {
+      ref: any;
+    };
+    getScrollerProps: () => {
+      ref: any;
+      style: {
+        overflowX: string | undefined;
+        overflowY: string | undefined;
+      };
+      role: string;
+      tabIndex: number | undefined;
+    };
+    getContentProps: () => {
+      style: React.CSSProperties;
+      role: string;
+    };
+    getPositionerProps: () => {
+      style: {
+        transform: string;
+      };
+    };
+    getScrollbarVerticalProps: () => {
+      ref: any;
+      scrollPosition: {
+        current: import("../../models/index.js").ScrollPosition;
+      };
+    };
+    getScrollbarHorizontalProps: () => {
+      ref: any;
+      scrollPosition: {
+        current: import("../../models/index.js").ScrollPosition;
+      };
+    };
+    getScrollAreaProps: () => {
+      scrollPosition: {
+        current: import("../../models/index.js").ScrollPosition;
+      };
+    };
+  };
+}
+type ListElements = BaseElements;
+export declare class LayoutList extends Layout<ListElements> {
+  static elements: readonly ["scroller", "container", "content", "positioner"];
+  use(store: Store<BaseState>, _params: ParamsWithDefaults, _api: RequiredAPI, layoutParams: VirtualizationLayoutParams): void;
+  static selectors: {
+    containerProps: (args_0: Virtualization.State<Layout<AnyElements>> & Dimensions.State) => {
+      ref: any;
+      style: React.CSSProperties;
+      role: string;
+      tabIndex: number | undefined;
+    };
+    contentProps: (args_0: Virtualization.State<Layout<AnyElements>> & Dimensions.State) => {
+      style: React.CSSProperties;
+      role: string;
+    };
+    positionerProps: (args_0: Virtualization.State<Layout<AnyElements>> & Dimensions.State) => {
+      style: React.CSSProperties;
+    };
+  };
+}
+export {};