@pond-ts/charts 0.69.0 → 0.71.0

package/dist/ChartContainer.js

@@ -6,12 +6,12 @@ import { scaleBand } from './bandScale.js';
 import { scaleElapsed } from './elapsed.js';
 import { Sequence, TimeZone } from 'pond-ts';
 import { ContainerContext, CursorContext, } from './context.js';
-import { LegacyCursor, legacyCursorWarning, presetNameFor, warnOnDuplicateGestureOwners, } from './cursors.js';
+import { warnOnDuplicateGestureOwners } from './cursors.js';
 import { effectiveSelectorEntries, resolveControlledHovered, resolveControlledSelected, selectorEntryEqual, warnInertClick, } from './selectors.js';
 import { isDev } from './dev.js';
 import { maxSlotWidths, sum } from './slots.js';
 import { computeLabelLanes } from './annotations.js';
-import { resolveCursorX, DEFAULT_CURSOR_MODE } from './tracker.js';
+import { resolveCursorX } from './tracker.js';
 import { clampToBounds } from './viewport.js';
 import { resolveAxisFormat, resolveTimeFormat, } from './format.js';
 import { TimeAxis } from './TimeAxis.js';
@@ -198,14 +198,7 @@ function AutoSizeContainer(props) {
  *  pass; a chart legitimately gated this long is not painting anyway. */
 const ZERO_SIZE_WARNING_MS = 600;
 /** {@link ChartContainer} with its width resolved to a concrete pixel number. */
-function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidth, bandAlign = 'start', width, height, rowGap = 0, showAxis = true, trackerPosition, onTrackerChanged, onDrawStats, panZoom = false, axisPanZoom = false, bounds, onTimeRangeChange, minDuration = 1, cursor: cursorProp, cursorSequence: cursorSequenceProp, onRegionSelect, regionSelectModifier, cursorTime: cursorTimeProp, crosshairSnap: crosshairSnapProp, editAnnotations = false, creating = null, onCreate, onSelectAnnotation, onHoverAnnotation, onEditAnnotation, snap = true, timeFormat, cursorFormat: cursorFormatProp, origin, theme, discontinuities, calendar, timeZone: timeZoneProp, spacing, xScale: xScaleKind = 'linear', grid = true, sessionDividers = 'none', children, }) {
-    // ── Legacy cursor props (deprecated) ───────────────────────────────────────
-    // The string surface keeps working for one minor: the resolved mode is
-    // synthesized into the equivalent mounted preset below (`<LegacyCursor>`),
-    // and a dev warning names the replacement whenever any of the props is
-    // *explicitly* set (never on the defaults). Mounted cursor components in the
-    // same scope override the shim. See docs/rfcs/interaction.md §9 / A4.4.
-    const cursor = cursorProp ?? DEFAULT_CURSOR_MODE;
+function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidth, bandAlign = 'start', width, height, rowGap = 0, showAxis = true, trackerPosition, onTrackerChanged, onDrawStats, panZoom = false, axisPanZoom = false, bounds, onTimeRangeChange, minDuration = 1, editAnnotations = false, creating = null, onCreate, onSelectAnnotation, onHoverAnnotation, onEditAnnotation, snap = true, timeFormat, origin, theme, discontinuities, calendar, timeZone: timeZoneProp, spacing, xScale: xScaleKind = 'linear', grid = true, sessionDividers = 'none', children, }) {
     // [PND-HEIGHT] Whether this container owns vertical layout (see the
     // `height` prop). Carried on the frame so a `<ChartRow flex>` can tell a
     // home that can size it from one that never will.
@@ -223,43 +216,8 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
     const declaredCategories = useMemo(() => categoriesProp === undefined ? null : [...categoriesProp], 
     // eslint-disable-next-line react-hooks/exhaustive-deps -- content identity
     [categoriesKey]);
-    const cursorTime = cursorTimeProp ?? false;
-    const crosshairSnap = crosshairSnapProp ?? true;
-    const warnedLegacyRef = useRef(false);
-    useEffect(() => {
-        if (!isDev || warnedLegacyRef.current)
-            return;
-        const legacy = [];
-        if (cursorProp !== undefined)
-            legacy.push(`cursor="${cursorProp}" → mount ${presetNameFor(cursorProp)}`);
-        if (crosshairSnapProp !== undefined)
-            legacy.push('crosshairSnap → <CrosshairCursor snap>');
-        if (cursorTimeProp !== undefined)
-            legacy.push('cursorTime → showTime on the mounted cursor');
-        if (cursorFormatProp !== undefined)
-            legacy.push('cursorFormat → format on <CrosshairCursor>');
-        if (cursorSequenceProp !== undefined)
-            legacy.push('cursorSequence → <RangeCursor sequence>');
-        if (onRegionSelect !== undefined)
-            legacy.push('onRegionSelect → <RangeCursor onDragRelease> (the payload becomes ' +
-                '{ x: [lo, hi] })');
-        if (regionSelectModifier !== undefined)
-            legacy.push('regionSelectModifier → <RangeCursor dragModifier>');
-        if (legacy.length === 0)
-            return;
-        warnedLegacyRef.current = true;
-        console.warn(legacyCursorWarning(legacy));
-    }, [
-        cursorProp,
-        crosshairSnapProp,
-        cursorTimeProp,
-        cursorFormatProp,
-        cursorSequenceProp,
-        onRegionSelect,
-        regionSelectModifier,
-    ]);
     // Mounted-cursor registry ({@link ContainerFrame.registerCursor}): the
-    // presets (and the legacy shim) register their specs here; rows and
+    // presets register their specs here; rows and
     // `<XAxis>` render the effective set. Same per-instance-slot discipline as
     // the tracker sources; register is idempotent under reference equality (the
     // presets memoize their entries on props).
@@ -282,16 +240,12 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
     useEffect(() => {
         warnOnDuplicateGestureOwners(cursors, warnedGestureRef);
     }, [cursors]);
-    // The registered cursors' resolution inputs, folded into the legacy
-    // channels: a mounted `<CrosshairCursor format>` feeds the shared readout
-    // channel exactly where `cursorFormat` fed it. First **component-mounted**
-    // entry wins (the shim registers before the children mount, so a bare
-    // first-wins would let the legacy synthesis shadow a real mount); the
-    // legacy prop is the fallback during the window. (`sequence` resolves the
+    // The registered cursors' resolution inputs: a mounted cursor's `format`
+    // feeds the shared readout channel (the x pill, marker indicators,
+    // annotation auto-labels). First mounted wins. (`sequence` resolves the
     // same way, below the selector registry — a `<MultiSelector sequence>`
     // feeds the same channel.)
-    const cursorFormat = useMemo(() => cursors.find((e) => !e.legacy && e.format !== undefined)?.format ??
-        cursorFormatProp, [cursors, cursorFormatProp]);
+    const cursorFormat = useMemo(() => cursors.find((e) => e.format !== undefined)?.format, [cursors]);
     // Which axes the gestures own. **Pan follows zoom's degrees of freedom**: an
     // axis that can be zoomed can be panned, because a zoomed axis shows less than
     // all of itself and the reader needs to reach the rest. `'pan'` is the one
@@ -445,7 +399,7 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
         setSelectableKeys(next);
     }, []);
     // Mounted-selector registry ({@link ContainerFrame.registerSelector}):
