@motionscript/charts 0.1.0-alpha.5 → 0.1.0-alpha.6

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @motionscript/charts
 
+## 0.1.0-alpha.6
+
+### Minor Changes
+
+- 163b708: Node types are components: one spec object handed to `component2d`, `component3d` or `componentAudio`, with no classes, decorators or JSX.
+
+  - **Writing a node type.** A component is one object literal: `key`, `state` (literals and `Types`), `defaults`, `commands`, `children`, `allowedChildren`/`allowedParents`, `provide`, `load`, and its tree's own fields (`measure`, `layout`, `render` for 2D). Behaviour comes from modules you spread in and call: `Paint`, `Flow`, `Shapes`, `Typeface`, `TextLayout`, `Aim`, `Material`, `View3D`. ADR 0007 and the custom-node docs cover it.
+  - **Building nodes in code** uses calls: `Rect({ fill: 'tomato', children: [Text({ text: 'Hi' })] })`, or `new Rect({...})` for the node itself.
+  - **Every built-in and every kit node is a component**, under the same document key. Code that tested `instanceof` a class now uses the component's `.is`, or `instanceof X.node`. Changed members:
+    - `SurfacePlot3d.valueAt` and `FunctionPlot.valueAt` are now the functions `surfaceValueAt` and `curveValue`.
+    - A system's `coordinates` is replaced by `planeMap`/`axesMap`/`systemMap`.
+    - `PieChart.isSelected` is replaced by `isSliceSelected`.
+    - `ItemGrid` is a kit module (`ItemGrid.isGrid`, `ItemGrid.define`), not a base class.
+  - **The sdk no longer exports the class surface:**
+    - the decorators: `node`, `property` and every `*Property`, `command`, `withdraw`, `driveCommand`;
+    - the authoring bases: `PaintNode`, `ShapeNode`, `TextBase`, `Mesh3DBase`, `Canvas3DBase` and the `*Base` geometry classes;
+    - `asCommand`, `compose`, `drive` and `declarePaints` from `@motionscript/sdk/component`;
+    - the `jsx-runtime` and `jsx-dev-runtime` subpaths.
+    - `Node`, `Node2D`, `Node3D` and `NodeAudio` remain as types.
+  - **Editor metadata leaves the engine.** The kits no longer declare `parentKey`, `forkable`, `layout`, `seed`, `within`, `beside` or `closed`; a host keeps those in its own configs. `describe()` now reports `holds`, the trees a type takes children from, and the placement checks use it, so a 2D viewport of your own that takes 3D children places them.
+  - A command called from code with no argument runs, and a refused child is told what its parent takes (`allowedChildren`) or where it goes (`allowedParents`).
+
 ## 0.1.0-alpha.5
 
 ### Patch Changes

package/README.md

@@ -30,20 +30,23 @@ npm install @motionscript/charts @motionscript/sdk
 Each chart folder (`line-chart/`, `bar-chart/`, `pie-chart/`) has an `index.ts`
 barrel with the node, its parts, its theme (`DEFAULT_*_THEME`, `resolve*Theme`,
 `lerp*Theme`) and its pure helpers (`resolveXScale`, `barSpans`, `pieArcs`, ...).
-The parts (`ChartLine`, `ChartBars`, `PieRing`, `VerticalAxis`, ...) are classes
-but not registered node types: a document cannot name them.
+The charts and their parts (`ChartLine`, `ChartBars`, `PieRing`, `VerticalAxis`, ...)
+are components (`component2d`); only the charts are registered node types, so a
+document cannot name a part. A chart tells a host its key, entries and commands;
+where it is shelved and the box it is seeded at are the host's to keep. `lineChartDomains` and `barChartDomain` give the axes as drawn, and
+`isSliceSelected` whether a pie slice is out.
 
 ## Nodes
 
-| Key | Seed (w x h) | Data props | Commands (default duration) |
+| Key | Made for (w x h) | Data props | Commands |
 |---|---|---|---|
