@rokkit/chart 1.1.18 → 1.1.19

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

@@ -0,0 +1,15 @@
+/**
+ * Dual range slider for a continuous crossfilter dimension.
+ * NOTE: Interim implementation using HTML range inputs.
+ * The spec calls for a Plot+Point+brush architecture, deferred until brush geom is implemented.
+ */
+type Props = {
+    field: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    label?: string;
+};
+declare const FilterSlider: import("svelte").Component<Props, {}, "">;
+type FilterSlider = ReturnType<typeof FilterSlider>;
+export default FilterSlider;

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

@@ -0,0 +1,17 @@
+import type { Readable } from 'svelte/store';
+type Scales = {
+    x: (value: number) => number;
+};
+type Props = {
+    rank: number;
+    value: number;
+    name: string;
+    formatString?: string;
+    scales: Readable<Scales>;
+    height?: number;
+    fill?: string;
+    spaceBetween?: number;
+};
+declare const Bar: import("svelte").Component<Props, {}, "">;
+type Bar = ReturnType<typeof Bar>;
+export default Bar;

package/dist/elements/ColorRamp.svelte.d.ts

@@ -0,0 +1,17 @@
+type ColorScale = {
+    (value: number): string;
+    domain(): number[];
+    ticks(count?: number): number[];
+};
+type Props = {
+    x?: number;
+    y?: number;
+    textSize?: number;
+    height?: number;
+    width?: number;
+    tickCount?: number;
+    scale: ColorScale;
+};
+declare const ColorRamp: import("svelte").Component<Props, {}, "">;
+type ColorRamp = ReturnType<typeof ColorRamp>;
+export default ColorRamp;

package/dist/elements/ContinuousLegend.svelte.d.ts

@@ -0,0 +1,18 @@
+type ColorScale = {
+    (value: number): string;
+    domain(): number[];
+    ticks?(count?: number): number[];
+};
+type Props = {
+    x?: number;
+    y?: number;
+    textSize?: number;
+    height?: number;
+    width?: number;
+    tickCount?: number;
+    scale: ColorScale;
+    id?: string;
+};
+declare const ContinuousLegend: import("svelte").Component<Props, {}, "">;
+type ContinuousLegend = ReturnType<typeof ContinuousLegend>;
+export default ContinuousLegend;

package/dist/elements/DefinePatterns.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { Component } from 'svelte';
+import type { SVGAttributes } from 'svelte/elements';
+type PatternComponentProps = {
+    size?: number;
+    fill?: string;
+    stroke?: string;
+};
+type Pattern = {
+    id: string;
+    component: Component<PatternComponentProps>;
+    fill?: string;
+    stroke?: string;
+};
+type Props = {
+    size?: number;
+    patternUnits?: SVGAttributes<SVGPatternElement>['patternUnits'];
+    patterns?: Pattern[];
+};
+declare const DefinePatterns: Component<Props, {}, "">;
+type DefinePatterns = ReturnType<typeof DefinePatterns>;
+export default DefinePatterns;

package/dist/elements/DiscreteLegend.svelte.d.ts

@@ -0,0 +1,17 @@
+type ColorScale = {
+    (value: number): string;
+    ticks(count?: number): number[];
+};
+type Props = {
+    x?: number;
+    y?: number;
+    textSize?: number;
+    size?: number;
+    space?: number;
+    padding?: number;
+    scale: ColorScale;
+    tickCount?: number;
+};
+declare const DiscreteLegend: import("svelte").Component<Props, {}, "">;
+type DiscreteLegend = ReturnType<typeof DiscreteLegend>;
+export default DiscreteLegend;

package/dist/elements/Label.svelte.d.ts

@@ -0,0 +1,11 @@
+type Props = {
+    x: number;
+    y: number;
+    text: string;
+    angle?: number;
+    small?: boolean;
+    anchor?: string;
+};
+declare const Label: import("svelte").Component<Props, {}, "">;
+type Label = ReturnType<typeof Label>;
+export default Label;

package/dist/elements/SymbolGrid.svelte.d.ts

@@ -0,0 +1,8 @@
+type Props = {
+    base?: string;
+    size?: number;
+    shade?: number;
+};
+declare const SymbolGrid: import("svelte").Component<Props, {}, "">;
+type SymbolGrid = ReturnType<typeof SymbolGrid>;
+export default SymbolGrid;

package/dist/examples/BarChartExample.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 BarChartExample: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type BarChartExample = InstanceType<typeof BarChartExample>;
+export default BarChartExample;

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

