@motionscript/charts 0.0.0-stage → 0.1.0-alpha.0

package/dist/kit/chart-legend.js

@@ -0,0 +1,212 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Rect, Text, command, easeOut, property, textOps, } from "@motionscript/core";
+import { drive, hold, together } from "@motionscript/core/component";
+import { DEFAULT_LEGEND, SPOTLIGHT_DIM, } from "./shared.js";
+/**
+ * The legend of a chart: a **horizontal-flow row of entries**, one per series, laid out
+ * left-to-right with the theme's `itemGap`. Each entry pairs the series label
+ * with a rounded colour swatch; only the swatch carries the series colour, the
+ * caption reads in the legend's neutral ink.
+ *
+ * {@link showSeries}/{@link hideSeries} flip a series on or off — showing one
+ * adds its entry back into the row at its stable series position and grows it
+ * in, hiding one shrinks it away and removes it. So the row only ever holds the
+ * currently-enabled series, in series order, and closes the gap when one leaves.
+ *
+ * This node *is* the row, so the parent places it (centred below the chart) and
+ * it hugs its entries.
+ */
+export class ChartLegend extends Rect {
+    /** One entry per series. **Every** entry is a child — see {@link reveal}. */
+    items = [];
+    /**
+     * How far each entry is shown, `0`–`1`. Drives its width, opacity and gap
+     * together, so `0` is an entry that takes no room and `1` is one at its
+     * natural size.
+     *
+     * This replaces adding and removing the entry from the row, which is what
+     * `showSeries`/`hideSeries` used to do. That could not be a command: a command
+     * is asked what it looks like at a time, and "is this node a child" is not a
+     * value a time can produce — the tree either contains it or it doesn't, and
+     * getting there means having run the add. Collapsed-but-present is the same
+     * picture reached by a route that *is* a function of `t`.
+     *
+     * A plain array rather than reactive props because the count is the series
+     * count, which is data. The entries' props are bound to it, so writing one
+     * still moves the layout.
+     */
+    reveal = [];
+    /**
+     * Each entry's natural width, last time it was fully shown.
+     *
+     * A collapse needs numeric endpoints — `lerpSizeInput` snaps between a token
+     * and a number rather than interpolating — and `"hug"` is not a number until
+     * something measures it. Refreshed on every frame an entry is at full reveal
+     * (see {@link widthFor}), so it is current by the time a hide starts, and it
+     * tracks a relabelled series or a restyled legend without being told.
+     */
+    natural = [];
+    constructor(props) {
+        // `flow` after the spread, with the rest of the geometry: this class *is*
+        // the row, so the direction is its own answer and not the caller's. It has
+        // to be stated — a `Rect` given no flow lays its children out `freeform`,
+        // which stacks every entry on the same spot. One series looks perfect that
+        // way and three look like one smeared caption, so the failure only shows up
+        // on the charts that most need a legend.
+        super({
+            ...props,
+            flow: "horizontal",
+            align: "center",
+            width: "hug",
+            height: "hug",
+        });
+        // Structure is one entry per series, so it's composed here from the resolved
+        // props super() applied. Fixed row geometry last, so it wins over super().
+        this.set({ gap: this.legend.itemGap, padding: this.legend.padding });
+        this.reveal = this.series.map((s) => ((s.enabled ?? true) ? 1 : 0));
+        this.natural = this.series.map(() => 0);
+        this.items = this.series.map((s, i) => this.buildItem(s, i));
+        // All of them, in series order. Order is now fixed rather than depending on
+        // which siblings happen to be shown, so an entry always comes back where it
+        // belongs and `insertionIndex` has nothing left to compute.
+        for (const item of this.items)
+            this.add(item);
+    }
+    /**
+     * An entry's width for its current reveal.
+     *
+     * `"hug"` at full reveal rather than the pinned number, so a shown entry stays
+     * responsive to its own content; the number only takes over while it is
+     * collapsing, which is the only time a token cannot express it.
+     *
+     * Records the natural width as a side effect, which is the honest place for it:
+     * this runs inside a binding, so it is already reading the layout every frame,
+     * and the value it wants is the one the layout just produced. It writes a plain
+     * array rather than a signal, so nothing is invalidated by it.
+     */
+    widthFor(index) {
+        const shown = this.reveal[index] ?? 0;
+        if (shown >= 1) {
+            const measured = this.items[index]?.measuredWidth ?? 0;
+            if (measured > 0)
+                this.natural[index] = measured;
+            return "hug";
+        }
+        return shown * (this.natural[index] ?? 0);
+    }
+    /** One entry: the series caption beside its colour swatch. */
+    buildItem(series, index) {
+        const marker = this.legend.markerStyle;
+        const item = new Rect({ flow: "horizontal",
+            gap: 12,
+            align: "center",
+            // Bound to the reveal, so showing and hiding is a number moving rather
+            // than a child arriving and leaving.
+            width: () => this.widthFor(index),
+            opacity: () => this.reveal[index] ?? 0,
+            height: "hug",
+            children: [
+                new Text({
+                    ...textOps.styleProps(this.legend.textStyle),
+                    text: series.label,
+                }),
+                new Rect({
+                    width: marker.width,
+                    height: marker.height,
+                    cornerRadius: marker.borderRadius,
+                    fill: this.swatches[index] ?? "white",
+                    stroke: marker.stroke,
+                    shadow: marker.shadow,
+                }),
+            ],
+        });
+        // `gapScale` is a `Node` prop rather than a container one, so it is bound here
+        // instead of in the config. It tracks the reveal so the flanking gap closes
+        // with the entry rather than snapping when it reaches zero.
+        item.set({ gapScale: () => this.reveal[index] ?? 0 });
+        return item;
+    }
+    /** True if series `index` is showing at all — see {@link reveal}. */
+    isEnabled(index) {
+        return (this.reveal[index] ?? 0) > 0;
+    }
+    /**
+     * Grow series `index`'s entry back in at its series-order position, the
+     * siblings sliding over to make room.
+     *
+     * A reveal tween rather than an animated `addChildAt`. The entry never left —
+     * see {@link reveal} — so there is no add to have happened, and the whole
+     * thing is a function of `t`.
+     */
+    showSeries(args) {
+        const { index = 0 } = args.data ?? {};
+        return this.revealTo(index, 1, args.duration ?? 0.35, args.easing ?? easeOut());
+    }
+    /**
+     * Shrink series `index`'s entry away, the gap closing behind it — the mirror
+     * of {@link showSeries}.
+     */
+    hideSeries(args) {
+        const { index = 0 } = args.data ?? {};
+        return this.revealTo(index, 0, args.duration ?? 0.35, args.easing ?? easeOut());
+    }
+    /**
+     * Ramp one entry's reveal to `target`.
+     *
+     * `from` is read when the command is built, which for a driven scene is with
+     * the node in the state its own start time implies — so a hide that follows a
+     * show starts where the show left it rather than at whatever the node happens
+     * to hold now.
+     */
+    revealTo(index, target, duration, easing) {
+        if (this.items[index] === undefined)
+            return hold(duration);
+        const from = this.reveal[index] ?? 0;
+        return drive(duration, (t) => {
+            this.reveal[index] = from + (target - from) * easing(t);
+        });
+    }
+    /**
+     * Dim every entry but series `index` to {@link SPOTLIGHT_DIM} and bring that
+     * one back to full — the legend half of a chart's `spotlightSeries`. Entries
+     * stay in place; only their opacity moves, so the row doesn't reflow.
+     *
+     * Only the currently-shown entries are touched — a hidden series' entry is
+     * left as {@link hideSeries} left it.
+     */
+    spotlightSeries(args) {
+        const { index = 0 } = args.data ?? {};
+        const duration = args.duration ?? 0.35;
+        const easing = args.easing ?? easeOut();
+        // Opacity only, on entries that are already in the row — no membership
+        // changes, so unlike {@link showSeries} this is a plain function of `t`.
+        return together(...this.items
+            .map((item, i) => ({ item, i }))
+            .filter(({ i }) => this.isEnabled(i))
+            .map(({ item, i }) => item.to({ data: { opacity: i === index ? 1 : SPOTLIGHT_DIM }, duration, easing })));
+    }
+}
+__decorate([
+    property({ default: () => [] })
+], ChartLegend.prototype, "series", void 0);
+__decorate([
+    property({ default: () => [] })
+], ChartLegend.prototype, "swatches", void 0);
+__decorate([
+    property({ default: DEFAULT_LEGEND })
+], ChartLegend.prototype, "legend", void 0);
+__decorate([
+    command()
+], ChartLegend.prototype, "showSeries", null);
+__decorate([
+    command()
+], ChartLegend.prototype, "hideSeries", null);
+__decorate([
+    command()
+], ChartLegend.prototype, "spotlightSeries", null);
+//# sourceMappingURL=chart-legend.js.map

