@fundar/data-chart-telling 0.0.64 → 1.1.0

package/dist/layout/scales/niceDomain.js

@@ -1,59 +0,0 @@
-// d3-array-compatible "nice" tick step/generation, reimplemented locally to
-// avoid depending on internals svelteplot itself pulls in (not one of our
-// declared dependencies) — see https://d3js.org/d3-array/ticks.
-/** Step between "nice" (1/2/5×10ⁿ) tick values for an approximate `count` over `[start, stop]`. */
-export function tickStep(start, stop, count) {
-    const e10 = Math.sqrt(50);
-    const e5 = Math.sqrt(10);
-    const e2 = Math.sqrt(2);
-    const step0 = Math.abs(stop - start) / Math.max(0, count);
-    let step1 = 10 ** Math.floor(Math.log10(step0));
-    const error = step0 / step1;
-    if (error >= e10)
-        step1 *= 10;
-    else if (error >= e5)
-        step1 *= 5;
-    else if (error >= e2)
-        step1 *= 2;
-    return step1;
-}
-/** Multiples of `step` covering `[start, stop]`, inclusive of either endpoint when it lands exactly on one. */
-export function ticksInRange(start, stop, step) {
-    if (!(step > 0) || !Number.isFinite(step))
-        return [];
-    const lo = Math.ceil(start / step);
-    const hi = Math.floor(stop / step);
-    const out = [];
-    for (let i = lo; i <= hi; i++)
-        out.push(i * step);
-    return out;
-}
-/** Ticks-per-axis heuristic — used by `ScalesLayout` to pick a target count from an axis's actual pixel span. */
-export function naturalTickCount(span, spacing, min) {
-    return Math.max(min, Math.round(span / spacing));
-}
-/**
- * Widens `[lo, hi]` outward to the nearest `count`-ish "nice" step —
- * equivalent to d3's own `scale.nice(count)`, except a value within
- * `epsilonFraction × step` of a step boundary is treated as already sitting
- * on it, rather than needing a full extra step to clear it.
- *
- * Exists because plain `Math.ceil`/`Math.floor` (what `nice()` uses
- * internally, both here and in d3) has zero tolerance: a value meant to be
- * exactly `100` that comes out `100.00000000000001` after summing several
- * independently-rounded parts (a common shape for "these categories add up
- * to a whole" data, e.g. percentages of a total) still fails `hi <= step*N`
- * and gets rounded up a full step further than the data actually warrants
- * (`100` → `110`, not just a hair past `100`). `epsilonFraction` defaults to
- * 1% of the step — small enough to only catch rounding/summation noise, not
- * data that's genuinely meaningfully past the boundary.
- */
-export function niceDomain(lo, hi, count = 5, epsilonFraction = 0.01) {
-    if (!(hi > lo))
-        return [lo, hi];
-    const step = tickStep(lo, hi, count);
-    const eps = step * epsilonFraction;
-    const niceLo = Math.floor((lo + eps) / step) * step;
-    const niceHi = Math.ceil((hi - eps) / step) * step;
-    return [niceLo, niceHi];
-}

package/dist/layout/tooltip/TooltipLayout.svelte

