@sophistry/charts 0.0.0-stage → 0.0.1

package/dist/math/mosaic.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Mosaic (Marimekko) layout: a two-way table as columns as wide as each
+ * column's share of the whole, split into segments as tall as each row's
+ * share within the column.
+ */
+/**
+ * A category of a mosaic's columns or rows: a string or a number.
+ *
+ * @category Math & helpers
+ */
+export type MosaicKey = string | number;
+/**
+ * One entry of the long-form table a mosaic lays out.
+ *
+ * @category Math & helpers
+ */
+export interface MosaicInput {
+    /** Column category. */
+    x: MosaicKey;
+    /** Row (segment) category. */
+    y: MosaicKey;
+    /** Amount; negative and non-finite values count as 0. */
+    value: number;
+}
+/** @category Math */
+export interface MosaicOptions {
+    /**
+     * Column order: listed keys first, then unlisted ones in first-seen order. Defaults to
+     * first-seen order.
+     */
+    columns?: readonly MosaicKey[];
+    /** Row (segment) order, bottom first; same rules as `columns`. Defaults to first-seen order. */
+    rows?: readonly MosaicKey[];
+    /** Width of the layout box. @default 1 */
+    width?: number;
+    /** Height of the layout box. @default 1 */
+    height?: number;
+    /**
+     * Gap between neighbouring columns, and between segments in a column;
+     * capped at half the box's width (or height) in total.
+     * @default 0
+     */
+    padding?: number;
+}
+/**
+ * One laid-out column of a mosaic, in the layout box.
+ *
+ * @category Math & helpers
+ */
+export interface MosaicColumn {
+    /** The column's category. */
+    key: MosaicKey;
+    /** Place among the drawn columns, left to right, 0-based. */
+    index: number;
+    /** Left edge. */
+    x0: number;
+    /** Right edge. */
+    x1: number;
+    /** Sum of the column's values. */
+    value: number;
+    /** The column's share of the grand total, 0..1. */
+    share: number;
+    /** Index of the first input entry with a positive value in the column. */
+    dataIndex: number;
+}
+/**
+ * One laid-out segment of a mosaic: a rectangle in the layout box, **y
+ * pointing down** (0 is the top edge).
+ *
+ * @category Math & helpers
+ */
+export interface MosaicRect {
+    /** The column's category. */
+    column: MosaicKey;
+    /** The row's category. */
+    row: MosaicKey;
+    /** The column's place among the drawn columns, 0-based. */
+    columnIndex: number;
+    /** The row's place in {@link MosaicLayout.rows}, 0-based (stable across columns, for colour). */
+    rowIndex: number;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    /** Sum of the values for this (column, row) pair. */
+    value: number;
+    /** The column's share of the grand total, 0..1 (the rectangle's width share). */
+    columnShare: number;
+    /** The segment's share of its column, 0..1 (its height share). */
+    rowShare: number;
+    /** Index of the first input entry with a positive value for this pair. */
+    dataIndex: number;
+}
+/**
+ * A mosaic laid out: see {@link mosaicLayout}.
+ *
+ * @category Math & helpers
+ */
+export interface MosaicLayout {
+    /** Columns with a positive total, left to right. */
+    columns: MosaicColumn[];
+    /** Segments with a positive value, column by column, bottom to top. */
+    rects: MosaicRect[];
+    /** Every row category, in row order (including rows with no positive value). */
+    rows: MosaicKey[];
+    /** Sum of every value. */
+    total: number;
+}
+/**
+ * Lays out a mosaic from a long-form `{ x, y, value }` table: column widths
+ * by share of the total, segments stacked bottom-up in row order by share
+ * of their column, so areas are proportional to values. Duplicate pairs
+ * sum; nothing-positive columns and segments get no rectangle or gap. The
+ * box has **y pointing down**.
+ *
+ * @returns Columns, segment rectangles, row order and total; empty when nothing is positive.
+ * @category Math & helpers
+ */
+export declare function mosaicLayout(cells: readonly MosaicInput[], options?: MosaicOptions): MosaicLayout;
+//# sourceMappingURL=mosaic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mosaic.d.ts","sourceRoot":"","sources":["../../src/math/mosaic.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAEH;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC;AAExC;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC3B,uBAAuB;IACvB,CAAC,EAAE,SAAS,CAAC;IACb,8BAA8B;IAC9B,CAAC,EAAE,SAAS,CAAC;IACb,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAC;CACd;AAED,qBAAqB;AACrB,MAAM,WAAW,aAAa;IAC7B;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IAC/B,gGAAgG;IAChG,IAAI,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IAC5B,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,6BAA6B;IAC7B,GAAG,EAAE,SAAS,CAAC;IACf,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,iBAAiB;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,kBAAkB;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IAC1B,6BAA6B;IAC7B,MAAM,EAAE,SAAS,CAAC;IAClB,0BAA0B;IAC1B,GAAG,EAAE,SAAS,CAAC;IACf,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,iGAAiG;IACjG,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,oDAAoD;IACpD,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,uEAAuE;IACvE,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,gFAAgF;IAChF,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,0BAA0B;IAC1B,KAAK,EAAE,MAAM,CAAC;CACd;AA4CD;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC3B,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,OAAO,GAAE,aAAkB,GACzB,YAAY,CA6Gd"}