-    // `<Selector>` — and the legacy shim below — register here, and **the
+    // `<Selector>` / `<MultiSelector>` register here, and **the
     // registration is what enables a plot click** (interaction RFC §7.1). Same
     // per-instance-slot discipline as the cursors/tracker sources. Mirrored to a
     // ref because `select` / `setHovered` are `[]`-stable callbacks that must not
@@ -477,15 +431,13 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
     }, []);
     const selectors = useMemo(() => Array.from(selectorMap.values()), [selectorMap]);
     const selectorsRef = useRef(selectors);
-    // The shared snap-bucket sequence, folded into the legacy channel exactly as
-    // `cursorFormat` is above: a component-mounted `<RangeCursor sequence>`
-    // wins, then a mounted `<MultiSelector sequence>` (its sweep extends bucket
-    // by bucket over the same realized buckets — one channel, so the band and
-    // the sweep can never snap differently), then the legacy shim / prop.
-    const cursorSequence = useMemo(() => cursors.find((e) => !e.legacy && e.sequence !== undefined)?.sequence ??
-        selectors.find((e) => e.sequence !== undefined)?.sequence ??
-        cursors.find((e) => e.sequence !== undefined)?.sequence ??
-        cursorSequenceProp, [cursors, selectors, cursorSequenceProp]);
+    // The shared snap-bucket sequence, resolved like `cursorFormat` above: a
+    // mounted `<RangeCursor sequence>` wins, then a mounted `<MultiSelector
+    // sequence>` (its sweep extends bucket by bucket over the same realized
+    // buckets — one channel, so the band and the sweep can never snap
+    // differently).
+    const cursorSequence = useMemo(() => cursors.find((e) => e.sequence !== undefined)?.sequence ??
+        selectors.find((e) => e.sequence !== undefined)?.sequence, [cursors, selectors]);
     // Annotations register here so the container can do what a mark can't in
     // isolation: draw its guide line across other rows, order regions, serve snap
     // targets. Keyed by per-instance slot key (same discipline as the sources).
