impact-nova 1.7.2 → 1.7.3

package/dist/lib/virtualized/index.d.ts

@@ -0,0 +1,9 @@
+export type { DataSourceApi, DataSourceConfig, RowSelectionMode, RowSelectionState, SelectionCounts, UseRowStateOptions, UseRowStateResult, VirtualItem, VirtualListKey, VirtualRowDataStatus, VirtualRowModel, } from './types';
+export { getSelectionCountsFromState } from './selection-counts';
+export { useDataSource } from './useDataSource';
+export { useRowState } from './useRowState';
+export { useVirtualizedRows, type UseVirtualizedRowsOptions } from './useVirtualizedRows';
+export { useVirtualizedList, type UseVirtualizedListOptions, type UseVirtualizedListResult, } from './useVirtualizedList';
+export { buildSectionedFlatList, type DataSectionBlock, type HeaderSectionBlock, type SectionBlock, type SectionedFlatList, type SectionedFlatRow, } from './sectioned';
+export { useDebouncedValue } from './useDebouncedValue';
+export { useDataGridVirtualRows, type DataGridVirtualRowsResult, } from './useDataGrid';

package/dist/lib/virtualized/sectioned.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Flatten **section headers + data rows** into a single virtualized index space.
+ * Use with {@link useVirtualizedList} by setting `rowCount` to `flatRowCount` and resolving
+ * `getRowData` / `getRowId` from {@link SectionedFlatList.describeFlatIndex}.
+ */
+export type SectionedFlatRow = {
+    kind: "header";
+    sectionKey: string;
+    title: string;
+} | {
+    kind: "data";
+    sectionKey: string;
+    sourceIndex: number;
+};
+export type HeaderSectionBlock = {
+    type: "header";
+    sectionKey: string;
+    title: string;
+};
+export type DataSectionBlock = {
+    type: "data";
+    sectionKey: string;
+    rowCount: number;
+    /** Maps offset within this block (0 … rowCount - 1) to a logical source index (e.g. global SKU index). */
+    getSourceIndex: (offsetInBlock: number) => number;
+};
+export type SectionBlock = HeaderSectionBlock | DataSectionBlock;
+export interface SectionedFlatList {
+    flatRowCount: number;
+    describeFlatIndex: (flatIndex: number) => SectionedFlatRow | null;
+    getStableKey: (flatIndex: number) => string;
+}
+/**
+ * Build O(#sections) metadata for a flattened virtual list (headers + variable data blocks).
+ * Safe for large `rowCount` inside data blocks — no dense array of all rows is allocated.
+ */
+export declare function buildSectionedFlatList(blocks: readonly SectionBlock[]): SectionedFlatList;

package/dist/lib/virtualized/sectioned.js

@@ -0,0 +1,38 @@
+function f(c) {
+  let n = 0;
+  const r = [];
+  for (const t of c)
+    t.type === "header" ? (r.push({ flatStart: n, flatEnd: n + 1, block: t }), n += 1) : (r.push({
+      flatStart: n,
+      flatEnd: n + t.rowCount,
+      block: t
+    }), n += t.rowCount);
+  function i(t) {
+    if (t < 0 || t >= n) return null;
+    for (const e of r) {
+      if (t < e.flatStart || t >= e.flatEnd) continue;
+      const o = e.block;
+      if (o.type === "header")
+        return {
+          kind: "header",
+          sectionKey: o.sectionKey,
+          title: o.title
+        };
+      const s = t - e.flatStart;
+      return {
+        kind: "data",
+        sectionKey: o.sectionKey,
+        sourceIndex: o.getSourceIndex(s)
+      };
+    }
+    return null;
+  }
+  function u(t) {
+    const e = i(t);
+    return e ? e.kind === "header" ? `h:${e.sectionKey}` : `d:${e.sectionKey}:${e.sourceIndex}` : `oob-${t}`;
+  }
+  return { flatRowCount: n, describeFlatIndex: i, getStableKey: u };
+}
+export {
+  f as buildSectionedFlatList
+};

package/dist/lib/virtualized/selection-counts.d.ts

