@fundar/data-chart-telling 0.0.64 → 1.0.0

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}
-/>

package/dist/plots/heatmap/buildCellMarkers.d.ts

@@ -1,21 +0,0 @@
-import type { AxisValue } from '../../types/layout/scales';
-import type { CellSegmentStyle } from '../../types/plots/segments/common';
-import type { CellMarkerConfig } from '../../types/markers/common';
-/** One resolved-style bucket of cells, as grouped by `HeatmapPlot`'s own `styleGroups`. */
-export type CellStyleGroup<TData> = {
-    style: CellSegmentStyle;
-    data: TData[];
-};
-/**
- * Every `'cell'` marker for one HeatmapPlot render: one marker per
- * resolved-style bucket in `styleGroups`. `fill` stays a per-row accessor,
- * falling back to `colorScale` wherever a segment doesn't set a literal
- * `fill`.
- */
-export declare function buildCellMarkers<TData extends Record<string, unknown>>(args: {
-    styleGroups: CellStyleGroup<TData>[];
-    getX: (d: TData) => AxisValue;
-    getY: (d: TData) => AxisValue;
-    getZ: (d: TData) => AxisValue;
-    colorScale: (value: number) => string;
-}): CellMarkerConfig[];

package/dist/plots/heatmap/buildCellMarkers.js

@@ -1,25 +0,0 @@
-/**
- * Every `'cell'` marker for one HeatmapPlot render: one marker per
- * resolved-style bucket in `styleGroups`. `fill` stays a per-row accessor,
- * falling back to `colorScale` wherever a segment doesn't set a literal
- * `fill`.
- */
-export function buildCellMarkers(args) {
-    const { styleGroups, getX, getY, getZ, colorScale } = args;
-    return styleGroups.map((group) => ({
-        type: 'cell',
-        data: group.data,
-        x: getX,
-        y: getY,
-        fill: (d) => group.style.fill ?? colorScale(Number(getZ(d))),
-        style: {
-            fillOpacity: group.style.fillOpacity ?? 1,
-            stroke: group.style.stroke,
-            strokeWidth: group.style.strokeWidth ?? 0,
-            strokeOpacity: group.style.strokeOpacity,
-            strokeDasharray: group.style.strokeDasharray,
-            borderRadius: group.style.borderRadius,
-        },
-        inset: 0.5,
-    }));
-}