@fundar/data-chart-telling 0.0.64 → 1.1.0

package/dist/plots/utils/labelOverflow.svelte.js

@@ -1,257 +0,0 @@
-import { AUTO_MARGIN_ESTIMATE } from '../../layout/plot/margins';
-const NO_OVERFLOW = { left: 0, right: 0, top: 0, bottom: 0 };
-/**
- * A generic `maxOverflow` cap for {@link createLabelMarginTracker}: half of
- * each dimension, so a facet cramped enough that its own value label can
- * never fully fit still leaves the plot's own content box the other half,
- * rather than `measured` growing without bound (see that function's own
- * `maxOverflow` doc comment). The same backstop applies regardless of *what*
- * overflows or *why* — every value-label-drawing plot (line/bar/pyramid/
- * scatter) passes this, sized off its own `width`/`height`.
- */
-export function halfDimensionOverflowCap(width, height) {
-    return {
-        left: Math.max(0, width * 0.5),
-        right: Math.max(0, width * 0.5),
-        top: Math.max(0, height * 0.5),
-        bottom: Math.max(0, height * 0.5)
-    };
-}
-/**
- * Watches an SVG group's rendered bounding box against the plot's own
- * content box (`bounds`) and reports how far it overflows on each side.
- * Polled across successive paints until two consecutive readings agree,
- * rather than trusted after a single frame: the group's own resolved
- * geometry (driven by svelteplot's separate reactive graph) and svelteplot's
- * own axis auto-margins can take a variable number of frames to settle —
- * more on a page with many other components competing for layout (e.g. a
- * docs page) than in an isolated story. Measuring too early can catch
- * content still at its pre-layout default position; capped so a layout that
- * genuinely never stabilizes still reports its last reading instead of
- * polling forever. Also waits for web fonts to finish loading, since glyph
- * metrics (and therefore `getBBox()`) can still reflect a fallback font's
- * narrower widths until the real font swaps in.
- */
-export function watchLabelOverflow(args) {
-    $effect(() => {
-        const el = args.el();
-        const bounds = args.bounds();
-        const reportOverflow = args.onOverflow;
-        if (!el || !bounds)
-            return;
-        const MAX_ATTEMPTS = 30;
-        let cancelled = false;
-        let frame;
-        let attempt = 0;
-        let lastReading;
-        function measure() {
-            if (cancelled)
-                return;
-            let box;
-            try {
-                box = el.getBBox();
-            }
-            catch {
-                return;
-            }
-            // An empty group (no labels currently rendered, e.g. every series is
-            // scrubbed/filtered out of view) reports getBBox() as (0,0,0,0) — the
-            // SVG origin, not "no content". Reading that literally as a box sitting
-            // at (0,0) would report overflow proportional to the *current* margins
-            // themselves, which grows them, which remounts this group against the
-            // new, larger bounds, which reports overflow again — an unbounded loop
-            // with nothing rendered to justify it.
-            const overflow = box.width === 0 && box.height === 0
-                ? NO_OVERFLOW
-                : {
-                    left: Math.ceil(Math.max(0, bounds.left - box.x)),
-                    right: Math.ceil(Math.max(0, box.x + box.width - bounds.right)),
-                    top: Math.ceil(Math.max(0, bounds.top - box.y)),
-                    bottom: Math.ceil(Math.max(0, box.y + box.height - bounds.bottom))
-                };
-            attempt += 1;
-            const stable = lastReading != null &&
-                lastReading.left === overflow.left &&
-                lastReading.right === overflow.right &&
-                lastReading.top === overflow.top &&
-                lastReading.bottom === overflow.bottom;
-            lastReading = overflow;
-            if (stable || attempt >= MAX_ATTEMPTS) {
-                reportOverflow(overflow);
-            }
-            else {
-                frame = requestAnimationFrame(measure);
-            }
-        }
-        const fontsReady = document.fonts?.ready ?? Promise.resolve();
-        fontsReady.then(() => {
-            if (cancelled)
-                return;
-            frame = requestAnimationFrame(measure);
-        });
-        return () => {
-            cancelled = true;
-            if (frame !== undefined)
-                cancelAnimationFrame(frame);
-        };
-    });
-}
-/**
- * Tracks value-label overflow reported by (possibly several, e.g. one per
- * series) {@link watchLabelOverflow} calls and grows a local margin override
- * to fit it — monotonically, since shrinking it back would re-expose the
- * overflow that caused the growth in the first place, oscillating between
- * "shrink margin → overflow reappears → grow margin → …". Each side is only
- * ever set when the caller's own `margins` prop hasn't already pinned it, so
- * an explicit caller override always wins over this auto-grown one.
- *
- * That monotonic growth is only sound for a *stable* dataset — it assumes
- * every reading describes the same thing being measured, just possibly at an
- * earlier, not-yet-settled frame. It stops being sound once the caller's own
- * data changes identity underneath it (e.g. a timeline scrubber revealing a
- * different slice of rows on every tick): an overflow measured against
- * *that* frame's rendered labels doesn't describe the next frame's, so
- * carrying it forward forever can leave a plot permanently — and wrongly —
- * margin-inflated by whatever the single most cluttered frame it ever
- * passed through needed, long after scrubbing away from it. `resetKey`, if
- * given, is compared by identity on every call; a change drops `measured`
- * back to zero so the next frame's overflow is measured fresh against only
- * what's actually on screen now. Pass whatever reactive value identifies
- * "what's currently being plotted" for the caller (e.g. its own resolved
- * series list) — a plain reference/value comparison, not a deep one, so it
- * only need change identity when the rendered content actually does.
- */
-export function createLabelMarginTracker(margins, resetKey, 
-/**
- * A precomputed overflow estimate — from the full dataset, not just the
- * current frame — used as the reset target instead of zero. Since it's
- * derived from stable inputs, a `resetKey` change resets `measured` back
- * to roughly the same value instead of zero, so DOM growth rarely needs
- * to re-detect and re-grow it (which would otherwise remount the plot on
- * every reset). DOM measurement can still grow past it for whatever this
- * estimate doesn't cover.
- */
-floor, 
-/**
- * Ceiling on how far `measured` can grow on each side, independent of
- * `floor`. Without one, a cell too small to ever fully fit its own label
- * (e.g. a narrow facet) keeps reporting overflow after every growth-
- * triggered remount — since the label's absolute size never shrinks —
- * and `measured` grows without bound, eventually leaving nothing for the
- * plot's own content box. Capping it trades a permanently-clipped label
- * in that case for a plot that still renders. Pass `Infinity` on a side
- * (the default) to leave it uncapped.
- */
-maxOverflow) {
-    const floorValue = () => floor?.() ?? NO_OVERFLOW;
-    let measured = $state(floorValue());
-    // Skips the reset on the very first run (there's nothing to reset yet,
-    // and `measured` already starts at the floor) so only a later, genuine
-    // change to `resetKey` clears accumulated growth.
-    let resetKeyInitialized = false;
-    let lastResetKey;
-    $effect(() => {
-        const key = resetKey?.();
-        if (!resetKeyInitialized) {
-            resetKeyInitialized = true;
-            lastResetKey = key;
-            return;
-        }
-        if (key !== lastResetKey) {
-            lastResetKey = key;
-            measured = floorValue();
-        }
-    });
-    // Pure `Math.max` — no `maxOverflow` cap here. `measured` is a *tracked*
-    // value, not the applied margin, and must stay strictly monotonic
-    // regardless of anything else changing (see this function's own doc
-    // comment on why shrinking it back oscillates). `maxOverflow` is
-    // typically sized off the plot's own live `width`/`height` (see
-    // `halfDimensionOverflowCap`), which moves continuously during a resize
-    // — capping *here* would let a shrinking cap force `measured` down mid-
-    // resize, immediately re-exposing the overflow that grew it in the first
-    // place and re-triggering growth, over and over, fast enough to trip
-    // Svelte's `effect_update_depth_exceeded` guard. The cap is applied only
-    // where it can't feed back into `measured` itself — see `resolvedMargins`.
-    function report(overflow) {
-        const next = {
-            left: Math.max(measured.left, overflow.left),
-            right: Math.max(measured.right, overflow.right),
-            top: Math.max(measured.top, overflow.top),
-            bottom: Math.max(measured.bottom, overflow.bottom)
-        };
-        if (next.left !== measured.left ||
-            next.right !== measured.right ||
-            next.top !== measured.top ||
-            next.bottom !== measured.bottom) {
-            measured = next;
-        }
-    }
-    // `measured` is overflow *past* the current margin, not the total margin
-    // needed — grown on top of `AUTO_MARGIN_ESTIMATE` (the same fallback
-    // svelteplot's own 'auto' sizing is estimated by elsewhere), not the raw
-    // overflow alone, or growth would silently replace whatever room 'auto'
-    // would have reserved for the axis itself (tick labels, title) with a
-    // number that only accounts for the value label. `AUTO_MARGIN_ESTIMATE` is
-    // a fixed constant, not `numericMargins`' own already-grown value, so this
-    // can't compound into unbounded growth across repeated reports.
-    //
-    // `maxOverflow`, if given, clamps `measured` down to a live cap *here*,
-    // read-only — every render re-reads the current cap and applies it fresh
-    // to the unclamped, monotonically-tracked `measured`, without ever
-    // writing the clamped value back into `measured` itself (see `report`'s
-    // own doc comment for why that distinction matters).
-    const resolvedMargins = $derived.by(() => {
-        const base = margins();
-        const cap = maxOverflow?.() ?? {
-            left: Infinity,
-            right: Infinity,
-            top: Infinity,
-            bottom: Infinity
-        };
-        const clamped = {
-            left: Math.min(measured.left, cap.left),
-            right: Math.min(measured.right, cap.right),
-            top: Math.min(measured.top, cap.top),
-            bottom: Math.min(measured.bottom, cap.bottom)
-        };
-        if (clamped.left <= 0 && clamped.right <= 0 && clamped.top <= 0 && clamped.bottom <= 0)
-            return base;
-        const out = { ...base };
-        if (clamped.right > 0 && base?.right === undefined)
-            out.right = AUTO_MARGIN_ESTIMATE.right + clamped.right;
-        if (clamped.left > 0 && base?.left === undefined)
-            out.left = AUTO_MARGIN_ESTIMATE.left + clamped.left;
-        if (clamped.top > 0 && base?.top === undefined)
-            out.top = AUTO_MARGIN_ESTIMATE.top + clamped.top;
-        if (clamped.bottom > 0 && base?.bottom === undefined)
-            out.bottom = AUTO_MARGIN_ESTIMATE.bottom + clamped.bottom;
-        return out;
-    });
-    // Bundles `resolvedMargins` with a remount key, ready to spread straight
-    // onto `<BasePlotLayout>` as its `margins`/`marginRemountKey` props (see
-    // that prop's doc comment for *why* a remount key is needed here at all)
-    // — keeps the caller from re-deriving the same key by hand. Keyed off
-    // `resolvedMargins` itself (the actually-applied value) rather than raw
-    // `measured` — with a `maxOverflow` cap in play, `measured` can keep
-    // climbing past the point where it's clamped without the applied margin
-    // changing at all, and remounting for that would be pure waste. Also
-    // tracks the caller's own `margins()` — a caller that changes its
-    // explicit margins prop after mount (e.g. locking in a previously-
-    // measured value) needs that picked up just as cleanly as internal
-    // growth does; `resolvedMargins` alone already reflects that too, but
-    // spelling it out keeps the key's intent obvious.
-    const plotProps = $derived.by(() => ({
-        margins: resolvedMargins,
-        marginRemountKey: JSON.stringify({ base: margins(), resolvedMargins })
-    }));
-    return {
-        report,
-        get resolvedMargins() {
-            return resolvedMargins;
-        },
-        get plotProps() {
-            return plotProps;
-        }
-    };
-}

