@sophistry/charts 0.0.0-stage → 0.0.1

package/dist/math/index.js

@@ -0,0 +1,3 @@
+import { $ as e, $t as t, A as n, An as r, At as i, B as a, Bn as o, Bt as s, C as c, Cn as l, Ct as u, D as d, Dn as f, Dt as p, E as m, En as h, Et as g, F as _, Fn as v, Ft as y, G as b, Gn as x, Gt as S, H as C, Hn as w, Ht as T, I as E, In as D, It as O, J as k, Jt as A, K as j, Kn as M, Kt as N, L as P, Ln as F, Lt as I, M as L, Mn as R, Mt as z, N as B, Nn as V, Nt as H, O as U, On as W, Ot as G, P as K, Pn as q, Pt as J, Q as Y, Qt as X, R as Z, Rn as Q, Rt as $, S as ee, Sn as te, St as ne, T as re, Tn as ie, Tt as ae, U as oe, Un as se, Ut as ce, V as le, Vn as ue, Vt as de, W as fe, Wn as pe, Wt as me, X as he, Xt as ge, Y as _e, Yt as ve, Z as ye, Zt as be, _ as xe, _n as Se, _t as Ce, a as we, an as Te, at as Ee, b as De, bn as Oe, bt as ke, c as Ae, cn as je, ct as Me, d as Ne, dn as Pe, dt as Fe, en as Ie, et as Le, f as Re, fn as ze, ft as Be, g as Ve, gn as He, gt as Ue, h as We, hn as Ge, ht as Ke, i as qe, in as Je, it as Ye, j as Xe, jn as Ze, jt as Qe, k as $e, kn as et, kt as tt, l as nt, ln as rt, lt as it, m as at, mn as ot, mt as st, n as ct, nn as lt, nt as ut, o as dt, on as ft, ot as pt, p as mt, pn as ht, pt as gt, q as _t, qt as vt, r as yt, rn as bt, rt as xt, s as St, sn as Ct, st as wt, t as Tt, tn as Et, tt as Dt, u as Ot, un as kt, ut as At, v as jt, vn as Mt, vt as Nt, w as Pt, wn as Ft, wt as It, x as Lt, xn as Rt, xt as zt, y as Bt, yn as Vt, yt as Ht, z as Ut, zn as Wt, zt as Gt } from "../math-CSHNpGej.js";
+import { a as Kt, i as qt, n as Jt, o as Yt, r as Xt, s as Zt, t as Qt } from "../voxels-9lJ2TZS4.js";
+export { Ht as DECIMATION_MIN_PER_COLUMN, He as DEFAULT_BAR_WIDTH, lt as DEFAULT_BIN_COUNT, p as DEFAULT_ECDF_PAD_FALLBACK, G as DEFAULT_ECDF_PAD_FRACTION, i as DEFAULT_SAMPLES, Qe as DEFAULT_VIOLIN_SCALE, B as DEFAULT_WHISKER_SCALE, jt as GAUGE_END_ANGLE, Bt as GAUGE_START_ANGLE, kt as INSIDE_LABEL_FADE, f as SYMBOLS, Ze as alignedRange, yt as assertRadarShape, R as autoRange, Zt as bar3dSlots, Pe as barLabelValues, Se as barSlot, Ce as barbGlyph, Te as beeswarmOffsets, Je as binIndex, z as blendViolinProfiles, K as boxplotStats, _t as breadcrumbLayout, ie as bubbleLegendValues, h as bubbleRadiusScale, N as bulletDomain, vt as bulletRow, n as chordLayout, Xe as chordRibbon, Mt as clipPolylineToX, Vt as clipRingToX, pt as clusterRows, st as contourBands, Ke as contourLines, Ue as dataExtent, ke as dataRuns, ue as datumKeys, ze as decimalsOf, zt as decimateRun, wt as distanceMatrix, ft as dodgeSpan, tt as ecdfSteps, $e as errorBarPoints, U as eventPlotRows, Pt as facetGrid, re as facetSlots, It as fillBetweenCurve, ae as fillBetweenRings, V as fitRange, k as flattenPathSpec, De as gaugeAngle, Lt as gaugeBandIndex, ee as gaugeBands, c as gaugeFraction, H as gaussianKde, xt as gridNcols, Ee as hexbin, le as hierarchyJoin, C as hierarchyKeys, At as hierarchyTreeLayout, Ye as histogram2d, bt as histogramBins, Dt as imshowCells, ht as insideLabelFit, ne as isNonDecreasingX, _e as isPathTransition, Et as jitterOffsets, q as joinStages, v as keyWindow, D as keyedJoin, ce as keyframeAt, Z as largestRemainder, Me as leafOrder, et as legendLayout, it as linkageTree, ge as loess, be as loessBand, X as meanInterval, ot as mixBarLabelValues, I as morphArea, $ as morphAreaRuns, Gt as morphPolyline, s as morphRuns, de as morphSteps, a as mosaicLayout, Ct as normalizeValues, w as observable10, se as okabeIto, pe as ordinalColorScale, m as outerEdge, oe as packLayout, d as panelProgress, Ve as parallelAxisX, xe as parallelLines, fe as partitionLayout, ut as pcolormeshCells, nt as pieGrow, Ot as pieSlices, Ne as pieSweep, Ae as polarAreaSlices, Yt as quiverVectors, me as raceTimeline, qe as radarAxisFrames, we as radarFramePolygon, dt as radarLabelOffset, St as radarVertices, Fe as radialTreeLink, Be as radialTreePoint, je as reduceValues, t as regression, F as rescaleKind, Q as rescaleWindow, L as resolvePolarSweep, Oe as revealClipAlongX, Rt as revealCutoff, te as revealPolylinesAlongX, l as revealRingsAlongX, Re as ringLayout, mt as ringOrder, rt as rollingValues, he as samePath, u as sameRuns, E as sankeyLayout, P as sankeyRibbon, ct as scatterPoints, Kt as scatterPoints3, r as sizeLegendLayout, A as stackColumns, ve as stackOrder, Ge as stackTotals, Nt as stackedBands, Wt as stageProgress, o as staggeredStageProgress, g as stairsPolyline, Tt as stemPoints, qt as stemPoints3, Ie as studentT, Jt as surfaceGridFaces, Xt as surfaceGridWireframe, at as sweepShare, We as sweepWedge, W as symbolPolygon, x as tableau10, S as trailPolyline, gt as treeLink, b as treemapLayout, j as treemapRows, ye as triangulate, Y as tricontourBands, e as tricontourLines, Le as tripcolorFaces, _ as trisurfaceFaces, M as uniqueKeys, J as violinProfile, y as violinProfileRing, O as violinRing, Qt as voxelFaces, Ut as waffleCells, T as waterfallSteps, Ft as xExtent };