@@ -0,0 +1,20 @@
+type Row = Record<string, unknown>;
+/**
+ * `fill` is the primary prop name; `color` is accepted as an alias for
+ * spec-driven usage (Plot.svelte passes `color` to all geoms generically).
+ */
+type Props = {
+    theta?: string;
+    fill?: string;
+    color?: string;
+    pattern?: string;
+    stat?: string;
+    labelFn?: (data: Row) => string;
+    options?: {
+        innerRadius?: number;
+    };
+    onselect?: (data: Row) => void;
+};
+declare const Arc: import("svelte").Component<Props, {}, "">;
+type Arc = ReturnType<typeof Arc>;
+export default Arc;

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

@@ -0,0 +1,16 @@
+type Options = {
+    stack?: boolean;
+    curve?: 'linear' | 'smooth' | 'step';
+    opacity?: number;
+};
+type Props = {
+    x?: string;
+    y?: string;
+    color?: string;
+    pattern?: string;
+    stat?: string;
+    options?: Options;
+};
+declare const Area: import("svelte").Component<Props, {}, "">;
+type Area = ReturnType<typeof Area>;
+export default Area;

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

@@ -0,0 +1,23 @@
+type Row = Record<string, unknown>;
+type Options = {
+    stack?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    labelInside?: boolean;
+    labelOffset?: number;
+};
+type Props = {
+    x?: string;
+    y?: string;
+    color?: string;
+    fill?: string;
+    pattern?: string;
+    label?: boolean | string | ((data: Row) => unknown);
+    stat?: string;
+    options?: Options;
+    filterable?: boolean;
+    onselect?: (data: Row) => void;
+    keyboard?: boolean;
+};
+declare const Bar: import("svelte").Component<Props, {}, "">;
+type Bar = ReturnType<typeof Bar>;
+export default Bar;

package/dist/geoms/Box.svelte.d.ts

@@ -0,0 +1,12 @@
+type Props = {
+    x?: string;
+    y?: string;
+    fill?: string;
+    stat?: string;
+    options?: {
+        opacity?: number;
+    };
+};
+declare const Box: import("svelte").Component<Props, {}, "">;
+type Box = ReturnType<typeof Box>;
+export default Box;

package/dist/geoms/Candlestick.svelte.d.ts

@@ -0,0 +1,20 @@
+type Options = {
+    open?: string;
+    high?: string;
+    low?: string;
+    close?: string;
+    upColor?: string;
+    downColor?: string;
+    wickWidth?: number;
+};
+type Props = {
+    x?: string;
+    y?: string;
+    color?: string;
+    fill?: string;
+    stat?: string;
+    options?: Options;
+};
+declare const Candlestick: import("svelte").Component<Props, {}, "">;
+type Candlestick = ReturnType<typeof Candlestick>;
+export default Candlestick;

package/dist/geoms/Heatmap.svelte.d.ts

@@ -0,0 +1,13 @@
+type Props = {
+    x?: string;
+    y?: string;
+    color?: string;
+    fill?: string;
+    stat?: string;
+    options?: {
+        rounded?: number;
+    };
+};
+declare const Heatmap: import("svelte").Component<Props, {}, "">;
+type Heatmap = ReturnType<typeof Heatmap>;
+export default Heatmap;

package/dist/geoms/Hexbin.svelte.d.ts

@@ -0,0 +1,13 @@
+type Props = {
+    x?: string;
+    y?: string;
+    color?: string;
+    fill?: string;
+    stat?: string;
+    options?: {
+        radius?: number;
+    };
+};
+declare const Hexbin: import("svelte").Component<Props, {}, "">;
+type Hexbin = ReturnType<typeof Hexbin>;
+export default Hexbin;

package/dist/geoms/LabelPill.svelte.d.ts

@@ -0,0 +1,9 @@
+type Props = {
+    x: number;
+    y: number;
+    text: string;
+    color?: string;
+};
+declare const LabelPill: import("svelte").Component<Props, {}, "">;
+type LabelPill = ReturnType<typeof LabelPill>;
+export default LabelPill;

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

@@ -0,0 +1,24 @@
+type Row = Record<string, unknown>;
+type Options = {
+    curve?: 'linear' | 'smooth' | 'step';
+    strokeWidth?: number;
+    markerRadius?: number;
+    labelOffset?: {
+        x?: number;
+        y?: number;
+    };
+};
+type Props = {
+    x?: string;
+    y?: string;
+    color?: string;
+    symbol?: string;
+    label?: boolean | string | ((data: Row) => unknown);
+    stat?: string;
+    options?: Options;
+    onselect?: (data: Row) => void;
+    keyboard?: boolean;
+};
+declare const Line: import("svelte").Component<Props, {}, "">;
+type Line = ReturnType<typeof Line>;
+export default Line;

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