-| `lineChart` | 760 x 460 | `data`, `xField`, `series`, `xAxis`, `yAxis`, `region` | `enter` (required), `spotlightRegion` 0.5, `clearRegion` 0.5, `zoomTo` 0.8, `resetZoom` 0.8, `showSeries`/`hideSeries`/`spotlightSeries` 0.35 |
-| `barChart` | 760 x 460 | `data`, `categoryField`, `series`, `valueAxis`, `stacked` | `enter` (required), `showSeries`/`hideSeries`/`spotlightSeries` 0.35, `spotlightCategory` 0.4, `clearCategory` 0.4 |
-| `pieChart` | 680 x 480 | `data`, `categoryField`, `valueField` | `enter` (required), `revealCenter` 0.6, `selectSlice`/`deselectSlice`/`selectOnlySlice`/`clearSelection` 0.45 |
+| `lineChart` | 760 x 460 | `data`, `xField`, `series`, `xAxis`, `yAxis`, `region` | `enter`, `spotlightRegion`, `clearRegion`, `zoomTo`, `resetZoom`, `showSeries`/`hideSeries`/`spotlightSeries` |
+| `barChart` | 760 x 460 | `data`, `categoryField`, `series`, `valueAxis`, `stacked` | `enter`, `showSeries`/`hideSeries`/`spotlightSeries`, `spotlightCategory`, `clearCategory` |
+| `pieChart` | 680 x 480 | `data`, `categoryField`, `valueField` | `enter`, `revealCenter`, `selectSlice`/`deselectSlice`/`selectOnlySlice`/`clearSelection` |
 
-Every command returns a `Command` (composed entrances go through `asCommand`), so
-all of them compile from a document. Arguments: `seriesIndex`, `sliceIndex`,
-`categoryIndex`, and for `spotlightRegion` and `zoomTo` a `region` of
+Every command takes the duration its row (or call) gives, and eases out unless
+given an easing. Arguments: `seriesIndex`, `sliceIndex`, `categoryIndex` (each 0
+when left out), and for `spotlightRegion` and `zoomTo` a `region` of
 `{ x?: [min, max], y?: [min, max] }`.
 
 ## Rules worth knowing
@@ -51,9 +54,14 @@ all of them compile from a document. Arguments: `seriesIndex`, `sliceIndex`,
 - **The kit stays an import.** `ms add line-chart` copies only `line-chart/*` and
   rewrites its kit imports to `@motionscript/charts` (`registry.json`): a second
   copy of `VerticalAxis` would render as nothing, with no error.
-- **Resting state is the finished chart.** `enter` arms every part back to its
-  pre-entrance state as the command is built (`arm()`), and `duration` is the whole
-  entrance: a beat with nothing to do (no legend, no series) holds its share.
+- **Resting state is the finished chart.** `enter` arms every part on its first
+  frame: every piece of a component command is built run to its end, and a beat
+  ahead of the playhead writes nothing, so the first frame writes what each later
+  beat moves from. `duration` is the whole entrance: a beat with nothing to do (no
+  legend, no series) holds its share.
+- **A part's command has no duration of its own.** The charts pass every part the
+  duration and easing it moves with; called directly, a part's command takes the
+  duration it is given, and a part's own frames ease out unless given an easing.
 - **Some props are read once, at construction**: the series list (count, labels,
   `enabled`), `showLegend`, `showValues`, `showCenter`, axis captions, text styles and
   paddings, the bar chart's category captions, the pie's label and legend-row counts,
@@ -67,10 +75,16 @@ all of them compile from a document. Arguments: `seriesIndex`, `sliceIndex`,
   are in the x scale's own units: the number (numeric column), UTC epoch
   milliseconds (time column) or the row index (ordinal column), chosen from the
   column by `resolveXScale` (dates via `parseInstant`).
-- **`zoomTo` captures the resting domain once** (`home`) and `resetZoom` reads and
-  clears it as the command is built, so the pair is order dependent: a `resetZoom`
-  with no earlier `zoomTo`, and a `zoomTo` naming neither axis, write nothing for
-  their duration. A zoom keeps the tick count so each marker slides.
+- **`zoomTo` remembers the resting domain once** (`home`, a private entry its
+  frames write) and `resetZoom`'s frames clear it, so the pair is order dependent
+  and a seek back before a zoom forgets it again: a `resetZoom` with no earlier
+  `zoomTo`, and a `zoomTo` naming neither axis, write nothing for their duration.
+  A zoom keeps the tick count so each marker slides.
+- **A `to` of an axis `range` or `ticks` tweens from the domain as drawn**
+  (`lerpAxisEntry`): an auto side is held mid-move as an `AxisDomainBlend`, which
+  the chart settles against its data, so a rescale from an auto axis is continuous.
+  A restated range without ticks spreads explicit ticks across it; one side of an
+  auto axis restated alone leaves the other to the data.
 - **Pie angles** are radians clockwise from 12 o'clock; `startAngle` is degrees.
 
 ## Development