package/dist/plots/utils/legendDisabled.d.ts

@@ -1,27 +0,0 @@
-import type { LegendDisabledAction, LegendDisabledStyle, LegendInteractionStore } from '../../types/layout/legend';
-import type { StrokeStyle, DotStyle } from '../../types/plots/styling';
-/** Resolves a {@link LegendDisabledAction} into the style a mark should render with — `'omit'` resolves to fully transparent. */
-export declare function resolveDisabledStyle(action: LegendDisabledAction | undefined, fallbackOpacity: number): LegendDisabledStyle | undefined;
-/** Drops series toggled off with `disabled: { mode: 'omit' }` from a series list. */
-export declare function omitDisabledSeries<S extends {
-    name: string;
-}>(series: S[], legendInteraction: LegendInteractionStore | null | undefined): S[];
-/** Builds a per-series-name → palette index from the full series list, before {@link omitDisabledSeries} filters it. */
-export declare function buildSeriesColorIndex<S extends {
-    name: string;
-}>(series: S[]): Map<string, number>;
-/** Resolves the disabled style for a series by name: legend-off state, falling back to hover-isolate dim. */
-export declare function resolveEffectiveDisabledStyle(name: string, legendInteraction: LegendInteractionStore | null | undefined, disabledOpacity: number, hoverIsolate: boolean, hoverIsolatedSeries: string | null): LegendDisabledStyle | undefined;
-/**
- * The three per-mark override layers a legend "disabled" state can apply,
- * derived once from a {@link LegendDisabledStyle}. Each is `undefined` when
- * there's no active override, so call sites can slot the result in as just
- * one more `??` layer ahead of their existing segment-style/default-color
- * chain — no branching needed at the call site.
- */
-export declare function disabledStrokeOverride(disabled: LegendDisabledStyle | undefined): StrokeStyle | undefined;
-export declare function disabledDotsOverride(disabled: LegendDisabledStyle | undefined): DotStyle | undefined;
-export declare function disabledFillOverride(disabled: LegendDisabledStyle | undefined): {
-    fill?: string;
-    fillOpacity?: number;
-} | undefined;

