@sheetxl/grid-react 0.8.0-beta.2 → 0.8.0-beta.20

package/LICENSE.md

@@ -1,11 +1,12 @@
-# Repository Licensing
+# License
 
-SheetXL contains a mix of open-source and commercially licensed packages. Each package is individually licensed and contains its own license file.
+Copyright (c) 2026-present SheetXL Inc. & Michael T. Ford. All rights reserved.
 
-For the specific terms and conditions applicable to a package, please see the `LICENSE.md` file located in that package's root directory.
+This package is commercial software, licensed under the SheetXL End-User License Agreement:
+https://www.sheetxl.com/eula
 
-Generally, packages intended for public distribution (such as CLIs, adapters, and vanilla wrappers) are licensed under the MIT license. All other core packages are proprietary and require a commercial license for use.
+A free Community License covers evaluation, learning and non-commercial use. Commercial use
+requires a paid license — see https://www.sheetxl.com/pricing.
 
-For more details on commercial licensing, please visit our website:
-
-https://www.sheetxl.com/docs/guides/licensing-pricing
+Third-party components bundled in this package remain under their own licenses, listed in
+`licenses/dependencies.txt`.

package/README.md

@@ -33,8 +33,10 @@ That's it — a virtualized grid that efficiently handles trillions of cells.
 
 `renderCells` receives a `CellRendererProps`: `{ cell, range, bounds, value, style, pane }` (plus a
 `key`). `style` is already positioned/sized for the cell — spread it onto your element. By default a
-rendered cell is `pointer-events: none` so clicks fall through to the grid; override per cell to make
-it interactive.
+rendered cell is `pointer-events: none` so clicks fall through to the grid. To make part of a cell
+interactive — a checkbox, a button, a slider — spread `CELL_INTERACTIVE_PROPS` onto that element and
+add its handlers as on any element: a plain press on it selects the cell, starts no drag-select, and
+then reaches the element's own `onPointerDown`; a drag captures the pointer on the element itself.
 
 ## Why another grid?
 
@@ -304,8 +306,16 @@ const pane = useGridPane();
 The **Stage is the grid's surface** — focus rests on it, and that's what cell navigation uses.
 Programmatically, `gridRef.current.focus()` (or `pane.focus()`) focuses the surface. A `VirtualDiv`
 that should take keyboard focus opts in with `tabIndex` — regular div focus semantics: when it's
-focused it receives keys first (and may `stopPropagation` to keep them from the grid); when the
-surface is focused, keys reach the grid and it navigates as usual.
+focused, keys target it and reach its handlers at its layer's turn (after the taps above it, per
+law 3), and it may `stopPropagation` to keep them from the layers below; when the surface is
+focused, keys reach the grid and it navigates as usual.
+
+A behavior that belongs to the **grid in ready mode** — opening the cell editor on a typed key or a
+double-click — is the floor's, not the top's: put it on its own Layer at the *bottom* of the stack
+(it then hears only what no widget above consumed) and, for keys, act only when the surface itself
+is the event target. A layer that sits high to *paint* (the editor box) must not carry that
+behavior, because its tap would hear every widget's keys first. `EditorStartLayer` + `EditorLayer`
+are this split.
 
 Keys are positionless, so their walk skips hit-testing: **every** layer is offered the key, top of
 z first, then the command system terminates the bubble. There is **no** "is the target an input?"
@@ -353,7 +363,7 @@ with gridlines and the selection rectangle at any device-pixel ratio:
 Composition: a **view-sized, pointer-transparent `VirtualDiv`** hosting a `RectangleSVG` drawn at
 the range's true coordinates (clamped to the view). The box is view-sized on purpose — a range-sized
 box would be enormous for whole-column ranges, and an SVG whose box moves can't animate its stroke
-(`animatedTransition` glides the path inside a stable coordinate space instead). `RectangleSVG` /
+(a `glide` — see `RangeGlide` — moves the path inside a stable coordinate space instead). `RectangleSVG` /
 `LineSVG` are available for composing your own shapes the same way.
 
 ### Anchored floats
@@ -364,8 +374,9 @@ anchor resolver + Floating UI), not from them:
 
 - **`StickyAnchor`** — resolves a grid anchor (range / cell / edge / point) to a live position;
   children render inline (clipping with the pane) or self-position via render-prop.
-- **`StickyFloat`** — the portal flavor: floats content beside the anchor with flip/shift/clamp.
-- **`HoverTipLayer`** — hover-intent tips: a `Layer` tap probing the hovered cell + a `StickyFloat`.
+- **`StickyPortal`** — the portal flavor: floats content beside the anchor with flip/shift/clamp.
+- **`RangeTooltipLayer`** — the tooltip kind: a `Layer` tap probing the hovered cell + a `StickyPortal` in the
+  group's bubble; `TooltipProvider` sets the timing, the bubble and the single-open group.
 - **`RangePrompt`** — a persistent prompt pinned to a range, with an out-of-view "go to" affordance.
 
 Naming convention: a component ending in `-Layer` roots a `Layer` (drop it in as a grid child);
@@ -390,7 +401,9 @@ Complete, drop-in layers (each roots its own `Layer` — stack them like any oth
   directly on a `GridSurface` when you own the stack.
 - **`SelectionLayer`** — pointer + keyboard selection over an `ISelection` model, with move grip and
   fill handle slots.
-- **`EditorLayer`** — an always-mounted inline cell editor (swappable input).
+- **`EditorStartLayer`** — the ready-mode edit starters (typed key / F2 / double-click); mount it
+  first (the floor).
+- **`EditorLayer`** — an always-mounted inline cell editor (swappable input); mount it last (the top).
 - **`RangesPickerLayer`** — multi-rectangle range picking (formula references, chart ranges).
 - **`List`** — a virtualized list built from the same engine (a one-column grid + selection).