package/dist/math/ordinal.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Categorical colour: an ordinal scale from category keys to colours, a few
+ * categorical schemes, and the per-datum keys that give marks their identity.
+ */
+import type { BandKey } from "@sophistry/core/geometry";
+/**
+ * An ordinal colour scale: category keys to colours, in domain order,
+ * cycling through `range` when there are more categories than colours.
+ *
+ * @category Math & helpers
+ */
+export interface OrdinalColorScale {
+    /** The categories, in order, each once. */
+    readonly domain: readonly BandKey[];
+    /** The colours cycled over the domain. */
+    readonly range: readonly string[];
+    /** The colour of `key`; a key not in the domain gets `unknown`. */
+    (key: BandKey | null | undefined): string;
+    /** The position of `key` in the domain, or -1. */
+    index(key: BandKey | null | undefined): number;
+}
+/**
+ * Options for {@link ordinalColorScale}.
+ *
+ * @category Math & helpers
+ */
+export interface OrdinalColorScaleOptions {
+    /**
+     * Colour for a key not in the domain, and for nullish keys. Defaults to the first colour of
+     * `range`.
+     */
+    unknown?: string;
+}
+/**
+ * The categories of `values` in first-seen order, each once; nullish
+ * entries are skipped. Like a band scale, `1` and `"1"` are different keys.
+ *
+ * @category Math & helpers
+ */
+export declare function uniqueKeys(values: Iterable<BandKey | null | undefined>): BandKey[];
+/**
+ * An ordinal colour scale: category `i` of `domain` gets
+ * `range[i % range.length]`. Pin the full domain to keep colours stable
+ * when data is filtered.
+ *
+ * @param domain - The categories, in order; duplicates and nullish entries are dropped.
+ * @throws {RangeError} If `range` is empty.
+ * @category Math & helpers
+ */
+export declare function ordinalColorScale(domain: Iterable<BandKey | null | undefined>, range: readonly string[], options?: OrdinalColorScaleOptions): OrdinalColorScale;
+/**
+ * Okabe & Ito's eight colours, distinct under common colour-vision
+ * deficiencies, with black swapped for a mid grey so it reads on dark grounds.
+ *
+ * @category Math & helpers
+ */
+export declare const okabeIto: readonly string[];
+/**
+ * Tableau's ten categorical colours (2016 revision).
+ *
+ * @category Math & helpers
+ */
+export declare const tableau10: readonly string[];
+/**
+ * Observable's ten categorical colours.
+ *
+ * @category Math & helpers
+ */
+export declare const observable10: readonly string[];
+/**
+ * One identity per datum, so marks keep their node across data changes: an
+ * explicit `key` wins (`"<key>#<n>"` for repeats), else the datum's place
+ * within its `series`, else its index. Keys are strings or numbers,
+ * compared with `===`, unique within the call.
+ *
+ * @param count - Number of data.
+ * @category Math & helpers
+ */
+export declare function datumKeys(count: number, key?: (index: number) => BandKey | null | undefined, series?: (index: number) => BandKey | null | undefined): BandKey[];
+//# sourceMappingURL=ordinal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ordinal.d.ts","sourceRoot":"","sources":["../../src/math/ordinal.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAExD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;IACpC,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,mEAAmE;IACnE,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC;IAC1C,kDAAkD;IAClD,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAAC;CAC/C;AAED;;;;GAIG;AACH,MAAM,WAAW,wBAAwB;IACxC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACzB,MAAM,EAAE,QAAQ,CAAC,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,GAC1C,OAAO,EAAE,CAQX;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAChC,MAAM,EAAE,QAAQ,CAAC,OAAO,GAAG,IAAI,GAAG,SAAS,CAAC,EAC5C,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,OAAO,GAAE,wBAA6B,GACpC,iBAAiB,CAwBnB;AAED;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,EAAE,SAAS,MAAM,EASpC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAWrC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,SAAS,MAAM,EAWxC,CAAC;AAEH;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACxB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,GAAG,SAAS,EACnD,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,GAAG,SAAS,GACpD,OAAO,EAAE,CAyBX"}

