@fundar/data-chart-telling 0.0.64 → 1.1.0

package/dist/types/markers/geo.d.ts

@@ -1,212 +1,10 @@
-import type { Snippet } from 'svelte';
-import type { Accessor } from '../plots/data/common';
-import type { AreaStyle, StrokeStyle } from '../plots/styling';
-import type { GeoFeature, GeoJsonInput } from '../plots/data/geo';
-import type { GeoSegmentStyle } from '../plots/segments/common';
-import type { GeoProjectionName } from '../layout/coordinates';
-import type { TooltipAnchorX, TooltipAnchorY } from '../layout/tooltip';
-import type { BaseMarkersConfig } from './base';
-/** Longitude/latitude gridlines — svelteplot's `Graticule`. */
-export type GeoGraticuleMarkerConfig = {
-    type: 'graticule';
-    step?: number;
-    stepX?: number;
-    stepY?: number;
-    style?: StrokeStyle;
-    /** Renders behind the base map's own fill/stroke instead of on top of it (markers otherwise draw over the base map). */
-    behind?: boolean;
-};
-/** The outer globe outline (for orthographic-type projections) — svelteplot's `Sphere`. */
-export type GeoSphereMarkerConfig = {
-    type: 'sphere';
-    style?: StrokeStyle & {
-        fill?: string;
-        fillOpacity?: number;
-    };
-    /** Renders behind the base map's own fill/stroke instead of on top of it — needed when `style.fill` is set. */
-    behind?: boolean;
-};
-/**
- * Arrows/spikes at points — svelteplot's `Vector`.
- * https://svelteplot.dev/examples/vector/shift-map
- */
-export type GeoVectorMarkerConfig<TRow extends Record<string, unknown> = Record<string, unknown>> = {
-    type: 'vector';
-    data: TRow[];
-    x: Accessor<TRow, number>;
-    y: Accessor<TRow, number>;
-    length?: Accessor<TRow, number> | number;
-    rotate?: Accessor<TRow, number> | number;
-    shape?: 'arrow' | 'spike' | 'arrow-filled';
-    anchor?: 'start' | 'middle' | 'end';
-    style?: {
-        fill?: string;
-        stroke?: string;
-        strokeWidth?: number;
-    };
-};
-/**
- * Geodesic-aware lines between point pairs — svelteplot's `Link` (its
- * `curve: 'auto'` traces a great-circle arc on a geographic projection).
- * https://svelteplot.dev/examples/link/spherical-link
- */
-export type GeoLinkMarkerConfig<TRow extends Record<string, unknown> = Record<string, unknown>> = {
-    type: 'link';
-    data: TRow[];
-    x1: Accessor<TRow, number>;
-    y1: Accessor<TRow, number>;
-    x2: Accessor<TRow, number>;
-    y2: Accessor<TRow, number>;
-    curve?: 'auto' | 'linear';
-    style?: StrokeStyle;
-};
-/**
- * Marching-squares contours from a scalar field — svelteplot's `Contour`.
- * https://svelteplot.dev/examples/contour/weather
- *
- * Two input modes: pass `data` (+ `x`/`y`/`value` row accessors) to
- * spatially interpolate a scatter of samples, or omit `data` and pass
- * `value` as an `(x, y) => number` sampling function.
- */
-export type GeoContourMarkerConfig<TRow extends Record<string, unknown> = Record<string, unknown>> = {
-    type: 'contour';
-    data?: TRow[];
-    x?: Accessor<TRow, number>;
-    y?: Accessor<TRow, number>;
-    value?: Accessor<TRow, number> | ((x: number, y: number) => number);
-    thresholds?: number | number[];
-    fill?: 'value' | string;
-    stroke?: 'value' | string;
-    blur?: number;
-    interpolate?: 'none' | 'nearest' | 'barycentric' | 'random-walk';
-    style?: {
-        strokeWidth?: number;
-        fillOpacity?: number;
-        strokeOpacity?: number;
-    };
-    /** Masks the contour to just the base map's landmass (`'land'`) or water (`'ocean'`). */
-    clip?: 'land' | 'ocean';
-    /** Renders behind the base map's own fill/stroke instead of on top of it. */
-    behind?: boolean;
-};
-/**
- * The in-map hover highlight — restyles the hovered feature's own shape.
- * Its own `type: 'geo-hover'` tag (rather than the axis-based `'hover'`)
- * keeps it unambiguous: both configs are all-optional, so an author writing
- * `{ type: 'hover' }` for a `GeoPlot` would otherwise be structurally
- * indistinguishable from the axis-based marker.
- */
-export type GeoHoverMarkerConfig = {
-    type: 'geo-hover';
-    style?: AreaStyle;
-};
-/**
- * Mounts an arbitrary Svelte component as a mark — the geo analog of
- * `CustomComponentMarkerConfig` (no `series` concept here). Its own
- * `type: 'geo-component'` tag (rather than the axis-based `'component'`)
- * keeps the two unambiguous at `GeometryLayout`'s dispatch — same reasoning
- * as `GeoHoverMarkerConfig`'s `'geo-hover'` tag.
- */
-export type GeoCustomComponentMarkerConfig = {
-    type: 'geo-component';
-    component: any;
-    props?: Record<string, unknown>;
-    data?: any[];
-};
-/**
- * Which edge of the plot frame an inset is anchored to, and where along it
- * — a `side-anchor` pair in either word order (`'bottom-right'` ==
- * `'right-bottom'`). `side` is `top`/`bottom`/`left`/`right`; `anchor` is
- * the same four plus `middle`.
- */
-export type GeoInsetLocation = 'top-left' | 'left-top' | 'top-middle' | 'middle-top' | 'top-right' | 'right-top' | 'middle-left' | 'left-middle' | 'middle-middle' | 'middle-right' | 'right-middle' | 'bottom-left' | 'left-bottom' | 'bottom-middle' | 'middle-bottom' | 'bottom-right' | 'right-bottom';
-/** Named projections an `inset` marker can use, minus `'identity'`/`'reflect-y'`, which have no scale/translate to auto-fit. */
-export type GeoInsetProjectionName = Exclude<GeoProjectionName, 'identity' | 'reflect-y'>;
-/**
- * Independent hover tooltip scoped to just one `inset` marker's own rendered
- * features, matched by nearest projected centroid within the inset's own
- * local mini-projection. Decoupled from the plot's own top-level `tooltip`.
- */
-export type GeoInsetTooltipConfig = {
-    /** Tooltip text for the nearest feature (by centroid) to the cursor, within this inset. */
-    format: (feature: GeoFeature<Record<string, unknown>>) => string;
-    /** Custom tooltip body; replaces `format` when given. */
-    content?: Snippet<[{
-        rows: GeoFeature<Record<string, unknown>>[];
-    }]>;
-    /**
-     * Preferred anchor for this inset's own tooltip. Unset falls back to the
-     * plot's own top-level `tooltip.anchorX`/`anchorY` when explicitly set
-     * there, then to the system default — see {@link TooltipAnchorX}.
-     */
-    anchorX?: TooltipAnchorX;
-    anchorY?: TooltipAnchorY;
-};
-/** Projection config for an `inset` marker — like `GeoProjectionConfig`, minus `inset`/`domain` (insets always auto-fit to their own content) and custom factories (which can't guarantee `fitExtent`). */
-export type GeoInsetProjectionConfig = GeoInsetProjectionName | {
-    type?: GeoInsetProjectionName;
-    rotate?: [number, number] | [number, number, number];
-    center?: [number, number];
-    parallels?: [number, number];
-    clip?: boolean | null | number | 'frame';
-};
-/**
- * A small, independently-projected map panel anchored to a corner/edge of
- * the plot, showing a region at a different scale than the main map. Shows
- * either a filtered subset of the plot's own `data` (via `features`) or a
- * wholly separate dataset (`data`, which takes precedence when both are
- * given).
- */
-export type GeoInsetMarkerConfig<TProps extends Record<string, unknown> = Record<string, unknown>> = {
-    type: 'inset';
-    location: GeoInsetLocation;
-    /** Feature ids (matching the plot's own `featureId`) to filter from the plot's own `data`. Ignored when `data` is set. */
-    features?: string[];
-    /**
-     * Narrows each `features`-matched feature to just the geometry parts that
-     * pass this predicate — same signature as `GeoDataProps.excludeParts`, so
-     * one feature's geometry can be split between the main map and this inset.
-     * Ignored when `data` is set.
-     */
-    featurePartsFilter?: (part: {
-        centroid: [number, number];
-        geometry: GeoJSON.Geometry;
-    }, feature: GeoFeature<TProps> & {
-        __id: string;
-    }) => boolean;
-    /** A separate GeoJSON dataset rendered inside the inset instead of a filtered subset of the plot's own `data`. TopoJSON isn't supported here. */
-    data?: GeoJsonInput<TProps>;
-    /** Projection for just this inset, independently fit to whatever it ends up showing. Defaults to `'mercator'`. */
-    projection?: GeoInsetProjectionConfig;
-    /** Inset box size as a fraction of the plot's own width/height. Defaults to `0.26`/`0.22`. */
-    width?: number;
-    height?: number;
-    /** Gap between the inset box and the plot's own edge, in pixels. Defaults to `8`. */
-    margin?: number;
-    style?: GeoSegmentStyle;
-    /** Independent hover tooltip for just this inset's own rendered features — see `GeoInsetTooltipConfig`. */
-    tooltip?: GeoInsetTooltipConfig;
-};
-/**
- * `GeoPlot`'s own `markers` prop type — unions {@link BaseMarkersConfig} with
- * every geo-only kind. Independent of `AxisBasedMarkersConfig`
- * (`types/markers/common.ts`): geo has no axis to `rule` against, and its
- * `hover`/`component` variants differ in shape from the axis-based kinds'.
- */
-export type GeoMarkersConfig = BaseMarkersConfig | GeoGraticuleMarkerConfig | GeoSphereMarkerConfig | GeoVectorMarkerConfig | GeoLinkMarkerConfig | GeoContourMarkerConfig | GeoHoverMarkerConfig | GeoCustomComponentMarkerConfig | GeoInsetMarkerConfig;
-/**
- * The base choropleth/base-map mark — one per distinct resolved feature
- * style. Never author-facing: `buildGeoMarkers` builds it from `GeoPlot`'s
- * own `styleGroups`.
- */
-export type GeoFeaturesMarkerConfig = {
-    type: 'geo';
-    data: Record<string, unknown>[];
-    fill: (d: any) => string;
-    fillOpacity?: number;
-    stroke?: string;
-    strokeWidth?: number;
-    onclick?: (e: Event, d: any) => void;
-    onpointerenter?: (e: Event, d: any) => void;
-    onpointerleave?: (e: Event) => void;
-};
+export * from './geo/graticule';
+export * from './geo/sphere';
+export * from './geo/vector';
+export * from './geo/link';
+export * from './geo/contour';
+export * from './geo/geoHover';
+export * from './geo/geoComponent';
+export * from './geo/features';
+export * from './geo/inset';
+export * from './geo/geoMarkersConfig';