package/dist/plots/utils/legendDisabled.js

@@ -1,68 +0,0 @@
-/** Resolves a {@link LegendDisabledAction} into the style a mark should render with — `'omit'` resolves to fully transparent. */
-export function resolveDisabledStyle(action, fallbackOpacity) {
-    if (!action)
-        return undefined;
-    if (action.mode === 'omit')
-        return { opacity: 0 };
-    return action.style ?? { opacity: fallbackOpacity };
-}
-/** Drops series toggled off with `disabled: { mode: 'omit' }` from a series list. */
-export function omitDisabledSeries(series, legendInteraction) {
-    if (!legendInteraction)
-        return series;
-    return series.filter((s) => legendInteraction.disabledSeries.get(s.name)?.mode !== 'omit');
-}
-/** Builds a per-series-name → palette index from the full series list, before {@link omitDisabledSeries} filters it. */
-export function buildSeriesColorIndex(series) {
-    const index = new Map();
-    series.forEach((s, i) => index.set(s.name, i));
-    return index;
-}
-/** Resolves the disabled style for a series by name: legend-off state, falling back to hover-isolate dim. */
-export function resolveEffectiveDisabledStyle(name, legendInteraction, disabledOpacity, hoverIsolate, hoverIsolatedSeries) {
-    return (resolveDisabledStyle(legendInteraction?.disabledSeries.get(name), disabledOpacity) ??
-        (hoverIsolate && hoverIsolatedSeries && hoverIsolatedSeries !== name
-            ? { opacity: disabledOpacity }
-            : undefined));
-}
-/**
- * The three per-mark override layers a legend "disabled" state can apply,
- * derived once from a {@link LegendDisabledStyle}. Each is `undefined` when
- * there's no active override, so call sites can slot the result in as just
- * one more `??` layer ahead of their existing segment-style/default-color
- * chain — no branching needed at the call site.
- */
-export function disabledStrokeOverride(disabled) {
-    if (!disabled)
-        return undefined;
-    return {
-        stroke: disabled.stroke?.stroke,
-        strokeWidth: disabled.stroke?.strokeWidth,
-        strokeOpacity: disabled.stroke?.strokeOpacity ?? disabled.opacity,
-        strokeDasharray: disabled.stroke?.strokeDasharray,
-        strokeLinecap: disabled.stroke?.strokeLinecap,
-        strokeLinejoin: disabled.stroke?.strokeLinejoin,
-    };
-}
-export function disabledDotsOverride(disabled) {
-    if (!disabled)
-        return undefined;
-    return {
-        dotRadius: disabled.dots?.dotRadius,
-        dotFill: disabled.dots?.dotFill,
-        dotFillOpacity: disabled.dots?.dotFillOpacity ?? disabled.opacity,
-        dotSymbol: disabled.dots?.dotSymbol,
-        dotStroke: disabled.dots?.dotStroke,
-        dotStrokeWidth: disabled.dots?.dotStrokeWidth,
-        dotStrokeOpacity: disabled.dots?.dotStrokeOpacity ?? disabled.opacity,
-        dotStrokeDasharray: disabled.dots?.dotStrokeDasharray,
-    };
-}
-export function disabledFillOverride(disabled) {
-    if (!disabled)
-        return undefined;
-    return {
-        fill: disabled.fill,
-        fillOpacity: disabled.fillOpacity ?? disabled.opacity,
-    };
-}