package/dist/math/parallel.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Parallel coordinates: each row of numbers becomes a polyline across a row
+ * of vertical axes, one axis per column.
+ */
+import type { Point, Range } from "@sophistry/core/geometry";
+/**
+ * Horizontal position of axis `index` of `count`, 0..1: evenly spaced, the
+ * first at 0 and the last at 1. A lone axis sits at 0.5.
+ *
+ * @category Math & helpers
+ */
+export declare function parallelAxisX(index: number, count: number): number;
+/**
+ * One row's polyline in normalized coordinates.
+ *
+ * @category Math & helpers
+ */
+export interface ParallelLine {
+    /** Position of the row in the input. */
+    index: number;
+    /**
+     * Runs of consecutive usable values, each a polyline in the unit square
+     * (`y` 0 at the axis's `min`, 1 at `max`). Non-finite values break the
+     * line; a one-point run is kept.
+     */
+    segments: Point[][];
+}
+/**
+ * Maps rows of values onto parallel axes in normalized `[0, 1] × [0, 1]`
+ * coordinates (y up): axis `j` stands at `parallelAxisX(j, ranges.length)`
+ * and a value sits at `(v − min) / (max − min)` along it. Short rows miss
+ * their last axes; a degenerate range puts values at 0.5.
+ *
+ * @param rows - One array per datum, one value per axis.
+ * @param ranges - One linear `[min, max, step?]` per axis.
+ * @category Math & helpers
+ */
+export declare function parallelLines(rows: readonly (readonly number[])[], ranges: readonly Range[]): ParallelLine[];
+//# sourceMappingURL=parallel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../src/math/parallel.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,wCAAwC;IACxC,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC5B,IAAI,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACpC,MAAM,EAAE,SAAS,KAAK,EAAE,GACtB,YAAY,EAAE,CAsBhB"}

package/dist/math/pcolormesh.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Pseudocolour mesh on a regular grid: `X`/`Y` are 1D per-axis coordinates,
+ * either cell edges (`ncols + 1` / `nrows + 1`) or centres (`ncols` /
+ * `nrows`), and `Z` the `nrows x ncols` cell values.
+ */
+import { type GridCell, type GridResult } from "./shared/gridCells";
+/** @category Math */
+export type PcolormeshCell = GridCell;
+/** @category Math */
+export type PcolormeshResult = GridResult;
+/**
+ * Cells for the grid `Z`, positioned by `X`/`Y` edges or centres. Ragged
+ * rows are tolerated; `min`/`max` cover finite values only (`[0, 1]` when
+ * none).
+ *
+ * @param X - Column coordinates: `ncols` centres or `ncols + 1` edges.
+ * @param Y - Row coordinates: `nrows` centres or `nrows + 1` edges.
+ * @param Z - Samples as `Z[row][col]`.
+ * @throws If `X` or `Y` has neither the grid size nor the grid size plus one entries (and `Z` is non-empty).
+ * @category Math & helpers
+ */
+export declare function pcolormeshCells(X: readonly number[], Y: readonly number[], Z: readonly (readonly number[])[]): PcolormeshResult;
+//# sourceMappingURL=pcolormesh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pcolormesh.d.ts","sourceRoot":"","sources":["../../src/math/pcolormesh.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAEN,KAAK,QAAQ,EACb,KAAK,UAAU,EAEf,MAAM,oBAAoB,CAAC;AAE5B,qBAAqB;AACrB,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC;AACtC,qBAAqB;AACrB,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC;AA4B1C;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC9B,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,CAAC,EAAE,SAAS,MAAM,EAAE,EACpB,CAAC,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,GAC/B,gBAAgB,CAmBlB"}