package/dist/math/jitter.d.ts

@@ -0,0 +1,17 @@
+/** Seeded jitter: offsets that are a pure function of a key and a seed, so they stay put across frames and when scrubbed. */
+/** @category Math */
+export interface JitterOptions {
+    /** Total width the offsets spread over, centred on 0. @default 1 */
+    width?: number;
+    /** Varies the pattern. @default 0 */
+    seed?: number;
+}
+/**
+ * One offset in `[-width / 2, width / 2)` per key. Key by something stable
+ * (an id) and a datum keeps its offset as others come and go.
+ *
+ * @returns Offsets parallel to `keys`.
+ * @category Math & helpers
+ */
+export declare function jitterOffsets(keys: readonly (string | number)[], options?: JitterOptions): number[];
+//# sourceMappingURL=jitter.d.ts.map

package/dist/math/jitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jitter.d.ts","sourceRoot":"","sources":["../../src/math/jitter.ts"],"names":[],"mappings":"AAAA,6HAA6H;AAI7H,qBAAqB;AACrB,MAAM,WAAW,aAAa;IAC7B,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC5B,IAAI,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAClC,OAAO,GAAE,aAAkB,GACzB,MAAM,EAAE,CAIV"}

package/dist/math/join.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Keyed data transitions: which marks enter, update and exit between two
+ * datasets, and how one blend `t` splits into stages. Pure, so a transition
+ * is a function of `t` and scrubs backwards exactly as it plays.
+ */
+import type { BandKey, Range } from "@sophistry/core/geometry";
+/**
+ * Which keys of a keyed join are in which dataset.
+ *
+ * @category Math & helpers
+ */
+export interface KeyedJoin {
+    /** Every key once: `from`'s in order, then the keys only `to` has, in `to`'s order. */
+    readonly keys: readonly BandKey[];
+    /** Each key's index in the `from` keys. Missing: the key enters. */
+    readonly from: ReadonlyMap<BandKey, number>;
+    /** Each key's index in the `to` keys. Missing: the key exits. */
+    readonly to: ReadonlyMap<BandKey, number>;
+    /** True when some key is only in `to`. */
+    readonly enters: boolean;
+    /** True when some key is only in `from`. */
+    readonly exits: boolean;
+}
+/**
+ * Matches two key lists: keys in both update, keys only in `to` enter,
+ * keys only in `from` exit. Keys are compared with `===`.
+ *
+ * @param from - The keys at `t = 0`, one per datum.
+ * @param to - The keys at `t = 1`, one per datum.
+ * @category Math & helpers
+ */
+export declare function keyedJoin(from: readonly BandKey[], to: readonly BandKey[]): KeyedJoin;
+/**
+ * How a keyed transition spends its blend: `"staged"` runs exit, then
+ * update, then enter (domains grow before the update and shrink after),
+ * each stage eased; `"together"` runs everything at once, linearly, so the
+ * driving track's easing applies.
+ *
+ * @see https://sophistry.dev/guides/chart-animation/#data-transitions
+ * @category Math & helpers
+ */
+export type JoinStaging = "staged" | "together";
+/**
+ * A stage's share of the blend, `[start, end]` within 0..1.
+ *
+ * @category Math & helpers
+ */
+export type StageWindow = readonly [start: number, end: number];
+/**
+ * Where each stage of a keyed transition falls within its blend. See
+ * {@link joinStages}.
+ *
+ * @category Math & helpers
+ */
+export interface JoinStages {
+    /** Exiting marks shrink or fade at their old place. */
+    readonly exit: StageWindow;
+    /** Domains that grow rescale here, before the update. */
+    readonly expand: StageWindow;
+    /** Matched marks move from old to new values; domains that shift without growing or shrinking rescale here too. */
+    readonly update: StageWindow;
+    /** Domains that shrink rescale here, after the update. */
+    readonly contract: StageWindow;
+    /** Entering marks grow or fade in at their new place. */
+    readonly enter: StageWindow;
+    /** Whether each stage eases in and out on its own (`"staged"`). */
+    readonly eased: boolean;
+}
+/**
+ * Options for {@link joinStages}.
+ *
+ * @category Math & helpers
+ */
+export interface JoinStageOptions {
+    /** Some mark exits. */
+    exits?: boolean;
+    /** Some mark enters. */
+    enters?: boolean;
+    /** Some domain grows (the new range contains the old). */
+    expand?: boolean;
+    /** Some domain shrinks (the old range contains the new). */
+    contract?: boolean;
+    /** See {@link JoinStaging}. @default "staged" */
+    staging?: JoinStaging;
+}
+/**
+ * Splits a keyed transition's blend into up to three equal phases, each
+ * present only when it has work: exits and growing domains, then the update
+ * (always), then shrinking domains and enters.
+ *
+ * @category Math & helpers
+ */
+export declare function joinStages(options?: JoinStageOptions): JoinStages;
+/**
+ * The window a key's entries fade on: the exit (or enter) stage, or the
+ * update when the transition has none, so an entry one end shows is still
+ * whole at its end.
+ *
+ * @internal
+ */
+export declare function keyWindow(own: StageWindow, update: StageWindow): StageWindow;
+/**
+ * How far a stage has got at blend `t`, 0..1: 0 before its window, 1 after,
+ * eased within it when `eased`. An empty window is a step at its start.
+ *
+ * @param eased - Ease within the window. Defaults to false.
+ * @category Math & helpers
+ */
+export declare function stageProgress(t: number, window: StageWindow, eased?: boolean): number;
+/**
+ * One item's progress through a staggered stage: item `rank` of `count`
+ * starts `spread · rank / (count − 1)` of the way in and takes `1 − spread`
+ * of the window, eased on its own sub-window when `eased`. The total spread
+ * is fixed, so 5 or 500 items take the same time, and every item is exact at
+ * the window's ends.
+ *
+ * @param spread - 0 (all together, as {@link stageProgress}) to 0.95.
+ * @category Math & helpers
+ */
+export declare function staggeredStageProgress(t: number, window: StageWindow, eased: boolean, rank: number, count: number, spread: number): number;
+/**
+ * How a domain changes between two ranges: `"expand"` when the new contains
+ * the old, `"contract"` when the old contains the new, `"none"` when equal,
+ * `"shift"` otherwise.
+ *
+ * @category Math & helpers
+ */
+export declare function rescaleKind(from: Readonly<Range>, to: Readonly<Range>): "none" | "expand" | "contract" | "shift";
+/**
+ * The window a domain change rescales in: growing before the update,
+ * shrinking after it, a shift with it.
+ *
+ * @category Math & helpers
+ */
+export declare function rescaleWindow(stages: JoinStages, kind: "none" | "expand" | "contract" | "shift"): StageWindow;
+//# sourceMappingURL=join.d.ts.map