package/dist/plots/utils/valueLabelMargin.d.ts

@@ -1,67 +0,0 @@
-import type { LineAnchor } from '../../types/plots/constants';
-/**
- * The one calculation every value-label-drawing plot (`LinePlot`, `BarPlot`,
- * `PyramidPlot`, …) needs to reserve margin for its own value labels ahead of
- * time, stable across a timeline scrubber or a dataset change: measure the
- * widest candidate label (already off-DOM/canvas via `measureMaxLabelWidth`,
- * so this is synchronous and exact, not an approximation needing a later
- * DOM-measured correction), then add a fixed `reach` — whatever fixed gap
- * sits between the anchor point and where the text itself starts, which
- * differs per plot (a bar/pyramid's anchor offset; a line's elbow-routed
- * lane geometry, see `laneReachUpperBound`).
- *
- * `texts` is the plot's own candidate list (its own concern — which values
- * count as "the widest this could ever need to be", e.g. every row's value
- * vs. just a pinned domain's extremes) — this function only measures and
- * combines, it never decides which labels matter.
- */
-export declare function estimateValueLabelMargin(texts: string[], options: {
-    /** Canvas font shorthand, e.g. `"12px sans-serif"`, matching the labels' own rendered font. */
-    canvasFont: string;
-    /**
-     * Fraction of the widest label's own width that extends toward the
-     * margin being reserved — `1` (the default) for a label anchored so
-     * its whole width reaches outward (`textAnchor: 'start'`), `0.5` for
-     * one centered on its anchor (`'middle'`), `0` for one anchored back
-     * over the plot's own content (no text-width contribution, though
-     * `reach` can still apply).
-     */
-    textFraction?: number;
-    /**
-     * Fixed gap (px) between the anchor point and the start of the label
-     * text — always reserved, even when `texts` is empty, matching every
-     * caller's existing behaviour of never collapsing to zero margin
-     * outright (a plot with no value-label-bearing data yet still keeps
-     * whatever fixed offset its style config asks for).
-     */
-    reach?: number;
-}): number;
-/** Estimated full rendered height of a single-line value label at `fontSize`. */
-export declare function estimateLabelHeight(fontSize: number): number;
-/** Vertical analogue of `estimateValueLabelMargin`: how far a value label's text extends above/below its anchor point. */
-export declare function estimateValueLabelVerticalMargin(options: {
-    fontSize: number;
-    lineAnchor: LineAnchor;
-    /** Pixel offset from the anchor point to the label's line-anchor edge, same sign as SVG's `dy`. */
-    dy?: number;
-}): {
-    top: number;
-    bottom: number;
-};
-/**
- * Upper bound on how far `LinePlot`'s end-of-line labels can ever fan out
- * into lanes (see `plots/utils/declutter.ts`'s `laneAssignment`): a run of
- * colliding labels never uses more lanes than it has members, and a run can
- * never have more members than there are series total — so `elbowGap +
- * (seriesCount - 1) * laneStep + labelGap` is always >= the real, rendered
- * reach, for *any* arrangement `declutter1D`/`laneAssignment` could ever
- * produce. That's what makes it safe to use as a stable floor: it doesn't
- * depend on which series happen to collide on the current frame (which can
- * change tick to tick as a timeline scrubs), only on how many series exist —
- * so the margin it implies never needs to change across a scrub either.
- */
-export declare function laneReachUpperBound(seriesCount: number, cfg: {
-    elbowGap: number;
-    laneStep: number;
-    labelGap: number;
-}): number;