package/dist/math/pie.d.ts

@@ -0,0 +1,106 @@
+/** Pie geometry: consecutive angular slices sized by each value's share of the total, plus sweep and grow reveals. */
+import type { BandKey, Point } from "@sophistry/core/geometry";
+import type { PolarSweepOptions } from "./shared/polar";
+/** @category Math */
+export interface PieSlice {
+    /** Position in the input `values`; parallel `colors`/`labels` arrays index by this. */
+    index: number;
+    /** The (clamped) value this slice represents. */
+    value: number;
+    /** Radians from +x, as `Sector`'s `startAngle`. */
+    startAngle: number;
+    /** Radians from +x; `endAngle - startAngle` is the signed sweep for `Sector`'s `angle`. */
+    endAngle: number;
+    /** `value / total`: the slice's share of the pie. */
+    fraction: number;
+}
+/** @category Math */
+export type PieOptions = PolarSweepOptions;
+/**
+ * One slice per value, consecutive and summing to a full turn. A zero still
+ * gets a zero-sweep slice, so parallel `colors`/`labels` stay aligned.
+ *
+ * @param values - One value per slice; negative and non-finite entries clamp to 0.
+ * @returns One {@link PieSlice} per value, or `[]` when the total is not positive.
+ * @category Math & helpers
+ */
+export declare function pieSlices(values: readonly number[], options?: PieOptions): PieSlice[];
+/**
+ * How much of each slice a clockwise sweep from the first slice's start has
+ * uncovered at `progress`: slices appear in data order, each complete before
+ * the next begins.
+ *
+ * @param progress - The sweep, 0..1 of a full turn.
+ * @returns One fraction per slice, 0 (not reached) to 1 (fully swept).
+ * @category Math & helpers
+ */
+export declare function pieSweep(slices: readonly PieSlice[], progress: number): number[];
+/**
+ * The slices growing together: every sweep scaled by `progress`, all opening
+ * from `startAngle` at once and keeping their true shares, until they close
+ * the circle at 1.
+ *
+ * @returns The slices with scaled angles; `index`, `value` and `fraction` unchanged.
+ * @category Math & helpers
+ */
+export declare function pieGrow(slices: readonly PieSlice[], progress: number): PieSlice[];
+/** @category Math */
+export interface SweepWedgeOptions extends PolarSweepOptions {
+    /** Centre. Defaults to the origin. */
+    center?: Point;
+    /** How far the wedge reaches; make it clear everything it uncovers. */
+    radius: number;
+}
+/**
+ * The wedge one angular sweep has uncovered, as a polygon from the centre:
+ * `progress` of a full turn from `startAngle`. A clip region for radial
+ * sweep reveals.
+ *
+ * @param progress - The sweep, 0..1.
+ * @returns The wedge, a lone centre point at 0, or undefined at `progress >= 1`.
+ * @category Math & helpers
+ */
+export declare function sweepWedge(progress: number, options: SweepWedgeOptions): Point[] | undefined;
+/** One slice of a ring on one frame: its angles, its share of the turn, and where that share starts. */
+export interface RingSlice {
+    /** Radians from +x. */
+    startAngle: number;
+    /** Radians from +x. */
+    endAngle: number;
+    /** Its share of the turn, 0..1. */
+    fraction: number;
+    /** The turn before it, 0..1 from `startAngle`. */
+    offset: number;
+}
+/**
+ * The order a ring lays out both ends' keys of a keyed transition so that
+ * nothing crosses: entering keys open beside the key they follow in `to`,
+ * leaving keys stay after the one they follow in `from`. When shared keys
+ * are reordered, they follow `follow`'s end and {@link ringLayout} blends.
+ *
+ * @param follow - Whose order the shared keys keep.
+ */
+export declare function ringOrder(from: readonly BandKey[], to: readonly BandKey[], follow: "from" | "to"): BandKey[];
+/**
+ * A ring of slices (a pie's, a rose's) laid out by weight in each end's
+ * {@link ringOrder}; when the orders differ, angles blend between the two
+ * layouts by `u`. Keys with no weight get a zero-sweep slice.
+ *
+ * @param weight - Each key's weight on this frame (negative and non-finite count as 0).
+ * @param u - The update stage's progress, 0..1.
+ * @returns Each key's slice; empty when no key has weight.
+ */
+export declare function ringLayout(orders: {
+    from: readonly BandKey[];
+    to: readonly BandKey[];
+}, weight: (key: BandKey) => number, u: number, options?: PieOptions): Map<BandKey, RingSlice>;
+/**
+ * How much of one slice a sweep has uncovered at `progress`, as {@link pieSweep}.
+ *
+ * @param progress - The sweep, 0..1 of a full turn.
+ */
+export declare function sweepShare(slice: {
+    offset: number;
+    fraction: number;
+}, progress: number): number;
+//# sourceMappingURL=pie.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pie.d.ts","sourceRoot":"","sources":["../../src/math/pie.ts"],"names":[],"mappings":"AAAA,sHAAsH;AAEtH,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGxD,qBAAqB;AACrB,MAAM,WAAW,QAAQ;IACxB,uFAAuF;IACvF,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,2FAA2F;IAC3F,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,qBAAqB;AACrB,MAAM,MAAM,UAAU,GAAG,iBAAiB,CAAC;AAE3C;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACxB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,UAAe,GACtB,QAAQ,EAAE,CAsBZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACvB,MAAM,EAAE,SAAS,QAAQ,EAAE,EAC3B,QAAQ,EAAE,MAAM,GACd,MAAM,EAAE,CASV;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CACtB,MAAM,EAAE,SAAS,QAAQ,EAAE,EAC3B,QAAQ,EAAE,MAAM,GACd,QAAQ,EAAE,CAOZ;AAED,qBAAqB;AACrB,MAAM,WAAW,iBAAkB,SAAQ,iBAAiB;IAC3D,sCAAsC;IACtC,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACzB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,iBAAiB,GACxB,KAAK,EAAE,GAAG,SAAS,CAerB;AAOD,wGAAwG;AACxG,MAAM,WAAW,SAAS;IACzB,uBAAuB;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,uBAAuB;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CACxB,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,EAAE,EAAE,SAAS,OAAO,EAAE,EACtB,MAAM,EAAE,MAAM,GAAG,IAAI,GACnB,OAAO,EAAE,CAmBX;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACzB,MAAM,EAAE;IAAE,IAAI,EAAE,SAAS,OAAO,EAAE,CAAC;IAAC,EAAE,EAAE,SAAS,OAAO,EAAE,CAAA;CAAE,EAC5D,MAAM,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,EAChC,CAAC,EAAE,MAAM,EACT,OAAO,GAAE,UAAe,GACtB,GAAG,CAAC,OAAO,EAAE,SAAS,CAAC,CAkCzB;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAC3C,QAAQ,EAAE,MAAM,GACd,MAAM,CAIR"}

