@motionscript/charts 0.1.0 → 0.1.1-alpha.1

package/src/line-chart/chart-line.ts

@@ -1,103 +1,98 @@
 import {
   Graphics2D,
   Types,
+  clamp,
   component2d,
+  fillOps,
   strokeOps,
+  type Fill,
+  type FillResolved,
   type NodeOf,
-  // Named so this component's emitted type reaches `Node2D` through the sdk, not core.
+  // Named so this component's emitted type reaches `Node2D` and its props through the sdk, not core.
   type Node2D as _Node2D,
+  type Node2DProps as _Node2DProps,
+  type PathCommand,
+  type RenderContext,
   type Stroke,
   type StrokeResolved,
   type Vector2,
 } from "@motionscript/sdk"
 
+import { fade } from "../kit/cartesian"
 import { fresh } from "../kit/entries"
 import { frameEase } from "../kit/motion"
 import { loadPaints } from "../kit/paints"
 import { SPOTLIGHT_DIM } from "../kit/shared"
 import {
   EMPTY_REGION_BOX,
+  clipPolygonToBox,
   clipPolylineToBox,
+  cutAt,
+  curvePoints,
   hasRegion,
+  type LineCurve,
   type RegionBox,
 } from "./shared"
 
-/**
- * The prefix of `pts` revealed at fraction `p ∈ [0, 1]`, measuring the reveal
- * by *cumulative arc length* so the line traces at a steady pace regardless of
- * uneven point spacing. Returns the whole-point prefix plus one interpolated
- * point partway along the active segment.
- */
-function tracePoints(pts: Vector2[], p: number): Vector2[] {
-  if (p >= 1 || pts.length < 2) return pts
-  if (p <= 0) return []
-
-  const segLen: number[] = []
-  let total = 0
-  for (let i = 1; i < pts.length; i++) {
-    const d = Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y)
-    segLen.push(d)
-    total += d
-  }
-  if (total === 0) return pts
-
-  let target = total * p
-  const out: Vector2[] = [pts[0]]
-  for (let i = 0; i < segLen.length; i++) {
-    if (target >= segLen[i]) {
-      out.push(pts[i + 1])
-      target -= segLen[i]
-    } else {
-      const t = segLen[i] === 0 ? 0 : target / segLen[i]
-      out.push({
-        x: pts[i].x + (pts[i + 1].x - pts[i].x) * t,
-        y: pts[i].y + (pts[i + 1].y - pts[i].y) * t,
-      })
-      break
-    }
-  }
-  return out
+/** The x a trace at `progress` has reached, across `points` ordered along x. */
+export function traceX(points: readonly Vector2[], progress: number): number {
+  if (points.length === 0) return 0
+  const first = points[0].x
+  const last = points[points.length - 1].x
+  return progress >= 1 ? Infinity : first + (last - first) * progress
+}
+
+/** The drawn path at `progress`: the whole curve once traced, else the part left of the trace. */
+function traced(points: readonly Vector2[], curve: LineCurve, progress: number): Vector2[] {
+  const path = curvePoints(points, curve)
+  return progress >= 1 ? path : cutAt(path, traceX(points, progress))
+}
+
+const curveEntry = () => Types.custom<LineCurve>("smooth")
+
+/** A closed outline as path commands. */
+function outlineCommands(points: readonly Vector2[]): PathCommand[] {
+  return [...points.map((p, i): PathCommand => ({ type: i === 0 ? "M" : "L", x: p.x, y: p.y })), { type: "Z" }]
+}
+
+function fillOutline(ctx: RenderContext, outline: readonly Vector2[], fill: FillResolved[], opacity: number): void {
+  if (outline.length < 3 || opacity <= 0) return
+  const { width, height } = ctx.size
+  // A frame symmetric about the origin, so the outline draws where its points say rather than re-centred on itself.
+  const centerBounds: [number, number, number, number] = [-width / 2, -height / 2, width / 2, height / 2]
+  ctx.draw(new Graphics2D().path({ data: outlineCommands(outline), centerBounds }).fill(fill).opacity(opacity))
 }
 
 /**
- * A single series line of a {@link LineChart}: one rounded polyline traced
- * through pre-mapped pixel `points`, drawn as one {@link Graphics2D} command list.
- * Sized and positioned by the parent, which shares the plot's coordinate frame.
- *
- * Two signals drive it: `progress` traces the line in
- * (animated by `enter`) and `enabled` shows or hides it wholesale.
+ * One series of a {@link LineChart}: its line through pre-mapped pixel `points`,
+ * shaped by `curve`, and a dot on each point. `progress` traces it in from the
+ * left; `enabled` shows or hides it wholesale.
  */
 export const ChartLine = component2d({
   key: "chartLine",
   state: {
-    /** The series polyline, already mapped into this node's local pixel space (origin at centre, y-up) by the parent {@link LineChart}. Ordered along x. */
+    /** In this node's pixel space (origin at centre, y-up), mapped by the parent and ordered along x. */
     points: fresh<Vector2[]>(() => []),
-    /** Line colour + weight (+ optional dash/cap/join) — the per-series stroke. */
+    curve: curveEntry(),
     stroke: Types.custom<Stroke, StrokeResolved[]>([], { resolve: strokeOps.resolve, lerp: strokeOps.lerp }),
-    /**
-     * Reveal of the line in `[0, 1]`: 0 hides it, 1 traces it fully from its left
-     * end to its right. Defaults to 1, so the paused editor canvas paints the line;
-     * `enter` drives it from 0 regardless of where it rests.
-     */
+    /** A dot of `dotSize` on each point, in `dotFill`; none at size 0. */
+    dotSize: 0,
+    dotFill: Types.custom<Fill, FillResolved[]>([], { resolve: fillOps.resolve, lerp: fillOps.lerp }),
+    /** Trace from the left end, `[0, 1]`. Rests at 1 so a paused editor canvas paints the line; `enter` drives it from 0. */
     progress: 1,
-    /** Whether this line is drawn at all: the switch the chart flips alongside its legend's per-series toggle. */
+    /** Whether the line is drawn at all, flipped alongside its legend entry. */
     enabled: true,
-    /** A slice of the plot to spotlight, in this node's own pixel space: outside it the line drops to `dimOpacity`. */
+    /** In this node's pixel space; outside it the line drops to `dimOpacity`. */
     spotlight: fresh<RegionBox>(() => EMPTY_REGION_BOX),
-    /** Opacity the out-of-region stretches fade to. */
     dimOpacity: SPOTLIGHT_DIM,
   },
-  load: (loader, state) => loadPaints(loader, { strokes: [state.stroke] }),
+  load: (loader, state) => loadPaints(loader, { fills: [state.dotFill], strokes: [state.stroke] }),
   commands: {
     /**
-     * Trace the line from `from` to `to` over the command — by default in from
-     * its left end to its right. `showSeries` and `hideSeries` are the same
-     * motion in opposite directions, so both are this with their ends stated.
-     *
-     * `enabled` rides along in the same value rather than being set before or
-     * after the command: a line is drawable for every `t` the trace covers and
-     * undrawn outside it, which is what makes arriving at a time backwards show
-     * what arriving forwards does.
+     * Trace the line from `from` to `to`; `showSeries`/`hideSeries` are this with
+     * the ends stated. `enabled` rides along in the same value, so the line is
+     * drawable for every `t` the trace covers and arriving backwards matches
+     * arriving forwards.
      */
     enter: {
       args: { from: Types.number(0, { min: 0, max: 1 }), to: Types.number(1, { min: 0, max: 1 }) },
@@ -106,51 +101,150 @@ export const ChartLine = component2d({
         const ease = frameEase(timeline)
         return timeline.animate((t) => {
           const progress = from + (to - from) * ease(t)
-          // Hidden only once it has fully retraced, so the last frame of a hide is
-          // the empty plot rather than a line that vanished a frame early.
+          // Hidden only once fully retraced, so a hide does not vanish a frame early.
           return { progress, enabled: progress > 0 }
         })
       },
     },
+    /** Hold the line fully traced while its chart moves it, switched on throughout a show and off once a hide lands. */
+    hold: {
+      args: { shown: Types.boolean(true) },
+      run: (timeline) => {
+        const { shown } = timeline.args
+        return timeline.animate((t) => ({ progress: 1, enabled: shown || t < 1 }), { eased: false })
+      },
+    },
   },
   render: (ctx, state) => {
     if (!state.enabled) return
     const pts = state.points
-    if (pts.length < 2) return
+    const p = clamp(state.progress, 0, 1)
+    if (pts.length === 0 || p <= 0) return
 
-    const p = Math.max(0, Math.min(1, state.progress))
-    if (p <= 0) return
-
-    const drawn = tracePoints(pts, p)
-    if (drawn.length < 2) return
+    const box = state.spotlight
+    const lit = hasRegion(box)
+    const dim = clamp(state.dimOpacity, 0, 1)
     const stroke = state.stroke
-    const radius = (stroke[0]?.weight ?? 0) * 2 // round the joins
+    const weight = stroke[0]?.weight ?? 0
+    const drawn = traced(pts, state.curve, p)
 
-    const box = state.spotlight
-    if (!hasRegion(box)) {
-      ctx.draw(new Graphics2D().line({ points: drawn, radius }).stroke(stroke))
-      return
+    if (drawn.length >= 2 && weight > 0) {
+      // Rounded corners only where the line has corners to round.
+      const radius = state.curve === "linear" ? weight * 2 : 0
+      ctx.draw(new Graphics2D().line({ points: drawn, radius }).stroke(stroke).opacity(lit ? dim : 1))
+      // One `draw` per run: shapes chained before `stroke()` combine into one surface, and stroking a union of disjoint open paths paints nothing.
+      if (lit) for (const run of clipPolylineToBox(drawn, box)) ctx.draw(new Graphics2D().line({ points: run, radius }).stroke(stroke))
     }
 
-    // Spotlit: the whole line goes down to `dimOpacity`, then the stretches
-    // inside the region are re-drawn over it at full strength. Two passes rather
-    // than one dim + one bright *complementary* pair, so the bright run has
-    // continuous geometry through the region and its joins round the way an
-    // unspotlit line's do — and so the boundary lands exactly on the region edge.
-    ctx.draw(
-      new Graphics2D()
-        .line({ points: drawn, radius })
-        .stroke(stroke)
-        .opacity(Math.max(0, Math.min(1, state.dimOpacity)))
-    )
-
-    // One `draw` per run: shapes chained before a `stroke()` are combined into a
-    // single surface, and stroking a union of disjoint open paths doesn't paint
-    // — so a line that leaves the region and comes back would lose both halves.
-    for (const run of clipPolylineToBox(drawn, box)) {
-      ctx.draw(new Graphics2D().line({ points: run, radius }).stroke(stroke))
+    const size = state.dotSize
+    if (size <= 0) return
+    const reach = traceX(pts, p)
+    const bright = new Graphics2D()
+    const dimmed = new Graphics2D()
+    let brightAny = false
+    let dimAny = false
+    for (const pt of pts) {
+      // A dot grows in as the trace passes it.
+      const grown = reach === Infinity ? 1 : clamp((reach - pt.x) / (size * 2), 0, 1)
+      if (grown <= 0) continue
+      const inside = !lit || (pt.x >= box.left && pt.x <= box.right && pt.y >= box.bottom && pt.y <= box.top)
+      ;(inside ? bright : dimmed).ellipse({ x: pt.x, y: pt.y, width: size * grown, height: size * grown })
+      if (inside) brightAny = true
+      else dimAny = true
     }
+    if (dimAny) ctx.draw(dimmed.fill(state.dotFill).opacity(dim))
+    if (brightAny) ctx.draw(bright.fill(state.dotFill))
   },
 })
 
 export type ChartLine = NodeOf<typeof ChartLine>
+
+/**
+ * The fill under one series of a {@link LineChart}: down to `base` (the series
+ * below it in a stack) or, without one, to the `baseline`. Drawn by its own node
+ * so every area sits under every line; the chart binds its trace, switch and
+ * opacity to its line's, so the two move as one.
+ */
+export const ChartArea = component2d({
+  key: "chartArea",
+  state: {
+    /** The series' points, as its line has them. */
+    points: fresh<Vector2[]>(() => []),
+    /** The line the area fills down to, at the same x positions; empty for the baseline. */
+    base: fresh<Vector2[]>(() => []),
+    /** Pixel y of the baseline. */
+    baseline: 0,
+    curve: curveEntry(),
+    area: Types.custom<"none" | "solid" | "gradient">("solid"),
+    /** The series colour; the area paints it at `areaOpacity`, a gradient fading it out towards the bottom. */
+    fill: Types.custom<Fill, FillResolved[]>([], { resolve: fillOps.resolve, lerp: fillOps.lerp }),
+    areaOpacity: 0.4,
+    progress: 1,
+    enabled: true,
+    spotlight: fresh<RegionBox>(() => EMPTY_REGION_BOX),
+    dimOpacity: SPOTLIGHT_DIM,
+  },
+  load: (loader, state) => loadPaints(loader, { fills: [state.fill] }),
+  render: (ctx, state) => {
+    const pts = state.points
+    const p = clamp(state.progress, 0, 1)
+    if (!state.enabled || state.area === "none" || pts.length < 2 || p <= 0 || state.fill.length === 0) return
+    const outlineAt = (progress: number) => {
+      const top = traced(pts, state.curve, progress)
+      if (top.length < 2) return []
+      const base = state.base.length === pts.length
+        ? traced(state.base, state.curve, progress)
+        : [{ x: top[0].x, y: state.baseline }, { x: top[top.length - 1].x, y: state.baseline }]
+      return [...top, ...[...base].reverse()]
+    }
+    // The gradient spans the whole area's height, so it holds still while the area traces in and across a spotlight's cut.
+    const span = verticalSpan(outlineAt(1))
+    const paint = (outline: readonly Vector2[], opacity: number) =>
+      fillOutline(ctx, outline, areaFill(state.fill, state.area, state.areaOpacity, span, verticalSpan(outline)), opacity)
+    const outline = outlineAt(p)
+    const box = state.spotlight
+    if (!hasRegion(box)) {
+      paint(outline, 1)
+      return
+    }
+    paint(outline, clamp(state.dimOpacity, 0, 1))
+    paint(clipPolygonToBox(outline, box), 1)
+  },
+})
+
+interface Span {
+  readonly top: number
+  readonly bottom: number
+}
+
+function verticalSpan(points: readonly Vector2[]): Span {
+  let top = -Infinity
+  let bottom = Infinity
+  for (const p of points) {
+    if (p.y > top) top = p.y
+    if (p.y < bottom) bottom = p.y
+  }
+  return { top, bottom }
+}
+
+/**
+ * The area's paint for an outline spanning `own`: the series colour at
+ * `opacity`, or for a gradient that colour fading to nearly nothing across
+ * `whole`. A gradient maps onto the bounds of the shape it fills, so its ends
+ * are placed in `own`'s unit box (y-up) at `whole`'s top and bottom.
+ */
+export function areaFill(colour: FillResolved[], area: "none" | "solid" | "gradient", opacity: number, whole: Span, own: Span): FillResolved[] {
+  const top = colour[colour.length - 1]
+  if (area !== "gradient" || top?.type !== "solid" || !(own.top > own.bottom)) return fade(colour, opacity) as FillResolved[]
+  const [r, g, b, a] = top.color
+  const middle = (own.top + own.bottom) / 2
+  const half = (own.top - own.bottom) / 2
+  return fillOps.resolve({
+    type: "linear-gradient",
+    colors: [[r, g, b, a * opacity], [r, g, b, a * opacity * 0.04]],
+    start: { x: 0, y: (whole.top - middle) / half },
+    end: { x: 0, y: (whole.bottom - middle) / half },
+  })
+}
+
+export type ChartArea = NodeOf<typeof ChartArea>

package/src/line-chart/chart-region.ts

@@ -7,45 +7,37 @@ import {
   type Fill,
   type FillResolved,
   type NodeOf,
-  // Named so this component's emitted type reaches `Node2D` through the sdk, not core.
+  // Named so this component's emitted type reaches `Node2D` and its props through the sdk, not core.
   type Node2D as _Node2D,
+  type Node2DProps as _Node2DProps,
   type Stroke,
   type StrokeResolved,
 } from "@motionscript/sdk"
 
+import { rule } from "../kit/chart-canvas"
 import { fresh } from "../kit/entries"
 import { loadPaints } from "../kit/paints"
 import {
-  DEFAULT_CHART_THEME,
   EMPTY_REGION_BOX,
   hasRegion,
   type RegionBox,
 } from "./shared"
 
 /**
- * The **region call-out** of a {@link LineChart}: a washed rectangle over the
- * plot with a dashed rule down each edge the author actually bounded. Sized and
- * positioned entirely from the pre-mapped `box` rather
- * than its own box — the region already carries the plot geometry.
- *
- * It draws only the *marking*; fading the series outside the region is
- * {@link ChartLine}'s job (it clips its own polyline against the same box), so
- * the two can't disagree about where the boundary is.
- *
- * Only bounded edges get a rule: a region given just an `x` range spans the full
- * plot height, so its top and bottom edges are the plot's own border, not a data
- * bound — drawing dashes there would assert a limit the author didn't set.
+ * The call-out of a {@link LineChart}: a washed rectangle with a dashed rule on
+ * each bounded edge, drawn from the pre-mapped `box`. Dimming the series outside
+ * is the line's and area's job, clipped against the same box so they agree on
+ * the boundary. An unbounded edge is the plot's own border, and a rule there
+ * would assert a limit the author did not set.
  */
 export const ChartRegion = component2d({
   key: "chartRegion",
   state: {
-    /** The highlighted slice, already resolved into this node's local pixel space (origin at centre, y-up) by the parent {@link LineChart}. A degenerate box draws nothing. */
+    /** In this node's pixel space (origin at centre, y-up), mapped by the parent. A degenerate box draws nothing. */
     box: fresh<RegionBox>(() => EMPTY_REGION_BOX),
-    /** Dashed rule marking each *bounded* edge of the box. */
-    stroke: Types.custom<Stroke, StrokeResolved[]>(DEFAULT_CHART_THEME.region.stroke, { resolve: strokeOps.resolve, lerp: strokeOps.lerp }),
-    /** Wash filling the box, under the series lines. */
-    fill: Types.custom<Fill, FillResolved[]>(DEFAULT_CHART_THEME.region.fill, { resolve: fillOps.resolve, lerp: fillOps.lerp }),
-    /** Reveal of the annotation in `[0, 1]`, driven by the chart's own `regionReveal` so the rules and the series' dimming move as one. */
+    stroke: Types.custom<Stroke, StrokeResolved[]>({ weight: 2, fill: "white/70", dash: [14, 12], cap: "butt", align: "center" }, { resolve: strokeOps.resolve, lerp: strokeOps.lerp }),
+    fill: Types.custom<Fill, FillResolved[]>("white/6", { resolve: fillOps.resolve, lerp: fillOps.lerp }),
+    /** Driven by the chart's `regionReveal`, so the rules and the series' dimming move as one. */
     reveal: 0,
   },
   load: (loader, state) => loadPaints(loader, { fills: [state.fill], strokes: [state.stroke] }),
@@ -61,28 +53,19 @@ export const ChartRegion = component2d({
     const cx = (box.left + box.right) / 2
     const cy = (box.bottom + box.top) / 2
 
-    // Wash first, so the rules sit over their own tint.
     if (state.fill.length > 0) {
       ctx.draw(new Graphics2D().rect({ x: cx, y: cy, width, height }).fill(state.fill).opacity(r))
     }
 
-    // One rule per bounded edge, growing from the region's centre outward as
-    // `reveal` climbs — the same "trace it in" beat as the series lines.
     if (state.stroke.length === 0) return
 
-    // One `draw` per rule rather than four line ops under a single paint:
-    // shapes chained before a `stroke()` are combined into one surface, and
-    // stroking a union of disjoint open paths doesn't paint.
-    const rule = (points: { x: number; y: number }[]) =>
-      ctx.draw(new Graphics2D().line({ points }).stroke(state.stroke).opacity(r))
-
     if (box.xBounded) {
       const half = (height / 2) * r
-      for (const x of [box.left, box.right]) rule([{ x, y: cy - half }, { x, y: cy + half }])
+      for (const x of [box.left, box.right]) rule(ctx, { x, y: cy - half }, { x, y: cy + half }, state.stroke, r)
     }
     if (box.yBounded) {
       const half = (width / 2) * r
-      for (const y of [box.bottom, box.top]) rule([{ x: cx - half, y }, { x: cx + half, y }])
+      for (const y of [box.bottom, box.top]) rule(ctx, { x: cx - half, y }, { x: cx + half, y }, state.stroke, r)
     }
   },
 })

package/src/line-chart/index.ts

@@ -1,39 +1,31 @@
-/**
- * The line chart: a cartesian plot with a traced polyline, spotlit regions and
- * a staggered entrance.
- *
- * {@link LineChart} composes the parts below plus the shared ones in the kit
- * (the plot panel, the value axis, the legend); each part is exported too, so
- * another node type can reuse one on its own.
- *
- * These files are what a copy of the line chart takes (`registry.json`). Everything they reach for
- * that is *not* here comes from the kit and stays a dependency — see
- * `../engine.ts` for why that line is where it is.
- */
 export { LineChart, lineChartDomains } from "./line-chart"
-export type { LineChartDomains, LineChartProps, LineChartValues } from "./line-chart"
+export type { LineChartDomains, LineChartStyle, LineChartValues } from "./line-chart"
 export { ChartRegion } from "./chart-region"
-export { ChartLine } from "./chart-line"
-export { HorizontalAxis } from "./horizontal-axis"
+export { ChartArea, ChartLine, areaFill, traceX } from "./chart-line"
 export {
-  DEFAULT_CHART_THEME,
   EMPTY_REGION_BOX,
+  LINE_LABELS,
+  LINE_MARKS,
+  clipPolygonToBox,
   clipPolylineToBox,
+  curvePoints,
+  cutAt,
   hasRegion,
-  lerpChartTheme,
-  resolveChartTheme,
+
   resolveRegionBox,
   resolveYScale,
   seriesPoints,
+  stackExtent,
+  stackSeries,
   yExtent,
 } from "./shared"
 export type {
-  ChartConfig,
-  ChartTheme,
+  LineCurve,
   LineSeries,
+  LineStack,
   PlotRegion,
   RegionBox,
-  RegionConfig,
+  StackedSeries,
 } from "./shared"
-export { formatInstant, parseInstant, resolveXScale } from "./x-scale"
+export { EVERY_SAMPLE, formatInstant, parseInstant, resolveXScale } from "./x-scale"
 export type { XScale, XScaleKind } from "./x-scale"