package/dist/plots/utils/valueLabelMargin.js

@@ -1,60 +0,0 @@
-import { measureMaxLabelWidth } from '../../layout/plot/measureText';
-/**
- * The one calculation every value-label-drawing plot (`LinePlot`, `BarPlot`,
- * `PyramidPlot`, …) needs to reserve margin for its own value labels ahead of
- * time, stable across a timeline scrubber or a dataset change: measure the
- * widest candidate label (already off-DOM/canvas via `measureMaxLabelWidth`,
- * so this is synchronous and exact, not an approximation needing a later
- * DOM-measured correction), then add a fixed `reach` — whatever fixed gap
- * sits between the anchor point and where the text itself starts, which
- * differs per plot (a bar/pyramid's anchor offset; a line's elbow-routed
- * lane geometry, see `laneReachUpperBound`).
- *
- * `texts` is the plot's own candidate list (its own concern — which values
- * count as "the widest this could ever need to be", e.g. every row's value
- * vs. just a pinned domain's extremes) — this function only measures and
- * combines, it never decides which labels matter.
- */
-export function estimateValueLabelMargin(texts, options) {
-    const maxWidth = measureMaxLabelWidth(texts, options.canvasFont);
-    const textFraction = options.textFraction ?? 1;
-    const reach = options.reach ?? 0;
-    return Math.ceil(reach + textFraction * maxWidth);
-}
-/** Estimated full rendered height of a single-line value label at `fontSize`. */
-export function estimateLabelHeight(fontSize) {
-    return fontSize * 1.2;
-}
-/** Vertical analogue of `estimateValueLabelMargin`: how far a value label's text extends above/below its anchor point. */
-export function estimateValueLabelVerticalMargin(options) {
-    const height = estimateLabelHeight(options.fontSize);
-    const dy = options.dy ?? 0;
-    if (options.lineAnchor === 'top') {
-        return { top: 0, bottom: Math.ceil(Math.max(0, dy) + height) + 2 };
-    }
-    if (options.lineAnchor === 'bottom') {
-        return { top: Math.ceil(Math.max(0, -dy) + height) + 2, bottom: 0 };
-    }
-    const half = height / 2;
-    return {
-        top: Math.ceil(Math.max(0, half - dy)) + 2,
-        bottom: Math.ceil(Math.max(0, half + dy)) + 2
-    };
-}
-/**
- * Upper bound on how far `LinePlot`'s end-of-line labels can ever fan out
- * into lanes (see `plots/utils/declutter.ts`'s `laneAssignment`): a run of
- * colliding labels never uses more lanes than it has members, and a run can
- * never have more members than there are series total — so `elbowGap +
- * (seriesCount - 1) * laneStep + labelGap` is always >= the real, rendered
- * reach, for *any* arrangement `declutter1D`/`laneAssignment` could ever
- * produce. That's what makes it safe to use as a stable floor: it doesn't
- * depend on which series happen to collide on the current frame (which can
- * change tick to tick as a timeline scrubs), only on how many series exist —
- * so the margin it implies never needs to change across a scrub either.
- */
-export function laneReachUpperBound(seriesCount, cfg) {
-    if (seriesCount <= 1)
-        return 0;
-    return cfg.elbowGap + (seriesCount - 1) * cfg.laneStep + cfg.labelGap;
-}

