@rokkit/chart 1.1.18 → 1.1.19

package/dist/AnimatedPlot.svelte.d.ts

@@ -0,0 +1,35 @@
+import type { Snippet } from 'svelte';
+import type { GeomSpec, PlotHelpers } from './lib/plot/types.js';
+type Row = Record<string, unknown>;
+type Animate = {
+    by: string;
+    duration?: number;
+    loop?: boolean;
+};
+type Props = {
+    data?: Row[];
+    animate: Animate;
+    x?: string;
+    y?: string;
+    color?: string;
+    fill?: string;
+    pattern?: string;
+    symbol?: string;
+    geom?: string;
+    stat?: string;
+    geoms?: GeomSpec[];
+    helpers?: PlotHelpers;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    legend?: boolean;
+    tween?: boolean;
+    sorted?: boolean;
+    dynamicDomain?: boolean;
+    label?: boolean | string | ((data: Row) => string);
+    children?: Snippet;
+};
+declare const AnimatedPlot: import("svelte").Component<Props, {}, "">;
+type AnimatedPlot = ReturnType<typeof AnimatedPlot>;
+export default AnimatedPlot;

package/dist/Chart.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { Snippet } from 'svelte';
+import type { ChartSpec } from './spec/chart-spec.js';
+type Props = {
+    spec?: ChartSpec;
+    data?: Record<string, unknown>[];
+    x?: string;
+    y?: string;
+    color?: string;
+    pattern?: string;
+    fill?: string;
+    size?: string;
+    label?: string;
+    symbol?: string;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    children?: Snippet;
+};
+declare const Chart: import("svelte").Component<Props, {}, "">;
+type Chart = ReturnType<typeof Chart>;
+export default Chart;

package/dist/ChartExporter.svelte.d.ts

@@ -0,0 +1,22 @@
+import type { Snippet } from 'svelte';
+/**
+ * ChartExporter — wraps a chart and provides export actions for SVG and PNG.
+ *
+ * Usage:
+ * <ChartExporter bind:this={exporter}>
+ *   <BarChart bind:el={chartEl} ... />
+ * </ChartExporter>
+ * <button onclick={() => exporter.exportSVG()}>SVG</button>
+ * <button onclick={() => exporter.exportPNG()}>PNG</button>
+ */
+type Props = {
+    children?: Snippet;
+    filename?: string;
+    scale?: number;
+};
+declare const ChartExporter: import("svelte").Component<Props, {
+    exportSVG: () => void;
+    exportPNG: (scaleFactor?: number) => void;
+}, "">;
+type ChartExporter = ReturnType<typeof ChartExporter>;
+export default ChartExporter;

package/dist/ChartLegend.svelte.d.ts

@@ -0,0 +1,30 @@
+type LegendItem = {
+    key: string;
+    label: string;
+    fill?: string;
+    stroke?: string;
+    patternId?: string;
+    shape?: string;
+};
+type LegendGroup = {
+    type?: 'color' | 'pattern' | 'symbol';
+    label?: string;
+    items: LegendItem[];
+};
+/**
+ * Standalone chart legend — HTML-based, usable outside of Plot context.
+ * Accepts `groups` from a chart's brewer or from multiple charts for shared legends.
+ */
+type Props = {
+    groups?: LegendGroup[];
+    orientation?: 'horizontal' | 'vertical' | 'wrap';
+    gradient?: {
+        style: string;
+        min: string;
+        max: string;
+    } | null;
+    swatchStyle?: 'fill' | 'line' | 'point';
+};
+declare const ChartLegend: import("svelte").Component<Props, {}, "">;
+type ChartLegend = ReturnType<typeof ChartLegend>;
+export default ChartLegend;

package/dist/ChartProvider.svelte.d.ts

@@ -0,0 +1,10 @@
+import type { Snippet } from 'svelte';
+import { createChartPreset } from './lib/preset.js';
+type Preset = ReturnType<typeof createChartPreset>;
+type Props = {
+    preset?: Preset;
+    children?: Snippet;
+};
+declare const ChartProvider: import("svelte").Component<Props, {}, "">;
+type ChartProvider = ReturnType<typeof ChartProvider>;
+export default ChartProvider;

