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

package/package.json

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

package/types/src/range/DragHandle.d.ts

@@ -23,6 +23,7 @@ export interface DragHandleRenderProps {
      */
     handleProps: {
         onPointerDown: (e: React.PointerEvent) => void;
+        onDoubleClick?: (e: React.MouseEvent) => void;
         onPointerEnter?: (e: React.PointerEvent) => void;
         onPointerLeave?: (e: React.PointerEvent) => void;
         style: React.CSSProperties;
@@ -64,6 +65,13 @@ export interface DragHandleProps {
      * applying it. Event-less — an Escape abort has no pointer event.
      */
     onDragCancel?: () => void;
+    /**
+     * The handle was **double-clicked** — fired on the second press of the pair, which starts no drag.
+     *
+     * Timed from pointer-down, and the `dblclick` it leaves behind is suppressed — both by
+     * {@link useDoubleClick}, which explains why neither can come from the browser directly.
+     */
+    onDoubleClick?: (e: React.MouseEvent) => void;
     /** The pointer entered (`true`) / left (`false`) the handle — for a hover affordance on the host. */
     onHoverChange?: (hovered: boolean) => void;
     /**

package/types/src/range/Draggable.d.ts

@@ -64,7 +64,19 @@ export interface DraggableProps {
      * so dragging a range doesn't blur the formula editor's textarea. @defaultValue false
      */
     preserveFocus?: boolean;
+    /**
+     * A border of the range was **double-clicked**, reported with the edge that was hit. Excel's
+     * jump-to-the-end-of-the-data: the consumer decides where that edge leads (`getExtended`), since
+     * this layer holds no model.
+     *
+     * The double-click is consumed — the second press starts no move drag. Only meaningful with
+     * `grip: 'edges'`; with `grip: 'entire'` the whole rectangle is the grip and there is no edge to
+     * name, so the nearest one is still reported but rarely means anything.
+     */
+    onEdgeDoubleClick?: (range: RangeCoords, edge: RangeEdge, e: React.PointerEvent) => void;
 }
+/** Which border of a range a gesture landed on. */
+export type RangeEdge = 'top' | 'bottom' | 'left' | 'right';
 /**
  * A **"make draggable" wrapper**: it makes its `children` movable (translate — same size, new location)
  * and reports the translated range via `onDrag*`. It owns ONLY the gesture (pointer-capture +

package/types/src/range/FillHandle.d.ts

@@ -36,6 +36,13 @@ export interface FillHandleProps extends VisualSVGProps {
      * Escape abort, hence the optional event.
      */
     onDragDone?: (e?: React.PointerEvent) => void;
+    /**
+     * The handle was **double-clicked** — Excel's "ride the rails" fill, where the destination comes
+     * from the data flanking the template rather than from a drag. Reported as the template only: the
+     * destination is the consumer's to work out (`ICellRange.getExtended` with `basis: 'adjacent'`), since it is a question
+     * about the sheet's content and this layer holds no model.
+     */
+    onDoubleClick?: (range: RangeCoords, e: React.MouseEvent) => void;
     /**
      * Render the fill handle **element** yourself (headless) — forwarded to {@link DragHandle.renderHandle}.
      * Replaces the default dot. Use it for a custom fill mark (e.g. the Excel fill square).

package/types/src/range/useDoubleClick.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Double-click detection for a grid gesture element, timed from its own `pointerdown`.
+ *
+ * The browser cannot simply be asked. `PointerEvent.detail` is always 0 — only `click`/`dblclick`
+ * carry a click count — and the compat `dblclick` never reaches the element either: the Stage offers
+ * that to the layers ABOVE it (the cell editor among them, by design) on the native capture phase,
+ * before the native dispatch reaches the element's own subtree. Pointer-down is the element's own
+ * event and arrives whatever sits over it.
+ *
+ * So the pair is timed here, and the `dblclick` it goes on to produce is swallowed on the `window`'s
+ * capture phase — which runs ahead of the Stage's — so the layers above do not act on it as well.
+ *
+ * @param enabled Whether to detect at all; `false` makes the filter a no-op (there is no consumer,
+ *          so a pair should stay two ordinary presses).
+ * @returns A `pointerdown` filter. `true` means the press completed a pair and has been consumed —
+ *          the caller must not start its drag; `false` means carry on as normal.
+ */
+export declare const useDoubleClick: (enabled: boolean) => ((e: React.PointerEvent) => boolean);
+//# sourceMappingURL=useDoubleClick.d.ts.map

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

@@ -2,6 +2,7 @@ import { default as React } from 'react';
 import { CellCoords, RangeCoords } from '@sheetxl/utils';
 import { LayerProps, GridPlacement } from '../layer';
 import { VisualSVGProps } from '../svg';
+import { RangeEdge } from '../range';
 import { ISelection } from './ISelection';
 import { SelectionNavigation } from './Types';
 import { SelectionRangeStyle } from './SelectionStyle';
@@ -112,7 +113,7 @@ export interface SelectionLayerProps extends LayerProps {
      * 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;
+    onFill?: (template: RangeCoords, destination: RangeCoords, e: React.MouseEvent) => 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
@@ -132,6 +133,21 @@ export interface SelectionLayerProps extends LayerProps {
      * anything {@link SelectionLayerProps.onFillPreview} set (e.g. closing the preview tooltip).
      */
     onFillEnd?: () => void;
+    /**
+     * Resolve the destination for a **double-clicked** fill handle — Excel's "ride the rails" fill,
+     * whose extent comes from the data flanking the template rather than from a drag. Return the
+     * destination (which must include the template) or `null` for no fill; omit to leave double-click
+     * inert. Injected rather than computed here because it is a question about the sheet's content
+     * and this layer holds no model — `ICellRange.getExtended` with `basis: 'adjacent'` answers it. The result then takes
+     * the same path a drag release does, {@link SelectionLayerProps.onFill} included.
+     */
+    resolveFillExtent?: (template: RangeCoords) => RangeCoords | null;
+    /**
+     * A border of the selection was **double-clicked**, reported with the edge that was hit — Excel's
+     * jump to the end of the data in that direction. Where it lands is the consumer's to decide
+     * (`ICellRange.getExtended`), as this layer holds no model; omit to leave the gesture inert.
+     */
+    onEdgeDoubleClick?: (range: RangeCoords, edge: RangeEdge, e: React.PointerEvent) => 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