impact-nova 2.1.0-alpha.4 → 2.1.0-alpha.6

package/dist/lib/compose-refs.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+/** Merge multiple refs into one callback ref. */
+export declare function composeRefs<T>(...refs: Array<React.Ref<T> | undefined>): (node: T | null) => void;
+/**
+ * Stable composed ref — avoids re-invoking measure / scroll refs every render
+ * (TanStack Virtual loops if measureElement ref identity churns).
+ */
+export declare function useComposedRefs<T>(...refs: Array<React.Ref<T> | undefined>): (node: T | null) => void;

package/dist/lib/compose-refs.js

@@ -0,0 +1,14 @@
+import * as f from "react";
+function n(...e) {
+  return (t) => {
+    for (const o of e)
+      o && (typeof o == "function" ? o(t) : o.current = t);
+  };
+}
+function r(...e) {
+  return f.useCallback(n(...e), e);
+}
+export {
+  n as composeRefs,
+  r as useComposedRefs
+};

package/dist/lib/primitives/field.types.d.ts

@@ -7,15 +7,21 @@ export type ControlSize = "sm" | "md" | "lg" | "default";
 export type LabelOrientation = "top" | "left";
 /** Field chrome shared by Field wrapper and inline form controls. */
 export interface FieldChromeProps {
+    /** Text shown above the control so users know what to enter. */
     label?: React.ReactNode;
-    /** Alias: `description` on Field */
+    /** Optional hint or validation message shown below the control. Alias: `description` on Field. */
     helperText?: React.ReactNode;
+    /** Where helper text appears: `absolute` floats below without pushing layout; `flow` takes page space. */
     helperTextPosition?: HelperTextPosition;
+    /** Label placement: `top` stacks label above control; `left` places label beside control. */
     labelOrientation?: LabelOrientation;
-    /** Boolean drives aria-invalid; ReactNode renders error message. */
+    /** When true, shows red error styling. Pass a ReactNode to also render an error message. */
     error?: boolean | React.ReactNode;
+    /** When true, shows a required indicator (asterisk) next to the label. */
     required?: boolean;
+    /** When true, the control is greyed out and cannot be clicked, typed into, or focused. */
     disabled?: boolean;
+    /** Controls height and padding: `sm`, `md`, `lg`, or `default`. */
     size?: ControlSize;
 }
 /** Form control props mixin — extend native/Radix props with field chrome. */

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