package/dist/types/charts/common.d.ts

@@ -1,22 +0,0 @@
-import type { Snippet } from 'svelte';
-import type { TimeValue } from '../layout/timeline';
-import type { LegendPlotContext } from '../layout/legend';
-import type { MarginConfig } from '../plots/props';
-export type ChartBoxContext = {
-    width: number;
-    height: number;
-};
-export type ChartBoxSnippet = Snippet<[ChartBoxContext]>;
-export type ChartPlotContext<TRow extends Record<string, unknown>> = {
-    data: TRow[];
-    width: number;
-    height: number;
-    facetValue?: string;
-    selectedValue?: TimeValue;
-    legend?: LegendPlotContext;
-    /** Present only when faceted with `facet.marginsForFacet` — forward to the plot's own `margins` prop so every facet shares the same content box. */
-    margins?: MarginConfig;
-};
-export type ChartPlotSnippet<TRow extends Record<string, unknown>> = Snippet<[
-    ChartPlotContext<TRow>
-]>;

package/dist/types/charts/props.d.ts

@@ -1,50 +0,0 @@
-import type { Snippet } from 'svelte';
-import type { AxisValue, AxisBasedScalesConfig } from '../layout/scales';
-import type { Accessor } from '../plots/data/common';
-import type { AxisBasedStylesConfig, GapsAwarePlotStylesConfig } from '../layout/styles';
-import type { SegmentsConfig, MarginConfig } from '../plots/props';
-import type { AxisBasedMarkersConfig } from '../markers/common';
-import type { TooltipProp } from '../layout/tooltip';
-import type { LegendSection } from '../layout/legend';
-import type { FacetConfig } from '../layout/facet';
-import type { TimelineConfig } from '../layout/timeline';
-/**
- * Common props accepted by every chart component (bar, line, heatmap, pyramid,
- * …). The `TSegmentStyle` parameter lets each chart narrow `segments` to its
- * own style shape while keeping everything else shared.
- *
- * Note: `z` is optional here (bar/line charts) but individual charts may
- * tighten it to required and/or narrow its value type (e.g. `number` for
- * heatmap).
- */
-export type ChartProps<TRow extends Record<string, unknown>, TSegmentStyle extends object = object> = {
-    width: number;
-    height: number;
-    title?: string;
-    subtitle?: string;
-    caption?: string;
-    header?: Snippet;
-    footer?: Snippet;
-    legend?: LegendSection[];
-    data: TRow[];
-    x: Accessor<TRow, AxisValue>;
-    y: Accessor<TRow, AxisValue>;
-    z?: Accessor<TRow, unknown>;
-    styles?: AxisBasedStylesConfig;
-    segments?: SegmentsConfig<TSegmentStyle>;
-    markers?: AxisBasedMarkersConfig[];
-    scales?: AxisBasedScalesConfig<TRow>;
-    margins?: MarginConfig;
-    facet?: FacetConfig<TRow>;
-    timeline?: TimelineConfig<TRow>;
-    tooltip?: TooltipProp<TRow>;
-};
-/**
- * `ChartProps` for the chart kinds with gap-fill (`BarChart`/`LineChart`/
- * `PyramidChart`) — identical shape, but `styles` accepts
- * `GapsAwarePlotStylesConfig<TSegmentStyle>` (adds `styles.gaps`) instead of
- * the plain `AxisBasedStylesConfig` every other chart kind uses.
- */
-export type GapsAwareChartProps<TRow extends Record<string, unknown>, TSegmentStyle extends object = object> = Omit<ChartProps<TRow, TSegmentStyle>, 'styles'> & {
-    styles?: GapsAwarePlotStylesConfig<TSegmentStyle>;
-};