package/dist/types/markers/geo.js

@@ -1 +1,10 @@
-export {};
+export * from './geo/graticule';
+export * from './geo/sphere';
+export * from './geo/vector';
+export * from './geo/link';
+export * from './geo/contour';
+export * from './geo/geoHover';
+export * from './geo/geoComponent';
+export * from './geo/features';
+export * from './geo/inset';
+export * from './geo/geoMarkersConfig';

package/dist/types/markers/traits.d.ts

@@ -0,0 +1,22 @@
+import type { LegendMark } from '../layout/legend';
+/** What the rest of the system needs to know about a marker kind, declared once per kind in `MarkerKinds`. */
+export type MarkerTraits = {
+    /**
+     * Whether the marker is cut off where it leaves the plot's frame (within
+     * `frameClip.tolerance`). Marks that stay inside by construction, or that
+     * are meant to overflow (dots, labels, arrows), don't clip. A marker's own
+     * `clip` prop overrides it.
+     */
+    clip: boolean;
+    /**
+     * Whether the marker draws the plot's own rows when it sets no `data`: a
+     * line, bar or area over the same data as the plot. Markers that are
+     * placed by their own props (a rule, a brush, a hover layer) don't.
+     */
+    drawsRows: boolean;
+    /**
+     * The symbol the marker takes in an automatic legend item: a line stroke, a
+     * dot, an area, a bar... A marker without one shows as a plain swatch.
+     */
+    legendSymbol?: LegendMark;
+};

