@fundar/data-chart-telling 0.0.63 → 1.0.0

package/dist/plots/bar/ValueLabels.svelte.d.ts

@@ -1,58 +0,0 @@
-import type { Series } from '../../types/plots/data/common';
-import type { ValuesStyle } from '../../types/layout/styles';
-import type { ValueAnchor } from '../../types/plots/constants';
-import type { BarSegmentStyle } from '../../types/plots/segments/common';
-import type { VisualGroup } from '../../types/plots/segments/config';
-import type { LegendDisabledStyle } from '../../types/layout/legend';
-import type { MarginOverflow } from '../utils/labelOverflow.svelte';
-import type { BarLayout } from './layout.svelte';
-declare function $$render<TData extends Record<string, unknown>>(): {
-    props: {
-        group: VisualGroup<Series<TData>, BarSegmentStyle>;
-        seriesIndex: number;
-        barLayout: BarLayout<TData>;
-        isHorizontal: boolean;
-        valAnchor: ValueAnchor;
-        formatValue: (value: number, seriesName: string) => string;
-        values: ValuesStyle | undefined;
-        axisColor: string;
-        /** Resolved legend/hover-isolate dimming style for this group's series, if any. */
-        disabled?: LegendDisabledStyle;
-        /** The plot's own pixel size — together with `numericMargins`, the ground truth for its content box (see `bounds()` below). */
-        width: number;
-        height: number;
-        /** `BasePlotLayout`'s resolved margins, already numeric on every side. */
-        numericMargins: {
-            top: number;
-            right: number;
-            bottom: number;
-            left: number;
-        };
-        /** Fired when the pointer enters this series' label — only wired when hover-isolate is enabled. */
-        onHoverSeries?: () => void;
-        onHoverEnd?: () => void;
-        /** Reports how far this label overflows the plot's own content box, in pixels, on each side (0 = no overflow). */
-        onOverflow?: (overflow: MarginOverflow) => void;
-    };
-    exports: {};
-    bindings: "";
-    slots: {};
-    events: {};
-};
-declare class __sveltets_Render<TData extends Record<string, unknown>> {
-    props(): ReturnType<typeof $$render<TData>>['props'];
-    events(): ReturnType<typeof $$render<TData>>['events'];
-    slots(): ReturnType<typeof $$render<TData>>['slots'];
-    bindings(): "";
-    exports(): {};
-}
-interface $$IsomorphicComponent {
-    new <TData extends Record<string, unknown>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TData>['props']>, ReturnType<__sveltets_Render<TData>['events']>, ReturnType<__sveltets_Render<TData>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<TData>['bindings']>;
-    } & ReturnType<__sveltets_Render<TData>['exports']>;
-    <TData extends Record<string, unknown>>(internal: unknown, props: ReturnType<__sveltets_Render<TData>['props']> & {}): ReturnType<__sveltets_Render<TData>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
-}
-declare const ValueLabels: $$IsomorphicComponent;
-type ValueLabels<TData extends Record<string, unknown>> = InstanceType<typeof ValueLabels<TData>>;
-export default ValueLabels;

package/dist/plots/bar/buildBarMarkers.d.ts

@@ -1,27 +0,0 @@
-import type { Series } from '../../types/plots/data/common';
-import type { BarSegmentStyle } from '../../types/plots/segments/common';
-import type { VisualGroup } from '../../types/plots/segments/config';
-import type { HoverPoint } from '../../types/layout/tooltip';
-import type { BarMarkerConfig } from '../../types/markers/common';
-import type { BarLayout } from './layout.svelte';
-import type { DiscreteGapFill } from '../utils/gaps';
-/**
- * Every `'bar'` marker for one BarPlot render: visible `role: 'segment'`
- * bars (real data + gap fills) plus one `role: 'hitArea'` hit region per row,
- * sized to that row's own segment.
- */
-export declare function buildBarMarkers<TData extends Record<string, unknown>>(args: {
-    groupedSeries: VisualGroup<Series<TData>, BarSegmentStyle>[];
-    barLayout: BarLayout<TData>;
-    isHorizontal: boolean;
-    hoverPoints: HoverPoint<TData>[];
-    colorFor: (seriesName: string) => string;
-    disabledFillFor: (seriesName: string) => {
-        fill?: string;
-        fillOpacity?: number;
-    } | undefined;
-    active: boolean;
-    setHoverMatch: (rows: TData[]) => void;
-    clearHoverMatch: () => void;
-    gapFillMaps: Map<string, Map<TData, DiscreteGapFill<BarSegmentStyle>>>;
-}): BarMarkerConfig[];