package/dist/types/markers/base.d.ts

@@ -1,45 +0,0 @@
-import type { AxisValue } from '../layout/scales';
-import type { DotStyle, FontStyle } from '../plots/styling';
-import type { ColorsStyle } from '../layout/styles';
-/**
- * A set of point marks (svelteplot's `Dot`) — usable on any plot kind, axis-based or geo.
- *
- * `x`/`y`/`r`/`value` accept a field key or an accessor function, like `Series.x`/`y`.
- * `GeometryLayout` resolves the shorthand before it reaches `DotMarker.svelte`, which only
- * ever sees functions.
- */
-export type DotMarkerConfig = {
-    type: 'dot';
-    data: Record<string, unknown>[];
-    x: string | ((d: any) => AxisValue);
-    y: string | ((d: any) => AxisValue);
-    /** Per-row radius, or a constant — overrides `style.dotRadius`. */
-    r?: number | string | ((d: any) => number);
-    /** Per-row fill, overriding `style.dotFill` — ignored when `value` is set. */
-    fill?: (d: any) => string;
-    /** Continuous value driving a per-dot color ramp through `style.colors`. */
-    value?: string | ((d: any) => number);
-    style?: DotStyle & {
-        colors?: ColorsStyle;
-    };
-};
-/**
- * A text label per row (svelteplot's `Text`) — usable on any plot kind, axis-based or geo.
- *
- * `x`/`y` accept the same field-key-or-function shorthand as `DotMarkerConfig`. `text` is a
- * constant or a per-row accessor.
- */
-export type TextMarkerConfig = {
-    type: 'text';
-    data: Record<string, unknown>[];
-    x: string | ((d: any) => AxisValue);
-    y: string | ((d: any) => AxisValue);
-    text: string | ((d: any) => string);
-    style?: FontStyle;
-};
-/**
- * Every marker kind usable on any plot, axis-based or geo. `AxisBasedMarkersConfig`
- * (`types/markers/common.ts`) and `GeoMarkersConfig` (`types/markers/geo.ts`) both extend
- * this, so `MarkerConfig` (`types/markers/all.ts`) can union the two without a shape collision.
- */
-export type BaseMarkersConfig = DotMarkerConfig | TextMarkerConfig;