@@ -7,3 +7,6 @@ export { useVirtualizedList, type UseVirtualizedListOptions, type UseVirtualized
 export { buildSectionedFlatList, type DataSectionBlock, type HeaderSectionBlock, type SectionBlock, type SectionedFlatList, type SectionedFlatRow, } from './sectioned';
 export { useDebouncedValue } from './useDebouncedValue';
 export { useDataGridVirtualRows, type DataGridVirtualRowsResult, } from './useDataGrid';
+export { VirtualizedListProvider, useVirtualizedListContext, type VirtualizedListContextValue, } from './virtualized-list-context';
+export { getVisibleReadyRowIds } from './virtualized-list-utils';
+export { VirtualizedList, VirtualizedListShell, VirtualizedListHeader, VirtualizedListHeaderActions, VirtualizedListFooter, VirtualizedListSearch, VirtualizedListSelectAll, VirtualizedListViewport, VirtualizedListContent, VirtualizedListItem, VirtualizedListItemSkeleton, type VirtualizedListProps, type VirtualizedListContentProps, type VirtualizedListItemProps, type VirtualizedListItemSkeletonProps, type VirtualizedListSelectAllProps, type VirtualizedListViewportProps, } from './virtualized-list-parts';

package/dist/lib/virtualized/index.js

@@ -1,18 +1,35 @@
-import { getSelectionCountsFromState as t } from "./selection-counts.js";
-import { useDataSource as u } from "./useDataSource.js";
-import { useRowState as i } from "./useRowState.js";
-import { useVirtualizedRows as m } from "./useVirtualizedRows.js";
-import { useVirtualizedList as p } from "./useVirtualizedList.js";
-import { buildSectionedFlatList as l } from "./sectioned.js";
-import { useDebouncedValue as S } from "./useDebouncedValue.js";
-import { useDataGridVirtualRows as n } from "./useDataGrid.js";
+import { getSelectionCountsFromState as i } from "./selection-counts.js";
+import { useDataSource as o } from "./useDataSource.js";
+import { useRowState as s } from "./useRowState.js";
+import { useVirtualizedRows as l } from "./useVirtualizedRows.js";
+import { useVirtualizedList as V } from "./useVirtualizedList.js";
+import { buildSectionedFlatList as L } from "./sectioned.js";
+import { useDebouncedValue as p } from "./useDebouncedValue.js";
+import { useDataGridVirtualRows as f } from "./useDataGrid.js";
+import { VirtualizedListProvider as S, useVirtualizedListContext as c } from "./virtualized-list-context.js";
+import { getVisibleReadyRowIds as R } from "./virtualized-list-utils.js";
+import { VirtualizedList as C, VirtualizedListContent as D, VirtualizedListFooter as F, VirtualizedListHeader as I, VirtualizedListHeaderActions as g, VirtualizedListItem as h, VirtualizedListItemSkeleton as A, VirtualizedListSearch as H, VirtualizedListSelectAll as k, VirtualizedListShell as v, VirtualizedListViewport as y } from "./virtualized-list-parts.js";
 export {
-  l as buildSectionedFlatList,
-  t as getSelectionCountsFromState,
-  n as useDataGridVirtualRows,
-  u as useDataSource,
-  S as useDebouncedValue,
-  i as useRowState,
-  p as useVirtualizedList,
-  m as useVirtualizedRows
+  C as VirtualizedList,
+  D as VirtualizedListContent,
+  F as VirtualizedListFooter,
+  I as VirtualizedListHeader,
+  g as VirtualizedListHeaderActions,
+  h as VirtualizedListItem,
+  A as VirtualizedListItemSkeleton,
+  S as VirtualizedListProvider,
+  H as VirtualizedListSearch,
+  k as VirtualizedListSelectAll,
+  v as VirtualizedListShell,
+  y as VirtualizedListViewport,
+  L as buildSectionedFlatList,
+  i as getSelectionCountsFromState,
+  R as getVisibleReadyRowIds,
+  f as useDataGridVirtualRows,
+  o as useDataSource,
+  p as useDebouncedValue,
+  s as useRowState,
+  V as useVirtualizedList,
+  c as useVirtualizedListContext,
+  l as useVirtualizedRows
 };

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

@@ -35,6 +35,8 @@ export interface UseVirtualizedListResult<TData, TScrollElement extends Element
         ref: Virtualizer<TScrollElement, TItemElement>["measureElement"] | undefined;
         style: CSSProperties;
     };