package/dist/plots/bar/buildBarMarkers.js

@@ -1,151 +0,0 @@
-import { resolveAccessor } from '../utils/accessors';
-import { getConfiguration } from '../../configuration/config.svelte';
-import { isGapValue, resolveGapAreaStyle } from '../utils/gaps';
-const GAP_KINDS = ['start', 'middle', 'end'];
-/**
- * Every `'bar'` marker for one BarPlot render: visible `role: 'segment'`
- * bars (real data + gap fills) plus one `role: 'hitArea'` hit region per row,
- * sized to that row's own segment.
- */
-export function buildBarMarkers(args) {
-    const { groupedSeries, barLayout, isHorizontal, hoverPoints, colorFor, disabledFillFor, active, setHoverMatch, clearHoverMatch, gapFillMaps } = args;
-    const gapDefaults = getConfiguration().bar.gap;
-    // Series names eligible for hover (excludes legend-disabled ones).
-    const hoverEligibleSeries = new Set(hoverPoints.map((p) => p.series));
-    const segmentMarkers = [];
-    const hitAreaMarkers = [];
-    groupedSeries.forEach((group, seriesIndex) => {
-        const xFn = resolveAccessor(group.series.x);
-        const yFn = resolveAccessor(group.series.y);
-        const defaultColor = colorFor(group.series.name);
-        const disabledFill = disabledFillFor(group.series.name);
-        // Builds one series' visible bar geometry (real or gap-fill data).
-        function makeMarker(data, valueFn, style) {
-            if (data.length === 0)
-                return null;
-            const marker = { type: 'bar', role: 'segment', isHorizontal, data, style };
-            if (barLayout.layout === 'stacked') {
-                const baselineFn = (d) => barLayout.stackedBaseline(xFn(d), seriesIndex);
-                const topFn = (d) => baselineFn(d) + valueFn(d);
-                if (isHorizontal) {
-                    marker.y = xFn;
-                    marker.x1 = baselineFn;
-                    marker.x2 = topFn;
-                }
-                else {
-                    marker.x = xFn;
-                    marker.y1 = baselineFn;
-                    marker.y2 = topFn;
-                }
-            }
-            else {
-                if (isHorizontal) {
-                    marker.y = xFn;
-                    marker.x1 = barLayout.valueBaseline;
-                    marker.x2 = valueFn;
-                }
-                else {
-                    marker.x = xFn;
-                    marker.y1 = barLayout.valueBaseline;
-                    marker.y2 = valueFn;
-                }
-                if (barLayout.layout === 'grouped') {
-                    const { start, end } = barLayout.groupInsetFraction(seriesIndex);
-                    if (isHorizontal) {
-                        marker.insetTop = start;
-                        marker.insetBottom = end;
-                    }
-                    else {
-                        marker.insetLeft = start;
-                        marker.insetRight = end;
-                    }
-                }
-            }
-            return marker;
-        }
-        // Builds one row's hit-test geometry — same shape as `makeMarker`, for one row.
-        function makeHitAreaMarker(d, valueFn) {
-            const marker = {
-                type: 'bar',
-                role: 'hitArea',
-                isHorizontal,
-                data: [d],
-                category: xFn(d)
-            };
-            if (barLayout.layout === 'stacked') {
-                const baseline = barLayout.stackedBaseline(xFn(d), seriesIndex);
-                const top = baseline + valueFn(d);
-                if (isHorizontal) {
-                    marker.x1 = baseline;
-                    marker.x2 = top;
-                }
-                else {
-                    marker.y1 = baseline;
-                    marker.y2 = top;
-                }
-            }
-            else {
-                if (isHorizontal) {
-                    marker.x1 = barLayout.valueBaseline;
-                    marker.x2 = valueFn(d);
-                }
-                else {
-                    marker.y1 = barLayout.valueBaseline;
-                    marker.y2 = valueFn(d);
-                }
-                if (barLayout.layout === 'grouped') {
-                    const { start, end } = barLayout.groupInsetFraction(seriesIndex);
-                    if (isHorizontal) {
-                        marker.insetTop = start;
-                        marker.insetBottom = end;
-                    }
-                    else {
-                        marker.insetLeft = start;
-                        marker.insetRight = end;
-                    }
-                }
-            }
-            return marker;
-        }
-        for (const seg of group.visualSegments) {
-            const realData = seg.data.filter((d) => !isGapValue(yFn(d)));
-            const style = {
-                fill: disabledFill?.fill ?? seg.style.fill ?? defaultColor,
-                fillOpacity: disabledFill?.fillOpacity ?? seg.style.fillOpacity ?? 1
-            };
-            const valueFn = barLayout.layout === 'stacked' ? (d) => Number(yFn(d)) : yFn;
-            const marker = makeMarker(realData, valueFn, style);
-            if (marker)
-                segmentMarkers.push(marker);
-            if (hoverEligibleSeries.has(group.series.name)) {
-                for (const d of realData) {
-                    const hitMarker = makeHitAreaMarker(d, valueFn);
-                    hitMarker.onpointerenter = active ? () => setHoverMatch([d]) : undefined;
-                    hitMarker.onpointerleave = active ? clearHoverMatch : undefined;
-                    hitAreaMarkers.push(hitMarker);
-                }
-            }
-        }
-        const fillMap = gapFillMaps.get(group.series.name) ?? new Map();
-        for (const kind of GAP_KINDS) {
-            const filledRows = group.series.data.filter((d) => fillMap.get(d)?.kind === kind);
-            if (filledRows.length === 0)
-                continue;
-            const base = resolveGapAreaStyle(fillMap.get(filledRows[0]).style, defaultColor, gapDefaults);
-            const gapStyle = {
-                ...base,
-                fill: disabledFill?.fill ?? base.fill,
-                fillOpacity: disabledFill?.fillOpacity ?? base.fillOpacity
-            };
-            // Tags each row with its resolved gap-fill value as a plain field.
-            const taggedData = filledRows.map((d) => ({
-                ...d,
-                __gapValue: fillMap.get(d).value
-            }));
-            const marker = makeMarker(taggedData, (d) => d.__gapValue, gapStyle);
-            if (marker)
-                segmentMarkers.push(marker);
-        }
-    });
-    return [...segmentMarkers, ...hitAreaMarkers];
-}