package/dist/math/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["../../src/math/join.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACzB,uFAAuF;IACvF,QAAQ,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,CAAC;IAClC,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC5C,iEAAiE;IACjE,QAAQ,CAAC,EAAE,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC1C,0CAA0C;IAC1C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACxB,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,EAAE,EAAE,SAAS,OAAO,EAAE,GACpB,SAAS,CAwBX;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEhD;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IAC1B,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,mHAAmH;IACnH,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,yDAAyD;IACzD,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAChC,uBAAuB;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,wBAAwB;IACxB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iDAAiD;IACjD,OAAO,CAAC,EAAE,WAAW,CAAC;CACtB;AASD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,gBAAqB,GAAG,UAAU,CA4BrE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,WAAW,CAE5E;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC5B,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,WAAW,EACnB,KAAK,UAAQ,GACX,MAAM,CAMR;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACrC,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACZ,MAAM,CAQR;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAC1B,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,EACrB,EAAE,EAAE,QAAQ,CAAC,KAAK,CAAC,GACjB,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,CAS1C;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,GAC5C,WAAW,CAMb"}

package/dist/math/keyframes.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Time as an encoding: where a keyed series of keyframes stands between
+ * them, the trail it leaves behind, and the ranks of a bar chart race. Every
+ * function reads only the moment it is asked about, so playback scrubs.
+ */
+import type { BandKey, Point } from "@sophistry/core/geometry";
+/**
+ * Where a moment falls among keyframe times.
+ *
+ * @category Math & helpers
+ */
+export interface KeyframeSpan {
+    /** Index of the keyframe at or before the moment. */
+    lo: number;
+    /** Index of the keyframe after it (`lo` itself on a keyframe). */
+    hi: number;
+    /** How far from `lo` to `hi`, 0..1. */
+    u: number;
+}
+/**
+ * The keyframes either side of `at` and the linear blend between them.
+ *
+ * @param times - Keyframe times, ascending.
+ * @returns The span, or undefined when `at` is outside the keyframes.
+ * @category Math & helpers
+ */
+export declare function keyframeAt(times: readonly number[], at: number): KeyframeSpan | undefined;
+/**
+ * The path a keyed mark has travelled from `at - length` to `at`, both ends
+ * interpolated, in time order.
+ *
+ * @param times - Keyframe times, ascending, parallel to `points`.
+ * @param length - How much time the trail spans. Defaults to all of it.
+ * @returns The trail, or `[]` before the first keyframe.
+ * @category Math & helpers
+ */
+export declare function trailPolyline(points: readonly Point[], times: readonly number[], at: number, length?: number): Point[];
+/**
+ * One entry of a bar chart race at a moment. See {@link raceTimeline}.
+ *
+ * @category Math & helpers
+ */
+export interface RaceEntry {
+    /** The entry's key. */
+    key: BandKey;
+    /** Its value, interpolated linearly between keyframes. */
+    value: number;
+    /** Its rank by that value, 0 for the first place. */
+    rank: number;
+    /** Where it is drawn, in ranks: `rank` at rest, sliding on the swap's ease after a change. */
+    position: number;
+    /**
+     * How present it is, 0..1: 1 within the `top` slots, fading to 0 as it
+     * slides past the last one. Always 1 without a `top`.
+     */
+    presence: number;
+}
+/**
+ * A race at one moment, laid out for a band axis of `top` slots. See
+ * {@link RaceTimeline.view}.
+ *
+ * @category Math & helpers
+ */
+export interface RaceView {
+    /** The entries still present (`presence > 0`), in key order. */
+    entries: RaceEntry[];
+    /**
+     * The axis's categories: the `top` entries drawn nearest first place (all
+     * without a `top`), in key order. An entry sliding past the last slot is
+     * drawn past the axis's end (cut by `<Chart clip>`).
+     */
+    categories: BandKey[];
+    /** Each entry's slot: its `position`, for a band axis's `slot` option. */
+    slot: (key: BandKey) => number | undefined;
+}
+/**
+ * Options for {@link raceTimeline}.
+ *
+ * @category Math & helpers
+ */
+export interface RaceOptions {
+    /**
+     * How long a rank swap takes, in the keyframes' time units; 0 swaps at once. Defaults to a
+     * quarter of the shortest gap between keyframes.
+     */
+    swap?: number;
+    /** `"descending"` puts the largest value first. @default "descending" */
+    order?: "descending" | "ascending";
+    /**
+     * How many places are shown: entries ranked past it fade as they slide
+     * below the last place. Defaults to every entry.
+     */
+    top?: number;
+}
+/**
+ * A bar chart race, precomputed: ask it for any moment.
+ *
+ * @category Math & helpers
+ */
+export interface RaceTimeline {
+    /** The keys, in the order given. */
+    readonly keys: readonly BandKey[];
+    /** The keyframe times, ascending. */
+    readonly times: readonly number[];
+    /** How many places are shown (`top`), or undefined for all. */
+    readonly top: number | undefined;
+    /** Every entry at `time`, in key order. */
+    at(time: number): RaceEntry[];
+    /**
+     * The race at `time` laid out for a band axis. Pass `categories` and `slot`
+     * to `<Chart yAxis>` (with `clip`) and draw `entries`.
+     */
+    view(time: number): RaceView;
+}
+/**
+ * A bar chart race over keyframes: values interpolate linearly, ranks come
+ * from the interpolated values (so bars swap exactly when values cross), and
+ * each swap slides on its own short ease (`swap`). A pure function of time,
+ * so it scrubs.
+ *
+ * @param keys - One key per entry.
+ * @param times - Keyframe times, ascending.
+ * @param values - `values[k][e]`: entry `e`'s value at keyframe `k`; non-finite counts as 0.
+ * @see https://sophistry.dev/guides/chart-animation/#data-transitions
+ * @category Math & helpers
+ */
+export declare function raceTimeline(keys: readonly BandKey[], times: readonly number[], values: readonly (readonly number[])[], options?: RaceOptions): RaceTimeline;
+//# sourceMappingURL=keyframes.d.ts.map