package/dist/math/polarArea.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Polar area geometry: one wedge per value, the turn split evenly, each
+ * wedge's radius linear in its value.
+ */
+import type { PolarSweepOptions } from "./shared/polar";
+/** @category Math */
+export interface PolarAreaSlice {
+    /** Position in the input `values` array. */
+    index: number;
+    /** The (clamped) value this wedge represents. */
+    value: number;
+    /** Radians from +x, as `Sector`'s `startAngle`. */
+    startAngle: number;
+    /** Radians from +x; `endAngle - startAngle` is the signed sweep for `Sector`'s `angle`. */
+    endAngle: number;
+    /** `value / maxValue`, 0..1: the fraction of the outer radius this wedge reaches. */
+    radius: number;
+    /** `value / total`: this wedge's share of all values. */
+    fraction: number;
+}
+/** @category Math */
+export interface PolarAreaOptions extends PolarSweepOptions {
+    /** The value that reaches the outer radius. Defaults to the greatest finite value. */
+    maxValue?: number;
+}
+/**
+ * One wedge per value, each `2π / n` wide, its radius the value's share of
+ * `maxValue`. A zero still gets a wedge, so parallel `colors`/`labels` stay
+ * aligned.
+ *
+ * @param values - One value per wedge; negative and non-finite entries clamp to 0.
+ * @category Math & helpers
+ */
+export declare function polarAreaSlices(values: readonly number[], options?: PolarAreaOptions): PolarAreaSlice[];
+//# sourceMappingURL=polarArea.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polarArea.d.ts","sourceRoot":"","sources":["../../src/math/polarArea.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGxD,qBAAqB;AACrB,MAAM,WAAW,cAAc;IAC9B,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,2FAA2F;IAC3F,QAAQ,EAAE,MAAM,CAAC;IACjB,qFAAqF;IACrF,MAAM,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,qBAAqB;AACrB,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;IAC1D,sFAAsF;IACtF,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,gBAAqB,GAC5B,cAAc,EAAE,CAsBlB"}