package/dist/plots/bar/hoverPoints.d.ts

@@ -1,15 +0,0 @@
-import type { Series } from '../../types/plots/data/common';
-import type { HoverPoint } from '../../types/layout/tooltip';
-import type { BarLayout } from './layout.svelte';
-/**
- * Builds hover-marker candidate points for every row across every series.
- *
- * `x`/`y` (the values matching is keyed off) stay the raw category/value so
- * every series at the same category still matches together under the 'x'
- * strategy; `dx`/`dy` only nudge where the matched point is *drawn* — see
- * {@link import('../../types/layout/tooltip').HoverDisplayPoint}. For
- * 'stacked' layout, `value` itself is adjusted to the series' cumulative
- * height instead of `dx`/`dy`, since that offset is representable as a
- * regular data value (unlike 'grouped''s pixel-only slice offset).
- */
-export declare function buildHoverPoints<TData extends Record<string, unknown>>(resolvedSeries: Series<TData>[], isHorizontal: boolean, geometry: Pick<BarLayout<TData>, 'layout' | 'stackedBaseline' | 'groupOffset' | 'groupInsetFraction'>, colorFor: (seriesName: string) => string): HoverPoint<TData>[];

package/dist/plots/bar/hoverPoints.js

@@ -1,37 +0,0 @@
-import { resolveAccessor } from '../utils/accessors';
-import { isGapValue } from '../utils/gaps';
-/**
- * Builds hover-marker candidate points for every row across every series.
- *
- * `x`/`y` (the values matching is keyed off) stay the raw category/value so
- * every series at the same category still matches together under the 'x'
- * strategy; `dx`/`dy` only nudge where the matched point is *drawn* — see
- * {@link import('../../types/layout/tooltip').HoverDisplayPoint}. For
- * 'stacked' layout, `value` itself is adjusted to the series' cumulative
- * height instead of `dx`/`dy`, since that offset is representable as a
- * regular data value (unlike 'grouped''s pixel-only slice offset).
- */
-export function buildHoverPoints(resolvedSeries, isHorizontal, geometry, colorFor) {
-    return resolvedSeries.flatMap((s, idx) => {
-        const sx = resolveAccessor(s.x);
-        const sy = resolveAccessor(s.y);
-        const areaInset = geometry.layout === 'grouped' ? geometry.groupInsetFraction(idx) : undefined;
-        return s.data.filter((d) => !isGapValue(sy(d))).map((d) => {
-            const category = sx(d);
-            const rawValue = Number(sy(d));
-            const value = geometry.layout === 'stacked' ? geometry.stackedBaseline(category, idx) + rawValue : rawValue;
-            const { dx, dy } = geometry.groupOffset(idx);
-            return {
-                x: isHorizontal ? value : category,
-                y: isHorizontal ? category : value,
-                dx,
-                dy,
-                areaInset,
-                row: d,
-                label: String(sy(d)),
-                series: s.name,
-                color: colorFor(s.name),
-            };
-        });
-    });
-}