package/dist/FacetPlot/Panel.svelte.d.ts

@@ -0,0 +1,22 @@
+import type { Snippet } from 'svelte';
+import type { GeomSpec, PlotHelpers } from '../lib/plot/types.js';
+type Props = {
+    data?: Record<string, unknown>[];
+    x?: string;
+    y?: string;
+    color?: string;
+    geoms?: GeomSpec[];
+    helpers?: PlotHelpers;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    legend?: boolean;
+    xDomain?: unknown[];
+    yDomain?: [number, number];
+    colorDomain?: unknown[];
+    children?: Snippet;
+};
+declare const Panel: import("svelte").Component<Props, {}, "">;
+type Panel = ReturnType<typeof Panel>;
+export default Panel;

package/dist/FacetPlot.svelte.d.ts

@@ -0,0 +1,32 @@
+import type { Snippet } from 'svelte';
+import type { GeomSpec, PlotHelpers } from './lib/plot/types.js';
+type Facet = {
+    by: string;
+    cols?: number;
+    scales?: 'fixed' | 'free' | 'free_x' | 'free_y';
+};
+type Props = {
+    data?: Record<string, unknown>[];
+    facet: Facet;
+    x?: string;
+    y?: string;
+    color?: string;
+    fill?: string;
+    pattern?: string;
+    symbol?: string;
+    geom?: string;
+    stat?: string;
+    geoms?: GeomSpec[];
+    helpers?: PlotHelpers;
+    panelWidth?: number;
+    panelHeight?: number;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    legend?: boolean;
+    children?: Snippet;
+};
+declare const FacetPlot: import("svelte").Component<Props, {}, "">;
+type FacetPlot = ReturnType<typeof FacetPlot>;
+export default FacetPlot;

package/dist/Plot/Arc.svelte.d.ts

@@ -0,0 +1,18 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const Arc: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type Arc = InstanceType<typeof Arc>;
+export default Arc;

package/dist/Plot/Area.svelte.d.ts

@@ -0,0 +1,14 @@
+import { type CurveFactory } from 'd3-shape';
+type Datum = Record<string, unknown> | number;
+type Props = {
+    data?: Datum[];
+    x?: string;
+    y?: string;
+    y0?: string;
+    fill?: string;
+    opacity?: number;
+    curve?: CurveFactory;
+};
+declare const Area: import("svelte").Component<Props, {}, "">;
+type Area = ReturnType<typeof Area>;
+export default Area;

package/dist/Plot/Axis.svelte.d.ts

@@ -0,0 +1,13 @@
+type Props = {
+    type?: 'x' | 'y';
+    label?: string;
+    format?: (v: unknown) => string;
+    ticks?: number;
+    minorTicks?: boolean;
+    showLine?: boolean;
+    showTicks?: boolean;
+    showLabels?: boolean;
+};
+declare const Axis: import("svelte").Component<Props, {}, "">;
+type Axis = ReturnType<typeof Axis>;
+export default Axis;

package/dist/Plot/Bar.svelte.d.ts

@@ -0,0 +1,11 @@
+type Datum = Record<string, unknown> | number;
+type Props = {
+    data?: Datum[];
+    x?: string;
+    y?: string;
+    fill?: string;
+    opacity?: number;
+};
+declare const Bar: import("svelte").Component<Props, {}, "">;
+type Bar = ReturnType<typeof Bar>;
+export default Bar;

package/dist/Plot/Grid.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const Grid: import("svelte").Component<Record<string, never>, {}, "">;
+type Grid = ReturnType<typeof Grid>;
+export default Grid;

package/dist/Plot/Legend.svelte.d.ts

@@ -0,0 +1,6 @@
+type Props = {
+    labels?: Record<string, string>;
+};
+declare const Legend: import("svelte").Component<Props, {}, "">;
+type Legend = ReturnType<typeof Legend>;
+export default Legend;

package/dist/Plot/Line.svelte.d.ts

