@abdullahjaswal/tickyr-charts-solid 0.1.0

package/dist/charts/sankey-chart-controller.d.ts

@@ -0,0 +1,176 @@
+import { Personalization, ThemeInput, VisualStyle, Theme, NodeAlignment, SankeyLinkColorInput, SankeyValueDisplayInput, LabelPlacement, LabelContentInput, TreemapColorScale, ChartFormatter, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat } from '../personalization';
+import { CrosshairMarker } from '../rendering/draw/crosshair';
+import { GridStyle } from '../rendering/draw/grid';
+import { SankeyGraph, SankeyInput } from './sankey-layout';
+export type { SankeyInput, SankeyNodeInput, SankeyLinkInput, } from './sankey-layout';
+export interface SankeyChartTooltipProps {
+    readonly target: {
+        kind: "node";
+        idx: number;
+        id: string;
+        name: string;
+        value: number;
+    } | {
+        kind: "link";
+        idx: number;
+        sourceId: string;
+        targetId: string;
+        value: number;
+    };
+    readonly color: string;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: import('../personalization').Theme;
+    readonly palette: import('../personalization').Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+export interface SankeyChartBaseProps {
+    /** Flow data - `{ nodes: [{name}], links: [{source, target, value}] }`.
+     *  Sankey renders nodes as bars and links as proportional flow ribbons. */
+    data?: SankeyInput;
+    /** Default 'justify'. */
+    nodeAlignment?: NodeAlignment;
+    /** Default 8. */
+    nodePadding?: number;
+    /** Default 16. */
+    nodeWidth?: number;
+    /** Default 0.45. */
+    linkOpacity?: number;
+    /** Default 'source'. */
+    linkColor?: SankeyLinkColorInput;
+    /** Default 6. */
+    iterations?: number;
+    /** Default 'auto'. */
+    labelPosition?: LabelPlacement;
+    /** Default 'name + value'. */
+    labelContent?: LabelContentInput;
+    /** Default false. */
+    valueDisplay?: SankeyValueDisplayInput;
+    /** Default 'flat-categorical'. */
+    colorScale?: TreemapColorScale;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: import('../personalization/axes/glow').GlowInput;
+    glowColor?: import('../personalization/axes/glow').GlowColorInput;
+    /** Pattern fills. */
+    pattern?: import('../personalization/axes/pattern').PatternInput;
+    patternScale?: number;
+    patternColor?: import('../personalization/axes/pattern').PatternColorInput;
+    ariaLabel?: string;
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    cornerRadius?: number;
+    borderWidth?: number;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+export interface SankeyChartProviderSnapshot {
+    theme: ThemeInput;
+    palette: string;
+    locale: string;
+    timeZone: string | undefined;
+    visualStyle: VisualStyle;
+    outlineFillColor: "auto" | string;
+    outlineFillOpacity: number;
+    cornerRadius: number;
+    borderWidth: number;
+    accents: boolean;
+    osTheme: Theme;
+    appTheme: Theme;
+}
+export interface SankeyChartRenderContext {
+    personalization: Personalization;
+    formatter: ChartFormatter;
+    resolvedLocaleBase: string;
+    resolvedTimeZone: string | undefined;
+    graph: SankeyGraph;
+    ariaLabel: string;
+    cssWidth: number;
+    cssHeight: number;
+}
+export interface HoverState {
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly target: {
+        kind: "node";
+        idx: number;
+        id: string;
+        name: string;
+        value: number;
+    } | {
+        kind: "link";
+        idx: number;
+        sourceId: string;
+        targetId: string;
+        value: number;
+    };
+    readonly color: string;
+}
+export interface SankeyChartControllerProps extends SankeyChartBaseProps {
+    tooltip?: undefined | false | ((p: SankeyChartTooltipProps) => unknown);
+}
+export interface SankeyChartControllerCallbacks {
+    onContextChange(ctx: SankeyChartRenderContext): void;
+    onHoverChange(hover: HoverState | null): void;
+}
+export interface SankeyChartControllerMountOptions extends SankeyChartControllerCallbacks {
+    container?: HTMLElement | null;
+    staticCanvas: HTMLCanvasElement;
+    dynamicCanvas: HTMLCanvasElement | null;
+    initialProps: SankeyChartControllerProps;
+    initialProvider: SankeyChartProviderSnapshot;
+}
+export declare class SankeyChartController {
+    private staticCanvas;
+    private dynamicCanvas;
+    private callbacks;
+    private props;
+    private providerCtx;
+    private handle;
+    private dynCfg;
+    private graph;
+    private personalization;
+    private resolvedLocale;
+    private formatter;
+    private resolvedNodeAlignment;
+    private resolvedLinkColor;
+    private resolvedValueDisplay;
+    private resolvedLabelPosition;
+    private resolvedLabelContent;
+    private resolvedColorScale;
+    private nodeColors;
+    private staticDrawAbort;
+    private disposed;
+    private visGate;
+    constructor(opts: SankeyChartControllerMountOptions);
+    update(props: SankeyChartControllerProps, providerCtx: SankeyChartProviderSnapshot): void;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerLeave(): void;
+    dispose(): void;
+    private setHover;
+    private resolveDerived;
+    private applyDynamicCfgFromProps;
+    private runStaticDraw;
+}

package/dist/charts/sankey-layout.d.ts

@@ -0,0 +1,64 @@
+import { NodeAlignment } from '../personalization/axes/node-alignment';
+export declare class SankeyCycleError extends Error {
+    readonly name = "SankeyCycleError";
+}
+export interface SankeyNodeInput {
+    readonly id: string;
+    readonly name?: string;
+    readonly color?: string;
+    readonly label?: string;
+}
+export interface SankeyLinkInput {
+    readonly source: string | number;
+    readonly target: string | number;
+    readonly value: number;
+    readonly color?: string;
+    readonly opacity?: number;
+}
+export interface SankeyInput {
+    readonly nodes: readonly SankeyNodeInput[];
+    readonly links: readonly SankeyLinkInput[];
+}
+export interface SankeyGraph {
+    readonly nodeCount: number;
+    readonly linkCount: number;
+    readonly nodeIds: readonly string[];
+    readonly nodeNames: readonly string[];
+    readonly nodeColorOverrides: readonly (string | null)[];
+    readonly nodeLabelOverrides: readonly (string | null)[];
+    /** Per-node aggregate value = max(incoming, outgoing). */
+    readonly nodeValues: Float64Array;
+    /** Per-node depth (root = 0). */
+    readonly depths: Int32Array;
+    readonly maxDepth: number;
+    readonly linkSources: Int32Array;
+    readonly linkTargets: Int32Array;
+    readonly linkValues: Float64Array;
+    readonly linkColorOverrides: readonly (string | null)[];
+    readonly linkOpacityOverrides: Float64Array;
+}
+export declare function ingestSankey(input: SankeyInput): SankeyGraph;
+export interface SankeyLayoutOptions {
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+    readonly nodeWidth: number;
+    readonly nodePadding: number;
+    readonly alignment: NodeAlignment;
+    /** Crossing-minimization passes. 6 is a good default. */
+    readonly iterations: number;
+}
+export interface SankeyLayoutResult {
+    readonly nodeX0: Float64Array;
+    readonly nodeY0: Float64Array;
+    readonly nodeX1: Float64Array;
+    readonly nodeY1: Float64Array;
+    /** Per-link source-y bounds (top, bottom of the band as it leaves the source). */
+    readonly linkSourceY0: Float64Array;
+    readonly linkSourceY1: Float64Array;
+    /** Per-link target-y bounds. */
+    readonly linkTargetY0: Float64Array;
+    readonly linkTargetY1: Float64Array;
+}
+export declare function layoutSankey(g: SankeyGraph, opts: SankeyLayoutOptions): SankeyLayoutResult;

package/dist/charts/scatter-chart-controller.d.ts

@@ -0,0 +1,90 @@
+import { Personalization, ThemeInput, VisualStyle, ChartFormatter, Theme, ResolvedPointSize, ResolvedRegressionLine } from '../personalization';
+import { ResolvedMarkerConfig } from '../personalization/axes/point-markers';
+import { HoverState, ResolvedScatterSeries, ScatterChartBaseProps, ScatterChartTooltipProps } from './scatter-chart-helpers';
+/** Provider snapshot - same shape contract as BarChart's. */
+export interface ScatterChartProviderSnapshot {
+    theme: ThemeInput;
+    palette: string;
+    locale: string;
+    timeZone: string | undefined;
+    visualStyle: VisualStyle;
+    outlineFillColor: "auto" | string;
+    outlineFillOpacity: number;
+    cornerRadius: number;
+    borderWidth: number;
+    accents: boolean;
+    osTheme: Theme;
+    appTheme: Theme;
+}
+/** Snapshot of derived state the adapter renders into JSX. */
+export interface ScatterChartRenderContext {
+    personalization: Personalization;
+    formatter: ChartFormatter;
+    resolvedLocaleBase: string;
+    resolvedTimeZone: string | undefined;
+    /** Primary + secondary series, each with its resolved color + bubble radii. */
+    seriesList: readonly ResolvedScatterSeries[];
+    resolvedPointSize: ResolvedPointSize;
+    resolvedRegression: ResolvedRegressionLine | null;
+    resolvedMarker: ResolvedMarkerConfig | null;
+    pointAlpha: number;
+    isHeatmap: boolean;
+    ariaLabel: string;
+    isSparkline: boolean;
+    cssWidth: number;
+    cssHeight: number;
+}
+export interface ScatterChartControllerCallbacks {
+    onContextChange(ctx: ScatterChartRenderContext): void;
+    onHoverChange(hover: HoverState | null): void;
+}
+export interface ScatterChartControllerProps extends ScatterChartBaseProps {
+    tooltip?: undefined | false | ((p: ScatterChartTooltipProps) => unknown);
+}
+export interface ScatterChartControllerMountOptions extends ScatterChartControllerCallbacks {
+    container?: HTMLElement | null;
+    staticCanvas: HTMLCanvasElement;
+    dynamicCanvas: HTMLCanvasElement | null;
+    initialProps: ScatterChartControllerProps;
+    initialProvider: ScatterChartProviderSnapshot;
+}
+export declare class ScatterChartController {
+    private staticCanvas;
+    private dynamicCanvas;
+    private callbacks;
+    private props;
+    private providerCtx;
+    private handle;
+    private hoverState;
+    private dynCfg;
+    private seriesList;
+    private personalization;
+    private resolvedLocale;
+    private formatter;
+    private resolvedPointSize;
+    private resolvedMarker;
+    private pointAlpha;
+    private resolvedRegression;
+    private regressionPoly;
+    private isHeatmap;
+    private densityGrid;
+    private isSparkline;
+    private flatSeriesIdx;
+    private flatPointIdx;
+    private quadtree;
+    private quadtreePending;
+    private staticDrawAbort;
+    private disposed;
+    private visGate;
+    constructor(opts: ScatterChartControllerMountOptions);
+    update(props: ScatterChartControllerProps, providerCtx: ScatterChartProviderSnapshot): void;
+    handlePointerMove(e: PointerEvent): void;
+    handlePointerLeave(): void;
+    dispose(): void;
+    private totalPointCount;
+    private setHover;
+    private resolveDerived;
+    private applyDynamicCfgFromProps;
+    private runStaticDraw;
+    private refreshQuadtree;
+}

package/dist/charts/scatter-chart-helpers.d.ts

@@ -0,0 +1,257 @@
+import { Personalization, ThemeInput, DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat, LegendPosition, LegendVisibility, ResolvedPointSize, ResolvedRegressionLine, PointSizeInput, PointOpacityInput, RegressionLineInput, DensityInput, ChartFormatter } from '../personalization';
+import { Viewport } from '../viewport/viewport-sizer';
+import { LinearScale } from '../viewport/scales/linear';
+import { NiceTick } from '../viewport/nice-ticks';
+import { YAxisPosition, XAxisPosition } from '../rendering/draw/axis';
+import { GridStyle } from '../rendering/draw/grid';
+import { CrosshairMarker } from '../rendering/draw/crosshair';
+import { ResolvedMarkerConfig, PointMarkers } from '../personalization/axes/point-markers';
+export interface ScatterPoint {
+    readonly x: number;
+    readonly y: number;
+    /** Optional 3rd dimension - only consumed when `pointSize` is data-driven. */
+    readonly size?: number;
+}
+/** AoS or SoA - host picks. SoA is zero-copy on ingest. */
+export type ScatterSeriesInput = {
+    readonly points: readonly ScatterPoint[];
+} | {
+    readonly xs: Float64Array;
+    readonly ys: Float64Array;
+    readonly sizes?: Float64Array;
+};
+/** Internal SoA aggregate. `sizes` is null when data-driven sizing is
+ *  unused - the draw path checks `null` once and falls through to the
+ *  fixed-size path. */
+export declare class ScatterSeries {
+    #private;
+    readonly xs: Float64Array;
+    readonly ys: Float64Array;
+    readonly sizes: Float64Array | null;
+    readonly length: number;
+    constructor(xs: Float64Array, ys: Float64Array, sizes: Float64Array | null);
+    get revisionId(): number;
+    bumpRevision(): number;
+}
+export declare function ingestScatterSeries(input: ScatterSeriesInput): ScatterSeries;
+export interface ScatterChartTooltipProps {
+    /** X-coordinate of the hovered point. */
+    readonly x: number;
+    /** Y-coordinate of the hovered point. */
+    readonly y: number;
+    /** Optional size value (when `pointSize` is data-driven). */
+    readonly size: number | null;
+    /** Index into the hovered series. */
+    readonly idx: number;
+    /** Index into the chart's series list (0 = primary, ≥1 = secondaries). */
+    readonly seriesIdx: number;
+    /** Series id (from `series[i].id`, or `'primary'` when only `data` was passed). */
+    readonly seriesId: string;
+    /** Series display label (`series[i].label ?? id`, or `'Value'` for primary-only). */
+    readonly seriesLabel: string;
+    /** Resolved CSS color for this series (categorical[i] cycling already applied). */
+    readonly seriesColor: string;
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    readonly theme: import('../personalization').Theme;
+    readonly palette: import('../personalization').Palette;
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+    readonly formatter: ChartFormatter;
+}
+/** Multi-series ScatterChart entry. Always supported.
+ *  Without per-series `color`, the lib auto-cycles `palette.categorical[i]`. */
+export interface ScatterSeriesConfig {
+    readonly id: string;
+    readonly data: ScatterSeriesInput;
+    readonly label?: string;
+    readonly color?: string;
+}
+export interface ScatterChartBaseProps {
+    /** Single-series point data - `xs` + `ys` + optional `sizes`. */
+    data?: ScatterSeriesInput;
+    /** Multi-series - pass an array of named series. */
+    series?: readonly ScatterSeriesConfig[];
+    /** Default 9 (fixed pixel diameter). */
+    pointSize?: PointSizeInput;
+    /** Default 'auto' - lowers per-point alpha at high counts. */
+    pointOpacity?: PointOpacityInput;
+    /** Default false. */
+    regressionLine?: RegressionLineInput;
+    /** Default 'auto' - switches to heatmap at ≥50k points. */
+    density?: DensityInput;
+    /** Inherits LineChart's MarkerConfig - controls point shape + fill/stroke
+     *  treatment. `pointSize` overrides the size field. */
+    pointMarker?: PointMarkers;
+    legend?: LegendVisibility;
+    legendPosition?: LegendPosition;
+    crosshairVisible?: boolean;
+    crosshairLineStyle?: GridStyle;
+    crosshairMarker?: CrosshairMarker;
+    width?: number;
+    height?: number;
+    theme?: ThemeInput;
+    palette?: string;
+    visualStyle?: "Fill" | "Outline";
+    outlineFillColor?: "auto" | string;
+    outlineFillOpacity?: number;
+    pixelDensityCap?: number;
+    fastMode?: boolean;
+    /** Glow + glow-color axes. */
+    glow?: import('../personalization/axes/glow').GlowInput;
+    glowColor?: import('../personalization/axes/glow').GlowColorInput;
+    /** Pattern fills. */
+    pattern?: import('../personalization/axes/pattern').PatternInput;
+    patternScale?: number;
+    patternColor?: import('../personalization/axes/pattern').PatternColorInput;
+    sparkline?: boolean;
+    ariaLabel?: string;
+    axisVisible?: boolean;
+    yAxisPosition?: YAxisPosition;
+    xAxisPosition?: XAxisPosition;
+    yAxisPadding?: number;
+    xAxisPadding?: number;
+    gridVisible?: boolean;
+    gridStyle?: GridStyle;
+    gridDensity?: "sparse" | "normal" | "dense";
+    accents?: boolean;
+    locale?: string;
+    timeZone?: string;
+    digitGrouping?: DigitGrouping;
+    numberAbbreviation?: NumberAbbreviation;
+    decimalPlaces?: DecimalPlaces;
+    currency?: string;
+    currencyDisplay?: CurrencyDisplay;
+    percentPrecision?: PercentPrecision;
+    dateFormat?: DateFormat;
+    timeFormat?: TimeFormat;
+}
+export declare const DEFAULT_FONT = "12px system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif";
+export declare const DEFAULT_AXIS_FONT_SIZE = 11;
+export declare const LABEL_GAP_PX = 6;
+export declare const TICK_LENGTH_PX = 4;
+export declare const Y_AXIS_RESERVE_PX = 80;
+export declare const X_AXIS_RESERVE_PX = 28;
+export declare const GRID_TARGET: {
+    readonly sparse: 4;
+    readonly normal: 8;
+    readonly dense: 12;
+};
+export declare const SPARKLINE_THRESHOLD_PX = 150;
+/** Default density bins on each axis when heatmap mode engages. Bins are
+ *  square pixel cells; the count adapts to viewport size at draw time. */
+export declare const DEFAULT_DENSITY_BIN_PX = 8;
+export interface HoverState {
+    readonly pointerX: number;
+    readonly pointerY: number;
+    readonly snapX: number;
+    readonly snapY: number;
+    /** Index into `seriesList` (0 = primary, ≥1 = secondaries). */
+    readonly seriesIdx: number;
+    /** Index of the hovered point within that series. */
+    readonly idx: number;
+    readonly x: number;
+    readonly y: number;
+    readonly size: number | null;
+}
+/** A resolved scatter series ready to draw - primary or secondary, all
+ *  share the same shape. The controller produces `seriesList[]` from the
+ *  `data` + `series` props, with index 0 always being the primary. */
+export interface ResolvedScatterSeries {
+    readonly id: string;
+    readonly label: string;
+    readonly series: ScatterSeries;
+    /** Resolved CSS color (categorical[i] cycling already applied). */
+    readonly color: string;
+    /** Pre-computed per-point bubble radii when `pointSize.kind === 'data-driven'`
+     *  AND the series provides a `sizes` field. Else null → fall back to fixed. */
+    readonly bubbleRadii: Float64Array | null;
+}
+export interface DynamicCfg {
+    readonly crosshairVisible: boolean;
+    readonly crosshairLineStyle: GridStyle;
+    readonly crosshairMarker: CrosshairMarker;
+}
+export interface ChartLayout {
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    xScale: LinearScale;
+    yScale: LinearScale;
+    xTicks: readonly NiceTick[];
+    yTicks: readonly NiceTick[];
+    viewport: Viewport;
+}
+export interface ChartHandle {
+    readonly dynamicCtx: CanvasRenderingContext2D | null;
+    readonly layout: ChartLayout;
+    readonly crosshairLineColor: string;
+    readonly crosshairMarkerFill: string;
+    readonly crosshairMarkerStroke: string;
+    /** Resolved per-series colors keyed by series index - used by hover state
+     *  for crosshair-marker and by tooltip render-prop callbacks. */
+    readonly seriesColors: readonly string[];
+}
+export declare function computeXYDomain(seriesList: readonly ResolvedScatterSeries[], xPadding: number, yPadding: number): {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+};
+export declare function computeLayout(opts: {
+    seriesList: readonly ResolvedScatterSeries[];
+    viewport: Viewport;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    xAxisPadding: number;
+    yAxisPadding: number;
+    gridDensity: "sparse" | "normal" | "dense";
+    axisVisible: boolean;
+    formatter: ChartFormatter;
+}): ChartLayout;
+export declare function defaultAriaLabel(seriesList: readonly ResolvedScatterSeries[]): string;
+export interface RegressionPolyline {
+    readonly xs: Float64Array;
+    readonly ys: Float64Array;
+}
+export declare function buildRegressionPolyline(spec: ResolvedRegressionLine, series: ScatterSeries, xMin: number, xMax: number, steps?: number): RegressionPolyline | null;
+export interface DensityGrid {
+    readonly counts: Uint32Array;
+    readonly binsX: number;
+    readonly binsY: number;
+    readonly maxCount: number;
+    readonly innerLeft: number;
+    readonly innerTop: number;
+    readonly cellPxX: number;
+    readonly cellPxY: number;
+}
+export declare function buildDensityGrid(seriesList: readonly ResolvedScatterSeries[], layout: ChartLayout, cellPx: number): DensityGrid;
+export interface DrawFullScatterArgs {
+    ctx: CanvasRenderingContext2D;
+    seriesList: readonly ResolvedScatterSeries[];
+    personalization: Personalization;
+    accents: boolean;
+    layout: ChartLayout;
+    axisVisible: boolean;
+    gridVisible: boolean;
+    gridStyle: GridStyle;
+    yAxisPosition: YAxisPosition;
+    xAxisPosition: XAxisPosition;
+    /** Resolved size shape (fixed or data-driven). */
+    pointSize: ResolvedPointSize;
+    /** Pre-resolved per-point alpha (already includes 'auto' density step). */
+    pointAlpha: number;
+    /** When non-null, render the heatmap instead of points. */
+    density: DensityGrid | null;
+    /** When non-null, stroke the regression polyline. */
+    regression: RegressionPolyline | null;
+    regressionSpec: ResolvedRegressionLine | null;
+    /** Resolved marker config (style + fill/stroke modifiers). When null, the
+     *  default circle marker is used. */
+    marker: ResolvedMarkerConfig | null;
+}
+export declare function drawFullScatterChart(args: DrawFullScatterArgs): void;
+export declare function drawScatterDynamicLayer(handle: ChartHandle, hover: HoverState | null, cfg: DynamicCfg): void;

package/dist/charts/scatter-density.d.ts

@@ -0,0 +1,5 @@
+export interface BinDensityResult {
+    /** Maximum bin count - used to normalize the heatmap color ramp. */
+    readonly maxCount: number;
+}
+export declare function binDensity(xs: Float64Array, ys: Float64Array, n: number, xMin: number, xMax: number, yMin: number, yMax: number, binsX: number, binsY: number, out: Uint32Array): BinDensityResult;

package/dist/charts/scatter-regression.d.ts

@@ -0,0 +1,27 @@
+export interface LinearFit {
+    /** Intercept - y = a + b·x. */
+    readonly a: number;
+    /** Slope. */
+    readonly b: number;
+}
+/** OLS linear regression. Returns intercept + slope. Robust to constant-x
+ *  inputs (slope clamps to 0 then). */
+export declare function fitLinear(xs: Float64Array, ys: Float64Array, n: number): LinearFit;
+/** Solve Vandermonde least-squares for polynomial coefficients
+ *  `[c0, c1, ..., cd]` such that `y ≈ Σ ci·x^i`. Writes `degree + 1` values
+ *  into `outCoeffs`. */
+export declare function fitPolynomial(xs: Float64Array, ys: Float64Array, n: number, degree: number, outCoeffs: Float64Array): void;
+/** Evaluate polynomial Σ c_i · x^i at `x` via Horner's method. */
+export declare function evaluatePolynomial(coeffs: Float64Array, x: number): number;
+export interface ExponentialFit {
+    /** y = a · exp(b·x). */
+    readonly a: number;
+    readonly b: number;
+}
+/** Fit `y = a · exp(b·x)` by linearizing: `ln(y) = ln(a) + b·x`. Returns
+ *  null if any y ≤ 0 (log undefined). */
+export declare function fitExponential(xs: Float64Array, ys: Float64Array, n: number): ExponentialFit | null;
+/** LOWESS - locally-weighted scatterplot smoothing with a tricube kernel
+ *  over a `bandwidth` fraction of the points. Writes per-evaluation values
+ *  into `evalYs` (length must equal `evalXs.length`). */
+export declare function fitLowess(xs: Float64Array, ys: Float64Array, n: number, bandwidth: number, evalXs: Float64Array, evalYs: Float64Array): void;