@fundar/data-chart-telling 0.0.64 → 1.0.0

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,34 @@
+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;
+    /** 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 {};

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

@@ -0,0 +1,73 @@
+import type { Series } from '../plots/data/common';
+import type { AxisBasedScalesConfig } from '../layout/scales';
+import type { SegmentsConfig, MarginConfig, HoverConfig, TooltipConfig } from '../plots/props';
+import type { HoverPosition } from './hover/phase';
+import type { VisualGroup } from '../plots/segments/config';
+import type { ScopedMarkerGroup } from '../layout/geometry';
+import type { ChannelAccessors, ResolvedChannels } from '../layout/mapping';
+import type { PlotStylesConfig } from '../configuration/styling';
+import type { AxisBasedMarkersConfig } from '../markers/common';
+import type { StatisticConfig } from '../layout/statistics';
+import type { MarkerTransform } from '../transforms';
+import type { ProcessedData } from './transforms/phase';
+import type { FacetStageState } from './facet/phase';
+import type { AxisBasedStylesConfig, ValuesStyle } from '../layout/styles';
+import type { ValueLabels } from '../../layout/styles/ValueLabels';
+import type { PlotInteraction } from '../../layout/interaction/PlotInteraction.svelte';
+import type { PlotAxes } from '../../phases/data/PlotAxes';
+import type { DiscreteGapFill, GapZonesConfig } from '../plots/gaps';
+/**
+ * The pipeline state every axis-based plot shares - raw props plus every
+ * phase's own output. A plot kind extends it with what only it has.
+ * `TSeries` is the series shape the "data" phase resolves, and `TRow` what
+ * `flat` holds, for a kind that tags its own rows.
+ */
+export type AxisPlotState<TData extends Record<string, unknown>, TStyle extends object, TSeries extends Series<TData> = Series<TData>, TRow = TData> = ChannelAccessors<TData> & {
+    series?: Series<TData>[];
+    data?: TData[];
+    segments?: SegmentsConfig<TStyle>;
+    scales: AxisBasedScalesConfig<TData>;
+    statistics?: StatisticConfig[];
+    transforms?: MarkerTransform[];
+    authorMarkers?: AxisBasedMarkersConfig[];
+    width: number;
+    height: number;
+    margins?: MarginConfig;
+    /** The plot's `styles`, which `BasePlotLayout` draws its frame from. */
+    styles?: AxisBasedStylesConfig;
+    /** The plot's `styles.values`, which its "markers" phase turns into a value-label `text` marker. */
+    values?: ValuesStyle;
+    /** The plot's `tooltip`, resolved: the "hover" phase reads it. */
+    tooltip?: TooltipConfig<TData>;
+    /** The plot's `styles.gaps`: how a discrete mark fills each series' missing values. */
+    gaps?: Record<string, GapZonesConfig<TStyle>>;
+    /** The plot's facet, which the "facet" phase splits the rows into panels by. */
+    facet?: FacetStageState['facet'];
+    panels?: FacetStageState['panels'];
+    panelOf?: FacetStageState['panelOf'];
+    /** What each position channel is, which one holds the categories, and which way the plot runs. */
+    axes?: PlotAxes;
+    resolvedSeries?: TSeries[];
+    /** Every series name, before legend-omitted ones are dropped, so colors stay put. */
+    allSeriesNames?: string[];
+    groupedSeries?: VisualGroup<TSeries, TStyle>[];
+    flat?: TRow[];
+    scopedGroups?: ScopedMarkerGroup<TData>[];
+    colorForSeries?: (name: string) => string;
+    /** A discrete mark's gap fills, per series id: the value each missing row is drawn at. */
+    gapFillMaps?: Map<string, Map<TData, DiscreteGapFill<TStyle>>>;
+    channels?: ResolvedChannels<TData>;
+    processedData?: ProcessedData;
+    valueLabels?: ValueLabels;
+    markers?: AxisBasedMarkersConfig[];
+    tooltipFormat?: (row: Record<string, unknown>) => string;
+    hover?: HoverConfig<any>;
+    hoverPosition?: HoverPosition;
+    hoverRows?: unknown[];
+};
+/** The environment every axis-based plot's phases read from, alongside the growing state. */
+export type AxisPlotCtx = {
+    cfg: PlotStylesConfig;
+    /** The legend's toggles and the figure's hover, read for one plot: which series show and how each dims. */
+    interaction?: PlotInteraction;
+};

package/dist/types/phases/state.js

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

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