package/dist/plots/bar/layout.svelte.d.ts

@@ -1,42 +0,0 @@
-import type { AxisValue, AxisBasedScalesConfig } from '../../types/layout/scales';
-import type { Series } from '../../types/plots/data/common';
-import type { BarSegmentStyle } from '../../types/plots/segments/common';
-import type { VisualGroup } from '../../types/plots/segments/config';
-import type { MarginConfig } from '../../types/plots/props';
-import type { DiscreteGapFill } from '../utils/gaps';
-export type BarSeriesLayout = 'overlap' | 'grouped' | 'stacked';
-/**
- * Reactive geometry for BarPlot's series-layout modes — the single source of
- * truth for "where does series N's bar actually sit," shared by bar-segment
- * rendering, value labels, and hover markers. Centralized here after a bug
- * where hover markers reproduced (and initially missed) the same grouped/
- * stacked math value labels already accounted for.
- */
-export declare function createBarLayout<TData extends Record<string, unknown>>(args: {
-    scales: () => AxisBasedScalesConfig<TData>;
-    isHorizontal: () => boolean;
-    width: () => number;
-    height: () => number;
-    margins: () => MarginConfig | undefined;
-    flat: () => TData[];
-    xAcc: () => (d: TData) => AxisValue;
-    groupedSeries: () => VisualGroup<Series<TData>, BarSegmentStyle>[];
-    gapFillMaps: () => Map<string, Map<TData, DiscreteGapFill<BarSegmentStyle>>>;
-}): {
-    readonly layout: BarSeriesLayout;
-    readonly valueBaseline: number;
-    readonly estimatedBandwidth: number;
-    readonly seriesCount: number;
-    readonly seriesStep: number;
-    readonly seriesGap: number;
-    stackedBaseline: (category: AxisValue, seriesIndex: number) => number;
-    groupOffset: (seriesIndex: number) => {
-        dx: number;
-        dy: number;
-    };
-    groupInsetFraction: (seriesIndex: number) => {
-        start: number;
-        end: number;
-    };
-};
-export type BarLayout<TData extends Record<string, unknown>> = ReturnType<typeof createBarLayout<TData>>;