package/dist/types/markers/line.d.ts

@@ -1,34 +0,0 @@
-import type { AxisValue } from '../layout/scales';
-import type { StrokeStyle, FontStyle, DotStyle } from '../plots/styling';
-import type { AxisBasedMarkersConfig } from './common';
-/** Which endpoint a delta measures from/to: a named series, or a fixed axis value (defaults to `0`). */
-export type DeltaTarget = {
-    type: 'series';
-    series: string;
-} | {
-    type: 'axis';
-    value?: number;
-};
-/** How far apart two points are on a line chart: a given x (or y), or a series' distance from a fixed axis value. */
-export type DeltaConfig = {
-    axis: 'x' | 'y';
-    at: AxisValue;
-    from: DeltaTarget;
-    to?: DeltaTarget;
-    formatDiff?: (diff: number) => string;
-    strokeStyle?: StrokeStyle;
-    fontStyle?: FontStyle;
-    dotStyle?: DotStyle;
-};
-/**
- * A delta annotation between two points on a line chart, resolved against
- * series data (`utils/delta.ts`). `xDomain`/`yDomain` optionally clamp
- * the varying endpoint to the plot's own axis range.
- */
-export type DeltaMarkerConfig = {
-    type: 'delta';
-    xDomain?: (number | string | Date)[];
-    yDomain?: (number | string | Date)[];
-} & DeltaConfig;
-/** `LinePlot`'s own `markers` prop type — every {@link AxisBasedMarkersConfig} kind plus the line-only `'delta'` annotation. */
-export type LineMarkersConfig = AxisBasedMarkersConfig | DeltaMarkerConfig;

package/dist/types/markers/props.d.ts

@@ -1,11 +0,0 @@
-/**
- * Baseline props every marker component receives when mounted by a plot:
- * `data` for the points/values it draws, plus `series`/`seriesColor` when
- * mounted per-series via a `CustomComponentMarkerConfig`. Marker components extend
- * this with whatever else they need (e.g. PeakMarker's `mode`, `label`).
- */
-export interface MarkerProps<TData = Record<string, unknown>> {
-    data?: TData[];
-    series?: string;
-    seriesColor?: string;
-}

package/dist/types/plots/data/scatter.d.ts

@@ -1,13 +0,0 @@
-import type { Accessor, SeriesProps, DataProps } from './common';
-/**
- * `SeriesProps`/`DataProps`, plus an optional per-row bubble radius —
- * ScatterPlot's own data contract. A field key or accessor function is
- * bound to svelteplot's own auto sqrt scale (mirroring how `x`/`y` are
- * bound to their own scales), so bubble *area* — not radius — ends up
- * proportional to the raw values with no manual scaling needed; feeding it
- * an already-scaled value double-scales it. A literal number bypasses
- * scaling entirely (a fixed pixel radius, same as the default dot size).
- */
-export type ScatterDataProps<T extends Record<string, unknown>> = (SeriesProps<T> | DataProps<T>) & {
-    r?: Accessor<T, number> | number;
-};