@@ -0,0 +1,41 @@
+import type { ScopedMarkerGroup } from '../../layout/geometry';
+import type { Accessor, Series } from '../../plots/data/common';
+import type { AxisValue } from '../../layout/mapping';
+import type { StatisticConfig } from '../../layout/statistics';
+import type { AxisBasedMarkersConfig } from '../../markers/common';
+import type { ProcessedData } from '../transforms/phase';
+import type { FacetStageState } from '../facet/phase';
+import type { PlotAxes } from '../../../phases/data/PlotAxes';
+/**
+ * What the shared "statistics" stage reads from and writes to a plot's state.
+ * Every axis-based plot state carries these fields, so each satisfies it by shape.
+ */
+export type StatisticsStageState = Pick<FacetStageState, 'panels'> & {
+    x?: Accessor<any, AxisValue>;
+    y?: Accessor<any, AxisValue>;
+    grouping?: Accessor<any, unknown>;
+    color?: Accessor<any, unknown>;
+    statistics?: StatisticConfig[];
+    authorMarkers?: AxisBasedMarkersConfig[];
+    resolvedSeries?: Series<any>[];
+    axes?: PlotAxes;
+    flat?: any[];
+    colorForSeries?: (name: string) => string;
+    /** Each series' segments, which a `scope: 'segment'` author marker splits by. */
+    scopedGroups?: ScopedMarkerGroup<any>[];
+    /** The plot's rows after its own transforms, which an author marker without rows of its own draws. */
+    processedData?: ProcessedData;
+    markers?: AxisBasedMarkersConfig[];
+};
+/** What differs between plots in the shared "statistics" stage. */
+export type StatisticsStageOptions<TState extends StatisticsStageState> = {
+    /** The color an unscoped author marker inherits. Defaults to the first series' color. */
+    defaultColor?: (state: TState) => string | undefined;
+    /**
+     * Whether author markers inherit the plot's `grouping`/`color`. On by
+     * default; off for a plot whose `color` is a value channel, not a group.
+     */
+    inheritGrouping?: boolean;
+    /** Whether a line/area/dot author marker with no `x`/`y` takes the plot's own. */
+    inheritPositions?: boolean;
+};

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

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

package/dist/types/phases/statistics/source.d.ts

@@ -0,0 +1,20 @@
+import type { AxisValue } from '../../layout/mapping';
+/**
+ * Resolved `{data, x, y}` input a statistic computes over - a marker's own
+ * data, or one plot series/the pooled combination of every series. `x`/`y`
+ * use the same field-key-or-function shape every marker config's own `x`/`y` does.
+ */
+export type StatisticSource<T extends Record<string, unknown> = Record<string, unknown>> = {
+    data: T[];
+    x: string | ((d: any) => AxisValue);
+    y: string | ((d: any) => AxisValue);
+    /** Fallback stroke for the derived marker, used when its own `styles.stroke` is unset - typically the source series' own color. */
+    color?: string;
+};
+/**
+ * Color a derived statistic draws in when neither its own `styles` nor its
+ * source supplies one. A statistic's color is resolved in this order: its own
+ * explicit style, then its source's color (the marker's own color, or the
+ * plot's default series color - per group when grouped), then this.
+ */
+export declare const STATISTIC_FALLBACK_COLOR = "#000000";

package/dist/types/phases/statistics/source.js

@@ -0,0 +1,7 @@
+/**
+ * Color a derived statistic draws in when neither its own `styles` nor its
+ * source supplies one. A statistic's color is resolved in this order: its own
+ * explicit style, then its source's color (the marker's own color, or the
+ * plot's default series color - per group when grouped), then this.
+ */
+export const STATISTIC_FALLBACK_COLOR = '#000000';

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

@@ -0,0 +1,24 @@
+import type { EdgeBox } from '../../layout/box';
+import type { ValueLabels } from '../../../layout/styles/ValueLabels';
+import type { ValueAnchor } from '../../plots/constants';
+/** A plot kind's own defaults for its value labels, under the author's `styles.values`. */
+export type ValueLabelsOptions<TState> = {
+    /** Whether the labels draw when `styles.values.show` is unset. Defaults to `false`. */
+    show?: boolean;
+    /** Where a label sits when `styles.values.anchor` is unset. Defaults to `'outside'`. */
+    anchor?: ValueAnchor;
+    /** A label's text when `styles.values.format` is unset. Defaults to the bare value. */
+    format?: (value: number, seriesName: string) => string;
+    /**
+     * Where the labels are expected to sit, from the whole data: boxes around
+     * the points they label, on the plot edges those points can reach (see
+     * {@link ValueLabels.edgeBox}). The plot's margins keep their room, so the
+     * labels fit from the first render; without it they still grow to fit,
+     * once measured.
+     */
+    reach?: (labels: ValueLabels, state: TState) => EdgeBox[];
+};
+/** What differs between plots in the shared "styles" stage. */
+export type StylesStageOptions<TState> = {
+    values?: ValueLabelsOptions<TState>;
+};

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

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

package/dist/types/phases/transforms/adapter.d.ts