@@ -0,0 +1,14 @@
+import { RowSelectionState, SelectionCounts } from './types';
+/**
+ * Selected / unselected **counts** from an AG Grid–compatible {@link RowSelectionState}.
+ *
+ * You must pass **`totalLogicalRows`** (your dataset size, e.g. server total count). Without it,
+ * when `selectAll` is true you cannot infer how many rows are selected — only how many **exceptions**
+ * (`toggledIds.size`) are unselected.
+ *
+ * | `selectAll` | Meaning of `toggledIds` | `selected` | `unselected` |
+ * |-------------|-------------------------|------------|----------------|
+ * | `false`     | explicitly selected ids | `toggledIds.size` | `total - selected` |
+ * | `true`      | exception (deselected) ids | `total - toggledIds.size` | `toggledIds.size` |
+ */
+export declare function getSelectionCountsFromState(state: RowSelectionState, totalLogicalRows: number): SelectionCounts;

package/dist/lib/virtualized/selection-counts.js

@@ -0,0 +1,12 @@
+function s(e, l) {
+  const t = Math.max(0, Math.floor(l));
+  if (!e.selectAll) {
+    const o = e.toggledIds.size;
+    return { selected: o, unselected: Math.max(0, t - o) };
+  }
+  const n = e.toggledIds.size;
+  return { selected: Math.max(0, t - n), unselected: n };
+}
+export {
+  s as getSelectionCountsFromState
+};

package/dist/lib/virtualized/types.d.ts