package/dist/math/radar.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Radar geometry: one vertex per value, evenly spaced round a full turn by
+ * index, with the value mapped to radius.
+ */
+import type { BandKey, Point } from "@sophistry/core/geometry";
+import type { PolarSweepOptions } from "./shared/polar";
+/** @category Math */
+export interface RadarVertex extends Point {
+    /** Position in the input `values`, keeping per-axis labels aligned. */
+    index: number;
+    /** The (clamped) value this vertex represents. */
+    value: number;
+    /** Radians from +x this axis points along. */
+    angle: number;
+}
+/** @category Math */
+export interface RadarOptions extends PolarSweepOptions {
+    /**
+     * The value that reaches the outer radius. Pass it when overlaying several
+     * series so they share one scale. Defaults to the greatest finite value in `values`.
+     */
+    maxValue?: number;
+}
+/**
+ * One vertex per value on the unit circle, scaled by the value's share of
+ * `maxValue`, returned open (`<Polygon>` closes it). A zero still gets a
+ * vertex at the origin, keeping `index` aligned with the axis labels.
+ *
+ * @param values - One value per axis; negative and non-finite entries clamp to 0.
+ * @returns One {@link RadarVertex} per value; `[]` for fewer than 3 values.
+ * @category Math & helpers
+ */
+export declare function radarVertices(values: readonly number[], options?: RadarOptions): RadarVertex[];
+/**
+ * Checks that every non-empty group has exactly one value per axis label.
+ *
+ * @throws If a non-empty group's length differs from `axisLabels.length`.
+ */
+export declare function assertRadarShape(groups: readonly (readonly number[])[], axisLabels?: readonly string[]): void;
+/**
+ * One axis of a radar chart on one frame of a keyed transition between two
+ * axis sets. See {@link radarAxisFrames}.
+ *
+ * @category Math & helpers
+ */
+export interface RadarAxisFrame {
+    /** The axis's identity: its name, or its position when the axes are unnamed. */
+    key: BandKey;
+    /** Its place in the union of both ends' axes (`from`'s in order, then those only in `to`). */
+    slot: number;
+    /** Its index among `from`'s axes, or -1 when only `to` has it. */
+    from: number;
+    /** Its index among `to`'s axes, or -1 when only `from` has it (or without a `to`). */
+    to: number;
+    /** Whether both ends have it (always, without a `to`): it never folds away. */
+    anchor: boolean;
+    /** Radians from +x it points along on this frame. */
+    angle: number;
+    /** 0..1: how far it is unfolded (1 for an anchor, `1 − exit` leaving, `enter` arriving). */
+    weight: number;
+}
+/**
+ * Options for {@link radarAxisFrames}: the sweep, and each stage's progress.
+ *
+ * @category Math & helpers
+ */
+export interface RadarAxisFrameOptions extends PolarSweepOptions {
+    /** Progress of the exit stage, 0..1. */
+    exit?: number;
+    /** Progress of the update stage, 0..1. */
+    update?: number;
+    /** Progress of the enter stage, 0..1. */
+    enter?: number;
+}
+/**
+ * A radar chart's axes on one frame of a keyed transition between two axis
+ * sets, matched by name (or position). Axes in both ends turn the short way
+ * on the update stage; others fold away (exit) or unfold (enter) between
+ * their neighbours. All stages at 0 gives `from`'s axes, at 1 `to`'s.
+ *
+ * @param to - The axis keys at the end; undefined without a transition.
+ * @returns Every axis of either end, in drawing order.
+ * @category Math & helpers
+ */
+export declare function radarAxisFrames(from: readonly BandKey[], to: readonly BandKey[] | undefined, options?: RadarAxisFrameOptions): RadarAxisFrame[];
+/**
+ * A radar polygon over {@link radarAxisFrames}' axes, in unit-circle
+ * coordinates. A folding axis, or one with no value, pulls its vertex onto
+ * the chord between its neighbours, so corners grow out of or flatten into
+ * the edge; with every axis whole this is {@link radarVertices}' polygon.
+ *
+ * @param valueAt - The series' value on an axis, or undefined where it has none.
+ * @returns The vertices; `[]` for fewer than 3.
+ * @category Math & helpers
+ */
+export declare function radarFramePolygon(axes: readonly RadarAxisFrame[], valueAt: (axis: RadarAxisFrame) => number | undefined, maxValue: number): Point[];
+/**
+ * Where an axis name's box centre sits relative to its spoke's outer end, so
+ * the box clears the ring by `gap` with its inner side facing the chart.
+ * Alignment blends smoothly within 15° of vertical and horizontal, so names
+ * on turning axes move without jumps.
+ *
+ * @param angle - The spoke's angle, radians from +x (y up).
+ * @param size - The name's box, in the units of the result.
+ * @category Math & helpers
+ */
+export declare function radarLabelOffset(angle: number, size: {
+    width: number;
+    height: number;
+}, gap: number): Point;
+//# sourceMappingURL=radar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"radar.d.ts","sourceRoot":"","sources":["../../src/math/radar.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAG/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGxD,qBAAqB;AACrB,MAAM,WAAW,WAAY,SAAQ,KAAK;IACzC,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,8CAA8C;IAC9C,KAAK,EAAE,MAAM,CAAC;CACd;AAED,qBAAqB;AACrB,MAAM,WAAW,YAAa,SAAQ,iBAAiB;IACtD;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,YAAiB,GACxB,WAAW,EAAE,CAqBf;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACtC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,GAC5B,IAAI,CASN;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC9B,gFAAgF;IAChF,GAAG,EAAE,OAAO,CAAC;IACb,8FAA8F;IAC9F,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,sFAAsF;IACtF,EAAE,EAAE,MAAM,CAAC;IACX,+EAA+E;IAC/E,MAAM,EAAE,OAAO,CAAC;IAChB,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,4FAA4F;IAC5F,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,iBAAiB;IAC/D,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0CAA0C;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAUD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC9B,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,EAAE,EAAE,SAAS,OAAO,EAAE,GAAG,SAAS,EAClC,OAAO,GAAE,qBAA0B,GACjC,cAAc,EAAE,CA4FlB;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,SAAS,cAAc,EAAE,EAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,MAAM,GAAG,SAAS,EACrD,QAAQ,EAAE,MAAM,GACd,KAAK,EAAE,CAsDT;AAKD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACvC,GAAG,EAAE,MAAM,GACT,KAAK,CAQP"}

