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

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

@@ -0,0 +1,147 @@
+import { RemoveListener } from '@sheetxl/utils';
+import { IGridPane } from '../surface';
+/**
+ * A handler in the dispatch walk. Receives the React synthetic event and the owning pane.
+ * Call `event.stopPropagation()` to consume the event — lower layers and the pane/app then do
+ * not see it (the one-bubble law's single consume signal).
+ */
+export type StageEventHandler = (event: React.SyntheticEvent, pane: IGridPane) => void;
+/**
+ * A {@link Layer} tap's registration with the Stage.
+ *
+ * @remarks
+ * The Stage is the convergence hub: every Layer registers one tap and the Stage offers each event
+ * down the walk in slot order (higher first), then registration (render) order, stopping when one
+ * consumes.
+ */
+export interface StageResponder {
+    /**
+     * The layer's dispatch **slot** — its derived order index in the grid's normalized layer list
+     * (see `LayerOrderContext`). Higher is offered the event first; ties break by registration
+     * (render) order REVERSED, so the later-declared layer (which paints on top) is offered first.
+     */
+    zIndex?: number;
+    /**
+     * Live accessor for the layer's boundary div. The dispatch resolves an event's **layer
+     * membership** by ancestry against these elements (which layer does the target belong to?) — the
+     * point of the Layer being a real div. Optional for element-less responders (the pane command
+     * terminal, `addReactEventListener` shims), which have no membership to resolve.
+     */
+    getElement?: () => Element | null;
+    /**
+     * Returns the current handler for a native event type (`'pointerdown'`, `'keydown'`,
+     * …), or `undefined`. Called per-dispatch, so it always sees the latest closures — a
+     * responder is registered once (not per render) and handler identity may change freely.
+     */
+    getHandler: (type: string) => StageEventHandler | undefined;
+}
+/**
+ * A geometried box's registration with the Stage (a {@link VirtualDiv}). Unlike a
+ * {@link StageResponder} (a Layer's zero-geometry tap), a box owns a real DOM element, so the
+ * DOM-driven dispatch can map a hit element to its box, resolve the boxes under the pointer, and
+ * skip the native target (whose handlers already fired in the "up your subtree" phase).
+ *
+ * @remarks
+ * Kept in a SEPARATE registry from the tap chain on purpose: there can be very many boxes
+ * (e.g. one fill per cell), and the tap chain is sorted on every event — boxes must not
+ * inflate that hot path. The dispatch resolves boxes geometrically (the DOM already stacks them),
+ * not by iterating this set per event.
+ */
+export interface LayerRegistration {
+    /**
+     * The box's enclosing Layer's dispatch **slot** (from `LayerOrderContext`). Interleaves the box
+     * with the Layer taps in the single walk: a box fires between the taps of the layers above and
+     * below its own.
+     */
+    zIndex?: number;
+    /** Live accessor for the box's DOM element (null while culled / unmounted). */
+    getElement: () => Element | null;
+    /**
+     * Per-type handler accessor (as {@link StageResponder.getHandler}). The DOM-driven dispatch uses
+     * it to invoke a box that is BELOW the native target (so it did not receive the event natively;
+     * the hit box fires its own handlers natively — the up phase). Boxes with no handlers omit it.
+     */
+    getHandler?: (type: string) => StageEventHandler | undefined;
+    /**
+     * Whether this box currently has any event handlers. Drives the dispatch fast-path: when NO
+     * registered box has handlers (the entire normal grid — fills / borders / selection visuals),
+     * the geometried pass is skipped entirely, so it adds zero per-event cost.
+     */
+    hasHandlers?: boolean;
+}
+/**
+ * The event types a {@link VirtualDiv}'s registered handlers are invoked for on **other layers'
+ * turns** (a box below the hit layer, under the pointer). These are the positional, bubbling
+ * events. A box's handlers are ordinary native props — they fire natively when the box is on the
+ * event's target chain (its own layer's turn, phase 2); this registry map covers the pass-through
+ * case (phase 3). Relational (`enter`/`leave`), focus, and key events are targeted — the DOM's own
+ * delivery is already correct, so boxes never receive them positionally (Layer taps do, via the
+ * ordered walk).
+ */
+export declare const WALKED_EVENT_TYPE_TO_PROP: Record<string, string>;
+/** The walk-dispatched box prop names (values of {@link WALKED_EVENT_TYPE_TO_PROP}). */
+export declare const WALKED_EVENT_PROPS: string[];
+/**
+ * The event types the **three-phase dispatch** fully orders (law 3: layers on top hear events
+ * first — keys and pointers alike): the positional walked types PLUS keys. For these:
+ * - **phase 1** — a native CAPTURE listener on the Stage offers the event to the taps of every
+ *   layer ABOVE the hit layer (top first), before the native dispatch runs;
+ * - **phase 2** — the native dispatch runs the hit layer's own subtree, exactly as React does
+ *   (inner content, then any boxes on the chain, then the layer's own boundary handlers);
+ * - **phase 3** — the Stage's bubble handlers continue the walk strictly BELOW the hit layer
+ *   (under-pointer boxes + taps, in slot order).
+ * `stopPropagation()` anywhere ends the whole bubble. Everything else (enter/leave/focus/blur) is
+ * stage-relational: a single unbounded tap walk.
+ */
+export declare const ORDERED_EVENT_TYPES: readonly string[];
+export interface IStageAttributes {
+    /**
+     * Add a listener for a single event type to the stage. Primarily grid-internal plumbing —
+     * external callers use {@link IGridPane.addReactEventListener} (which delegates here); layers
+     * use {@link Layer} taps instead.
+     */
+    addReactEventListener(type: string, listener: (event: React.SyntheticEvent) => void, listenerPane?: (event: React.SyntheticEvent, pane: IGridPane) => void): RemoveListener;
+    isStage(): true;
+}
+export interface IStageElement extends HTMLDivElement, IStageAttributes {
+}
+/**
+ * @internal
+ * The responder registry the Stage implementation also provides. Deliberately kept off the public
+ * {@link IStageElement} — Layers join the dispatch walk via their tap, which reaches
+ * this through {@link IStageElementInternal}.
+ */
+export interface IStageResponderHost {
+    /** Register a (non-visual, broadcast) responder in the responder chain. Returns a remover. */
+    registerResponder(responder: StageResponder): RemoveListener;
+    /**
+     * Register a geometried layer (a {@link Layer}). Returns a remover. Stored
+     * apart from the responder chain (see {@link LayerRegistration}); consumed by the DOM-driven
+     * dispatch, not by the per-event responder fan-out.
+     */
+    registerLayer(layer: LayerRegistration): RemoveListener;
+}
+/** @internal Stage element augmented with the responder registry (used by `Layer` / `useLayerResponder`). */
+export interface IStageElementInternal extends IStageElement, IStageResponderHost {
+}
+/**
+ * @internal
+ * Resolve a pane's Stage element WITH the responder registry (grid-internal; the registry is
+ * deliberately off the public pane API — external callers get {@link IGridPane.addReactEventListener}).
+ * The pane's surface element IS its Stage, brand-checked via `isStage` so a non-stage host (e.g. a
+ * static-border stub pane) resolves to `null` and the caller skips registration.
+ */
+export declare const getStageInternal: (pane: IGridPane | null | undefined) => IStageElementInternal | null;
+export interface StageProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Ref for the HTMLDivElement
+     */
+    ref?: React.Ref<IStageElement>;
+}
+/**
+ * Stage
+ *
+ * Internally used to distinguish the main grid area.
+ */
+export declare const Stage: import('react').NamedExoticComponent<Omit<StageProps, "ref"> & import('react').RefAttributes<IStageElement>>;
+//# sourceMappingURL=Stage.d.ts.map

