@motionscript/charts 0.1.0-alpha.0 → 0.1.0-alpha.10

package/src/kit/shared.ts

@@ -12,9 +12,8 @@
  * 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.
+ * Kept renderer-agnostic (no `Node` imports) so a host's own inspector
+ * mappings can build a partial theme without pulling the components in.
  *
  * **Two conventions run through every resolver and lerp below**, inherited from
  * the shape system's `resolveStroke`/`resolveShadow`:
@@ -46,7 +45,7 @@ import {
   type Stroke,
   type StrokeResolved,
   type TextStyle,
-} from "@motionscript/core"
+} from "@motionscript/sdk"
 
 /**
  * One series of a chart: a column of the table, captioned and painted.
@@ -102,7 +101,7 @@ export interface AxisDomainConfig {
 }
 
 /**
- * An axis domain's @property mapper: merges the author's partial input onto
+ * An axis domain entry's resolve: 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.
@@ -120,7 +119,7 @@ export function resolveAxisDomain(
 }
 
 /**
- * An axis domain's @property tween: interpolates `range`/`ticks` numerically
+ * An axis domain entry's lerp: 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.
@@ -163,6 +162,81 @@ function lerpOptionalTicks(
   return out
 }
 
+/**
+ * Where a generic `to()` of an axis domain should land, given the domain as it
+ * is *drawn* (`drawn`, with `range` and `ticks` resolved off the data), or
+ * `undefined` when the request states neither a `range` nor `ticks` and the
+ * plain property tween will do.
+ *
+ * The stored domain of an auto axis has no `range` and no `ticks`, and
+ * {@link lerpAxisDomain} steps an unset side at the midpoint, so tweening the
+ * stored value from an auto axis is a cut. The charts therefore tween between
+ * resolved domains, as their zoom does; this builds the destination. A `range`
+ * given without `ticks` keeps the tick *count* the axis already draws, so each
+ * marker slides from its old value to its new one instead of the row popping.
+ */
+export function axisTweenTarget(
+  drawn: AxisDomainConfig,
+  requested: AxisDomainConfig | undefined
+): AxisDomainConfig | undefined {
+  if (requested?.range === undefined && requested?.ticks === undefined) return undefined
+  const target = resolveAxisDomain(requested, drawn)
+  if (requested.ticks === undefined && requested.range !== undefined) {
+    const count = Math.max(2, drawn.ticks?.length ?? 2)
+    target.ticks = markerValues(requested.range, count - 1)
+  }
+  return target
+}
+
+/**
+ * An axis domain part-way through a tween that leaves or reaches a `range` or
+ * `ticks` left to the data: both ends as stored, and how far along. Only the
+ * chart knows what an auto side draws as, so {@link settleAxisDomain} resolves
+ * it there. Its own fields are the plain {@link lerpAxisDomain} of its ends, so
+ * a mapper merging onto one still reads a domain.
+ */
+export interface AxisDomainBlend extends AxisDomainConfig {
+  readonly blend: { readonly from: AxisDomainConfig; readonly to: AxisDomainConfig; readonly t: number }
+}
+
+function blendOf(domain: AxisDomainConfig): AxisDomainBlend["blend"] | undefined {
+  return (domain as Partial<AxisDomainBlend>).blend
+}
+
+/**
+ * A chart's axis entry tween: what `to({ yAxis: { range } })` moves through.
+ * Between two explicit domains it is {@link lerpAxisDomain}, and a restated
+ * `range` without `ticks` spreads explicit ticks across it, keeping their count.
+ * When either end leaves `range` or `ticks` to the data, the value between is an
+ * {@link AxisDomainBlend}, which the chart draws as the blend of what each end
+ * draws: a rescale from an auto axis is continuous, not a cut at the midpoint.
+ */
+export function lerpAxisEntry(from: AxisDomainConfig, to: AxisDomainConfig, t: number): AxisDomainConfig {
+  // The mapper merged the request onto `from`, so a field it left unstated is `from`'s own, by identity.
+  const rangeMoved = to.range !== from.range
+  const target = rangeMoved && to.range && to.ticks && to.ticks === from.ticks
+    ? { ...to, ticks: markerValues(to.range, Math.max(2, to.ticks.length) - 1) }
+    : to
+  const blended = blendOf(from) !== undefined
+  const moved = blended || rangeMoved || target.ticks !== from.ticks
+  const auto = blended || from.range === undefined || from.ticks === undefined || target.range === undefined || target.ticks === undefined
+  if (!moved || !auto) return lerpAxisDomain(from, target, t)
+  if (t === 0) return from
+  if (t === 1) return target
+  const blend: AxisDomainBlend = { ...lerpAxisDomain(from, target, t), blend: { from, to: target, t } }
+  return blend
+}
+
+/**
+ * `domain` as the chart draws it: `drawn` resolves a plain domain's auto `range`
+ * and `ticks` off the data, and a blend is the lerp of what its two ends draw.
+ */
+export function settleAxisDomain(domain: AxisDomainConfig, drawn: (domain: AxisDomainConfig) => AxisDomainConfig): AxisDomainConfig {
+  const blend = blendOf(domain)
+  if (!blend) return drawn(domain)
+  return lerpAxisDomain(settleAxisDomain(blend.from, drawn), settleAxisDomain(blend.to, drawn), blend.t)
+}
+
 /**
  * The low-level colour tokens the default themes are built from — a dark plot
  * panel with warm-grey axis furniture.
@@ -203,7 +277,8 @@ export function clampUnit(value: number): number {
 // ---- Row readers ---------------------------------------------------------
 
 /**
- * Read a numeric field off a row, defaulting missing/non-numeric values to 0.
+ * Read a numeric field off a row, defaulting missing, non-numeric and non-finite
+ * 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
@@ -212,7 +287,9 @@ export function clampUnit(value: number): number {
 export function num(row: DataRecord, field: string | undefined): number {
   if (field === undefined) return 0
   const v = row[field]
-  return typeof v === "number" ? v : 0
+  // A `NaN` or infinite cell is no more a measurement than a missing one: read
+  // as 0, it cannot poison the scale and turn every point into `NaN`.
+  return typeof v === "number" && Number.isFinite(v) ? v : 0
 }
 
 /**
@@ -650,10 +727,40 @@ export function resolvePalettePaint(
 // ---- Scales and formatting -----------------------------------------------
 
 
-/** Format a marker value: integers plain, otherwise trimmed to one decimal. */
-export function formatMarker(value: number): string {
+/**
+ * Format a marker value: integers plain, otherwise trimmed to one decimal, or to
+ * as many as the axis's tick `step` needs to tell neighbouring ticks apart.
+ *
+ * One decimal is the floor, so a step of 0.1 or more reads exactly as it always
+ * has; a finer step (a unit axis ticked every 0.05) gets two, instead of five
+ * ticks captioned `0.1 0.1 0.2 0.2 0.3`. Trailing zeros are dropped either way.
+ */
+export function formatMarker(value: number, step?: number): string {
   if (Number.isInteger(value)) return String(value)
-  return value.toFixed(1).replace(/\.0$/, "")
+  const decimals = Math.max(1, step === undefined ? 1 : decimalsFor(step))
+  return value.toFixed(decimals).replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "")
+}
+
+/** Decimal places needed to write `step` exactly, capped at six. */
+function decimalsFor(step: number): number {
+  if (!(step > 0) || !Number.isFinite(step)) return 1
+  for (let d = 0; d <= 6; d++) {
+    const scaled = step * 10 ** d
+    if (Math.abs(scaled - Math.round(scaled)) < 1e-6 * Math.max(1, scaled)) return d
+  }
+  // An irrational-looking step (a third): as many places as separate the ticks.
+  return Math.min(6, Math.max(1, Math.ceil(-Math.log10(step)) + 1))
+}
+
+/** The gap between neighbouring tick values, or `undefined` for fewer than two distinct ones. */
+export function markerStep(markers: readonly number[]): number | undefined {
+  const sorted = [...markers].filter(Number.isFinite).sort((a, b) => a - b)
+  let step: number | undefined
+  for (let i = 1; i < sorted.length; i++) {
+    const gap = sorted[i] - sorted[i - 1]
+    if (gap > 1e-12 && (step === undefined || gap < step)) step = gap
+  }
+  return step
 }
 
 /** Format a fraction in `[0, 1]` as a percentage: integers plain, else one decimal. */