@@ -0,0 +1,131 @@
+import { VirtualItem } from '@tanstack/virtual-core';
+export type { VirtualItem };
+/** Stable virtual row key type (matches TanStack Virtual item keys). */
+export type VirtualListKey = VirtualItem["key"];
+/**
+ * Row payload availability for virtualized lists (server/windowed or sparse client data).
+ */
+export type VirtualRowDataStatus = "loading" | "ready" | "error";
+/**
+ * Per-row view model passed to render functions. Indices are virtualization-only;
+ * stable {@link VirtualRowModel.id} is used for selection and expansion.
+ */
+export interface VirtualRowModel<TData> {
+    index: number;
+    id: string;
+    /** Resolved row data when available */
+    data: TData | undefined;
+    /** Alias for {@link VirtualRowModel.data} */
+    item: TData | undefined;
+    status: VirtualRowDataStatus;
+    error?: unknown;
+    isSelected: boolean;
+    isExpanded: boolean;
+    toggleSelect: () => void;
+    toggleExpand: () => void;
+}
+/**
+ * Configure how row data is resolved without allocating an array of length `rowCount`.
+ * In server mode, implement {@link DataSourceConfig.isRowLoaded} and optional
+ * {@link DataSourceConfig.prefetchRange} while keeping `rowCount` as total logical rows.
+ */
+export interface DataSourceConfig<TData> {
+    rowCount: number;
+    getRowData: (index: number) => TData | undefined;
+    /** When false, the row is treated as not yet hydrated (skeleton / placeholder). */
+    isRowLoaded?: (index: number) => boolean;
+    /** Optional viewport hint for fetching (e.g. infinite query). */
+    prefetchRange?: (startIndex: number, endIndex: number) => void;
+    getRowError?: (index: number) => unknown;
+}
+export interface DataSourceApi<TData> {
+    rowCount: number;
+    getRowData: (index: number) => TData | undefined;
+    isRowLoaded: (index: number) => boolean;
+    prefetchRange?: (startIndex: number, endIndex: number) => void;
+    getRowStatus: (index: number) => VirtualRowDataStatus;
+    getRowError: (index: number) => unknown | undefined;
+}
+/**
+ * Row selection snapshot aligned with AG Grid server-side selection / SSRM:
+ * - `selectAll === false` → `toggledIds` lists **included** (selected) row ids only.
+ * - `selectAll === true` → `toggledIds` lists **exceptions** (deselected) row ids; all other rows count as selected.
+ */
+export interface RowSelectionState {
+    selectAll: boolean;
+    toggledIds: Set<string>;
+}
+/** Returned by {@link UseRowStateResult.getSelectionCounts} and {@link getSelectionCountsFromState}. */
+export interface SelectionCounts {
+    selected: number;
+    unselected: number;
+}
+/**
+ * - **`explicit`**: finite selection only — `selectedIds` is the source of truth (same as before).
+ * - **`selectAllWithExceptions`**: AG Grid–style SSRM selection — global `selectAll` + exception `toggledIds`
+ *   without enumerating every row id (`isSelected` uses the inversion formula).
+ */
+export type RowSelectionMode = "explicit" | "selectAllWithExceptions";
+export interface UseRowStateOptions {
+    /**
+     * @default "explicit"
+     */
+    selectionMode?: RowSelectionMode;
+    /** --- `explicit` mode (default) --- */
+    /** Controlled selection; pass a stable reference (e.g. memoized `Set` or `string[]`). */
+    selectedIds?: ReadonlySet<string> | readonly string[];
+    onSelectedIdsChange?: (next: Set<string>) => void;
+    defaultSelectedIds?: ReadonlySet<string> | readonly string[];
+    /** --- `selectAllWithExceptions` mode (AG Grid SSRM–style) --- */
+    /** Controlled global “select all rows” flag. */
+    selectAll?: boolean;
+    /** Controlled exception ids (exclusions when `selectAll` is true; inclusions when `selectAll` is false). */
+    toggledIds?: ReadonlySet<string> | readonly string[];
+    onSelectionStateChange?: (next: RowSelectionState) => void;
+    defaultSelectAll?: boolean;
+    defaultToggledIds?: ReadonlySet<string> | readonly string[];
+    expandedIds?: ReadonlySet<string> | readonly string[];
+    onExpandedIdsChange?: (next: Set<string>) => void;
+    defaultExpandedIds?: ReadonlySet<string> | readonly string[];
+}
+export interface UseRowStateResult {
+    selectionMode: RowSelectionMode;
+    /** Snapshot for reading selection membership (finite set). When `selectAll` is true in SSRM mode, this Set cannot list every selected id — use {@link getSelectionState} instead (may be empty). */
+    selectedIds: ReadonlySet<string>;
+    /**
+     * AG Grid–compatible flags. In `explicit` mode, `selectAll` is always `false` and `toggledIds` matches {@link selectedIds}.
+     */
+    selectAll: boolean;
+    /** Exception / inclusion ids depending on {@link selectAll} (see {@link RowSelectionState}). */
+    toggledIds: ReadonlySet<string>;
+    /** Same shape as AG Grid `getServerSideSelectionState()` for wiring to APIs. */
+    getSelectionState: () => RowSelectionState;
+    /**
+     * Selected / unselected **counts** when you know **total logical row count** (e.g. server `totalCount`).
+     * See {@link getSelectionCountsFromState} for the formula (depends on `selectAll` + `toggledIds`).
+     */
+    getSelectionCounts: (totalLogicalRows: number) => SelectionCounts;
+    /**
+     * Sets global select-all and clears exceptions (AG Grid: select entire result set without listing ids).
+     * No-op in `explicit` mode except `setSelectAll(false)` which clears selection.
+     */
+    setSelectAll: (value: boolean) => void;
+    expandedIds: ReadonlySet<string>;
+    isSelected: (id: string) => boolean;
+    isExpanded: (id: string) => boolean;
+    toggleSelect: (id: string) => void;
+    toggleExpand: (id: string) => void;
+    /**
+     * Adds ids to the current selection (explicit: union into `selectedIds`; SSRM: merges into `toggledIds`
+     * — when `selectAll` is true, removes ids from toggled so they become selected; when false, adds ids to toggled).
+     */
+    mergeSelectedIds: (ids: string[]) => void;
+    /**
+     * If every id is already selected, removes those ids in one update; otherwise adds all ids
+     * (same merge as {@link mergeSelectedIds}). Use for “select / deselect visible window” toggles.
+     */
+    toggleSelectAll: (ids: ReadonlyArray<string>) => void;
+    clearSelection: () => void;
+    isAllSelected: (candidateIds: string[]) => boolean;
+    clearExpansion: () => void;
+}

package/dist/lib/virtualized/useDataGrid.d.ts

@@ -0,0 +1,15 @@
+import { Row, Table } from '@tanstack/react-table';
+export interface DataGridVirtualRowsResult<TData> {
+    rowCount: number;
+    getRowData: (index: number) => TData | undefined;
+    getRowId: (index: number) => string;
+    getTanStackRow: (index: number) => Row<TData> | undefined;
+}
+/**
+ * Maps a TanStack Table row model into the shape expected by {@link useVirtualizedList}.
+ *
+ * **Important:** This reads `table.getRowModel().rows`, which materializes every row in memory.
+ * Use only for moderate in-browser datasets (on the order of thousands of rows). For 100k+ rows,
+ * keep a windowed store or infinite query and drive the list from {@link useDataSource} instead.
+ */
+export declare function useDataGridVirtualRows<TData>(table: Table<TData>): DataGridVirtualRowsResult<TData>;