package/types/src/layer/Stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stage.d.ts","sourceRoot":"","sources":["../../../../src/layer/Stage.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGrD,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAIzD;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;AAEvF;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,OAAO,GAAG,IAAI,CAAC;IAClC;;;;OAIG;IACH,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,CAAC;CAC7D;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,UAAU,EAAE,MAAM,OAAO,GAAG,IAAI,CAAC;IACjC;;;;OAIG;IACH,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,CAAC;IAC7D;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAK5D,CAAC;AAEF,wFAAwF;AACxF,eAAO,MAAM,kBAAkB,EAAE,MAAM,EAA6C,CAAC;AAErF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAEhD,CAAC;AAGF,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,qBAAqB,CACnB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,KAAK,IAAI,EAC/C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,GACpE,cAAc,CAAC;IAElB,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,aAAc,SAAQ,cAAc,EAAE,gBAAgB;CAAG;AAE1E;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,8FAA8F;IAC9F,iBAAiB,CAAC,SAAS,EAAE,cAAc,GAAG,cAAc,CAAC;IAC7D;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,iBAAiB,GAAG,cAAc,CAAC;CACzD;AAED,6GAA6G;AAC7G,MAAM,WAAW,qBAAsB,SAAQ,aAAa,EAAE,mBAAmB;CAAG;AAEpF;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,SAAS,GAAG,IAAI,GAAG,SAAS,KAAG,qBAAqB,GAAG,IAG7F,CAAC;AAEF,MAAM,WAAW,UAAW,SAAQ,KAAK,CAAC,cAAc,CAAC,cAAc,CAAC;IACtE;;OAEG;IACH,GAAG,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;CAChC;AAED;;;;GAIG;AACH,eAAO,MAAM,KAAK,8GA4Yf,CAAC"}

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