package/dist/kit/chart-legend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chart-legend.js","sourceRoot":"","sources":["../../src/kit/chart-legend.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,OAAO,EACP,QAAQ,EACR,OAAO,GAMR,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAiB,MAAM,8BAA8B,CAAA;AAEnF,OAAO,EACL,cAAc,EACd,aAAa,GAGd,MAAM,UAAU,CAAA;AAqBjB;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,WAAY,SAAQ,IAAI;IAKnC,6EAA6E;IACrE,KAAK,GAAW,EAAE,CAAA;IAC1B;;;;;;;;;;;;;;;OAeG;IACK,MAAM,GAAa,EAAE,CAAA;IAC7B;;;;;;;;OAQG;IACK,OAAO,GAAa,EAAE,CAAA;IAE9B,YAAY,KAAiD;QAC3D,0EAA0E;QAC1E,2EAA2E;QAC3E,0EAA0E;QAC1E,2EAA2E;QAC3E,4EAA4E;QAC5E,yCAAyC;QACzC,KAAK,CAAC;YACJ,GAAI,KAAmB;YACvB,IAAI,EAAE,YAAY;YAClB,KAAK,EAAE,QAAQ;YACf,KAAK,EAAE,KAAK;YACZ,MAAM,EAAE,KAAK;SACd,CAAC,CAAA;QAEF,6EAA6E;QAC7E,2EAA2E;QAC3E,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,CAAA;QAEpE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QACnE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAA;QACvC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QAE5D,4EAA4E;QAC5E,4EAA4E;QAC5E,4DAA4D;QAC5D,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK;YAAE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;IAC/C,CAAC;IAED;;;;;;;;;;;OAWG;IACK,QAAQ,CAAC,KAAa;QAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QACrC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,aAAa,IAAI,CAAC,CAAA;YACtD,IAAI,QAAQ,GAAG,CAAC;gBAAE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAA;YAChD,OAAO,KAAK,CAAA;QACd,CAAC;QACD,OAAO,KAAK,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAA;IAC3C,CAAC;IAED,8DAA8D;IACtD,SAAS,CAAC,MAAmB,EAAE,KAAa;QAClD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,WAAW,CAAA;QACtC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,EAAE,IAAI,EAAE,YAAY;YACxC,GAAG,EAAE,EAAE;YACP,KAAK,EAAE,QAAQ;YACf,uEAAuE;YACvE,qCAAqC;YACrC,KAAK,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;YACjC,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC;YACtC,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE;gBACR,IAAI,IAAI,CAAC;oBACP,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC;oBAC5C,IAAI,EAAE,MAAM,CAAC,KAAK;iBACnB,CAAC;gBACF,IAAI,IAAI,CAAC;oBACP,KAAK,EAAE,MAAM,CAAC,KAAK;oBACnB,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,YAAY,EAAE,MAAM,CAAC,YAAY;oBACjC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,OAAO;oBACrC,MAAM,EAAE,MAAM,CAAC,MAAM;oBACrB,MAAM,EAAE,MAAM,CAAC,MAAM;iBACtB,CAAC;aACH;SACF,CAAC,CAAA;QACF,+EAA+E;QAC/E,4EAA4E;QAC5E,4DAA4D;QAC5D,IAAI,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACrD,OAAO,IAAI,CAAA;IACb,CAAC;IAED,qEAAqE;IACrE,SAAS,CAAC,KAAa;QACrB,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;IACtC,CAAC;IAED;;;;;;;OAOG;IAEH,UAAU,CAAC,IAAoC;QAC7C,MAAM,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAA;QACrC,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,QAAQ,IAAI,IAAI,EAAE,IAAI,CAAC,MAAM,IAAI,OAAO,EAAE,CAAC,CAAA;IACjF,CAAC;IAED;;;OAGG;IAEH,UAAU,CAAC,IAAoC;QAC7C,MAAM,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAA;QACrC,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,QAAQ,IAAI,IAAI,EAAE,IAAI,CAAC,MAAM,IAAI,OAAO,EAAE,CAAC,CAAA;IACjF,CAAC;IAED;;;;;;;OAOG;IACK,QAAQ,CACd,KAAa,EACb,MAAc,EACd,QAAgB,EAChB,MAAsB;QAEtB,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC,QAAQ,CAAC,CAAA;QAC1D,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QACpC,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE;YAC3B,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAA;QACzD,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;OAOG;IAEH,eAAe,CAAC,IAAoC;QAClD,MAAM,EAAE,KAAK,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAA;QACrC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAA;QACtC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,OAAO,EAAE,CAAA;QACvC,uEAAuE;QACvE,yEAAyE;QACzE,OAAO,QAAQ,CACb,GAAG,IAAI,CAAC,KAAK;aACV,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC;aAC/B,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;aACpC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CACnB,IAAI,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAClF,CACJ,CAAA;IACH,CAAC;CACF;AAhM2D;IAAzD,QAAQ,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAmB,EAAE,CAAC;2CAA8B;AAC5B;IAAlD,QAAQ,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAY,EAAE,CAAC;6CAAyB;AACpB;IAA9C,QAAQ,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC;2CAA6B;AAkInE;IADC,OAAO,EAAE;6CAIT;AAOD;IADC,OAAO,EAAE;6CAIT;AAgCD;IADC,OAAO,EAAE;kDAeT","sourcesContent":["import {\n  Rect,\n  Text,\n  command,\n  easeOut,\n  property,\n  textOps,\n  type CommandArgs,\n  type EasingFunction,\n  type Fill,\n  type NodeConfig,\n  type RectProps,\n} from \"@motionscript/core\"\n\nimport { drive, hold, together, type Seekable } from \"@motionscript/core/component\"\n\nimport {\n  DEFAULT_LEGEND,\n  SPOTLIGHT_DIM,\n  type ChartSeries,\n  type LegendConfig,\n} from \"./shared\"\n\nexport interface ChartLegendProps extends RectProps {\n  /**\n   * One entry per series: legend `label`, its `enabled` default, and — through\n   * {@link ChartLegendProps.swatches} — the colour its chip is painted. A series\n   * that starts enabled (the default) is added to the row up front; one that\n   * starts `false` is hidden until a later {@link ChartLegend.showSeries}.\n   */\n  series: ChartSeries[]\n  /**\n   * The swatch colour for each series, by index — resolved by the chart, whose\n   * business it is whether a series' colour comes out of a stroke palette (a\n   * line) or a fill palette (a bar). Shorter than the series list means the\n   * missing entries fall back to white.\n   */\n  swatches: Fill[]\n  /** Padding, caption style, gaps, and swatch geometry — see {@link LegendConfig}. */\n  legend: LegendConfig\n}\n\n/**\n * The legend of a chart: a **horizontal-flow row of entries**, one per series, laid out\n * left-to-right with the theme's `itemGap`. Each entry pairs the series label\n * with a rounded colour swatch; only the swatch carries the series colour, the\n * caption reads in the legend's neutral ink.\n *\n * {@link showSeries}/{@link hideSeries} flip a series on or off — showing one\n * adds its entry back into the row at its stable series position and grows it\n * in, hiding one shrinks it away and removes it. So the row only ever holds the\n * currently-enabled series, in series order, and closes the gap when one leaves.\n *\n * This node *is* the row, so the parent places it (centred below the chart) and\n * it hugs its entries.\n */\nexport class ChartLegend extends Rect {\n  @property({ default: () => [] as ChartSeries[] }) declare series: ChartSeries[]\n  @property({ default: () => [] as Fill[] }) declare swatches: Fill[]\n  @property({ default: DEFAULT_LEGEND }) declare legend: LegendConfig\n\n  /** One entry per series. **Every** entry is a child — see {@link reveal}. */\n  private items: Rect[] = []\n  /**\n   * How far each entry is shown, `0`–`1`. Drives its width, opacity and gap\n   * together, so `0` is an entry that takes no room and `1` is one at its\n   * natural size.\n   *\n   * This replaces adding and removing the entry from the row, which is what\n   * `showSeries`/`hideSeries` used to do. That could not be a command: a command\n   * is asked what it looks like at a time, and \"is this node a child\" is not a\n   * value a time can produce — the tree either contains it or it doesn't, and\n   * getting there means having run the add. Collapsed-but-present is the same\n   * picture reached by a route that *is* a function of `t`.\n   *\n   * A plain array rather than reactive props because the count is the series\n   * count, which is data. The entries' props are bound to it, so writing one\n   * still moves the layout.\n   */\n  private reveal: number[] = []\n  /**\n   * Each entry's natural width, last time it was fully shown.\n   *\n   * A collapse needs numeric endpoints — `lerpSizeInput` snaps between a token\n   * and a number rather than interpolating — and `\"hug\"` is not a number until\n   * something measures it. Refreshed on every frame an entry is at full reveal\n   * (see {@link widthFor}), so it is current by the time a hide starts, and it\n   * tracks a relabelled series or a restyled legend without being told.\n   */\n  private natural: number[] = []\n\n  constructor(props?: NodeConfig<ChartLegend, ChartLegendProps>) {\n    // `flow` after the spread, with the rest of the geometry: this class *is*\n    // the row, so the direction is its own answer and not the caller's. It has\n    // to be stated — a `Rect` given no flow lays its children out `freeform`,\n    // which stacks every entry on the same spot. One series looks perfect that\n    // way and three look like one smeared caption, so the failure only shows up\n    // on the charts that most need a legend.\n    super({\n      ...(props as RectProps),\n      flow: \"horizontal\",\n      align: \"center\",\n      width: \"hug\",\n      height: \"hug\",\n    })\n\n    // Structure is one entry per series, so it's composed here from the resolved\n    // props super() applied. Fixed row geometry last, so it wins over super().\n    this.set({ gap: this.legend.itemGap, padding: this.legend.padding })\n\n    this.reveal = this.series.map((s) => ((s.enabled ?? true) ? 1 : 0))\n    this.natural = this.series.map(() => 0)\n    this.items = this.series.map((s, i) => this.buildItem(s, i))\n\n    // All of them, in series order. Order is now fixed rather than depending on\n    // which siblings happen to be shown, so an entry always comes back where it\n    // belongs and `insertionIndex` has nothing left to compute.\n    for (const item of this.items) this.add(item)\n  }\n\n  /**\n   * An entry's width for its current reveal.\n   *\n   * `\"hug\"` at full reveal rather than the pinned number, so a shown entry stays\n   * responsive to its own content; the number only takes over while it is\n   * collapsing, which is the only time a token cannot express it.\n   *\n   * Records the natural width as a side effect, which is the honest place for it:\n   * this runs inside a binding, so it is already reading the layout every frame,\n   * and the value it wants is the one the layout just produced. It writes a plain\n   * array rather than a signal, so nothing is invalidated by it.\n   */\n  private widthFor(index: number): number | \"hug\" {\n    const shown = this.reveal[index] ?? 0\n    if (shown >= 1) {\n      const measured = this.items[index]?.measuredWidth ?? 0\n      if (measured > 0) this.natural[index] = measured\n      return \"hug\"\n    }\n    return shown * (this.natural[index] ?? 0)\n  }\n\n  /** One entry: the series caption beside its colour swatch. */\n  private buildItem(series: ChartSeries, index: number): Rect {\n    const marker = this.legend.markerStyle\n    const item = new Rect({ flow: \"horizontal\",\n      gap: 12,\n      align: \"center\",\n      // Bound to the reveal, so showing and hiding is a number moving rather\n      // than a child arriving and leaving.\n      width: () => this.widthFor(index),\n      opacity: () => this.reveal[index] ?? 0,\n      height: \"hug\",\n      children: [\n        new Text({\n          ...textOps.styleProps(this.legend.textStyle),\n          text: series.label,\n        }),\n        new Rect({\n          width: marker.width,\n          height: marker.height,\n          cornerRadius: marker.borderRadius,\n          fill: this.swatches[index] ?? \"white\",\n          stroke: marker.stroke,\n          shadow: marker.shadow,\n        }),\n      ],\n    })\n    // `gapScale` is a `Node` prop rather than a container one, so it is bound here\n    // instead of in the config. It tracks the reveal so the flanking gap closes\n    // with the entry rather than snapping when it reaches zero.\n    item.set({ gapScale: () => this.reveal[index] ?? 0 })\n    return item\n  }\n\n  /** True if series `index` is showing at all — see {@link reveal}. */\n  isEnabled(index: number): boolean {\n    return (this.reveal[index] ?? 0) > 0\n  }\n\n  /**\n   * Grow series `index`'s entry back in at its series-order position, the\n   * siblings sliding over to make room.\n   *\n   * A reveal tween rather than an animated `addChildAt`. The entry never left —\n   * see {@link reveal} — so there is no add to have happened, and the whole\n   * thing is a function of `t`.\n   */\n  @command()\n  showSeries(args: CommandArgs<{ index: number }>): Seekable {\n    const { index = 0 } = args.data ?? {}\n    return this.revealTo(index, 1, args.duration ?? 0.35, args.easing ?? easeOut())\n  }\n\n  /**\n   * Shrink series `index`'s entry away, the gap closing behind it — the mirror\n   * of {@link showSeries}.\n   */\n  @command()\n  hideSeries(args: CommandArgs<{ index: number }>): Seekable {\n    const { index = 0 } = args.data ?? {}\n    return this.revealTo(index, 0, args.duration ?? 0.35, args.easing ?? easeOut())\n  }\n\n  /**\n   * Ramp one entry's reveal to `target`.\n   *\n   * `from` is read when the command is built, which for a driven scene is with\n   * the node in the state its own start time implies — so a hide that follows a\n   * show starts where the show left it rather than at whatever the node happens\n   * to hold now.\n   */\n  private revealTo(\n    index: number,\n    target: number,\n    duration: number,\n    easing: EasingFunction\n  ): Seekable {\n    if (this.items[index] === undefined) return hold(duration)\n    const from = this.reveal[index] ?? 0\n    return drive(duration, (t) => {\n      this.reveal[index] = from + (target - from) * easing(t)\n    })\n  }\n\n  /**\n   * Dim every entry but series `index` to {@link SPOTLIGHT_DIM} and bring that\n   * one back to full — the legend half of a chart's `spotlightSeries`. Entries\n   * stay in place; only their opacity moves, so the row doesn't reflow.\n   *\n   * Only the currently-shown entries are touched — a hidden series' entry is\n   * left as {@link hideSeries} left it.\n   */\n  @command()\n  spotlightSeries(args: CommandArgs<{ index: number }>): Seekable {\n    const { index = 0 } = args.data ?? {}\n    const duration = args.duration ?? 0.35\n    const easing = args.easing ?? easeOut()\n    // Opacity only, on entries that are already in the row — no membership\n    // changes, so unlike {@link showSeries} this is a plain function of `t`.\n    return together(\n      ...this.items\n        .map((item, i) => ({ item, i }))\n        .filter(({ i }) => this.isEnabled(i))\n        .map(({ item, i }) =>\n          item.to({ data: { opacity: i === index ? 1 : SPOTLIGHT_DIM }, duration, easing })\n        )\n    )\n  }\n}\n"]}