package/dist/types/markers/traits.js

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

package/dist/types/misc/easing.js

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

package/dist/types/misc/viewport.js

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

package/dist/types/phases/data/axes.d.ts

@@ -0,0 +1,18 @@
+import type { AxisChannelName } from '../../layout/mapping';
+/** How an axis lays out its values: as distinct categories, along time, or along a numeric range. */
+export type AxisKind = 'discrete' | 'temporal' | 'continuous';
+/** Where an axis' kind came from: the author's `scales.*.type`, its values, or the plot kind needing a discrete axis. */
+export type AxisOrigin = 'explicit' | 'inferred' | 'promoted';
+/** One active position channel, as the "data" phase reads it. */
+export type InferredAxis = {
+    kind: AxisKind;
+    origin: AxisOrigin;
+};
+/** Which way a plot's marks run: a horizontal plot measures along `x`. */
+export type Orientation = 'vertical' | 'horizontal';
+/** The part an axis plays: the categories a plot sorts into, or the values it measures. */
+export type AxisRole = 'category' | 'value';
+/** An axis by name, or by the part it plays - resolved against a plot's own axes. */
+export type AxisRef = AxisChannelName | AxisRole;
+/** How many axes a plot kind needs as categories: none (line), one (bar), or both (heatmap). */
+export type DiscreteAxesCount = 0 | 1 | 2;