@@ -0,0 +1,83 @@
+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';
+/**
+ * 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:
+ *
+ * - a **render-prop** child self-positions — e.g. a portal that escapes the clip and flows past the
+ *   pane bounds (this is what {@link StickyFloat} does for you);
+ * - a plain **node** ("just a div") is positioned INLINE by StickyAnchor, clipping with the pane.
+ *
+ * `StickyAnchor` itself is portal-agnostic; it only resolves the anchor and positions inline divs.
+ */
+export interface StickyState {
+    /** Client-space Floating UI virtual reference (stable identity; reads live). */
+    reference: {
+        getBoundingClientRect: () => DOMRect;
+    };
+    /** Client-space boundary rect (for `flip`/`shift`/`hide` limiters). */
+    getBoundaryRect: () => DOMRect;
+    /** The placement's anchor pixel (client px). */
+    anchorPoint: Point;
+    /** Pane-relative range bounds (for an in-grid child) — only meaningful on the owner pane, else null. */
+    bounds: Bounds | null;
+    /** The pane that owns the anchor pixel (null when clipped off every pane). */
+    owner: AnchorLocation | null;
+    /** Whether THIS instance's pane is the owner — the child self-gates on it (render once / correct pane). */
+    isOwner: boolean;
+    /** Anchor outside the boundary. */
+    clipped: boolean;
+    /** The clamp slide (distance/direction) when `whenOff: 'clamp'` pushed it in-frame, else null. */
+    slid: GridSlide | null;
+    /**
+     * The anchored range is **fully scrolled off** (no visible portion) — stays true under `whenOff:
+     * 'clamp'` (unlike {@link clipped}), so a presence can distinguish "partially obstructed / clamped"
+     * (keep showing) from "off-screen" (show a goto affordance).
+     */
+    outOfView: boolean;
+    /** The resolved placement. */
+    placement: GridPlacement;
+    /** This instance's pane (null outside a `GridPaneProvider`). */
+    pane: IGridPane | null;
+    /**
+     * Scroll the anchor's top-left cell into view — the grid-level "reveal" for a render-prop child (e.g.
+     * a clamped Presence label whose click should bring its range back on-screen). No-op for anchors
+     * without a cell (`bounds` / `edge` / `point`) or outside a pane. This is reveal only; selection lives
+     * a layer up (`sheet.getRange(addr).select()`).
+     */
+    scrollIntoView: (options?: globalThis.ScrollIntoViewOptions | boolean) => Promise<unknown>;
+}
+/** Read the enclosing {@link StickyAnchor}'s state. Throws outside one. */
+export declare const useSticky: () => StickyState;
+/** Read the enclosing {@link StickyAnchor}'s state, or null outside one. */
+export declare const useStickyOptional: () => StickyState | null;
+/**
+ * Props for {@link StickyAnchor}.
+ */
+export interface StickyAnchorProps {
+    /** WHERE to anchor — a grid coordinate (range / cell / bounds / edge / point). */
+    anchor: GridAnchor;
+    /** Which side + align of the anchor the float attaches to (picks the single anchor pixel). */
+    placement?: GridPlacement;
+    /** Clip / clamp boundary (client-space math input, not a DOM parent). @defaultValue 'data' */
+    boundary?: GridBoundary;
+    /** What happens when the anchor pixel leaves the data area. @defaultValue 'hide' */
+    whenOff?: GridWhenOff;
+    /** Px overlap below which a geometried anchor reads as clipped. @defaultValue 0 */
+    minVisible?: number;
+    /** The child — a node, or a render function `(state) => node`. Reads state via {@link useSticky} too. */
+    children?: React.ReactNode | ((state: StickyState) => React.ReactNode);
+}
+/**
+ * A **sticky** grid layer: it resolves an {@link GridAnchor} (via {@link useGridAnchor}) to a live
+ * anchor point and positions its child there. A plain `<div>` child is placed **inline** (clips with
+ * the pane); a **render-prop** child self-positions (e.g. a portal — see {@link StickyFloat}). It owns
+ * no portal and knows nothing about Floating UI.
+ *
+ * Rendered per pane like any layer; each instance publishes its own `isOwner`, so only the owner pane
+ * renders the child (once).
+ */
+export declare const StickyAnchor: React.FC<StickyAnchorProps>;
+//# sourceMappingURL=StickyAnchor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StickyAnchor.d.ts","sourceRoot":"","sources":["../../../../src/layer/StickyAnchor.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmF,MAAM,OAAO,CAAC;AAExG,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,KAAK,EAAmB,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAE1F,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,EAEL,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EAAE,KAAK,SAAS,EACzF,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;GASG;AACH,MAAM,WAAW,WAAW;IAC1B,gFAAgF;IAChF,SAAS,EAAE;QAAE,qBAAqB,EAAE,MAAM,OAAO,CAAA;KAAE,CAAC;IACpD,uEAAuE;IACvE,eAAe,EAAE,MAAM,OAAO,CAAC;IAC/B,gDAAgD;IAChD,WAAW,EAAE,KAAK,CAAC;IACnB,wGAAwG;IACxG,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,8EAA8E;IAC9E,KAAK,EAAE,cAAc,GAAG,IAAI,CAAC;IAC7B,2GAA2G;IAC3G,OAAO,EAAE,OAAO,CAAC;IACjB,mCAAmC;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,kGAAkG;IAClG,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IACvB;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB,8BAA8B;IAC9B,SAAS,EAAE,aAAa,CAAC;IACzB,gEAAgE;IAChE,IAAI,EAAE,SAAS,GAAG,IAAI,CAAC;IACvB;;;;;OAKG;IACH,cAAc,EAAE,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,qBAAqB,GAAG,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC5F;AAID,2EAA2E;AAC3E,eAAO,MAAM,SAAS,QAAO,WAI5B,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,iBAAiB,QAAO,WAAW,GAAG,IAAiC,CAAC;AAErF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,kFAAkF;IAClF,MAAM,EAAE,UAAU,CAAC;IACnB,8FAA8F;IAC9F,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,oFAAoF;IACpF,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,mFAAmF;IACnF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yGAAyG;IACzG,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,KAAK,EAAE,WAAW,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC;CACxE;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAqGpD,CAAC"}

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

