@rokkit/chart 1.0.0-next.15 → 1.0.0-next.151

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

@@ -0,0 +1,114 @@
+export function buildLegendGroups(channels: any, colorMap: any, patternMap: any, symbolMap: any): {
+    field: any;
+    items: any;
+}[];
+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: any;
+        items: any;
+    }[];
+    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/dimensions.svelte.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Creates chart dimensions based on width, height and margins
+ *
+ * @param {number} width - Total chart width
+ * @param {number} height - Total chart height
+ * @param {ChartMargin} margin - Chart margins
+ * @returns {ChartDimensions} Chart dimensions
+ */
+export function createDimensions(width?: number, height?: number, margin?: ChartMargin): ChartDimensions;
+/**
+ * Updates existing dimensions with new values
+ *
+ * @param {ChartDimensions} dimensions - Current dimensions
+ * @param {Object} updates - Values to update
+ * @param {number} [updates.width] - New width
+ * @param {number} [updates.height] - New height
+ * @param {ChartMargin} [updates.margin] - New margin
+ * @returns {ChartDimensions} Updated dimensions
+ */
+export function updateDimensions(dimensions: ChartDimensions, updates?: {
+    width?: number | undefined;
+    height?: number | undefined;
+    margin?: import("./types.js").ChartMargin | undefined;
+}): ChartDimensions;
+/**
+ * @typedef {import('./types').ChartMargin} ChartMargin
+ * @typedef {import('./types').ChartDimensions} ChartDimensions
+ */
+/**
+ * Default chart margin
+ * @type {ChartMargin}
+ */
+export const DEFAULT_MARGIN: ChartMargin;
+export type ChartMargin = import("./types").ChartMargin;
+export type ChartDimensions = import("./types").ChartDimensions;

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

@@ -0,0 +1,118 @@
+/**
+ * Main class that manages chart state and provides access to all brewing functions
+ */
+export class ChartBrewer {
+    /**
+     * Creates a new ChartBrewer instance
+     *
+     * @param {Object} options Configuration options
+     */
+    constructor(options?: Object);
+    /**
+     * Sets the data for the chart
+     *
+     * @param {Array} data Data array
+     * @returns {ChartBrewer} this for method chaining
+     */
+    setData(data: any[]): ChartBrewer;
+    /**
+     * Sets the field mappings for axes and color
+     *
+     * @param {Object} fields Field mappings
+     * @returns {ChartBrewer} this for method chaining
+     */
+    setFields({ x, y, color }: Object): ChartBrewer;
+    /**
+     * Sets the dimensions of the chart
+     *
+     * @param {Object} dimensions Chart dimensions
+     * @returns {ChartBrewer} this for method chaining
+     */
+    setDimensions({ width, height, margin }: Object): ChartBrewer;
+    /**
+     * Creates scales based on data and dimensions
+     *
+     * @returns {ChartBrewer} this for method chaining
+     */
+    createScales(): ChartBrewer;
+    /**
+     * Creates bar data for rendering
+     *
+     * @returns {Array} Data for rendering bars
+     */
+    createBars(): any[];
+    /**
+     * Creates x-axis tick data for rendering
+     *
+     * @param {Object} options Axis options
+     * @returns {Object} Axis rendering data
+     */
+    createXAxis(options?: Object): Object;
+    /**
+     * Creates y-axis tick data for rendering
+     *
+     * @param {Object} options Axis options
+     * @returns {Object} Axis rendering data
+     */
+    createYAxis(options?: Object): Object;
+    /**
+     * Creates grid line data for rendering
+     *
+     * @param {Object} options Grid options
+     * @returns {Object} Grid rendering data
+     */
+    createGrid(options?: Object): Object;
+    /**
+     * Creates legend data for rendering
+     *
+     * @param {Object} options Legend options
+     * @returns {Object} Legend rendering data
+     */
+    createLegend(options?: Object): Object;
+    /**
+     * Gets all chart dimensions
+     *
+     * @returns {Object} Chart dimensions
+     */
+    getDimensions(): Object;
+    /**
+     * Gets all chart scales
+     *
+     * @returns {Object} Chart scales
+     */
+    getScales(): Object;
+    /**
+     * Gets the animation duration
+     *
+     * @returns {number} Animation duration in ms
+     */
+    getAnimationDuration(): number;
+    /**
+     * Gets the data being used
+     *
+     * @returns {Array} Chart data
+     */
+    getData(): any[];
+    /**
+     * Gets the fields configuration
+     *
+     * @returns {Object} Fields configuration
+     */
+    getFields(): Object;
+    #private;
+}
+import { createDimensions } from './dimensions.svelte.js';
+import { updateDimensions } from './dimensions.svelte.js';
+import { createScales } from './scales.svelte.js';
+import { getOrigin } from './scales.svelte.js';
+import { createBars } from './bars.svelte.js';
+import { filterBars } from './bars.svelte.js';
+import { createGroupedBars } from './bars.svelte.js';
+import { createXAxis } from './axes.svelte.js';
+import { createYAxis } from './axes.svelte.js';
+import { createGrid } from './axes.svelte.js';
+import { createTickAttributes } from './axes.svelte.js';
+import { createLegend } from './legends.svelte.js';
+import { filterByLegend } from './legends.svelte.js';
+import { createLegendItemAttributes } from './legends.svelte.js';
+export { createDimensions, updateDimensions, createScales, getOrigin, createBars, filterBars, createGroupedBars, createXAxis, createYAxis, createGrid, createTickAttributes, createLegend, filterByLegend, createLegendItemAttributes };

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