package/dist/math/keyframes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyframes.d.ts","sourceRoot":"","sources":["../../src/math/keyframes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,qDAAqD;IACrD,EAAE,EAAE,MAAM,CAAC;IACX,kEAAkE;IAClE,EAAE,EAAE,MAAM,CAAC;IACX,uCAAuC;IACvC,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,EAAE,EAAE,MAAM,GACR,YAAY,GAAG,SAAS,CAa1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,EAAE,EAAE,MAAM,EACV,MAAM,SAA2B,GAC/B,KAAK,EAAE,CAkBT;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACzB,uBAAuB;IACvB,GAAG,EAAE,OAAO,CAAC;IACb,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,8FAA8F;IAC9F,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACxB,gEAAgE;IAChE,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB;;;;OAIG;IACH,UAAU,EAAE,OAAO,EAAE,CAAC;IACtB,0EAA0E;IAC1E,IAAI,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;CAC3C;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC3B;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,KAAK,CAAC,EAAE,YAAY,GAAG,WAAW,CAAC;IACnC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,oCAAoC;IACpC,QAAQ,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,CAAC;IAClC,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,+DAA+D;IAC/D,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,2CAA2C;IAC3C,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC;IAC9B;;;OAGG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;CAC7B;AAcD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC3B,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACtC,OAAO,GAAE,WAAgB,GACvB,YAAY,CAgId"}