@@ -1,51 +0,0 @@
-<script lang="ts" generics="TRow extends Record<string, unknown>">
-  import type { Snippet } from 'svelte';
-  import Tooltip from './Tooltip.svelte';
-  import type { TooltipAnchorX, TooltipAnchorY } from '../../types/layout/tooltip';
-
-  /**
-   * The "resolve + render" step every hoverable plot repeats verbatim:
-   * given the matched row(s) for the current hover and the author's
-   * `format`/`content` config, decide what goes inside the floating
-   * `Tooltip` — its own custom snippet (`content`, given every matched row)
-   * or the newline-joined `format` text (the default). Shared by
-   * `BasePlotLayout` (fed by the shared hover controller, used by every plot
-   * kind including `GeoPlot`) and `InsetMarker` (which matches hover locally,
-   * independent of that controller) so neither re-implements this branch.
-   */
-  let {
-    visible,
-    x,
-    y,
-    bounds,
-    rows,
-    format,
-    content,
-    anchorX,
-    anchorY,
-  }: {
-    visible: boolean;
-    x: number;
-    y: number;
-    /** Box the tooltip must stay within — see `Tooltip`'s own `bounds` doc. */
-    bounds: { width: number; height: number };
-    /** Every row the current hover matched — passed to `content` as-is; joined via `format` otherwise. */
-    rows: TRow[];
-    format: (row: TRow) => string;
-    /** Custom tooltip body; replaces the joined `format` text when given. */
-    content?: Snippet<[{ rows: TRow[] }]>;
-    /** Preferred anchor — forwarded to `Tooltip` as-is; `undefined` falls through to its own system default. */
-    anchorX?: TooltipAnchorX;
-    anchorY?: TooltipAnchorY;
-  } = $props();
-</script>
-
-{#if visible}
-  <Tooltip {x} {y} {bounds} plain={!!content} {anchorX} {anchorY}>
-    {#if content}
-      {@render content({ rows })}
-    {:else}
-      {rows.map(format).join('\n')}
-    {/if}
-  </Tooltip>
-{/if}

package/dist/layout/tooltip/TooltipLayout.svelte.d.ts

@@ -1,45 +0,0 @@
-import type { Snippet } from 'svelte';
-import type { TooltipAnchorX, TooltipAnchorY } from '../../types/layout/tooltip';
-declare function $$render<TRow extends Record<string, unknown>>(): {
-    props: {
-        visible: boolean;
-        x: number;
-        y: number;
-        /** Box the tooltip must stay within — see `Tooltip`'s own `bounds` doc. */
-        bounds: {
-            width: number;
-            height: number;
-        };
-        /** Every row the current hover matched — passed to `content` as-is; joined via `format` otherwise. */
-        rows: TRow[];
-        format: (row: TRow) => string;
-        /** Custom tooltip body; replaces the joined `format` text when given. */
-        content?: Snippet<[{
-            rows: TRow[];
-        }]>;
-        /** Preferred anchor — forwarded to `Tooltip` as-is; `undefined` falls through to its own system default. */
-        anchorX?: TooltipAnchorX;
-        anchorY?: TooltipAnchorY;
-    };
-    exports: {};
-    bindings: "";
-    slots: {};
-    events: {};
-};
-declare class __sveltets_Render<TRow extends Record<string, unknown>> {
-    props(): ReturnType<typeof $$render<TRow>>['props'];
-    events(): ReturnType<typeof $$render<TRow>>['events'];
-    slots(): ReturnType<typeof $$render<TRow>>['slots'];
-    bindings(): "";
-    exports(): {};
-}
-interface $$IsomorphicComponent {
-    new <TRow extends Record<string, unknown>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TRow>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TRow>['props']>, ReturnType<__sveltets_Render<TRow>['events']>, ReturnType<__sveltets_Render<TRow>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<TRow>['bindings']>;
-    } & ReturnType<__sveltets_Render<TRow>['exports']>;
-    <TRow extends Record<string, unknown>>(internal: unknown, props: ReturnType<__sveltets_Render<TRow>['props']> & {}): ReturnType<__sveltets_Render<TRow>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
-}
-declare const TooltipLayout: $$IsomorphicComponent;
-type TooltipLayout<TRow extends Record<string, unknown>> = InstanceType<typeof TooltipLayout<TRow>>;
-export default TooltipLayout;

package/dist/layout/tooltip/controller.svelte.d.ts

@@ -1,61 +0,0 @@
-import type { HoverStore, HoverPoint } from '../../types/layout/tooltip';
-import type { AxisValue } from '../../types/layout/scales';
-/** Return type of {@link createHoverController}. */
-export type HoverController<T extends Record<string, unknown>> = ReturnType<typeof createHoverController<T>>;
-/**
- * The plot-agnostic hover state machine shared by every plot. Given reactive
- * accessors for the current hover store, this facet's id, and the local points,
- * it produces everything a plot needs to render: the highlight points, the
- * crosshair rule positions, and the floating-tooltip state — plus the event
- * handlers that feed (and broadcast to) the shared store.
- *
- * Kept generic so line / bar / heatmap reuse it unchanged; only the points and
- * accessors they pass in differ.
- */
-export declare function createHoverController<T extends Record<string, unknown>>(args: {
-    hover: () => HoverStore;
-    facetId: () => string;
-    points: () => HoverPoint<T>[];
-    getX: () => (d: T) => AxisValue;
-    getY: () => (d: T) => AxisValue;
-    /** Short label drawn next to the highlight dot (e.g. the value). */
-    label: () => (row: T) => string;
-    /** Named subset of series the tooltip text/content should be limited to. */
-    seriesFilter?: () => string[] | undefined;
-    /** This facet's own box, used to convert the cursor to/from a sync-broadcast fraction. */
-    width: () => number;
-    height: () => number;
-    /** Forces the crosshair rule(s) off entirely — see {@link import('../../types/plots/props').HoverConfig.crosshair}. */
-    crosshair?: () => boolean | undefined;
-}): {
-    onPointer: (data: T[]) => void;
-    onMove: (e: PointerEvent) => void;
-    onLeave: () => void;
-    reportActivePointPixel(pos: {
-        x: number;
-        y: number;
-    } | null): void;
-    readonly points: {
-        x: AxisValue;
-        y: AxisValue;
-        label: string;
-        series: string | undefined;
-        color: string | undefined;
-        dx: number | undefined;
-        dy: number | undefined;
-        row: T;
-    }[];
-    readonly matchedRows: HoverPoint<T>[];
-    readonly activePoint: HoverPoint<T> | null;
-    readonly impliesCrosshairX: boolean;
-    readonly impliesCrosshairY: boolean;
-    readonly showTooltip: boolean;
-    readonly tooltipPosition: {
-        x: number;
-        y: number;
-    } | null;
-    readonly cursor: {
-        x: number;
-        y: number;
-    } | null;
-};

package/dist/layout/tooltip/controller.svelte.js

@@ -1,173 +0,0 @@
-import { eq, matchByStrategy, impliesCrosshairX, impliesCrosshairY, filterBySeries } from './utils';
-/**
- * The plot-agnostic hover state machine shared by every plot. Given reactive
- * accessors for the current hover store, this facet's id, and the local points,
- * it produces everything a plot needs to render: the highlight points, the
- * crosshair rule positions, and the floating-tooltip state — plus the event
- * handlers that feed (and broadcast to) the shared store.
- *
- * Kept generic so line / bar / heatmap reuse it unchanged; only the points and
- * accessors they pass in differ.
- */
-export function createHoverController(args) {
-    let cursor = $state(null);
-    // This facet's own `activePoint`, as a pixel position reported by `HoverMarker`.
-    let activePointPixel = $state(null);
-    // Finds the matching hoverPoint for a hit row — by identity first, then
-    // by x/y value (for svelteplot's `Pointer`, which hands back clones).
-    const pointForRow = (row) => {
-        const byIdentity = args.points().find((p) => p.row === row);
-        if (byIdentity)
-            return byIdentity;
-        const x = args.getX()(row);
-        const y = args.getY()(row);
-        return args.points().find((p) => eq(p.x, x) && eq(p.y, y));
-    };
-    // Points matched in THIS facet. Non-source facets only react when sync is
-    // enabled. The strategy in the shared store determines how points are found.
-    const matched = $derived.by(() => {
-        const h = args.hover();
-        const isSource = h.source === args.facetId();
-        if (!isSource && !h.sync)
-            return [];
-        return matchByStrategy(args.points(), h);
-    });
-    const matchedRows = $derived(filterBySeries(matched, args.seriesFilter?.()));
-    // Points highlighted in THIS facet for the in-SVG marker — no series
-    // filtering, since that's the tooltip text's concern, not the marker's.
-    // Keeps `row` (not just the display fields) so plot-kind templates can
-    // resolve a semantic value off the source row directly — e.g. a bar
-    // plot's category, regardless of which visual axis it's drawn on.
-    const highlight = $derived(matched.map(({ x, y, label, series, color, dx, dy, row }) => ({
-        x,
-        y,
-        label,
-        series,
-        color,
-        dx,
-        dy,
-        row
-    })));
-    /**
-     * The specific matched point that was actually hovered — found by the
-     * shared store's `activeSeries` (set from whichever row was hit), falling
-     * back to the first match when there's no series concept (punctual
-     * matches) or nothing tags a series. Consumers read `.x`/`.y` off this
-     * for the crosshair rule position — every point in `matched` already
-     * shares the "implied" axis's value by construction of `matchByStrategy`,
-     * and picking the actively-hovered one is what makes forcing a rule on
-     * the *other* axis (e.g. `ruleY: true` under an `'x'`-strategy chart)
-     * point at the row under the cursor rather than an arbitrary matched
-     * sibling. `BasePlotLayout` gates actual display with
-     * `impliesCrosshairX`/`Y` + the marker's own `ruleX`/`ruleY` props.
-     *
-     * `activeSeries` alone can't disambiguate two matched rows that share the
-     * same (or absent) series tag — e.g. an ungrouped bar/line chart where two
-     * categories tie on the matched axis value. `onPointer` sets `activeX`/
-     * `activeY` straight from the hit row, so when more than one series-tied
-     * candidate remains, narrowing to the one whose own x/y equals the hit
-     * row's picks the actual row under the cursor instead of an arbitrary tie.
-     */
-    const activePoint = $derived.by(() => {
-        if (matched.length === 0)
-            return null;
-        const h = args.hover();
-        const bySeries = matched.filter((p) => p.series === h.activeSeries);
-        const candidates = bySeries.length > 0 ? bySeries : matched;
-        if (candidates.length === 1)
-            return candidates[0];
-        const { activeX, activeY } = h;
-        if (activeX == null || activeY == null)
-            return candidates[0];
-        return candidates.find((p) => eq(p.x, activeX) && eq(p.y, activeY)) ?? candidates[0];
-    });
-    // Whether the current strategy implies a crosshair rule on each axis, unless `crosshair: false`.
-    const _impliesCrosshairX = $derived(args.crosshair?.() === false ? false : impliesCrosshairX(args.hover().strategy));
-    const _impliesCrosshairY = $derived(args.crosshair?.() === false ? false : impliesCrosshairY(args.hover().strategy));
-    const showTooltip = $derived.by(() => {
-        if (matchedRows.length === 0)
-            return false;
-        const h = args.hover();
-        if (h.source === args.facetId())
-            return cursor != null;
-        return h.sync;
-    });
-    function onPointer(data) {
-        const h = args.hover();
-        if (data.length) {
-            const point = pointForRow(data[0]);
-            h.activeX = point?.x ?? args.getX()(data[0]);
-            h.activeY = point?.y ?? args.getY()(data[0]);
-            h.activeSeries = point?.series ?? null;
-            h.source = args.facetId();
-        }
-        else if (h.source === args.facetId()) {
-            h.activeX = null;
-            h.activeY = null;
-            h.activeSeries = null;
-            h.source = null;
-        }
-    }
-    function onMove(e) {
-        const rect = e.currentTarget.getBoundingClientRect();
-        const x = e.clientX - rect.left;
-        const y = e.clientY - rect.top;
-        cursor = { x, y };
-        const w = args.width();
-        const h = args.height();
-        if (w > 0 && h > 0)
-            args.hover().cursorFrac = { x: x / w, y: y / h };
-    }
-    function onLeave() {
-        cursor = null;
-        const h = args.hover();
-        if (h.source === args.facetId()) {
-            h.activeX = null;
-            h.activeY = null;
-            h.activeSeries = null;
-            h.cursorFrac = null;
-            h.source = null;
-        }
-    }
-    /** This facet's tooltip position: the cursor, else `activePointPixel`, else the source facet's cursor fraction reprojected onto this box. */
-    const tooltipPosition = $derived.by(() => {
-        if (cursor)
-            return cursor;
-        if (activePointPixel)
-            return activePointPixel;
-        const frac = args.hover().cursorFrac;
-        return frac ? { x: frac.x * args.width(), y: frac.y * args.height() } : null;
-    });
-    return {
-        onPointer,
-        onMove,
-        onLeave,
-        reportActivePointPixel(pos) {
-            activePointPixel = pos;
-        },
-        get points() {
-            return highlight;
-        },
-        get matchedRows() {
-            return matchedRows;
-        },
-        get activePoint() {
-            return activePoint;
-        },
-        get impliesCrosshairX() {
-            return _impliesCrosshairX;
-        },
-        get impliesCrosshairY() {
-            return _impliesCrosshairY;
-        },
-        get showTooltip() {
-            return showTooltip;
-        },
-        get tooltipPosition() {
-            return tooltipPosition;
-        },
-        get cursor() {
-            return cursor;
-        }
-    };
-}

package/dist/layout/tooltip/hover.svelte.d.ts

@@ -1,7 +0,0 @@
-import type { HoverStore } from '../../types/layout/tooltip';
-/** Create + register the shared hover store. Call during component init. */
-export declare function provideHover(): HoverStore;
-/** Read the shared hover store, or `null` when there is no provider. */
-export declare function getHover(): HoverStore | null;
-/** A private hover store for a plot used outside of a {@link BaseChart}. */
-export declare function createHover(): HoverStore;

package/dist/layout/tooltip/hover.svelte.js

@@ -1,28 +0,0 @@
-import { getContext, setContext } from 'svelte';
-const HOVER_KEY = Symbol('dct-hover');
-function blank() {
-    return {
-        activeX: null,
-        activeY: null,
-        activeSeries: null,
-        cursorFrac: null,
-        source: null,
-        strategy: 'x',
-        sync: false,
-    };
-}
-/** Create + register the shared hover store. Call during component init. */
-export function provideHover() {
-    const store = $state(blank());
-    setContext(HOVER_KEY, store);
-    return store;
-}
-/** Read the shared hover store, or `null` when there is no provider. */
-export function getHover() {
-    return getContext(HOVER_KEY) ?? null;
-}
-/** A private hover store for a plot used outside of a {@link BaseChart}. */
-export function createHover() {
-    const store = $state(blank());
-    return store;
-}

package/dist/layout/tooltip/resolveTooltipPlacement.d.ts

@@ -1,24 +0,0 @@
-import type { TooltipAnchorX, TooltipAnchorY } from '../../types/layout/tooltip';
-/**
- * Resolves a floating tooltip's top-left pixel position relative to a cursor
- * point, honoring a preferred anchor per axis and falling back toward the
- * opposite side (via the centered position) when the preferred side would
- * push it past `bounds`. Used by `Tooltip.svelte` for both the default box
- * and any custom `content` snippet — both go through the same placement.
- */
-export declare function resolveTooltipPlacement(args: {
-    x: number;
-    y: number;
-    boxWidth: number;
-    boxHeight: number;
-    /** Box the tooltip must stay within — usually the hosting plot's width/height. */
-    bounds?: {
-        width: number;
-        height: number;
-    };
-    anchorX: TooltipAnchorX;
-    anchorY: TooltipAnchorY;
-}): {
-    left: number;
-    top: number;
-};

package/dist/layout/tooltip/resolveTooltipPlacement.js

@@ -1,49 +0,0 @@
-const GAP = 10;
-const EDGE_MARGIN = 6;
-/** Anchors tried in order for a given preference — the opposite side is always the last resort. */
-function candidateOrder(anchor) {
-    if (anchor === 'before')
-        return ['before', 'middle', 'after'];
-    if (anchor === 'after')
-        return ['after', 'middle', 'before'];
-    return ['middle'];
-}
-function axisStart(anchor, pos, size) {
-    if (anchor === 'before')
-        return pos - GAP - size;
-    if (anchor === 'after')
-        return pos + GAP;
-    return pos - size / 2;
-}
-function fits(start, size, boundsSize) {
-    return start >= EDGE_MARGIN && start + size <= boundsSize - EDGE_MARGIN;
-}
-/** Resolves one axis: tries the preferred anchor, then its fallbacks in order, then clamps as a last resort. */
-function resolveAxis(pos, size, boundsSize, anchor) {
-    const order = candidateOrder(anchor);
-    for (const candidate of order) {
-        const start = axisStart(candidate, pos, size);
-        if (fits(start, size, boundsSize))
-            return start;
-    }
-    const fallbackStart = axisStart(order[order.length - 1], pos, size);
-    const maxStart = Math.max(EDGE_MARGIN, boundsSize - size - EDGE_MARGIN);
-    return Math.min(Math.max(fallbackStart, EDGE_MARGIN), maxStart);
-}
-/**
- * Resolves a floating tooltip's top-left pixel position relative to a cursor
- * point, honoring a preferred anchor per axis and falling back toward the
- * opposite side (via the centered position) when the preferred side would
- * push it past `bounds`. Used by `Tooltip.svelte` for both the default box
- * and any custom `content` snippet — both go through the same placement.
- */
-export function resolveTooltipPlacement(args) {
-    const boundsWidth = args.bounds?.width ?? Infinity;
-    const boundsHeight = args.bounds?.height ?? Infinity;
-    const xAnchor = args.anchorX === 'right' ? 'after' : args.anchorX === 'left' ? 'before' : 'middle';
-    const yAnchor = args.anchorY === 'bottom' ? 'after' : args.anchorY === 'top' ? 'before' : 'middle';
-    return {
-        left: resolveAxis(args.x, args.boxWidth, boundsWidth, xAnchor),
-        top: resolveAxis(args.y, args.boxHeight, boundsHeight, yAnchor),
-    };
-}

package/dist/layout/tooltip/utils.d.ts

@@ -1,49 +0,0 @@
-import type { AxisValue } from '../../types/layout/scales';
-import type { HoverStore, HoverStrategy, HoverPoint, TooltipProp, TooltipOptions, TooltipAnchorX, TooltipAnchorY } from '../../types/layout/tooltip';
-/** Value equality that also handles `Date` (compared by timestamp). */
-export declare function eq(a: AxisValue, b: AxisValue): boolean;
-/**
- * Given the shared hover state, return the local points that should be
- * highlighted using the store's current strategy.
- */
-export declare function matchByStrategy<T>(points: HoverPoint<T>[], hover: HoverStore): HoverPoint<T>[];
-/** Whether the strategy implies an x crosshair rule by default. */
-export declare function impliesCrosshairX(strategy: HoverStrategy): boolean;
-/** Whether the strategy implies a y crosshair rule by default. */
-export declare function impliesCrosshairY(strategy: HoverStrategy): boolean;
-/** Normalize the author-facing prop into a resolved object. */
-export declare function resolveTooltip<TRow extends Record<string, unknown>>(tooltip: TooltipProp<TRow> | undefined, defaultStrategy: HoverStrategy): {
-    enabled: boolean;
-    strategy: HoverStrategy;
-    sync: boolean;
-    format?: (row: TRow) => string;
-    series?: string[];
-    content?: TooltipOptions<TRow>['content'];
-    anchorX?: TooltipAnchorX;
-    anchorY?: TooltipAnchorY;
-};
-/**
- * Resolve the strategy that should drive the shared hover store: the
- * tooltip's own `strategy` wins, else the first hover marker's `strategy`,
- * else the chart kind's default. Generic over the caller's own marker union,
- * like {@link findHoverMarker}.
- */
-export declare function resolveHoverStrategy<T extends {
-    type: string;
-}>(tooltipStrategy: HoverStrategy | undefined, markers: T[] | undefined, defaultStrategy: HoverStrategy): HoverStrategy;
-/** Resolve whether the hover should be broadcast across facets. Generic — see {@link resolveHoverStrategy}. */
-export declare function resolveHoverSync<T extends {
-    type: string;
-}>(tooltipSync: boolean | undefined, markers: T[] | undefined): boolean;
-/** Whether any marker in the list is a hover marker — axis-based (`'hover'`) or geo (`'geo-hover'`). */
-export declare function hasHoverMarker(markers: {
-    type: string;
-}[] | undefined): boolean;
-/** First hover marker in the list, if any — generic over the caller's own marker union. */
-export declare function findHoverMarker<T extends {
-    type: string;
-}>(markers: T[] | undefined): Extract<T, {
-    type: 'hover';
-}> | undefined;
-/** Narrow matched points down to a named subset of series (no-op if `series` is empty/undefined). */
-export declare function filterBySeries<T>(points: HoverPoint<T>[], series?: string[]): HoverPoint<T>[];

package/dist/layout/tooltip/utils.js

@@ -1,82 +0,0 @@
-/** Value equality that also handles `Date` (compared by timestamp). */
-export function eq(a, b) {
-    if (a instanceof Date && b instanceof Date)
-        return +a === +b;
-    return a === b;
-}
-/**
- * Given the shared hover state, return the local points that should be
- * highlighted using the store's current strategy.
- */
-export function matchByStrategy(points, hover) {
-    const { strategy, activeX, activeY, activeSeries } = hover;
-    if (strategy === 'x') {
-        return activeX == null ? [] : points.filter((p) => eq(p.x, activeX));
-    }
-    if (strategy === 'y') {
-        return activeY == null ? [] : points.filter((p) => eq(p.y, activeY));
-    }
-    if (strategy === 'series') {
-        return activeSeries == null ? [] : points.filter((p) => p.series === activeSeries);
-    }
-    // 'punctual': exact XY match, respecting series identity when both sides carry it
-    if (activeX == null || activeY == null)
-        return [];
-    return points.filter((p) => eq(p.x, activeX) &&
-        eq(p.y, activeY) &&
-        (activeSeries == null || p.series == null || p.series === activeSeries));
-}
-/** Whether the strategy implies an x crosshair rule by default. */
-export function impliesCrosshairX(strategy) {
-    return strategy === 'x' || strategy === 'punctual';
-}
-/** Whether the strategy implies a y crosshair rule by default. */
-export function impliesCrosshairY(strategy) {
-    return strategy === 'y' || strategy === 'punctual';
-}
-/** Normalize the author-facing prop into a resolved object. */
-export function resolveTooltip(tooltip, defaultStrategy) {
-    if (!tooltip)
-        return { enabled: false, strategy: defaultStrategy, sync: false };
-    if (tooltip === true)
-        return { enabled: true, strategy: defaultStrategy, sync: false };
-    return {
-        enabled: true,
-        strategy: tooltip.strategy ?? defaultStrategy,
-        sync: tooltip.sync ?? false,
-        format: tooltip.format,
-        series: tooltip.series,
-        content: tooltip.content,
-        anchorX: tooltip.anchorX,
-        anchorY: tooltip.anchorY,
-    };
-}
-/**
- * Resolve the strategy that should drive the shared hover store: the
- * tooltip's own `strategy` wins, else the first hover marker's `strategy`,
- * else the chart kind's default. Generic over the caller's own marker union,
- * like {@link findHoverMarker}.
- */
-export function resolveHoverStrategy(tooltipStrategy, markers, defaultStrategy) {
-    const marker = findHoverMarker(markers);
-    return tooltipStrategy ?? marker?.strategy ?? defaultStrategy;
-}
-/** Resolve whether the hover should be broadcast across facets. Generic — see {@link resolveHoverStrategy}. */
-export function resolveHoverSync(tooltipSync, markers) {
-    const marker = findHoverMarker(markers);
-    return tooltipSync ?? marker?.sync ?? false;
-}
-/** Whether any marker in the list is a hover marker — axis-based (`'hover'`) or geo (`'geo-hover'`). */
-export function hasHoverMarker(markers) {
-    return (markers ?? []).some((m) => m.type === 'hover' || m.type === 'geo-hover');
-}
-/** First hover marker in the list, if any — generic over the caller's own marker union. */
-export function findHoverMarker(markers) {
-    return (markers ?? []).find((m) => m.type === 'hover');
-}
-/** Narrow matched points down to a named subset of series (no-op if `series` is empty/undefined). */
-export function filterBySeries(points, series) {
-    if (!series || series.length === 0)
-        return points;
-    return points.filter((p) => p.series != null && series.includes(p.series));
-}

package/dist/markers/CellMarker.svelte

@@ -1,21 +0,0 @@
-<script lang="ts">
-  import { Cell } from 'svelteplot';
-  import type { CellMarkerConfig } from '../types/markers/common';
-
-  /** Renders one `'cell'` marker as a `<Cell>` call. */
-  let { marker }: { marker: CellMarkerConfig } = $props();
-</script>
-
-<Cell
-  data={marker.data}
-  x={marker.x}
-  y={marker.y}
-  fill={marker.fill}
-  fillOpacity={marker.style?.fillOpacity ?? 1}
-  stroke={marker.style?.stroke}
-  strokeWidth={marker.style?.strokeWidth ?? 0}
-  strokeOpacity={marker.style?.strokeOpacity}
-  strokeDasharray={marker.style?.strokeDasharray}
-  borderRadius={marker.style?.borderRadius}
-  inset={marker.inset ?? 0.5}
-/>