package/dist/lib/virtualized/useDataGrid.js

@@ -0,0 +1,12 @@
+function a(r) {
+  const o = r.getRowModel().rows;
+  return {
+    rowCount: o.length,
+    getRowData: (t) => o[t]?.original,
+    getRowId: (t) => String(o[t]?.id ?? t),
+    getTanStackRow: (t) => o[t]
+  };
+}
+export {
+  a as useDataGridVirtualRows
+};

package/dist/lib/virtualized/useDataSource.d.ts

@@ -0,0 +1,8 @@
+import { DataSourceApi, DataSourceConfig } from './types';
+/**
+ * Headless data access for virtualized lists. Never materializes `rowCount` items in memory.
+ *
+ * - **Client**: omit `isRowLoaded` — rows are considered ready; `getRowData` may still return `undefined`.
+ * - **Server / partial**: provide `isRowLoaded` and optionally `prefetchRange` for windowed fetches.
+ */
+export declare function useDataSource<TData>(config: DataSourceConfig<TData>): DataSourceApi<TData>;

package/dist/lib/virtualized/useDataSource.js

@@ -0,0 +1,34 @@
+import { useCallback as a, useMemo as g } from "react";
+function l(R) {
+  const { rowCount: o, getRowData: n, isRowLoaded: u, prefetchRange: s, getRowError: t } = R, e = a(
+    (r) => r < 0 || r >= o ? !1 : u ? u(r) : !0,
+    [o, u]
+  ), c = a(
+    (r) => {
+      if (r < 0 || r >= o) return "ready";
+      const w = t?.(r);
+      return w != null ? "error" : e(r) ? "ready" : "loading";
+    },
+    [o, t, e]
+  ), f = a(
+    (r) => {
+      if (!(r < 0 || r >= o))
+        return t?.(r);
+    },
+    [o, t]
+  );
+  return g(
+    () => ({
+      rowCount: o,
+      getRowData: n,
+      isRowLoaded: e,
+      prefetchRange: s,
+      getRowStatus: c,
+      getRowError: f
+    }),
+    [o, n, e, s, c, f]
+  );
+}
+export {
+  l as useDataSource
+};

package/dist/lib/virtualized/useDebouncedValue.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Debounces a value for search fields and similar inputs.
+ */
+export declare function useDebouncedValue<T>(value: T, delayMs: number): T;

package/dist/lib/virtualized/useDebouncedValue.js

@@ -0,0 +1,11 @@
+import { useState as c, useEffect as r } from "react";
+function i(e, t) {
+  const [o, u] = c(e);
+  return r(() => {
+    const n = setTimeout(() => u(e), t);
+    return () => clearTimeout(n);
+  }, [e, t]), o;
+}
+export {
+  i as useDebouncedValue
+};

package/dist/lib/virtualized/useRowState.d.ts

@@ -0,0 +1,15 @@
+import { UseRowStateOptions, UseRowStateResult } from './types';
+/**
+ * Headless selection and expansion for virtualized rows.
+ *
+ * **Selection modes**
+ * - **`explicit` (default)**: finite `selectedIds` set — same model as before.
+ * - **`selectAllWithExceptions`**: AG Grid SSRM–style `{ selectAll, toggledIds }` where
+ *   `isSelected(id) === selectAll ? !toggledIds.has(id) : toggledIds.has(id)` so you do not
+ *   need every row id for a global “select all”.
+ *
+ * **Ids vs indices**: Key state by stable row ids (`getRowId`), not visible index.
+ *
+ * **Controlled**: pass the matching props + `on*Change` handlers with stable references when possible.
+ */
+export declare function useRowState(options?: UseRowStateOptions): UseRowStateResult;

package/dist/lib/virtualized/useRowState.js

