@fundar/data-chart-telling 0.0.64 → 1.0.0

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

@@ -1,6 +1,6 @@
-import type { EasingName, EasingFn } from '../charts/interpolate';
+import type { EasingName, EasingFn } from '../misc/easing';
 import type { GeoInsetLocation } from '../markers/geo';
-/** What the camera frames. `features` shares its id space with `segments`/`featureId`. `center` has no extent of its own — see `GeoCameraConfig.zoom`. */
+/** What the camera frames. `features` shares its id space with `segments`/`featureId`. `center` has no extent of its own - see `GeoCameraConfig.zoom`. */
 export type GeoCameraTarget = {
     features: string[];
 } | {
@@ -8,33 +8,23 @@ export type GeoCameraTarget = {
 } | {
     bounds: GeoJSON.GeoJsonObject;
 };
-/**
- * How the camera moves to a newly resolved target.
- * - `progress` unset: auto-plays once over `duration` ms, eased by `easing`.
- * - `progress` set (a live 0–1 value, e.g. from scroll): renders the move as
- *   a pure function of it instead — stalls/reverses with the input.
- */
+/** How the camera moves to a new target: auto-played over `duration` ms, or driven by a live 0-1 `progress`. */
 export type GeoCameraTransition = {
     /** Auto-play duration in ms, ignored once `progress` is set. Defaults to 750. */
     duration?: number;
     /** Same `EasingName | EasingFn` vocabulary as `styles.gaps`/`TimelineConfig.interpolate`. */
     easing?: EasingName | EasingFn;
-    /** A live 0–1 value the host drives itself instead of an auto-played duration. */
+    /** A live 0-1 value the host drives itself instead of an auto-played duration. */
     progress?: number;
-    /** Which way to interpolate rotation when ambiguous — only relevant for `orthographic`. `'shortest'` (default) or `'longest'`. No-op for 2D projections. */
+    /** Which way to interpolate rotation when ambiguous - only relevant for `orthographic`. `'shortest'` (default) or `'longest'`. No-op for 2D projections. */
     direction?: 'shortest' | 'longest';
 };
-/**
- * `coordinates.camera` — `GeoPlot`'s declarative "current viewpoint": frames,
- * zooms and anchors on `target`, animated on change. Realized as a
- * pixel-space pan/zoom transform for 2D projections, plus a `rotate`
- * override for `orthographic`. Composes with interactive `coordinates.pan`/`zoom`/`rotate`.
- */
+/** `coordinates.camera`: the viewpoint `GeoPlot` frames on `target`, animated on change. */
 export type GeoCameraConfig = {
     target: GeoCameraTarget;
     /** Multiplier on the auto-fit scale for a `features`/`bounds` target (`1` = tight fit). For a `center` target, used directly as the pixel scale instead. */
     zoom?: number;
-    /** Where the framed target lands within the plot frame — the same 9-point vocabulary `inset` markers use. Defaults to `'middle-middle'`. */
+    /** Where the framed target lands within the plot frame - the same 9-point vocabulary `inset` markers use. Defaults to `'middle-middle'`. */
     anchor?: GeoInsetLocation;
     /** Pixel gap kept between the framed target and whichever edge(s) `anchor` pushes it toward. Defaults to 24. */
     padding?: number;

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

@@ -1,27 +1,35 @@
 /**
  * Unified positional anchor for value labels across all plot kinds.
  *
- * - `'outside'` — beyond the tip of the mark (above a vertical bar, to the
+ * - `'outside'` - beyond the tip of the mark (above a vertical bar, to the
  *   far end of a horizontal bar or line). This is the only value with no
  *   direct svelteplot equivalent; the plot computes dx/dy internally.
- * - `'start'` — at the tip of the mark, just inside (top of a bar, far end
+ * - `'start'` - at the tip of the mark, just inside (top of a bar, far end
  *   of a pyramid bar from zero, right of a line's last point).
- * - `'middle'` — centred on the mark.
- * - `'end'` — at the baseline/zero end of the mark.
+ * - `'middle'` - centred on the mark.
+ * - `'end'` - at the baseline/zero end of the mark.
  */
 export type ValueAnchor = 'outside' | 'start' | 'middle' | 'end';
-export type SymbolType = 'circle' | 'square' | 'triangle' | 'line';
+/**
+ * Shared by two unrelated renderers: a `dot` mark's own point shape
+ * (delegated to svelteplot/d3-shape) and a discrete legend item's own icon
+ * (`DiscreteSymbolIcon.svelte`, the same shape fitted to the icon). `'line'` is legend-only - it represents
+ * a Line series' own swatch there, but isn't a real d3-shape symbol name, so
+ * a `dot` mark (or the `symbol` channel) given `'line'` renders as
+ * `'circle'` instead.
+ */
+export type SymbolType = 'circle' | 'square' | 'triangle' | 'line' | 'diamond' | 'star' | 'cross';
 export type LineStyle = 'solid' | 'dashed' | 'dotted' | 'dashdot';
 export type LineCap = 'butt' | 'round' | 'square';
 export type LineJoin = 'arcs' | 'bevel' | 'miter' | 'miter-clip' | 'round';
-/** `font-weight` keyword accepted by any text styling. */
-export type FontWeight = 'normal' | 'bold';
+/** `font-weight` accepted by any text styling: a keyword, or a numeric weight (100-900). */
+export type FontWeight = 'normal' | 'bold' | number;
 /** `font-style` keyword accepted by any text styling. */
 export type FontStyleKeyword = 'normal' | 'italic';
 /**
  * Horizontal text anchor. `'outside'` is only meaningful where the consuming
  * mark resolves it per-point from a signed x value (currently `HoverMarker`
- * only) — it anchors the label away from zero: `'start'` (extending right)
+ * only) - it anchors the label away from zero: `'start'` (extending right)
  * for a positive x, `'end'` (extending left) for negative. Elsewhere it's
  * treated the same as `'start'`.
  */

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

@@ -1,40 +1,48 @@
-import type { AxisValue } from '../../layout/scales';
+import type { AxisValue, AxisChannelName, ChannelAccessors } from '../../layout/mapping';
 /**
  * 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.
+ * so chart-level encodings (`x`, `y`, `color`, 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;
+ * 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>;
+    /** Tells apart series that share a `name`, such as one per facet panel. Defaults to `name`. */
+    id?: string;
+    /** The facet panel the series belongs to, once the "facet" phase splits it. */
+    panel?: string;
+    /** Horizontal position. A plot reading one position channel only (a histogram) takes either alone. */
+    x?: Accessor<T, AxisValue>;
+    /** Vertical position. */
+    y?: Accessor<T, AxisValue>;
+    /** The `color` channel's own accessor - a pre-built series is already one group, so this is purely the color value (per-name for most plot kinds; per-cell for HeatmapPlot). */
+    color?: Accessor<T, unknown>;
     data: T[];
 };
+/** The channels a pre-built {@link Series} carries itself, so a plot given `series` takes none of them. */
+type SeriesChannelName = AxisChannelName | 'color' | 'grouping';
 /**
- * Pre-built series. Mutually exclusive with {@link DataProps} — takes
- * precedence when both could apply.
+ * Pre-built series. Mutually exclusive with {@link DataProps} - takes
+ * precedence when both could apply. Any channel a series doesn't carry
+ * itself is still a plot-level prop.
  */
 export type SeriesProps<T extends Record<string, unknown>> = {
     series: Series<T>[];
     data?: never;
-    x?: never;
-    y?: never;
-    z?: never;
-};
+} & {
+    [K in SeriesChannelName]?: never;
+} & Omit<ChannelAccessors<T>, SeriesChannelName>;
 /**
  * Flat rows to group into series, as an alternative to {@link SeriesProps}.
+ * Takes every channel; `x`/`y` are required.
  */
 export type DataProps<T extends Record<string, unknown>> = {
     series?: never;
     data: T[];
-    x: Accessor<T, AxisValue>;
-    y: Accessor<T, AxisValue>;
-    z?: Accessor<T, unknown>;
-};
+} & ChannelAccessors<T> & Required<Pick<ChannelAccessors<T>, AxisChannelName>>;
+export {};

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

