@svgrid/grid 3.0.2 → 3.0.4

package/dist/chart-scale.js

@@ -0,0 +1,405 @@
+// Number formatting lives in its own leaf (see chart-format.ts for why) and
+// is re-exported here so every importer of chart-scale keeps working.
+export { fmtTick, formatChartValue } from './chart-format.js';
+/** Series colours used when a {@link ChartSeries} sets none, in order. */
+export const DEFAULT_PALETTE = [
+    '#2563eb',
+    '#16a34a',
+    '#f59e0b',
+    '#ef4444',
+    '#8b5cf6',
+    '#0ea5e9',
+    '#ec4899',
+    '#14b8a6',
+];
+/** @internal Two-decimal rounding for SVG coordinates. */
+export function round(n) {
+    return Math.round(n * 100) / 100;
+}
+/** @internal Nice-number rounding used by niceScale. */
+export function niceNum(range, roundIt) {
+    if (range <= 0)
+        return 1;
+    const exp = Math.floor(Math.log10(range));
+    const f = range / Math.pow(10, exp);
+    let nf;
+    if (roundIt)
+        nf = f < 1.5 ? 1 : f < 3 ? 2 : f < 7 ? 5 : 10;
+    else
+        nf = f <= 1 ? 1 : f <= 2 ? 2 : f <= 5 ? 5 : 10;
+    return nf * Math.pow(10, exp);
+}
+// ---- Color helpers for heatmap / pattern fills ----------------------
+/** Built-in sequential ramp (light cyan -> deep blue), perception-friendly. */
+const SEQUENTIAL_STOPS = ['#eff6ff', '#bfdbfe', '#60a5fa', '#2563eb', '#1e3a8a'];
+/** Built-in diverging ramp (red -> neutral -> blue). Use for signed data. */
+const DIVERGING_STOPS = ['#b91c1c', '#fca5a5', '#f1f5f9', '#93c5fd', '#1d4ed8'];
+/** Dark-theme ramps. The low (sequential) / neutral (diverging) end sits just
+ *  above the dark grid surface instead of near-white, so empty / low cells read
+ *  as "cold" rather than as glaring white rectangles. */
+const SEQUENTIAL_STOPS_DARK = ['#1c2c4d', '#1d4ed8', '#3b82f6', '#60a5fa', '#bae6fd'];
+const DIVERGING_STOPS_DARK = ['#f87171', '#b91c1c', '#222b3d', '#1d4ed8', '#60a5fa'];
+/** @internal Pick the colour-ramp stops for a heatmap / calendar. */
+export function resolveColorScale(scale, vMin, vMax, theme = 'light') {
+    if (Array.isArray(scale) && scale.length >= 2)
+        return scale;
+    const dark = theme === 'dark';
+    if (scale === 'diverging' || (scale == null && vMin < 0 && vMax > 0)) {
+        return dark ? DIVERGING_STOPS_DARK : DIVERGING_STOPS;
+    }
+    return dark ? SEQUENTIAL_STOPS_DARK : SEQUENTIAL_STOPS;
+}
+/** Sample a hex color from an array of hex stops at fractional position t.
+ *  Linearly interpolates between the two nearest stops in RGB space. */
+export function sampleGradient(stops, t) {
+    if (!stops.length)
+        return '#888';
+    const clamped = Math.max(0, Math.min(1, t));
+    if (stops.length === 1)
+        return stops[0];
+    const pos = clamped * (stops.length - 1);
+    const i = Math.floor(pos);
+    const frac = pos - i;
+    const a = hexToRgb(stops[i]);
+    const b = hexToRgb(stops[Math.min(stops.length - 1, i + 1)]);
+    if (!a || !b)
+        return stops[i] ?? '#888';
+    const lerp = (x, y) => Math.round(x + (y - x) * frac);
+    const toHex = (n) => n.toString(16).padStart(2, '0');
+    return '#' + toHex(lerp(a.r, b.r)) + toHex(lerp(a.g, b.g)) + toHex(lerp(a.b, b.b));
+}
+function hexToRgb(hex) {
+    const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+    if (!m)
+        return null;
+    const n = parseInt(m[1], 16);
+    return { r: (n >> 16) & 255, g: (n >> 8) & 255, b: n & 255 };
+}
+/** Pick a black or white text color that has the better contrast against
+ *  the given background. Uses the WCAG relative-luminance heuristic. */
+export function pickContrastText(bgHex) {
+    const rgb = hexToRgb(bgHex);
+    if (!rgb)
+        return '#0f172a';
+    const lin = (c) => {
+        const s = c / 255;
+        return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+    };
+    const L = 0.2126 * lin(rgb.r) + 0.7152 * lin(rgb.g) + 0.0722 * lin(rgb.b);
+    return L > 0.5 ? '#0f172a' : '#ffffff';
+}
+/** Pick the largest power of 10 that fits at the bottom of [min,max], and
+ *  the smallest that covers the top, then enumerate decade boundaries. Used
+ *  by log-scale axes (yScale: 'log'). */
+export function niceLogScale(min, max) {
+    // Only positive values are plottable on a log scale; callers should
+    // strip non-positive values before passing them in.
+    if (!Number.isFinite(min) || min <= 0)
+        min = 1;
+    if (!Number.isFinite(max) || max <= min)
+        max = min * 10;
+    const lo = Math.floor(Math.log10(min));
+    const hi = Math.ceil(Math.log10(max));
+    const ticks = [];
+    for (let p = lo; p <= hi; p += 1)
+        ticks.push(Math.pow(10, p));
+    return { min: Math.pow(10, lo), max: Math.pow(10, hi), step: 10, ticks };
+}
+/**
+ * @internal Tick values for a logarithmic axis between two positive bounds:
+ * every decade, plus the 2 and 5 of each decade when the range spans fewer
+ * than three, so a two-decade axis does not read as three lonely labels.
+ */
+export function logTicks(min, max) {
+    if (!(min > 0) || !(max > min))
+        return [];
+    const lo = Math.floor(Math.log10(min));
+    const hi = Math.ceil(Math.log10(max));
+    const minors = hi - lo < 3 ? [2, 5] : [];
+    const out = [];
+    for (let p = lo; p <= hi; p += 1) {
+        const d = Math.pow(10, p);
+        for (const m of [1, ...minors]) {
+            const v = d * m;
+            if (v >= min * 0.999 && v <= max * 1.001)
+                out.push(v);
+        }
+    }
+    return out;
+}
+/** @internal Map a value to a fractional position [0..1] across the axis domain.
+ *  Pass the appropriate fn into projection code so linear / log share the
+ *  same plumbing. Returns null for non-positive values on log. */
+export function project(value, min, max, isLog) {
+    if (!Number.isFinite(value))
+        return null;
+    if (isLog) {
+        if (value <= 0 || min <= 0)
+            return null;
+        return (Math.log10(value) - Math.log10(min)) / (Math.log10(max) - Math.log10(min));
+    }
+    return (value - min) / (max - min);
+}
+/** Round a [min,max] domain out to nice tick boundaries. */
+export function niceScale(min, max, tickCount = 4) {
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+        min = 0;
+        max = 1;
+    }
+    if (min === max) {
+        if (min === 0)
+            max = 1;
+        else {
+            min = Math.min(0, min);
+            max = Math.max(0, max);
+        }
+        if (min === max)
+            max = min + 1;
+    }
+    const range = niceNum(max - min, false);
+    const step = niceNum(range / Math.max(1, tickCount), true);
+    const nMin = Math.floor(min / step) * step;
+    const nMax = Math.ceil(max / step) * step;
+    const ticks = [];
+    for (let v = nMin; v <= nMax + step * 0.5; v += step)
+        ticks.push(round(v));
+    return { min: nMin, max: nMax, step, ticks };
+}
+/**
+ * A value-axis domain that honours an axis config on top of the data extent:
+ * a pinned `min` / `max` (hard edges - marks past them are clipped), an exact
+ * `tickInterval`, a `tickCount`, and `nice: false` for the raw extent with
+ * evenly spaced ticks. With no config this is exactly {@link niceScale}.
+ */
+export function axisScale(dataMin, dataMax, axis = {}) {
+    let min = axis.min ?? dataMin;
+    let max = axis.max ?? dataMax;
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+        min = Number.isFinite(min) ? min : 0;
+        max = Number.isFinite(max) ? max : min + 1;
+    }
+    const nice = axis.nice !== false;
+    const interval = axis.tickInterval;
+    if (interval && interval > 0 && Number.isFinite(interval)) {
+        // An explicit interval is the whole axis: the ends land on multiples of it
+        // (unless pinned) and every tick is one interval apart.
+        if (nice && axis.min == null)
+            min = Math.floor(min / interval) * interval;
+        if (nice && axis.max == null)
+            max = Math.ceil(max / interval) * interval;
+        if (max <= min)
+            max = min + interval;
+        const ticks = [];
+        const first = Math.ceil(min / interval - 1e-9) * interval;
+        // Cap the count so a tiny interval on a huge domain cannot hang the layout.
+        // `+ 0` turns the -0 that `Math.ceil` hands back at the origin into a plain 0.
+        for (let v = first, n = 0; v <= max + interval * 1e-6 && n < 1000; v += interval, n += 1)
+            ticks.push(round(v) + 0);
+        return { min, max, step: interval, ticks };
+    }
+    if (nice) {
+        const ns = niceScale(min, max, axis.tickCount ?? 4);
+        if (axis.min == null && axis.max == null)
+            return ns;
+        // A pinned end wins over the rounding, and ticks past it go.
+        const lo = axis.min ?? ns.min;
+        const hi = axis.max ?? ns.max;
+        return { min: lo, max: hi, step: ns.step, ticks: ns.ticks.filter((t) => t >= lo - 1e-9 && t <= hi + 1e-9) };
+    }
+    if (max <= min)
+        max = min + 1;
+    const n = Math.max(1, Math.round(axis.tickCount ?? 4));
+    const step = (max - min) / n;
+    const ticks = Array.from({ length: n + 1 }, (_, i) => round(min + step * i));
+    return { min, max, step, ticks };
+}
+/** @internal One day in milliseconds. */
+export const DAY = 86400000;
+/**
+ * @internal Calendar-aligned tick timestamps across [min, max], at most about
+ * `target` of them.
+ *
+ * The unit is the finest of day, week (Mondays), month, quarter, year and
+ * multiples of years whose count fits the target, and every tick sits on a
+ * calendar boundary in UTC (the axis parses 'YYYY-MM-DD' categories as UTC
+ * midnight). The old version stepped a fixed 30 or 365 days from the epoch,
+ * so a tick labelled "2025" stood weeks away from New Year and a thirty-month
+ * axis carried two labels on a plot with room for eight.
+ */
+export function dateTicks(tMin, tMax, target = 6) {
+    if (!(tMax > tMin))
+        return [tMin];
+    // A little over the target beats dropping to the next unit, which halves
+    // or thirds the count: ten quarters on a plot with room for nine.
+    const want = Math.max(2, target) * 1.3;
+    const span = tMax - tMin;
+    // Steps as [days, months]: a year is twelve months, so multiples of twelve
+    // land on the first of January.
+    const steps = [[1, 0], [2, 0], [7, 0], [14, 0], [0, 1], [0, 3], [0, 6], [0, 12], [0, 24], [0, 60], [0, 120]];
+    let [d, m] = steps[steps.length - 1];
+    for (const [sd, sm] of steps) {
+        if (span / (sd * DAY + sm * 30.44 * DAY) <= want) {
+            d = sd;
+            m = sm;
+            break;
+        }
+    }
+    const from = new Date(tMin);
+    const out = [];
+    if (d) {
+        let t = Date.UTC(from.getUTCFullYear(), from.getUTCMonth(), from.getUTCDate());
+        // Weekly steps sit on Mondays; UTC day 0 is Sunday.
+        if (d >= 7)
+            t += ((8 - new Date(t).getUTCDay()) % 7) * DAY;
+        while (t < tMin)
+            t += d * DAY;
+        for (; t <= tMax + 1; t += d * DAY)
+            out.push(t);
+    }
+    else {
+        let months = Math.ceil((from.getUTCFullYear() * 12 + from.getUTCMonth()) / m) * m;
+        const at = (mo) => Date.UTC(Math.floor(mo / 12), mo % 12, 1);
+        if (at(months) < tMin)
+            months += m;
+        for (let t = at(months); t <= tMax + 1; months += m, t = at(months))
+            out.push(t);
+    }
+    return out.length < 2 ? [tMin, tMax] : out;
+}
+/**
+ * Tick positions for an ordinal (evenly spaced) date axis, as INDICES into
+ * `times`.
+ *
+ * A time axis can put a tick anywhere, because x is a function of the
+ * timestamp. An ordinal axis cannot: x is a function of the index, so a tick
+ * has to land on a point that exists. This picks the first point of each
+ * calendar unit - day, week, month, year, whichever gets closest to `target`
+ * ticks without going over - so labels sit on real sessions and a weekend or a
+ * holiday never stretches the spacing.
+ */
+export function ordinalDateTicks(times, target = 6) {
+    if (times.length <= 1)
+        return times.length ? [0] : [];
+    const keyOf = {
+        day: (d) => `${d.getUTCFullYear()}-${d.getUTCMonth()}-${d.getUTCDate()}`,
+        // Weeks start on Monday: day 0 of the epoch was a Thursday, so +3 puts
+        // the boundary there (+4 put it on Sunday, and weekly ticks sat on Sundays).
+        week: (d) => Math.floor((Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()) / DAY + 3) / 7),
+        month: (d) => `${d.getUTCFullYear()}-${d.getUTCMonth()}`,
+        year: (d) => d.getUTCFullYear(),
+    };
+    let chosen = null;
+    for (const unit of ['day', 'week', 'month', 'year']) {
+        const at = [];
+        let prev = null;
+        for (let i = 0; i < times.length; i += 1) {
+            const t = times[i];
+            if (!Number.isFinite(t))
+                continue;
+            const k = keyOf[unit](new Date(t));
+            if (k !== prev)
+                at.push(i);
+            prev = k;
+        }
+        chosen = at;
+        if (at.length <= target * 2)
+            break;
+    }
+    let out = chosen ?? [];
+    // Even the coarsest unit can be too dense (a decade of yearly points), and a
+    // single trading day yields one boundary. Thin, or fall back to plain strides.
+    if (out.length > target) {
+        const stride = Math.ceil(out.length / target);
+        out = out.filter((_, i) => i % stride === 0);
+    }
+    if (out.length < 2) {
+        const stride = Math.max(1, Math.ceil(times.length / target));
+        out = times.map((_, i) => i).filter((i) => i % stride === 0);
+    }
+    return out;
+}
+/** @internal Date label sized to the gap between ticks: days and weeks read
+ *  "Jan 5", months and quarters "Jun 25", years "2025". Read in UTC: the axis
+ *  parses 'YYYY-MM-DD' as UTC midnight, and a local-time read of that in the
+ *  Americas labelled every tick with the day before. Sized to the tick step
+ *  rather than the axis span, so a thirty-month axis on quarters does not
+ *  read "2024, 2024, 2024, 2025". */
+export function fmtDate(t, step) {
+    const d = new Date(t);
+    if (step < 28 * DAY)
+        return d.toLocaleDateString(undefined, { month: 'short', day: 'numeric', timeZone: 'UTC' });
+    if (step < 360 * DAY)
+        return d.toLocaleDateString(undefined, { month: 'short', year: '2-digit', timeZone: 'UTC' });
+    return String(d.getUTCFullYear());
+}
+/**
+ * @internal A category on a date axis, written out for a tooltip or a
+ * crosshair pill: "Jun 2025" when every category is the first of a month,
+ * "2025" when every one is New Year, otherwise "Jun 1, 2025". `grain` is
+ * what {@link dateGrain} found for the axis.
+ */
+export function fmtDateFull(t, grain = 'day') {
+    const d = new Date(t);
+    if (grain === 'year')
+        return String(d.getUTCFullYear());
+    if (grain === 'month')
+        return d.toLocaleDateString(undefined, { month: 'short', year: 'numeric', timeZone: 'UTC' });
+    return d.toLocaleDateString(undefined, { year: 'numeric', month: 'short', day: 'numeric', timeZone: 'UTC' });
+}
+/** @internal The calendar grain a list of UTC timestamps sits on. */
+export function dateGrain(times) {
+    let month = true, year = true, any = false;
+    for (const t of times) {
+        if (!Number.isFinite(t))
+            continue;
+        any = true;
+        const d = new Date(t);
+        if (d.getUTCDate() !== 1 || d.getUTCHours() !== 0) {
+            month = false;
+            year = false;
+            break;
+        }
+        if (d.getUTCMonth() !== 0)
+            year = false;
+    }
+    return !any ? 'day' : year ? 'year' : month ? 'month' : 'day';
+}
+/**
+ * @internal Category-axis labels, thinned so they do not overlap.
+ *
+ * A category axis used to emit one tick per category however many there were.
+ * At 5000 categories that is 5000 `<text>` nodes stacked into an unreadable
+ * grey band - the labels were the single biggest thing the renderer had to put
+ * in the DOM, and none of them could be read. The time and ordinal-time axes
+ * already thinned themselves (`dateTicks` / `ordinalDateTicks`); this brings
+ * the plain category axis in line.
+ *
+ * The first category always gets a label, so a thinned axis still starts where
+ * the data does.
+ */
+export function thinCategoryTicks(categories, xCenter, slot, rotated) {
+    // Rotated labels run diagonally and pack far tighter than upright ones. 18px
+    // is deliberately just under the spacing a 40-category chart at 800px already
+    // had, so charts that read fine before are untouched and only genuinely
+    // overlapping axes get thinned.
+    const minPx = rotated ? 18 : 60;
+    const step = Math.max(1, Math.ceil(minPx / Math.max(slot, 0.001)));
+    const out = [];
+    for (let i = 0; i < categories.length; i += step)
+        out.push({ label: categories[i], x: xCenter(i) });
+    return out;
+}
+/** @internal Normalize one `errors` entry to an absolute low/high pair around `value`. */
+export function errorSpan(e, value) {
+    if (e == null)
+        return null;
+    if (typeof e === 'number') {
+        if (!Number.isFinite(e))
+            return null;
+        const m = Math.abs(e);
+        return { lo: value - m, hi: value + m };
+    }
+    if (!Number.isFinite(e.lo) || !Number.isFinite(e.hi))
+        return null;
+    return { lo: Math.min(e.lo, e.hi), hi: Math.max(e.lo, e.hi) };
+}

