@fundar/data-chart-telling 0.0.14 → 0.0.16

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

@@ -0,0 +1,40 @@
+import type { AxisValue } from '../axis';
+/**
+ * A field key or accessor function. Mirrors the shorthand used across plots
+ * so chart-level encodings (`x`, `y`, `z`, facet, timeline) feel consistent
+ * with the plot-level series definitions.
+ */
+export type Accessor<TRow extends Record<string, unknown>, V> = keyof TRow | ((d: TRow) => V);
+/**
+ * A plot series: a name, x/y accessors and the rows it draws. Shared as-is by
+ * every mark (line, bar, …) — none of them need anything beyond this shape;
+ * visual styling lives separately in `segments`.
+ */
+export type Series<T extends Record<string, unknown> = Record<string, unknown>> = {
+    name: string;
+    x: Accessor<T, AxisValue>;
+    y: Accessor<T, AxisValue>;
+    z?: Accessor<T, unknown>;
+    data: T[];
+};
+/**
+ * Pre-built series. Mutually exclusive with {@link DataProps} — takes
+ * precedence when both could apply.
+ */
+export type SeriesProps<T extends Record<string, unknown>> = {
+    series: Series<T>[];
+    data?: never;
+    x?: never;
+    y?: never;
+    z?: never;
+};
+/**
+ * Flat rows to group into series, as an alternative to {@link SeriesProps}.
+ */
+export type DataProps<T extends Record<string, unknown>> = {
+    series?: never;
+    data: T[];
+    x: Accessor<T, AxisValue>;
+    y: Accessor<T, AxisValue>;
+    z?: Accessor<T, unknown>;
+};

package/dist/types/plots/data/common.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,74 @@
+import type { Accessor } from './common';
+/**
+ * One GeoJSON feature, generically typed over its `properties`. Intersected
+ * with `Record<string, unknown>` so it satisfies the same generic bound
+ * every other row type in this package does (e.g. `TooltipConfig<TRow
+ * extends Record<string, unknown>>`) — GeoJSON's own `Feature` type has no
+ * index signature on its own.
+ */
+export type GeoFeature<TProps extends Record<string, unknown> = Record<string, unknown>> = GeoJSON.Feature<GeoJSON.Geometry, TProps> & Record<string, unknown>;
+export type GeoJsonInput<TProps extends Record<string, unknown>> = GeoJSON.FeatureCollection<GeoJSON.Geometry, TProps> | GeoFeature<TProps>[];
+/**
+ * Minimal structural shape of a TopoJSON `Topology` object. Deliberately not
+ * imported from `topojson-client`'s own types, so referencing it never forces
+ * module resolution of that (optional peer) package at typecheck time for
+ * consumers who haven't installed it — see `$lib/plots/utils/topojson`.
+ */
+export type Topology = {
+    type: 'Topology';
+    objects: Record<string, unknown>;
+    arcs: unknown[][];
+    transform?: {
+        scale: [number, number];
+        translate: [number, number];
+    };
+    bbox?: number[];
+};
+/**
+ * Data contract for GeoPlot — the geo analog of {@link DataProps}/{@link SeriesProps}
+ * (`$lib/types/plots/data/common`). There's no x/y/z axis pair for geographic data:
+ * `data` IS the map.
+ */
+export type GeoDataProps<TProps extends Record<string, unknown> = Record<string, unknown>> = {
+    /**
+     * GeoJSON is always accepted. A TopoJSON `Topology` is also accepted, but
+     * only converted at runtime if `topojson-client` is installed (an optional
+     * peer dependency) — see `object`.
+     */
+    data: GeoJsonInput<TProps> | Topology;
+    /**
+     * Required when `data` is a `Topology` — the key under `topology.objects`
+     * to convert via topojson-client's `feature()`. Ignored for GeoJSON input.
+     */
+    object?: string;
+    /**
+     * Resolves each feature's stable id — used as the `segments` lookup key
+     * (e.g. `segments.argentina`) and for hover/click identification. Defaults
+     * to `feature.id ?? feature.properties?.id ?? feature.properties?.name`.
+     */
+    featureId?: Accessor<GeoFeature<TProps>, string>;
+    /**
+     * Optional continuous value accessor for choropleth coloring (mirrors
+     * heatmap's `z`). A feature with no `value` (or when omitted entirely)
+     * falls back to `styles.fill`/`segments`.
+     */
+    value?: (feature: GeoFeature<TProps>) => number | undefined;
+    /**
+     * Excludes matching parts of a feature's geometry from the map's own
+     * rendering and hover/click matching — e.g. so a separate `inset` marker
+     * (via its own `featurePartsFilter`) can take over showing that part
+     * elsewhere without it being drawn twice. Runs once per disjoint part of
+     * each feature's geometry (each polygon of a `MultiPolygon`, each line of
+     * a `MultiLineString`; any other geometry type is a single part). Return
+     * `true` to exclude that part — excluding every part of a feature drops
+     * it entirely, which also covers omitting a whole feature from the map.
+     * `segments` styling is unaffected (still keyed by whole-feature
+     * `featureId`, applied to whatever geometry remains).
+     */
+    excludeParts?: (part: {
+        centroid: [number, number];
+        geometry: GeoJSON.Geometry;
+    }, feature: GeoFeature<TProps> & {
+        __id: string;
+    }) => boolean;
+};