package/dist/kit/shared.d.ts

@@ -0,0 +1,251 @@
+/**
+ * The vocabulary every chart node shares: what a *series* is, how an axis is
+ * scaled and formatted, and the theme leaves each chart's own theme is assembled
+ * from.
+ *
+ * This module exists because the three chart types are three ways of drawing the
+ * same table. A line chart, a bar chart and a pie chart disagree about almost
+ * everything visible — polylines against columns against wedges — and agree
+ * about almost everything underneath: a series is a column with a caption and a
+ * paint, a marker is a number formatted one way, a legend is a swatch beside a
+ * label, and a theme is a tree of paints with one mapper and one tween. Writing
+ * that three times would mean three answers to "how does a chart round its axis"
+ * within one app.
+ *
+ * Kept renderer-agnostic (no `Node` imports) so the studio's own inspector
+ * mappings can build a partial theme without pulling the node classes in, the
+ * same way `line-chart-props.ts` always has.
+ *
+ * **Two conventions run through every resolver and lerp below**, inherited from
+ * the shape system's `resolveStroke`/`resolveShadow`:
+ *
+ * - A **mapper** merges the author's loose, partial input onto a `previous`
+ *   resolved value and resolves every leaf, so the tween always has resolved
+ *   data to interpolate. It is idempotent.
+ * - A **tween** interpolates two resolved values leaf by leaf. Categorical
+ *   fields (`fontFamily`, `textAlign`) and fields that are `undefined` on either
+ *   side **step at the midpoint**, because there is no meaningful in-between and
+ *   defaulting the missing side to 0 would animate a font weight down to nothing
+ *   on the way to "unset".
+ */
+import { type DataRecord, type Fill, type Insets, type Shadow, type Stroke, type TextStyle } from "@motionscript/core";
+/**
+ * One series of a chart: a column of the table, captioned and painted.
+ *
+ * `field` names the column carrying this series' values. What that becomes is
+ * the chart's business — a traced polyline, a column of bars, a wedge — but the
+ * three questions asked of it are the same everywhere: which column, what to
+ * call it, what to paint it, and whether it is currently drawn.
+ *
+ * `fill` is an **override**: omit it and the series takes the theme palette's
+ * entry for its own index, which is what makes a chart nobody has themed come
+ * out in five distinct colours rather than five identical ones.
+ */
+export interface ChartSeries {
+    /** Key into each data row for this series' value. */
+    field: string;
+    /** Legend caption for this series. */
+    label: string;
+    /**
+     * Paint override for this series' mark and its legend swatch. Omit to take
+     * the theme palette's entry for this series' index.
+     */
+    fill?: Fill;
+    /** Whether the series shows by default. Defaults to `true`. */
+    enabled?: boolean;
+}
+/** A `[min, max]` numeric range in data units. */
+export type Range = [min: number, max: number];
+/**
+ * One axis's *data* domain — what it shows — as opposed to {@link AxisConfig},
+ * which is how it's *styled*. Every field is optional: `range`/`ticks` derive
+ * from the plotted data when omitted, and `label` defaults to `""`.
+ */
+export interface AxisDomainConfig {
+    /** Caption drawn alongside the axis. Pass `""` (the default) to hide it. */
+    label?: string;
+    /** `[min, max]` of the scale. Derived from the data bounds when omitted. */
+    range?: Range;
+    /** Tick values (in data units). Derived (five evenly-spaced) when omitted. */
+    ticks?: number[];
+    /**
+     * How a tick value is written down — a `number-format` pattern such as
+     * `#,##0.00` or `$#,##0`.
+     *
+     * Here rather than in {@link AxisConfig} because it is a statement about the
+     * *numbers*, not about the ink they are set in: `$` on a revenue axis says
+     * what the column holds, and it has to survive a re-theme. It sits beside
+     * `range` and `ticks` for the same reason those do.
+     */
+    format?: string;
+}
+/**
+ * An axis domain's @property mapper: merges the author's partial input onto
+ * `previous`, so a later partial `.set({ yAxis: {...} })` patches
+ * `label`/`range`/`ticks` independently. `range`/`ticks` staying `undefined`
+ * after the merge is the auto-derive signal the scale getters read.
+ */
+export declare function resolveAxisDomain(domain: AxisDomainConfig | undefined, previous?: AxisDomainConfig): AxisDomainConfig;
+/**
+ * An axis domain's @property tween: interpolates `range`/`ticks` numerically
+ * (pairwise by index for `ticks`), so a `to` command that restates a range
+ * rescales the plot smoothly. `label`, and either field when one side is in
+ * auto-derive mode, step at the midpoint.
+ */
+export declare function lerpAxisDomain(from: AxisDomainConfig, to: AxisDomainConfig, t: number): AxisDomainConfig;
+/**
+ * The low-level colour tokens the default themes are built from — a dark plot
+ * panel with warm-grey axis furniture.
+ */
+export declare const CHART_PALETTE: {
+    /** Fill of the plot panel behind the marks. */
+    readonly plotFill: "#15130e";
+    /** Colour of the plot's thick border. */
+    readonly borderColor: "#4a4036";
+    /** Colour of the faint grid lines spanning the plot. */
+    readonly gridColor: "#2c2820";
+    /** Colour of the numeric axis markers, axis captions, and legend labels. */
+    readonly markerColor: "#8a7f70";
+    /** Colour of a spotlit region's dashed rules and its wash. */
+    readonly regionColor: "#d99a3a";
+};
+/** The out-of-the-box series palette, cycled by series index. */
+export declare const DEFAULT_SERIES_COLORS: readonly ["#d9603b", "#8194ad", "#e0a93b", "#5e9d6b", "#9ec85a"];
+/**
+ * Opacity an *un*-spotlighted series fades to — its mark and its legend entry
+ * alike, so the two dim together.
+ */
+export declare const SPOTLIGHT_DIM = 0.2;
+/** Clamp a number into `[0, 1]` — the range every reveal signal here runs in. */
+export declare function clampUnit(value: number): number;
+/**
+ * Read a numeric field off a row, defaulting missing/non-numeric values to 0.
+ *
+ * A column left as strings silently plots as 0, which is why the CSV parser's
+ * numeric auto-coercion matters — a quoted or unit-suffixed column won't plot
+ * until it's coerced.
+ */
+export declare function num(row: DataRecord, field: string | undefined): number;
+/**
+ * Read a field off a row as its caption — the counterpart to {@link num} for
+ * the columns a chart *names* things by rather than measures them by (a bar's
+ * category, a wedge's slice). A missing cell reads as empty rather than as the
+ * string `"undefined"`.
+ */
+export declare function text(row: DataRecord, field: string | undefined): string;
+/**
+ * Every column that holds numbers across `data`, in header order, skipping the
+ * names in `exclude` (typically the category column).
+ *
+ * A column counts as numeric only if every non-empty cell in it is a number, so
+ * a stray text cell leaves the column out rather than plotting zeros. This is
+ * what lets a chart plot "every other column" without the author naming twenty
+ * fields.
+ */
+export declare function numericFields(data: DataRecord[], exclude?: string[]): string[];
+/** One axis's (x or y) style vocabulary. */
+export interface AxisConfig {
+    /** Style of each marker along the axis. */
+    labelStyle: TextStyle;
+    /** Style of the axis caption. */
+    titleStyle: TextStyle;
+    /**
+     * This axis's direction of the plot's internal grid — weight+fill honoured,
+     * dash/cap/join ignored (grid lines are drawn as filled rects).
+     */
+    lineStyle: Stroke;
+    /**
+     * Gap between the plot and the marker row. Only the side facing the plot is
+     * read — `.top` for a horizontal axis, `.right` for a vertical one.
+     */
+    tickPadding: Insets;
+    /** Gap between the marker row and the caption, read the same side. */
+    titlePadding: Insets;
+}
+/** A legend's per-series colour swatch — a rounded chip, not the caption. */
+export interface LegendMarkerConfig {
+    width: number;
+    height: number;
+    borderRadius: number;
+    stroke: Stroke;
+    shadow: Shadow;
+}
+/** A legend's visual theme. */
+export interface LegendConfig {
+    padding: Insets;
+    /** Caption style — only the swatch carries the series colour. */
+    textStyle: TextStyle;
+    /** Gap between legend entries. */
+    itemGap: number;
+    markerStyle: LegendMarkerConfig;
+}
+/** The plot panel a cartesian chart draws its marks over. */
+export interface PlotAreaConfig {
+    stroke: Stroke;
+    fill: Fill;
+    shadow: Shadow;
+}
+/** The default styling of a horizontal (marker row beneath the plot) axis. */
+export declare const DEFAULT_X_AXIS: AxisConfig;
+/** The default styling of a vertical (marker column beside the plot) axis. */
+export declare const DEFAULT_Y_AXIS: AxisConfig;
+/**
+ * The default plot panel: **unpainted**, framed. A chart reads against the
+ * stage rather than punching a panel into it, which is the look the family was
+ * designed at.
+ */
+export declare const DEFAULT_PLOT_AREA: PlotAreaConfig;
+/** The default legend styling, shared by every chart that draws one. */
+export declare const DEFAULT_LEGEND: LegendConfig;
+/** The default per-series stroke palette — {@link DEFAULT_SERIES_COLORS}, drawn 4px. */
+export declare const DEFAULT_SERIES_STROKES: Stroke[];
+/** The default per-series fill palette — the same colours, as solid paint. */
+export declare const DEFAULT_SERIES_FILLS: Fill[];
+export declare function resolveAxisConfig(axis: Partial<AxisConfig> | undefined, previous: AxisConfig): AxisConfig;
+export declare function lerpAxisConfig(from: AxisConfig, to: AxisConfig, t: number): AxisConfig;
+export declare function resolvePlotArea(plotArea: Partial<PlotAreaConfig> | undefined, previous: PlotAreaConfig): PlotAreaConfig;
+export declare function lerpPlotArea(from: PlotAreaConfig, to: PlotAreaConfig, t: number): PlotAreaConfig;
+/** A legend theme as the author may state it — every branch optional. */
+export type LegendTheme = Partial<Omit<LegendConfig, "markerStyle">> & {
+    markerStyle?: Partial<LegendMarkerConfig>;
+};
+export declare function resolveLegendConfig(legend: LegendTheme | undefined, previous: LegendConfig): LegendConfig;
+export declare function lerpLegendConfig(from: LegendConfig, to: LegendConfig, t: number): LegendConfig;
+/** A whole-palette override replaces the previous palette outright. */
+export declare function resolveSeriesStrokes(styles: Stroke[] | undefined, previous: Stroke[]): Stroke[];
+/** Pairwise by index; a palette that grows/shrinks holds the longer side's tail. */
+export declare function lerpSeriesStrokes(from: Stroke[], to: Stroke[], t: number): Stroke[];
+/** The fill-palette twin of {@link resolveSeriesStrokes}, for filled marks. */
+export declare function resolveSeriesFills(fills: Fill[] | undefined, previous: Fill[]): Fill[];
+/** The fill-palette twin of {@link lerpSeriesStrokes}. */
+export declare function lerpSeriesFills(from: Fill[], to: Fill[], t: number): Fill[];
+/**
+ * The effective stroke for series `index`: the palette's entry at
+ * `index % palette.length`, with the series' own `fill`, if set, overriding just
+ * the last (topmost) layer's colour.
+ */
+export declare function resolveSeriesStroke(palette: Stroke[], series: ChartSeries, index: number): Stroke;
+/**
+ * The effective *colour* for series `index` — the same colour
+ * {@link resolveSeriesStroke} draws its line in — for contexts (a legend
+ * swatch) that only need the fill.
+ */
+export declare function resolveSeriesFill(palette: Stroke[], series: ChartSeries, index: number): Fill;
+/**
+ * The effective paint for mark `index` of a **filled** chart (a bar, a wedge):
+ * the series' own `fill` when it carries one, else the palette's entry for its
+ * index, cycled.
+ *
+ * The stroke twin above has to reach inside a stroke to swap one layer's colour;
+ * a filled mark has no such geometry wrapped around its paint, so an override is
+ * simply the whole answer.
+ */
+export declare function resolvePalettePaint(palette: Fill[], override: Fill | undefined, index: number): Fill;
+/** Format a marker value: integers plain, otherwise trimmed to one decimal. */
+export declare function formatMarker(value: number): string;
+/** Format a fraction in `[0, 1]` as a percentage: integers plain, else one decimal. */
+export declare function formatPercent(fraction: number): string;
+/** `markerCount` evenly-spaced tick values across `[min, max]`, ends inclusive. */
+export declare function markerValues([min, max]: Range, markerCount: number): number[];
+export { niceStep, enterBudget } from "@motionscript/core/component";
+//# sourceMappingURL=shared.d.ts.map

package/dist/kit/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/kit/shared.ts"],"names":[],"mappings":"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"}