@sheetxl/grid-react 0.7.27 → 0.7.28-beta.2

package/types/src/selection/RangesPickerLayer.d.ts

@@ -0,0 +1,128 @@
+import { default as React } from 'react';
+import { VisualSVGProps } from '../svg';
+import { HandleAnchor, DragHandleRenderProps } from '../range';
+import { LayerProps } from '../layer';
+import { ISelection } from './ISelection';
+/**
+ * The range-reference palette, in rotation order. The default {@link RangesPickerLayer} look cycles `stroke`
+ * through this so each range gets its own color — `PICKER_COLORS[i % length]` — and the fill is derived
+ * automatically (a low-alpha tint of the same color).
+ *
+ * These are the shared `--sxl-color-series-*` theme tokens (the SAME hues the formula editor colors reference
+ * text with, so a range's text and its rectangle match), so they follow light/dark automatically. The literal
+ * fallback keeps a bare (un-themed) grid — storybook / SDK-free reference use — colored.
+ */
+export declare const PICKER_COLORS: readonly string[];
+/**
+ * Props for {@link RangesPickerLayer}. It **renders a {@link Layer}** at its root (extends
+ * {@link LayerProps}: `zIndex`, tap handlers), so a consumer stacks it like any layer. The shared
+ * base outline look for every range is {@link RangesPickerLayerProps.rangeStyle}, with
+ * {@link RangesPickerLayerProps.getRangeStyle} overriding per range (default: cycle `stroke`
+ * through the {@link PICKER_COLORS}).
+ */
+export interface RangesPickerLayerProps extends LayerProps {
+    /** Shared base outline look for every range (`stroke`, `strokeWidth`, …), merged UNDER `getRangeStyle`. */
+    rangeStyle?: VisualSVGProps;
+    /**
+     * The selection model this layer renders + edits (like {@link SelectionLayer}, and typically a
+     * `SheetSelection` over an sdk `IRangeSelection.createSelection()`). It reads the model's
+     * {@link SelectionCoords} — one resizable + movable rectangle per range, the `rangeIndex` range
+     * **active** — and writes every move / resize / draw back through `setSelection`, setting
+     * `rangeIndex` to the edited range so a text-backed model can rewrite exactly that reference.
+     *
+     * @remarks
+     * Unlike {@link SelectionLayer} it renders *only ranges* (never an anchor cell — Excel doesn't draw
+     * the formula's home). A gesture over an empty picker (or a click while the caret isn't on a reference)
+     * APPENDS a new range, so it doubles as the "insert a new reference" surface.
+     */
+    selection: ISelection;
+    /**
+     * Per-range outline props, merged over the layer's shared base ({@link VisualSVGProps}). Receives the
+     * range `index` and whether it's `active`. Defaults to cycling `stroke` through {@link PICKER_COLORS}
+     * (`PICKER_COLORS[index % length]`). The layer still derives the fill (a low-alpha tint of `stroke`
+     * unless you set `fill`), the active animation, and the hover/drag emphasis on top of what you return.
+     *
+     * Return `null` to OMIT that range from this layer entirely — no outline, no resize/move handles, not
+     * interactive. The model (`selection`) is untouched; this is a per-INSTANCE render filter, not a data
+     * filter. Lets a consumer share one multi-range model across several layers and have each show only
+     * the subset relevant to it (e.g. a formula's references split across per-sheet panes) with no index
+     * remapping — writes still go back through `selection.setSelection` at the range's real, unfiltered
+     * index, since the model itself was never filtered.
+     */
+    getRangeStyle?: (index: number, active: boolean) => VisualSVGProps | null;
+    /**
+     * Which resize handles to show. @defaultValue {@link RESIZE_ANCHORS_4} (corners). Pass
+     * {@link RESIZE_ANCHORS_8} for corners + edge midpoints.
+     */
+    anchors?: readonly HandleAnchor[];
+    /** Enable the move grip (drag the border to relocate a range, keeping its size). @defaultValue false */
+    enabledMove?: boolean;
+    /**
+     * Don't claim the grid-wide **draw** gesture — the pointer-drag over empty grid that re-scopes the
+     * **active** range from scratch. Ranges stay movable/resizable via their border + corners.
+     * @defaultValue false
+     */
+    disableDraw?: boolean;
+    /**
+     * Allow Ctrl/Cmd+click (and drag) on the draw surface to **append** a brand-new range even while a
+     * range is active — the multi-range pick gesture (Excel point mode's Ctrl+click; a text-backed
+     * consumer renders the appended range after a `,` separator). Set `false` for a picker whose value
+     * is a single rectangle (a chart series / table range field): the modifier is then ignored and the
+     * gesture is a plain draw. There is deliberately no Ctrl+click *deselect* counterpart (unlike the
+     * body selection's `useSelectionPointer`) — Excel does not remove a reference by clicking it.
+     *
+     * @defaultValue true
+     */
+    allowMulti?: boolean;
+    /** Resize handle size (px). @defaultValue 8 */
+    size?: number;
+    /**
+     * Animate the **active** range's outline with a marching-ants stroke (the others stay static).
+     *
+     * @defaultValue false
+     */
+    animated?: boolean;
+    /**
+     * Render the resize corner grips yourself (headless) — forwarded to {@link RangeResizer}'s
+     * `renderHandle` per anchor. Replaces the default grips.
+     */
+    renderHandle?: (props: DragHandleRenderProps) => React.ReactNode;
+    /**
+     * Keep whatever had focus across a drag (draw / move / resize) rather than letting the gesture move
+     * focus to the grid's `tabIndex` Stage. The picker is used *while editing a formula*, so a handle drag
+     * must not blur the editor's textarea — it preserves the existing focus (nothing to restore). Turn off
+     * only for a picker used outside an editor. @defaultValue true
+     */
+    preserveFocus?: boolean;
+    /**
+     * Called when a rectangle gesture (draw / move / resize) starts (`true`) and ends (`false`) — one
+     * aggregated signal across all of them. Lets a host react to "a reference drag is in progress" as a whole,
+     * e.g. the formula editor hiding its hint popup for the duration. `index` is the range being moved/resized
+     * (so a host can highlight exactly that reference), or `null` for a DRAW (no existing range yet) / idle.
+     */
+    onDragActiveChange?: (active: boolean, index: number | null) => void;
+}
+/**
+ * The default per-range look: cycle the stroke through {@link PICKER_COLORS}. Exported so a consumer
+ * wrapping {@link RangesPickerLayerProps.getRangeStyle} (e.g. to add a per-instance visibility filter —
+ * see that prop's doc) can fall back to it instead of reimplementing the color cycle.
+ */
+export declare const defaultRangeStyle: (index: number) => VisualSVGProps;
+/**
+ * A **multi-rectangle** range picker — each rectangle resizable + movable — used to re-scope a set of
+ * **formula references** or a **chart's data ranges**. Like {@link SelectionLayer} it binds to an
+ * {@link ISelection} model, but it renders *only ranges* (never an anchor cell — Excel doesn't draw the
+ * formula's home).
+ *
+ * @remarks
+ * Each range is a {@link RangeResizer} (outline + corners) wrapped in a {@link Draggable}
+ * (border-ring move), colored from {@link RangesPickerLayerProps.getRangeStyle} (default: cycle
+ * {@link PICKER_COLORS}). The model's `rangeIndex` range is **active** — the grid draw re-scopes it and it
+ * animates; interacting with a range makes it active. Every gesture writes back through
+ * `selection.setSelection`, setting `rangeIndex` to the edited range. A draw while the caret isn't on a
+ * reference (`rangeIndex < 0`) APPENDS a new range instead (insert / draw-from-empty). Shift+draw
+ * EXTENDS the active range from its start corner; Ctrl/Cmd+draw appends a new range even while one is
+ * active (gated by {@link RangesPickerLayerProps.allowMulti}).
+ */
+export declare const RangesPickerLayer: React.FC<RangesPickerLayerProps>;
+//# sourceMappingURL=RangesPickerLayer.d.ts.map