@@ -1201,10 +1153,10 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
     // briefly stale until the next pointer move — rare, and the bounds check below
     // hides an out-of-plot crosshair meanwhile.
     const cursorX = resolveCursorX(trackerPosition, hoverX, xScale);
-    // `cursor="region"` snap buckets — the intervals the band snaps to (and a drag
+    // `<RangeCursor>` snap buckets — the intervals the band snaps to (and a drag
     // extends bucket by bucket over). Two sources, in precedence order:
     //
-    // 1. **An explicit `cursorSequence`** (time axis only): realized over the view
+    // 1. **An explicit `sequence`** (time axis only): realized over the view
     //    (a `Sequence` → `.bounded`; a `BoundedSequence` used as-is). A `Sequence`
     //    bucket is a *time* interval, so it's gated to a time axis — realizing time
     //    buckets over a value domain is meaningless (it would shade the whole plot).
@@ -1231,9 +1183,9 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
         // or a time-axis histogram with no explicit sequence). `binIntervals` is only
         // published by a vertical bar layer, so this is a no-op for
         // line/area/scatter rows. On a **category** axis the bins are the unit
-        // slots `[i, i+1)`: the region cursor never reads them (its band gates on
-        // a continuous axis), but the `<MultiSelector>` sweep's band snaps over
-        // them so it runs slot-edge to slot-edge — the band scale's `invert`
+        // slots `[i, i+1)`: the `<RangeCursor>` band shades the slot under the
+        // pointer ([PND-ORDCURSOR]), and the `<MultiSelector>` sweep's band snaps
+        // over them so it runs slot-edge to slot-edge — the band scale's `invert`
         // returns slot *centres*, and a centre-to-centre band disagreed with the
         // snapped-outward span the release commits (RFC A7.6's edge rule).
         //
@@ -1294,6 +1246,25 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
             'axis; key the data on the quantity itself (a `ValueSeries`) to get a ' +
             'value axis you can scale.');
     }