package/dist/bar-chart/bar-chart.d.ts

@@ -1,6 +1,6 @@
-import { Node2D, type CommandArgs, type DataRecord, type Command, type NodeConfig, type Node2DProps } from "@motionscript/sdk";
-import { type AxisDomainConfig } from "../kit/shared.js";
-import { type BarChartTheme, type BarSeries } from "./shared.js";
+import { type DataRecord, type NodeOf, type Node2D, type Node2DProps } from "@motionscript/sdk";
+import { type AxisDomainConfig, type Range } from "../kit/shared.js";
+import { type BarChartConfig, type BarChartTheme, type BarSeries } from "./shared.js";
 export interface BarChartProps extends Node2DProps {
     /** One row per category — a plain record of field name to value. */
     data: DataRecord[];
@@ -33,268 +33,115 @@ export interface BarChartProps extends Node2DProps {
     /** Whether each column prints the figure it plots. */
     showValues?: boolean;
 }
-/**
- * How {@link BarChart.enter} divides its duration between its three beats: the
- * axes arriving, the columns rising, and the legend coming up. Shares of the
- * whole, so they must sum to 1 — the entrance takes exactly the time it was
- * given, for the reason spelt out on `LineChart.enter`.
- */
-/**
- * The signals the bar chart's own commands move, as props types.
- *
- * Written out rather than reusing `BarChartProps` because these are signals of
- * the chart's own — how far the columns have risen, and which category is lit —
- * rather than part of what an author states about it. Same reason the line chart
- * types its `RegionState` separately.
- */
-type CategorySpotlight = {
-    spotlight: number | null;
-    spotlightReveal: number;
+/** What a bar chart plots, as its entries hold it. */
+export interface BarChartValues {
+    readonly data: DataRecord[];
+    readonly series: BarSeries[];
+    readonly stacked: boolean;
+    readonly valueAxis: AxisDomainConfig;
+}
+/** The value axis's domain with its range and ticks resolved. */
+export type BarChartDomain = AxisDomainConfig & {
+    readonly range: Range;
+    readonly ticks: number[];
 };
+/** The value axis as a bar chart draws it now, an auto range or tick row read back as itself. */
+export declare function barChartDomain(s: BarChartValues): BarChartDomain;
 /**
- * A grouped or stacked bar chart, composed from independent parts rather than
- * one monolithic draw — the sibling of the {@link LineChart} family, built the
- * same way and out of several of the same pieces:
+ * A grouped or stacked bar chart, the sibling of the line chart and built the
+ * same way, out of several of the same pieces:
  *
  * - `ChartCanvas` — the plot panel with a horizontal grid, under everything.
  * - `VerticalAxis` — the numeric value markers, staggering in bottom-to-top.
- * - {@link CategoryAxis} — the row of names beneath the baseline, one per row of
- *   the data, staggering in left-to-right.
+ * - {@link CategoryAxis} — the row of names beneath the baseline, one per row.
  * - {@link ChartBars} (one per series) — that series' column in every category,
  *   plus the figures printed on them.
  * - `ChartLegend` — a row of entries below the chart, one per series.
  *
- * The parts are laid out from this node's `layoutBounds` exactly as the line
- * chart's are: the value axis on the left, the category captions below, the
- * plot filling what's left, and the legend row beneath the whole thing. The
- * columns are mapped across the plot panel's own laid-out box and read the same
- * resolved scale the axis does, so a column's end lands exactly on its marker
- * and the chart re-flows if its box changes.
+ * Every part reads the chart's entries through bindings, and the columns map
+ * across the plot panel's own laid-out box, so a column's end lands exactly on
+ * its marker. **Zero is always on the scale**, and the columns grow about it, so
+ * a negative value draws downward out of the same `growth` signal.
  *
- * **Resting state is the finished chart** — the same bargain the line chart
- * makes: an editor paints a node's Initial state on a paused canvas, so a chart
- * that only appeared once a command had run would be edited blind. {@link enter}
- * arms every part back to its pre-entrance state before animating.
- *
- * **Zero is always on the scale** (see `barValueExtent`), and the columns
- * grow about it rather than about the plot floor, so a negative value draws
- * downward out of the same `growth` signal that draws a positive one up.
- *
- * Past the entrance, two things move the chart:
- * {@link showSeries}/{@link hideSeries}/{@link spotlightSeries} pick out a
- * *series* — and hiding one **reflows the group**, the remaining columns
- * widening into the space as it goes, rather than leaving a hole where it was —
- * while {@link spotlightCategory}/{@link clearCategory} pick out a *column of
- * the table*, dimming every other category and its caption with it.
+ * **Resting state is the finished chart**; `enter` arms every part on its first
+ * frame. `showSeries`/`hideSeries`/`spotlightSeries` pick out a *series* (hiding
+ * one reflows the group), `spotlightCategory`/`clearCategory` a *column of the
+ * table*. A `to` of the value axis's `range` or `ticks` tweens from the domain
+ * as drawn, so an auto axis rescales the columns continuously.
  */
-export declare class BarChart extends Node2D<BarChartProps> {
-    data: DataRecord[];
-    categoryField: string;
-    series: BarSeries[];
-    stacked: boolean;
-    /**
-     * The value axis's domain (label/range/ticks), tweenable and mappable exactly
-     * as the line chart's axes are: the mapper merges a partial input onto the
-     * previous resolved domain and the tween interpolates numerically, so
-     * `chart.to({ data: { valueAxis: { range: [0, 10] } }, duration: 1 })` smoothly
-     * rescales every column. The axis *label* text is captured once at construction.
-     */
-    valueAxis: AxisDomainConfig;
-    categoryAxis: AxisDomainConfig;
-    theme: BarChartTheme;
+export declare const BarChart: import("@motionscript/sdk").Component<"barChart", import("@motionscript/sdk").Merge<import("@motionscript/sdk").Box2DState, {
+    readonly data: import("@motionscript/sdk").Type<DataRecord[], DataRecord[], false>;
+    readonly categoryField: "";
+    readonly series: import("@motionscript/sdk").Type<import("../index.js").ChartSeries[], import("../index.js").ChartSeries[], false>;
+    readonly stacked: false;
+    readonly valueAxis: import("@motionscript/sdk").Type<AxisDomainConfig, AxisDomainConfig, false>;
+    readonly categoryAxis: import("@motionscript/sdk").Type<AxisDomainConfig, AxisDomainConfig, false>;
+    readonly theme: import("@motionscript/sdk").Type<BarChartTheme, BarChartConfig, false>;
     /**
      * Global rise of every column in `[0, 1]`, measured about the baseline: 0
-     * collapses them all onto it, 1 draws them at full length. Each
-     * {@link ChartBars}' own `growth` is bound to this, so tweening this one
-     * signal raises the whole chart in proportion.
-     */
-    growth: number;
-    /**
-     * How much of the slot each series currently claims, one entry per series.
-     *
-     * A *weight* rather than a boolean, because that is what makes hiding a series
-     * an animation instead of a jump: the grouped columns divide the slot in
-     * proportion to these, so tweening one to 0 has the remaining columns widen
-     * into the space as it shrinks away, and a stacked segment's contribution to
-     * the stack fades out with it. Seeded from each series' `enabled` field.
+     * collapses them all onto it, 1 draws them at full length.
      */
-    weights: number[];
+    readonly growth: 1;
     /**
-     * The category currently spotlit, or `null` for none. Held as a plain reactive
-     * value rather than a tweened one: the *choice* snaps, and the animation is
-     * {@link spotlightReveal} dimming everything else.
+     * How much of the slot each series claims, one entry per series: a weight
+     * rather than a switch, so hiding one is the others widening into the space.
+     * Seeded from each series' `enabled`.
      */
-    spotlight: number | null;
+    readonly weights: import("@motionscript/sdk").Type<number[], number[], false>;
+    /** The category spotlit, or `null` for none. The choice snaps; `spotlightReveal` is the animation. */
+    readonly spotlight: import("@motionscript/sdk").Type<number | null, number | null, false>;
     /** How far the category spotlight is drawn in, `[0, 1]`. */
-    spotlightReveal: number;
-    private vAxis;
-    private cAxis;
-    private legend;
-    private barSets;
-    /** The plot panel: the box the grid, the columns and the border all share. */
-    private plotRect;
-    /**
-     * `this.theme` read back through its *resolved* shape — the same
-     * loose-declared/resolved-stored idiom as a shape's `fill`/`stroke`, and as
-     * the line chart's own theme.
-     */
-    private get resolvedTheme();
-    /** Fallback marker count when the value axis states no ticks. */
-    private static readonly DEFAULT_MARKERS;
-    private get valueScale();
-    /**
-     * A value written down as this chart's value axis says — the axis ticks and
-     * the figures printed on the columns both read through here, so the two
-     * cannot disagree about what a number looks like.
-     */
-    private valueLabel;
-    /** The value axis ticks: the explicit ones, else five across the scale. */
-    private get resolvedMarkers();
-    /**
-     * The plot panel's size, **as laid out**.
-     *
-     * The value axis is `width: "hug"` and the category row and legend are as tall
-     * as their text, so the panel's real box is whatever the layout makes it. An
-     * estimate built from gutter constants never matched it, and the columns sat a
-     * few percent off the grid line they were supposed to end on. Asking the panel
-     * is exact by construction: the grid, the columns and the border all resolve
-     * against the one box they are drawn in. Zero until the first layout pass, like
-     * any other `layoutBounds` read; the bindings that call this re-run on the
-     * next frame.
-     */
-    private plotSize;
-    /** Map a value onto the plot's **centred** pixel space (origin at its centre, y-up). */
-    private valueToY;
-    /**
-     * Pixel y of the line every column grows from.
-     *
-     * Zero, clamped onto the scale — so an author who *did* crop the axis to
-     * `[40, 100]` gets columns rising from the plot floor rather than from a
-     * baseline off the bottom of the panel.
-     */
-    private get baselinePx();
-    /** Width of one category's slot across the plot. */
-    private get slotWidth();
-    /** Centre x of category `i`'s slot, in the plot's centred space. */
-    private slotCenter;
-    /** The part of a slot the columns fill — the rest is the channel between categories. */
-    private get slotInner();
-    /** Series `i`'s live share of the slot; 0 once it has been hidden. */
-    private weightAt;
-    /** Total live share across the series — the slot's inner width divides by this. */
-    private get totalWeight();
-    /** Live share of every series *before* `index`, for the grouped offset. */
-    private weightBefore;
+    readonly spotlightReveal: 0;
+    /** Read as the chart is built: the legend is a part the chart builds or doesn't. */
+    readonly showLegend: import("@motionscript/sdk").Type<boolean, boolean, false>;
+    /** Read as the chart is built: whether each column prints the figure it plots. */
+    readonly showValues: import("@motionscript/sdk").Type<boolean, boolean, false>;
+    /** Whether each series' columns are drawn: on for every frame a show or hide covers, off once a hide lands. */
+    readonly showing: import("@motionscript/sdk").Type<boolean[], boolean[], false>;
+}>, {
+    readonly enter: {};
+    readonly showSeries: {
+        readonly seriesIndex: import("@motionscript/sdk").Type<number, number, false>;
+    };
+    readonly hideSeries: {
+        readonly seriesIndex: import("@motionscript/sdk").Type<number, number, false>;
+    };
+    readonly spotlightSeries: {
+        readonly seriesIndex: import("@motionscript/sdk").Type<number, number, false>;
+    };
+    readonly spotlightCategory: {
+        readonly categoryIndex: import("@motionscript/sdk").Type<number, number, false>;
+    };
+    readonly clearCategory: {};
+}, null, Node2D<Node2DProps>, import("@motionscript/sdk").CallProps<import("@motionscript/sdk").Merge<import("@motionscript/sdk").Box2DState, {
+    readonly data: import("@motionscript/sdk").Type<DataRecord[], DataRecord[], false>;
+    readonly categoryField: "";
+    readonly series: import("@motionscript/sdk").Type<import("../index.js").ChartSeries[], import("../index.js").ChartSeries[], false>;
+    readonly stacked: false;
+    readonly valueAxis: import("@motionscript/sdk").Type<AxisDomainConfig, AxisDomainConfig, false>;
+    readonly categoryAxis: import("@motionscript/sdk").Type<AxisDomainConfig, AxisDomainConfig, false>;
+    readonly theme: import("@motionscript/sdk").Type<BarChartTheme, BarChartConfig, false>;
     /**
-     * Series `index`'s columns, mapped into the plot's centred pixel space.
-     *
-     * Both modes come out of one walk over the rows: a grouped series divides the
-     * slot with its siblings and every column runs from zero, a stacked one takes
-     * the whole slot and each column runs from the running total below it. The
-     * live {@link weights} scale the grouped widths and the stacked contributions
-     * alike, which is what lets `hideSeries` reflow rather than punch a hole.
-     */
-    private seriesBars;
-    /**
-     * `row` with each series' value scaled by that series' live {@link weights}
-     * entry — what the stacked spans are measured from.
-     */
-    private weightedRow;
-    /**
-     * How far each category is dimmed by the spotlight, one entry per row —
-     * 1 while nothing is spotlit, falling to the theme's `dimOpacity` for every
-     * category but the chosen one as the reveal climbs.
-     */
-    private categoryDims;
-    constructor(props?: NodeConfig<BarChart, BarChartProps>);
-    /**
-     * Prime every part at its pre-entrance state — axis markers and captions
-     * shifted and transparent, columns collapsed onto the baseline, legend dropped
-     * and transparent.
-     *
-     * Called by {@link enter} before its first frame so nothing flashes ahead of
-     * its beat. Idempotent, and public so a scene can hide a chart ahead of time
-     * without starting the entrance.
-     */
-    arm(): void;
-    /**
-     * Animate the whole chart in: the two axes stagger their markers and captions
-     * in, the columns rise from the baseline, and the legend fades up last.
-     *
-     * `duration` is the **whole** entrance. The phases are shares of it, not
-     * multiples — a command that declares 1.4 seconds has to take 1.4 seconds,
-     * because that is the slot the timeline lays out for it, the length its
-     * parallel siblings are timed against, and its contribution to the scene's own
-     * duration.
-     */
-    enter(args: CommandArgs<Record<string, never>> & {
-        duration: number;
-    }): Command<Record<string, never>>;
-    /**
-     * Move props to new values; a restated value-axis `range` or `ticks` tweens
-     * from the domain as drawn, so an auto axis (the default) rescales the columns
-     * continuously instead of cutting at the midpoint of the move.
-     */
-    to<D extends Partial<BarChartProps> = Partial<BarChartProps>>(args: CommandArgs<D> & {
-        duration: number;
-    }): Command<BarChartProps>;
-    /** Tween {@link growth} `0 → 1`, raising every column about the baseline. */
-    private riseBars;
-    /**
-     * Show series `index`: bring its columns back, the group reflowing to make
-     * room as they arrive, in lockstep with its legend entry growing in.
-     */
-    showSeries(args: CommandArgs<{
-        seriesIndex: number;
-    }>): Command<Record<string, never>>;
-    /**
-     * Hide series `index`: its columns narrow away (or, stacked, sink out of the
-     * stack) while the rest of the group widens into the space, its legend entry
-     * shrinking beside them — the mirror of {@link showSeries}.
-     */
-    hideSeries(args: CommandArgs<{
-        seriesIndex: number;
-    }>): Command<Record<string, never>>;
-    /**
-     * Move series `index`'s slot share to `target`, with its legend entry.
-     *
-     * One method for both directions, so the pair cannot drift apart. `enabled`
-     * rides in the same value as the weight rather than being set before or after,
-     * which is what makes arriving at a time backwards show what arriving forwards
-     * does.
-     */
-    private toggleSeries;
-    /**
-     * Fade out every other series — its columns **and its legend entry** — to
-     * focus attention on `index`, which comes back to full. Nothing moves, so the
-     * group doesn't reflow.
-     */
-    spotlightSeries(args: CommandArgs<{
-        seriesIndex: number;
-    }>): Command<Record<string, never>>;
-    /** Ease series `index`'s slot share toward `target`, reflowing the group. */
-    private tweenWeight;
-    /**
-     * Spotlight one **category** — one column of the table rather than one series:
-     * every other category's bars and its caption fade to the theme's
-     * `dimOpacity`, and the chosen one stays full.
-     *
-     * The counterpart of the line chart's `spotlightRegion`, and the same shape of
-     * thing: it picks out a slice of the plot without changing what is drawn.
-     * Calling it while another category is already lit moves the focus directly —
-     * only the dimming changes, so there is nothing to retract first.
+     * Global rise of every column in `[0, 1]`, measured about the baseline: 0
+     * collapses them all onto it, 1 draws them at full length.
      */
-    spotlightCategory(args: CommandArgs<{
-        categoryIndex: number;
-    }>): Command<CategorySpotlight>;
+    readonly growth: 1;
     /**
-     * Drop the category spotlight, bringing every category back to full. A no-op
-     * when nothing is lit — but it still takes its slot on the timeline, for the
-     * reason `LineChart.clearRegion` does.
+     * How much of the slot each series claims, one entry per series: a weight
+     * rather than a switch, so hiding one is the others widening into the space.
+     * Seeded from each series' `enabled`.
      */
-    clearCategory(args: CommandArgs<Record<string, never>>): Command<CategorySpotlight>;
-    /** The no-op both of the above return — see {@link hold}. */
-    private holdSpotlight;
-}
-export {};
+    readonly weights: import("@motionscript/sdk").Type<number[], number[], false>;
+    /** The category spotlit, or `null` for none. The choice snaps; `spotlightReveal` is the animation. */
+    readonly spotlight: import("@motionscript/sdk").Type<number | null, number | null, false>;
+    /** How far the category spotlight is drawn in, `[0, 1]`. */
+    readonly spotlightReveal: 0;
+    /** Read as the chart is built: the legend is a part the chart builds or doesn't. */
+    readonly showLegend: import("@motionscript/sdk").Type<boolean, boolean, false>;
+    /** Read as the chart is built: whether each column prints the figure it plots. */
+    readonly showValues: import("@motionscript/sdk").Type<boolean, boolean, false>;
+    /** Whether each series' columns are drawn: on for every frame a show or hide covers, off once a hide lands. */
+    readonly showing: import("@motionscript/sdk").Type<boolean[], boolean[], false>;
+}>, null>>;
+export type BarChart = NodeOf<typeof BarChart>;
 //# sourceMappingURL=bar-chart.d.ts.map

package/dist/bar-chart/bar-chart.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bar-chart.d.ts","sourceRoot":"","sources":["../../src/bar-chart/bar-chart.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"bar-chart.d.ts","sourceRoot":"","sources":["../../src/bar-chart/bar-chart.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,UAAU,EAEf,KAAK,MAAM,EAEX,KAAK,MAAM,EACX,KAAK,WAAW,EAGjB,MAAM,mBAAmB,CAAA;AAU1B,OAAO,EAUL,KAAK,gBAAgB,EACrB,KAAK,KAAK,EACX,MAAM,eAAe,CAAA;AAGtB,OAAO,EASL,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,EACf,MAAM,UAAU,CAAA;AAEjB,MAAM,WAAW,aAAc,SAAQ,WAAW;IAChD,oEAAoE;IACpE,IAAI,EAAE,UAAU,EAAE,CAAA;IAClB;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAA;IACrB,gFAAgF;IAChF,MAAM,EAAE,SAAS,EAAE,CAAA;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,yEAAyE;IACzE,SAAS,CAAC,EAAE,gBAAgB,CAAA;IAC5B,qFAAqF;IACrF,YAAY,CAAC,EAAE,gBAAgB,CAAA;IAC/B;;;;OAIG;IACH,KAAK,CAAC,EAAE,aAAa,CAAA;IACrB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,sDAAsD;IACtD,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,sDAAsD;AACtD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,CAAA;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAA;CACrC;AAED,iEAAiE;AACjE,MAAM,MAAM,cAAc,GAAG,gBAAgB,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAmCnG,iGAAiG;AACjG,wBAAgB,cAAc,CAAC,CAAC,EAAE,cAAc,GAAG,cAAc,CAEhE;AA8ID;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,QAAQ;;;;;;;;IAUjB;;;OAGG;;IAEH;;;;OAIG;;IAEH,sGAAsG;;IAEtG,4DAA4D;;IAE5D,oFAAoF;;IAEpF,kFAAkF;;IAElF,+GAA+G;;;;;;;;;;;;;;;;;;;;;;;;;IAnB/G;;;OAGG;;IAEH;;;;OAIG;;IAEH,sGAAsG;;IAEtG,4DAA4D;;IAE5D,oFAAoF;;IAEpF,kFAAkF;;IAElF,+GAA+G;;UA6MjH,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,OAAO,QAAQ,CAAC,CAAA"}