package/dist/math/legend.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Legend layout: where each entry's swatch and label go, given the labels'
+ * measured widths. Pure; the `<Legend>` component measures and draws.
+ */
+import type { Point } from "@sophistry/core/geometry";
+/**
+ * Options for {@link legendLayout}. Lengths are in scene units.
+ *
+ * @category Math & helpers
+ */
+export interface LegendLayoutOptions {
+    /** `"column"`: one entry per row, top-down. `"row"`: entries side by side, wrapping at `maxWidth`. */
+    direction: "column" | "row";
+    /** Height of one row (an entry's line). */
+    rowHeight: number;
+    /** Width reserved for a swatch. */
+    swatchWidth: number;
+    /** Space between a swatch and its label. */
+    swatchGap: number;
+    /** Row direction: space between one entry's label and the next entry's swatch. */
+    itemGap: number;
+    /**
+     * Row direction: wrap before an entry that would run past this width. Defaults to no wrapping.
+     */
+    maxWidth?: number;
+    /** Width of a title line above the entries, if there is one. */
+    titleWidth?: number;
+}
+/**
+ * One entry, placed. Offsets from the legend's top-left corner, y up (so
+ * rows below the first have negative y).
+ *
+ * @category Math & helpers
+ */
+export interface LegendItemLayout {
+    /** Centre of the swatch. */
+    swatch: Point;
+    /** Left end of the label, at the row's vertical middle. */
+    label: Point;
+}
+/**
+ * A legend, laid out.
+ *
+ * @category Math & helpers
+ */
+export interface LegendLayout {
+    items: LegendItemLayout[];
+    /** Left end of the title line, at its vertical middle; undefined without a title. */
+    title?: Point;
+    /** Overall width. */
+    width: number;
+    /** Overall height. */
+    height: number;
+}
+/**
+ * Lays a legend out from its labels' widths: swatches in a column (or a
+ * wrapping row), each label right of its swatch, an optional title on top.
+ *
+ * @param widths - Each label's width, in order.
+ * @category Math & helpers
+ */
+export declare function legendLayout(widths: readonly number[], options: LegendLayoutOptions): LegendLayout;
+/**
+ * Options for {@link sizeLegendLayout}. Lengths are in scene units.
+ *
+ * @category Math & helpers
+ */
+export interface SizeLegendLayoutOptions {
+    /** `"column"`: one circle per row, top-down. `"row"`: side by side, wrapping at `maxWidth`. */
+    direction: "column" | "row";
+    /** The least height of a row: one line of text. A circle taller than that makes its row taller. */
+    rowHeight: number;
+    /** Space between a circle and its label. */
+    gap: number;
+    /** Row direction: space between one entry's label and the next entry's circle. */
+    itemGap: number;
+    /** Room kept above and below each circle. @default 0 */
+    pad?: number;
+    /**
+     * Row direction: wrap before an entry that would run past this width. Defaults to no wrapping.
+     */
+    maxWidth?: number;
+    /** Width of a title line above the entries, if there is one. */
+    titleWidth?: number;
+}
+/**
+ * One size-key entry, placed. Offsets from the key's top-left corner, y up.
+ *
+ * @category Math & helpers
+ */
+export interface SizeLegendItemLayout {
+    /** Centre of the circle. */
+    center: Point;
+    /** Left end of the label, level with the circle's centre. */
+    label: Point;
+}
+/**
+ * A size key, laid out.
+ *
+ * @category Math & helpers
+ */
+export interface SizeLegendLayout {
+    items: SizeLegendItemLayout[];
+    /** Left end of the title line, at its vertical middle; undefined without a title. */
+    title?: Point;
+    /** Overall width. */
+    width: number;
+    /** Overall height. */
+    height: number;
+}
+/**
+ * Lays a size key out: one reference circle per entry with its value
+ * beside it. In a column the circles share one centre line and each row is
+ * as tall as its circle; in a row every row is as tall as its tallest entry.
+ *
+ * @param radii - Each entry's circle radius, in order.
+ * @param widths - Each entry's label width, in order.
+ * @category Math & helpers
+ */
+export declare function sizeLegendLayout(radii: readonly number[], widths: readonly number[], options: SizeLegendLayoutOptions): SizeLegendLayout;
+//# sourceMappingURL=legend.d.ts.map