package/dist/types/phases/data/axes.js

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

package/dist/types/phases/data/phase.d.ts

@@ -0,0 +1,26 @@
+import type { Series } from '../../plots/data/common';
+import type { DiscreteAxesCount } from './axes';
+/** How a plot kind's own mark splits into visual segments. */
+export type SegmentsStageOptions = {
+    /** The color a segment's own style sets, if any, for the markers scoped to its series. */
+    color?: (style: any) => string | undefined;
+    /** Whether adjacent visual segments share their boundary row - a continuous mark (line, area) does. Defaults to `true`. */
+    connect?: boolean;
+};
+/**
+ * What differs between plots in the shared "data" stage. Everything else -
+ * which channels the author set, what each axis is, which way the plot runs,
+ * whether `color` groups - the stage reads off the data itself.
+ */
+export type DataStageOptions<TState, TCtx> = {
+    /** How many axes the kind lays out as categories: 0 (line), 1 (bar) or 2 (heatmap). Defaults to 0. */
+    discreteAxes?: DiscreteAxesCount;
+    /** How the kind's own mark splits into visual segments. */
+    segments?: SegmentsStageOptions;
+    /** Tags or reorders the series once built, before colors and legend filtering. */
+    orderSeries?: (series: Series<any>[], state: TState) => Series<any>[];
+    /** The order colors are assigned in. Defaults to the series' own order. */
+    colorOrder?: (series: Series<any>[]) => Series<any>[];
+    /** The plot's own extra "data" output, once the shared one is in place. */
+    extend?: (state: TState, ctx: TCtx) => TState;
+};

package/dist/types/phases/data/phase.js

@@ -0,0 +1,2 @@
+export {};
+/* eslint-enable @typescript-eslint/no-explicit-any */

package/dist/types/phases/facet/phase.d.ts

@@ -0,0 +1,18 @@
+import type { FacetConfig } from '../../layout/facet';
+/** One facet panel: its key, its label, and in a `rows`/`cols` grid its row and col values. */
+export type FacetPanel = {
+    key: string;
+    label: string;
+    row?: string;
+    col?: string;
+};
+/** What the "facet" phase reads from and writes to a plot's state. */
+export type FacetStageState = {
+    data?: Record<string, unknown>[];
+    series?: unknown[];
+    facet?: FacetConfig<any>;
+    /** Every panel the facet lays out, in layout order. */
+    panels?: FacetPanel[];
+    /** The panel a row belongs to: its own panel tag, or its facet values. `undefined` for a row no panel shows. */
+    panelOf?: (row: Record<string | symbol, unknown>) => string | undefined;
+};