package/dist/chart-stats.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Statistics the chart engine computes from raw values: five-number summaries,
+ * regression and moving-average overlays. DOM-free, spec-free.
+ */
+import type { BoxStats, ChartReducer } from './chart-types.js';
+export { linearTrend, pearson } from './chart-trend.js';
+/**
+ * Five-number summary of a raw sample, with the 1.5 IQR whisker rule.
+ *
+ * Whiskers stop at the last observation INSIDE the fence rather than at the
+ * fence itself, which is what makes them read as real data; anything past them
+ * comes back in `outliers`. Quartiles use linear interpolation between the two
+ * neighbouring order statistics.
+ *
+ * Returns `null` for an empty sample, so a category with no observations is a
+ * gap rather than a box drawn at zero.
+ */
+export declare function boxStats(sample: ReadonlyArray<number>, whisker?: number): BoxStats | null;
+/**
+ * A regression's result: the fitted value at every index (NaN where the
+ * source was non-finite or the model cannot take the value), R-squared
+ * against the finite source values, the equation, and `predict`, the model
+ * at any x. With no `xs` the x of a value is its index, which is what a
+ * category chart's overlay wants; a scatter passes its points' x values, so
+ * the fit is y on x and `predict` draws the curve across the plot.
+ */
+export type RegressionFit = {
+    fitted: number[];
+    r2: number;
+    equation: string;
+    predict: (x: number) => number;
+};
+/** R-squared of a fit: 1 minus residual over total variance across the
+ *  indices where both the value and the fit are finite. 0 when there is no
+ *  variance to explain. */
+export declare function rSquared(values: ReadonlyArray<number>, fitted: ReadonlyArray<number>): number;
+/**
+ * Least-squares polynomial of `degree` (clamped to 1..6) through
+ * (x, values[i]), x the index or the caller's `xs`. The x values are
+ * normalised to [-1, 1] before the normal equations are solved, so a
+ * degree-6 fit over a thousand points does not lose the low coefficients to
+ * rounding. Non-finite values are skipped and fitted as NaN.
+ */
+export declare function polynomialFit(values: ReadonlyArray<number>, degree: number, xs?: ReadonlyArray<number>): RegressionFit;
+/** Ordinary least squares of values on their index, or on `xs`, as a {@link RegressionFit}. */
+export declare function linearFit(values: ReadonlyArray<number>, xs?: ReadonlyArray<number>): RegressionFit;
+/** Fit y = a * e^(b x) by least squares on ln y, x the index or `xs`;
+ *  values at or below zero cannot be logged and are skipped (fitted as NaN). */
+export declare function exponentialFit(values: ReadonlyArray<number>, xs?: ReadonlyArray<number>): RegressionFit;
+/** Fit y = a + b ln(x + 1) by least squares (x the index, shifted by one so
+ *  the first point has a logarithm), or y = a + b ln(x) on `xs`, where
+ *  points with x at or below zero are skipped. */
+export declare function logarithmicFit(values: ReadonlyArray<number>, xs?: ReadonlyArray<number>): RegressionFit;
+/** Fit y = a (x + 1)^b by least squares on ln y against ln(x + 1), or
+ *  y = a x^b on `xs`; values (and x on `xs`) at or below zero are skipped
+ *  (fitted as NaN). */
+export declare function powerFit(values: ReadonlyArray<number>, xs?: ReadonlyArray<number>): RegressionFit;
+/** Simple moving average over a window of `period` values. Window centres
+ *  trail to the right (typical for time-series). NaN for points before the
+ *  window is full. */
+export declare function simpleMovingAverage(values: number[], period: number): number[];
+/** Exponential moving average. Smoothing factor alpha = 2 / (period + 1). */
+export declare function exponentialMovingAverage(values: number[], period: number): number[];
+/** The reducers that need every observation, not a running sum and count. */
+export declare function reducerNeedsSamples(reducer: ChartReducer): boolean;
+/**
+ * Collapse a group's observations to one number. `sum` / `avg` / `count` are
+ * what `rowsToChartSpec` always did; the rest are the ones a pivot table
+ * offers and a chart panel was missing: `min`, `max`, `median`, `first`,
+ * `last`, `countDistinct`, and `pN` for the Nth percentile (`'p90'`). An
+ * empty group reduces to 0 for `sum` / `count` and to NaN otherwise, so a
+ * missing bucket draws as a gap rather than as a fake zero.
+ */
+export declare function reduceValues(samples: ReadonlyArray<number>, reducer: ChartReducer): number;
+/** The p-th percentile (0..100) by linear interpolation between order statistics. */
+export declare function percentile(samples: ReadonlyArray<number>, p: number): number;
+/** How `rowsToChartSpec` groups dates when `bucket` is set. */
+export type ChartTimeBucket = 'day' | 'week' | 'month' | 'quarter' | 'year';
+/**
+ * The ISO date (`YYYY-MM-DD`, UTC) that starts the bucket containing `date`:
+ * the day itself, the Monday of its week, the first of its month, quarter or
+ * year. Returns `''` for a value that is not a date, so the caller can drop
+ * the row rather than file it under 1970.
+ */
+export declare function bucketStart(date: string | number | Date, bucket: ChartTimeBucket): string;
+/** What {@link binValues} returns: one category per bin plus the edges. */
+export type ChartBins = {
+    /** Bin midpoints as strings, ready to be the categories of a numeric axis. */
+    categories: string[];
+    /** Observations per bin. */
+    counts: number[];
+    /** Bin edges, one more than there are bins. */
+    edges: number[];
+    /** Width of every bin. */
+    width: number;
+};
+/**
+ * Bin a raw sample for a histogram. The bin count comes from `bins`, from a
+ * `binWidth`, or from a rule: `'sturges'` (default, log2 n + 1), `'fd'`
+ * (Freedman-Diaconis, 2 IQR / cbrt n) or `'sqrt'`. The range is the data's
+ * extent unless `min` / `max` pin it; the top edge is inclusive. Edges are
+ * rounded to a sensible precision for the width, so labels read as `10, 20,
+ * 30` rather than `10.000000001`.
+ */
+export declare function binValues(values: ReadonlyArray<number>, opts?: {
+    bins?: number;
+    binWidth?: number;
+    method?: 'sturges' | 'fd' | 'sqrt';
+    min?: number;
+    max?: number;
+}): ChartBins;