package/dist/math/legend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legend.d.ts","sourceRoot":"","sources":["../../src/math/legend.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEtD;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC,sGAAsG;IACtG,SAAS,EAAE,QAAQ,GAAG,KAAK,CAAC;IAC5B,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAClB,mCAAmC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,kFAAkF;IAClF,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAChC,4BAA4B;IAC5B,MAAM,EAAE,KAAK,CAAC;IACd,2DAA2D;IAC3D,KAAK,EAAE,KAAK,CAAC;CACb;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,qFAAqF;IACrF,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,EAAE,mBAAmB,GAC1B,YAAY,CA8Cd;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACvC,+FAA+F;IAC/F,SAAS,EAAE,QAAQ,GAAG,KAAK,CAAC;IAC5B,mGAAmG;IACnG,SAAS,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,kFAAkF;IAClF,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC,4BAA4B;IAC5B,MAAM,EAAE,KAAK,CAAC;IACd,6DAA6D;IAC7D,KAAK,EAAE,KAAK,CAAC;CACb;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,qFAAqF;IACrF,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,qBAAqB;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,EAAE,uBAAuB,GAC9B,gBAAgB,CAyDlB"}

package/dist/math/line.d.ts

@@ -0,0 +1,54 @@
+/** Line plots from discrete data, split into continuous runs at non-finite pairs (a gap, not a spike). */
+import type { Point } from "@sophistry/core/geometry";
+/**
+ * Parallel `x`/`y` arrays split into runs, breaking at non-finite pairs.
+ *
+ * @returns Runs of consecutive finite points; single-point runs are dropped.
+ * @category Math & helpers
+ */
+export declare function dataRuns(xs: readonly number[], ys: readonly number[]): Point[][];
+/**
+ * Whether a run's x never decreases: the precondition for
+ * {@link decimateRun}, which bisects on x.
+ *
+ * @internal
+ */
+export declare function isNonDecreasingX(run: readonly Point[]): boolean;
+/**
+ * How many points per column a run must exceed, inside the window, before
+ * {@link decimateRun} thins it: below this the line is drawn as given.
+ */
+export declare const DECIMATION_MIN_PER_COLUMN = 4;
+/**
+ * Min/max-per-column ("M4") decimation of a long line: inside `edges`' window,
+ * each column keeps only its first, last, lowest and highest points, in
+ * order. A line through them covers, column by column, exactly the span the
+ * full line does and enters and leaves each column at the same points, so
+ * with a column per device pixel it rasterises to the same pixels (Jugel et
+ * al., "M4", VLDB 2014) at no more than four points per column, however many
+ * the data holds.
+ *
+ * Outside the window the run is kept as it is — or, with `dropOutside` (the
+ * window is clipped, so nothing past it shows), cut to the one point each
+ * side that carries the line to the window's edge.
+ *
+ * @param run - Points with non-decreasing x (see {@link isNonDecreasingX}).
+ * @param edges - Column boundaries in data x, ascending; column `k` is
+ * `[edges[k], edges[k + 1])`, the last one closed.
+ * @param dropOutside - Whether points beyond the window can be dropped.
+ * @returns The kept points (the run's own objects), or `run` itself when the
+ * window holds no more than {@link DECIMATION_MIN_PER_COLUMN} points per
+ * column.
+ * @internal
+ */
+export declare function decimateRun(run: readonly Point[], edges: readonly number[], dropOutside?: boolean): readonly Point[];
+/**
+ * Whether two lines' runs hold the same points: lengths, then coordinates,
+ * stopping at the first difference. The equality for point arrays that can
+ * be long, where `deepEqual`'s `Object.keys` per array would allocate a key
+ * per point on every comparison, even one that fails at once.
+ *
+ * @internal
+ */
+export declare function sameRuns(a: readonly (readonly Point[])[], b: readonly (readonly Point[])[]): boolean;
+//# sourceMappingURL=line.d.ts.map