package/dist/math/range.d.ts

@@ -0,0 +1,99 @@
+/** Axis ranging for data plotted from raw values rather than a function. */
+import type { Range, ScaleName, TimeZone } from "@sophistry/core/geometry";
+/** @category Math */
+export interface AutoRangeOptions {
+    /** Roughly how many ticks the rounded range should offer. @default 5 */
+    targetTicks?: number;
+}
+/**
+ * Rounds a data span out to a whole number of nice steps, always including
+ * zero (an axis starting at 90 exaggerates differences). For charts whose
+ * caller gave no explicit range.
+ *
+ * @param values - The data the axis must cover; non-finite entries are ignored.
+ * @returns `[min, max, step]` containing 0; `[0, 1, 1]` when there is no spread.
+ * @category Math & helpers
+ */
+export declare function autoRange(values: readonly number[], options?: AutoRangeOptions): Range;
+/**
+ * Options for {@link fitRange}.
+ *
+ * @category Math & helpers
+ */
+export interface FitRangeOptions {
+    /**
+     * The scale the range is for, which decides what "round" means: a 1-2-5
+     * step for linear, sqrt and symlog, whole decades for log, calendar units
+     * for time and utc.
+     * @default "linear"
+     */
+    type?: ScaleName;
+    /**
+     * Stretch the range to include zero, for marks whose length encodes value
+     * (bars, areas, histograms). Ignored by log and time scales.
+     * @default false
+     */
+    zero?: boolean;
+    /**
+     * Round the ends out to tick values. `false` keeps the data's ends;
+     * `"tight"` rounds an end out only when the next tick is within a quarter
+     * step of the data (weeks 0–11 fit `[0, 11]`, not `[0, 15]`).
+     * @default true
+     */
+    nice?: boolean | "tight";
+    /** Roughly how many ticks the rounded range should offer. @default 5 */
+    targetTicks?: number;
+    /** Log base, when `type` is `"log"`. @default 10 */
+    base?: number;
+    /**
+     * The zone whose calendar a time range rounds to: an IANA name, `"UTC"` or
+     * `"local"`. Omitted, `"utc"` rounds in UTC and `"time"` in local time.
+     */
+    timeZone?: TimeZone;
+    /**
+     * Pad the data's extent by this fraction of its span on each side before
+     * rounding; a side pinned at zero by `zero` stays there. Ignored by log.
+     * @default 0
+     */
+    margin?: number;
+}
+/**
+ * The range an axis should span to show `values`: their extent, stretched to
+ * zero if asked, rounded out to ticks for the scale type. This is how
+ * `<Chart>` fits its axes. Non-finite values (and non-positive ones on a
+ * log scale) are ignored; one value or none still gets a usable span.
+ *
+ * @returns `[min, max, step]` on a nice linear-family range, `[min, max]` otherwise.
+ * @category Math & helpers
+ */
+export declare function fitRange(values: readonly number[], options?: FitRangeOptions): Range;
+/**
+ * Options for {@link alignedRange}.
+ *
+ * @category Math & helpers
+ */
+export interface AlignedRangeOptions {
+    /** Keep zero in range (bars, areas). @default false */
+    zero?: boolean;
+    /**
+     * Pad the data's extent by this fraction of its span first, as {@link FitRangeOptions.margin}.
+     * @default 0
+     */
+    margin?: number;
+    /** The two axes run opposite ways (one is reversed). @default false */
+    opposite?: boolean;
+}
+/**
+ * A secondary axis range whose ticks fall exactly where the primary's do,
+ * so one grid serves both: the same number of tick intervals, with the
+ * smallest nice step (1, 2, 2.5 or 5 × 10ⁿ) that covers `values`. Linear
+ * axes only.
+ *
+ * @param primary - The primary axis's range, `[min, max, step?]` (either order).
+ * @param primaryTicks - The primary's major tick values, evenly spaced (at least two).
+ * @param values - The data the secondary axis must show.
+ * @returns `[min, max, step]` ascending, or undefined when the primary has fewer than two ticks.
+ * @category Math & helpers
+ */
+export declare function alignedRange(primary: Range, primaryTicks: readonly number[], values: readonly number[], options?: AlignedRangeOptions): Range | undefined;
+//# sourceMappingURL=range.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../src/math/range.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAE5E,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAS3E,qBAAqB;AACrB,MAAM,WAAW,gBAAgB;IAChC,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACxB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,gBAAqB,GAC5B,KAAK,CAEP;AAED;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC/B;;;;;OAKG;IACH,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB;;;;OAIG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;OAKG;IACH,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC;IACzB,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CACvB,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,eAAoB,GAC3B,KAAK,CA4CP;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC,uDAAuD;IACvD,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAKD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC3B,OAAO,EAAE,KAAK,EACd,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,GAAE,mBAAwB,GAC/B,KAAK,GAAG,SAAS,CAkDnB"}