@sheetxl/grid-react 0.7.22 → 0.7.23-beta.1

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/SelectionLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionLayer.d.ts","sourceRoot":"","sources":["../../../../src/selection/SelectionLayer.tsx"],"names":[],"mappings":"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"}

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/SelectionStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionStyle.d.ts","sourceRoot":"","sources":["../../../../src/selection/SelectionStyle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,QAAQ,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,oFAAoF;IACpF,IAAI,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IAC7B,wBAAwB;IACxB,MAAM,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IAC/B,sFAAsF;IACtF,KAAK,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;CAC/B;AAqBD,iGAAiG;AACjG,eAAO,MAAM,oBAAoB,EAAE,mBAIlC,CAAC;AAEF,kFAAkF;AAClF,eAAO,MAAM,mBAAmB,EAAE,mBAIjC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAIlC,CAAC;AAEF,uGAAuG;AACvG,eAAO,MAAM,4BAA4B,EAAE,mBAG1C,CAAC"}

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/SelectionTouchGrips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionTouchGrips.d.ts","sourceRoot":"","sources":["../../../../src/selection/SelectionTouchGrips.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAY/B,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAK/C;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,sFAAsF;IACtF,SAAS,EAAE,UAAU,CAAC;IACtB,gGAAgG;IAChG,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AA+DD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CAiElE,CAAC"}

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/SelectionUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectionUtils.d.ts","sourceRoot":"","sources":["../../../../src/selection/SelectionUtils.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,MAAM,CAAC"}

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/Types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Types.d.ts","sourceRoot":"","sources":["../../../../src/selection/Types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEnE,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,UAAU,GAAG,UAAU,EAAE,CAAC;IACrC,6FAA6F;IAC7F,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,6FAA6F;IAC7F,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9B,uFAAuF;IACvF,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,GAAG,OAAO,CAAC;IAC/C,qCAAqC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,uGAAuG;IACvG,WAAW,IAAI,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAChD;AAED;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,+CAA+C;IAC/C,YAAY,EAAE,MAAM,UAAU,CAAC;IAC/B,0FAA0F;IAC1F,OAAO,EAAE,MAAM,SAAS,CAAC;IACzB;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,MAAM,WAAW,CAAC;IACrC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAC5E;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,WAAW,GAAG,IAAI,CAAC;CAC5D"}

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/_SelectionNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_SelectionNavigation.d.ts","sourceRoot":"","sources":["../../../../src/selection/_SelectionNavigation.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,0BAA0B,EAAmB,MAAM,SAAS,CAAC;AAerG;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,0BAA0B,GAAG,mBAAmB,CAgQlG"}

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/_SelectionUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_SelectionUtils.d.ts","sourceRoot":"","sources":["../../../../src/selection/_SelectionUtils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAe3D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC9B,MAAM,mBAAmB,EACzB,OAAO,mBAAmB,KACzB,mBAOF,CAAC"}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/selection/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AAExB,cAAc,kBAAkB,CAAC;AAEjC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC"}

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