package/dist/math/line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../src/math/line.ts"],"names":[],"mappings":"AAAA,0GAA0G;AAE1G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAGtD;;;;;GAKG;AACH,wBAAgB,QAAQ,CACvB,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,EAAE,EAAE,SAAS,MAAM,EAAE,GACnB,KAAK,EAAE,EAAE,CAgBX;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAI/D;AAcD;;;GAGG;AACH,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAC1B,GAAG,EAAE,SAAS,KAAK,EAAE,EACrB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,WAAW,UAAQ,GACjB,SAAS,KAAK,EAAE,CAyClB;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACvB,CAAC,EAAE,SAAS,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,EAChC,CAAC,EAAE,SAAS,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,GAC9B,OAAO,CAaT"}

package/dist/math/morph.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Data-space morphing: a line, an area or a step function at blend `t`
+ * between two versions of itself, interpolated in data units so every frame
+ * is a valid chart of its kind under whatever scale is current.
+ */
+import type { Point } from "@sophistry/core/geometry";
+/**
+ * Morphs one polyline into another in data units. Two functions of x are
+ * resampled onto the union of their xs and blended per x, so points move
+ * vertically and the x extent grows or retreats at the ends; other shapes
+ * are resampled by arc length and blended point by point. `t = 0` returns
+ * `from`, `t = 1` returns `to`.
+ *
+ * @param t - Blend, clamped to 0..1.
+ * @category Math & helpers
+ */
+export declare function morphPolyline(from: readonly Point[], to: readonly Point[], t: number): Point[];
+/**
+ * Morphs a line of several runs (split at data gaps) into another: run by
+ * run when the counts match, else as one line (gaps open or close only at
+ * the ends of the blend). See {@link morphPolyline}.
+ *
+ * @param t - Blend, clamped to 0..1.
+ * @category Math & helpers
+ */
+export declare function morphRuns(from: readonly (readonly Point[])[], to: readonly (readonly Point[])[], t: number): Point[][];
+/**
+ * One x of an area: its two bounds there, `y1` and `y2` in either order.
+ *
+ * @category Math & helpers
+ */
+export interface AreaPoint {
+    x: number;
+    y1: number;
+    y2: number;
+}
+/**
+ * Morphs one area (a band, a stacked layer, a density fill) into another in
+ * data units, both bounds together. Two functions of x are resampled onto
+ * the union of their xs and blended per x, as {@link morphPolyline}, so
+ * adjacent stack layers keep sharing an edge; other shapes are blended
+ * point by point. `t = 0` returns `from`, `t = 1` returns `to`.
+ *
+ * @param t - Blend, clamped to 0..1.
+ * @category Math & helpers
+ */
+export declare function morphArea(from: readonly AreaPoint[], to: readonly AreaPoint[], t: number): AreaPoint[];
+/**
+ * Morphs an area of several runs (split at data gaps) into another: run by
+ * run when the counts match, else as one area. See {@link morphArea}.
+ *
+ * @param t - Blend, clamped to 0..1.
+ * @category Math & helpers
+ */
+export declare function morphAreaRuns(from: readonly (readonly AreaPoint[])[], to: readonly (readonly AreaPoint[])[], t: number): AreaPoint[][];
+/**
+ * A step function: `values[i]` held across `[edges[i], edges[i + 1]]`, so
+ * one more edge than values.
+ *
+ * @category Math & helpers
+ */
+export interface StepFunction {
+    /** Step boundaries, ascending, in data units. */
+    edges: readonly number[];
+    /** One height per interval, in data units. */
+    values: readonly number[];
+}
+/**
+ * Morphs one step function into another in data units, so every frame is
+ * still stairs. Both are resampled onto the union of their edges and each
+ * height blended; outer edges blend between the extents. Non-ascending
+ * edges cut from `from` to `to` at `t = 0.5`.
+ *
+ * @param t - Blend, clamped to 0..1.
+ * @returns The step function at `t`, with `edges.length === values.length + 1`.
+ * @category Math & helpers
+ */
+export declare function morphSteps(from: StepFunction, to: StepFunction, t: number): {
+    edges: number[];
+    values: number[];
+};
+//# sourceMappingURL=morph.d.ts.map