@@ -0,0 +1,27 @@
+export type Row = Record<string | symbol, unknown>;
+/** A transform's props once split: what svelteplot reads as channels, and what it takes as options. */
+export type TransformArgs = {
+    channels: Row;
+    options: Row;
+};
+/**
+ * Everything one transform type needs to run through svelteplot, and the fixes
+ * that type alone needs: `prepare` before it runs, `finish` on the marker once
+ * every transform has run. A type without a fix leaves the hook out.
+ */
+export type TransformAdapter = {
+    /** The keys svelteplot reads as channels; every other prop of the transform is an option. */
+    channelKeys: Record<string, true>;
+    /**
+     * Keys that, set on the transform, are reducers (options), while the
+     * marker's own channel of the same name is still read as the reducer's input
+     * - a `groupX`'s `y: 'sum'` sums the marker's `y`.
+     */
+    outputKeys?: Record<string, true>;
+    /** svelteplot's own function for this type, taking channels first and options second. */
+    run: (channels: Row, options: Row) => Row;
+    /** Fixes the split props before svelteplot sees them. */
+    prepare?: (args: TransformArgs) => TransformArgs;
+    /** Fixes the marker after all of its transforms have been merged onto it. */
+    finish?: (marker: Row) => Row;
+};

package/dist/types/phases/transforms/adapter.js

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

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

@@ -0,0 +1,40 @@
+import type { Series } from '../../plots/data/common';
+import type { MarkerTransform } from '../../transforms';
+import type { PlotAxes } from '../../../phases/data/PlotAxes';
+/** A row the plot-level transforms produced: the source row's fields, plus whatever channels they add (often symbol-keyed). */
+export type ProcessedRow = Record<string | symbol, unknown>;
+/** A channel as svelteplot reads it off a processed row: a field key, a symbol key, or a function. */
+export type ProcessedChannel = string | symbol | ((row: any) => unknown);
+/** The position channels a processed row can carry. */
+export type ProcessedChannelName = 'x' | 'y' | 'x1' | 'x2' | 'y1' | 'y2';
+/**
+ * Every visible series' rows after the plot-level transforms, as one set.
+ * With no transforms, they're the source rows read by the series' own `x`/`y`.
+ */
+export type ProcessedData = {
+    /** Every row, each tagged with its series name under `SERIES_KEY`. */
+    data: ProcessedRow[];
+    /** The channels that read those rows: the series' `x`/`y`, or what the transforms set (`x1`/`x2`, `y1`/`y2`…). */
+    channels: Partial<Record<ProcessedChannelName, ProcessedChannel>>;
+    /** The transforms' own mark options (e.g. a bin's insets), for the marks that draw these rows. */
+    options: Record<string, unknown>;
+    /** The transforms the rows went through, so a mark can apply each type's `finish` fix. */
+    transforms: MarkerTransform[];
+};
+/** What the shared "transforms" stage reads from and writes to a plot's state. */
+export type TransformsStageState = {
+    resolvedSeries?: Series<any>[];
+    axes?: PlotAxes;
+    /** Each series' gap fills, by series id: the value each missing row is drawn at. */
+    gapFillMaps?: Map<string, Map<unknown, {
+        value: number;
+        kind: string;
+    }>>;
+    transforms?: MarkerTransform[];
+    processedData?: ProcessedData;
+};
+/** What differs between plots in the shared "transforms" stage. */
+export type TransformsStageOptions<TState extends TransformsStageState, TCtx> = {
+    /** The transforms to run. Defaults to the plot's own `transforms`. */
+    transforms?: (state: TState, ctx: TCtx) => MarkerTransform[];
+};

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

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

package/dist/types/plots/area/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 { AreaStyle } from '../styling';
+/** `AreaPlot`'s public props. */
+export type AreaPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+/** What `AreaPlot`'s core draws from. */
+export type AreaPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, AxisBasedStylesConfig, AreaStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

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

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

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

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

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

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

package/dist/types/plots/bar/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 { BarSegmentStyle } from '../segments/common';
+/** `BarPlot`'s public props. */
+export type BarPlotProps<TData extends Record<string, unknown>> = BasePlotProps<SeriesProps<TData> | DataProps<TData>, TData, GapsAwarePlotStylesConfig<BarSegmentStyle>, BarSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;
+/** What `BarPlot`'s core draws from. */
+export type BarPlotCoreProps<TData extends Record<string, unknown>> = PlotCoreProps<SeriesProps<TData> | DataProps<TData>, TData, GapsAwarePlotStylesConfig<BarSegmentStyle>, BarSegmentStyle, AxisBasedMarkersConfig, AxisBasedScalesConfig<TData>>;

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

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

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

@@ -0,0 +1,6 @@
+import type { AxisPlotState, AxisPlotCtx } from '../../phases';
+import type { BarSegmentStyle } from '../segments/common';
+/** BarPlot's pipeline state: the shared axis-based state. */
+export type BarPlotState<TData extends Record<string, unknown>> = AxisPlotState<TData, BarSegmentStyle>;
+/** The environment every BarPlot phase reads from, alongside the growing state. */
+export type BarPlotCtx = AxisPlotCtx;

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

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