+    /** Reset a row to its `estimateSize` after dynamic expansion collapses. */
+    resetRowSize: (index: number) => void;
     rowState: UseRowStateResult;
 }
 /**

package/dist/lib/virtualized/useVirtualizedList.js

@@ -1,155 +1,161 @@
-import { useRef as d, useEffect as M, useCallback as u } from "react";
-import { useDataSource as re } from "./useDataSource.js";
-import { useRowState as ae } from "./useRowState.js";
-import { useVirtualizedRows as ie } from "./useVirtualizedRows.js";
-function fe(T) {
+import { useRef as g, useEffect as _, useCallback as d } from "react";
+import { useDataSource as ie } from "./useDataSource.js";
+import { useRowState as ce } from "./useRowState.js";
+import { useVirtualizedRows as le } from "./useVirtualizedRows.js";
+function pe($) {
   const {
-    rowCount: l,
-    getRowData: _,
-    isRowLoaded: $,
-    prefetchRange: D,
-    getRowError: A,
-    selectionMode: H,
-    selectedIds: L,
-    onSelectedIdsChange: B,
-    defaultSelectedIds: K,
-    selectAll: P,
-    toggledIds: X,
-    onSelectionStateChange: Y,
-    defaultSelectAll: j,
-    defaultToggledIds: q,
-    expandedIds: F,
-    onExpandedIdsChange: G,
-    defaultExpandedIds: J,
-    scrollElementRef: N,
-    getRowId: S,
-    estimateSize: Q,
-    overscan: U,
-    getItemKey: W,
-    endReachedThreshold: g = 3,
-    onEndReached: f,
-    hasMore: h = !0,
-    onChange: x,
-    ...Z
-  } = T, n = re({
-    rowCount: l,
-    getRowData: _,
-    isRowLoaded: $,
-    prefetchRange: D,
-    getRowError: A
-  }), E = ae({
-    selectionMode: H,
-    selectedIds: L,
-    onSelectedIdsChange: B,
-    defaultSelectedIds: K,
-    selectAll: P,
-    toggledIds: X,
-    onSelectionStateChange: Y,
-    defaultSelectAll: j,
-    defaultToggledIds: q,
-    expandedIds: F,
-    onExpandedIdsChange: G,
-    defaultExpandedIds: J
-  }), z = d(l), C = d(h), b = d(g), p = d(f);
-  M(() => {
-    z.current = l, C.current = h, b.current = g, p.current = f;
-  }, [l, h, g, f]);
-  const O = u(
+    rowCount: u,
+    getRowData: D,
+    isRowLoaded: A,
+    prefetchRange: H,
+    getRowError: L,
+    selectionMode: B,
+    selectedIds: K,
+    onSelectedIdsChange: P,
+    defaultSelectedIds: X,
+    selectAll: Y,
+    toggledIds: j,
+    onSelectionStateChange: q,
+    defaultSelectAll: F,
+    defaultToggledIds: G,
+    expandedIds: J,
+    onExpandedIdsChange: N,
+    defaultExpandedIds: Q,
+    scrollElementRef: U,
+    getRowId: x,
+    estimateSize: c,
+    overscan: W,
+    getItemKey: Z,
+    endReachedThreshold: f = 3,
+    onEndReached: h,
+    hasMore: p = !0,
+    onChange: z,
+    ...O
+  } = $, n = ie({
+    rowCount: u,
+    getRowData: D,
+    isRowLoaded: A,
+    prefetchRange: H,
+    getRowError: L
+  }), E = ce({
+    selectionMode: B,
+    selectedIds: K,
+    onSelectedIdsChange: P,
+    defaultSelectedIds: X,
+    selectAll: Y,
+    toggledIds: j,
+    onSelectionStateChange: q,
+    defaultSelectAll: F,
+    defaultToggledIds: G,
+    expandedIds: J,
+    onExpandedIdsChange: N,
+    defaultExpandedIds: Q
+  }), C = g(u), b = g(p), y = g(f), R = g(h);
+  _(() => {
+    C.current = u, b.current = p, y.current = f, R.current = h;
+  }, [u, p, f, h]);
+  const ee = d(
     (e, o) => {
-      if (x?.(e, o), !p.current || !C.current) return;
-      const t = e.getVirtualItems(), s = t[t.length - 1];
-      s && s.index >= z.current - b.current - 1 && p.current();
+      if (z?.(e, o), !R.current || !b.current) return;
+      const t = e.getVirtualItems(), r = t[t.length - 1];
+      r && r.index >= C.current - y.current - 1 && R.current();
     },
-    [x]
-  ), { virtualizer: i, virtualItems: r, totalSize: y, measureElement: R } = ie({
-    scrollElementRef: N,
+    [z]
+  ), { virtualizer: s, virtualItems: a, totalSize: I, measureElement: m } = le({
+    scrollElementRef: U,
     rowCount: n.rowCount,
-    estimateSize: Q,
-    overscan: U,
-    getItemKey: W,
-    onChange: O,
-    ...Z
-  }), m = r[0]?.index, w = r[r.length - 1]?.index;
-  M(() => {
-    n.prefetchRange && (m === void 0 || w === void 0 || n.prefetchRange(m, w));
-  }, [n, m, w]);
-  const { isSelected: I, isExpanded: v, toggleSelect: V, toggleExpand: k } = E, ee = u(
+    estimateSize: c,
+    overscan: W,
+    getItemKey: Z,
+    onChange: ee,
+    ...O
+  }), w = a[0]?.index, S = a[a.length - 1]?.index;
+  _(() => {
+    n.prefetchRange && (w === void 0 || S === void 0 || n.prefetchRange(w, S));
+  }, [n, w, S]);
+  const { isSelected: v, isExpanded: V, toggleSelect: k, toggleExpand: M } = E, te = d(
     (e) => {
-      const o = S(e), t = n.getRowStatus(e), s = n.getRowData(e), c = n.getRowError(e);
+      const o = x(e), t = n.getRowStatus(e), r = n.getRowData(e), l = n.getRowError(e);
       return {
         index: e,
         id: o,
-        data: s,
-        item: s,
+        data: r,
+        item: r,
         status: t,
-        error: t === "error" ? c : void 0,
-        isSelected: I(o),
-        isExpanded: v(o),
-        toggleSelect: () => V(o),
-        toggleExpand: () => k(o)
+        error: t === "error" ? l : void 0,
+        isSelected: v(o),
+        isExpanded: V(o),
+        toggleSelect: () => k(o),
+        toggleExpand: () => M(o)
       };
     },
-    [S, n, I, v, V, k]
-  ), te = u(
+    [x, n, v, V, k, M]
+  ), oe = d(
     (e, o) => {
-      const t = typeof e == "number" ? r.find((a) => a.index === e) : e, s = !!i.options.horizontal, c = o?.measure !== !1;
+      const t = typeof e == "number" ? a.find((i) => i.index === e) : e, r = !!s.options.horizontal, l = o?.measure !== !1;
       if (!t) {
-        const a = typeof e == "number" ? e : -1;
+        const i = typeof e == "number" ? e : -1;
         return {
-          key: a >= 0 ? a : "__missing__",
-          "data-index": a >= 0 ? a : 0,
+          key: i >= 0 ? i : "__missing__",
+          "data-index": i >= 0 ? i : 0,
           ref: void 0,
           style: {}
         };
       }
-      const ne = {
+      const re = {
         position: "absolute",
         top: 0,
         left: 0,
         width: "100%",
         transform: `translateY(${t.start}px)`
-      }, se = {
+      }, ae = {
         position: "absolute",
         top: 0,
         left: 0,
         height: "100%",
         transform: `translateX(${t.start}px)`
-      };
+      }, T = c(t.index);
       return {
         key: t.key,
         "data-index": t.index,
-        ref: c ? R : void 0,
-        style: s ? {
-          ...se,
-          // Fixed span when not measuring; dynamic width uses measureElement.
-          ...c ? {} : { width: `${t.size}px` }
+        ref: l ? m : void 0,
+        style: r ? {
+          ...ae,
+          // Fixed span when not measuring; use estimate — not cached expanded size.
+          ...l ? {} : { width: `${T}px` }
         } : {
-          ...ne,
+          ...re,
           // Do not set fixed height when measuring — expanded rows must grow and
           // ResizeObserver can update layout so following virtual rows move down.
-          ...c ? {} : { height: `${t.size}px` }
+          ...l ? {} : { height: `${T}px` }
         }
       };
     },
-    [r, i.options.horizontal, R]
-  ), oe = u(
+    [a, s.options.horizontal, m, c]
+  ), ne = d(
+    (e) => {
+      s.resizeItem(e, c(e));
+    },
+    [s, c]
+  ), se = d(
     (...e) => {
-      i.scrollToIndex(...e);
+      s.scrollToIndex(...e);
     },
-    [i]
+    [s]
   );
   return {
-    virtualItems: r,
-    totalHeight: y,
-    totalSize: y,
-    measureElement: R,
-    virtualizer: i,
-    scrollToIndex: oe,
-    getRow: ee,
-    getItemProps: te,
+    virtualItems: a,
+    totalHeight: I,
+    totalSize: I,
+    measureElement: m,
+    virtualizer: s,
+    scrollToIndex: se,
+    getRow: te,
+    getItemProps: oe,
+    resetRowSize: ne,
     rowState: E
   };
 }
 export {
-  fe as useVirtualizedList
+  pe as useVirtualizedList
 };

package/dist/lib/virtualized/virtualized-list-context.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from 'react';
+import { UseVirtualizedListResult } from './useVirtualizedList';
+import * as React from "react";
+export interface VirtualizedListContextValue<TData = unknown> {
+    list: UseVirtualizedListResult<TData>;
+    scrollRef: RefObject<HTMLDivElement | null>;
+}
+export declare function VirtualizedListProvider<TData>({ value, children, }: {
+    value: VirtualizedListContextValue<TData>;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useVirtualizedListContext<TData = unknown>(): VirtualizedListContextValue<TData>;

package/dist/lib/virtualized/virtualized-list-context.js

@@ -0,0 +1,21 @@
+import { jsx as o } from "react/jsx-runtime";
+import * as i from "react";
+const r = i.createContext(null);
+function u({
+  value: t,
+  children: e
+}) {
+  return /* @__PURE__ */ o(r.Provider, { value: t, children: e });
+}
+function s() {
+  const t = i.useContext(r);
+  if (!t)
+    throw new Error(
+      "VirtualizedList compound parts must be used within VirtualizedList or VirtualizedListProvider."
+    );
+  return t;
+}
+export {
+  u as VirtualizedListProvider,
+  s as useVirtualizedListContext
+};

