@fundar/data-chart-telling 0.0.64 → 1.1.0

package/dist/layout/plot/Plot.svelte.d.ts

@@ -0,0 +1,49 @@
+import type { Component } from 'svelte';
+import { Pipeline } from '../../phases/Pipeline';
+import type { TooltipProp } from '../../types/layout/tooltip';
+import type { MarginConfig, PlotChromeConfig } from '../../types/plots/props';
+import type { PlotCellContext, PlotCellSnippet, PlotCoreBase } from '../../types/layout/plot';
+import type { FacetConfig } from '../../types/layout/facet';
+import type { TimelineConfig } from '../../types/layout/timeline';
+import type { AxisPlotDefaults } from '../../types/phases';
+declare function $$render<TRow extends Record<string, unknown>, TScales extends object, TCore extends PlotCoreBase>(): {
+    props: PlotChromeConfig & {
+        Core?: Component<any, Record<string, never>, "margins">;
+        core?: TCore;
+        defaults?: () => AxisPlotDefaults<any, any> | Pipeline<any, any>;
+        slice?: (cell: PlotCellContext<TRow, TScales>) => TCore;
+        cell?: PlotCellSnippet<TRow, TScales>;
+        margins?: MarginConfig;
+        tooltip?: TooltipProp<TRow>;
+        /** The rows `timeline` and `facet` slice. Defaults to `core.data`. */
+        data?: TRow[];
+        width?: number;
+        height?: number;
+        markers?: {
+            type: string;
+        }[];
+        timeline?: TimelineConfig<TRow>;
+        facet?: FacetConfig<TRow>;
+    };
+    exports: {};
+    bindings: "margins";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<TRow extends Record<string, unknown>, TScales extends object, TCore extends PlotCoreBase> {
+    props(): ReturnType<typeof $$render<TRow, TScales, TCore>>['props'];
+    events(): ReturnType<typeof $$render<TRow, TScales, TCore>>['events'];
+    slots(): ReturnType<typeof $$render<TRow, TScales, TCore>>['slots'];
+    bindings(): "margins";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <TRow extends Record<string, unknown>, TScales extends object, TCore extends PlotCoreBase>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TRow, TScales, TCore>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TRow, TScales, TCore>['props']>, ReturnType<__sveltets_Render<TRow, TScales, TCore>['events']>, ReturnType<__sveltets_Render<TRow, TScales, TCore>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TRow, TScales, TCore>['bindings']>;
+    } & ReturnType<__sveltets_Render<TRow, TScales, TCore>['exports']>;
+    <TRow extends Record<string, unknown>, TScales extends object, TCore extends PlotCoreBase>(internal: unknown, props: ReturnType<__sveltets_Render<TRow, TScales, TCore>['props']> & {}): ReturnType<__sveltets_Render<TRow, TScales, TCore>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any, any>['bindings']>;
+}
+declare const Plot: $$IsomorphicComponent;
+type Plot<TRow extends Record<string, unknown>, TScales extends object, TCore extends PlotCoreBase> = InstanceType<typeof Plot<TRow, TScales, TCore>>;
+export default Plot;

package/dist/layout/plot/PlotContext.d.ts