package/dist/plots/bar/layout.svelte.js

@@ -1,182 +0,0 @@
-import { SvelteMap, SvelteSet } from 'svelte/reactivity';
-import { getConfiguration } from '../../configuration/config.svelte';
-import { resolveAccessor } from '../utils/accessors';
-import { numericMargin } from '../../layout/plot/margins';
-import { isGapValue } from '../utils/gaps';
-/**
- * Reactive geometry for BarPlot's series-layout modes — the single source of
- * truth for "where does series N's bar actually sit," shared by bar-segment
- * rendering, value labels, and hover markers. Centralized here after a bug
- * where hover markers reproduced (and initially missed) the same grouped/
- * stacked math value labels already accounted for.
- */
-export function createBarLayout(args) {
-    const cfg = $derived(getConfiguration());
-    /**
-     * How series sharing the same category are arranged — see
-     * {@link import('../../types/layout/scales').AxisScale.seriesLayout}. Read
-     * off `scales.z` since it's the grouping axis, not the category axis itself.
-     */
-    const layout = $derived(args.scales().z?.seriesLayout ?? 'overlap');
-    const categoricalScale = $derived(args.isHorizontal() ? args.scales().y : args.scales().x);
-    const valueScale = $derived(args.isHorizontal() ? args.scales().x : args.scales().y);
-    /**
-     * Bars default to a 0 baseline. When the value axis's domain is set and
-     * excludes 0 (e.g. `[75, 85]`, to zoom in on a tight range), a literal 0
-     * baseline sits way outside the visible domain — the scale still maps it
-     * linearly, so the bar's "start" lands far past the plot's own edge and
-     * the bar overflows into the margin instead of appearing to end at the
-     * frame. Clamping the baseline to whichever domain bound is closest to 0
-     * makes bars cut off exactly at the visible edge instead, which is the
-     * point of setting a truncated domain in the first place. Left as 0 (no
-     * clamp) when the domain isn't set or already straddles 0 naturally.
-     */
-    const valueBaseline = $derived.by(() => {
-        const domain = valueScale?.domain;
-        if (!domain || domain.length < 2)
-            return 0;
-        const lo = Number(domain[0]);
-        const hi = Number(domain[domain.length - 1]);
-        if (Number.isNaN(lo) || Number.isNaN(hi))
-            return 0;
-        const min = Math.min(lo, hi);
-        const max = Math.max(lo, hi);
-        if (min > 0)
-            return min;
-        if (max < 0)
-            return max;
-        return 0;
-    });
-    /**
-     * Approximate per-category band size in pixels (width for vertical bars,
-     * height for horizontal ones), used only to size each series' slice in
-     * 'grouped' layout via inset props. Derived from this plot's own
-     * `width`/`height`/`margins` rather than svelteplot's actual measured
-     * scale (not part of its public API) — close enough for a grouped look,
-     * though it can be slightly off when an 'auto' margin ends up wider than
-     * the estimate (e.g. unusually long tick labels). Follows the same
-     * band-scale formula (and 0.15 default padding) svelteplot itself uses,
-     * so the category axis's own `paddingInner`/`paddingOuter` — the space
-     * *between* categories — is reflected here too, not just svelteplot's
-     * real render. In practice `categoricalScale` always carries a resolved
-     * `paddingInner`/`paddingOuter` by the time it gets here — `Plot.svelte`
-     * backs its own category axis with the theme's `bar.paddingInner`/
-     * `paddingOuter` before either this estimate or the real svelteplot
-     * scale sees it, so the two stay in sync; the literal fallback below is
-     * only a defensive last resort.
-     */
-    const estimatedBandwidth = $derived.by(() => {
-        const categoryCount = new SvelteSet(args.flat().map((d) => args.xAcc()(d))).size;
-        if (categoryCount === 0)
-            return 0;
-        const baseMargins = { ...cfg.margins, ...args.margins() };
-        const innerSize = args.isHorizontal()
-            ? Math.max(0, args.height() -
-                numericMargin('top', baseMargins.top) -
-                numericMargin('bottom', baseMargins.bottom))
-            : Math.max(0, args.width() -
-                numericMargin('left', baseMargins.left) -
-                numericMargin('right', baseMargins.right));
-        const paddingInner = categoricalScale?.paddingInner ?? categoricalScale?.padding ?? 0.15;
-        const paddingOuter = categoricalScale?.paddingOuter ?? categoricalScale?.padding ?? 0.15;
-        const step = innerSize / (categoryCount - paddingInner + 2 * paddingOuter);
-        return step * (1 - paddingInner);
-    });
-    const seriesCount = $derived(args.groupedSeries().length);
-    // `seriesPadding` (0–1, space *within* a group, between its series)
-    // reserves a fraction of each series' own slice as a gap split evenly on
-    // either side of the bar.
-    const seriesGapFraction = $derived(Math.max(0, Math.min(1, args.scales().z?.seriesPadding ?? cfg.bar.seriesPadding)));
-    // Each series gets an equal slice of the band.
-    const seriesStep = $derived(seriesCount > 0 ? estimatedBandwidth / seriesCount : 0);
-    const seriesGap = $derived(seriesGapFraction * seriesStep);
-    /**
-     * Per-category cumulative sums for 'stacked' layout — `stackedPrefixSums.get(category)[i]`
-     * is the sum of series `0..i-1`'s value at that category, i.e. series `i`'s
-     * own segment spans `[prefix, prefix + value]`. Computed by hand (rather
-     * than svelteplot's `stackY`/`stackX` transform, which needs every series'
-     * rows in one call to line up cumulative offsets) so the same numbers can
-     * position the bar segment, its middle-anchored label, and its hover marker.
-     */
-    const stackedPrefixSums = $derived.by(() => {
-        const sums = new SvelteMap();
-        if (layout !== 'stacked')
-            return sums;
-        for (const category of new SvelteSet(args.flat().map((d) => args.xAcc()(d)))) {
-            let running = 0;
-            const prefix = [];
-            for (const group of args.groupedSeries()) {
-                prefix.push(running);
-                const seriesXFn = resolveAccessor(group.series.x);
-                const seriesYFn = resolveAccessor(group.series.y);
-                const row = group.series.data.find((d) => seriesXFn(d) === category);
-                if (row) {
-                    const raw = seriesYFn(row);
-                    const fill = args.gapFillMaps().get(group.series.name)?.get(row);
-                    running += fill ? fill.value : isGapValue(raw) ? 0 : Number(raw);
-                }
-            }
-            sums.set(category, prefix);
-        }
-        return sums;
-    });
-    function stackedBaseline(category, seriesIndex) {
-        return stackedPrefixSums.get(category)?.[seriesIndex] ?? 0;
-    }
-    /**
-     * Pixel offset for a 'grouped' series' own slice of the category band —
-     * shared by bar segments, value labels, and hover markers. `dy` is
-     * negated for horizontal bars, matching how `insetBottom` positions them.
-     */
-    function groupOffset(seriesIndex) {
-        if (layout !== 'grouped')
-            return { dx: 0, dy: 0 };
-        const offset = -(estimatedBandwidth / 2) + seriesIndex * seriesStep + seriesStep / 2;
-        return args.isHorizontal() ? { dx: 0, dy: -offset } : { dx: offset, dy: 0 };
-    }
-    /**
-     * A 'grouped' series' own slice of the category band, as fractions (0–1)
-     * of the *whole* band rather than pixels — unlike {@link groupOffset},
-     * which bakes in `estimatedBandwidth`'s own guess, these stay exact
-     * regardless of how far off that guess ends up: `BarMarker` multiplies
-     * them by the band's real, svelteplot-measured width at render time
-     * (only available once mounted inside the actual `<Plot>`, which this
-     * module isn't), so a bar's own visible width/position is never off by
-     * the estimate's error the way `estimatedBandwidth`-derived pixels can be
-     * — most noticeable in a small faceted cell, where a fixed margin
-     * estimate is proportionally least accurate.
-     */
-    function groupInsetFraction(seriesIndex) {
-        if (layout !== 'grouped' || seriesCount === 0)
-            return { start: 0, end: 0 };
-        const sliceFraction = 1 / seriesCount;
-        const gapFraction = (seriesGapFraction * sliceFraction) / 2;
-        return {
-            start: seriesIndex * sliceFraction + gapFraction,
-            end: (seriesCount - 1 - seriesIndex) * sliceFraction + gapFraction
-        };
-    }
-    return {
-        get layout() {
-            return layout;
-        },
-        get valueBaseline() {
-            return valueBaseline;
-        },
-        get estimatedBandwidth() {
-            return estimatedBandwidth;
-        },
-        get seriesCount() {
-            return seriesCount;
-        },
-        get seriesStep() {
-            return seriesStep;
-        },
-        get seriesGap() {
-            return seriesGap;
-        },
-        stackedBaseline,
-        groupOffset,
-        groupInsetFraction
-    };
-}