package/dist/types/phases/facet/phase.js

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

package/dist/types/phases/hover/phase.d.ts

@@ -0,0 +1,40 @@
+import type { HoverDisplayPoint, HoverStrategy } from '../../layout/hover';
+import type { HoverConfig, PointMatchingStrategy } from '../../plots/props';
+/** Where a row sits for hover matching and the hover controller: its `x` and `y`. */
+export type HoverPosition = {
+    x: (row: never) => unknown;
+    y: (row: never) => unknown;
+};
+/**
+ * What differs between plots in the shared "hover" stage. Everything else -
+ * which axis the pointer matches along, which rows can be hovered (a gap
+ * row or a cell outside the legend's range can't), the rows themselves and
+ * their series' colors - the stage reads off the plot's own state.
+ */
+export type HoverStageOptions<TState, TCtx = unknown> = {
+    /**
+     * The hover strategy, when the plot's axes don't say it: along the axis
+     * that isn't measured, or `'punctual'` with both axes holding categories.
+     */
+    strategy?: HoverStrategy;
+    /** The rows the pointer hovers over, when they aren't the ones drawn (a box plot's one summary per box). Defaults to the processed rows. */
+    rows?: (state: TState) => Record<string | symbol, unknown>[];
+    /** How a hovered row reads in the tooltip unless the author sets `format`. Defaults to the shared tooltip text. */
+    format?: (state: TState) => (row: never) => string;
+    /** The order a tooltip's rows read in. Defaults to the shared order: highest value first. */
+    sort?: (state: TState) => (a: never, b: never) => number;
+    /** Where a row sits. Defaults to its processed position: a stacked row's top, a bin's centre. */
+    position?: (state: TState) => HoverPosition;
+    /** The short label drawn next to a hovered row. Defaults to its value. */
+    label?: (state: TState) => (row: never) => string;
+    /** What a hovered row reads as, e.g. with derived fields added. Defaults to the processed row. */
+    row?: (state: TState) => (row: never) => unknown;
+    /** Fields a candidate carries besides its place, label and series color (a grouped bar's `dx`/`dy`). */
+    decorate?: (state: TState, ctx: TCtx) => (row: never) => Partial<Omit<HoverDisplayPoint, 'x' | 'y' | 'label'>>;
+    /** Invisible markers that drive the plot's hover themselves (a bar's band), given its resolved hover config. */
+    hitAreas?: (state: TState, hover: HoverConfig<any>, ctx: TCtx) => {
+        type: string;
+    }[];
+    /** How a pointer event resolves to a candidate. Defaults to the nearest one. */
+    pointMatching?: PointMatchingStrategy;
+};

package/dist/types/phases/hover/phase.js

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

package/dist/types/phases/index.d.ts

@@ -0,0 +1,14 @@
+export type { PlotPhase, PhaseStage } from './stage';
+export type { AxisPlotState, AxisPlotCtx } from './state';
+export type { AxisPlotKind, AxisPlotDefaults, SharedScalesOptions } from './kind';
+export type { DataRunState } from './pipeline';
+export type { DataStageOptions } from './data/phase';
+export type { MappingStageOptions } from './mapping/phase';
+export type { ProcessedRow, ProcessedChannel, ProcessedChannelName, ProcessedData, TransformsStageState, TransformsStageOptions } from './transforms/phase';
+export type { StatisticsStageState, StatisticsStageOptions } from './statistics/phase';
+export type { SharedAxisValues } from './sharedScales/phase';
+export type { ScalesStageOptions } from './scales/phase';
+export type { StylesStageOptions, ValueLabelsOptions } from './styles/phase';
+export type { MarkersStageOptions } from './markers/phase';
+export type { FacetPanel, FacetStageState } from './facet/phase';
+export type { HoverStageOptions, HoverPosition } from './hover/phase';

package/dist/types/phases/index.js

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

package/dist/types/phases/kind.d.ts