package/dist/lib/virtualized/virtualized-list-parts.d.ts

@@ -0,0 +1,51 @@
+import { VirtualItem, VirtualRowModel } from './types';
+import { VirtualizedListContextValue } from './virtualized-list-context';
+import { UseVirtualizedListOptions, UseVirtualizedListResult } from './useVirtualizedList';
+import * as React from "react";
+export declare const VirtualizedListShell: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export type VirtualizedListProps<TData> = {
+    children: React.ReactNode;
+    className?: string;
+} & ({
+    value: VirtualizedListContextValue<TData>;
+} | (Omit<UseVirtualizedListOptions<TData>, "scrollElementRef"> & {
+    value?: undefined;
+}));
+export declare function VirtualizedList<TData>(props: VirtualizedListProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare namespace VirtualizedList {
+    var displayName: string;
+}
+export declare const VirtualizedListHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const VirtualizedListHeaderActions: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const VirtualizedListFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export declare const VirtualizedListSearch: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export interface VirtualizedListSelectAllProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "children" | "type" | "onClick"> {
+    children?: React.ReactNode | ((state: {
+        allVisibleSelected: boolean;
+    }) => React.ReactNode);
+    /** Override visible row ids (default: loaded rows in the virtual window). */
+    getVisibleIds?: (list: UseVirtualizedListResult<unknown>) => string[];
+}
+export declare const VirtualizedListSelectAll: React.ForwardRefExoticComponent<VirtualizedListSelectAllProps & React.RefAttributes<HTMLButtonElement>>;
+export interface VirtualizedListViewportProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+export declare const VirtualizedListViewport: React.ForwardRefExoticComponent<VirtualizedListViewportProps & React.RefAttributes<HTMLDivElement>>;
+export interface VirtualizedListContentProps<TData> {
+    children: (row: VirtualRowModel<TData>, virtualItem: VirtualItem) => React.ReactNode;
+    className?: string;
+    /** When false, row uses fixed `estimateSize` (faster for collapsed expandable rows). Default: true. */
+    getItemMeasure?: (row: VirtualRowModel<TData>) => boolean;
+}
+export declare function VirtualizedListContent<TData>({ children, className, getItemMeasure, }: VirtualizedListContentProps<TData>): import("react/jsx-runtime").JSX.Element;
+export interface VirtualizedListItemProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "children"> {
+    virtualItem: VirtualItem;
+    children: React.ReactNode;
+    measure?: boolean;
+    /** Enables collapse height reset for expandable rows. */
+    row?: Pick<VirtualRowModel<unknown>, "isExpanded">;
+}
+export declare const VirtualizedListItem: React.ForwardRefExoticComponent<VirtualizedListItemProps & React.RefAttributes<HTMLDivElement>>;
+export interface VirtualizedListItemSkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+export declare const VirtualizedListItemSkeleton: React.ForwardRefExoticComponent<VirtualizedListItemSkeletonProps & React.RefAttributes<HTMLDivElement>>;

package/dist/lib/virtualized/virtualized-list-parts.js

@@ -0,0 +1,175 @@
+import { jsx as l } from "react/jsx-runtime";
+import * as d from "react";
+import { useRef as m, useLayoutEffect as P, useMemo as H } from "react";
+import { useComposedRefs as N } from "../compose-refs.js";
+import { createCompoundPart as c } from "../primitives/create-compound.js";
+import { cn as p } from "../utils.js";
+import { VirtualizedListProvider as R, useVirtualizedListContext as f } from "./virtualized-list-context.js";
+import { getVisibleReadyRowIds as _ } from "./virtualized-list-utils.js";
+import { useVirtualizedList as T } from "./useVirtualizedList.js";
+const y = c("virtualized-list", {
+  part: "root",
+  displayName: "VirtualizedList",
+  className: "mx-auto flex w-full max-w-[420px] flex-col overflow-hidden rounded-xl border border-stroke bg-canvas-elevated shadow-sm"
+});
+function D({
+  className: t,
+  children: a,
+  ...r
+}) {
+  const e = m(null), i = T({
+    ...r,
+    scrollElementRef: e
+  }), s = H(
+    () => ({ list: i, scrollRef: e }),
+    [i, e]
+  );
+  return /* @__PURE__ */ l(R, { value: s, children: /* @__PURE__ */ l(y, { className: t, children: a }) });
+}
+function F(t) {
+  if ("value" in t && t.value) {
+    const { value: i, className: s, children: o } = t;
+    return /* @__PURE__ */ l(R, { value: i, children: /* @__PURE__ */ l(y, { className: s, children: o }) });
+  }
+  const { className: a, children: r, ...e } = t;
+  return /* @__PURE__ */ l(D, { className: a, ...e, children: r });
+}
+F.displayName = "VirtualizedList";
+const $ = c("virtualized-list", {
+  part: "header",
+  displayName: "VirtualizedListHeader",
+  className: "shrink-0 border-b border-stroke bg-canvas-elevated px-4 pb-3 pt-4"
+}), ee = c("virtualized-list", {
+  part: "header-actions",
+  displayName: "VirtualizedListHeaderActions",
+  className: "mt-3 flex items-center gap-2"
+}), te = c("virtualized-list", {
+  part: "footer",
+  displayName: "VirtualizedListFooter",
+  className: "shrink-0 border-t border-stroke px-4 py-2 text-xs text-content-muted"
+}), ie = c("virtualized-list", {
+  part: "search",
+  displayName: "VirtualizedListSearch",
+  className: "min-w-0 flex-1"
+}), j = d.forwardRef(({ className: t, children: a, getVisibleIds: r, ...e }, i) => {
+  const { list: s } = f(), o = d.useMemo(
+    () => r ? r(s) : _(s),
+    [r, s]
+  ), n = o.length > 0 && s.rowState.isAllSelected(o), u = typeof a == "function" ? a({ allVisibleSelected: n }) : a ?? (n ? "Deselect visible" : "Select all visible");
+  return /* @__PURE__ */ l(
+    "button",
+    {
+      ref: i,
+      type: "button",
+      "data-component": "virtualized-list-select-all",
+      className: p(
+        "shrink-0 text-sm font-medium text-brand hover:underline",
+        t
+      ),
+      onClick: () => s.rowState.toggleSelectAll(o),
+      ...e,
+      children: u
+    }
+  );
+});
+j.displayName = "VirtualizedListSelectAll";
+const I = d.forwardRef(({ className: t, children: a, ...r }, e) => {
+  const { scrollRef: i } = f(), s = N(i, e);
+  return /* @__PURE__ */ l(
+    "div",
+    {
+      ref: s,
+      "data-component": "virtualized-list-viewport",
+      className: p("shrink-0 overflow-auto", t),
+      ...r,
+      children: a
+    }
+  );
+});
+I.displayName = "VirtualizedListViewport";
+function se({
+  children: t,
+  className: a,
+  getItemMeasure: r
+}) {
+  const { list: e } = f();
+  return /* @__PURE__ */ l(
+    "div",
+    {
+      "data-component": "virtualized-list-content",
+      className: p("relative w-full", a),
+      style: { height: e.totalHeight },
+      children: e.virtualItems.map((i) => {
+        const s = e.getRow(i.index), o = r ? r(s) : !0;
+        return /* @__PURE__ */ l(
+          b,
+          {
+            virtualItem: i,
+            row: s,
+            measure: o,
+            children: t(s, i)
+          },
+          String(i.key)
+        );
+      })
+    }
+  );
+}
+const K = 220, b = d.forwardRef(
+  ({ virtualItem: t, children: a, className: r, measure: e, row: i, ...s }, o) => {
+    const { list: n } = f(), u = m(null), x = m(i?.isExpanded), h = m(e), S = n.getItemProps(t, { measure: e }), { key: U, ref: E, style: g, ...k } = S, A = N(E, o, u);
+    return P(() => {
+      const M = x.current, L = i?.isExpanded, C = h.current, z = e !== !1, V = M === !0 && L === !1;
+      (V || C && !z) && n.resetRowSize(t.index);
+      let v;
+      return V && z && (v = window.setTimeout(() => {
+        const w = u.current;
+        w && n.measureElement(w);
+      }, K)), x.current = L, h.current = z, () => {
+        v !== void 0 && window.clearTimeout(v);
+      };
+    }, [i?.isExpanded, e, t.index, n]), /* @__PURE__ */ l(
+      "div",
+      {
+        ref: A,
+        "data-component": "virtualized-list-item",
+        style: g,
+        className: r,
+        ...k,
+        ...s,
+        children: a
+      }
+    );
+  }
+);
+b.displayName = "VirtualizedListItem";
+const O = d.forwardRef(({ className: t, children: a, ...r }, e) => /* @__PURE__ */ l(
+  "div",
+  {
+    ref: e,
+    "data-component": "virtualized-list-item-skeleton",
+    className: p("px-3 py-2", t),
+    ...r,
+    children: a ?? /* @__PURE__ */ l(
+      "div",
+      {
+        className: "h-12 w-full animate-pulse rounded-md bg-muted",
+        "aria-hidden": !0
+      }
+    )
+  }
+));
+O.displayName = "VirtualizedListItemSkeleton";
+export {
+  F as VirtualizedList,
+  se as VirtualizedListContent,
+  te as VirtualizedListFooter,
+  $ as VirtualizedListHeader,
+  ee as VirtualizedListHeaderActions,
+  b as VirtualizedListItem,
+  O as VirtualizedListItemSkeleton,
+  ie as VirtualizedListSearch,
+  j as VirtualizedListSelectAll,
+  y as VirtualizedListShell,
+  I as VirtualizedListViewport
+};

package/dist/lib/virtualized/virtualized-list-utils.d.ts

@@ -0,0 +1,5 @@
+import { UseVirtualizedListResult } from './useVirtualizedList';
+/**
+ * Row ids for loaded rows currently in the virtual window (excludes loading / error placeholders).
+ */
+export declare function getVisibleReadyRowIds<TData>(list: Pick<UseVirtualizedListResult<TData>, "virtualItems" | "getRow">): string[];