package/dist/plots/geo/buildGeoMarkers.d.ts

@@ -1,33 +0,0 @@
-import type { MarkerConfig } from '../../types/markers/all';
-import type { GeoMarkersConfig } from '../../types/markers/geo';
-import type { GeoSegmentStyle } from '../../types/plots/segments/common';
-/** One resolved-style bucket of features, as grouped by `GeoPlot`'s own `styleGroups`. */
-export type GeoStyleGroup<TRow> = {
-    style: GeoSegmentStyle;
-    data: TRow[];
-};
-/**
- * Every marker for one `GeoPlot` render, in final draw order: any authored
- * marker with `behind: true`, then the base map itself (one `'geo'` marker
- * per resolved feature style), then the rest of the authored markers in
- * order, with any `hover` marker moved last.
- */
-export declare function buildGeoMarkers<TRow extends Record<string, unknown> & {
-    __id: string;
-}>(args: {
-    styleGroups: GeoStyleGroup<TRow>[];
-    resolveBaseFill: (d: TRow) => string;
-    fillOpacity?: number;
-    stroke?: string;
-    strokeWidth?: number;
-    axisColor: string;
-    onFeatureClick?: (d: TRow, e: Event) => void;
-    markers: GeoMarkersConfig[];
-    hoverActive: boolean;
-    hoverPointById: Map<string, {
-        row: TRow;
-    }>;
-    isOverInset: (e: PointerEvent) => boolean;
-    setHoverMatch: (rows: TRow[]) => void;
-    clearHoverMatch: () => void;
-}): MarkerConfig[];