package/types/src/selection/SelectionLayer.d.ts

@@ -0,0 +1,179 @@
+import { default as React } from 'react';
+import { CellCoords, RangeCoords } from '@sheetxl/utils';
+import { LayerProps, GridPlacement } from '../layer';
+import { VisualSVGProps } from '../svg';
+import { ISelection } from './ISelection';
+import { SelectionNavigation } from './Types';
+import { SelectionRangeStyle } from './SelectionStyle';
+/**
+ * The in-flight selection gesture passed to {@link SelectionLayerProps.renderTip}:
+ * - `select` — a drag-select growing the active range (Excel's live R×C);
+ * - `move` — the built-in move grip (border drag); `to` is the in-flight destination;
+ * - `fill` — the fill handle; `destination` is the in-flight fill range.
+ */
+export type SelectionGesture = {
+    kind: 'select';
+    range: RangeCoords;
+} | {
+    kind: 'move';
+    from: RangeCoords;
+    to: RangeCoords;
+} | {
+    kind: 'fill';
+    template: RangeCoords;
+    destination: RangeCoords;
+};
+/**
+ * Props for {@link SelectionLayer}.
+ */
+export interface SelectionLayerProps extends LayerProps {
+    /**
+     * The writable selection model this layer owns.
+     */
+    selection: ISelection;
+    /**
+     * The content (used-range) bounds the `…End` keys (End / Ctrl+End) jump to. Supply it from a tier that
+     * knows the used range (the sheet layer) so those keys land on the last cell *with content*; omit it
+     * and they fall back to the grid edge (correct for the dumb {@link DefaultSelection} tier, which has no
+     * used range). It stays a plain bounds getter here — the layer never learns it's a sheet.
+     */
+    getContentBounds?: () => RangeCoords;
+    /**
+     * The bounding REGION enclosing a cell — a table's data range from a tier that knows tables (the sheet
+     * layer), else `null` (the bare sheet). Drives Tab/Enter wrapping inside a table and the row/column
+     * span of Ctrl/Shift+Space. Omit it (the dumb {@link DefaultSelection} tier) and there is no enclosing
+     * region: Tab is a plain move and Ctrl/Shift+Space select the whole grid. The layer never learns it's a
+     * sheet — just a `cell → bounds | null` getter; any escalation lives in the provider.
+     */
+    getRegionBounds?: (cell: CellCoords) => RangeCoords | null;
+    /**
+     * The scroll executor for keyboard selection. Supply it from a tier that OWNS scrolling — e.g. the
+     * sheet layer, which routes to `sheet.scrollTo` so the UI and scripting scroll through one path. When
+     * supplied, the layer delegates every keyboard scroll here and lets the model own the arrow-`navigate`
+     * scroll (it already scrolls to the moved edge) so the two don't compete. When omitted, the layer
+     * scrolls its own pane (correct for a standalone grid, whose {@link DefaultSelection} has no sheet).
+     */
+    scrollIntoView?: (cell: Partial<CellCoords>) => void;
+    /** The single-range look. Merged (slot-by-slot) over {@link DEFAULT_SINGLE_STYLE}. */
+    singleStyle?: SelectionRangeStyle;
+    /** The multi-range look. Merged (slot-by-slot) over {@link DEFAULT_MULTI_STYLE}. */
+    multiStyle?: SelectionRangeStyle;
+    /** The active-cell border within a **multi**-range selection. Merged over {@link DEFAULT_ANCHOR_STYLE}. */
+    multiAnchorStyle?: VisualSVGProps;
+    /**
+     * A border drawn on the active cell within a **single**-range selection. Off by default (Excel draws
+     * none — the selection rectangle is the only outline). Set it to mark the anchor when the fill covers
+     * the whole row (see {@link SelectionLayerProps.anchorHole}) — e.g. a list's focus ring. An `inset`
+     * border stays within the row, so it never clips at the viewport edge.
+     */
+    singleAnchorStyle?: VisualSVGProps;
+    /** The Ctrl/Cmd-drag remove rubber-band. Merged (slot-by-slot) over {@link DEFAULT_REMOVE_PREVIEW_STYLE}. */
+    removePreviewStyle?: SelectionRangeStyle;
+    /**
+     * Stacked layers (fill, move, …) rendered when a single range is selected.
+     */
+    singleLayer?: React.ReactNode;
+    /**
+     * Stacked layers rendered when multiple ranges are selected.
+     */
+    multiLayer?: React.ReactNode;
+    /**
+     * Disable the built-in move grip on a single range (drag the border to move it, Excel-style).
+     *
+     * @defaultValue false
+     */
+    enabledMove?: boolean;
+    /**
+     * Called when the single range is moved by its border — `from` is the original range, `to` the new
+     * one. The selection follows automatically; use this for the data side-effect (cut-move).
+     */
+    onMove?: (from: RangeCoords, to: RangeCoords, e: React.PointerEvent) => void;
+    /** The move drag started (before any translation) — `from` is the range being moved. */
+    onMoveStart?: (from: RangeCoords, e: React.PointerEvent) => void;
+    /**
+     * Live during the move drag — `to` is the in-flight translated range. `e` carries the current
+     * modifiers (Ctrl = copy, Shift = insert), so a consumer can reflect the mode (cursor/description).
+     */
+    onMoveUpdate?: (from: RangeCoords, to: RangeCoords, e: React.PointerEvent) => void;
+    /**
+     * The move drag ended (fires on release regardless of whether the range actually moved) — for teardown
+     * of anything {@link SelectionLayerProps.onMoveStart}/`onMoveUpdate` set (e.g. clearing a drag mode).
+     */
+    onMoveEnd?: () => void;
+    /**
+     * Enable the built-in fill handle on a single range (the Excel fill square at the bottom-right
+     * corner; drag to fill). Opt-in (unlike the always-on move grip) because it adds a visible handle.
+     *
+     * @defaultValue false
+     */
+    enableFill?: boolean;
+    /**
+     * Called when the single range is filled via the handle — `template` is the source range, `destination`
+     * the filled range (which includes the template). The selection extends to `destination` automatically;
+     * use this for the data side-effect (the actual fill).
+     */
+    onFill?: (template: RangeCoords, destination: RangeCoords, e: React.PointerEvent) => void;
+    /**
+     * Adjust the raw fill destination before it drives the preview + fill callbacks — e.g. snap the fill
+     * edge to a merged-cell boundary so the dashed preview and the committed fill agree and never land on
+     * an illegal interval. Given the template and the pointer-derived destination, return the destination
+     * to use. Omit for no snapping.
+     */
+    snapFillDestination?: (template: RangeCoords, destination: RangeCoords) => RangeCoords;
+    /** The fill drag started — `template` is the source range. */
+    onFillStart?: (template: RangeCoords, e: React.PointerEvent) => void;
+    /**
+     * Live during the fill drag — `destination` is the in-flight fill range (incl. the template). Use it
+     * to preview what will be filled (e.g. a value tooltip). The fill axis is `template` vs `destination`.
+     */
+    onFillPreview?: (template: RangeCoords, destination: RangeCoords, e: React.PointerEvent) => void;
+    /**
+     * The fill drag ended (fires on release regardless of whether a fill was drawn) — for teardown of
+     * anything {@link SelectionLayerProps.onFillPreview} set (e.g. closing the preview tooltip).
+     */
+    onFillEnd?: () => void;
+    /**
+     * Fired when a selection pointer interaction ends (click/drag settled) — "act on the just-selected
+     * range" (e.g. the format painter applies the copied format to the new selection). See
+     * {@link SelectionPointerOptions.onSelectionEnd}.
+     */
+    onSelectionEnd?: (e: React.PointerEvent) => void;
+    /**
+     * Render a transient tip during a gesture — a drag-select ({@link SelectionGesture} `select`, live
+     * R×C), a move (`move`, the destination address), or a fill (`fill`, the preview). Return a falsy node
+     * for no tip (e.g. skip a 1×1 drag-select). The tip floats on the in-flight range (non-interactive).
+     */
+    renderTip?: (gesture: SelectionGesture) => React.ReactNode;
+    /** Placement of the gesture tip relative to the in-flight range. @defaultValue `{ side: 'b', align: 'end' }` */
+    tipPlacement?: GridPlacement;
+    /**
+     * Disable the layer's **built-in keyboard** routing (arrows → {@link ISelection.navigate}, Tab/Enter
+     * → {@link ISelection.traverse}) so an external command system owns the keyboard instead — without it,
+     * both would fire the same navigation. Pointer routing is unaffected.
+     *
+     * @defaultValue false
+     */
+    disableKeyboard?: boolean;
+    /**
+     * Cut the active (anchor) cell out of the fill — the Excel "current cell" cutout. For a selection that
+     * is just the 1×1 active cell the cutout covers the *entire* range, so the fill vanishes; set `false`
+     * to fill the whole selected row (then mark the anchor with {@link SelectionLayerProps.singleAnchorStyle},
+     * since the anchor is still the live Space/scroll target).
+     *
+     * @defaultValue true
+     */
+    anchorHole?: boolean;
+}
+/**
+ * The selection layer: renders the selection (single-range "rich" treatment vs multi-range), routes
+ * pointer + keyboard to the model, owns the {@link SelectionRangeStyle} theme, and mounts the
+ * single/multi handle slots bound to the active range. The only piece that knows about
+ * {@link ISelection}; the handle layers stay dumb, controlled RangeHandles.
+ *
+ * @remarks
+ * Slot children are cloned with `range` = the active range injected and their `onDragEnd` wrapped so
+ * the committed range updates the selection (the child's own `onDragEnd`, e.g. a data fill, still
+ * runs after). Handles inherit the active style via {@link SelectionStyleContext}.
+ */
+export declare const SelectionLayer: React.ForwardRefExoticComponent<SelectionLayerProps & React.RefAttributes<SelectionNavigation>>;
+//# sourceMappingURL=SelectionLayer.d.ts.map