@@ -0,0 +1,65 @@
+import { default as React } from 'react';
+import { ThemeAttrs } from '@sheetxl/utils-react';
+import { IGridPane } from '../surface';
+import { StickyState } from './StickyAnchor';
+import { GridAnchor, GridPlacement, GridBoundary, GridWhenOff } from './useGridAnchor';
+/**
+ * Carry a grid float's theme **across the portal boundary**. A grid float portals into the shared,
+ * theme-free fullscreen root, where the grid's `--sxl-color-*` tokens do NOT cascade in (the CSS cascade
+ * doesn't cross a portal — unlike MUI content, which rides React context and so themes for free). Returns
+ * the `className` + `data-sxl-theme-*` attrs to put on the portaled element so the token rules resolve —
+ * the same mechanism `FloatPopper` uses for menus.
+ *
+ * Two parts, because the app themes with `@scope` (per-instance), not just global attribute rules:
+ * - **attrs** — the pane's live `mode` / `surface` (grid surface, and the grid's own mode even if it
+ *   differs from the app). These select WHICH token values apply.
+ * - **className** — the theme **scope class(es)** (the float surface's, plus the nearest token provider's
+ *   `scopeClass` when the instance is isolated). Without a scope class the portaled element is outside
+ *   every `@scope` root, so the `@scope (.cls){ :scope[mode][surface]{…} }` rules never match it and the
+ *   attrs alone resolve nothing. The class makes the portal a `:scope` root so those rules apply.
+ */
+export declare const useGridFloatTheme: (pane: IGridPane | null | undefined) => {
+    className?: string;
+    attrs: ThemeAttrs;
+};
+/**
+ * Props for {@link StickyFloat}.
+ */
+export interface StickyFloatProps {
+    /** WHERE to anchor — a grid coordinate (range / cell / bounds / edge / point). */
+    anchor: GridAnchor;
+    /** Which side + align the float attaches to. @defaultValue `{ side: 't', align: 'center' }` */
+    placement?: GridPlacement;
+    /** What happens when the anchor leaves the data area. @defaultValue 'hide' */
+    whenOff?: GridWhenOff;
+    /** Clip / clamp boundary. @defaultValue 'data' */
+    boundary?: GridBoundary;
+    /** Px overlap below which a geometried anchor reads as clipped. @defaultValue 0 */
+    minVisible?: number;
+    /** Gap (px) between the anchor edge and the float. @defaultValue 4 */
+    offset?: number;
+    /**
+     * Offset (px) along the anchor EDGE — only applies to `start` / `end` alignment (a centered float has
+     * no edge to slide along). Positive insets the float inward from the corner. @defaultValue 0
+     */
+    alignOffset?: number;
+    /** Controlled visibility (e.g. a hover tooltip). @defaultValue true */
+    open?: boolean;
+    /** Portal container. @defaultValue the fullscreen-aware root ({@link useFullscreenPortal}). */
+    container?: Element;
+    className?: string;
+    style?: React.CSSProperties;
+    /** @defaultValue 1250 (a below-modal band; see FLOATING-DESIGN §z-index). */
+    zIndex?: number;
+    /** The float content — a node, or a render function `(state) => node` (e.g. to react to `slid`). */
+    children?: React.ReactNode | ((state: StickyState) => React.ReactNode);
+}
+/**
+ * The ergonomic **floating label**: a {@link StickyAnchor} that renders its child in a **portal**
+ * (escaping the pane clip, so it can flow past the pane bounds — e.g. overhang a freeze line) anchored
+ * at the resolved point. The common case — `<StickyFloat anchor={{ range }}>A1:B4</StickyFloat>` —
+ * with no hand-written `createPortal`. For an in-grid (clipping) label, use `<StickyAnchor>` with a plain
+ * `<div>` child instead.
+ */
+export declare const StickyFloat: React.FC<StickyFloatProps>;
+//# sourceMappingURL=StickyFloat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StickyFloat.d.ts","sourceRoot":"","sources":["../../../../src/layer/StickyFloat.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAO1B,OAAO,EAEgC,KAAK,UAAU,EACrD,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,EAAgB,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EACL,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,KAAK,WAAW,EACzE,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,GAC5B,MAAM,SAAS,GAAG,IAAI,GAAG,SAAS,KACjC;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAiBzC,CAAC;AAwDF;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kFAAkF;IAClF,MAAM,EAAE,UAAU,CAAC;IACnB,+FAA+F;IAC/F,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,8EAA8E;IAC9E,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,mFAAmF;IACnF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,+FAA+F;IAC/F,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,6EAA6E;IAC7E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oGAAoG;IACpG,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,KAAK,EAAE,WAAW,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC;CACxE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAiBlD,CAAC"}

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