package/dist/types/plots/data/geo.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,5 +1,5 @@
-import type { AxisValue } from './common';
-import type { StrokeStyle, FontStyle, DotStyle } from './styles';
+import type { AxisValue } from './axis';
+import type { StrokeStyle, FontStyle, DotStyle } from './styling';
 export type DeltaTarget = {
     type: 'series';
     series: string;

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

@@ -1,23 +1,112 @@
-import type { Marker } from './markers';
-import type { TooltipRuntime } from '../layout/tooltip';
-import type { PlotStyles, Segments } from './styles';
-import type { SeriesProps, DataProps, ScalesConfig, MarginConfig } from './common';
+import type { TooltipOptions } from '../layout/tooltip';
+import type { Segment } from './segments/config';
+import type { AxisScale } from './axis';
+import type { GeoProjectionConfig } from './scales/geo';
+/** The `styles` prop accepted by every plot kind — its own
+ * styles shape ({@link BasePlotStyles}, `GeoStyles`, …). */
+export type StylesConfig<TStyles extends object> = TStyles;
+/** The `markers` prop accepted by every plot kind — a list of that
+ * kind's own marker union ({@link Marker}, `GeoMarker`, …). */
+export type MarkersConfig<TMarker> = TMarker[];
 /**
- * Common props accepted by every plot component (bar, line, heatmap, pyramid,
- * …). The `TSegmentStyle` parameter lets each plot narrow `segments` to its
- * own style shape ({@link BarSegmentStyle}, {@link LineSegmentStyle}, etc.)
- * while keeping everything else shared.
+ * The `segments` prop accepted by every plot kind.
  *
- * Data can be provided either as pre-built {@link SeriesProps} or as flat
- * rows via {@link DataProps}.
+ * A record mapping series names (or `'default'` for all series) to lists of
+ * {@link Segment}s. Segments in a named key apply only to that series;
+ * segments under `'default'` apply to every series.
+ *
+ * ```ts
+ * segments: {
+ *   female:  [{ style: { stroke: { stroke: 'tomato' } } }],   // catch-all for female
+ *   male:    [{ style: { stroke: { stroke: 'steelblue' } } }], // catch-all for male
+ *   default: [{ areas: [{ x: { from: 2012, to: 2014 } }], style: { dots: { dotSymbol: 'circle' } } }],
+ * }
+ * ```
+ *
+ * Within each resolved series list, catch-alls (no `areas`) are evaluated last
+ * so that area-specific segments always override them, regardless of position.
+ * Area-specific segments also inherit any style key absent from their own style
+ * by merging the catch-all as a baseline — the area's own style wins on conflict.
+ * This lets you set a series colour once in a catch-all and add per-range dots
+ * or dash patterns without repeating the colour on every area segment.
+ */
+export type SegmentsConfig<TStyle> = Record<string, Segment<TStyle>[]>;
+/**
+ * Partial margin override — only the sides you specify are overridden; the
+ * rest come from the theme (which itself defaults every side to `'auto'`).
+ * `'auto'` sizes that side to fit its rendered content (tick labels, axis
+ * title, rotated ticks); a number pins it exactly.
+ */
+export type MarginConfig = Partial<{
+    top: number | 'auto';
+    right: number | 'auto';
+    bottom: number | 'auto';
+    left: number | 'auto';
+}>;
+/**
+ * The `tooltip` prop a plot actually receives — the chart's resolved form of
+ * the author-facing {@link TooltipOptions} (which a chart accepts as a bare
+ * `boolean` or the full object via `TooltipProp`): `format`/`sync` become
+ * required once resolved, and `facetId` identifies the originating facet
+ * (`''` when not faceted). Presence of this object on a plot is what turns
+ * hovering on.
+ */
+export type TooltipConfig<TRow extends Record<string, unknown>> = Omit<TooltipOptions<TRow>, 'format' | 'sync'> & {
+    format: (row: TRow) => string;
+    sync: boolean;
+    facetId: string;
+};
+/**
+ * Per-axis scale overrides, passed as a single `scales` prop to every
+ * axis-based plot kind (`GeoPlot` uses {@link GeoScalesConfig} instead — a
+ * map has no x/y/z axis pair). `TData` threads through to
+ * {@link AxisScale.sort} on each axis.
+ */
+export type AxisBasedScalesConfig<TData = Record<string, unknown>> = {
+    x?: AxisScale<TData>;
+    y?: AxisScale<TData>;
+    z?: AxisScale<TData>;
+};
+/**
+ * `scales` prop for GeoPlot — the geo analog of {@link AxisBasedScalesConfig}.
+ * A map has no x/y/z axis pair, so this configures the projection and the
+ * choropleth colour domain instead.
+ */
+export type GeoScalesConfig = {
+    /** Which map projection to draw with. Defaults to `'equal-earth'`. */
+    projection?: GeoProjectionConfig;
+    /** Continuous choropleth value domain — mirrors heatmap's `scales.z.domain`. */
+    color?: {
+        domain?: [number, number];
+    };
+};
+/**
+ * The `scales` prop accepted by every plot kind — either flavor of scale
+ * config a plot kind can have ({@link AxisBasedScalesConfig} for the
+ * axis-based kinds, {@link GeoScalesConfig} for `GeoPlot`). Each concrete
+ * `Plot.svelte` narrows `BasePlotProps`'s `TScales` to exactly the one
+ * that applies to it, rather than accepting this whole union.
+ */
+export type ScalesConfig<TData = Record<string, unknown>> = AxisBasedScalesConfig<TData> | GeoScalesConfig;
+/**
+ * The shared "prop bag" every plot component accepts, parameterized over
+ * everything that varies by plot kind: `TDataContract` is the kind's own
+ * data shape ({@link SeriesProps}`|`{@link DataProps} for the axis-based
+ * kinds, `GeoDataProps` for `GeoPlot`), `TRow` is what `tooltip` resolves
+ * against, and `TStyles`/`TSegmentStyle`/`TMarker`/`TScales` are that kind's
+ * own segment/style/marker/scale shapes. Each `Plot.svelte` instantiates
+ * this directly with its own concrete arguments rather than going through a
+ * shared per-kind alias — segments/styles/markers already diverge in shape
+ * across kinds today (or will soon), so a shared alias would just be an
+ * extra layer to keep in sync.
  */
-export type PlotProps<TData extends Record<string, unknown>, TSegmentStyle extends object = object> = (SeriesProps<TData> | DataProps<TData>) & {
+export type BasePlotProps<TDataContract, TRow extends Record<string, unknown>, TStyles extends object, TSegmentStyle extends object, TMarker, TScales extends ScalesConfig<TRow>> = TDataContract & {
     width: number;
     height: number;
-    styles?: PlotStyles;
-    segments?: Segments<TSegmentStyle>;
-    markers?: Marker[];
-    scales?: ScalesConfig;
+    styles?: StylesConfig<TStyles>;
+    segments?: SegmentsConfig<TSegmentStyle>;
+    markers?: MarkersConfig<TMarker>;
+    scales?: TScales;
     margins?: MarginConfig;
-    tooltip?: TooltipRuntime<TData>;
+    tooltip?: TooltipConfig<TRow>;
 };

package/dist/types/plots/scales/geo.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The projection names svelteplot's `<Plot projection>` accepts as a string
+ * (svelteplot itself doesn't export this as a type — defined here so authors
+ * get autocomplete/type-checking over the full supported set).
+ */
+export type GeoProjectionName = 'albers-usa' | 'albers' | 'azimuthal-equal-area' | 'azimuthal-equidistant' | 'conic-conformal' | 'conic-equal-area' | 'conic-equidistant' | 'equal-earth' | 'equirectangular' | 'gnomonic' | 'identity' | 'reflect-y' | 'mercator' | 'orthographic' | 'stereographic' | 'transverse-mercator';
+import type { GeoProjection } from 'd3-geo';
+/**
+ * What a custom projection factory (e.g. `argentinaBicontinental` under
+ * `$lib`'s geo projections) must return — just enough of d3's `GeoProjection`
+ * for svelteplot to stream marks through it and invert pointer coordinates
+ * back to lon/lat. Deliberately narrower than importing `GeoProjection`
+ * itself, since a hand-tuned custom projection may not implement its full
+ * surface (e.g. no single `scale`/`translate` describing it).
+ */
+export type GeoCustomProjection = Pick<GeoProjection, 'stream'> & Partial<Pick<GeoProjection, 'invert'>>;
+/**
+ * A custom projection factory, usable as `scales.projection.type` alongside
+ * (instead of) a `GeoProjectionName`. svelteplot calls this with the plot's
+ * inner width/height (already net of margins/insets) and expects a
+ * ready-to-use projection back.
+ */
+export type GeoCustomProjectionFactory = (opts: {
+    width: number;
+    height: number;
+}) => GeoCustomProjection;
+export type GeoProjectionConfig = GeoProjectionName | {
+    type?: GeoProjectionName | GeoCustomProjectionFactory;
+    rotate?: [number, number] | [number, number, number];
+    center?: [number, number] | [number, number, number];
+    parallels?: [number, number] | [number, number, number];
+    inset?: number;
+    clip?: boolean | null | number | 'frame';
+    /**
+     * Fits the projection's scale/translate to this GeoJSON object's extent
+     * instead of the projection's own default (whole-world-sized) framing,
+     * regardless of which named projection is active. Also what makes
+     * `'identity'`/`'reflect-y'` (which otherwise have no scale/translate of
+     * their own — they pass lon/lat through as-is) size themselves to fill
+     * the plot. Pass `'data'` to fit to whatever was already given to the
+     * plot's own `data` prop, instead of repeating it here.
+     */
+    domain?: GeoJSON.GeoJsonObject | GeoJSON.FeatureCollection | GeoJSON.Feature | 'data';
+};

package/dist/types/plots/scales/geo.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,25 @@
+import type { StrokeStyle, DotStyle } from '../styling';
+/** Per-segment styling for a line: its stroke and/or its endpoint dots. */
+export type LineSegmentStyle = {
+    stroke?: StrokeStyle;
+    dots?: DotStyle;
+};
+/** Per-segment styling for a bar-shaped mark: its fill. Shared by `BarPlot` and `PyramidPlot`. */
+export type BarSegmentStyle = {
+    fill?: string;
+    fillOpacity?: number;
+};
+/** Per-cell styling override for a heatmap cell. */
+export type CellSegmentStyle = {
+    fill?: string;
+    fillOpacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+};
+/** Per-feature styling override for `GeoPlot` — the geo analog of `CellSegmentStyle`. */
+export type GeoSegmentStyle = {
+    fill?: string;
+    fillOpacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+};

package/dist/types/plots/segments/common.js

@@ -0,0 +1 @@
+export {};

package/dist/types/plots/segments/config.d.ts

@@ -0,0 +1,51 @@
+import type { AxisValue } from '../axis';
+import type { Series } from '../data/common';
+import type { LineSegmentStyle } from './common';
+/** A half-open interval on one axis. Both bounds are inclusive; omit either to leave that end open. */
+export type Range = {
+    from?: AxisValue;
+    to?: AxisValue;
+};
+/**
+ * A 2-D rectangular area on the plot, addressed by optional x and y intervals.
+ * Omitting an interval leaves that axis unrestricted (matches all values).
+ *
+ * - For line/bar/pyramid plots only the `x` interval is used (the series' primary
+ *   axis); `y` is evaluated but filters by the series' value axis.
+ * - For heatmaps both `x` (column) and `y` (row) are used to address cells.
+ */
+export type Area = {
+    x?: Range;
+    y?: Range;
+};
+/**
+ * One styled rule for a plot. A data point (or cell) is styled when it falls
+ * inside **any** of the listed `areas`. Omitting `areas` (or passing an empty
+ * array) makes the segment a catch-all that matches every data point — useful
+ * as a baseline style. `TStyle` is the per-mark shape ({@link LineSegmentStyle},
+ * {@link BarSegmentStyle}, {@link CellSegmentStyle}, …).
+ *
+ * Catch-alls are evaluated last so that area-specific segments always take
+ * priority, regardless of their position in the list. A catch-all placed first
+ * therefore acts as a fallback baseline that area-specific segments override.
+ */
+export type Segment<TStyle> = {
+    areas?: Area[];
+    style?: TStyle;
+};
+/** One contiguous, styled slice of a series' data — ready to draw as its own mark. */
+export type VisualSegment<T extends Record<string, unknown>, TStyle = LineSegmentStyle> = {
+    data: T[];
+    style: TStyle;
+};
+/**
+ * A series split into its styled visual segments. `S` is the full series
+ * type Series<T> — its row type is read off `S['data']`
+ * rather than taken as a separate parameter, since TypeScript can't reliably
+ * infer a type parameter that only appears inside another parameter's
+ * constraint.
+ */
+export type VisualGroup<S extends Series<any>, TStyle = LineSegmentStyle> = {
+    series: S;
+    visualSegments: VisualSegment<S['data'][number], TStyle>[];
+};

package/dist/types/plots/segments/config.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,37 @@
+import type { ValueAnchor } from '../constants';
+import type { FontStyle } from '../styling';
+/**
+ * Controls if and how value labels are rendered on a plot. The high-level
+ * `anchor` sets sensible defaults for placement; the inherited {@link FontStyle}
+ * fields (`dx`, `dy`, `textAnchor`, `lineAnchor`, `lineHeight`, `rotate`,
+ * `class`, `textClass`, `fill`, …) override those defaults when provided.
+ */
+export type ValuesStyle = FontStyle & {
+    show?: boolean;
+    anchor?: ValueAnchor;
+    /** Called with the numeric value and the series name. Return a string to render. */
+    format?: (value: number, seriesName: string) => string;
+};
+/**
+ * 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;
+};

package/dist/types/plots/styles/common.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,42 @@
+import type { ColorsStyle } from './common';
+import type { GeoFeature } from '../data/geo';
+export type GeoTileLayerConfig = {
+    /** XYZ tile URL template, e.g. `'https://tile.openstreetmap.org/{z}/{x}/{y}.png'`. */
+    url: string;
+    attribution?: string;
+    opacity?: number;
+    minZoom?: number;
+    maxZoom?: number;
+    /** Tile edge length in pixels. Defaults to `256`. */
+    tileSize?: number;
+};
+export type GeoZoomConfig = {
+    min?: number;
+    max?: number;
+    initial?: {
+        x?: number;
+        y?: number;
+        k?: number;
+    };
+};
+/**
+ * `styles` prop for GeoPlot — the geo analog of `BasePlotStyles`. Unlike the
+ * other plot kinds, GeoPlot's styling needs (base map, choropleth ramp, tile
+ * background, zoom, click handling) are unlike anything x/y plots need, so
+ * this is its own type rather than a reuse of `BasePlotStyles`.
+ */
+export type GeoStyles<TProps extends Record<string, unknown> = Record<string, unknown>> = {
+    /** Base map fill, used when a feature isn't styled by `segments` or the choropleth ramp. */
+    fill?: string;
+    fillOpacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+    /** Continuous choropleth ramp endpoints — used when `value` is provided on data. Mirrors heatmap's `styles.colors`. */
+    colors?: ColorsStyle;
+    /** Raster XYZ tile basemap under the vector geometry. Mercator-family projections only. */
+    tileLayer?: GeoTileLayerConfig;
+    /** `true`/config enables drag-pan + scroll-zoom. Omitted/`false` = static map. */
+    zoom?: boolean | GeoZoomConfig;
+    /** Fired when a base-map feature is clicked. */
+    onFeatureClick?: (feature: GeoFeature<TProps>, event: Event) => void;
+};

package/dist/types/plots/styles/geo.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,45 @@
+import type { FontWeight, FontStyleKeyword, TextAnchor, LineAnchor, LineStyle, LineCap, LineJoin, SymbolType } from './constants';
+/** Text/label styling for any text mark — a marker's label, an annotation, a value label. */
+export type FontStyle = {
+    fill?: string;
+    fontSize?: number;
+    fontWeight?: FontWeight;
+    fontStyle?: FontStyleKeyword;
+    textAnchor?: TextAnchor;
+    lineAnchor?: LineAnchor;
+    lineHeight?: number;
+    rotate?: number;
+    stroke?: string;
+    strokeWidth?: number;
+    paintOrder?: string;
+    dx?: number;
+    dy?: number;
+    class?: string;
+    textClass?: string;
+};
+/** Stroke styling for any line-ish mark — a line, a rule, a marker's connector. */
+export type StrokeStyle = {
+    stroke?: string;
+    strokeWidth?: number;
+    strokeOpacity?: number;
+    strokeDasharray?: string | LineStyle;
+    strokeLinecap?: LineCap;
+    strokeLinejoin?: LineJoin;
+};
+/**
+ * Dot styling for any point mark — a line's endpoint dots, a marker's dot.
+ * Carries its own `dotStroke*` fields rather than nesting a {@link StrokeStyle},
+ * because a dot's outline is a distinct style from the stroke of the line (or
+ * other mark) it sits next to — e.g. a `LineSegmentStyle` styles its
+ * line's stroke and its dots' outline independently.
+ */
+export type DotStyle = {
+    dotRadius?: number;
+    dotFill?: string;
+    dotFillOpacity?: number;
+    dotSymbol?: SymbolType;
+    dotStroke?: string;
+    dotStrokeWidth?: number;
+    dotStrokeOpacity?: number;
+    dotStrokeDasharray?: string | LineStyle;
+};

package/dist/types/plots/styling.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/grouping.d.ts

@@ -1,4 +1,5 @@
-import type { Series, AxisValue, Accessor } from '../types/plots/common';
+import type { AxisValue } from '../types/plots/axis';
+import type { Series, Accessor } from '../types/plots/data/common';
 /**
  * Splits rows into ordered groups keyed by the stringified accessor value.
  * Insertion order of first appearance is preserved, which keeps colours stable

package/dist/utils/interpolate.d.ts

@@ -1,6 +1,7 @@
 import type { EasingName, EasingFn } from '../types/charts/interpolate';
 import type { TimeValue, TimelineInterpolation } from '../types/charts/common';
-import type { Accessor, AxisValue } from '../types/plots/common';
+import type { AxisValue } from '../types/plots/axis';
+import type { Accessor } from '../types/plots/data/common';
 export declare function resolveEasing(easing?: EasingName | EasingFn): EasingFn;
 /**
  * Brackets a continuous target position `x` within one key-group's sorted

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fundar/data-chart-telling",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "type": "module",
   "files": [
     "dist"
@@ -18,46 +18,60 @@
     }
   },
   "dependencies": {
-    "d3-interpolate": "^3.0.1"
+    "@types/geojson": "^7946.0.16",
+    "d3-geo": "^3.1.1",
+    "d3-interpolate": "^3.0.1",
+    "d3-selection": "^3.0.0",
+    "d3-zoom": "^3.0.0"
   },
   "peerDependencies": {
     "svelte": "^5.0.0",
-    "svelteplot": "^0.14.0"
+    "svelteplot": "^0.14.0",
+    "topojson-client": "^3.1.0"
+  },
+  "peerDependenciesMeta": {
+    "topojson-client": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@chromatic-com/storybook": "^5.2.1",
     "@eslint/compat": "^2.0.4",
     "@eslint/js": "^10.0.1",
+    "@storybook/addon-a11y": "^10.4.1",
+    "@storybook/addon-docs": "^10.4.1",
+    "@storybook/addon-svelte-csf": "^5.1.2",
+    "@storybook/addon-vitest": "^10.4.1",
+    "@storybook/svelte-vite": "^10.4.1",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
+    "@types/d3-geo": "^3.1.0",
     "@types/d3-interpolate": "^3.0.4",
+    "@types/d3-selection": "^3.0.11",
+    "@types/d3-zoom": "^3.0.8",
     "@types/node": "^22",
     "@vitest/browser": "^4.1.7",
     "@vitest/browser-playwright": "^4.1.7",
+    "@vitest/coverage-v8": "4.1.7",
     "eslint": "^10.2.0",
     "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-storybook": "^10.4.1",
     "eslint-plugin-svelte": "^3.17.0",
     "globals": "^17.4.0",
     "playwright": "^1.60.0",
     "prettier": "^3.8.1",
     "prettier-plugin-svelte": "^3.5.1",
     "publint": "^0.3.18",
+    "storybook": "^10.4.1",
     "svelte": "^5.55.2",
     "svelte-check": "^4.4.6",
     "svelteplot": "^0.14.0",
+    "topojson-client": "^3.1.0",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.1",
     "vite": "^8.0.7",
     "vitest": "^4.1.3",
-    "vitest-browser-svelte": "^2.1.1",
-    "storybook": "^10.4.1",
-    "@storybook/svelte-vite": "^10.4.1",
-    "@storybook/addon-svelte-csf": "^5.1.2",
-    "@chromatic-com/storybook": "^5.2.1",
-    "@storybook/addon-vitest": "^10.4.1",
-    "@storybook/addon-a11y": "^10.4.1",
-    "@storybook/addon-docs": "^10.4.1",
-    "eslint-plugin-storybook": "^10.4.1",
-    "@vitest/coverage-v8": "4.1.7"
+    "vitest-browser-svelte": "^2.1.1"
   },
   "keywords": [
     "svelte"