package/types/src/selection/SelectionStyle.d.ts

@@ -0,0 +1,28 @@
+import { VisualSVGProps } from '../svg';
+/**
+ * The style of one selection range: a stack of up to three rectangles — a `fill`, a `border` outline,
+ * and an optional `inner` accent ring (the white inner edge of the Excel-style two-tone border). Each
+ * slot is a {@link VisualSVGProps} (a single rectangle's visual override; geometry/hole are supplied by
+ * the layer); a `null` or omitted slot draws no rectangle. Per-mode overrides merge slot-by-slot over
+ * the `DEFAULT_*_STYLE`.
+ */
+export interface SelectionRangeStyle {
+    /** The interior fill (the active cell is cut out via the layer-supplied `hole`). */
+    fill?: VisualSVGProps | null;
+    /** The main outline. */
+    border?: VisualSVGProps | null;
+    /** The inner accent ring, inset inside the border. Omit for a single-tone outline. */
+    inner?: VisualSVGProps | null;
+}
+/** The rich single-range style: tinted fill, thick outline, inner ring (the two-tone border). */
+export declare const DEFAULT_SINGLE_STYLE: SelectionRangeStyle;
+/** The quieter multi-range style: lighter fill, thin outline, thin inner ring. */
+export declare const DEFAULT_MULTI_STYLE: SelectionRangeStyle;
+/**
+ * The active-cell border drawn over a multi-range selection (the anchor cell within the rich range).
+ * Inset so it sits just inside the cell, leaving a gap to the range's outer border.
+ */
+export declare const DEFAULT_ANCHOR_STYLE: VisualSVGProps;
+/** The transient rubber-band shown while Ctrl/Cmd-dragging to remove an area (fill + border stack). */
+export declare const DEFAULT_REMOVE_PREVIEW_STYLE: SelectionRangeStyle;
+//# sourceMappingURL=SelectionStyle.d.ts.map