@@ -0,0 +1,59 @@
+import { VirtualDivPlacement } from './LayerTypes';
+export interface VirtualDivProps extends React.HTMLAttributes<HTMLDivElement>, VirtualDivPlacement {
+    /**
+     * Skip device-pixel edge alignment. By default the box edges are snapped to the
+     * device grid (so content stays crisp and adjacent boxes sharing an edge resolve to
+     * the same pixel — no seam). Turn off for a raw, unaligned box.
+     *
+     * @defaultValue false
+     */
+    disableAlign?: boolean;
+    /**
+     * Extend the right/bottom edges by 1 device px so the box covers all four of its
+     * gridline pixels (a gridline paints the boundary PIXEL `[B, B+1]`). Adjacent boxes
+     * then overlap by 1px at the shared boundary — intended, like Excel cell fills.
+     *
+     * @defaultValue false
+     */
+    coverGridlines?: boolean;
+    /**
+     * Render an aligned **border** of this many DEVICE px instead of a fill. The edges are placed on
+     * the boundary centerline (`edgeCenter`, leading straddles / trailing grows outward) — the same
+     * rule as gridlines and {@link RectangleSVG} — so the border lines up with the selection rectangle
+     * exactly. The box is `border-box`; set the color via `style.borderColor`.
+     *
+     * @remarks
+     * This is the HTML-`border-box` counterpart of {@link RectangleSVG}'s stroke. Use it for a
+     * **content-hosting** box that needs a matching border (the cell editor: the content auto-insets
+     * inside the border). For a pure outline/fill overlay, prefer {@link RectangleSVG}/`RangeRect`.
+     */
+    alignWidth?: number;
+    /**
+     * Keep the element mounted (positioned off-screen) instead of culling to `null` when off-screen.
+     * For always-mounted content such as the cell editor, whose input must never unmount.
+     *
+     * @defaultValue false
+     */
+    keepMounted?: boolean;
+}
+/**
+ * A **VirtualDiv**: a `<div>` whose bounds are driven by the grid metrics. Place it at a `range`
+ * (cell coordinates), `bounds` (grid-space pixels), or `fill` (the whole view); it resolves the
+ * placement via the current pane, culls when off-screen, and device-aligns its edges — then hosts
+ * any content (CSS background/gradient/pattern for fills, children like images / widgets /
+ * movables, or SVG shape leaves like {@link RectangleSVG}).
+ *
+ * Everything you know about divs applies — pointer events, focus (`tabIndex`), refs, CSS, children —
+ * and means what it always means. It is **hittable by default**, exactly like a real div; a
+ * decoration opts out with `style.pointerEvents:'none'` (never a hit target; a child shape can
+ * re-enable `pointer-events` on its stroke to opt back in). Its handlers are ordinary native props
+ * that fire **at its layer's turn** in the ordered bubble (law 3: layers on top hear events first —
+ * when the hit is inside this box the native dispatch IS its layer's turn; when the box sits in a
+ * lower layer under the pointer, the Stage invokes its positional handlers at that slot). Call
+ * `event.stopPropagation()` to consume — there is no auto-consume and no passthrough flag. Render
+ * it inside a {@link Layer} (which is what gives it — and everything inside it — its layer
+ * membership); with frozen panes each pane instantiates one. For multiple ranges, map it in the
+ * consumer (one per range).
+ */
+export declare const VirtualDiv: import('react').NamedExoticComponent<VirtualDivProps & import('react').RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=VirtualDiv.d.ts.map