@@ -0,0 +1,41 @@
+import type { PlotHover } from '../hover/PlotHover.svelte';
+import type { LegendState } from '../legend/LegendState.svelte';
+import type { TimelineState } from '../timeline/TimelineState.svelte';
+import type { PlotMargins } from '../margins/PlotMargins.svelte';
+import type { PlotAxes } from '../../phases/data/PlotAxes';
+/** What a plot's context is built from; the functions are read reactively. */
+export type PlotContextParts<T extends Record<string, unknown>> = {
+    hover: PlotHover<T>;
+    legend: LegendState | null;
+    timeline: TimelineState | null;
+    margins: PlotMargins;
+    scales: () => object | undefined;
+    axes: () => PlotAxes | undefined;
+    data: () => T[];
+    size: () => {
+        width: number;
+        height: number;
+    };
+};
+/**
+ * Everything one plot is, gathered where what draws inside it can reach it:
+ * its hover, its figure's legend and timeline, its margins, scales, axes, rows and box. The
+ * mutable side; {@link PublicPlotContext} is what a user gets to read.
+ */
+export declare class PlotContext<T extends Record<string, unknown> = Record<string, unknown>> {
+    #private;
+    readonly hover: PlotHover<T>;
+    readonly legend: LegendState | null;
+    readonly timeline: TimelineState | null;
+    readonly margins: PlotMargins;
+    constructor(parts: PlotContextParts<T>);
+    /** The enclosing plot's context, or `null` outside one. Call during component init. */
+    static current(): PlotContext | null;
+    /** A new context for everything drawn below. Call during component init. */
+    static provide<T extends Record<string, unknown>>(parts: PlotContextParts<T>): PlotContext<T>;
+    get scales(): object | undefined;
+    get axes(): PlotAxes | undefined;
+    get data(): T[];
+    get width(): number;
+    get height(): number;
+}

package/dist/layout/plot/PlotContext.js

@@ -0,0 +1,46 @@
+import { getContext, setContext } from 'svelte';
+const PLOT_CONTEXT_KEY = Symbol('dct-plot-context');
+/**
+ * Everything one plot is, gathered where what draws inside it can reach it:
+ * its hover, its figure's legend and timeline, its margins, scales, axes, rows and box. The
+ * mutable side; {@link PublicPlotContext} is what a user gets to read.
+ */
+export class PlotContext {
+    hover;
+    legend;
+    timeline;
+    margins;
+    #parts;
+    constructor(parts) {
+        this.#parts = parts;
+        this.hover = parts.hover;
+        this.legend = parts.legend;
+        this.timeline = parts.timeline;
+        this.margins = parts.margins;
+    }
+    /** The enclosing plot's context, or `null` outside one. Call during component init. */
+    static current() {
+        return getContext(PLOT_CONTEXT_KEY) ?? null;
+    }
+    /** A new context for everything drawn below. Call during component init. */
+    static provide(parts) {
+        const context = new PlotContext(parts);
+        setContext(PLOT_CONTEXT_KEY, context);
+        return context;
+    }
+    get scales() {
+        return this.#parts.scales();
+    }
+    get axes() {
+        return this.#parts.axes();
+    }
+    get data() {
+        return this.#parts.data();
+    }
+    get width() {
+        return this.#parts.size().width;
+    }
+    get height() {
+        return this.#parts.size().height;
+    }
+}

package/dist/layout/plot/PublicPlotContext.d.ts