@@ -0,0 +1,127 @@
+import { useState as b, useMemo as w, useCallback as c } from "react";
+import { getSelectionCountsFromState as J } from "./selection-counts.js";
+function f(d) {
+  return d ? d instanceof Set ? new Set(d) : new Set(d) : /* @__PURE__ */ new Set();
+}
+function K(d) {
+  return (d.selectionMode ?? "explicit") === "selectAllWithExceptions" ? {
+    all: d.defaultSelectAll ?? !1,
+    toggled: f(d.defaultToggledIds)
+  } : {
+    all: !1,
+    toggled: f(d.defaultSelectedIds)
+  };
+}
+function O(d = {}) {
+  const o = d.selectionMode ?? "explicit", {
+    selectedIds: g,
+    onSelectedIdsChange: h,
+    expandedIds: x,
+    onExpandedIdsChange: m,
+    defaultExpandedIds: R,
+    onSelectionStateChange: P,
+    selectAll: S,
+    toggledIds: u
+  } = d, [I, A] = b(() => K(d)), [v, y] = b(
+    () => f(R)
+  ), r = x !== void 0, E = w(() => r ? f(x) : v, [r, x, v]), l = w(
+    () => o === "selectAllWithExceptions" ? S !== void 0 ? S : I.all : !1,
+    [o, S, I.all]
+  ), s = w(() => o === "explicit" ? g !== void 0 ? f(g) : I.toggled : u !== void 0 ? f(u) : I.toggled, [o, g, u, I.toggled]), W = w(() => o === "explicit" || !l ? s : /* @__PURE__ */ new Set(), [o, l, s]), k = c(
+    (e) => l ? !s.has(e) : s.has(e),
+    [l, s]
+  ), F = c((e) => E.has(e), [E]), p = c(
+    (e) => {
+      h?.(e), g === void 0 && A((t) => ({ ...t, all: !1, toggled: e }));
+    },
+    [h, g]
+  ), i = c(
+    (e) => {
+      P?.(e), S === void 0 && u === void 0 ? A({ all: e.selectAll, toggled: e.toggledIds }) : u === void 0 ? A((t) => ({ ...t, toggled: e.toggledIds })) : S === void 0 && A((t) => ({ ...t, all: e.selectAll }));
+    },
+    [P, S, u]
+  ), T = c(
+    (e) => {
+      const t = new Set(s);
+      t.has(e) ? t.delete(e) : t.add(e), o === "explicit" ? p(t) : i({ selectAll: l, toggledIds: t });
+    },
+    [o, s, l, p, i]
+  ), j = c(
+    (e) => {
+      const t = r ? f(x) : v, n = new Set(t);
+      n.has(e) ? n.delete(e) : n.add(e), r ? m?.(n) : y(n);
+    },
+    [r, x, v, m]
+  ), q = c(
+    (e) => {
+      const t = new Set(s);
+      for (const n of e)
+        l ? t.delete(n) : t.add(n);
+      o === "explicit" ? p(t) : i({ selectAll: l, toggledIds: t });
+    },
+    [o, s, l, p, i]
+  ), z = c(
+    (e) => {
+      if (e.length === 0) return;
+      const t = e.every(
+        (a) => l ? !s.has(a) : s.has(a)
+      ), n = new Set(s);
+      if (t)
+        for (const a of e)
+          l ? n.add(a) : n.delete(a);
+      else
+        for (const a of e)
+          l ? n.delete(a) : n.add(a);
+      o === "explicit" ? p(n) : i({ selectAll: l, toggledIds: n });
+    },
+    [o, l, s, p, i]
+  ), C = c(() => {
+    const e = /* @__PURE__ */ new Set();
+    o === "explicit" ? (h?.(e), g === void 0 && A((t) => ({ ...t, all: !1, toggled: e }))) : i({ selectAll: !1, toggledIds: e });
+  }, [o, h, g, i]), B = c(
+    (e) => {
+      if (o === "explicit") {
+        e || C();
+        return;
+      }
+      i({ selectAll: e, toggledIds: /* @__PURE__ */ new Set() });
+    },
+    [o, C, i]
+  ), M = c(() => ({
+    selectAll: l,
+    toggledIds: new Set(s)
+  }), [l, s]), D = c(
+    (e) => J(M(), e),
+    [M]
+  ), G = c(
+    (e) => e.length === 0 ? !0 : e.every(
+      (t) => l ? !s.has(t) : s.has(t)
+    ),
+    [l, s]
+  ), H = c(() => {
+    const e = /* @__PURE__ */ new Set();
+    r ? m?.(e) : y(e);
+  }, [r, m]);
+  return {
+    selectionMode: o,
+    selectedIds: W,
+    selectAll: l,
+    toggledIds: s,
+    getSelectionState: M,
+    getSelectionCounts: D,
+    setSelectAll: B,
+    expandedIds: E,
+    isSelected: k,
+    isExpanded: F,
+    toggleSelect: T,
+    toggleExpand: j,
+    mergeSelectedIds: q,
+    toggleSelectAll: z,
+    clearSelection: C,
+    isAllSelected: G,
+    clearExpansion: H
+  };
+}
+export {
+  O as useRowState
+};