package/types/src/layer/VirtualDiv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VirtualDiv.d.ts","sourceRoot":"","sources":["../../../../src/layer/VirtualDiv.tsx"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,cAAc,CAAC;AASxD,MAAM,WAAW,eAAgB,SAAQ,KAAK,CAAC,cAAc,CAAC,cAAc,CAAC,EAAE,mBAAmB;IAChG;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;OAUG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,uGA+HpB,CAAC"}

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

@@ -0,0 +1,37 @@
+import { RangeCoords } from '@sheetxl/utils';
+import { LayerNode } from './LayerTypes';
+/** Content key for a range — stable across object identity (dedupe / memo / hover-target keys). */
+export declare const rangeKey: (r: RangeCoords) => string;
+/**
+ * A layer's **derived stacking order** — its index in the normalized layer list, i.e. the react list
+ * order with explicit-`zIndex` overrides already folded in (see {@link normalizeLayers}). This is the
+ * "effective z" a dev means by *visual order* — **not** the raw `zIndex` prop. The {@link Layer} at
+ * each slot registers its event tap at it, and descendant command scopes read it (via `useLayer`) so
+ * keystroke / command dispatch follows the visual stack. Derived purely from the React list — **no
+ * DOM, no registration timing**.
+ */
+export declare const LayerOrderContext: import('react').Context<number>;
+/**
+ * Whether the current subtree is inside a {@link Layer}. Backs the flat-stack law (law 4): a `Layer`
+ * dev-errors when it finds itself already inside one, and a {@link VirtualDiv} dev-warns when it is
+ * NOT inside one. Purely a dev-time diagnostic — no runtime behavior branches on it.
+ */
+export declare const LayerScopeContext: import('react').Context<boolean>;
+/**
+ * Normalize the layers (the grid's children) for rendering: sort by `zIndex` and stamp each with its
+ * **derived order index** (its position in the sorted list = its effective z). A non-array passes
+ * through unchanged.
+ *
+ * @remarks
+ * Ordering matches the CSS model: sort by `zIndex` **ascending** (higher paints later = on top); a layer
+ * without a `zIndex` counts as `0`, and `Array.prototype.sort` is stable so same-`zIndex` layers keep
+ * **declaration order** — exactly as `z-index: auto` behaves. The `zIndex` is read off the top-level
+ * child element (a `<Layer zIndex>` or a composite forwarding one) — this is the ONLY place z is
+ * honored; a Layer's dispatch slot always comes from the resulting order index. Each sorted layer is
+ * wrapped in a {@link LayerOrderContext} carrying its index, so its `Layer` (and any descendant command
+ * scope) reads its effective stacking order — the react-list analog of CSS paint order. That index is
+ * stable across remounts / effect re-runs (it is the LIST position, not when a responder registered)
+ * and needs **no DOM**. Keyed by the element's own key so a reorder re-slots (not remounts).
+ */
+export declare const normalizeLayers: (layers: LayerNode) => React.ReactNode;
+//# sourceMappingURL=_Utils.d.ts.map