package/types/src/selection/SelectionTouchGrips.d.ts

@@ -0,0 +1,29 @@
+import { default as React } from 'react';
+import { ISelection } from './ISelection';
+/**
+ * Props for {@link SelectionTouchGrips}.
+ */
+export interface SelectionTouchGripsProps {
+    /** The selection the touch handles read (for placement) and extend (via `modify`). */
+    selection: ISelection;
+    /** The ring color (the fill is the surface/"window" color). @defaultValue the theme primary. */
+    color?: string;
+    /** Handle diameter (px). Touch-sized. @defaultValue 22 */
+    size?: number;
+}
+/**
+ * Touch selection handles: round grips at the active range's corners (or edges, for a whole row/column)
+ * that drag to **extend the selection** via {@link ISelection.modify}, reusing the exact range math the
+ * mouse path uses. See {@link computeGrips} for the per-selection grip layout.
+ *
+ * @remarks
+ * Each grip is a {@link StickyAnchor} rendered through a **portal** (via the fullscreen-aware root) so it
+ * escapes the pane clip. StickyAnchor's owner/clip gating means exactly ONE pane renders each grip, and
+ * anchoring to a cell makes the grip vanish the moment that cell scrolls off — no slide-to-edge.
+ *
+ * The drag runs on **window** pointer listeners owned by this (always-mounted) component — not
+ * pointer-capture on the grip element — so the gesture survives the grip hiding mid-drag (the grips fade
+ * to `opacity: 0` while dragging so the finger isn't dragging a dot it can't see past).
+ */
+export declare const SelectionTouchGrips: React.FC<SelectionTouchGripsProps>;
+//# sourceMappingURL=SelectionTouchGrips.d.ts.map

