@fundar/data-chart-telling 0.0.25 → 0.0.27

package/dist/types/plots/styling.d.ts

@@ -43,3 +43,13 @@ export type DotStyle = {
     dotStrokeOpacity?: number;
     dotStrokeDasharray?: string | LineStyle;
 };
+/** Styling for a 2D area mark — a bar segment, a heatmap cell, a geo feature highlight. */
+export type AreaStyle = {
+    fill?: string;
+    fillOpacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+    strokeOpacity?: number;
+    strokeDasharray?: string | LineStyle;
+    borderRadius?: number;
+};

package/dist/{plots/utils → utils}/delta.d.ts

@@ -1,5 +1,5 @@
-import type { Series } from '../../types/plots/data/common';
-import type { DeltaConfig } from '../../types/plots/delta';
+import type { Series } from '../types/plots/data/common';
+import type { DeltaConfig } from '../types/markers/line';
 export type ResolvedDelta = {
     cfg: DeltaConfig;
     at: number;

package/dist/{plots/utils → utils}/delta.js

@@ -1,4 +1,4 @@
-import { resolveAccessor } from './accessors';
+import { resolveAccessor } from '../plots/utils/accessors';
 /**
  * Sorts `data` by `sortBy`, then finds the first adjacent pair where `scanBy`
  * brackets `target` and linearly interpolates `measureBy` at that crossing.

package/dist/utils/edgeAwareAnchor.d.ts

@@ -0,0 +1,37 @@
+export type HorizontalAnchor = 'start' | 'middle' | 'end';
+export type VerticalAnchor = 'top' | 'middle' | 'bottom';
+/** Rough estimate of rendered text width in pixels — character count × font size, not a real DOM measurement. Shared so a pre-render space reservation (e.g. domain padding) and this file's own overflow check agree on the same number. */
+export declare function estimateTextWidth(text: string, fontSize: number): number;
+export type AnchorPlacement = {
+    textAnchor: HorizontalAnchor;
+    lineAnchor: VerticalAnchor;
+    dx: number;
+    dy: number;
+};
+/**
+ * Flips (or nudges) a label's anchor/offset when its default placement
+ * would push it past a pixel box — e.g. the plot's own inner content box.
+ * `extent` estimates the rendered label size (character count × font size,
+ * not a real DOM measurement) deliberately: measuring via `getBBox()` and
+ * feeding the result back into anything reactive to the plot's own layout
+ * (like svelteplot's shared margin-auto-sizing context) risks a feedback
+ * loop between this component's own effect and svelteplot's — this stays
+ * self-contained and read-only against the live scale instead.
+ */
+export declare function resolveEdgeAwareAnchor(args: {
+    /** Pixel position of the anchored point. */
+    px: number;
+    py: number;
+    /** Size of the box the label must stay within — typically the plot's own inner content box. */
+    width: number;
+    height: number;
+    textAnchor: HorizontalAnchor;
+    lineAnchor: VerticalAnchor;
+    /** Desired distance from the point, in pixels — sign is resolved from the (possibly flipped) anchor. */
+    gapX: number;
+    gapY: number;
+    extent: {
+        width: number;
+        height: number;
+    };
+}): AnchorPlacement;

package/dist/utils/edgeAwareAnchor.js

@@ -0,0 +1,65 @@
+/** Rough estimate of rendered text width in pixels — character count × font size, not a real DOM measurement. Shared so a pre-render space reservation (e.g. domain padding) and this file's own overflow check agree on the same number. */
+export function estimateTextWidth(text, fontSize) {
+    return text.length * fontSize * 0.62;
+}
+/**
+ * Flips (or nudges) a label's anchor/offset when its default placement
+ * would push it past a pixel box — e.g. the plot's own inner content box.
+ * `extent` estimates the rendered label size (character count × font size,
+ * not a real DOM measurement) deliberately: measuring via `getBBox()` and
+ * feeding the result back into anything reactive to the plot's own layout
+ * (like svelteplot's shared margin-auto-sizing context) risks a feedback
+ * loop between this component's own effect and svelteplot's — this stays
+ * self-contained and read-only against the live scale instead.
+ */
+export function resolveEdgeAwareAnchor(args) {
+    const { px, py, width, height, gapX, gapY, extent } = args;
+    let { textAnchor, lineAnchor } = args;
+    let dx;
+    let dy;
+    if (textAnchor === 'start') {
+        dx = gapX;
+        if (px + dx + extent.width > width) {
+            textAnchor = 'end';
+            dx = -gapX;
+        }
+    }
+    else if (textAnchor === 'end') {
+        dx = -gapX;
+        if (px + dx - extent.width < 0) {
+            textAnchor = 'start';
+            dx = gapX;
+        }
+    }
+    else {
+        const half = extent.width / 2;
+        dx = 0;
+        if (px - half < 0)
+            dx = half - px;
+        else if (px + half > width)
+            dx = width - (px + half);
+    }
+    if (lineAnchor === 'top') {
+        dy = gapY;
+        if (py + dy + extent.height > height) {
+            lineAnchor = 'bottom';
+            dy = -gapY;
+        }
+    }
+    else if (lineAnchor === 'bottom') {
+        dy = -gapY;
+        if (py + dy - extent.height < 0) {
+            lineAnchor = 'top';
+            dy = gapY;
+        }
+    }
+    else {
+        const half = extent.height / 2;
+        dy = 0;
+        if (py - half < 0)
+            dy = half - py;
+        else if (py + half > height)
+            dy = height - (py + half);
+    }
+    return { textAnchor, lineAnchor, dx, dy };
+}

package/dist/utils/grouping.d.ts

@@ -1,4 +1,4 @@
-import type { AxisValue } from '../types/plots/axis';
+import type { AxisValue } from '../types/layout/scales';
 import type { Series, Accessor } from '../types/plots/data/common';
 /**
  * Splits rows into ordered groups keyed by the stringified accessor value.

package/dist/utils/interpolate.d.ts

@@ -1,6 +1,6 @@
 import type { EasingName, EasingFn } from '../types/charts/interpolate';
-import type { TimeValue, TimelineInterpolation } from '../types/charts/common';
-import type { AxisValue } from '../types/plots/axis';
+import type { TimeValue, TimelineInterpolation } from '../types/layout/timeline';
+import type { AxisValue } from '../types/layout/scales';
 import type { Accessor } from '../types/plots/data/common';
 export declare function resolveEasing(easing?: EasingName | EasingFn): EasingFn;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fundar/data-chart-telling",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "type": "module",
   "files": [
     "dist"
@@ -58,6 +58,7 @@
     "eslint-plugin-storybook": "^10.4.1",
     "eslint-plugin-svelte": "^3.17.0",
     "globals": "^17.4.0",
+    "knip": "^6.32.1",
     "playwright": "^1.60.0",
     "prettier": "^3.8.1",
     "prettier-plugin-svelte": "^3.5.1",
@@ -80,6 +81,7 @@
     "build": "svelte-package",
     "check": "svelte-check --tsconfig ./tsconfig.json",
     "check:watch": "svelte-check --tsconfig ./tsconfig.json --watch",
+    "check:unused-types": "knip --include types",
     "lint": "prettier --check . && eslint .",
     "format": "prettier --write .",
     "test": "vitest run --project=unit --project=browser",

package/dist/layout/geo/GeoLayout.svelte

@@ -1,51 +0,0 @@
-<script lang="ts">
-  import type { Snippet } from 'svelte';
-  import TileLayer from '../../plots/geo/TileLayer.svelte';
-  import type { GeoTileLayerConfig } from '../../types/plots/styles/geo';
-
-  /**
-   * Geo-only chrome nested inside `BasePlotLayout` (the `GeoPlot` analog of
-   * `AxisLayout`/`GridLayout`/`RuleLayout`) — just the pan/zoom transform
-   * group and the raster tile layer underneath the map's own marks.
-   * Everything else GeoPlot used to duplicate from `BasePlotLayout` (the hover
-   * state machine, `<Plot>` itself, `<Pointer>`, the tooltip) now lives
-   * exclusively in `BasePlotLayout`; the zoom/rotate *gesture* state itself lives
-   * in `GeoPlot`'s own `Plot.svelte` (it also feeds the projection's
-   * `rotate`, which has to reach `BasePlotLayout`'s `<Plot projection>` prop —
-   * something a component nested *inside* that same `<Plot>` has no way to
-   * reach back out to), and is only handed down here as an already-resolved
-   * `zoomTransform` to apply.
-   */
-  let {
-    width,
-    height,
-    numericMargins,
-    zoomTransform,
-    tileLayer,
-    dataLonLatBounds,
-    children,
-  }: {
-    width: number;
-    height: number;
-    numericMargins: { top: number; right: number; bottom: number; left: number };
-    zoomTransform: { x: number; y: number; k: number };
-    tileLayer?: GeoTileLayerConfig;
-    /** Forwarded to `TileLayer` — see `Plot.svelte`'s `dataLonLatBounds`. */
-    dataLonLatBounds?: [number, number, number, number] | null;
-    children: Snippet;
-  } = $props();
-</script>
-
-<g transform="translate({zoomTransform.x}, {zoomTransform.y}) scale({zoomTransform.k})">
-  {#if tileLayer}
-    <TileLayer
-      config={tileLayer}
-      left={numericMargins.left}
-      top={numericMargins.top}
-      width={Math.max(0, width - numericMargins.left - numericMargins.right)}
-      height={Math.max(0, height - numericMargins.top - numericMargins.bottom)}
-      {dataLonLatBounds}
-    />
-  {/if}
-  {@render children()}
-</g>

package/dist/layout/geo/GeoLayout.svelte.d.ts

@@ -1,24 +0,0 @@
-import type { Snippet } from 'svelte';
-import type { GeoTileLayerConfig } from '../../types/plots/styles/geo';
-type $$ComponentProps = {
-    width: number;
-    height: number;
-    numericMargins: {
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
-    };
-    zoomTransform: {
-        x: number;
-        y: number;
-        k: number;
-    };
-    tileLayer?: GeoTileLayerConfig;
-    /** Forwarded to `TileLayer` — see `Plot.svelte`'s `dataLonLatBounds`. */
-    dataLonLatBounds?: [number, number, number, number] | null;
-    children: Snippet;
-};
-declare const GeoLayout: import("svelte").Component<$$ComponentProps, {}, "">;
-type GeoLayout = ReturnType<typeof GeoLayout>;
-export default GeoLayout;

package/dist/layout/geo/resolveProjection.js

@@ -1,48 +0,0 @@
-/**
- * `data` (see `resolveProjection`) is one row per disjoint geometry *part*
- * (see `Plot.svelte`'s `hoverCandidates` — needed so hover-matching finds
- * every part of a multi-part feature, not just whichever one its combined
- * centroid happens to land near), not one row per feature. Several rows
- * therefore share the exact same `geometry` object by reference — spread
- * from the same tagged feature, only `__cx`/`__cy` differ. Deduping by that
- * reference before handing rows to d3-geo's bounds/fit computation matters:
- * a feature with many parts (e.g. a province whose `MultiPolygon` has
- * hundreds of small islands) would otherwise have its *entire* geometry
- * re-traversed once per part it contributed, an accidental O(parts²) cost
- * that got severe enough to be visible (multi-second) on real IGN data.
- */
-function dedupeByGeometry(data) {
-    const seen = new Set();
-    const result = [];
-    for (const row of data) {
-        if (seen.has(row.geometry))
-            continue;
-        seen.add(row.geometry);
-        result.push(row);
-    }
-    return result;
-}
-/**
- * Resolves a `GeoScalesConfig['projection']` into what svelteplot's own
- * `<Plot projection>` expects — kept separate from `GeoPlot`'s own
- * `Plot.svelte` so adding more projection-level behavior (like the
- * `domain: 'data'` sentinel below) doesn't grow that component itself.
- */
-export function resolveProjection(projection, data) {
-    if (!projection)
-        return 'equal-earth';
-    if (typeof projection === 'string')
-        return projection;
-    const domain = projection.domain === 'data'
-        ? { type: 'FeatureCollection', features: dedupeByGeometry(data) }
-        : projection.domain;
-    return {
-        type: projection.type,
-        rotate: projection.rotate,
-        center: projection.center,
-        parallels: projection.parallels,
-        inset: projection.inset,
-        clip: projection.clip,
-        domain,
-    };
-}

package/dist/layout/plot/GridLayout.svelte

@@ -1,30 +0,0 @@
-<script lang="ts" generics="TData extends Record<string, unknown>">
-  import { GridX, GridY } from 'svelteplot';
-  import type { AxisBasedScalesConfig } from '../../types/plots/props';
-
-  /**
-   * Grid lines for the plot kinds that have an x/y axis pair — opt-in via
-   * `scales.x.grid`/`scales.y.grid` (svelteplot's own implicit grid is a
-   * fixed, unstyled default, so this is drawn instead of that, not on top of
-   * it — see `BasePlotLayout`'s `finalizeScale`, which strips `grid` from what
-   * actually reaches `<Plot x y>`).
-   */
-  let { scales }: { scales?: AxisBasedScalesConfig<TData> } = $props();
-</script>
-
-{#if scales?.x?.grid}
-  <GridX
-    stroke={typeof scales.x.grid === 'object' ? scales.x.grid.stroke : undefined}
-    strokeWidth={typeof scales.x.grid === 'object' ? scales.x.grid.strokeWidth : undefined}
-    strokeOpacity={typeof scales.x.grid === 'object' ? scales.x.grid.strokeOpacity : undefined}
-    strokeDasharray={typeof scales.x.grid === 'object' ? scales.x.grid.strokeDasharray : undefined}
-  />
-{/if}
-{#if scales?.y?.grid}
-  <GridY
-    stroke={typeof scales.y.grid === 'object' ? scales.y.grid.stroke : undefined}
-    strokeWidth={typeof scales.y.grid === 'object' ? scales.y.grid.strokeWidth : undefined}
-    strokeOpacity={typeof scales.y.grid === 'object' ? scales.y.grid.strokeOpacity : undefined}
-    strokeDasharray={typeof scales.y.grid === 'object' ? scales.y.grid.strokeDasharray : undefined}
-  />
-{/if}

package/dist/layout/plot/RuleLayout.svelte

@@ -1,111 +0,0 @@
-<script lang="ts" generics="TData extends Record<string, unknown>">
-  import type { Snippet } from 'svelte';
-  import { RuleX, RuleY } from 'svelteplot';
-  import HoverMarker from '../../markers/HoverMarker.svelte';
-  import type { AxisValue } from '../../types/plots/axis';
-  import type { Series } from '../../types/plots/data/common';
-  import type { Marker } from '../../types/markers/common';
-  import type { HoverPoint } from '../../types/layout/tooltip';
-
-  /**
-   * Standalone rule markers (`ruleX`/`ruleY`/un-scoped `component`) plus the
-   * unscoped hover crosshair+dot+label — the plot kinds with an x/y axis pair
-   * only (line/bar/heatmap/pyramid); `GeoPlot` has no rule/crosshair concept
-   * of its own. Wraps `children` (the plot kind's actual marks) so both draw
-   * in the same order as before this was split out of `BasePlotLayout`: marks
-   * first, then rules/hover marker on top of them.
-   */
-  let {
-    markers = [],
-    seriesData = [],
-    matchedPoints,
-    ruleX,
-    ruleY,
-    impliesRuleX,
-    impliesRuleY,
-    showHoverLabels = true,
-    children,
-  }: {
-    markers?: Marker[];
-    /** All resolved series, forwarded to unscoped component markers (e.g. DeltaMarker). */
-    seriesData?: Series<TData>[];
-    matchedPoints: HoverPoint<TData>[];
-    ruleX: AxisValue | null;
-    ruleY: AxisValue | null;
-    impliesRuleX: boolean;
-    impliesRuleY: boolean;
-    showHoverLabels?: boolean;
-    children: Snippet;
-  } = $props();
-
-  const topLevelMarkers = $derived(
-    markers.filter(
-      (marker) =>
-        marker.type === 'ruleX' ||
-        marker.type === 'ruleY' ||
-        (marker.type === 'component' && !marker.series),
-    ),
-  );
-
-  /** The unscoped (no `series`) hover marker, if any. */
-  const unscopedHoverMarker = $derived(
-    markers.find((m) => m.type === 'hover' && !m.series) as
-      | Extract<Marker, { type: 'hover' }>
-      | undefined,
-  );
-
-  /**
-   * Gate ruleX display: shows when the strategy implies it (default) or the
-   * marker explicitly requests it (`ruleX: true`), and is never suppressed
-   * unless the marker explicitly disables it (`ruleX: false`).
-   */
-  const showRuleX = $derived(
-    unscopedHoverMarker != null &&
-    unscopedHoverMarker.ruleX !== false &&
-    (impliesRuleX || unscopedHoverMarker.ruleX === true),
-  );
-  const showRuleY = $derived(
-    unscopedHoverMarker != null &&
-    unscopedHoverMarker.ruleY !== false &&
-    (impliesRuleY || unscopedHoverMarker.ruleY === true),
-  );
-</script>
-
-{@render children()}
-
-{#each topLevelMarkers as marker, i (marker.type === 'ruleX' ? `${marker.type}-${marker.x}` : marker.type === 'ruleY' ? `${marker.type}-${marker.y}` : `${marker.type}-${i}`)}
-  {#if marker.type === 'ruleX'}
-    <RuleX
-      data={[{ xValue: marker.x }]}
-      x={(d) => d.xValue}
-      stroke={marker.style?.stroke ?? 'currentColor'}
-      strokeWidth={marker.style?.strokeWidth ?? 1}
-      strokeOpacity={marker.style?.strokeOpacity ?? 1}
-      strokeDasharray={marker.style?.strokeDasharray}
-    />
-  {:else if marker.type === 'ruleY'}
-    <RuleY
-      data={[{ yValue: marker.y }]}
-      y={(d) => d.yValue}
-      stroke={marker.style?.stroke ?? 'currentColor'}
-      strokeWidth={marker.style?.strokeWidth ?? 1}
-      strokeOpacity={marker.style?.strokeOpacity ?? 1}
-      strokeDasharray={marker.style?.strokeDasharray}
-    />
-  {:else if marker.type === 'component'}
-    <marker.component {...marker.props} data={marker.data ?? seriesData} />
-  {/if}
-{/each}
-
-{#if unscopedHoverMarker}
-  <HoverMarker
-    data={matchedPoints}
-    ruleX={showRuleX ? ruleX : null}
-    ruleY={showRuleY ? ruleY : null}
-    showLabels={unscopedHoverMarker.showLabels ?? showHoverLabels}
-    format={unscopedHoverMarker.format}
-    ruleStyle={unscopedHoverMarker.ruleStyle}
-    dotStyle={unscopedHoverMarker.dotStyle}
-    fontStyle={unscopedHoverMarker.fontStyle}
-  />
-{/if}

package/dist/plots/bar/BarSegments.svelte

@@ -1,69 +0,0 @@
-<script lang="ts" generics="TData extends Record<string, unknown>">
-  import { BarX, BarY } from 'svelteplot';
-  import { resolveAccessor } from '../utils/accessors';
-  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 { BarLayout } from './layout.svelte';
-
-  /**
-   * Renders one series' bars — the `'stacked'` branch (cumulative baseline
-   * from {@link BarLayout.stackedBaseline}) or the `'grouped'`/`'overlap'`
-   * branch (per-segment insets from {@link BarLayout.seriesStep}/`seriesGap`).
-   */
-  let {
-    group,
-    seriesIndex,
-    barLayout,
-    isHorizontal,
-    BarMark,
-    defaultColor,
-    disabledFill,
-  }: {
-    group: VisualGroup<Series<TData>, BarSegmentStyle>;
-    seriesIndex: number;
-    barLayout: BarLayout<TData>;
-    isHorizontal: boolean;
-    BarMark: typeof BarX | typeof BarY;
-    defaultColor: string;
-    disabledFill?: { fill?: string; fillOpacity?: number };
-  } = $props();
-
-  const xFn = $derived(resolveAccessor(group.series.x));
-  const yFn = $derived(resolveAccessor(group.series.y));
-</script>
-
-{#if barLayout.layout === 'stacked'}
-  {@const stackedBaselineFn = (d: TData) => barLayout.stackedBaseline(xFn(d), seriesIndex)}
-  {@const stackedTopFn = (d: TData) => barLayout.stackedBaseline(xFn(d), seriesIndex) + Number(yFn(d))}
-  <BarMark
-    data={group.series.data}
-    {...isHorizontal
-      ? { y: xFn, x1: stackedBaselineFn, x2: stackedTopFn }
-      : { x: xFn, y1: stackedBaselineFn, y2: stackedTopFn }}
-    fill={disabledFill?.fill ?? defaultColor}
-    fillOpacity={disabledFill?.fillOpacity ?? 1}
-  />
-{:else}
-  {#each group.visualSegments as seg, i (`${group.series.name}-${i}`)}
-    <BarMark
-      data={seg.data}
-      {...isHorizontal
-        ? { y: xFn, x1: barLayout.valueBaseline, x2: yFn }
-        : { x: xFn, y1: barLayout.valueBaseline, y2: yFn }}
-      fill={disabledFill?.fill ?? seg.style.fill ?? defaultColor}
-      fillOpacity={disabledFill?.fillOpacity ?? seg.style.fillOpacity ?? 1}
-      {...barLayout.layout === 'grouped'
-        ? isHorizontal
-          ? {
-              insetTop: seriesIndex * barLayout.seriesStep + barLayout.seriesGap / 2,
-              insetBottom: (barLayout.seriesCount - 1 - seriesIndex) * barLayout.seriesStep + barLayout.seriesGap / 2,
-            }
-          : {
-              insetLeft: seriesIndex * barLayout.seriesStep + barLayout.seriesGap / 2,
-              insetRight: (barLayout.seriesCount - 1 - seriesIndex) * barLayout.seriesStep + barLayout.seriesGap / 2,
-            }
-        : {}}
-    />
-  {/each}
-{/if}

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

@@ -1,60 +0,0 @@
-import type { SymbolType, LineStyle } from '../plots/constants';
-import type { StrokeStyle, DotStyle } from '../plots/styling';
-export type LegendSectionType = 'discrete' | 'continuous';
-/**
- * Style applied to whatever a legend interaction has turned "off" — a
- * toggled-off discrete series, or a datapoint/cell/feature outside an active
- * continuous range filter. `opacity` is a blanket convenience: any
- * `*Opacity` field a consumer doesn't set falls back to it, so
- * `{ opacity: 0.1 }` alone is enough to read as "disabled" everywhere.
- */
-export type LegendDisabledStyle = {
-    opacity?: number;
-    stroke?: StrokeStyle;
-    dots?: DotStyle;
-    fill?: string;
-    fillOpacity?: number;
-};
-export type LegendItem = {
-    name: string;
-    label?: string;
-    color?: string;
-    symbol?: SymbolType;
-    opacity?: number;
-    lineStyle?: LineStyle;
-    /** Initial toggled-off state (uncontrolled — the user can still click it back on). */
-    disabled?: boolean;
-};
-export type DiscreteLegendSection = {
-    type: 'discrete';
-    title?: string;
-    items: LegendItem[];
-    columns?: number;
-    /** Enables click-to-toggle on each item. */
-    interactive?: boolean;
-    /** Style applied to a toggled-off item's series. Falls back to `cfg.legend.disabledOpacity`. */
-    disabledStyle?: LegendDisabledStyle;
-};
-export type ContinuousLegendSection = {
-    type: 'continuous';
-    title?: string;
-    columns?: number;
-    min: number;
-    max: number;
-    colorMin?: string;
-    colorMax?: string;
-    ticks?: number[];
-    width?: number;
-    format?: (v: number) => string;
-    /** Enables drag handles on the bar's edges to narrow the visible range. */
-    interactive?: boolean;
-    /**
-     * How the color ramp responds to a narrowed range: `'rescale'` reprojects
-     * it onto the new bounds, `'filter'` keeps the original domain and only
-     * excludes out-of-range values. Defaults to `'filter'`.
-     */
-    mode?: 'rescale' | 'filter';
-    /** Style applied to values outside the active range. Falls back to `cfg.legend.disabledOpacity`. */
-    disabledStyle?: LegendDisabledStyle;
-};
-export type LegendSection = DiscreteLegendSection | ContinuousLegendSection;

package/dist/types/plots/delta.d.ts

@@ -1,19 +0,0 @@
-import type { AxisValue } from './axis';
-import type { StrokeStyle, FontStyle, DotStyle } from './styling';
-export type DeltaTarget = {
-    type: 'series';
-    series: string;
-} | {
-    type: 'axis';
-    value?: number;
-};
-export type DeltaConfig = {
-    axis: 'x' | 'y';
-    at: AxisValue;
-    from: DeltaTarget;
-    to?: DeltaTarget;
-    formatDiff?: (diff: number) => string;
-    strokeStyle?: StrokeStyle;
-    fontStyle?: FontStyle;
-    dotStyle?: DotStyle;
-};

package/dist/types/plots/styles/common.d.ts

@@ -1,52 +0,0 @@
-import type { ValueAnchor } from '../constants';
-import type { FontStyle, StrokeStyle } from '../styling';
-/**
- * Controls if and how value labels are rendered on a plot. The high-level
- * `anchor` sets sensible defaults for placement; `fontStyle` (`dx`, `dy`,
- * `textAnchor`, `lineAnchor`, `lineHeight`, `rotate`, `class`, `textClass`,
- * `fill`, …) overrides those defaults field-by-field when provided — mirrors
- * {@link DeltaConfig}'s `fontStyle`/`strokeStyle` split, so label text and
- * connector-line styling never mix into one flat bag of props.
- */
-export type ValuesStyle = {
-    show?: boolean;
-    anchor?: ValueAnchor;
-    /** Called with the numeric value and the series name. Return a string to render. */
-    format?: (value: number, seriesName: string) => string;
-    /** Text styling for the label itself. */
-    fontStyle?: FontStyle;
-    /**
-     * Style for the leader line drawn from a label displaced to clear an
-     * overlap with another series' label, back to its real data point.
-     * Labels only ever move when they'd otherwise collide — this is a no-op
-     * style until that happens. Falls back to a neutral grey, thin, solid
-     * stroke — deliberately not the series' own colour or stroke width, since
-     * matching the data line reads as more data rather than as a leader,
-     * right where several lines are already converging. Unset fields keep
-     * that fallback.
-     */
-    strokeStyle?: StrokeStyle;
-};
-/**
- * Color overrides for plots that derive their palette from data.
- * Each plot uses only the fields relevant to its kind; unused fields are
- * silently ignored.
- *
- * - `min` / `max` — sequential colour ramp endpoints (heatmap).
- * - `left` / `right` — diverging bar sides (pyramid).
- */
-export type ColorsStyle = {
-    min?: string;
-    max?: string;
-    left?: string;
-    right?: string;
-};
-/**
- * Top-level rendering style overrides shared by the non-geo plot kinds.
- * Passed as the `styles` prop. Each plot reads only the fields it cares
- * about.
- */
-export type BasePlotStyles = {
-    values?: ValuesStyle;
-    colors?: ColorsStyle;
-};