package/dist/lib/virtualized/useVirtualizedList.d.ts

@@ -0,0 +1,72 @@
+import { Virtualizer } from '@tanstack/virtual-core';
+import { CSSProperties, RefObject } from 'react';
+import { ReactVirtualizerOptions } from '@tanstack/react-virtual';
+import { DataSourceConfig, UseRowStateOptions, UseRowStateResult, VirtualItem, VirtualListKey, VirtualRowModel } from './types';
+export type UseVirtualizedListOptions<TData, TScrollElement extends Element = HTMLDivElement, TItemElement extends Element = HTMLDivElement> = DataSourceConfig<TData> & UseRowStateOptions & {
+    scrollElementRef: RefObject<TScrollElement | null>;
+    /** Stable logical id for each row index (required for selection / expansion). */
+    getRowId: (index: number) => string;
+    estimateSize: (index: number) => number;
+    overscan?: number;
+    getItemKey?: (index: number) => VirtualListKey;
+    /** How close to the last logical index `onEndReached` fires (default 3). */
+    endReachedThreshold?: number;
+    onEndReached?: () => void;
+    /** When false, `onEndReached` is not invoked (e.g. no further pages). */
+    hasMore?: boolean;
+} & Omit<Partial<ReactVirtualizerOptions<TScrollElement, TItemElement>>, "count" | "getScrollElement" | "estimateSize" | "overscan" | "getItemKey" | "onChange"> & {
+    /** Merged with the internal handler that powers `onEndReached`. */
+    onChange?: ReactVirtualizerOptions<TScrollElement, TItemElement>["onChange"];
+};
+export interface UseVirtualizedListResult<TData, TScrollElement extends Element = HTMLDivElement, TItemElement extends Element = HTMLDivElement> {
+    virtualItems: VirtualItem[];
+    /** Total scrollable size in pixels (alias of `totalSize`). */
+    totalHeight: number;
+    totalSize: number;
+    measureElement: Virtualizer<TScrollElement, TItemElement>["measureElement"];
+    virtualizer: Virtualizer<TScrollElement, TItemElement>;
+    scrollToIndex: Virtualizer<TScrollElement, TItemElement>["scrollToIndex"];
+    getRow: (index: number) => VirtualRowModel<TData>;
+    getItemProps: (virtualItemOrIndex: VirtualItem | number, options?: {
+        measure?: boolean;
+    }) => {
+        key: VirtualListKey;
+        role: "row";
+        "data-index": number;
+        ref: Virtualizer<TScrollElement, TItemElement>["measureElement"] | undefined;
+        style: CSSProperties;
+    };
+    rowState: UseRowStateResult;
+}
+/**
+ * Composes {@link useDataSource}, {@link useRowState}, and {@link useVirtualizedRows}.
+ * Intended for 100k+ rows: never builds an array of length `rowCount`; resolve data per index only.
+ *
+ * **Render pattern**
+ * ```tsx
+ * virtualItems.map((vItem) => {
+ *   const row = getRow(vItem.index);
+ *   return renderItem(row);
+ * });
+ * ```
+ *
+ * **SSR**: pass `initialRect` (and related options) through to the underlying virtualizer.
+ *
+ * **Infinite loading**: implement `onEndReached` and set `hasMore` when no pages remain; optionally
+ * use `prefetchRange` so a parent cache (e.g. TanStack Query) can fetch the visible window.
+ *
+ * @example
+ * ```tsx
+ * const parentRef = useRef<HTMLDivElement>(null);
+ * const list = useVirtualizedList({
+ *   scrollElementRef: parentRef,
+ *   rowCount: 100_000,
+ *   getRowId: (i) => String(i),
+ *   getRowData: (i) => rows.get(i),
+ *   estimateSize: () => 52,
+ *   onEndReached: fetchNextPage,
+ *   hasMore,
+ * });
+ * ```
+ */
+export declare function useVirtualizedList<TData, TScrollElement extends Element = HTMLDivElement, TItemElement extends Element = HTMLDivElement>(options: UseVirtualizedListOptions<TData, TScrollElement, TItemElement>): UseVirtualizedListResult<TData, TScrollElement, TItemElement>;