@rokkit/chart 1.0.0-next.146 → 1.0.0-next.148

package/dist/Plot/index.d.ts

@@ -3,3 +3,7 @@ export { default as Axis } from "./Axis.svelte";
 export { default as Bar } from "./Bar.svelte";
 export { default as Legend } from "./Legend.svelte";
 export { default as Grid } from "./Grid.svelte";
+export { default as Line } from "./Line.svelte";
+export { default as Area } from "./Area.svelte";
+export { default as Point } from "./Point.svelte";
+export { default as Arc } from "./Arc.svelte";

package/dist/PlotState.svelte.d.ts

@@ -0,0 +1,47 @@
+export class PlotState {
+    constructor(config?: {});
+    axisOrigin: undefined[];
+    orientation: string;
+    colorScaleType: any;
+    xScale: any;
+    yScale: any;
+    colors: Map<unknown, {
+        fill: string;
+        stroke: string;
+    }>;
+    patterns: Map<any, any>;
+    symbols: Map<any, any>;
+    colorField: any;
+    patternField: any;
+    symbolField: any;
+    geomTypes: Set<any>;
+    xAxisY: any;
+    yAxisX: any;
+    update(config: any): void;
+    registerGeom(config: any): string;
+    updateGeom(id: any, config: any): void;
+    unregisterGeom(id: any): void;
+    geomData(id: any): any[];
+    label(field: any): any;
+    format(field: any): any;
+    tooltip(): any;
+    geomComponent(type: any): any;
+    preset(): {
+        colors: any;
+        patterns: any;
+        symbols: any;
+    };
+    get margin(): {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    get innerWidth(): number;
+    get innerHeight(): number;
+    get mode(): string;
+    get hovered(): null;
+    setHovered(data: any): void;
+    clearHovered(): void;
+    #private;
+}

package/dist/crossfilter/createCrossFilter.svelte.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates a reactive cross-filter state object.
+ *
+ * Filter values follow the spec type:
+ *   FilterState = Map<string, Set<unknown> | [number, number]>
+ *   - categorical: raw Set of selected values
+ *   - continuous:  [min, max] tuple
+ *
+ * Exposes a `filters` getter so CrossFilter.svelte can bind to current state.
+ * Exposes a `version` counter that increments on every mutation, giving
+ * components a simple reactive signal to watch for filter changes.
+ *
+ * @returns {CrossFilter}
+ */
+export function createCrossFilter(): CrossFilter;

package/dist/geoms/lib/areas.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Builds area path geometry for multi-series area charts.
+ *
+ * @param {Object[]} data
+ * @param {{ x: string, y: string, color?: string }} channels
+ * @param {Function} xScale
+ * @param {Function} yScale
+ * @param {Map<unknown, {fill: string, stroke: string}>} colors
+ * @param {'linear'|'smooth'|'step'} [curve]
+ * @param {Map<unknown, string>} [patterns]
+ * @returns {{ d: string, fill: string, stroke: string, key: unknown, patternId: string|null }[]}
+ */
+export function buildAreas(data: Object[], channels: {
+    x: string;
+    y: string;
+    color?: string;
+}, xScale: Function, yScale: Function, colors: Map<unknown, {
+    fill: string;
+    stroke: string;
+}>, curve?: "linear" | "smooth" | "step", patterns?: Map<unknown, string>): {
+    d: string;
+    fill: string;
+    stroke: string;
+    key: unknown;
+    patternId: string | null;
+}[];
+/**
+ * Builds stacked area paths using d3 stack layout.
+ *
+ * @param {Object[]} data
+ * @param {{ x: string, y: string, color: string }} channels
+ * @param {Function} xScale
+ * @param {Function} yScale
+ * @param {Map<unknown, {fill: string, stroke: string}>} colors
+ * @param {'linear'|'smooth'|'step'} [curve]
+ * @param {Map<unknown, string>} [patterns]
+ * @returns {{ d: string, fill: string, stroke: string, key: unknown, patternId: string|null }[]}
+ */
+export function buildStackedAreas(data: Object[], channels: {
+    x: string;
+    y: string;
+    color: string;
+}, xScale: Function, yScale: Function, colors: Map<unknown, {
+    fill: string;
+    stroke: string;
+}>, curve?: "linear" | "smooth" | "step", patterns?: Map<unknown, string>): {
+    d: string;
+    fill: string;
+    stroke: string;
+    key: unknown;
+    patternId: string | null;
+}[];

package/dist/geoms/lib/bars.d.ts

@@ -0,0 +1,3 @@
+export function buildGroupedBars(data: any, channels: any, xScale: any, yScale: any, colors: any, innerHeight: any, patterns: any): any;
+export function buildStackedBars(data: any, channels: any, xScale: any, yScale: any, colors: any, innerHeight: any, patterns: any): any;
+export function buildHorizontalBars(data: any, channels: any, xScale: any, yScale: any, colors: any, _innerHeight: any): any;

package/dist/index.d.ts

@@ -1,14 +1,51 @@
-export namespace Plot {
+export namespace PlotLayers {
     export { Root };
     export { Axis };
     export { Bar };
     export { Grid };
     export { Legend };
+    export { Line };
+    export { Area };
+    export { Point };
+    export { Arc };
 }
+export { default as PlotChart } from "./Plot.svelte";
+export { default as FacetPlot } from "./FacetPlot.svelte";
+export { default as AnimatedPlot } from "./AnimatedPlot.svelte";
+export { default as GeomBar } from "./geoms/Bar.svelte";
+export { default as GeomLine } from "./geoms/Line.svelte";
+export { default as GeomArea } from "./geoms/Area.svelte";
+export { default as GeomPoint } from "./geoms/Point.svelte";
+export { default as GeomArc } from "./geoms/Arc.svelte";
+export { default as GeomBox } from "./geoms/Box.svelte";
+export { default as GeomViolin } from "./geoms/Violin.svelte";
+export { default as Chart } from "./Chart.svelte";
+export { default as Sparkline } from "./Sparkline.svelte";
+export { default as BarChart } from "./charts/BarChart.svelte";
+export { default as LineChart } from "./charts/LineChart.svelte";
+export { default as AreaChart } from "./charts/AreaChart.svelte";
+export { default as PieChart } from "./charts/PieChart.svelte";
+export { default as ScatterPlot } from "./charts/ScatterPlot.svelte";
+export { default as BoxPlot } from "./charts/BoxPlot.svelte";
+export { default as ViolinPlot } from "./charts/ViolinPlot.svelte";
+export { default as BubbleChart } from "./charts/BubbleChart.svelte";
+export { PlotState } from "./PlotState.svelte.js";
 export { ChartBrewer } from "./lib/brewing/index.svelte.js";
 export * from "./lib/brewing/index.svelte.js";
+export { CartesianBrewer } from "./lib/brewing/CartesianBrewer.svelte.js";
+export { PieBrewer } from "./lib/brewing/PieBrewer.svelte.js";
+export { BoxBrewer } from "./lib/brewing/BoxBrewer.svelte.js";
+export { ViolinBrewer } from "./lib/brewing/ViolinBrewer.svelte.js";
+export { createCrossFilter } from "./crossfilter/createCrossFilter.svelte.js";
+export { default as CrossFilter } from "./crossfilter/CrossFilter.svelte";
+export { default as FilterBar } from "./crossfilter/FilterBar.svelte";
+export { default as FilterSlider } from "./crossfilter/FilterSlider.svelte";
 import Root from './Plot/Root.svelte';
 import Axis from './Plot/Axis.svelte';
 import Bar from './Plot/Bar.svelte';
 import Grid from './Plot/Grid.svelte';
 import Legend from './Plot/Legend.svelte';
+import Line from './Plot/Line.svelte';
+import Area from './Plot/Area.svelte';
+import Point from './Plot/Point.svelte';
+import Arc from './Plot/Arc.svelte';

package/dist/lib/brewing/BoxBrewer.svelte.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Brewer for box plots. Always computes quartile statistics regardless of the stat prop.
+ * Groups by x + fill (primary) or x + color (fallback).
+ * fill = box interior color, color = whisker/outline stroke.
+ */
+export class BoxBrewer extends ChartBrewer {
+    transform(data: any, channels: any): any;
+    boxes: any[];
+}
+import { ChartBrewer } from './brewer.svelte.js';

package/dist/lib/brewing/CartesianBrewer.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Brewer for cartesian charts (Bar, Line, Area).
+ * Groups by x (and fill/color if set) and applies the given stat.
+ */
+export class CartesianBrewer extends ChartBrewer {
+    transform(data: any, channels: any, stat: any): any;
+}
+import { ChartBrewer } from './brewer.svelte.js';

package/dist/lib/brewing/PieBrewer.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Brewer for pie charts. Always aggregates by the label field.
+ * 'identity' is not meaningful for pie charts — falls back to 'sum'.
+ */
+export class PieBrewer extends ChartBrewer {
+    transform(data: any, channels: any, stat: any): any;
+}
+import { ChartBrewer } from './brewer.svelte.js';

package/dist/lib/brewing/ViolinBrewer.svelte.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Brewer for violin plots. Computes the same quartile statistics as BoxBrewer.
+ * fill = violin body color, color = outline stroke.
+ */
+export class ViolinBrewer extends ChartBrewer {
+    transform(data: any, channels: any): any;
+    violins: any[];
+}
+import { ChartBrewer } from './brewer.svelte.js';

package/dist/lib/brewing/brewer.svelte.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Groups aesthetic channel mappings by field name, merging aesthetics that
+ * share the same field into one legend section.
+ *
+ * @param {{ fill?: string, color?: string, pattern?: string, symbol?: string }} channels
+ *   `fill` takes precedence over `color` for polygon charts (bars, areas, pie slices).
+ * @param {Map<unknown, {fill:string, stroke:string}>} colorMap
+ * @param {Map<unknown, string>} patternMap
+ * @param {Map<unknown, string>} symbolMap
+ * @returns {{ field: string, items: { label: string, fill: string|null, stroke: string|null, patternId: string|null, shape: string|null }[] }[]}
+ */
+export function buildLegendGroups(channels: {
+    fill?: string;
+    color?: string;
+    pattern?: string;
+    symbol?: string;
+}, colorMap: Map<unknown, {
+    fill: string;
+    stroke: string;
+}>, patternMap: Map<unknown, string>, symbolMap: Map<unknown, string>): {
+    field: string;
+    items: {
+        label: string;
+        fill: string | null;
+        stroke: string | null;
+        patternId: string | null;
+        shape: string | null;
+    }[];
+}[];
+export class ChartBrewer {
+    /**
+     * Override in subclasses to apply stat aggregation.
+     * @param {Object[]} data
+     * @param {Object} channels
+     * @param {string|Function} stat
+     * @returns {Object[]}
+     */
+    transform(data: Object[], _channels: any, _stat: any): Object[];
+    /** Aggregated data — all derived marks read this, not #rawData */
+    processedData: Object[];
+    /** Exposes channels to subclasses for use in their own $derived properties */
+    get channels(): {};
+    /** @type {Map<unknown, {fill:string,stroke:string}>} */
+    colorMap: Map<unknown, {
+        fill: string;
+        stroke: string;
+    }>;
+    /** @type {Map<unknown, string>} */
+    patternMap: Map<unknown, string>;
+    /**
+     * Unified pattern defs for ChartPatternDefs.
+     * When fill and pattern map the same field, pattern key = color key (simple case).
+     * When they differ, each unique (fillKey, patternKey) pair gets its own pattern def
+     * so bars/areas can have distinct colors per region AND distinct textures per category.
+     * @type {Array<{ id: string, name: string, fill: string, stroke: string }>}
+     */
+    patternDefs: Array<{
+        id: string;
+        name: string;
+        fill: string;
+        stroke: string;
+    }>;
+    /** @type {Map<unknown, string>} */
+    symbolMap: Map<unknown, string>;
+    get innerWidth(): number;
+    get innerHeight(): number;
+    xScale: any;
+    yScale: any;
+    sizeScale: any;
+    bars: any;
+    lines: {
+        d: string;
+        fill: string;
+        stroke: string;
+        points: {
+            x: number;
+            y: number;
+            data: Object;
+        }[];
+        key?: unknown;
+    }[];
+    areas: {
+        d: any;
+        fill: any;
+        stroke: string;
+        key: any;
+        colorKey: any;
+        patternKey: any;
+        patternId: string | null;
+    }[] | {
+        d: any;
+        fill: any;
+        stroke: string;
+        colorKey: null;
+        patternKey: null;
+        patternId: null;
+    }[];
+    arcs: any;
+    points: {
+        data: Object;
+        cx: any;
+        cy: any;
+        r: any;
+        fill: any;
+        stroke: any;
+        symbolPath: string | null;
+        key: any;
+    }[];
+    legendGroups: {
+        field: string;
+        items: {
+            label: string;
+            fill: string | null;
+            stroke: string | null;
+            patternId: string | null;
+            shape: string | null;
+        }[];
+    }[];
+    get margin(): {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    get width(): number;
+    get height(): number;
+    get mode(): string;
+    /**
+     * @param {{ data?: Object[], channels?: Object, width?: number, height?: number, mode?: string, margin?: Object, layers?: Object[], curve?: string, stat?: string|Function }} opts
+     *   Supported channel keys: `x`, `y`, `fill`, `color`, `pattern`, `symbol`, `size`, `label`.
+     *   `frame` is reserved for future animation use (no-op).
+     */
+    update(opts?: {
+        data?: Object[];
+        channels?: Object;
+        width?: number;
+        height?: number;
+        mode?: string;
+        margin?: Object;
+        layers?: Object[];
+        curve?: string;
+        stat?: string | Function;
+    }): void;
+    #private;
+}

package/dist/lib/brewing/colors.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Extracts distinct values for a given field from the data array.
+ * @param {Object[]} data
+ * @param {string|null} field
+ * @returns {unknown[]}
+ */
+export function distinct(data: Object[], field: string | null): unknown[];
+/**
+ * Assigns palette colors to an array of distinct values.
+ * @param {unknown[]} values
+ * @param {'light'|'dark'} mode
+ * @returns {Map<unknown, {fill: string, stroke: string}>}
+ */
+export function assignColors(values: unknown[], mode?: "light" | "dark"): Map<unknown, {
+    fill: string;
+    stroke: string;
+}>;

package/dist/lib/brewing/marks/arcs.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Builds arc geometry for pie/donut charts.
+ * @param {Object[]} data
+ * @param {{ color: string, y: string, pattern?: string }} channels
+ * @param {Map} colors
+ * @param {number} width
+ * @param {number} height
+ * @param {{ innerRadius?: number }} opts
+ * @param {Map<unknown, string>} [patterns]
+ */
+export function buildArcs(data: Object[], channels: {
+    color: string;
+    y: string;
+    pattern?: string;
+}, colors: Map<any, any>, width: number, height: number, opts?: {
+    innerRadius?: number;
+}, patterns?: Map<unknown, string>): any;

package/dist/lib/brewing/marks/areas.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @param {Object[]} data
+ * @param {{ x: string, y: string, fill?: string, pattern?: string }} channels
+ *   `fill` is the primary aesthetic — drives grouping and interior color.
+ * @param {Function} xScale
+ * @param {Function} yScale
+ * @param {Map} colors
+ * @param {'linear'|'smooth'|'step'} [curve]
+ * @param {Map} [patternMap]
+ */
+export function buildAreas(data: Object[], channels: {
+    x: string;
+    y: string;
+    fill?: string;
+    pattern?: string;
+}, xScale: Function, yScale: Function, colors: Map<any, any>, curve?: "linear" | "smooth" | "step", patternMap?: Map<any, any>): {
+    d: any;
+    fill: any;
+    stroke: string;
+    key: any;
+    colorKey: any;
+    patternKey: any;
+    patternId: string | null;
+}[] | {
+    d: any;
+    fill: any;
+    stroke: string;
+    colorKey: null;
+    patternKey: null;
+    patternId: null;
+}[];

package/dist/lib/brewing/marks/bars.d.ts

@@ -0,0 +1 @@
+export function buildBars(data: any, channels: any, xScale: any, yScale: any, colors: any, patternMap: any): any;

package/dist/lib/brewing/marks/boxes.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Builds box geometry for box plot charts.
+ * Input data rows must already contain { q1, median, q3, iqr_min, iqr_max } —
+ * computed by applyBoxStat before reaching this function.
+ *
+ * When `fill` differs from `x`, boxes are sub-grouped within each x-band
+ * (one narrower box per fill value per x category, like grouped bars).
+ * Box body uses the lighter fill shade; whiskers and median use the darker stroke shade.
+ *
+ * @param {Object[]} data - Pre-aggregated rows with quartile fields
+ * @param {{ x: string, fill?: string }} channels
+ *   `fill` drives the box and whisker color (defaults to x-field).
+ * @param {import('d3-scale').ScaleBand} xScale
+ * @param {import('d3-scale').ScaleLinear} yScale
+ * @param {Map<unknown, {fill:string, stroke:string}>} colors
+ * @returns {Array}
+ */
+export function buildBoxes(data: Object[], channels: {
+    x: string;
+    fill?: string;
+}, xScale: any, yScale: any, colors: Map<unknown, {
+    fill: string;
+    stroke: string;
+}>): any[];

package/dist/lib/brewing/marks/lines.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @param {Object[]} data
+ * @param {{ x: string, y: string, color?: string }} channels
+ * @param {Function} xScale
+ * @param {Function} yScale
+ * @param {Map} colors
+ * @param {'linear'|'smooth'|'step'} [curve]
+ * @returns {{ d: string, fill: string, stroke: string, points: {x:number, y:number, data:Object}[], key?: unknown }[]}
+ */
+export function buildLines(data: Object[], channels: {
+    x: string;
+    y: string;
+    color?: string;
+}, xScale: Function, yScale: Function, colors: Map<any, any>, curve?: "linear" | "smooth" | "step"): {
+    d: string;
+    fill: string;
+    stroke: string;
+    points: {
+        x: number;
+        y: number;
+        data: Object;
+    }[];
+    key?: unknown;
+}[];

package/dist/lib/brewing/marks/points.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Returns a Map assigning shape names to distinct values, cycling through available shapes.
+ * @param {unknown[]} values
+ * @returns {Map<unknown, string>}
+ */
+export function assignSymbols(values: unknown[]): Map<unknown, string>;
+/**
+ * Builds an SVG path string for a given shape name and radius.
+ * @param {string} shapeName
+ * @param {number} r
+ * @returns {string}
+ */
+export function buildSymbolPath(shapeName: string, r: number): string;
+/**
+ * Builds point geometry for scatter/bubble charts.
+ * @param {Object[]} data
+ * @param {{ x: string, y: string, color?: string, size?: string, symbol?: string }} channels
+ * @param {Function} xScale
+ * @param {Function} yScale
+ * @param {Map} colors
+ * @param {Function|null} sizeScale
+ * @param {Map<unknown, string>|null} symbolMap  — maps symbol field value → shape name
+ * @param {number} defaultRadius
+ */
+export function buildPoints(data: Object[], channels: {
+    x: string;
+    y: string;
+    color?: string;
+    size?: string;
+    symbol?: string;
+}, xScale: Function, yScale: Function, colors: Map<any, any>, sizeScale: Function | null, symbolMap: Map<unknown, string> | null, defaultRadius?: number): {
+    data: Object;
+    cx: any;
+    cy: any;
+    r: any;
+    fill: any;
+    stroke: any;
+    symbolPath: string | null;
+    key: any;
+}[];

package/dist/lib/brewing/marks/violins.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Builds a closed violin shape path for each group.
+ * Input rows must have { q1, median, q3, iqr_min, iqr_max } from applyBoxStat.
+ *
+ * When `fill` differs from `x`, violins are sub-grouped within each x-band
+ * (one narrower violin per fill value per x category, like grouped bars).
+ * Violin body uses the lighter fill shade; outline uses the darker stroke shade.
+ *
+ * @param {Object[]} data
+ * @param {{ x: string, fill?: string }} channels
+ *   `fill` drives violin interior and outline (defaults to x-field).
+ * @param {import('d3-scale').ScaleBand} xScale
+ * @param {import('d3-scale').ScaleLinear} yScale
+ * @param {Map} colors
+ * @returns {Array}
+ */
+export function buildViolins(data: Object[], channels: {
+    x: string;
+    fill?: string;
+}, xScale: any, yScale: any, colors: Map<any, any>): any[];

package/dist/lib/brewing/patterns.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Converts a data key to a safe SVG element ID for pattern references.
+ * Spaces and non-word characters are replaced to avoid broken url(#...) refs.
+ * @param {unknown} key
+ * @returns {string}
+ */
+export function toPatternId(key: unknown): string;
+/**
+ * Assigns patterns from PATTERN_ORDER to an array of distinct values.
+ * @param {unknown[]} values
+ * @returns {Map<unknown, string>}
+ */
+export function assignPatterns(values: unknown[]): Map<unknown, string>;
+export const PATTERN_ORDER: string[];

package/dist/lib/brewing/scales.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Builds an x scale (band for categorical, linear for numeric).
+ * @param {Object[]} data
+ * @param {string} field
+ * @param {number} width - inner width (pixels)
+ * @param {{ padding?: number }} opts
+ */
+export function buildXScale(data: Object[], field: string, width: number, opts?: {
+    padding?: number;
+}): any;
+/**
+ * Builds a y linear scale from 0 to max, extended by any layer overrides.
+ * @param {Object[]} data
+ * @param {string} field
+ * @param {number} height - inner height (pixels)
+ * @param {Array<{data?: Object[], y?: string}>} layers
+ */
+export function buildYScale(data: Object[], field: string, height: number, layers?: Array<{
+    data?: Object[];
+    y?: string;
+}>): any;
+/**
+ * Builds a sqrt scale for bubble/point size.
+ * @param {Object[]} data
+ * @param {string} field
+ * @param {number} maxRadius
+ */
+export function buildSizeScale(data: Object[], field: string, maxRadius?: number): any;

package/dist/lib/brewing/stats.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Computes box plot quartile statistics grouped by x (and optionally color).
+ * Output rows have { q1, median, q3, iqr_min, iqr_max } replacing the raw y values.
+ *
+ * @param {Object[]} data
+ * @param {{ x?: string, y?: string, color?: string }} channels
+ * @returns {Object[]}
+ */
+export function applyBoxStat(data: Object[], channels: {
+    x?: string;
+    y?: string;
+    color?: string;
+}): Object[];
+/**
+ * Aggregates data by one or more grouping fields, reducing the value field
+ * using the given stat. Accepts a built-in name or a custom function.
+ *
+ * @param {Object[]} data
+ * @param {{ by: string[], value: string, stat: string|Function }} opts
+ * @returns {Object[]}
+ */
+export function applyAggregate(data: Object[], { by, value, stat }: {
+    by: string[];
+    value: string;
+    stat: string | Function;
+}): Object[];
+/**
+ * Built-in reduction functions. Each receives an array of numeric values.
+ * @type {Record<string, (values: number[]) => number>}
+ */
+export const STAT_FNS: Record<string, (values: number[]) => number>;

package/dist/lib/brewing/symbols.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Assigns shapes from SYMBOL_ORDER to an array of distinct values.
+ * @param {unknown[]} values
+ * @returns {Map<unknown, string>}
+ */
+export function assignSymbols(values: unknown[]): Map<unknown, string>;
+export const SYMBOL_ORDER: string[];