@@ -0,0 +1,48 @@
+/**
+ * Creates legend data for rendering
+ *
+ * @param {Array} data - Chart data
+ * @param {Object} fields - Field mappings
+ * @param {string} fields.color - Color field
+ * @param {Object} scales - Chart scales
+ * @param {Function} scales.color - Color scale
+ * @param {Object} options - Legend options including dimensions
+ * @param {Object} options.dimensions - Chart dimensions
+ * @param {string} [options.title=''] - Legend title
+ * @param {string} [options.align='right'] - Legend alignment ('left', 'center', or 'right')
+ * @param {string} [options.shape='rect'] - Legend marker shape ('rect' or 'circle')
+ * @param {number} [options.markerSize=10] - Size of legend markers
+ * @returns {LegendData} Legend rendering data
+ */
+export function createLegend(data: any[], fields: {
+    color: string;
+}, scales: {
+    color: Function;
+}, options: {
+    dimensions: Object;
+    title?: string | undefined;
+    align?: string | undefined;
+    shape?: string | undefined;
+    markerSize?: number | undefined;
+}): LegendData;
+/**
+ * Filter data based on legend selection
+ *
+ * @param {Array} data - Chart data
+ * @param {string} colorField - Field used for color mapping
+ * @param {Array} selectedValues - Selected legend values
+ * @returns {Array} Filtered data
+ */
+export function filterByLegend(data: any[], colorField: string, selectedValues: any[]): any[];
+/**
+ * Create attributes for legend items
+ *
+ * @param {LegendItem} item - Legend item
+ * @returns {Object} Attributes for the legend item
+ */
+export function createLegendItemAttributes(item: LegendItem): Object;
+export type LegendItem = import("./types").LegendItem;
+export type LegendData = import("./types").LegendData;
+export type ScaleFields = import("./types").ScaleFields;
+export type ChartScales = import("./types").ChartScales;
+export type ChartDimensions = import("./types").ChartDimensions;

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/scales.svelte.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Creates scales based on data, fields, and dimensions
+ *
+ * @param {Array} data - Chart data
+ * @param {ScaleFields} fields - Field mappings
+ * @param {Object} dimensions - Chart dimensions
+ * @param {Object} options - Scale options
+ * @param {number} [options.padding=0.2] - Padding for band scales
+ * @returns {ChartScales} Chart scales
+ */
+export function createScales(data: any[], fields: ScaleFields, dimensions: Object, options?: {
+    padding?: number | undefined;
+}): ChartScales;
+/**
+ * Gets the origin coordinates for the axes
+ *
+ * @param {ChartScales} scales - Chart scales
+ * @param {Object} dimensions - Chart dimensions
+ * @returns {Object} Origin coordinates
+ */
+export function getOrigin(scales: ChartScales, dimensions: Object): Object;
+export type ChartScales = import("./types").ChartScales;
+export type ScaleFields = import("./types").ScaleFields;
+export type ChartDimensions = import("./types").ChartDimensions;

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

@@ -0,0 +1,23 @@
+/**
+ * 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[];
+export function applyAggregate(data: any, { by, value, stat }: {
+    by: any;
+    value: any;
+    stat: any;
+}): any;
+/**
+ * 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[];