@sheetxl/grid-react 0.7.28-beta.4 → 0.8.0-beta.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sheetxl/grid-react",
   "description": "Grid React - Advanced grid component for React",
-  "version": "0.7.28-beta.4",
+  "version": "0.8.0-beta.1",
   "license": "SEE LICENSE IN <LICENSE>",
   "type": "module",
   "exports": {
@@ -42,8 +42,8 @@
   ],
   "dependencies": {
     "@floating-ui/react-dom": "^2.1.9",
-    "@sheetxl/utils": "^0.7.28-beta.4",
-    "@sheetxl/utils-react": "^0.7.28-beta.4",
+    "@sheetxl/utils": "^0.8.0-beta.1",
+    "@sheetxl/utils-react": "^0.8.0-beta.1",
     "clsx": "^2.1.1",
     "react-merge-refs": "^3.0.2",
     "react-use": "^17.6.1",

package/types/src/layer/HoverTipLayer.d.ts

@@ -1,29 +1,25 @@
 import { default as React } from 'react';
 import { CellCoords, RangeCoords } from '@sheetxl/utils';
 import { IGridPane } from '../surface';
-import { LayerProps } from './Layer';
 import { StickyState } from './StickyAnchor';
 import { HoverTipProps } from './useHoverIntent';
-import { GridPlacement, GridWhenOff, GridBoundary } from './useGridAnchor';
-/** A hit returned by a {@link HoverTipLayerProps.probe} — the range to anchor on plus arbitrary payload. */
-export interface HoverTarget<T = unknown> {
-    /** The range the tip anchors to (e.g. the cell's own range, or an enclosing table). */
-    range: RangeCoords;
-    /**
-     * Stable identity for dedupe — the tip re-opens only when this changes (a `pointermove` storm within
-     * one target is a no-op). Defaults to the range's coords.
-     */
-    key?: string;
-    /** Payload passed to the render-prop (the message, the table, …). */
-    data: T;
-}
+import { RangeFloatTarget, RangeFloatLayerProps } from './RangeFloatLayer';
+/**
+ * A hit returned by a {@link HoverTipLayerProps.probe} — the range to anchor on plus arbitrary payload.
+ *
+ * The hover-flavored name for a {@link RangeFloatTarget}; they are the same shape.
+ */
+export type HoverTarget<T = unknown> = RangeFloatTarget<T>;
 /** The context passed to a {@link HoverTipLayerProps} render-prop. */
 export interface HoverTipRender<T = unknown> {
     /** The anchored range. */
     range: RangeCoords;
     /** The probe payload. */
     data: T;
-    /** Spread onto the tip element to keep it open while hovered (`pointer-events:auto` + enter/leave). */
+    /**
+     * Spread onto the tip element to keep it open while hovered (`pointer-events:auto` + enter/leave).
+     * The same object {@link RangeFloatLayer} calls `floatProps`.
+     */
     tipProps: HoverTipProps;
     /** The resolved sticky state (e.g. `state.scrollIntoView()`). */
     state: StickyState;
@@ -31,44 +27,21 @@ export interface HoverTipRender<T = unknown> {
 /**
  * Props for {@link HoverTipLayer}.
  */
-export interface HoverTipLayerProps<T = unknown> extends Omit<LayerProps, 'children'> {
-    /** Class for the floated tip container. */
-    className?: string;
-    /** Style for the floated tip container. */
-    style?: React.CSSProperties;
+export interface HoverTipLayerProps<T = unknown> extends Omit<RangeFloatLayerProps<T>, 'activateOn' | 'selection' | 'target' | 'probe' | 'children'> {
     /** Probe the hovered cell → a {@link HoverTarget} (range + data), or `null` when nothing should show. */
     probe: (coords: CellCoords, pane: IGridPane) => HoverTarget<T> | null;
-    /** Which side of the range the tip attaches to. @defaultValue `{ side: 't' }` */
-    placement?: GridPlacement;
-    /** Gap (px) perpendicular to the edge. @defaultValue 6 */
-    offset?: number;
-    /** Offset (px) along the edge (only `start` / `end` align). @defaultValue 0 */
-    alignOffset?: number;
-    /** Dwell (ms) before the tip shows. @defaultValue 300 */
-    openDelay?: number;
-    /** Grace (ms) before the tip hides (bridges the gap to the tip). @defaultValue 150 */
-    closeDelay?: number;
-    /** What happens when the anchor leaves the data area. @defaultValue 'hide' */
-    whenOff?: GridWhenOff;
-    /** Clip / clamp boundary. @defaultValue 'data' */
-    boundary?: GridBoundary;
-    /** @defaultValue 1250 */
-    zIndex?: number;
-    /**
-     * Edge-triggered hard dismissal: when this transitions truthy the current tip closes **immediately**
-     * (bypassing `closeDelay`) — e.g. the anchored cell entered edit mode. It does not hold the tip
-     * closed; a subsequent hover re-opens it normally.
-     */
-    dismiss?: boolean;
     /** Render the tip. **Spread `tipProps`** on the returned element so hovering it keeps the tip open. */
     children: (info: HoverTipRender<T>) => React.ReactNode;
 }
 /**
- * The reusable **hover-tooltip layer**: sweeps the pointer over cells (a {@link Layer} tap +
- * `getCellFromPointer`), asks a {@link HoverTipLayerProps.probe} whether the hovered cell has something
- * to show, and — via the shared hover intent ({@link useHoverIntent}) — floats a {@link StickyFloat} tip
- * (with flip / shift). The probe supplies the anchor range + payload; the render-prop draws the tip and
- * keeps it open on hover. This is the shared engine behind `CellErrorLayer`, a table tip, etc.
+ * The **hover preset** of {@link RangeFloatLayer} — `activateOn: 'hover'`, with the render-prop's
+ * `floatProps` surfaced under its original name `tipProps`.
+ *
+ * @remarks
+ * The engine (pointer tap, hover intent, anchoring, dismissal) lives in {@link RangeFloatLayer}; this
+ * is the ergonomic entry point for the pure-tooltip case and the shape `CellErrorLayer` uses. Reach
+ * for `RangeFloatLayer` directly when the float is activated by the selection, driven by a gesture, or
+ * is something other than a tip.
  */
 export declare const HoverTipLayer: <T>(props: HoverTipLayerProps<T>) => React.ReactElement;
 //# sourceMappingURL=HoverTipLayer.d.ts.map

package/types/src/layer/RangeFloatLayer.d.ts

@@ -0,0 +1,141 @@
+import { default as React } from 'react';
+import { CellCoords, RangeCoords } from '@sheetxl/utils';
+import { IGridPane } from '../surface';
+import { ICellAnchor } from '../selection/ICellAnchor';
+import { LayerProps } from './Layer';
+import { StickyState } from './StickyAnchor';
+import { HoverTipProps } from './useHoverIntent';
+import { GridPlacement, GridWhenOff, GridBoundary } from './useGridAnchor';
+/**
+ * How the layer decides WHICH range is floating.
+ *
+ * - `'hover'` — the pointer, through the shared hover intent (open / close delays, keep-open-on-float).
+ * - `'selection'` — the active cell of {@link RangeFloatLayerProps.selection}, with no delay: a resting
+ *   affordance, not a transient tip.
+ *
+ * Pass an array to accept EITHER (`['hover','selection']` — not an AND; each one opens the float on its
+ * own). Omit entirely and drive {@link RangeFloatLayerProps.target} yourself (gesture-driven action
+ * popups — paste options, autofill options).
+ */
+export type RangeFloatActivation = 'hover' | 'selection';
+/** A hit from a {@link RangeFloatLayerProps.probe} — the range to anchor on plus arbitrary payload. */
+export interface RangeFloatTarget<T = unknown> {
+    /** The range the float anchors to (e.g. the cell's own range, a merge, or an enclosing table). */
+    range: RangeCoords;
+    /**
+     * Stable identity for dedupe — the float re-opens only when this changes (a `pointermove` storm
+     * within one target is a no-op). Defaults to the range's coords.
+     */
+    key?: string;
+    /** Payload passed to the render-prop (the message, the validation, the table, …). */
+    data: T;
+}
+/** The context passed to a {@link RangeFloatLayerProps} render-prop. */
+export interface RangeFloatRender<T = unknown> {
+    /** The anchored range. */
+    range: RangeCoords;
+    /** The probe payload. */
+    data: T;
+    /**
+     * Spread onto the floated element. Supplies `pointer-events: auto` (a layer's box never takes the
+     * pointer, so content must opt back in) and — under `'hover'` — the enter/leave handlers that keep
+     * the float open while the pointer is on it.
+     */
+    floatProps: HoverTipProps;
+    /** The resolved sticky state (e.g. `state.scrollIntoView()`, `state.slid`). */
+    state: StickyState;
+}
+/**
+ * Props for {@link RangeFloatLayer}.
+ */
+export interface RangeFloatLayerProps<T = unknown> extends Omit<LayerProps, 'children'> {
+    /** Class for the floated container. */
+    className?: string;
+    /** Style for the floated container. */
+    style?: React.CSSProperties;
+    /**
+     * What makes a float appear. Omit to drive {@link target} yourself.
+     * @defaultValue none (controlled)
+     */
+    activateOn?: RangeFloatActivation | readonly RangeFloatActivation[];
+    /**
+     * Identity for the hover state this layer brokers across its per-pane copies. Defaults to the
+     * layer's z-slot, which is already unique per grid child — pass one only when a SINGLE grid child
+     * hosts more than one `RangeFloatLayer` (they would otherwise share a cell and fight).
+     */
+    name?: string;
+    /**
+     * Ask whether a cell has something to float — the anchor range + payload, or `null` for nothing.
+     * Called with the hovered cell (`'hover'`) and with the selection's active cell (`'selection'`), so
+     * one probe serves both. Not needed when {@link target} is controlled.
+     */
+    probe?: (coords: CellCoords, pane: IGridPane) => RangeFloatTarget<T> | null;
+    /**
+     * The selection to follow for `activateOn: 'selection'`. An {@link ICellAnchor} rather than a full
+     * selection — the layer only ever reads the active cell and subscribes to it.
+     */
+    selection?: ICellAnchor;
+    /**
+     * Controlled target: supply it (including `null`) and the layer floats exactly what you say,
+     * ignoring `activateOn` / `probe`. The escape hatch for gesture-driven popups whose lifetime is the
+     * action's, not the pointer's.
+     */
+    target?: RangeFloatTarget<T> | null;
+    /**
+     * Hard close. Under `'hover'` it is **edge-triggered**: the float drops now, bypassing `closeDelay`,
+     * and a later hover re-opens normally. Under `'selection'` there is no gesture to re-arm it, so it
+     * reads as a **level**: the float stays closed while this holds and returns when it clears (e.g. the
+     * anchored cell is in edit mode). Ignored when {@link target} is controlled — the lifetime is yours
+     * there, so close it by passing `null`.
+     */
+    dismiss?: boolean;
+    /** Which side of the range the float attaches to. @defaultValue `{ side: 't' }` */
+    placement?: GridPlacement;
+    /** Gap (px) perpendicular to the edge. @defaultValue 6 */
+    offset?: number;
+    /** Offset (px) along the edge (only `start` / `end` align). @defaultValue 0 */
+    alignOffset?: number;
+    /** Dwell (ms) before a hovered float shows. @defaultValue 300 */
+    openDelay?: number;
+    /** Grace (ms) before a hovered float hides (bridges the gap to the float). @defaultValue 150 */
+    closeDelay?: number;
+    /** What happens when the anchor leaves the data area. @defaultValue 'hide' */
+    whenOff?: GridWhenOff;
+    /** Where the float may live. @defaultValue 'data' */
+    boundary?: GridBoundary;
+    /** @defaultValue 1250 */
+    zIndex?: number;
+    /** Render the float. **Spread `floatProps`** on the returned element. */
+    children: (info: RangeFloatRender<T>) => React.ReactNode;
+}
+/**
+ * The **range float layer**: content anchored to a range that portals out of the pane clip. It owns
+ * the three things every such float needs — **anchoring** (a {@link StickyFloat} on the probed range),
+ * **activation** (what makes it appear) and **dismissal**. What it draws is entirely the consumer's:
+ * a tooltip, a button, a toolbar, an action popup.
+ *
+ * @remarks
+ * This is the **float half** of the grid's two mechanisms. A `CellTileDiv` covers everything whose
+ * content is a function of the cell alone — clicks and hover styling included — as a cached DOM
+ * snapshot. A float is for content that depends on transient UI state (selection, hover, open/closed)
+ * or that must leave the cell box. "Only on the active cell" is the expensive predicate: it would
+ * dirty a tile per selection move, which is exactly why it belongs here.
+ *
+ * Activation is pluggable and the rest of the layer is identical across the choices:
+ *
+ * ```tsx
+ * <RangeFloatLayer activateOn="hover" probe={probeError}>
+ *   {({ data, floatProps }) => <div {...floatProps}>{data.message}</div>}
+ * </RangeFloatLayer>
+ *
+ * <RangeFloatLayer activateOn="selection" selection={selection} probe={probeList}>
+ *   {({ range, floatProps }) => <Chevron {...floatProps} onPointerDown={() => open(range)} />}
+ * </RangeFloatLayer>
+ * ```
+ *
+ * When either can activate it, hover is the transient override and selection is the resting state:
+ * while the pointer holds a target the float shows that one, and it falls back to the selection's when
+ * the pointer leaves.
+ */
+export declare const RangeFloatLayer: <T>(props: RangeFloatLayerProps<T>) => React.ReactElement;
+//# sourceMappingURL=RangeFloatLayer.d.ts.map

package/types/src/layer/StickyAnchor.d.ts

@@ -1,7 +1,7 @@
 import { default as React } from 'react';
 import { Bounds, Point, AnchorLocation } from '@sheetxl/utils';
 import { IGridPane } from '../surface';
-import { GridAnchor, GridPlacement, GridBoundary, GridWhenOff, GridSlide } from './useGridAnchor';
+import { GridAnchor, GridAnchorReference, GridPlacement, GridBoundary, GridWhenOff, GridSlide } from './useGridAnchor';
 /**
  * The state a {@link StickyAnchor} publishes to its child. Carries the resolved `anchorPoint` (+ owner /
  * clip / slide state) so the child alone decides how to render:
@@ -14,9 +14,7 @@ import { GridAnchor, GridPlacement, GridBoundary, GridWhenOff, GridSlide } from
  */
 export interface StickyState {
     /** Client-space Floating UI virtual reference (stable identity; reads live). */
-    reference: {
-        getBoundingClientRect: () => DOMRect;
-    };
+    reference: GridAnchorReference;
     /** Client-space boundary rect (for `flip`/`shift`/`hide` limiters). */
     getBoundaryRect: () => DOMRect;
     /** The placement's anchor pixel (client px). */

package/types/src/layer/StickyFloat.d.ts

@@ -32,7 +32,10 @@ export interface StickyFloatProps {
     placement?: GridPlacement;
     /** What happens when the anchor leaves the data area. @defaultValue 'hide' */
     whenOff?: GridWhenOff;
-    /** Clip / clamp boundary. @defaultValue 'data' */
+    /**
+     * Where the float may LIVE — one rect, resolved by {@link GridBoundary}: it is both the anchor's
+     * clip / clamp boundary and the rect `flip` / `shift` collide against. @defaultValue 'data'
+     */
     boundary?: GridBoundary;
     /** Px overlap below which a geometried anchor reads as clipped. @defaultValue 0 */
     minVisible?: number;

package/types/src/layer/index.d.ts

@@ -1,11 +1,12 @@
 export * from './LayerTypes';
 export * from './Layer';
 export * from './VirtualDiv';
-export type { GridAnchor, GridPlacement, GridWhenOff, GridBoundary, GridFloatSide, GridAlign, GridSlide } from './useGridAnchor';
+export type { GridAnchor, GridAnchorReference, GridPlacement, GridWhenOff, GridBoundary, GridFloatSide, GridAlign, GridSlide } from './useGridAnchor';
 export * from './StickyAnchor';
 export * from './StickyFloat';
 export * from './useHoverIntent';
 export * from './useRangeHover';
+export * from './RangeFloatLayer';
 export * from './HoverTipLayer';
 export * from './RangePrompt';
 //# sourceMappingURL=index.d.ts.map

package/types/src/layer/useGridAnchor.d.ts

@@ -60,15 +60,18 @@ export type GridAnchor = {
     point: Point;
 };
 /**
- * The clip / clamp boundary — a **rect fed to the positioning math**, NOT a DOM parent. This is how
- * "don't slide under the headers" is expressed: clamp to the data viewport.
+ * The clip / clamp boundary — a **rect fed to the positioning math**, NOT a DOM parent. One prop, one
+ * meaning: *where may this thing live*. It governs the anchor's clip / clamp AND (via `StickyFloat`)
+ * where `flip` / `shift` may land the float. This is how "don't slide under the headers" is expressed:
+ * clamp to the data viewport.
  *
  * - `'data'` — the union of the panes' cell areas (headers excluded). Default.
  * - `'pane'` — just the resolving pane's cell area.
  * - `'grid'` — currently the same as `'data'` (until a surface/header rect is threaded).
+ * - `'viewport'` — the browser viewport: the opt-out, for a float that may cover grid chrome.
  * - a {@link Bounds} — an explicit **client-px** rect.
  */
-export type GridBoundary = 'data' | 'pane' | 'grid' | Bounds;
+export type GridBoundary = 'data' | 'pane' | 'grid' | 'viewport' | Bounds;
 /** A `DOMRect`-shaped plain object (works in Floating UI and in Node tests without a DOM). */
 export interface GridAnchorRect {
     x: number;
@@ -106,15 +109,29 @@ export interface GridAnchorResolved {
      */
     outOfView: boolean;
 }
+/**
+ * The Floating UI **virtual reference** for a grid anchor. Stable identity (so `autoUpdate` subscribes
+ * once), but both members read **live**.
+ */
+export interface GridAnchorReference {
+    /** The anchor's client rect, read live on every call (`autoUpdate` calls it between React renders). */
+    getBoundingClientRect: () => DOMRect;
+    /**
+     * The pane element. `autoUpdate` unwraps a virtual reference to *this* element and gates **every**
+     * DOM-side trigger on it — ancestor `scroll`, the `observeMove` layout-shift detector, element resize.
+     * Without it only the window `resize` listener survives, which is why the float used to need a 60fps
+     * `animationFrame` poll. A **getter**: the pane element only exists after mount, and resolving it
+     * lazily keeps this object's identity stable.
+     */
+    readonly contextElement?: Element;
+}
 /** The hook result: stable live accessors + render-time snapshot values. */
 export interface UseGridAnchorResult {
     /**
      * A Floating UI **virtual reference** with **stable identity** — its `getBoundingClientRect` reads
      * the anchor **live** on every call (Floating UI's `autoUpdate` invokes it between React renders).
      */
-    reference: {
-        getBoundingClientRect: () => DOMRect;
-    };
+    reference: GridAnchorReference;
     /** Live accessor for the boundary rect (for `shift`/`flip`/`hide` limiters). */
     getBoundaryRect: () => DOMRect;
     /** Render-time snapshot: anchor outside the boundary. Updates each scroll frame (pane re-render). */

package/types/src/layer/useRangeHover.d.ts

@@ -26,10 +26,11 @@ export interface UseRangeHoverResult {
  *
  * @remarks
  * Registers a passive `pointermove` / `pointerleave` responder on the pane's Stage (mirrors
- * a {@link Layer} tap); it never consumes the event. Because a grid child renders per pane, the tip
- * resolves on the pane owning the anchor — for a range that straddles panes the open state follows the
- * pointer's pane, which can differ from the owner (a known v1 limitation; small / single-cell ranges,
- * the common error-tooltip case, are unaffected).
+ * a {@link Layer} tap); it never consumes the event. Because a grid child renders per pane, the pointer
+ * is seen by whichever pane it is over while the tip renders on the pane owning the anchor — which for
+ * a range straddling a freeze is a DIFFERENT pane. The aimed target is therefore brokered through
+ * {@link useSurfaceState}, so every pane copy runs its intent off the same signal and the owner is
+ * armed no matter where the pointer is.
  */
 export declare const useRangeHover: (range: RangeCoords, options?: UseHoverIntentOptions) => UseRangeHoverResult;
 //# sourceMappingURL=useRangeHover.d.ts.map

package/types/src/list/List.d.ts

@@ -40,16 +40,16 @@ export interface ListProps extends React.HTMLAttributes<HTMLDivElement> {
     ref?: React.Ref<IListElement>;
 }
 /**
- * A virtualized **list** built on `GridSurface` with the grid's own layers — a `CellLayer` for the
- * items and a `SelectionLayer` for the active-row highlight + Arrow keys (the same shape as the editor
- * demo: a model passed to layers as props).
+ * A virtualized **list** of arbitrary React content, built on {@link ListSurface} — which is the
+ * grid's own machinery (a `CellLayer` for the items and a `SelectionLayer` for the active-row
+ * highlight + Arrow keys) dressed as a list.
  *
  * @remarks
  * The List's whole state is its {@link ListProps.selection}; it has no per-item callbacks and no notion
  * of "checked" or "toggle". Pointer selection is the `SelectionLayer`'s job (it hit-tests the pointer),
  * so the cells are inert, transparent content; the keyboard is the caller's via {@link ListProps.onKeyDown}.
- * The active row fills (no Excel anchor hole) and carries an inset ring, since the anchor is the live
- * Space/scroll target. See {@link CheckboxList} for the checkbox-list specialization.
+ * See {@link CheckboxList} for the checkbox-list specialization, and `SheetValueList` in
+ * `@sheetxl/react` for the sheet-backed one (real cells, so values format like the sheet).
  */
 export declare const List: React.ForwardRefExoticComponent<Omit<ListProps, "ref"> & React.RefAttributes<IListElement>>;
 //# sourceMappingURL=List.d.ts.map

package/types/src/list/ListSurface.d.ts

@@ -0,0 +1,73 @@
+import { default as React } from 'react';
+import { CellLayerProps, CellRendererProps } from '../cell';
+import { LayerEventProps } from '../layer';
+import { ISelection } from '../selection';
+/**
+ * Props for {@link ListSurface}.
+ */
+export interface ListSurfaceProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Number of rows. */
+    itemCount: number;
+    /**
+     * Render one row, as a grid cell — the `CellLayer` renderer, so the row is handed its bounds, its
+     * pane (zoom) and its resolved `value`. The cell is positioned and clipped by the tiling engine.
+     */
+    renderCell: (props: CellRendererProps) => React.ReactNode;
+    /**
+     * Resolve the visible rows to render (and their `value`). Omit to render every visible row with no
+     * pre-resolved value — `renderCell` then derives its content from the row index.
+     */
+    getVisibleCells?: CellLayerProps['getVisibleCells'];
+    /**
+     * Uniform row height in px. Also the list's natural height (`itemCount * itemHeight`) unless
+     * `style.height` overrides it. @defaultValue 24
+     */
+    itemHeight?: number;
+    /**
+     * Width the **column** should be, in px — the list sizes itself to this PLUS its own chrome (the
+     * vertical scrollbar's gutter), so the column actually ends up this wide.
+     *
+     * @remarks
+     * The distinction matters because the natural thing to pass — a measured content width, e.g.
+     * `ICellRange.getBestFit().width` — describes the column, not the box. Setting it as the box's
+     * `width` instead silently hands the gutter's worth of pixels back, and content sized to fit
+     * exactly then does not. Omit to size from `style` and let the column take what is left.
+     */
+    contentWidth?: number;
+    /**
+     * The selection model — the active-row highlight + Arrow-key navigation. The surface's *state*.
+     * Owned by the caller (so it can read what's selected); a private one is created when omitted.
+     */
+    selection?: ISelection;
+    /**
+     * Event taps installed as the list's TOP layer — so they are offered keys and pointers before the
+     * built-in Arrow navigation and before the selection's own hit test. Handle Space/Enter here (the
+     * grid would otherwise consume them) and `stopPropagation` to override; anything you don't consume
+     * falls through to navigation.
+     */
+    propsLayer?: LayerEventProps;
+    /** Take focus on mount, so the Arrow keys work without a click first. @defaultValue false */
+    autoFocus?: boolean;
+    /** Opaque content cache-bust forwarded to the `CellLayer`. */
+    cacheToken?: unknown;
+    /** Ref for the Element. */
+    ref?: React.Ref<HTMLDivElement>;
+}
+/**
+ * The **list chrome**: a virtualized single-column `GridSurface` wearing the grid's own layers — a
+ * `CellLayer` for the rows and a `SelectionLayer` for the active-row highlight + Arrow keys — dressed
+ * so it reads as a list rather than a grid.
+ *
+ * @remarks
+ * Not a list *component*: it renders no row content of its own, has no notion of an item, and adds no
+ * padding — {@link ListSurfaceProps.renderCell} owns the whole row box. It exists because there are
+ * two kinds of list ({@link List}, whose rows are arbitrary React, and `@sheetxl/react`'s
+ * `SheetValueList`, whose rows are real sheet cells) and they differ ONLY in that renderer. Everything
+ * they share — the viewport, the measured single column, the selection styling and its rationale, the
+ * layer order — is here, once.
+ *
+ * The single column tracks the measured content width, so a row spans the full list; scrolling is
+ * vertical only.
+ */
+export declare const ListSurface: React.ForwardRefExoticComponent<Omit<ListSurfaceProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=ListSurface.d.ts.map

package/types/src/list/index.d.ts

@@ -1,3 +1,4 @@
+export * from './ListSurface';
 export * from './List';
 export * from './CheckboxList';
 //# sourceMappingURL=index.d.ts.map