package/types/src/layer/_Utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_Utils.d.ts","sourceRoot":"","sources":["../../../../src/layer/_Utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,mGAAmG;AACnG,eAAO,MAAM,QAAQ,GAAI,GAAG,WAAW,KAAG,MAA+D,CAAC;AAG1G;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,iCAA2B,CAAC;AAE1D;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,kCAAgC,CAAC;AAE/D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,GAAI,QAAQ,SAAS,KAAG,KAAK,CAAC,SAYzD,CAAC"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/layer/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAK7B,YAAY,EACV,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAC1F,MAAM,iBAAiB,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}

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

@@ -0,0 +1,157 @@
+import { CellCoords, RangeCoords, Bounds, Point, AnchorLocation } from '@sheetxl/utils';
+import { IGridPane } from '../surface';
+/**
+ * A viewport edge (used by `edge` anchors and reported by {@link GridAnchorResolved.clampedTo}).
+ */
+export type GridFloatSide = 't' | 'l' | 'r' | 'b';
+/** Alignment along the anchored edge (which end the anchor pixel sits at). */
+export type GridAlign = 'start' | 'center' | 'end';
+/**
+ * WHERE the float attaches to the range — the `side` it sits on plus the `align` along that edge.
+ * This picks a **single anchor pixel** (a corner / edge-midpoint) which decides pane ownership and
+ * clip (that one pixel is in exactly one pane), while positioning still uses the whole range rect.
+ * Maps to a Floating UI `Placement` at the `FloatPopper` boundary (`t-start` → `top-start`, …).
+ */
+export interface GridPlacement {
+    side: GridFloatSide;
+    /** @defaultValue 'center' */
+    align?: GridAlign;
+}
+/**
+ * What happens when **no pane owns the anchor pixel** (it scrolled off the data area).
+ *
+ * - `'hide'` — not rendered (touch handles once their range is gone; ephemeral tooltips). Default.
+ * - `'clamp'` — project the pixel onto the nearest data edge and slide it there (sticky / presence);
+ *   the owner becomes the pane under the clamped pixel and {@link GridAnchorResolved.slid} is set.
+ */
+export type GridWhenOff = 'hide' | 'clamp';
+/**
+ * How far the anchor pixel was pushed to stay in frame (the `clamp` fallback). Handed to the sticky
+ * child so it can render differently when slid — an arrow toward the true (off-frame) anchor, etc.
+ */
+export interface GridSlide {
+    /** Client-px offset applied to the anchor to clamp it into the boundary. */
+    dx: number;
+    dy: number;
+    /** Magnitude of the push (`hypot(dx, dy)`). */
+    distance: number;
+    /** The edge it slid to — the direction of the true, off-frame anchor. */
+    direction: GridFloatSide;
+}
+/**
+ * WHERE a grid float is anchored — a **grid coordinate**, resolved live to a client rect via the
+ * pane. The float tracks it across scroll / zoom / resize / freeze.
+ *
+ * - `range` — a cell range (the primary "virtual range" case).
+ * - `cell` — a single cell.
+ * - `bounds` — pane **view-relative** bounds (same space `getBoundsFromRange` returns).
+ * - `edge` — the midpoint of a viewport edge (touch handles / scrollbars).
+ * - `point` — a **client-px** point (drag readouts that follow the pointer).
+ */
+export type GridAnchor = {
+    range: RangeCoords;
+} | {
+    cell: CellCoords;
+} | {
+    bounds: Bounds;
+} | {
+    edge: GridFloatSide;
+} | {
+    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.
+ *
+ * - `'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).
+ * - a {@link Bounds} — an explicit **client-px** rect.
+ */
+export type GridBoundary = 'data' | 'pane' | 'grid' | Bounds;
+/** A `DOMRect`-shaped plain object (works in Floating UI and in Node tests without a DOM). */
+export interface GridAnchorRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+}
+/** The full resolution of a {@link GridAnchor} at a moment in time. */
+export interface GridAnchorResolved {
+    /** The anchor's client rect (what Floating UI positions against). */
+    rect: GridAnchorRect;
+    /** True when the anchor is fully outside {@link boundaryRect}. */
+    clipped: boolean;
+    /** The clip / clamp boundary in client px. */
+    boundaryRect: GridAnchorRect;
+    /** When clipped, which side the anchor is off (for `clamp` / presence); else `null`. */
+    clampedTo: GridFloatSide | null;
+    /**
+     * The single anchor pixel (client px) the `placement` picks out — the corner / edge-midpoint that
+     * decides ownership + clip. For a straddling range this pixel lives in exactly one pane.
+     */
+    anchorPoint: Point;
+    /** The pane (by anchor location) that owns the anchor pixel — the single render owner. */
+    owner: AnchorLocation | null;
+    /** Set (non-null) only under the `clamp` fallback when the anchor slid to stay in frame. */
+    slid: GridSlide | null;
+    /**
+     * The anchor's range has **no visible portion** (fully scrolled off) — independent of `whenOff`. Unlike
+     * {@link clipped} (which `clamp` forces false), this stays true under `clamp`, so a presence can tell
+     * "partially obstructed / clamped" (still show) from "off-screen" (show a goto affordance).
+     */
+    outOfView: boolean;
+}
+/** 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;
+    };
+    /** 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). */
+    clipped: boolean;
+    /** Render-time snapshot: which side the anchor is off, when clipped. */
+    clampedTo: GridFloatSide | null;
+    /** Render-time snapshot: the placement's anchor pixel (client px). */
+    anchorPoint: Point;
+    /** Render-time snapshot: the pane (by anchor location) that owns the anchor pixel. */
+    owner: AnchorLocation | null;
+    /** Render-time snapshot: the slide applied by the `clamp` fallback (else `null`). */
+    slid: GridSlide | null;
+    /** Render-time snapshot: the range is fully scrolled off (stays true under `clamp`; see resolved). */
+    outOfView: boolean;
+    /** The pane the anchor resolves against (null outside a `GridPaneProvider`). */
+    pane: IGridPane | null;
+}
+/** @internal The shared placement default (`StickyAnchor` and the resolver must agree on it). */
+export declare const DEFAULT_PLACEMENT: GridPlacement;
+/**
+ * Resolve a {@link GridAnchor} to a client rect + clip state against a boundary. **Pure** (given a
+ * pane) — no React, no live DOM beyond `getBoundingClientRect`, so it is directly unit-testable with a
+ * fake {@link IGridPane}. Shared by {@link useGridAnchor} (the live closures call this per frame).
+ */
+export declare const resolveGridAnchor: (pane: IGridPane | null, anchor: GridAnchor, boundary?: GridBoundary, minVisible?: number, placement?: GridPlacement, whenOff?: GridWhenOff) => GridAnchorResolved;
+/**
+ * Bridge a {@link GridAnchor} (grid coordinate) to a **live Floating UI virtual reference** plus clip
+ * state. The pane already re-renders every layer on scroll (so the snapshot values update per frame),
+ * and the returned {@link UseGridAnchorResult.reference} reads live on each `getBoundingClientRect`
+ * call so `autoUpdate` keeps the float glued between renders. No hidden measure element, no
+ * scroll-parent walk. Read the pane from context, or pass one explicitly.
+ */
+export declare const useGridAnchor: (anchor: GridAnchor, options?: {
+    pane?: IGridPane;
+    boundary?: GridBoundary;
+    minVisible?: number;
+    placement?: GridPlacement;
+    whenOff?: GridWhenOff;
+}) => UseGridAnchorResult;
+//# sourceMappingURL=useGridAnchor.d.ts.map

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

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