@@ -0,0 +1,30 @@
+type Row = Record<string, unknown>;
+type Options = {
+    minRadius?: number;
+    maxRadius?: number;
+    radius?: number;
+    opacity?: number;
+    jitter?: {
+        width?: number;
+        height?: number;
+    } | null;
+    labelOffset?: {
+        x?: number;
+        y?: number;
+    };
+};
+type Props = {
+    x?: string;
+    y?: string;
+    color?: string;
+    size?: string;
+    symbol?: string;
+    label?: boolean | string | ((data: Row) => unknown);
+    stat?: string;
+    options?: Options;
+    onselect?: (data: Row) => void;
+    keyboard?: boolean;
+};
+declare const Point: import("svelte").Component<Props, {}, "">;
+type Point = ReturnType<typeof Point>;
+export default Point;

package/dist/geoms/Ribbon.svelte.d.ts

@@ -0,0 +1,16 @@
+type Options = {
+    source?: string;
+    target?: string;
+    value?: string;
+};
+type Props = {
+    x?: string;
+    y?: string;
+    color?: string;
+    fill?: string;
+    stat?: string;
+    options?: Options;
+};
+declare const Ribbon: import("svelte").Component<Props, {}, "">;
+type Ribbon = ReturnType<typeof Ribbon>;
+export default Ribbon;

package/dist/geoms/Violin.svelte.d.ts

@@ -0,0 +1,12 @@
+type Props = {
+    x?: string;
+    y?: string;
+    fill?: string;
+    stat?: string;
+    options?: {
+        opacity?: number;
+    };
+};
+declare const Violin: import("svelte").Component<Props, {}, "">;
+type Violin = ReturnType<typeof Violin>;
+export default Violin;

package/dist/geoms/Waterfall.svelte.d.ts

@@ -0,0 +1,18 @@
+type Options = {
+    positiveColor?: string;
+    negativeColor?: string;
+    totalColor?: string;
+    totalField?: string;
+    connectorWidth?: number;
+};
+type Props = {
+    x?: string;
+    y?: string;
+    color?: string;
+    fill?: string;
+    stat?: string;
+    options?: Options;
+};
+declare const Waterfall: import("svelte").Component<Props, {}, "">;
+type Waterfall = ReturnType<typeof Waterfall>;
+export default Waterfall;

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

@@ -2,7 +2,7 @@
  * Builds area path geometry for multi-series area charts.
  *
  * @param {Object[]} data
- * @param {{ x: string, y: string, color?: string }} channels
+ * @param {{ x: string, y: string, color?: string, pattern?: string }} channels
  * @param {Function} xScale
  * @param {Function} yScale
  * @param {Map<unknown, {fill: string, stroke: string}>} colors