@@ -0,0 +1,131 @@
+import { usePlot as usePlotFromSvelteplot } from 'svelteplot';
+import { HoverState } from '../hover/HoverState.svelte';
+import { LegendState } from '../legend/LegendState.svelte';
+import { PlotContext } from './PlotContext';
+import { TimelineState } from '../timeline/TimelineState.svelte';
+import type { PlotHover } from '../hover/PlotHover.svelte';
+import type { Margins } from '../margins/Margins';
+import type { PlotAxes } from '../../phases/data/PlotAxes';
+import type { AxisValue } from '../../types/layout/mapping';
+import type { HoverPoint, HoverStrategy } from '../../types/layout/hover';
+import type { PlayerControl, TimeInput, TimelineStep } from '../../types/layout/timeline';
+import type { LegendDisabledAction, LegendEntry, LegendRange } from '../../types/layout/legend';
+/** What the pointer is over, shared by every plot in a figure. Read-only. */
+export declare class PublicHover {
+    #private;
+    constructor(state: HoverState);
+    /** The hovered x, or `null` while nothing is hovered. */
+    get activeX(): AxisValue | null;
+    get activeY(): AxisValue | null;
+    /** The hovered row's series, when its plot has one. */
+    get activeSeries(): string | null;
+    /** How related points are found: by x, y, series or exact position. */
+    get strategy(): HoverStrategy;
+    /** Whether a plot's hover shows in the others. */
+    get sync(): boolean;
+    /** The id of the plot (facet panel or composer cell) that owns the hover, or `null`. */
+    get source(): string | null;
+}
+/** One plot's hover: the figure's, seen from the plot, with the points it highlights and its tooltip. Read-only. */
+export declare class PublicPlotHover<T extends Record<string, unknown>> extends PublicHover {
+    #private;
+    constructor(hover: PlotHover<T>);
+    /** The points the hover highlights in this plot. */
+    get points(): HoverPoint<T>[];
+    /** The highlighted point under the cursor, or `null`. */
+    get activePoint(): HoverPoint<T> | null;
+    /** The plot's tooltip: whether it shows, where, and the rows it reads. */
+    get tooltip(): {
+        visible: boolean;
+        position: {
+            x: number;
+            y: number;
+        } | null;
+        rows: T[];
+    };
+}
+/** A figure's legend: what is on it and which series are off, which a user can turn on and off too. */
+export declare class PublicLegend {
+    #private;
+    constructor(state: LegendState);
+    /** Everything the figure's plots draw on the legend. */
+    get entries(): LegendEntry[];
+    /** The range its continuous section narrows to, or `null`. */
+    get range(): LegendRange | null;
+    /** The series that are turned off. */
+    get off(): string[];
+    isOff(series: string): boolean;
+    turnOff(series: string, action: LegendDisabledAction): void;
+    turnOn(series: string): void;
+    toggle(series: string, action: LegendDisabledAction): void;
+}
+/**
+ * A figure's timeline: where it is, whether it is playing, and what a user
+ * can do to it - to build a widget of their own in place of the player bar.
+ */
+export declare class PublicTimeline {
+    #private;
+    constructor(state: TimelineState);
+    /** Whether the figure has a timeline at all. */
+    get enabled(): boolean;
+    /** Every step it moves across, ascending. */
+    get steps(): TimelineStep[];
+    /** The position across the steps, `0`-`1`. */
+    get progress(): number;
+    /** The step the position lands on, or `undefined` without steps. */
+    get value(): TimelineStep | undefined;
+    get index(): number;
+    get playing(): boolean;
+    get loop(): boolean;
+    /** The playing speed, as a multiple of `stepDuration`. */
+    get speed(): number;
+    get speeds(): number[];
+    get controls(): PlayerControl[];
+    seek(progress: number): void;
+    seekIndex(index: number): void;
+    /** Moves to the step closest to `value`. */
+    seekValue(value: TimeInput): void;
+    next(): void;
+    previous(): void;
+    play(): void;
+    pause(): void;
+    toggle(): void;
+    setLoop(loop: boolean): void;
+    setSpeed(speed: number): void;
+    cycleSpeed(): void;
+}
+/** What anything inside a figure - its chrome included - can read of it. */
+export declare class PublicFigureContext {
+    readonly hover: PublicHover;
+    readonly legend: PublicLegend | null;
+    readonly timeline: PublicTimeline | null;
+    constructor(hover: HoverState, legend: LegendState | null, timeline: TimelineState | null);
+    /** The enclosing figure's context. Call during component init, below a figure. */
+    static use(): PublicFigureContext;
+}
+/**
+ * What anything drawn inside a plot can read of it: its hover, its figure's
+ * legend, margins, scales, axes, rows and box - and svelteplot's own plot state,
+ * apart as `svelteplot`. Read-only, but for the legend.
+ */
+export declare class PublicPlotContext<T extends Record<string, unknown> = Record<string, unknown>> {
+    #private;
+    readonly hover: PublicPlotHover<T>;
+    readonly legend: PublicLegend | null;
+    readonly timeline: PublicTimeline | null;
+    /** svelteplot's own state for this plot: its scales, options and size. */
+    readonly svelteplot: ReturnType<typeof usePlotFromSvelteplot>;
+    constructor(context: PlotContext<T>, svelteplot: ReturnType<typeof usePlotFromSvelteplot>);
+    /** The enclosing plot's context. Call during component init, below a plot's `BasePlotLayout`. */
+    static use<T extends Record<string, unknown> = Record<string, unknown>>(): PublicPlotContext<T>;
+    /** The margins around the plot's content box. */
+    get margins(): Margins;
+    /** The plot's scales as its kind built them. */
+    get scales(): object | undefined;
+    /** What the plot's position channels are and which way it runs - `undefined` for a plot with no axes (a map). */
+    get axes(): PlotAxes | undefined;
+    /** The rows the plot draws and hovers over. */
+    get data(): T[];
+    get width(): number;
+    get height(): number;
+}