@@ -0,0 +1,59 @@
+import type { DataStageOptions } from './data/phase';
+import type { MappingStageOptions } from './mapping/phase';
+import type { TransformsStageOptions, TransformsStageState } from './transforms/phase';
+import type { StatisticsStageOptions, StatisticsStageState } from './statistics/phase';
+import type { ScalesStageOptions } from './scales/phase';
+import type { HoverStageOptions } from './hover/phase';
+import type { StylesStageOptions } from './styles/phase';
+import type { MarkersStageOptions } from './markers/phase';
+import type { AxisChannelName, ChannelName } from '../layout/mapping';
+import type { AxisRole } from './data/axes';
+/**
+ * What one axis-based plot kind adds to the shared pipeline: options for each
+ * shared stage - its own marks and value labels among them.
+ */
+export type AxisPlotKind<TState extends TransformsStageState & StatisticsStageState, TCtx> = {
+    data?: DataStageOptions<TState, TCtx>;
+    mapping?: MappingStageOptions<TState, TCtx>;
+    transforms?: TransformsStageOptions<TState, TCtx>;
+    statistics?: StatisticsStageOptions<TState>;
+    scales?: ScalesStageOptions<TState, TCtx>;
+    styles?: StylesStageOptions<TState>;
+    markers: MarkersStageOptions<TState, TCtx>;
+    hover?: HoverStageOptions<TState, TCtx>;
+    /**
+     * How the slices of a plot (facet panels, timeline steps) share their
+     * domains. Every axis kind shares them - bands from its axes, zero from its
+     * "scales" options - so this is only for what those can't say.
+     */
+    sharedScales?: SharedScalesOptions;
+};
+/** How a plot kind shares its domains across slices, beyond what its axes and "scales" options say. */
+export type SharedScalesOptions = {
+    /**
+     * Channels whose shared domain is the one the kind's own "scales" phase sets
+     * over the rows that share it - for a domain nothing else can describe, like
+     * a heatmap's color ramp. A symmetric axis always takes its domain this way.
+     */
+    fromScalesPhase?: (AxisChannelName | 'color')[];
+};
+/**
+ * Everything an axis plot kind contributes, as defaults the shared machinery
+ * runs with: the options for each pipeline phase (its hover among them),
+ * plus how its plot tweens a timeline unless the author says otherwise.
+ */
+export type AxisPlotDefaults<TState extends TransformsStageState & StatisticsStageState, TCtx> = AxisPlotKind<TState, TCtx> & {
+    timeline?: {
+        /** Default for `timeline.filterMode`. */
+        filterMode?: 'exact' | 'upTo';
+        /**
+         * The channels a tweened timeline tweens (`value`) and matches rows across
+         * steps by (`key`) - by name, or by the part an axis plays (`'value'`,
+         * `'category'`), whichever way the plot runs.
+         */
+        interpolation?: {
+            value: ChannelName | AxisRole;
+            key: (ChannelName | AxisRole)[];
+        };
+    };
+};

package/dist/types/phases/kind.js

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

package/dist/types/phases/mapping/phase.d.ts

@@ -0,0 +1,5 @@
+/** What differs between plots in the shared "mapping" stage. */
+export type MappingStageOptions<TState, TCtx> = {
+    /** The plot's own extra "mapping" output, once every channel is resolved. */
+    extend?: (state: TState, ctx: TCtx) => TState;
+};

package/dist/types/phases/mapping/phase.js

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

package/dist/types/phases/markers/phase.d.ts

@@ -0,0 +1,13 @@
+import type { ValueLabels } from '../../../layout/styles/ValueLabels';
+import type { AxisBasedMarkersConfig, TextMarkerConfig } from '../../markers/common';
+/** What a plot kind adds to the shared "markers" stage. */
+export type MarkersStageOptions<TState, TCtx> = {
+    /** The plot's own marks - its bars, lines, dots... - drawn under every other marker. */
+    marks: (state: TState, ctx: TCtx) => AxisBasedMarkersConfig[];
+    /**
+     * Its value labels, once they show: `text` markers drawn over everything.
+     * The stage adds what every label shares - see {@link ValueLabels.hooks}.
+     * Without it, the plot draws none.
+     */
+    valueLabels?: (labels: ValueLabels, state: TState, ctx: TCtx) => TextMarkerConfig[];
+};

