@fundar/data-chart-telling 0.0.63 → 1.0.0

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

package/dist/markers/ContourClipMarker.svelte

@@ -1,77 +0,0 @@
-<script lang="ts">
-  import { geoPath, type GeoPath } from 'd3-geo';
-  import { usePlot } from 'svelteplot';
-  import type { Snippet } from 'svelte';
-  import type { GeoFeature } from '../types/plots/data/geo';
-
-  /**
-   * Masks a `contour` marker to just the landmass (`'land'`) or just the
-   * water (`'ocean'`) of the plot's own base map, via an SVG `clipPath` —
-   * lets a filled contour read as "temperature over land" without also
-   * painting straight across the ocean, or vice versa. A no-op passthrough
-   * when `mode` is unset, so this can unconditionally wrap every `contour`
-   * marker without an extra branch at each call site.
-   *
-   * Builds the clip path from the plot's own shared, already-fitted
-   * projection (`usePlot()` — the same hook `TileLayer.svelte` uses) rather
-   * than an independent one, so it lines up with the rest of the map
-   * regardless of projection/zoom. `'ocean'` unions the sphere and land
-   * paths into one `clip-rule: evenodd` shape — the sphere covers
-   * everything, then every land ring toggles back out, leaving only water.
-   */
-  let {
-    mode,
-    features,
-    children,
-  }: {
-    mode: 'land' | 'ocean' | undefined;
-    features: GeoFeature<Record<string, unknown>>[];
-    children: Snippet;
-  } = $props();
-
-  const plot = usePlot();
-  const clipId = `geo-contour-clip-${Math.random().toString(36).slice(2, 9)}`;
-
-  // Same runtime shape TileLayer.svelte relies on — svelteplot's own
-  // `PlotScale` type doesn't reflect it, but `plot.scales.projection` is a
-  // real `d3-geo`-compatible stream source at runtime.
-  const path: GeoPath = $derived(geoPath(plot.scales.projection as unknown as Parameters<typeof geoPath>[0]));
-  // Some real-world datasets carry exact-duplicate features for the same
-  // territory (seen in this repo's own `WORLD_COUNTRIES` fixture, for every
-  // South American country) — harmless for an ordinary filled `<Geo>` (the
-  // duplicate just redraws the same shape), but fatal here: two identical,
-  // oppositely-would-be-redundant copies of the same ring toggle each other
-  // back out under `clip-rule: evenodd`, silently punching a hole exactly
-  // where the duplicated territory is. Deduping by geometry keeps this
-  // correct regardless of whether the caller's data happens to be clean.
-  const uniqueGeometries = $derived(
-    Array.from(new Map(features.map((f) => [JSON.stringify(f.geometry), f as unknown as GeoJSON.Feature])).values()),
-  );
-  const landPath = $derived(
-    uniqueGeometries
-      .map((f) => path(f))
-      .filter((d): d is string => !!d)
-      .join(' '),
-  );
-  // `{type: 'Sphere'}` is d3-geo's own pseudo-geometry for "the whole
-  // globe" — not part of the GeoJSON spec, so `@types/geojson` has no type
-  // for it either.
-  const spherePath = $derived(path({ type: 'Sphere' } as unknown as GeoJSON.Feature) ?? '');
-</script>
-
-{#if mode}
-  <defs>
-    <clipPath id={clipId}>
-      {#if mode === 'land'}
-        <path d={landPath} clip-rule="evenodd" />
-      {:else}
-        <path d="{spherePath} {landPath}" clip-rule="evenodd" />
-      {/if}
-    </clipPath>
-  </defs>
-  <g clip-path="url(#{clipId})">
-    {@render children()}
-  </g>
-{:else}
-  {@render children()}
-{/if}

package/dist/markers/ContourMarker.svelte

@@ -1,28 +0,0 @@
-<script lang="ts">
-  import { Contour } from 'svelteplot';
-  import type { GeoContourMarkerConfig } from '../types/markers/geo';
-
-  /**
-   * Renders one `'contour'` marker's `<Contour>` mark. `marker.clip` is
-   * handled by the caller (`GeometryLayout` wraps this in `ContourClipMarker`)
-   * — this component only draws the contour itself.
-   */
-  let { marker }: { marker: GeoContourMarkerConfig } = $props();
-</script>
-
-<!-- No `?? 'none'` fallback: an unset `fill` should leave svelteplot's own default (`fill="none"`) in place, not run the literal string `'none'` through the color scale. -->
-<Contour
-  class="contour"
-  data={marker.data}
-  x={marker.x}
-  y={marker.y}
-  value={marker.value}
-  thresholds={marker.thresholds}
-  fill={marker.fill}
-  stroke={marker.stroke ?? 'currentColor'}
-  strokeWidth={marker.style?.strokeWidth}
-  fillOpacity={marker.style?.fillOpacity}
-  strokeOpacity={marker.style?.strokeOpacity}
-  blur={marker.blur}
-  interpolate={marker.interpolate}
-/>

package/dist/markers/DeltaMarker.svelte

@@ -1,109 +0,0 @@
-<script
-  lang="ts"
-  generics="TData extends Record<string, unknown>"
->
-  import { Line } from 'svelteplot';
-  import DotMarker from './DotMarker.svelte';
-  import TextMarker from './TextMarker.svelte';
-  import { resolveXDeltas, resolveYDeltas } from '../utils/delta';
-  import type { Series } from '../types/plots/data/common';
-  import type { DeltaMarkerConfig } from '../types/markers/line';
-
-  let { marker, data = [] }: { marker: DeltaMarkerConfig; data?: Series<TData>[] } = $props();
-
-  const resolved = $derived.by(() => {
-    const [d] = marker.axis === 'x' ? resolveXDeltas(data, [marker]) : resolveYDeltas(data, [marker]);
-    return d;
-  });
-
-  const clampRange = $derived.by((): [number, number] | undefined => {
-    const domain = marker.axis === 'x' ? marker.yDomain : marker.xDomain;
-    if (!domain || domain.length < 2) return undefined;
-    const lo = Number(domain[0]);
-    const hi = Number(domain[domain.length - 1]);
-    return isNaN(lo) || isNaN(hi) ? undefined : [Math.min(lo, hi), Math.max(lo, hi)];
-  });
-
-  function clamp(v: number): number {
-    return clampRange ? Math.max(clampRange[0], Math.min(clampRange[1], v)) : v;
-  }
-
-  function pt(fixed: number, varying: number) {
-    return marker.axis === 'x' ? { x: fixed, y: varying } : { x: varying, y: fixed };
-  }
-
-  function textVaryCoord(fromVis: number, toVis: number) {
-    const anchor = marker.fontStyle?.lineAnchor ?? 'middle';
-    return anchor === 'top'
-      ? Math.max(fromVis, toVis)
-      : anchor === 'bottom'
-      ? Math.min(fromVis, toVis)
-      : (fromVis + toVis) / 2;
-  }
-
-  // Pre-derive all coordinates as script-level signals so prop getters read safe
-  // values during Svelte 5 teardown, before the {#if} guard finishes unmounting.
-  const coords = $derived.by(() => {
-    if (!resolved) return null;
-    const fromVis = clamp(resolved.from ?? 0);
-    const toVis = clamp(resolved.to ?? 0);
-    const at = resolved.at ?? 0;
-    return {
-      fromPt: pt(at, fromVis),
-      toPt: pt(at, toVis),
-      textPt: pt(at, textVaryCoord(fromVis, toVis)),
-      lineData: [pt(at, fromVis), pt(at, toVis)],
-      diff: resolved.diff ?? 0,
-    };
-  });
-</script>
-
-{#if coords}
-  <Line
-    data={coords.lineData}
-    x={(p) => p.x}
-    y={(p) => p.y}
-    stroke={marker.strokeStyle?.stroke ?? 'currentColor'}
-    strokeWidth={marker.strokeStyle?.strokeWidth ?? 2}
-    strokeOpacity={marker.strokeStyle?.strokeOpacity ?? 0.8}
-    strokeDasharray={marker.strokeStyle?.strokeDasharray ?? '6 6'}
-    strokeLinecap={marker.strokeStyle?.strokeLinecap ?? 'round'}
-  />
-  <DotMarker
-    x={coords?.fromPt?.x ?? 0}
-    y={coords?.fromPt?.y ?? 0}
-    style={{
-      dotRadius: 4,
-      dotFill: marker.strokeStyle?.stroke,
-      dotStroke: marker.strokeStyle?.stroke,
-      dotStrokeWidth: 2,
-      ...marker.dotStyle,
-    }}
-  />
-  <DotMarker
-    x={coords?.toPt?.x ?? 0}
-    y={coords?.toPt?.y ?? 0}
-    style={{
-      dotRadius: 4,
-      dotFill: marker.strokeStyle?.stroke,
-      dotStroke: marker.strokeStyle?.stroke,
-      dotStrokeWidth: 2,
-      ...marker.dotStyle,
-    }}
-  />
-  <TextMarker
-    x={coords?.textPt?.x ?? 0}
-    y={coords?.textPt?.y ?? 0}
-    text={(marker.formatDiff ?? ((v: number) => v.toFixed(1)))(coords?.diff ?? 0)}
-    style={{
-      fontWeight: 'bold',
-      fontSize: 14,
-      textAnchor: 'middle',
-      fill: marker.strokeStyle?.stroke ?? 'currentColor',
-      ...marker.fontStyle,
-      dx: marker.fontStyle?.dx ?? (marker.axis === 'x' ? 12 : 0),
-      dy: marker.fontStyle?.dy ?? (marker.axis === 'x' ? 0 : -10),
-      lineAnchor: marker.axis === 'x' ? (marker.fontStyle?.lineAnchor ?? 'middle') : 'bottom',
-    }}
-  />
-{/if}

package/dist/markers/DotMarker.svelte

@@ -1,70 +0,0 @@
-<script lang="ts" generics="TData = Record<string, unknown>">
-  import { Dot } from 'svelteplot';
-  import { makeColorScale } from '../utils/color';
-  import { getConfiguration } from '../configuration/config.svelte';
-  import type { MarkerProps } from '../types/markers/props';
-  import type { AxisValue } from '../types/layout/scales';
-  import type { DotStyle } from '../types/plots/styling';
-  import type { ColorsStyle } from '../types/layout/styles';
-
-  interface Props extends MarkerProps<TData> {
-    x?: AxisValue | ((d: TData) => AxisValue);
-    y?: AxisValue | ((d: TData) => AxisValue);
-    /** Per-row radius, or a constant — overrides `style.dotRadius` when set. */
-    r?: number | ((d: TData) => number);
-    /** Per-row fill, overriding `style.dotFill` — ignored when `value` is set. */
-    fill?: (d: TData) => string;
-    /** Continuous value driving a per-dot color ramp through `style.colors` — takes priority over `fill`/`style.dotFill` when set. */
-    value?: (d: TData) => number;
-    style?: DotStyle & { colors?: ColorsStyle };
-  }
-
-  const { data = [], x, y, r: rProp, fill: fillProp, value, style }: Props = $props();
-
-  const cfg = $derived(getConfiguration());
-
-  const xAccessor = $derived(typeof x === 'function' ? x : () => x ?? 0);
-  const yAccessor = $derived(typeof y === 'function' ? y : () => y ?? 0);
-  /** A literal `x`/`y` draws one dot at a fixed point regardless of `data`; an accessor reads its position per row. */
-  const displayData = $derived(
-    data.length > 0 || typeof x === 'function' || typeof y === 'function' ? data : [{} as TData],
-  );
-
-  /** Color scale built from `value`'s own data extent — `null` when `value` is unset. */
-  const valueColorScale = $derived.by(() => {
-    if (!value) return null;
-    const vals = displayData.map((d) => Number(value(d))).filter((v) => Number.isFinite(v));
-    if (!vals.length) return null;
-    return makeColorScale(
-      Math.min(...vals),
-      Math.max(...vals),
-      style?.colors?.min ?? cfg.continuous.min,
-      style?.colors?.max ?? cfg.continuous.max,
-    );
-  });
-
-  const r = $derived(rProp ?? style?.dotRadius ?? 5);
-  const fill = $derived(
-    valueColorScale && value ? (d: TData) => valueColorScale(Number(value(d))) : (fillProp ?? style?.dotFill ?? 'currentColor'),
-  );
-  const fillOpacity = $derived(style?.dotFillOpacity ?? 1);
-  const symbol = $derived(style?.dotSymbol ?? 'circle');
-  const stroke = $derived(style?.dotStroke ?? 'currentColor');
-  const strokeWidth = $derived(style?.dotStrokeWidth ?? 1);
-  const strokeOpacity = $derived(style?.dotStrokeOpacity ?? 1);
-  const strokeDasharray = $derived(style?.dotStrokeDasharray);
-</script>
-
-<Dot
-  data={displayData}
-  x={xAccessor}
-  y={yAccessor}
-  {r}
-  {fill}
-  {fillOpacity}
-  {stroke}
-  {strokeWidth}
-  {strokeOpacity}
-  {strokeDasharray}
-  {symbol}
-/>

package/dist/markers/GeoFeaturesMarker.svelte

@@ -1,19 +0,0 @@
-<script lang="ts">
-  import { Geo } from 'svelteplot';
-  import type { GeoFeaturesMarkerConfig } from '../types/markers/geo';
-
-  /** Renders one `'geo'` marker — one resolved-style bucket of the base map's own features, as a single `<Geo>` call. */
-  let { marker }: { marker: GeoFeaturesMarkerConfig } = $props();
-</script>
-
-<Geo
-  data={marker.data}
-  fill={marker.fill}
-  fillOpacity={marker.fillOpacity ?? 1}
-  stroke={marker.stroke ?? 'currentColor'}
-  strokeWidth={marker.strokeWidth ?? 0.5}
-  style="vector-effect: non-scaling-stroke"
-  onclick={marker.onclick}
-  onpointerenter={marker.onpointerenter}
-  onpointerleave={marker.onpointerleave}
-/>

package/dist/markers/GeoHoverMarker.svelte

@@ -1,25 +0,0 @@
-<script lang="ts">
-  import { Geo } from 'svelteplot';
-  import { getConfiguration } from '../configuration/config.svelte';
-  import type { GeoHoverMarkerConfig } from '../types/markers/geo';
-  import type { HoverPoint } from '../types/layout/tooltip';
-
-  /** Renders the hovered feature restyled in place — no dot, no label. `pointer-events: none` so it never steals hover from the base map underneath it. */
-  let { marker, data }: { marker: GeoHoverMarkerConfig; data: HoverPoint<Record<string, unknown>>[] } = $props();
-
-  const cfg = $derived(getConfiguration());
-  const style = $derived({ ...cfg.hover.area, ...marker.style });
-</script>
-
-{#if data.length > 0}
-  <Geo
-    data={data.map((p) => p.row)}
-    fill={style.fill}
-    fillOpacity={style.fillOpacity}
-    stroke={style.stroke}
-    strokeWidth={style.strokeWidth}
-    strokeOpacity={style.strokeOpacity}
-    strokeDasharray={style.strokeDasharray}
-    style="vector-effect: non-scaling-stroke; pointer-events: none;"
-  />
-{/if}

package/dist/markers/GraticuleMarker.svelte

@@ -1,18 +0,0 @@
-<script lang="ts">
-  import { Graticule } from 'svelteplot';
-  import type { GeoGraticuleMarkerConfig } from '../types/markers/geo';
-
-  /** Renders one `'graticule'` marker — longitude/latitude gridlines. */
-  let { marker }: { marker: GeoGraticuleMarkerConfig } = $props();
-</script>
-
-<Graticule
-  step={marker.step}
-  stepX={marker.stepX}
-  stepY={marker.stepY}
-  stroke={marker.style?.stroke ?? 'currentColor'}
-  strokeWidth={marker.style?.strokeWidth ?? 0.5}
-  strokeOpacity={marker.style?.strokeOpacity ?? 0.3}
-  strokeDasharray={marker.style?.strokeDasharray}
-  style="vector-effect: non-scaling-stroke"
-/>