@@ -0,0 +1,13 @@
+import { type CurveFactory } from 'd3-shape';
+type Datum = Record<string, unknown> | number;
+type Props = {
+    data?: Datum[];
+    x?: string;
+    y?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    curve?: CurveFactory;
+};
+declare const Line: import("svelte").Component<Props, {}, "">;
+type Line = ReturnType<typeof Line>;
+export default Line;

package/dist/Plot/Point.svelte.d.ts

@@ -0,0 +1,13 @@
+type Datum = Record<string, unknown> | number;
+type Props = {
+    data?: Datum[];
+    x?: string;
+    y?: string;
+    r?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+};
+declare const Point: import("svelte").Component<Props, {}, "">;
+type Point = ReturnType<typeof Point>;
+export default Point;

package/dist/Plot/Root.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { Snippet } from 'svelte';
+type Margin = {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+};
+type Props = {
+    data?: Record<string, unknown>[];
+    x?: string;
+    y?: string;
+    color?: string;
+    width?: number;
+    height?: number;
+    margin?: Margin;
+    mode?: 'light' | 'dark';
+    children?: Snippet;
+};
+declare const Root: import("svelte").Component<Props, {}, "">;
+type Root = ReturnType<typeof Root>;
+export default Root;

package/dist/Plot/Timeline.svelte.d.ts

@@ -0,0 +1,13 @@
+type Props = {
+    frameKeys?: unknown[];
+    currentIndex?: number;
+    playing?: boolean;
+    speed?: number;
+    onplay?: () => void;
+    onpause?: () => void;
+    onscrub?: (index: number) => void;
+    onspeed?: (speed: number) => void;
+};
+declare const Timeline: import("svelte").Component<Props, {}, "">;
+type Timeline = ReturnType<typeof Timeline>;
+export default Timeline;

package/dist/Plot/Tooltip.svelte.d.ts

@@ -0,0 +1,7 @@
+type Row = Record<string, unknown>;
+type Props = {
+    tooltip?: boolean | ((data: Row) => string);
+};
+declare const Tooltip: import("svelte").Component<Props, {}, "">;
+type Tooltip = ReturnType<typeof Tooltip>;
+export default Tooltip;

package/dist/Plot.svelte.d.ts

@@ -0,0 +1,34 @@
+import type { Snippet } from 'svelte';
+import type { PlotSpec, PlotHelpers } from './lib/plot/types.js';
+type Row = Record<string, unknown>;
+type Margin = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+type Props = {
+    data?: Row[];
+    spec?: PlotSpec;
+    helpers?: PlotHelpers;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    axes?: boolean;
+    margin?: Margin;
+    legend?: boolean;
+    title?: string;
+    summary?: string;
+    tooltip?: boolean | ((data: Row) => string);
+    zoom?: boolean;
+    xFormat?: (v: unknown) => string;
+    yFormat?: (v: unknown) => string;
+    xTicks?: number;
+    yTicks?: number;
+    minorTicks?: boolean;
+    children?: Snippet;
+};
+declare const Plot: import("svelte").Component<Props, {}, "">;
+type Plot = ReturnType<typeof Plot>;
+export default Plot;

package/dist/PlotState.svelte.d.ts