+    // [PND-ORDCURSOR] A `<RangeCursor onDragRelease>` on a category axis draws
+    // its slot band but never starts a drag (`resolveRangeDrag`): the callback
+    // would silently never fire, so say so once. Same `sources.size` guard as
+    // above — the kind is 'time' until the layers register.
+    const rangeDragOnCategory = resolvedKind === 'category' &&
+        sources.size > 0 &&
+        cursors.some((e) => e.onDragRelease !== undefined && e.enableDrag !== false);
+    const warnedRangeDragOnCategoryRef = useRef(false);
+    useEffect(() => {
+        if (!isDev || !rangeDragOnCategory)
+            return;
+        if (warnedRangeDragOnCategoryRef.current)
+            return;
+        warnedRangeDragOnCategoryRef.current = true;
+        console.warn('[pond-charts] <RangeCursor onDragRelease> is mounted on a category x ' +
+            'axis, where the range drag is off: the band shades the slot under the ' +
+            'pointer, but `onDragRelease` never fires. To drag across bars and get ' +
+            'them back, mount a <MultiSelector> instead.');
+    }, [rangeDragOnCategory]);
     const xIsLog = ((s) => {
         const probe = s;
         return (typeof probe.base === 'function' || typeof probe.constant === 'function');
@@ -1342,15 +1313,12 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
         rowGap,
         setHoverX,
         setHoverY,
-        crosshairSnap,
         cursorBuckets,
         regionAnchor,
         previewSpans,
         setPreviewSpans,
         setRegionAnchor,
-        onRegionSelect,
         reportDrawStats,
-        regionSelectModifier,
         draggingKey,
         setDragging,
         selected: selectedValue,
@@ -1358,8 +1326,6 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
         select,
         hovered: hoveredValue,
         setHovered,
-        cursor,
-        cursorTime,
         editAnnotations,
         creating,
         snap,
@@ -1428,15 +1394,12 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
         rightGutter,
         rowGap,
         setHoverY,
-        crosshairSnap,
         cursorBuckets,
         regionAnchor,
         previewSpans,
         setPreviewSpans,
         setRegionAnchor,
-        onRegionSelect,
         reportDrawStats,
-        regionSelectModifier,
         draggingKey,
         setDragging,
         selectedValue,
@@ -1444,8 +1407,6 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
         select,
         hoveredValue,
         setHovered,
-        cursor,
-        cursorTime,
         editAnnotations,
         creating,
         snap,
@@ -1499,37 +1460,33 @@ function ResolvedChartContainer({ range, categories: categoriesProp, maxBandWidt
         registerRow,
         firstRowKey,
     ]);
-    return (_jsx(ContainerContext.Provider, { value: frame, children: _jsxs(CursorContext.Provider, { value: cursorFrame, children: [_jsx(LegacyCursor, { mode: cursor, showTime: cursorTime, snap: crosshairSnap, sequence: cursorSequenceProp, 
-                    // The 'line' default nobody asked for is IMPLICIT — the one cursor a
-                    // <MultiSelector>'s resting block preview may replace with the
-                    // brush band. An explicit `cursor` prop (any mode) still wins.
-                    implicit: cursorProp === undefined }), _jsxs("div", { style: {
-                        width: `${width}px`,
-                        // [PND-HEIGHT] A managed height makes the outer box a flex
-                        // column: the rows block below flexes, the axis strip keeps its
-                        // natural height at the bottom, and CSS subtracts one from the
-                        // other. That subtraction being layout rather than arithmetic is
-                        // the feature — the strip's height varies with label, font size,
-                        // calendar bands and pill lanes, so no constant is correct.
-                        ...(height !== undefined
-                            ? {
-                                height: `${height}px`,
-                                display: 'flex',
-                                flexDirection: 'column',
-                            }
-                            : {}),
-                    }, children: [_jsx("div", { style: {
-                                display: 'flex',
-                                flexDirection: 'column',
-                                gap: `${rowGap}px`,
-                                // The positioned ancestor for overlay chrome (`<Legend>`): the
-                                // card anchors to the rows block, never the axis strip below.
-                                position: 'relative',
-                                // The rows block takes what the axis strip leaves. `minHeight:
-                                // 0` lets it shrink below its content — without it a flex
-                                // child's floor is its content and nothing can ever get
-                                // smaller.
-                                ...(height !== undefined ? { flex: '1 1 0%', minHeight: 0 } : {}),
-                            }, children: children }), showAxis && _jsx(TimeAxis, {})] })] }) }));
+    return (_jsx(ContainerContext.Provider, { value: frame, children: _jsx(CursorContext.Provider, { value: cursorFrame, children: _jsxs("div", { style: {
+                    width: `${width}px`,
+                    // [PND-HEIGHT] A managed height makes the outer box a flex
+                    // column: the rows block below flexes, the axis strip keeps its
+                    // natural height at the bottom, and CSS subtracts one from the
+                    // other. That subtraction being layout rather than arithmetic is
+                    // the feature — the strip's height varies with label, font size,
+                    // calendar bands and pill lanes, so no constant is correct.
+                    ...(height !== undefined
+                        ? {
+                            height: `${height}px`,
+                            display: 'flex',
+                            flexDirection: 'column',
+                        }
+                        : {}),
+                }, children: [_jsx("div", { style: {
+                            display: 'flex',
+                            flexDirection: 'column',
+                            gap: `${rowGap}px`,
+                            // The positioned ancestor for overlay chrome (`<Legend>`): the
+                            // card anchors to the rows block, never the axis strip below.
+                            position: 'relative',
+                            // The rows block takes what the axis strip leaves. `minHeight:
+                            // 0` lets it shrink below its content — without it a flex
+                            // child's floor is its content and nothing can ever get
+                            // smaller.
+                            ...(height !== undefined ? { flex: '1 1 0%', minHeight: 0 } : {}),
+                        }, children: children }), showAxis && _jsx(TimeAxis, {})] }) }) }));
 }
 //# sourceMappingURL=ChartContainer.js.map

package/dist/ChartRow.d.ts

@@ -1,5 +1,4 @@
 import { type ReactNode } from 'react';
-import { type CursorMode } from './context.js';
 export interface ChartRowProps {
     /**
      * Row height in CSS pixels — the **fixed** sizing mode. Omit it (or pass
@@ -39,16 +38,6 @@ export interface ChartRowProps {
      * hidden, so a `display: none` tab switch does not discard its scales.
      */
     flex?: number;
-    /**
-     * Cursor presentation for this row, overriding the container's default
-     * ({@link ChartContainerProps.cursor}). Omit to inherit. See {@link CursorMode}.
-     *
-     * @deprecated Mount a cursor component **inside the row** instead
-     * (`<ChartRow><CrosshairCursor /> …</ChartRow>`) — the per-row override with
-     * the same nearest-mount-wins semantics. Works for one more minor; a mounted
-     * cursor in the row overrides this prop.
-     */
-    cursor?: CursorMode;
     children?: ReactNode;
 }
 /**
@@ -68,5 +57,5 @@ export interface ChartRowProps {
  * Children lay out left-to-right in author order, so `<YAxis side="left"/>` goes
  * before `<Layers/>` and `<YAxis side="right"/>` after.
  */
-export declare function ChartRow({ height: heightProp, flex, cursor, children, }: ChartRowProps): import("react/jsx-runtime").JSX.Element;
+export declare function ChartRow({ height: heightProp, flex, children, }: ChartRowProps): import("react/jsx-runtime").JSX.Element;
 //# sourceMappingURL=ChartRow.d.ts.map

package/dist/ChartRow.js

@@ -8,7 +8,6 @@ import { resolveAxisFormat } from './format.js';
 import { resolveYTickCount } from './yticks.js';
 import { placeAxisSlots } from './slots.js';
 import { useSlotKey } from './use-slot-key.js';
-import { LegacyCursor } from './cursors.js';
 import { YAxis } from './YAxis.js';
 import { ContainerContext, RowContext, } from './context.js';
 /**
@@ -139,7 +138,7 @@ const TOP_LABEL_HEADER = 16;
  * Children lay out left-to-right in author order, so `<YAxis side="left"/>` goes
  * before `<Layers/>` and `<YAxis side="right"/>` after.
  */
-export function ChartRow({ height: heightProp, flex, cursor, children, }) {
+export function ChartRow({ height: heightProp, flex, children, }) {
     const container = useContext(ContainerContext);
     if (container === null) {
         throw new Error('<ChartRow> must be rendered inside a <ChartContainer>');
@@ -212,18 +211,6 @@ export function ChartRow({ height: heightProp, flex, cursor, children, }) {
     const { registerRow } = container;
     useEffect(() => registerRow(rowKey), [registerRow, rowKey]);
     const isFirstRow = container.firstRowKey === rowKey;
-    // Deprecation notice for the legacy `cursor` prop (dev, once per row): the
-    // per-row override is now a cursor component mounted inside the row. The
-    // prop keeps working via the shim rendered below.
-    const warnedCursorRef = useRef(false);
-    useEffect(() => {
-        if (!isDev || cursor === undefined || warnedCursorRef.current)
-            return;
-        warnedCursorRef.current = true;
-        console.warn(`[pond-charts] <ChartRow cursor="${cursor}"> is deprecated (it keeps ` +
-            'working this minor, removed next) — mount the cursor component ' +
-            'inside the row instead (docs/rfcs/interaction.md §9).');
-    }, [cursor]);
     // Keyed by a stable per-instance id (Map preserves insertion order; setting an
     // existing key updates in place). So a re-register on a prop change keeps the
     // entry's slot — the axis-default (first axis) and layer z-order stay stable
@@ -378,7 +365,7 @@ export function ChartRow({ height: heightProp, flex, cursor, children, }) {
             const extents = needsExtents(ax)
                 ? layerList
                     .filter((entry) => (entry.axisId ?? defaultAxisId) === ax.id)
-                    .map((entry) => entry.layer.yExtent())
+                    .map((entry) => entry.layer.yExtent(ax.scale))
                 : [];
             const [lo, hi] = resolveYDomain(ax.min, ax.max, extents, ax.pad, ax.scale);
             // Reserve a header band at the top when any axis draws a `'top'` title,
@@ -483,7 +470,7 @@ export function ChartRow({ height: heightProp, flex, cursor, children, }) {
             // about.
             const message = logAxisWarning(ax, layerList
                 .filter((entry) => (entry.axisId ?? defaultAxisId) === ax.id)
-                .map((entry) => entry.layer.yExtent()));
+                .map((entry) => entry.layer.yExtent(ax.scale)));
             if (message === null)
                 warned.delete(ax.id);
             else if (warned.get(ax.id) !== message) {
@@ -626,7 +613,6 @@ export function ChartRow({ height: heightProp, flex, cursor, children, }) {
     const frame = useMemo(() => ({
         height,
         topInset: topHeader,
-        cursor,
         isFirstRow,
         rowKey,
         yScales,
@@ -649,7 +635,6 @@ export function ChartRow({ height: heightProp, flex, cursor, children, }) {
     }), [
         height,
         topHeader,
-        cursor,
         isFirstRow,
         rowKey,
         yScales,
@@ -737,17 +722,17 @@ export function ChartRow({ height: heightProp, flex, cursor, children, }) {
             "wrap the row's <Layers>, leaving each <YAxis> a direct child of the " +
             '<ChartRow>.');
     }, [axisInsideWrapper]);
-    return (_jsxs(RowContext.Provider, { value: frame, children: [cursor !== undefined && (_jsx(LegacyCursor, { mode: cursor, showTime: container.cursorTime, snap: container.crosshairSnap })), _jsxs("div", { ref: boxRef, style: {
-                    display: 'flex',
-                    flexDirection: 'row',
-                    width: `${container.width}px`,
-                    // Fixed rows keep their pixels; a flex row is sized by the
-                    // container's column layout and reads the result back
-                    // ([PND-HEIGHT]). `minHeight: 0` is what lets it actually shrink —
-                    // a flex child's default min-height is its content.
-                    ...(isFlex
-                        ? { flex: `${flexGrow} 1 0%`, minHeight: 0 }
-                        : { height: `${height}px` }),
-                }, children: [leftPad > 0 && _jsx("div", { style: { flex: `0 0 ${leftPad}px` } }), leftAxisEls, plotEls, rightAxisEls, rightPad > 0 && _jsx("div", { style: { flex: `0 0 ${rightPad}px` } })] })] }));
+    return (_jsx(RowContext.Provider, { value: frame, children: _jsxs("div", { ref: boxRef, style: {
+                display: 'flex',
+                flexDirection: 'row',
+                width: `${container.width}px`,
+                // Fixed rows keep their pixels; a flex row is sized by the
+                // container's column layout and reads the result back
+                // ([PND-HEIGHT]). `minHeight: 0` is what lets it actually shrink —
+                // a flex child's default min-height is its content.
+                ...(isFlex
+                    ? { flex: `${flexGrow} 1 0%`, minHeight: 0 }
+                    : { height: `${height}px` }),
+            }, children: [leftPad > 0 && _jsx("div", { style: { flex: `0 0 ${leftPad}px` } }), leftAxisEls, plotEls, rightAxisEls, rightPad > 0 && _jsx("div", { style: { flex: `0 0 ${rightPad}px` } })] }) }));
 }
 //# sourceMappingURL=ChartRow.js.map

package/dist/HeatMap.d.ts

@@ -161,9 +161,9 @@ export interface HeatMapProps<S extends SeriesSchema = SeriesSchema, VS extends
  * theme, and the M5 "theme tokens optional-with-default" gate has to land
  * first. Borrowing defers that decision instead of pre-empting it.
  *
- * **Pair it with `<ChartContainer cursor="none">`.** The container's default is
- * the shared vertical line, and on a grid that is a *second, weaker* cursor
- * competing with the one that already works: the cell under the pointer takes an
+ * **Mount no cursor component with it.** A `<LineCursor>` draws the shared
+ * vertical line, and on a grid that is a *second, weaker* cursor competing
+ * with the one that already works: the cell under the pointer takes an
  * outline, which says both axes at once. The line says only x, and a heat map's
  * x position is rarely the question. The pointer's own crosshair shape plus the
  * cell outline is the whole affordance.

package/dist/HeatMap.js

@@ -61,9 +61,9 @@ function marksOf(set) {
  * theme, and the M5 "theme tokens optional-with-default" gate has to land
  * first. Borrowing defers that decision instead of pre-empting it.
  *
- * **Pair it with `<ChartContainer cursor="none">`.** The container's default is
- * the shared vertical line, and on a grid that is a *second, weaker* cursor
- * competing with the one that already works: the cell under the pointer takes an
+ * **Mount no cursor component with it.** A `<LineCursor>` draws the shared
+ * vertical line, and on a grid that is a *second, weaker* cursor competing
+ * with the one that already works: the cell under the pointer takes an
  * outline, which says both axes at once. The line says only x, and a heat map's
  * x position is rarely the question. The pointer's own crosshair shape plus the
  * cell outline is the whole affordance.