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

package/src/line-chart/shared.ts

@@ -5,14 +5,14 @@
  *
  * Everything a bar or a pie chart would want too — what a series is, how an axis
  * is scaled and formatted, the theme leaf resolvers, the legend and plot-panel
- * branches — lives in `nodes/chart-kit/shared.ts` and is imported here. What's
+ * branches — lives in `../kit/shared.ts` and is imported here. What's
  * left below is what only a line chart has: points sorted along an x column,
  * a region clipped out of a polyline, and the `region` branch of the theme.
  *
  * Kept renderer-agnostic (no `Node` imports) so every part shares one
- * scale/format/palette/theme vocabulary, and so the studio's own inspector
- * mapping (`line-chart-props.ts`) can build a partial {@link ChartTheme} without
- * pulling the node classes in.
+ * scale/format/palette/theme vocabulary, and so a host's own inspector
+ * mapping can build a partial {@link ChartTheme} without
+ * pulling the components in.
  */
 
 import {
@@ -25,7 +25,7 @@ import {
   type FillResolved,
   type Stroke,
   type StrokeResolved,
-} from "@motionscript/core"
+} from "@motionscript/sdk"
 
 import {
   CHART_PALETTE,
@@ -365,7 +365,7 @@ function lerpRegionConfig(
 }
 
 /**
- * {@link LineChart}'s `theme` @property mapper: merges the author's partial
+ * {@link LineChart}'s `theme` entry's resolve: merges the author's partial
  * {@link ChartTheme} onto `previous` (falling back to
  * {@link DEFAULT_CHART_THEME} on first resolution), fully resolving every leaf.
  */
@@ -384,7 +384,7 @@ export function resolveChartTheme(
   }
 }
 
-/** {@link LineChart}'s `theme` @property tween — leaf by leaf. */
+/** {@link LineChart}'s `theme` entry's lerp — leaf by leaf. */
 export function lerpChartTheme(
   from: ChartConfig,
   to: ChartConfig,
@@ -454,6 +454,20 @@ export function resolveYScale(
   if (range) return range
   const [lo, hi] = yExtent(data, series)
   const segments = Math.max(1, Math.round(divisions))
-  const step = niceStep((hi - lo) / segments || 1)
+  if (hi === lo) return constantScale(lo, segments)
+  const step = niceStep((hi - lo) / segments)
   return [Math.floor(lo / step) * step, Math.ceil(hi / step) * step]
 }
+
+/**
+ * The scale for data that never moves. A zero-width scale puts every tick on the
+ * same value and the line on the plot's floor, so it is widened to a few steps
+ * either side of the value (the step sized to its magnitude, so `5` gets
+ * `[3, 7]` and `5000` gets `[3000, 7000]`), or to `[0, 1]` for all zeros, as for
+ * no data at all.
+ */
+function constantScale(value: number, segments: number): Range {
+  if (value === 0) return [0, 1]
+  const step = niceStep(Math.abs(value) / segments)
+  return [value - step, value + step]
+}

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

@@ -26,7 +26,7 @@
  * and that is the one case {@link formatInstant} covers.
  */
 
-import type { DataRecord } from "@motionscript/core"
+import type { DataRecord } from "@motionscript/sdk"
 
 import {
   formatMarker,
@@ -35,7 +35,7 @@ import {
   text,
   type Range,
 } from "../kit/shared"
-import { formatNumber } from "@motionscript/core/component"
+import { formatNumber } from "@motionscript/sdk/component"
 
 /** How an x column's cells become positions along the axis. */
 export type XScaleKind = "numeric" | "time" | "ordinal"
@@ -304,15 +304,30 @@ function labelBySample(
   return i >= 0 ? captions[i] : fallback(value)
 }
 
+/** Scales already resolved, by data array, then by field and pattern. */
+const scales = new WeakMap<DataRecord[], Map<string, XScale>>()
+
 /**
  * How `field` positions the rows: the number it holds, the instant it names, or
  * failing both, the row's own place in the file.
  *
- * Resolved from the data on every read rather than cached on the node: it is
- * cheap (one pass to classify, one to position), and a cache keyed on a `data`
- * array that `buildScene` rebuilds on every edit would miss every time anyway.
+ * Kept per `data` array: a chart's bound props ask a dozen times a frame, and
+ * parsing every row's instant each time was most of a frame.
  */
 export function resolveXScale(
+  data: DataRecord[],
+  field: string,
+  pattern?: string
+): XScale {
+  let byKey = scales.get(data)
+  if (!byKey) scales.set(data, (byKey = new Map()))
+  const key = JSON.stringify([field, pattern ?? null])
+  let scale = byKey.get(key)
+  if (!scale) byKey.set(key, (scale = xScaleOf(data, field, pattern)))
+  return scale
+}
+
+function xScaleOf(
   data: DataRecord[],
   field: string,
   /**

package/src/nodes.ts

@@ -6,15 +6,13 @@ import { PieChart } from "./pie-chart";
  * Every node type this package publishes.
  *
  * A host registers these by handing the array to an engine —
- * `new Engine(platform, { nodes: NODES })` — which reads each class's `@node()`
- * key. The decorator only *declares* that key: nothing is registered by the mere
- * act of importing a module, so a registry holds exactly what its owner asked
- * for and two engines in one process can differ about it.
+ * `new Engine(platform, { nodes: NODES })` — which reads each component's key.
+ * Defining a component only *declares* that key: nothing is registered by
+ * importing a module, so a registry holds exactly what its owner asked for.
  *
- * Listing class **values** is also what survives bundling. This package declares
- * `sideEffects: false`, which licenses a bundler to drop a module nothing
- * imports a value from, and a document names a node type by string — so
- * `import "./line-chart"` for its side effect is exactly what gets shaken out, where an
- * array of bindings is a data dependency that cannot be.
+ * Listing the component **values** is also what survives bundling: this package
+ * declares `sideEffects: false`, and a document names a node type by string, so
+ * an import kept only for its side effect is exactly what gets shaken out.
  */
-export const NODES = [LineChart, BarChart, PieChart];
+// Typed by name, so the declaration names each component rather than spelling out its type through core.
+export const NODES: (typeof LineChart | typeof BarChart | typeof PieChart)[] = [LineChart, BarChart, PieChart];

package/src/pie-chart/index.ts

@@ -7,8 +7,8 @@
  * pie; it defaults to a donut, because the hole is the only place a chart has
  * to put its conclusion.
  */
-export { PieChart } from "./pie-chart"
-export type { PieChartProps } from "./pie-chart"
+export { PieChart, isSliceSelected } from "./pie-chart"
+export type { PieChartProps, PieChartValues } from "./pie-chart"
 export { PieRing } from "./pie-ring"
 export type { PieRingProps } from "./pie-ring"
 export { PieLegend } from "./pie-legend"