@@ -17,9 +17,6 @@ export class PlotState {
     colors: Map<unknown, {
         fill: string;
         stroke: string;
-    }> | Map<null, {
-        fill: any;
-        stroke: any;
     }>;
     patterns: Map<unknown, string> | SvelteMap<any, any>;
     symbols: Map<unknown, string> | SvelteMap<any, any>;

package/dist/Sparkline.svelte.d.ts

@@ -0,0 +1,16 @@
+import { PATTERNS } from './patterns/patterns.js';
+type Props = {
+    data?: number[] | Record<string, unknown>[];
+    field?: string;
+    type?: 'line' | 'area' | 'bar';
+    curve?: 'linear' | 'smooth';
+    color?: string;
+    pattern?: keyof typeof PATTERNS;
+    width?: number;
+    height?: number;
+    min?: number;
+    max?: number;
+};
+declare const Sparkline: import("svelte").Component<Props, {}, "">;
+type Sparkline = ReturnType<typeof Sparkline>;
+export default Sparkline;

package/dist/Symbol.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { SVGAttributes } from 'svelte/elements';
+type Props = {
+    x?: number;
+    y?: number;
+    size?: number;
+    fill?: string;
+    stroke?: string;
+    name?: string;
+} & Omit<SVGAttributes<SVGElement>, 'x' | 'y' | 'fill' | 'stroke'>;
+declare const Symbol: import("svelte").Component<Props, {}, "">;
+type Symbol = ReturnType<typeof Symbol>;
+export default Symbol;

package/dist/Texture.svelte.d.ts

@@ -0,0 +1,12 @@
+type Props = {
+    id?: string;
+    path?: string;
+    fill?: string;
+    stroke?: string;
+    thickness?: number;
+    patternUnits?: 'userSpaceOnUse' | 'objectBoundingBox';
+    size?: number;
+};
+declare const Texture: import("svelte").Component<Props, {}, "">;
+type Texture = ReturnType<typeof Texture>;
+export default Texture;

package/dist/charts/AreaChart.svelte.d.ts

@@ -0,0 +1,25 @@
+type Row = Record<string, unknown>;
+type Format = (v: unknown) => string;
+type Props = {
+    data?: Row[];
+    x?: string;
+    y?: string;
+    fill?: string;
+    stat?: string;
+    curve?: 'linear' | 'smooth' | 'step';
+    pattern?: string;
+    stack?: boolean;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    legend?: boolean;
+    xFormat?: Format;
+    yFormat?: Format;
+    xTicks?: number;
+    yTicks?: number;
+    minorTicks?: boolean;
+};
+declare const AreaChart: import("svelte").Component<Props, {}, "">;
+type AreaChart = ReturnType<typeof AreaChart>;
+export default AreaChart;

package/dist/charts/BarChart.svelte.d.ts

@@ -0,0 +1,26 @@
+type Row = Record<string, unknown>;
+type Format = (v: unknown) => string;
+type Props = {
+    data?: Row[];
+    x?: string;
+    y?: string;
+    fill?: string;
+    pattern?: string;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    legend?: boolean;
+    stat?: string;
+    stack?: boolean;
+    label?: boolean | string | ((data: Row) => unknown);
+    tooltip?: boolean | ((data: Row) => string);
+    xFormat?: Format;
+    yFormat?: Format;
+    xTicks?: number;
+    yTicks?: number;
+    minorTicks?: boolean;
+};
+declare const BarChart: import("svelte").Component<Props, {}, "">;
+type BarChart = ReturnType<typeof BarChart>;
+export default BarChart;

package/dist/charts/BoxPlot.svelte.d.ts

@@ -0,0 +1,18 @@
+type Row = Record<string, unknown>;
+type Props = {
+    data?: Row[];
+    x?: string;
+    y?: string;
+    fill?: string;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    legend?: boolean;
+    yFormat?: (v: unknown) => string;
+    yTicks?: number;
+    minorTicks?: boolean;
+};
+declare const BoxPlot: import("svelte").Component<Props, {}, "">;
+type BoxPlot = ReturnType<typeof BoxPlot>;
+export default BoxPlot;

package/dist/charts/BubbleChart.svelte.d.ts

@@ -0,0 +1,23 @@
+type Row = Record<string, unknown>;
+type Format = (v: unknown) => string;
+type Props = {
+    data?: Row[];
+    x?: string;
+    y?: string;
+    color?: string;
+    symbol?: string;
+    size?: string;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    legend?: boolean;
+    xFormat?: Format;
+    yFormat?: Format;
+    xTicks?: number;
+    yTicks?: number;
+    minorTicks?: boolean;
+};
+declare const BubbleChart: import("svelte").Component<Props, {}, "">;
+type BubbleChart = ReturnType<typeof BubbleChart>;
+export default BubbleChart;

package/dist/charts/LineChart.svelte.d.ts

@@ -0,0 +1,26 @@
+type Row = Record<string, unknown>;
+type Format = (v: unknown) => string;
+type Props = {
+    data?: Row[];
+    x?: string;
+    y?: string;
+    color?: string;
+    stat?: string;
+    symbol?: string;
+    curve?: 'linear' | 'smooth' | 'step';
+    label?: boolean | string | ((data: Row) => unknown);
+    tooltip?: boolean | ((data: Row) => string);
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    legend?: boolean;
+    xFormat?: Format;
+    yFormat?: Format;
+    xTicks?: number;
+    yTicks?: number;
+    minorTicks?: boolean;
+};
+declare const LineChart: import("svelte").Component<Props, {}, "">;
+type LineChart = ReturnType<typeof LineChart>;
+export default LineChart;

package/dist/charts/PieChart.svelte.d.ts

@@ -0,0 +1,19 @@
+type Row = Record<string, unknown>;
+type Props = {
+    data?: Row[];
+    label?: string;
+    y?: string;
+    fill?: string;
+    pattern?: string;
+    innerRadius?: number;
+    labelFn?: (data: Row) => string;
+    tooltip?: boolean | ((data: Row) => string);
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    legend?: boolean;
+    stat?: string;
+};
+declare const PieChart: import("svelte").Component<Props, {}, "">;
+type PieChart = ReturnType<typeof PieChart>;
+export default PieChart;

package/dist/charts/ScatterPlot.svelte.d.ts

@@ -0,0 +1,29 @@
+type Row = Record<string, unknown>;
+type Format = (v: unknown) => string;
+type Props = {
+    data?: Row[];
+    x?: string;
+    y?: string;
+    color?: string;
+    symbol?: string;
+    size?: string;
+    label?: boolean | string | ((data: Row) => unknown);
+    tooltip?: boolean | ((data: Row) => string);
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    legend?: boolean;
+    jitter?: {
+        width?: number;
+        height?: number;
+    } | null;
+    xFormat?: Format;
+    yFormat?: Format;
+    xTicks?: number;
+    yTicks?: number;
+    minorTicks?: boolean;
+};
+declare const ScatterPlot: import("svelte").Component<Props, {}, "">;
+type ScatterPlot = ReturnType<typeof ScatterPlot>;
+export default ScatterPlot;

package/dist/charts/ViolinPlot.svelte.d.ts

@@ -0,0 +1,18 @@
+type Row = Record<string, unknown>;
+type Props = {
+    data?: Row[];
+    x?: string;
+    y?: string;
+    fill?: string;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+    grid?: boolean;
+    legend?: boolean;
+    yFormat?: (v: unknown) => string;
+    yTicks?: number;
+    minorTicks?: boolean;
+};
+declare const ViolinPlot: import("svelte").Component<Props, {}, "">;
+type ViolinPlot = ReturnType<typeof ViolinPlot>;
+export default ViolinPlot;

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

@@ -0,0 +1,12 @@
+import type { Snippet } from 'svelte';
+import { createCrossFilter } from './createCrossFilter.svelte.js';
+type CrossFilter = ReturnType<typeof createCrossFilter>;
+type FilterState = CrossFilter['filters'];
+type Props = {
+    crossfilter?: CrossFilter;
+    mode?: 'dim' | 'hide';
+    filters?: FilterState;
+    children?: Snippet;
+};
+declare const CrossFilter: import("svelte").Component<Props, {}, "filters">;
+export default CrossFilter;

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

@@ -0,0 +1,12 @@
+type Props = {
+    data?: Record<string, unknown>[];
+    field?: string;
+    valueField?: string;
+    stat?: string;
+    width?: number;
+    height?: number;
+    mode?: 'light' | 'dark';
+};
+declare const FilterBar: import("svelte").Component<Props, {}, "">;
+type FilterBar = ReturnType<typeof FilterBar>;
+export default FilterBar;

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

@@ -0,0 +1,19 @@
+type Row = Record<string, unknown>;
+/**
+ * Interactive histogram with brush selection for crossfilter range dimensions.
+ * Renders bins as bars; mouse drag selects a range and calls cf.setRange().
+ * Click without dragging clears the filter.
+ */
+type Props = {
+    data?: Row[];
+    field?: string;
+    label?: string;
+    bins?: number;
+    width?: number;
+    height?: number;
+    color?: string;
+    dimColor?: string;
+};
+declare const FilterHistogram: import("svelte").Component<Props, {}, "">;
+type FilterHistogram = ReturnType<typeof FilterHistogram>;
+export default FilterHistogram;