package/types/src/selection/SelectionUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const SELECTION_CLIP_INSETS = -10;
+//# sourceMappingURL=SelectionUtils.d.ts.map

package/types/src/selection/Types.d.ts

@@ -0,0 +1,67 @@
+import { CellCoords, RangeCoords } from '@sheetxl/utils';
+import { IKeyStroke } from '@sheetxl/utils-react';
+import { IGridPane } from '../surface';
+import { ISelection } from './ISelection';
+/**
+ * One navigation binding: its **default** keystroke(s) + the method to run. The single source for a
+ * selection navigation capability — keystroke handling (the layer's `onKeyDown`), the imperative
+ * handle (`invoke`), and the command catalog (which derives its shortcut + adds chrome) all read it.
+ */
+export interface NavBinding {
+    /**
+     * The default keystroke(s). The command catalog seeds its (re-mappable) shortcut from this. Omitted
+     * for a command-only binding (invokable by name, no default chord) — every chord maps to exactly ONE
+     * binding, so a method whose natural chord is already taken ships without one.
+     */
+    shortcut?: IKeyStroke | IKeyStroke[];
+    /** The behavior — a composition of {@link ISelection} (model) + {@link IGridPane} (view). */
+    run: () => void;
+}
+/**
+ * The selection navigation capability owned by `SelectionLayer`.
+ */
+export interface SelectionNavigation {
+    /** Run a binding by name (the command front-end). Returns `false` if the name is unknown. */
+    invoke(name: string): boolean;
+    /** Match a keyboard event to a binding and run it (the layer's keyboard front-end). */
+    handleKey(event: React.KeyboardEvent): boolean;
+    /** Whether a binding name exists. */
+    supports(name: string): boolean;
+    /** The full binding map — `name → { shortcut, run }` (the command catalog seeds shortcuts from it). */
+    getBindings(): ReadonlyMap<string, NavBinding>;
+}
+/**
+ * Options for {@link createSelectionNavigation} — the live getters a navigation capability is built
+ * over. `getSelection` / `getPane` are read on *every* action so the capability stays valid across
+ * re-renders and scroll (never captured once). The bounds getters inject sheet-tier knowledge; the
+ * dumb {@link DefaultSelection} tier omits them and everything falls back to the grid edge.
+ */
+export interface SelectionNavigationOptions {
+    /** The writable selection model, read live. */
+    getSelection: () => ISelection;
+    /** The grid view (metrics + scroll), read live so bindings stay correct across scroll. */
+    getPane: () => IGridPane;
+    /**
+     * The content (used-range) bounds the `…End` keys (End / Ctrl+End) jump to. A **sheet-global**
+     * property — the used range — so it is deliberately **cell-independent**: Ctrl+End lands on the same
+     * used-range corner wherever the cursor sits. (Contrast {@link getRegionBounds}, a *positional*
+     * query — that difference is why one takes a `cell` and this one does not; it is not an oversight.)
+     * Omit it (the dumb tier, which has no sheet ⇒ no used range) ⇒ the grid edge.
+     */
+    getContentBounds?: () => RangeCoords;
+    /**
+     * The scroll executor for keyboard selection. Supply it from a tier that OWNS scrolling (the sheet
+     * layer → `sheet.scrollTo`) so UI and scripting scroll through one path; the model then owns the
+     * arrow-`navigate` scroll and the two don't compete. Omit it and the layer scrolls its own pane.
+     */
+    getScrollIntoView?: () => ((cell: Partial<CellCoords>) => void) | undefined;
+    /**
+     * The bounding REGION enclosing a cell — a table's data range, or `null` on the bare sheet. A
+     * **positional** query (hence the `cell`, unlike the sheet-global {@link getContentBounds}): drives
+     * Tab/Enter wrapping inside a table and the row/column span of Ctrl/Shift+Space. Omit it (the dumb
+     * tier) ⇒ no enclosing region (Tab moves, Ctrl/Shift+Space select the whole grid). Any escalation
+     * (data → table → sheet) is the provider's job, not the consumer's.
+     */
+    getRegionBounds?: (cell: CellCoords) => RangeCoords | null;
+}
+//# sourceMappingURL=Types.d.ts.map