package/dist/plots/geo/buildGeoMarkers.js

@@ -1,47 +0,0 @@
-/**
- * `graticule`/`sphere`/`contour` opt into drawing underneath the base map's
- * own fill/stroke instead of on top of it — see each config's own `behind`
- * doc comment.
- */
-function isBehindMarker(marker) {
-    return ((marker.type === 'graticule' || marker.type === 'sphere' || marker.type === 'contour') &&
-        marker.behind === true);
-}
-/**
- * Every marker for one `GeoPlot` render, in final draw order: any authored
- * marker with `behind: true`, then the base map itself (one `'geo'` marker
- * per resolved feature style), then the rest of the authored markers in
- * order, with any `hover` marker moved last.
- */
-export function buildGeoMarkers(args) {
-    const { styleGroups, resolveBaseFill, fillOpacity, stroke, strokeWidth, axisColor, onFeatureClick, markers, hoverActive, hoverPointById, isOverInset, setHoverMatch, clearHoverMatch, } = args;
-    const featureMarkers = styleGroups.map((group) => ({
-        type: 'geo',
-        data: group.data,
-        fill: (d) => group.style.fill ?? resolveBaseFill(d),
-        fillOpacity: group.style.fillOpacity ?? fillOpacity ?? 1,
-        stroke: group.style.stroke ?? stroke ?? axisColor,
-        strokeWidth: group.style.strokeWidth ?? strokeWidth ?? 0.5,
-        onclick: onFeatureClick ? (e, d) => onFeatureClick(d, e) : undefined,
-        onpointerenter: hoverActive
-            ? (e, d) => {
-                if (isOverInset(e))
-                    return;
-                const hp = hoverPointById.get(d.__id);
-                if (hp)
-                    setHoverMatch([hp.row]);
-            }
-            : undefined,
-        onpointerleave: hoverActive
-            ? (e) => {
-                if (isOverInset(e))
-                    return;
-                clearHoverMatch();
-            }
-            : undefined,
-    }));
-    const behindMarkers = markers.filter(isBehindMarker);
-    const frontMarkers = markers.filter((m) => !isBehindMarker(m) && m.type !== 'geo-hover');
-    const hoverMarker = markers.find((m) => m.type === 'geo-hover');
-    return [...behindMarkers, ...featureMarkers, ...frontMarkers, ...(hoverMarker ? [hoverMarker] : [])];
-}