package/dist/layout/plot/PublicPlotContext.js

@@ -0,0 +1,240 @@
+import { usePlot as usePlotFromSvelteplot } from 'svelteplot';
+import { HoverState } from '../hover/HoverState.svelte';
+import { LegendState } from '../legend/LegendState.svelte';
+import { PlotContext } from './PlotContext';
+import { TimelineState } from '../timeline/TimelineState.svelte';
+/** What the pointer is over, shared by every plot in a figure. Read-only. */
+export class PublicHover {
+    #state;
+    constructor(state) {
+        this.#state = state;
+    }
+    /** The hovered x, or `null` while nothing is hovered. */
+    get activeX() {
+        return this.#state.activeX;
+    }
+    get activeY() {
+        return this.#state.activeY;
+    }
+    /** The hovered row's series, when its plot has one. */
+    get activeSeries() {
+        return this.#state.activeSeries;
+    }
+    /** How related points are found: by x, y, series or exact position. */
+    get strategy() {
+        return this.#state.strategy;
+    }
+    /** Whether a plot's hover shows in the others. */
+    get sync() {
+        return this.#state.sync;
+    }
+    /** The id of the plot (facet panel or composer cell) that owns the hover, or `null`. */
+    get source() {
+        return this.#state.source;
+    }
+}
+/** One plot's hover: the figure's, seen from the plot, with the points it highlights and its tooltip. Read-only. */
+export class PublicPlotHover extends PublicHover {
+    #hover;
+    constructor(hover) {
+        super(hover.state);
+        this.#hover = hover;
+    }
+    /** The points the hover highlights in this plot. */
+    get points() {
+        return this.#hover.points;
+    }
+    /** The highlighted point under the cursor, or `null`. */
+    get activePoint() {
+        return this.#hover.activePoint;
+    }
+    /** The plot's tooltip: whether it shows, where, and the rows it reads. */
+    get tooltip() {
+        const position = this.#hover.tooltipPosition;
+        return {
+            visible: this.#hover.showTooltip && position != null,
+            position,
+            rows: this.#hover.matchedRows.map((point) => point.row)
+        };
+    }
+}
+/** A figure's legend: what is on it and which series are off, which a user can turn on and off too. */
+export class PublicLegend {
+    #state;
+    constructor(state) {
+        this.#state = state;
+    }
+    /** Everything the figure's plots draw on the legend. */
+    get entries() {
+        return this.#state.entries;
+    }
+    /** The range its continuous section narrows to, or `null`. */
+    get range() {
+        return this.#state.range;
+    }
+    /** The series that are turned off. */
+    get off() {
+        return [...this.#state.disabled.keys()];
+    }
+    isOff(series) {
+        return this.#state.isOff(series);
+    }
+    turnOff(series, action) {
+        this.#state.turnOff(series, action);
+    }
+    turnOn(series) {
+        this.#state.turnOn(series);
+    }
+    toggle(series, action) {
+        this.#state.toggle(series, action);
+    }
+}
+/**
+ * A figure's timeline: where it is, whether it is playing, and what a user
+ * can do to it - to build a widget of their own in place of the player bar.
+ */
+export class PublicTimeline {
+    #state;
+    constructor(state) {
+        this.#state = state;
+    }
+    /** Whether the figure has a timeline at all. */
+    get enabled() {
+        return this.#state.enabled;
+    }
+    /** Every step it moves across, ascending. */
+    get steps() {
+        return this.#state.steps.map((step) => this.#state.step(step));
+    }
+    /** The position across the steps, `0`-`1`. */
+    get progress() {
+        return this.#state.progress;
+    }
+    /** The step the position lands on, or `undefined` without steps. */
+    get value() {
+        const { value } = this.#state;
+        return value === undefined ? undefined : this.#state.step(value);
+    }
+    get index() {
+        return this.#state.index;
+    }
+    get playing() {
+        return this.#state.playing;
+    }
+    get loop() {
+        return this.#state.loop;
+    }
+    /** The playing speed, as a multiple of `stepDuration`. */
+    get speed() {
+        return this.#state.speed;
+    }
+    get speeds() {
+        return this.#state.speeds;
+    }
+    get controls() {
+        return this.#state.controls;
+    }
+    seek(progress) {
+        this.#state.seek(progress);
+    }
+    seekIndex(index) {
+        this.#state.seekIndex(index);
+    }
+    /** Moves to the step closest to `value`. */
+    seekValue(value) {
+        const time = this.#state.timeOf(value);
+        if (time !== undefined)
+            this.#state.seekValue(time);
+    }
+    next() {
+        this.#state.next();
+    }
+    previous() {
+        this.#state.previous();
+    }
+    play() {
+        this.#state.play();
+    }
+    pause() {
+        this.#state.pause();
+    }
+    toggle() {
+        this.#state.toggle();
+    }
+    setLoop(loop) {
+        this.#state.setLoop(loop);
+    }
+    setSpeed(speed) {
+        this.#state.setSpeed(speed);
+    }
+    cycleSpeed() {
+        this.#state.cycleSpeed();
+    }
+}
+/** What anything inside a figure - its chrome included - can read of it. */
+export class PublicFigureContext {
+    hover;
+    legend;
+    timeline;
+    constructor(hover, legend, timeline) {
+        this.hover = new PublicHover(hover);
+        this.legend = legend && new PublicLegend(legend);
+        this.timeline = timeline && new PublicTimeline(timeline);
+    }
+    /** The enclosing figure's context. Call during component init, below a figure. */
+    static use() {
+        const hover = HoverState.current();
+        if (!hover)
+            throw new Error('useFigure() must be called inside a figure (a plot or a PlotComposer).');
+        return new PublicFigureContext(hover, LegendState.current(), TimelineState.current());
+    }
+}
+/**
+ * What anything drawn inside a plot can read of it: its hover, its figure's
+ * legend, margins, scales, axes, rows and box - and svelteplot's own plot state,
+ * apart as `svelteplot`. Read-only, but for the legend.
+ */
+export class PublicPlotContext {
+    hover;
+    legend;
+    timeline;
+    /** svelteplot's own state for this plot: its scales, options and size. */
+    svelteplot;
+    #context;
+    constructor(context, svelteplot) {
+        this.#context = context;
+        this.hover = new PublicPlotHover(context.hover);
+        this.legend = context.legend && new PublicLegend(context.legend);
+        this.timeline = context.timeline && new PublicTimeline(context.timeline);
+        this.svelteplot = svelteplot;
+    }
+    /** The enclosing plot's context. Call during component init, below a plot's `BasePlotLayout`. */
+    static use() {
+        const context = PlotContext.current();
+        if (!context)
+            throw new Error('usePlot() must be called inside a plot.');
+        return new PublicPlotContext(context, usePlotFromSvelteplot());
+    }
+    /** The margins around the plot's content box. */
+    get margins() {
+        return this.#context.margins.numeric;
+    }
+    /** The plot's scales as its kind built them. */
+    get scales() {
+        return this.#context.scales;
+    }
+    /** What the plot's position channels are and which way it runs - `undefined` for a plot with no axes (a map). */
+    get axes() {
+        return this.#context.axes;
+    }
+    /** The rows the plot draws and hovers over. */
+    get data() {
+        return this.#context.data;
+    }
+    get width() {
+        return this.#context.width;
+    }
+    get height() {
+        return this.#context.height;
+    }
+}

package/dist/layout/plot/Slice.d.ts

@@ -0,0 +1,44 @@
+import type { FacetCellContext, FacetConfig } from '../../types/layout/facet';
+import type { TimelineConfig } from '../../types/layout/timeline';
+import type { SlicePlace } from '../../types/layout/plot';
+/** What a plot is sliced by. */
+export type SliceInputs<TRow extends Record<string, unknown>> = {
+    /** The rows being sliced. Without them (a plot of pre-built `series`) nothing slices. */
+    rows: TRow[] | undefined;
+    timeline: TimelineConfig<TRow> | undefined;
+    facet: FacetConfig<TRow> | undefined;
+    /** The plot kind's default for `timeline.filterMode`. */
+    filterMode: 'exact' | 'upTo' | undefined;
+};
+/**
+ * How a plot's rows divide into slices - the timeline steps and facet panels
+ * each cell of its grid shows: which rows belong in a slice ({@link Slice.keep}),
+ * the scales the slices share and how the facets lay out. Create it once per
+ * plot, from its current inputs.
+ */
+export declare class Slice<TRow extends Record<string, unknown>> {
+    #private;
+    readonly timeline: TimelineConfig<TRow> | undefined;
+    readonly facet: FacetConfig<TRow> | undefined;
+    /** Whether the plot's rows are sliced at all. Unsliced, its one core is the whole plot. */
+    readonly sliced: boolean;
+    /** How a timeline matches rows to a step: the author's, else the plot kind's. */
+    readonly filterMode: 'exact' | 'upTo' | undefined;
+    /** The facet's layout alone - its `scales` and `axes` shape each cell instead. */
+    readonly layout: Omit<FacetConfig<TRow>, 'scales' | 'axes'> | undefined;
+    /** What is wrong with the slicing as set, for the author to fix. */
+    readonly problems: string[];
+    constructor({ rows, timeline, facet, filterMode }: SliceInputs<TRow>);
+    /** Whether a row belongs in the slice at `place`. A row lacking a slicing field belongs in every slice. */
+    keep(place: SlicePlace): (row: TRow) => boolean;
+    /** The key of the facet panel the cell at `place` shows, or `undefined` without a facet. */
+    panelKey(place: FacetCellContext<TRow>): string | undefined;
+    /**
+     * The scales for the facet cell at `place`: its panel's share of the
+     * domains the slices `shared` (keyed by panel), under how `facet.axes`
+     * displays its axes.
+     */
+    facetScales<TScales extends object>(shared: Record<string, object> | undefined, place: FacetCellContext<TRow>): TScales | undefined;
+    /** The scales a timeline alone keeps every step on - the domains all its rows span - unless it fits each step's own. */
+    timelineScales<TScales extends object>(shared: Record<string, object> | undefined): TScales | undefined;
+}

package/dist/layout/plot/Slice.js

@@ -0,0 +1,100 @@
+import { resolveAccessor } from '../../plots/utils/accessors';
+import { merge } from '../../utils/merge';
+import { TimelineSteps } from '../timeline/TimelineSteps';
+import { TimelineTime } from '../timeline/TimelineTime';
+import { buildFacetAxesDisplay } from '../facet/axes';
+import { buildFacetPlaceKey, isFacetWrap } from '../facet/config';
+/**
+ * How a plot's rows divide into slices - the timeline steps and facet panels
+ * each cell of its grid shows: which rows belong in a slice ({@link Slice.keep}),
+ * the scales the slices share and how the facets lay out. Create it once per
+ * plot, from its current inputs.
+ */
+export class Slice {
+    timeline;
+    facet;
+    /** Whether the plot's rows are sliced at all. Unsliced, its one core is the whole plot. */
+    sliced;
+    /** How a timeline matches rows to a step: the author's, else the plot kind's. */
+    filterMode;
+    /** The facet's layout alone - its `scales` and `axes` shape each cell instead. */
+    layout;
+    /** What is wrong with the slicing as set, for the author to fix. */
+    problems = [];
+    #axes;
+    constructor({ rows, timeline, facet, filterMode }) {
+        this.timeline = timeline;
+        this.facet = facet;
+        this.sliced = rows != null && (timeline != null || facet != null);
+        this.filterMode = timeline?.filterMode ?? filterMode;
+        this.#axes = facet ? buildFacetAxesDisplay(facet) : undefined;
+        if (facet) {
+            const layout = { ...facet };
+            delete layout.scales;
+            delete layout.axes;
+            this.layout = layout;
+        }
+        if (!rows && (timeline || facet)) {
+            this.problems.push('`timeline` and `facet` slice flat `data` rows - they are ignored with pre-built `series`.');
+        }
+        if (facet && facet.by === undefined && facet.rows === undefined && facet.cols === undefined) {
+            this.problems.push('`facet` needs `by`, or `rows` and/or `cols`.');
+        }
+    }
+    /** Whether a row belongs in the slice at `place`. A row lacking a slicing field belongs in every slice. */
+    keep(place) {
+        const { timeline, facet } = this;
+        const tests = [];
+        const matches = (accessor, expected) => {
+            if (accessor === undefined || expected === undefined)
+                return;
+            const get = resolveAccessor(accessor);
+            tests.push((row) => {
+                const value = get(row);
+                return value == null || String(value) === expected;
+            });
+        };
+        if (timeline && place.time !== undefined) {
+            const get = resolveAccessor(timeline.accessor);
+            const reader = new TimelineTime(timeline.dateFormat);
+            const time = place.time;
+            tests.push((row) => {
+                const value = reader.toTime(get(row));
+                if (value === undefined)
+                    return true;
+                return TimelineSteps.matches(value, time, this.filterMode);
+            });
+        }
+        if (facet && place.facet) {
+            if (isFacetWrap(facet))
+                matches(facet.by, place.facet.facetValue);
+            else {
+                matches(facet.rows, place.facet.row);
+                matches(facet.cols, place.facet.col);
+            }
+        }
+        return (row) => tests.every((test) => test(row));
+    }
+    /** The key of the facet panel the cell at `place` shows, or `undefined` without a facet. */
+    panelKey(place) {
+        return this.facet ? buildFacetPlaceKey(this.facet, place) : undefined;
+    }
+    /**
+     * The scales for the facet cell at `place`: its panel's share of the
+     * domains the slices `shared` (keyed by panel), under how `facet.axes`
+     * displays its axes.
+     */
+    facetScales(shared, place) {
+        const key = this.panelKey(place);
+        if (key === undefined)
+            return undefined;
+        return merge(shared?.[key], this.#axes?.(place));
+    }
+    /** The scales a timeline alone keeps every step on - the domains all its rows span - unless it fits each step's own. */
+    timelineScales(shared) {
+        const { timeline, facet } = this;
+        if (!timeline || facet || timeline.scales === 'free')
+            return undefined;
+        return shared?.[''];
+    }
+}

package/dist/layout/plot/usePlot.d.ts

@@ -0,0 +1,9 @@
+import { PublicFigureContext, PublicPlotContext } from './PublicPlotContext';
+/**
+ * What the plot around the calling component is: its hover, its figure's
+ * legend and timeline, margins, scales, rows and box, and svelteplot's own state as
+ * `svelteplot`. Call it during init, in anything drawn inside a plot.
+ */
+export declare function usePlot<T extends Record<string, unknown> = Record<string, unknown>>(): PublicPlotContext<T>;
+/** What the figure around the calling component is: its hover, legend and timeline. Call it during init, anywhere inside a figure - its chrome too. */
+export declare function useFigure(): PublicFigureContext;

package/dist/layout/plot/usePlot.js

@@ -0,0 +1,13 @@
+import { PublicFigureContext, PublicPlotContext } from './PublicPlotContext';
+/**
+ * What the plot around the calling component is: its hover, its figure's
+ * legend and timeline, margins, scales, rows and box, and svelteplot's own state as
+ * `svelteplot`. Call it during init, in anything drawn inside a plot.
+ */
+export function usePlot() {
+    return PublicPlotContext.use();
+}
+/** What the figure around the calling component is: its hover, legend and timeline. Call it during init, anywhere inside a figure - its chrome too. */
+export function useFigure() {
+    return PublicFigureContext.use();
+}