@@ -0,0 +1,218 @@
+import { CellCoords } from '@sheetxl/utils';
+import { IGridPane } from '../surface';
+/**
+ * Repeat interval (ms) for the held-still auto-scroll. While a drag is parked past the viewport edge no
+ * pointer-move events fire, so the engine re-applies the drag at the last pointer position on this
+ * cadence; each tick scrolls one cell, which shifts the cell under the (fixed) point, continuing the drag.
+ */
+export declare const AUTO_SCROLL_INTERVAL_MS = 60;
+/**
+ * How close (client px) the pointer must get to a pane edge — on the INSIDE of the viewport, or past it —
+ * to engage the auto-scroll. Edge detection is by pointer POSITION, not by the resolved cell, because a
+ * TOUCH drag can never resolve a cell past the last visible one: a finger is pinned to the physical grid
+ * edge and can't roam into the empty space beyond the content the way a mouse cursor can. This band is
+ * sized so a fingertip at the edge falls inside it.
+ */
+export declare const EDGE_AUTO_SCROLL_MARGIN_PX = 24;
+/**
+ * The default {@link DragCellsSession.edgeScroll} for a body / picker drag: step the pane's viewport ONE
+ * cell toward whichever edge(s) the pointer sits within {@link EDGE_AUTO_SCROLL_MARGIN_PX} of (or past),
+ * on both axes. Returns whether an edge is still scrollable — so the held-still auto-scroll keeps ticking.
+ *
+ * @remarks
+ * Position/direction-based rather than "scroll the dragged cell into view": the latter only advances when
+ * the resolved cell is off-screen (reachable by a mouse roaming past the content, never by a finger). A
+ * fixed one-cell step per tick advances the viewport regardless, and the engine then extends to the cell
+ * newly revealed under the pointer. The step routes through the CENTER pane (a frozen pane can't move its
+ * frozen axis).
+ *
+ * @param axes restricts which axes may scroll — a whole-row/column touch grip extends only one axis, so
+ *   it passes e.g. `{ x: true, y: false }`. Omitted axes default to enabled (both).
+ */
+export declare const edgeScrollPane: (pane: IGridPane, point: {
+    x: number;
+    y: number;
+}, axes?: {
+    x?: boolean;
+    y?: boolean;
+}) => boolean;
+/**
+ * The in-flight gesture returned by {@link DragCellsOptions.onStart}. It carries the *policy* — how a
+ * given cell-drag mutates the model — while the engine owns the *mechanics* (pointer capture, `lastCell`
+ * de-dup, the held-still auto-scroll timer, and the public `dragMode` signal).
+ *
+ * @remarks
+ * `onStart` has already SEEDED the model for the down cell (and taken ownership of the down event —
+ * `stopPropagation` / `preventDefault` per its own policy); the session's callbacks then drive the drag:
+ * `drag` on each new cell, `edgeScroll` for the held-still edge auto-scroll, `end` on release, `cancel`
+ * on an OS-cancelled abort.
+ */
+export interface DragCellsSession {
+    /**
+     * Apply the in-flight update for a newly-entered `cell` — called once per DISTINCT cell during the
+     * drag (the engine de-dups moves within the same cell). Not called for the down cell (already seeded).
+     * `e` is the triggering pointer event when the move came from a real pointer (read live modifiers off
+     * it — e.g. a move-drag's Ctrl=copy / Shift=insert); it is ABSENT on a held-still auto-scroll tick
+     * (no pointer event fires while the pointer is parked past the edge), so treat it as optional.
+     */
+    drag: (cell: CellCoords, e?: React.PointerEvent) => void;
+    /**
+     * The auto-scroll step: given the pointer's client `point`, scroll the viewport ONE cell toward any edge
+     * the pointer is at (see {@link edgeScrollPane}), and return whether an edge is still engaged so the
+     * held-still timer keeps ticking. Called every tick (not gated on a distinct cell) — the drag EXTEND is
+     * separate (the engine's per-cell `drag`), so the two concerns don't fight: this steps the viewport, and
+     * the engine then extends to the cell newly under the pointer.
+     *
+     * Position/direction-based on purpose — a cell-based "is the dragged cell off-screen?" test can't fire
+     * on TOUCH (a finger can't leave the content). The header supplies a single-axis, sheet-routed version
+     * (its controlled viewport can't scroll itself); a body / picker drag uses the default.
+     * @defaultValue {@link edgeScrollPane} of the engine's pane (both axes).
+     */
+    edgeScroll?: (point: {
+        x: number;
+        y: number;
+    }) => boolean;
+    /** Finalize on pointer-up (e.g. a remove-drag's `deselect`, an `onSelectionEnd`, a refocus). */
+    end?: (e: React.PointerEvent) => void;
+    /**
+     * Abort cleanup for a CANCELLED gesture — the OS/browser seized the pointer (`pointercancel`: a touch
+     * became a system pan/zoom, a pen left range, a window blurred), OR the user pressed **Escape**
+     * (Windows-style drag abort). The engine always runs the mechanical teardown (stop the auto-scroll
+     * timer, disarm the touch swallow, release capture); this hook is for the policy's own rollback —
+     * restore the pre-drag selection, clear a rubber-band / preview — WITHOUT committing, since a cancel is
+     * an abort, not a release. {@link DragCellsSession.end} never runs on a cancel. The event is absent on
+     * an Escape abort (no pointer event drives it).
+     */
+    cancel?: (e?: React.PointerEvent) => void;
+    /**
+     * Take pointer capture and track the drag. `false` = a click-only gesture (e.g. a header right-click
+     * that positions the selection for the context menu): no capture, moves are ignored, but {@link end}
+     * still runs on the next pointer-up. @defaultValue true
+     */
+    capture?: boolean;
+    /**
+     * `stopPropagation` the move / up events while this drag is in flight, so a layer below never also acts
+     * on them. The down event is owned by `onStart` itself. @defaultValue true
+     */
+    captureEvents?: boolean;
+    /**
+     * A public label for the gesture, surfaced as {@link DragCellsResult.dragMode} between down and up (a
+     * layer shows a transient tip — e.g. live R×C — off it). Flips only on start / end, not per move.
+     */
+    dragMode?: string;
+}
+/**
+ * Options for {@link useDragCells} / {@link createDragCells}.
+ */
+export interface DragCellsOptions {
+    /**
+     * Begin a gesture at the `cell` under the pointer. SEED the model, take ownership of the down event
+     * (`stopPropagation` / `preventDefault` as the policy needs), and return a {@link DragCellsSession} to
+     * drive the drag — or `null` to not start one (a non-primary button, an intercepted right-click, …).
+     * The engine captures the pointer only for a returned session (unless {@link DragCellsSession.capture}
+     * is `false`).
+     */
+    onStart: (cell: CellCoords, e: React.PointerEvent) => DragCellsSession | null;
+}
+/** The spreadable handlers + the public `dragMode`, produced by {@link useDragCells}. */
+export interface DragCellsResult {
+    onPointerDown: (e: React.PointerEvent) => void;
+    onPointerMove: (e: React.PointerEvent) => void;
+    onPointerUp: (e: React.PointerEvent) => void;
+    /**
+     * Abort the in-flight drag. Wire it onto the tap only if the host routes `pointercancel` — the engine
+     * ALSO listens natively on the captured element (a `pointercancel` fires there whether or not the host
+     * dispatches it), so this is a safe idempotent extra, not a requirement.
+     */
+    onPointerCancel: (e: React.PointerEvent) => void;
+    /**
+     * What the in-flight drag is doing — the active session's {@link DragCellsSession.dragMode}, or `null`
+     * between drags. Flips only on down / up so a layer can show a transient tip without re-rendering on
+     * every pointer move.
+     */
+    dragMode: string | null;
+}
+/** The headless controller behind {@link useDragCells}. */
+export interface DragCellsController {
+    onPointerDown: (e: React.PointerEvent) => void;
+    onPointerMove: (e: React.PointerEvent) => void;
+    onPointerUp: (e: React.PointerEvent) => void;
+    /** Abort the in-flight drag (see {@link DragCellsResult.onPointerCancel}). */
+    onPointerCancel: (e: React.PointerEvent) => void;
+    /** Stop the auto-scroll timer + disarm touch. Call on unmount (the hook wires this). */
+    dispose: () => void;
+}
+/**
+ * The **shared cell-drag engine** — the axis-agnostic mechanics every pointer selection needs: pointer
+ * capture, per-cell de-dup, the held-still auto-scroll timer, and the public `dragMode` signal. It holds
+ * NO range math: an {@link DragCellsOptions.onStart} adapter supplies the policy as a
+ * {@link DragCellsSession}. Used by the body selection, the header selection, and the range picker's draw
+ * — each a thin adapter over this one engine (so all three get identical auto-scroll for free).
+ *
+ * @remarks
+ * This is the **tap driver**: the consumer spreads `onPointerDown` / `onPointerMove` / `onPointerUp`
+ * (and, if the host routes it, `onPointerCancel`) onto a Stage tap; the engine captures the pointer on
+ * that tap's element so move / up keep firing when the drag leaves the viewport. The handle / grip
+ * flavors, whose element repositions or unmounts mid-drag, use {@link createWindowDragCells} instead —
+ * same session, `window`-tracked.
+ *
+ * A plain (non-hook) factory so a headless controller (e.g. the header's `createHeaderSelectionPointer`,
+ * unit-tested with a fake pane) can build on it directly. The React hook is {@link useDragCells}.
+ * `onStart` is captured at creation; a caller that needs live values reads them through a ref inside its
+ * `onStart` closure (as the hook does).
+ *
+ * @param onDragModeChange Notified when the active session's `dragMode` changes (a hook turns this into
+ *   React state); omit for a headless controller that doesn't surface it.
+ */
+export declare const createDragCells: (pane: IGridPane, onStart: (cell: CellCoords, e: React.PointerEvent) => DragCellsSession | null, onDragModeChange?: (mode: string | null) => void) => DragCellsController;
+/** The headless controller behind {@link useWindowDragCells}. */
+export interface WindowDragCellsController {
+    /**
+     * Begin a `window`-driven gesture from a pointer-down on the source element. `cursorEl` is captured
+     * (pointer-capture) purely so the browser paints ITS cursor for the whole drag — the gesture tracks on
+     * `window` regardless, surviving the element repositioning / unmounting. Defaults to `e.currentTarget`.
+     */
+    start: (e: React.PointerEvent, cursorEl?: Element | null) => void;
+    /** Stop any in-flight gesture (drop the `window` listeners + timer + touch swallow). Call on unmount. */
+    dispose: () => void;
+}
+/**
+ * The **window-driven** cell-drag engine — same {@link DragCellsSession} policy and shared mechanics as
+ * {@link createDragCells}, but the gesture tracks on `window` listeners instead of a Stage tap's element
+ * capture. Use it when the element that starts the drag repositions or unmounts mid-gesture: a fill /
+ * resize handle culled under an edge auto-scroll, a move grip whose source range scrolls off in ghost
+ * mode. Element capture on such an element would silently drop the drag; `window` tracking is immune.
+ *
+ * @remarks
+ * The source element is still pointer-captured (for its CURSOR only — see {@link WindowDragCellsController.start});
+ * the actual move / up / cancel are `window` listeners, so a re-render or unmount of the handle never
+ * interrupts the gesture. Consumers supply `onStart` policy exactly as for the tap engine, and get the
+ * same held-still auto-scroll, touch arming, per-cell de-dup, and abort-on-cancel.
+ */
+export declare function createWindowDragCells(pane: IGridPane, onStart: (cell: CellCoords, e: React.PointerEvent) => DragCellsSession | null, onDragModeChange?: (mode: string | null) => void, 
+/** Override cell resolution (a touch grip resolves against the pane the finger is over). */
+resolveCell?: (clientX: number, clientY: number) => CellCoords | null): WindowDragCellsController;
+/**
+ * The React hook over {@link createDragCells}: reads the pane from context, owns the `dragMode` state,
+ * and stops the auto-scroll timer on unmount. `onStart` is read live through a ref, so a consumer's
+ * closure over changing values (selection, options) needs no handler rebuild.
+ */
+export declare const useDragCells: (onStart: (cell: CellCoords, e: React.PointerEvent) => DragCellsSession | null) => DragCellsResult;
+/** Handlers + transient `dragMode` produced by {@link useWindowDragCells}. */
+export interface WindowDragCellsResult {
+    /**
+     * Begin a window-driven gesture. Spread as the source element's `onPointerDown`. Pass a `cursorEl` (the
+     * element whose cursor should paint for the drag) when the pointer-down may be dispatched with a
+     * `currentTarget` other than that element (e.g. a grip below an interactive child).
+     */
+    start: (e: React.PointerEvent, cursorEl?: Element | null) => void;
+    /** The active session's `dragMode`, or `null` between drags (flips only on start / end). */
+    dragMode: string | null;
+}
+/**
+ * The React hook over {@link createWindowDragCells}: reads the pane from context, owns the `dragMode`
+ * state, and disposes the gesture on unmount. For handle / grip flavors (fill, resize, move, touch grips)
+ * whose element repositions or unmounts mid-drag. `onStart` is read live through a ref.
+ */
+export declare const useWindowDragCells: (onStart: (cell: CellCoords, e: React.PointerEvent) => DragCellsSession | null) => WindowDragCellsResult;
+//# sourceMappingURL=useDragCells.d.ts.map

package/types/src/selection/useDragCells.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDragCells.d.ts","sourceRoot":"","sources":["../../../../src/selection/useDragCells.ts"],"names":[],"mappings":"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"}