package/types/src/selection/_SelectionNavigation.d.ts

@@ -0,0 +1,6 @@
+import { SelectionNavigation, SelectionNavigationOptions } from './Types';
+/**
+ * Build the navigation capability over the live getters in {@link SelectionNavigationOptions}.
+ */
+export declare function createSelectionNavigation(options: SelectionNavigationOptions): SelectionNavigation;
+//# sourceMappingURL=_SelectionNavigation.d.ts.map

package/types/src/selection/_SelectionUtils.d.ts

@@ -0,0 +1,7 @@
+import { SelectionRangeStyle } from './SelectionStyle';
+/**
+ * Merge a {@link SelectionRangeStyle} override over a base, slot-by-slot (each rectangle merges
+ * independently).
+ */
+export declare const mergeSelectionStyle: (base: SelectionRangeStyle, over?: SelectionRangeStyle) => SelectionRangeStyle;
+//# sourceMappingURL=_SelectionUtils.d.ts.map

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

@@ -0,0 +1,12 @@
+export * from './Types';
+export * from './SelectionUtils';
+export * from './ICellAnchor';
+export * from './ISelection';
+export * from './DefaultSelection';
+export * from './SelectionStyle';
+export * from './useDragCells';
+export * from './useSelectionPointer';
+export * from './SelectionTouchGrips';
+export * from './SelectionLayer';
+export * from './RangesPickerLayer';
+//# sourceMappingURL=index.d.ts.map