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

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

@@ -1,68 +0,0 @@
-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;
-    /**
-     * Where the float may LIVE — one rect, resolved by {@link GridBoundary}: it is both the anchor's
-     * clip / clamp boundary and the rect `flip` / `shift` collide against. @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/useRangeHover.d.ts

@@ -1,36 +0,0 @@
-import { RangeCoords } from '@sheetxl/utils';
-import { UseHoverIntentOptions, HoverTipProps } from './useHoverIntent';
-/**
- * The result of {@link useRangeHover}.
- */
-export interface UseRangeHoverResult {
-    /** Whether a hover tooltip for the range should be shown (after the intent delays). */
-    open: boolean;
-    /** Spread onto the floated tip so hovering it keeps the tooltip open (see {@link HoverTipProps}). */
-    tipProps: HoverTipProps;
-}
-/**
- * Tracks the pointer over a **fixed grid range** and drives hover-tooltip intent: returns `open` (with
- * open / close delays) plus `tipProps` to keep the tip open while the pointer is on it. Pair with
- * {@link StickyFloat} for the label:
- *
- * ```tsx
- * const { open, tipProps } = useRangeHover(range);
- * <StickyFloat anchor={{ range }} placement={{ side: 't' }} offset={6} open={open}>
- *   <div {...tipProps}>Value must be a positive number</div>
- * </StickyFloat>
- * ```
- *
- * Must be called inside a grid (needs pane context). For a **dynamic** target (an error layer that
- * discovers whichever hovered cell has errors), drive {@link useHoverIntent} directly instead.
- *
- * @remarks
- * Registers a passive `pointermove` / `pointerleave` responder on the pane's Stage (mirrors
- * a {@link Layer} tap); it never consumes the event. Because a grid child renders per pane, the pointer
- * is seen by whichever pane it is over while the tip renders on the pane owning the anchor — which for
- * a range straddling a freeze is a DIFFERENT pane. The aimed target is therefore brokered through
- * {@link useSurfaceState}, so every pane copy runs its intent off the same signal and the owner is
- * armed no matter where the pointer is.
- */
-export declare const useRangeHover: (range: RangeCoords, options?: UseHoverIntentOptions) => UseRangeHoverResult;
-//# sourceMappingURL=useRangeHover.d.ts.map