@@ -14,6 +14,7 @@ export function buildAreas(data: Object[], channels: {
     x: string;
     y: string;
     color?: string;
+    pattern?: string;
 }, xScale: Function, yScale: Function, colors: Map<unknown, {
     fill: string;
     stroke: string;
@@ -28,7 +29,7 @@ export function buildAreas(data: Object[], channels: {
  * Builds stacked area paths using d3 stack layout.
  *
  * @param {Object[]} data
- * @param {{ x: string, y: string, color: string }} channels
+ * @param {{ x: string, y: string, color?: string, pattern?: string }} channels
  * @param {Function} xScale
  * @param {Function} yScale
  * @param {Map<unknown, {fill: string, stroke: string}>} colors
@@ -39,7 +40,8 @@ export function buildAreas(data: Object[], channels: {
 export function buildStackedAreas(data: Object[], channels: {
     x: string;
     y: string;
-    color: string;
+    color?: string;
+    pattern?: string;
 }, xScale: Function, yScale: Function, colors: Map<unknown, {
     fill: string;
     stroke: string;

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

@@ -39,23 +39,23 @@ export class ChartBrewer {
     symbolMap: Map<unknown, string>;
     get innerWidth(): number;
     get innerHeight(): number;
-    xScale: any;
-    yScale: any;
-    sizeScale: any;
+    xScale: import("d3-scale").ScaleBand<string> | (number[] & import("d3-scale").ScaleLinear<number, number, never>) | null;
+    yScale: import("d3-scale").ScaleLinear<number, number, never> | null;
+    sizeScale: import("d3-scale").ScalePower<number, number, never> | null;
     bars: any;
     lines: {
-        d: string;
+        d: string | null;
         fill: string;
         stroke: string;
         points: {
             x: number;
             y: number;
-            data: Object;
+            data: Record<string, unknown>;
         }[];
         key?: unknown;
     }[];
     areas: {
-        d: any;
+        d: string | null;
         fill: any;
         stroke: string;
         key: any;
@@ -63,23 +63,32 @@ export class ChartBrewer {
         patternKey: any;
         patternId: string | null;
     }[] | {
-        d: any;
+        d: never;
         fill: any;
         stroke: string;
         colorKey: null;
         patternKey: null;
         patternId: null;
     }[];
-    arcs: any;
+    arcs: {
+        d: string | null;
+        fill: string;
+        stroke: string;
+        key: unknown;
+        patternId: string | null;
+        pct: number;
+        centroid: [number, number];
+        data: Record<string, unknown>;
+    }[];
     points: {
-        data: Object;
-        cx: any;
-        cy: any;
-        r: any;
-        fill: any;
-        stroke: any;
+        data: Record<string, unknown>;
+        cx: number;
+        cy: number;
+        r: number;
+        fill: string;
+        stroke: string;
         symbolPath: string | null;
-        key: any;
+        key: unknown;
     }[];
     legendGroups: {
         field: any;

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

@@ -1,17 +1,27 @@
 /**
  * Builds arc geometry for pie/donut charts.
- * @param {Object[]} data
- * @param {{ color: string, y: string, pattern?: string }} channels
+ * @param {Record<string, unknown>[]} 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]
+ * @returns {{ d: string | null, fill: string, stroke: string, key: unknown, patternId: string | null, pct: number, centroid: [number, number], data: Record<string, unknown> }[]}
  */
-export function buildArcs(data: Object[], channels: {
-    color: string;
-    y: string;
+export function buildArcs(data: Record<string, unknown>[], channels: {
+    color?: string;
+    y?: string;
     pattern?: string;
 }, colors: Map<any, any>, width: number, height: number, opts?: {
     innerRadius?: number;
-}, patterns?: Map<unknown, string>): any;
+}, patterns?: Map<unknown, string>): {
+    d: string | null;
+    fill: string;
+    stroke: string;
+    key: unknown;
+    patternId: string | null;
+    pct: number;
+    centroid: [number, number];
+    data: Record<string, unknown>;
+}[];

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

@@ -14,7 +14,7 @@ export function buildAreas(data: Object[], channels: {
     fill?: string;
     pattern?: string;
 }, xScale: Function, yScale: Function, colors: Map<any, any>, curve?: "linear" | "smooth" | "step", patternMap?: Map<any, any>): {
-    d: any;
+    d: string | null;
     fill: any;
     stroke: string;
     key: any;
@@ -22,7 +22,7 @@ export function buildAreas(data: Object[], channels: {
     patternKey: any;
     patternId: string | null;
 }[] | {
-    d: any;
+    d: never;
     fill: any;
     stroke: string;
     colorKey: null;

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

@@ -8,7 +8,7 @@
  * 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
+ * @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
@@ -16,9 +16,9 @@
  * @returns {Array}
  */
 export function buildBoxes(data: Object[], channels: {
-    x: string;
+    x?: string;
     fill?: string;
-}, xScale: any, yScale: any, colors: Map<unknown, {
+}, xScale: import("d3-scale").ScaleBand<any>, yScale: import("d3-scale").ScaleLinear<any, any, never>, colors: Map<unknown, {
     fill: string;
     stroke: string;
 }>): any[];

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

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

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

@@ -23,8 +23,8 @@ export function buildSymbolPath(shapeName: string, r: number): string;
 export function jitterOffset(i: number, range: number): number;
 /**
  * Builds point geometry for scatter/bubble charts.
- * @param {Object[]} data
- * @param {{ x: string, y: string, color?: string, size?: string, symbol?: string }} channels
+ * @param {Record<string, unknown>[]} data
+ * @param {{ x?: string, y?: string, color?: string, size?: string, symbol?: string }} channels
  * @param {Function} xScale
  * @param {Function} yScale
  * @param {Map} colors
@@ -32,10 +32,11 @@ export function jitterOffset(i: number, range: number): number;
  * @param {Map<unknown, string>|null} symbolMap  — maps symbol field value → shape name
  * @param {number} defaultRadius
  * @param {{ width?: number, height?: number }|null} jitter
+ * @returns {{ data: Record<string, unknown>, cx: number, cy: number, r: number, fill: string, stroke: string, symbolPath: string | null, key: unknown }[]}
  */
-export function buildPoints(data: Object[], channels: {
-    x: string;
-    y: string;
+export function buildPoints(data: Record<string, unknown>[], channels: {
+    x?: string;
+    y?: string;
     color?: string;
     size?: string;
     symbol?: string;
@@ -43,13 +44,13 @@ export function buildPoints(data: Object[], channels: {
     width?: number;
     height?: number;
 } | null): {
-    data: Object;
-    cx: any;
-    cy: any;
-    r: any;
-    fill: any;
-    stroke: any;
+    data: Record<string, unknown>;
+    cx: number;
+    cy: number;
+    r: number;
+    fill: string;
+    stroke: string;
     symbolPath: string | null;
-    key: any;
+    key: unknown;
 }[];
 import { defaultPreset } from '../../preset.js';