package/dist/plots/heatmap/ValueLabels.svelte

@@ -1,56 +0,0 @@
-<script lang="ts" generics="TData extends Record<string, unknown>">
-  import { Text } from 'svelteplot';
-  import type { AxisValue } from '../../types/layout/scales';
-  import type { ValuesStyle } from '../../types/layout/styles';
-
-  /**
-   * Renders every cell's value label in one mark — heatmaps have no
-   * per-series concept to loop over, so unlike bar/line/pyramid this covers
-   * the whole flat dataset at once. Centered by default, overridable
-   * per-field via `styles.values.fontStyle`.
-   */
-  let {
-    data,
-    getX,
-    getY,
-    getZ,
-    formatValue,
-    values,
-    defaultColor,
-  }: {
-    data: TData[];
-    getX: (d: TData) => AxisValue;
-    getY: (d: TData) => AxisValue;
-    getZ: (d: TData) => unknown;
-    formatValue: (value: number, seriesName: string) => string;
-    values: ValuesStyle | undefined;
-    defaultColor: string;
-  } = $props();
-
-  const font = $derived(values?.fontStyle);
-  // 'outside' is a per-point escape hatch resolved by HoverMarker; heatmaps
-  // have no signed axis to resolve it against, so treat it as unset.
-  const resolvedTextAnchor = $derived(font?.textAnchor === 'outside' ? undefined : font?.textAnchor);
-</script>
-
-<Text
-  {data}
-  x={getX}
-  y={getY}
-  text={(d: TData) => formatValue(Number(getZ(d)), '')}
-  fill={font?.fill ?? defaultColor}
-  fontSize={font?.fontSize ?? 12}
-  fontWeight={font?.fontWeight ?? 600}
-  fontStyle={font?.fontStyle}
-  textAnchor={resolvedTextAnchor ?? 'middle'}
-  lineAnchor={font?.lineAnchor ?? 'middle'}
-  dx={font?.dx ?? 0}
-  dy={font?.dy ?? 0}
-  lineHeight={font?.lineHeight}
-  rotate={font?.rotate}
-  stroke={font?.stroke}
-  strokeWidth={font?.strokeWidth}
-  paintOrder={font?.paintOrder}
-  class={font?.class}
-  textClass={font?.textClass}
-/>