@@ -3,7 +3,7 @@ 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
+ * 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>;
@@ -12,7 +12,7 @@ export type GeoJsonInput<TProps extends Record<string, unknown>> = GeoJSON.Featu
  * 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`.
+ * consumers who haven't installed it - see `$lib/plots/utils/topojson`.
  */
 export type Topology = {
     type: 'Topology';
@@ -25,42 +25,56 @@ export type Topology = {
     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 contract for GeoPlot - the geo analog of {@link DataProps}/{@link SeriesProps}
+ * (`$lib/types/plots/data/common`). There's no x/y 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`.
+     * peer dependency) - see `object`.
      */
     data: GeoJsonInput<TProps> | Topology;
     /**
-     * Required when `data` is a `Topology` — the key under `topology.objects`
+     * 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
+     * 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)
+     * Optional continuous color-value accessor for choropleth coloring - the
+     * channel driving the ramp (mirrors heatmap's `color`), configured via
+     * `scales.color`. A feature with no `color` (or when omitted entirely)
      * falls back to `styles.fill`/`segments`.
      */
-    value?: (feature: GeoFeature<TProps>) => number | undefined;
+    color?: (feature: GeoFeature<TProps>) => number | undefined;
+    /**
+     * Optional structural grouping key - splits features into named buckets
+     * for `segments` to address by name (e.g. `segments.global_south`),
+     * independent of `color`. Unlike the axis-based plot kinds, this has no
+     * implicit default: `color` here is a per-feature *continuous* value, not
+     * a series-splitting key, so defaulting `grouping` to `color` would try
+     * to bucket by every distinct numeric value instead of leaving features
+     * ungrouped. A feature whose `grouping` value has no matching `segments`
+     * key simply falls through to `segments.default`/the plot-level ramp.
+     */
+    grouping?: (feature: GeoFeature<TProps>) => string | undefined;
+    /** Continuous or categorical opacity-value accessor - configure the ramp via `scales.opacity`. */
+    opacity?: (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
+     * 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
+     * `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).

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

@@ -1,54 +1,35 @@
-import type { EasingName } from '../charts/interpolate';
-import type { AxisValue } from '../layout/scales';
-/**
- * How one gap zone bridges its hole: `interpolate` eases the synthetic
- * segment's value between its two endpoints (defaults to `'linear'`, a
- * straight line); `style` is the per-mark shape drawn for it
- * ({@link LineSegmentStyle} for `LinePlot`), independent of that plot
- * kind's own default marker style unless the caller repeats it.
- */
+import type { EasingName } from '../misc/easing';
+import type { AxisValue } from '../layout/mapping';
+/** How one gap zone is bridged: `interpolate` eases the value (default `'linear'`), `style` draws it. */
 export type GapZoneConfig<TStyle> = {
     interpolate?: EasingName;
     style?: TStyle;
 };
 /**
- * A leading/trailing gap has only one real boundary — `x` (required to opt
- * in) is the domain value the synthetic segment extends to, and `y` is the
- * value it reaches there (defaults to holding the nearest real point's
- * value, i.e. a flat extrapolation). Omitting the zone entirely leaves that
- * end of the series unfilled — extrapolating without an explicit target
- * would imply data that doesn't exist.
- *
- * On `LinePlot`, `x`'s value is the actual spatial target the bridge draws
- * out to (its axis is continuous). On `BarPlot`/`PyramidPlot`, each gap row
- * already has its own real category, so `x`'s *presence* is only the opt-in
- * gate — its value isn't read; `y` is what drives the fill.
+ * A gap before the first or after the last real point: bridged out to `x`
+ * (required to fill it), reaching `y` there (default: the nearest real
+ * value). On bar plots only `x`'s presence matters.
  */
 export type OpenGapZoneConfig<TStyle> = GapZoneConfig<TStyle> & {
     x: AxisValue;
     y?: AxisValue;
 };
-/**
- * One series' gap-fill config: `start` (before its first real point),
- * `middle` (any internal run of missing rows, bounded by real data on both
- * sides) and `end` (after its last real point). A row counts as missing
- * when its resolved value is `null`, `undefined`, or `NaN` — the same
- * convention svelteplot's own `Line` mark already uses to break the line
- * there. See {@link GapsConfig} for how this is keyed per series on a
- * gap-aware plot kind's `styles.gaps`.
- */
+/** One series' gap fill: `start`, `middle` and `end`. A row is missing when its value is `null`, `undefined` or `NaN`. */
 export type GapZonesConfig<TStyle> = {
     start?: OpenGapZoneConfig<TStyle>;
     middle?: GapZoneConfig<TStyle>;
     end?: OpenGapZoneConfig<TStyle>;
 };
-/**
- * The `gaps` field a gap-aware plot kind's `styles` accepts (see
- * {@link GapsAwarePlotStylesConfig}, `types/layout/styles.ts`) — series name
- * (or `'default'` for all series) to that series' {@link GapZonesConfig}.
- * Mirrors `SegmentsConfig`'s series-keyed shape: a named entry applies only
- * to that series; `'default'` fills in whichever of its zones
- * (`start`/`middle`/`end`) the named entry itself leaves unset, at zone
- * granularity rather than a merged style.
- */
+/** `styles.gaps`: series name (or `'default'`) to its {@link GapZonesConfig}; `'default'` fills the zones a named entry leaves unset. */
 export type GapsConfig<TStyle> = Record<string, GapZonesConfig<TStyle>>;
+/** A point sampled along a gap-fill bridge, already resolved to plot data-space numbers. */
+export type GapPoint = {
+    x: number;
+    y: number;
+};
+/** One gap row's resolved fill - the interpolated value to render instead of the missing one, and which zone produced it. */
+export type DiscreteGapFill<TStyle> = {
+    value: number;
+    kind: 'start' | 'middle' | 'end';
+    style?: TStyle;
+};

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

@@ -0,0 +1,23 @@
+import type { BasePlotProps, PlotCoreProps } from '../props';
+import type { GeoScalesConfig, CoordinatesConfig } from '../../layout/coordinates';
+import type { GeoFeature, GeoDataProps } from '../data/geo';
+import type { GeoStylesConfig } from '../../layout/styles';
+import type { GeoSegmentStyle } from '../segments/common';
+import type { GeoMarkersConfig } from '../../markers/geo';
+import type { TimelineConfig } from '../../layout/timeline';
+import type { FacetConfig } from '../../layout/facet';
+/** `Omit` on each member of a union, so the union (and what tells its members apart) survives. */
+type OmitEach<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * `GeoPlot`'s public props. Its `timeline` and `facet` slice both the map's
+ * features (reading a field key from each feature's `properties`) and every
+ * marker's own `data` rows; a feature or row without the field is context,
+ * drawn in every slice.
+ */
+export type GeoPlotProps<TProps extends Record<string, unknown>> = OmitEach<BasePlotProps<GeoDataProps<TProps>, GeoFeature<TProps>, GeoStylesConfig<TProps>, GeoSegmentStyle, GeoMarkersConfig, GeoScalesConfig, CoordinatesConfig>, 'timeline' | 'facet'> & {
+    timeline?: TimelineConfig<Record<string, unknown>>;
+    facet?: FacetConfig<Record<string, unknown>>;
+};
+/** What `GeoPlot`'s core draws from. */
+export type GeoPlotCoreProps<TProps extends Record<string, unknown>> = PlotCoreProps<GeoDataProps<TProps>, GeoFeature<TProps>, GeoStylesConfig<TProps>, GeoSegmentStyle, GeoMarkersConfig, GeoScalesConfig, CoordinatesConfig>;
+export {};

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

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

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

@@ -0,0 +1,82 @@
+import type { Accessor } from '../data/common';
+import type { GeoFeature } from '../data/geo';
+import type { GeoScalesConfig } from '../../layout/coordinates';
+import type { SegmentsConfig, MarginConfig, HoverConfig } from '../props';
+import type { HoverPosition } from '../../phases';
+import type { TooltipProp } from '../../layout/tooltip';
+import type { GeoSegmentStyle } from '../segments/common';
+import type { GeoMarkersConfig } from '../../markers/geo';
+import type { MarkerConfig } from '../../markers/all';
+import type { PlotStylesConfig } from '../../configuration/styling';
+import type { LegendDisabledStyle } from '../../layout/legend';
+/** One feature tagged with its resolved id/centroid as plain fields. */
+export type TaggedGeoFeature<TProps extends Record<string, unknown>> = GeoFeature<TProps> & {
+    __id: string;
+    __cx: number;
+    __cy: number;
+};
+/** One resolved-style bucket of features - `opacity` is a second bucketing dimension alongside `style`, quantized so the channel produces a bounded number of mark instances. */
+export type GeoStyleGroup<TProps extends Record<string, unknown>> = {
+    style: GeoSegmentStyle;
+    opacity: number | undefined;
+    data: TaggedGeoFeature<TProps>[];
+};
+/** The active continuous-legend range filter, if any - mirrors HeatmapPlot's own. */
+export type GeoRangeFilter = {
+    min: number;
+    max: number;
+    mode: 'rescale' | 'filter';
+    disabledStyle: LegendDisabledStyle;
+};
+/** GeoPlot's shared pipeline state - raw props plus every phase's own output. */
+export type GeoPlotState<TProps extends Record<string, unknown>> = {
+    /** Already resolved to plain GeoJSON - TopoJSON's async conversion happens in `Plot.svelte` itself, before the pipeline runs. */
+    rawFeatures: GeoFeature<TProps>[];
+    featureId?: Accessor<GeoFeature<TProps>, string>;
+    /** Color-value accessor - see `GeoDataProps.color`. */
+    color?: (feature: GeoFeature<TProps>) => number | undefined;
+    /** Structural grouping-bucket accessor - see `GeoDataProps.grouping`. */
+    grouping?: (feature: GeoFeature<TProps>) => string | undefined;
+    /** Opacity-value accessor - see `GeoDataProps.opacity`. */
+    opacity?: (feature: GeoFeature<TProps>) => number | undefined;
+    excludeParts?: (part: {
+        centroid: [number, number];
+        geometry: GeoJSON.Geometry;
+    }, feature: TaggedGeoFeature<TProps>) => boolean;
+    segments: SegmentsConfig<GeoSegmentStyle>;
+    scales: GeoScalesConfig;
+    /** The plot's `tooltip`, which the "hover" phase reads. */
+    tooltip?: TooltipProp<TaggedGeoFeature<TProps>>;
+    /** The raw `markers` prop - GeoPlot interleaves it with the base map by draw order, not a plain append. */
+    authoredMarkers: GeoMarkersConfig[];
+    width: number;
+    height: number;
+    margins?: MarginConfig;
+    allFeatures?: TaggedGeoFeature<TProps>[];
+    features?: TaggedGeoFeature<TProps>[];
+    /** "scales" phase output: the `[min, max]` the color ramp spans, before any legend range narrows it - `undefined` without a `color`. */
+    colorDomain?: [number, number];
+    /** "scales" phase output: the `[min, max]` of the `opacity` values - `undefined` without an `opacity`. */
+    opacityDomain?: [number, number];
+    /** "scales" phase output: each feature's own resolved color, composed from `color` and the color ramp - `undefined` where `color` itself is unset/returns nothing. */
+    resolveColor?: (feature: GeoFeature<TProps>) => string | undefined;
+    /** "scales" phase output: each feature's own resolved opacity, composed from `opacity` and the opacity ramp - `undefined` where `opacity` itself is unset/returns nothing. */
+    resolveOpacity?: (feature: GeoFeature<TProps>) => number | undefined;
+    markers?: MarkerConfig[];
+    styleGroups?: GeoStyleGroup<TProps>[];
+    /** "tooltip" phase output: how a hovered feature reads, unless `tooltip.format` says otherwise. */
+    tooltipFormat?: (feature: GeoFeature<TProps>) => string;
+    hover?: HoverConfig<TaggedGeoFeature<TProps>>;
+    hoverPosition?: HoverPosition;
+    hoverRows?: TaggedGeoFeature<TProps>[];
+};
+/** The environment every GeoPlot phase reads from, alongside the growing state. */
+export type GeoPlotCtx<TProps extends Record<string, unknown>> = {
+    cfg: PlotStylesConfig;
+    range: GeoRangeFilter | null | undefined;
+    fill?: string;
+    fillOpacity?: number;
+    stroke?: string;
+    strokeWidth?: number;
+    onFeatureClick?: (d: TaggedGeoFeature<TProps>, e: Event) => void;
+};

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

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

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

@@ -0,0 +1,10 @@
+import type { BasePlotProps, PlotCoreProps } from '../props';
+import type { AxisBasedScalesConfig } from '../../layout/scales';
+import type { AxisBasedMarkersConfig } from '../../markers/common';
+import type { SeriesProps, DataProps } from '../data/common';
+import type { AxisBasedStylesConfig } from '../../layout/styles';
+import type { CellSegmentStyle } from '../segments/common';
+/** `HeatmapPlot`'s public props. */
+export type HeatmapPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, CellSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+/** What `HeatmapPlot`'s core draws from. */
+export type HeatmapPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, CellSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/heatmap/props.js

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

package/dist/types/plots/heatmap/state.d.ts

@@ -0,0 +1,28 @@
+import type { CellSegmentStyle } from '../segments/common';
+import type { ResolvedChannel, ResolvedChannels } from '../../layout/mapping';
+import type { LegendRange } from '../../layout/legend';
+import type { AxisPlotState, AxisPlotCtx } from '../../phases';
+/**
+ * The active continuous-legend range filter, if any - narrows which cells
+ * render at full opacity, and in `'rescale'` mode, the color domain itself.
+ */
+export type HeatmapRangeFilter = LegendRange;
+/**
+ * HeatmapPlot's pipeline state: the shared axis-based state, where `color` is
+ * each cell's value channel (so always resolved) rather than a grouping key.
+ */
+export type HeatmapPlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, CellSegmentStyle> & {
+    channels?: ResolvedChannels<TData> & {
+        color: ResolvedChannel<TData, unknown>;
+    };
+    /** "scales" phase output: each row's own resolved color, composed from `channels.color` and the color ramp. */
+    resolveColor?: (row: TData) => string;
+    /** "scales" phase output: the `[min, max]` of the `opacity` values - `undefined` unless `opacity` is numeric. */
+    opacityDomain?: [number, number];
+    /** "scales" phase output: each row's own resolved opacity, composed from `channels.opacity` and the opacity ramp - `undefined` when `opacity` itself is unset. */
+    resolveOpacity?: (row: TData) => number;
+};
+/** The environment every HeatmapPlot phase reads from, alongside the growing state. */
+export type HeatmapPlotCtx = AxisPlotCtx & {
+    range: HeatmapRangeFilter | null | undefined;
+};

package/dist/types/plots/heatmap/state.js

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

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

@@ -0,0 +1,18 @@
+import type { BasePlotProps, PlotCoreProps } from '../props';
+import type { AxisBasedScalesConfig } from '../../layout/scales';
+import type { AxisBasedMarkersConfig } from '../../markers/common';
+import type { SeriesProps, DataProps } from '../data/common';
+import type { AxisBasedStylesConfig } from '../../layout/styles';
+import type { AreaStyle } from '../styling';
+import type { AxisChannelName, ChannelAccessors } from '../../layout/mapping';
+/** Flat rows binned on one axis: `x` for vertical bars, or `y` alone for horizontal ones. A bin's count is its length. */
+type HistogramDataProps<TRow extends Record<string, unknown>> = Omit<DataProps<TRow>, AxisChannelName> & ((Required<Pick<ChannelAccessors<TRow>, 'x'>> & {
+    y?: never;
+}) | (Required<Pick<ChannelAccessors<TRow>, 'y'>> & {
+    x?: never;
+}));
+/** `HistogramPlot`'s public props. */
+export type HistogramPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | HistogramDataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+/** What `HistogramPlot`'s core draws from. */
+export type HistogramPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | HistogramDataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+export {};

package/dist/types/plots/histogram/props.js

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

package/dist/types/plots/histogram/state.d.ts

@@ -0,0 +1,6 @@
+import type { AreaStyle } from '../styling';
+import type { AxisPlotState, AxisPlotCtx } from '../../phases';
+/** HistogramPlot's pipeline state: the shared axis-based state, with no extras of its own. */
+export type HistogramPlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, AreaStyle>;
+/** The environment every HistogramPlot phase reads from, alongside the growing state. */
+export type HistogramPlotCtx = AxisPlotCtx;

package/dist/types/plots/histogram/state.js

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

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

@@ -0,0 +1,10 @@
+import type { BasePlotProps, PlotCoreProps } from '../props';
+import type { AxisBasedScalesConfig } from '../../layout/scales';
+import type { AxisBasedMarkersConfig } from '../../markers/common';
+import type { SeriesProps, DataProps } from '../data/common';
+import type { GapsAwarePlotStylesConfig } from '../../layout/styles';
+import type { LineSegmentStyle } from '../segments/common';
+/** `LinePlot`'s public props. */
+export type LinePlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, GapsAwarePlotStylesConfig<LineSegmentStyle>, LineSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+/** What `LinePlot`'s core draws from. */
+export type LinePlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, GapsAwarePlotStylesConfig<LineSegmentStyle>, LineSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

package/dist/types/plots/line/props.js

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

package/dist/types/plots/line/state.d.ts

@@ -0,0 +1,9 @@
+import type { GapsConfig } from '../gaps';
+import type { LineSegmentStyle } from '../segments/common';
+import type { AxisPlotState, AxisPlotCtx } from '../../phases';
+/** LinePlot's pipeline state: the shared axis-based state plus its gaps. */
+export type LinePlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, LineSegmentStyle> & {
+    gaps?: GapsConfig<LineSegmentStyle>;
+};
+/** The environment every LinePlot phase reads from, alongside the growing state. */
+export type LinePlotCtx = AxisPlotCtx;

package/dist/types/plots/line/state.js

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