package/dist/math/morph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"morph.d.ts","sourceRoot":"","sources":["../../src/math/morph.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AA2DtD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC5B,IAAI,EAAE,SAAS,KAAK,EAAE,EACtB,EAAE,EAAE,SAAS,KAAK,EAAE,EACpB,CAAC,EAAE,MAAM,GACP,KAAK,EAAE,CA4CT;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACxB,IAAI,EAAE,SAAS,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,EACnC,EAAE,EAAE,SAAS,CAAC,SAAS,KAAK,EAAE,CAAC,EAAE,EACjC,CAAC,EAAE,MAAM,GACP,KAAK,EAAE,EAAE,CAQX;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACX;AA4CD;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACxB,IAAI,EAAE,SAAS,SAAS,EAAE,EAC1B,EAAE,EAAE,SAAS,SAAS,EAAE,EACxB,CAAC,EAAE,MAAM,GACP,SAAS,EAAE,CAmCb;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC5B,IAAI,EAAE,SAAS,CAAC,SAAS,SAAS,EAAE,CAAC,EAAE,EACvC,EAAE,EAAE,SAAS,CAAC,SAAS,SAAS,EAAE,CAAC,EAAE,EACrC,CAAC,EAAE,MAAM,GACP,SAAS,EAAE,EAAE,CAQf;AAED;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC5B,iDAAiD;IACjD,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,8CAA8C;IAC9C,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B;AA0BD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACzB,IAAI,EAAE,YAAY,EAClB,EAAE,EAAE,YAAY,EAChB,CAAC,EAAE,MAAM,GACP;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CA4BvC"}