@@ -670,6 +777,6 @@ export function markerValues([min, max]: Range, markerCount: number): number[] {
 }
 
 // Lifted into the engine, because a graph and a diagram want them too — see
-// `@motionscript/core/component`. Re-exported so a chart, and anything that
+// `@motionscript/sdk/component`. Re-exported so a chart, and anything that
 // copied one, still reaches them where it always did.
-export { niceStep, enterBudget } from "@motionscript/core/component"
+export { niceStep, enterBudget } from "@motionscript/sdk/component"

package/src/kit/vertical-axis.ts

@@ -1,18 +1,18 @@
 import {
-  command,
-  Node2D,
   Rect,
   RotatedBox,
   Text,
-  easeOut,
-  property,
+  Types,
+  component2d,
   insetsOps,
   textOps,
-  type CommandArgs,
-  type NodeConfig,
+  type NodeOf,
+  type Node2D,
   type Node2DProps,
-} from "@motionscript/core"
+} from "@motionscript/sdk"
 
+import { asParts, fresh } from "./entries"
+import { armed, arrival, arrivalOf, arrivalsEntry, beats, frameEase, type Arrival } from "./motion"
 import {
   DEFAULT_Y_AXIS,
   enterBudget,
@@ -20,7 +20,6 @@ import {
   type AxisConfig,
   type Range,
 } from "./shared"
-import { at, compose, type Seekable } from "@motionscript/core/component"
 
 export interface VerticalAxisProps extends Node2DProps {
   /** `[min, max]` of the vertical scale the markers are positioned within. */
@@ -31,6 +30,12 @@ export interface VerticalAxisProps extends Node2DProps {
    * the ends.
    */
   markers: number[]
+  /**
+   * How each marker is captioned, one per entry of `markers` and in its order.
+   * Empty (the default), or short, captions a marker with its bare numeric
+   * reading; a chart with a number format on this axis writes them through it.
+   */
+  captions: string[]
   /** Marker/caption text style, grid stroke, and gutters — see {@link AxisConfig}. */
   axis: AxisConfig
   /**
@@ -44,9 +49,15 @@ export interface VerticalAxisProps extends Node2DProps {
 /** How far a marker starts to the right of its slot when it enters, in px. */
 const SLIDE = 24
 
-/** How a tick value is captioned — see {@link VerticalAxis.labelFor}. */
+/** How a tick value is captioned — see {@link VerticalAxisProps.captions}. */
 export type MarkerLabel = (value: number) => string
 
+/** What a marker's caption reads: the one listed for its value, else its bare reading. */
+export function markerCaption(s: { readonly markers: readonly number[]; readonly captions: readonly string[] }, value: number): string {
+  const index = s.markers.indexOf(value)
+  return (index >= 0 ? s.captions[index] : undefined) ?? formatMarker(value)
+}
+
 /**
  * The numeric vertical axis shared by the cartesian charts: a **column of
  * {@link Text} nodes**, one per marker value, running top-to-bottom (highest
@@ -60,73 +71,54 @@ export type MarkerLabel = (value: number) => string
  * tweens `range`/`markers` live. Only the marker **count** is fixed at
  * construction.
  *
- * {@link enter} staggers them in **bottom-to-top**: each marker starts pushed a
+ * `enter` staggers them in **bottom-to-top**: each marker starts pushed a
  * little to the right and transparent, then fades and slides left into place.
  * The resting state is the landed one, so a chart that is never told to enter
  * still reads as a finished chart.
  */
-export class VerticalAxis extends Node2D<VerticalAxisProps> {
-  @property({ default: () => [0, 1] as Range }) declare range: Range
-  @property({ default: () => [] as number[] }) declare markers: number[]
-  @property({ default: DEFAULT_Y_AXIS }) declare axis: AxisConfig
-  @property({ default: "" }) declare label: string
-
-  /**
-   * How a tick value is captioned. Defaults to the bare numeric reading; a
-   * chart with a number format on this axis replaces it (see `number-format`).
-   *
-   * A plain field rather than a `@property`, for the reason the horizontal
-   * axis's twin spells out: it is a policy, not a value, and there is nothing
-   * to tween between two formatters.
-   */
-  labelFor: MarkerLabel = formatMarker
-
-  /** One text node per marker, ordered top → bottom, for the staggered enter. */
-  private markerNodes: Text[] = []
-  /** The caption node, or null when `label` is empty. Entered after the markers. */
-  private labelNode: Text | null = null
-
-  /** The live tick values, top → bottom (highest first) — re-read every frame. */
-  private get sortedMarkers(): number[] {
-    return [...this.markers].sort((a, b) => b - a)
-  }
-
-  /**
-   * Tick `i`'s value, or `undefined` once the live `markers` list is shorter
-   * than the column of text nodes built for it — a slot with no value renders as
-   * empty text rather than repeating its neighbour.
-   */
-  private valueAt(index: number): number | undefined {
-    return this.sortedMarkers[index]
-  }
-
-  /** Tick `i`'s fraction across the live `range`, 0 at the bottom edge. */
-  private fracAt(index: number): number {
-    const v = this.valueAt(index)
-    if (v === undefined) return 0
-    const [min, max] = this.range
-    return max <= min ? 0 : (v - min) / (max - min)
-  }
-
-  constructor(props?: NodeConfig<VerticalAxis, VerticalAxisProps>) {
-    super(props)
-
-    // Composed from plain props (range/markers/label) — no context needed, so
-    // it's built here. super() applied the props, so the reads below resolve.
-    const tickPad = insetsOps.resolve(this.axis.tickPadding).right
-    const titlePad = insetsOps.resolve(this.axis.titlePadding).right
+export const VerticalAxis = component2d({
+  key: "verticalAxis",
+  state: {
+    range: fresh<Range>(() => [0, 1]),
+    markers: fresh<number[]>(() => []),
+    captions: fresh<string[]>(() => []),
+    axis: Types.custom<AxisConfig>(DEFAULT_Y_AXIS),
+    label: "",
+    arrivals: arrivalsEntry(),
+  },
+  // A plain node filled its parent; one made of its markers would hug them.
+  defaults: { width: "fill", height: "fill" },
+  children: (state) => {
+    // Composed from plain entries (range/markers/label), so it's built once here.
+    const tickPad = insetsOps.resolve(state.axis.tickPadding).right
+    const titlePad = insetsOps.resolve(state.axis.titlePadding).right
+
+    const row: Node2D[] = []
+    // The row's parent is the axis: its box is what the markers are placed in.
+    const box = () => (row[0]?.parent as Node2D | null | undefined)?.layoutBounds ?? { width: 0, height: 0 }
+    /** The live tick values, top → bottom (highest first) — re-read every frame. */
+    const sorted = () => [...state.markers].sort((a, b) => b - a)
+    /** Tick `i`'s fraction across the live `range`, 0 at the bottom edge. */
+    const fracAt = (value: number | undefined) => {
+      if (value === undefined) return 0
+      const [min, max] = state.range
+      return max <= min ? 0 : (value - min) / (max - min)
+    }
 
-    this.markerNodes = this.markers.map((_, i) => {
-      const marker: Text = new Text({
-        ...textOps.styleProps(this.axis.labelStyle),
+    // One text node per marker, ordered top → bottom. A slot with no value (the
+    // live list is shorter than the column built for it) renders as empty text
+    // rather than repeating its neighbour.
+    const markers = state.markers.map((_, i) => {
+      const marker: Node2D = new Text({
+        ...textOps.styleProps(state.axis.labelStyle),
         text: () => {
-          const v = this.valueAt(i)
-          return v === undefined ? "" : this.labelFor(v)
+          const value = sorted()[i]
+          return value === undefined ? "" : markerCaption(state, value)
         },
         y: () => {
           // Node2D space is y-up, so the fraction runs from the bottom.
-          const height = this.layoutBounds.height
-          const centred = (this.fracAt(i) - 0.5) * height
+          const height = box().height
+          const centred = (fracAt(sorted()[i]) - 0.5) * height
           // Held inside the axis's top edge — the backstop for a chart whose
           // headroom is smaller than its marker text is tall, which a theme with
           // much larger markers can arrange. Only the top, because what lies
@@ -134,91 +126,69 @@ export class VerticalAxis extends Node2D<VerticalAxisProps> {
           const limit = height / 2 - marker.layoutBounds.height / 2
           return Math.min(centred, limit)
         },
+        opacity: () => arrivalOf(state.arrivals, i).opacity,
+        x: () => arrivalOf(state.arrivals, i).shift,
       })
       return marker
     })
 
     const children: Node2D[] = []
-    if (this.label !== "") {
-      this.labelNode = new Text({
-        ...textOps.styleProps(this.axis.titleStyle),
-        text: this.label,
-      })
+    if (state.label !== "") {
       // Node2D space is y-up and rotation is clockwise, so -90° reads bottom-to-top.
       children.push(
         new RotatedBox({
           angle: -90,
           width: "hug",
           height: "hug",
-          children: this.labelNode,
+          children: new Text({
+            ...textOps.styleProps(state.axis.titleStyle),
+            text: state.label,
+            opacity: () => arrivalOf(state.arrivals, "label").opacity,
+            x: () => arrivalOf(state.arrivals, "label").shift,
+          }),
         })
       )
     }
-    children.push(
-      new Rect({
-        height: "fill",
-        width: "hug",
-        padding: { right: tickPad },
-        children: this.markerNodes,
-      })
-    )
-
-    this.add(new Rect({ flow: "horizontal", gap: titlePad, children }))
-  }
-
-  /**
-   * Primes every marker (and the caption) at its pre-entrance state: shifted
-   * right and transparent. Idempotent, and separate from {@link enter} so the
-   * chart can arm its whole composition before the first frame is drawn.
-   */
-  arm(slide = SLIDE): void {
-    for (const marker of this.markerNodes) marker.set({ opacity: 0, x: slide })
-    this.labelNode?.set({ opacity: 0, x: slide })
-  }
-
-  /**
-   * Stagger the markers in bottom to top, then slide the caption in from the
-   * right after them.
-   *
-   * A {@link Seekable} rather than a generator — see the note on the horizontal
-   * axis's `enter`. The offsets were always static; expressing them as `wait`
-   * inside a generator is what made them reachable only by running it.
-   *
-   * `args.duration` is the **whole** entrance, not one marker's slide: the
-   * stagger and the caption are carved out of it rather than added on top. See
-   * {@link enterBudget} for why that distinction matters here.
-   *
-   * `args.data.stagger` is seconds between successive markers (derived when
-   * omitted); `args.data.slide` is the starting rightward offset in px.
-   */
-  @command()
-  enter(args: CommandArgs<{ stagger?: number; slide?: number }> & { duration: number }): Seekable {
-    const { stagger, slide = SLIDE } = args.data ?? {}
-    const easing = args.easing ?? easeOut()
-    const nodes = this.markerNodes
-    if (nodes.length === 0) return compose([])
-    const { step, per, caption } = enterBudget(
-      args.duration,
-      nodes.length,
-      this.labelNode !== null,
-      stagger
-    )
-
-    this.arm(slide)
-
-    // Bottom marker leads: markerNodes is top → bottom, so walk it in reverse.
-    const markers = nodes.map((node, i) => {
-      const order = nodes.length - 1 - i // bottom-most = 0
-      return at(order * step, node.to({ data: { opacity: 1, x: 0 }, duration: per, easing }))
-    })
-    const lastMarkerEnds = (nodes.length - 1) * step + per
-
-    // Once every marker has landed, the caption slides in from the right.
-    return compose([
-      ...markers,
-      ...(this.labelNode
-        ? [at(lastMarkerEnds, this.labelNode.to({ data: { opacity: 1, x: 0 }, duration: caption, easing }))]
-        : []),
-    ])
-  }
-}
+    children.push(new Rect({ height: "fill", width: "hug", padding: { right: tickPad }, children: markers }))
+    row.push(new Rect({ flow: "horizontal", gap: titlePad, children }))
+    return asParts(row)
+  },
+  commands: {
+    /**
+     * Stagger the markers in bottom to top, then slide the caption in from the
+     * right after them. Its first frame arms them all: shifted right by `slide`
+     * and transparent.
+     *
+     * The timeline's duration is the **whole** entrance, not one marker's slide:
+     * the stagger and the caption are carved out of it rather than added on top.
+     * See {@link enterBudget} for why that distinction matters here.
+     *
+     * `stagger` is seconds between successive markers (derived when omitted);
+     * `slide` is the starting rightward offset in px.
+     */
+    enter: {
+      args: {
+        stagger: Types.custom<number | undefined>(undefined),
+        slide: Types.number(SLIDE),
+      },
+      run: (timeline, state) => {
+        const { stagger, slide } = timeline.args
+        const count = state.markers.length
+        const captioned = state.label !== ""
+        const from: Arrival = { opacity: 0, shift: slide }
+        const keys = [...state.markers.keys(), ...(captioned ? ["label"] : [])]
+        const arm = timeline.animate(() => ({ arrivals: armed(keys, from) }))
+        if (count === 0) return arm
+        const { step, per, caption } = enterBudget(timeline.duration, count, captioned, stagger)
+        const ease = frameEase(timeline)
+        // Bottom marker leads: the column is top → bottom, so walk it in reverse.
+        const markers = state.markers.map((_, i) => ({ at: (count - 1 - i) * step, duration: per, piece: arrival(timeline, i, from, ease) }))
+        // Once every marker has landed, the caption slides in from the right.
+        const label = captioned ? [{ at: (count - 1) * step + per, duration: caption, piece: arrival(timeline, "label", from, ease) }] : []
+        return timeline.together([arm, beats(timeline, [...markers, ...label])])
+      },
+    },
+  },
+})
+
+export type VerticalAxis = NodeOf<typeof VerticalAxis>