package/dist/types/phases/markers/phase.js

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

package/dist/types/phases/pipeline.d.ts

@@ -0,0 +1,10 @@
+import type { FacetStageState } from './facet/phase';
+/**
+ * What a {@link Pipeline.runData} leaves: every panel's part of the
+ * data phases, and the domains its slices (facet panels, timeline steps)
+ * share, keyed by panel - `''` for the whole run without a facet. Without a
+ * domain there, a slice fits its own. Author `scales` win.
+ */
+export type DataRunState = FacetStageState & {
+    sharedScales?: Record<string, object>;
+};

package/dist/types/phases/pipeline.js

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

package/dist/types/phases/scales/phase.d.ts

@@ -0,0 +1,26 @@
+import type { AxisChannelName } from '../../layout/mapping';
+import type { AxisRef } from '../data/axes';
+import type { AxisScale } from '../../layout/scales';
+/** One axis' scale options, whatever the row type. */
+type AnyAxisScale = AxisScale<any>;
+/**
+ * What differs between plots in the shared "scales" stage. The stage lays out
+ * every category axis the kind asks for as a band and grows an unpinned
+ * numeric axis to cover derived markers and transformed ranges; these say
+ * where a kind goes beyond that.
+ */
+export type ScalesStageOptions<TState, TCtx> = {
+    /** Axes whose marks grow from zero, so a domain this stage sets still reaches it - by name or by role (`'value'`). */
+    zero?: AxisRef[];
+    /** Axes that reach as far below zero as above it, to the largest magnitude - by name or by role. */
+    symmetric?: AxisRef[];
+    /** Keeps a category axis in the order the data gives it. Without it, categories sort ascending, as svelteplot does. */
+    bandOrder?: 'data';
+    /** The kind's own options for an axis, by name or by role, under the author's `scales`: padding, label anchor, tick format. */
+    defaults?: (state: TState, ctx: TCtx) => Partial<Record<AxisRef, AnyAxisScale>>;
+    /** The options the kind fits to its own marks on an axis the author left unpinned - a niced value axis, a domain padded for its dots. */
+    fit?: (state: TState, ctx: TCtx) => Partial<Record<AxisChannelName, Partial<AnyAxisScale>>>;
+    /** The kind's own extra "scales" output, once every scale is in place. */
+    extend?: (state: TState, ctx: TCtx) => TState;
+};
+export {};

package/dist/types/phases/scales/phase.js

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

package/dist/types/phases/sharedScales/phase.d.ts

@@ -0,0 +1,12 @@
+import type { AxisChannelName } from '../../layout/mapping';
+/** Every value one slice places on each axis, and how its kind lays those axes out. */
+export type SharedAxisValues = {
+    x: unknown[];
+    y: unknown[];
+    /** Axes laid out as bands (categories). */
+    band: AxisChannelName[];
+    /** Axes whose domain must include zero. */
+    zero: AxisChannelName[];
+    /** Whether its bands keep the order the data gives them, instead of sorting. */
+    dataOrder?: boolean;
+};

package/dist/types/phases/sharedScales/phase.js

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

package/dist/types/phases/stage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A grammar-of-graphics layer - facet, data, mapping, transforms, statistics,
+ * scales, markers, coordinates - plus `sharedScales`, the domains every slice
+ * of a plot shares, `tooltip`, how a hovered row reads once
+ * everything it reads from is placed, and `hover`, what the pointer can match.
+ */
+export type PlotPhase = 'facet' | 'data' | 'mapping' | 'transforms' | 'statistics' | 'sharedScales' | 'scales' | 'styles' | 'markers' | 'coordinates' | 'tooltip' | 'hover';
+/** A resolution step for one {@link PlotPhase} - same state shape in and out. Each shared phase is a class (`DataPhase`, `HoverPhase`...) that implements it. */
+export type PhaseStage<TState, TCtx = unknown> = {
+    phase: PlotPhase;
+    run: (state: TState, ctx: TCtx) => TState;
+};

package/dist/types/phases/stage.js

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