semiotic 2.0.3 → 3.0.0-beta.2

package/dist/stream/networkTypes.d.ts

@@ -0,0 +1,346 @@
+import type { ReactNode } from "react";
+import type { HoverData, AnnotationContext } from "../realtime/types";
+import type { LegendGroup } from "../types/legendTypes";
+import type { Style } from "./types";
+export interface TensionConfig {
+    weightChange: number;
+    newEdge: number;
+    newNode: number;
+    threshold: number;
+    transitionDuration: number;
+}
+export declare const DEFAULT_TENSION_CONFIG: TensionConfig;
+export interface RealtimeNode {
+    id: string;
+    x0: number;
+    x1: number;
+    y0: number;
+    y1: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    _prevX0?: number;
+    _prevX1?: number;
+    _prevY0?: number;
+    _prevY1?: number;
+    _targetX0?: number;
+    _targetX1?: number;
+    _targetY0?: number;
+    _targetY1?: number;
+    value: number;
+    depth?: number;
+    data?: Record<string, any>;
+    createdByFrame?: boolean;
+    sourceLinks?: RealtimeEdge[];
+    targetLinks?: RealtimeEdge[];
+}
+export interface RealtimeEdge {
+    source: RealtimeNode | string;
+    target: RealtimeNode | string;
+    value: number;
+    y0: number;
+    y1: number;
+    sankeyWidth: number;
+    _prevY0?: number;
+    _prevY1?: number;
+    _prevSankeyWidth?: number;
+    _targetY0?: number;
+    _targetY1?: number;
+    _targetSankeyWidth?: number;
+    direction?: string;
+    circular?: boolean;
+    circularPathData?: any;
+    bezier?: BezierCache;
+    data?: Record<string, any>;
+}
+export interface BezierPoint {
+    x: number;
+    y: number;
+}
+export interface BezierCache {
+    circular: boolean;
+    points?: [BezierPoint, BezierPoint, BezierPoint, BezierPoint];
+    segments?: Array<[BezierPoint, BezierPoint, BezierPoint, BezierPoint]>;
+    halfWidth: number;
+}
+export interface Particle {
+    t: number;
+    offset: number;
+    edgeIndex: number;
+    active: boolean;
+    x: number;
+    y: number;
+}
+export interface ParticleStyle {
+    radius?: number;
+    color?: string | ((edge: RealtimeEdge, node: RealtimeNode) => string);
+    /** Color particles by source or target node (default: "source") */
+    colorBy?: "source" | "target";
+    opacity?: number;
+    speedMultiplier?: number;
+    maxPerEdge?: number;
+    spawnRate?: number;
+}
+export declare const DEFAULT_PARTICLE_STYLE: Required<Pick<ParticleStyle, "radius" | "opacity" | "speedMultiplier" | "maxPerEdge" | "spawnRate">>;
+export interface EdgePush {
+    source: string;
+    target: string;
+    value: number;
+}
+export type { HoverData };
+export type RealtimeNetworkFrameHandle = StreamNetworkFrameHandle;
+export interface RealtimeNetworkFrameProps {
+    initialEdges?: EdgePush[];
+    size?: [number, number];
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    orientation?: "horizontal" | "vertical";
+    nodeAlign?: "justify" | "left" | "right" | "center";
+    nodePaddingRatio?: number;
+    nodeWidth?: number;
+    tensionConfig?: Partial<TensionConfig>;
+    showParticles?: boolean;
+    particleStyle?: ParticleStyle;
+    colorBy?: string | ((d: RealtimeNode) => string);
+    colorScheme?: string | string[];
+    edgeColorBy?: "source" | "target" | ((d: RealtimeEdge) => string);
+    edgeOpacity?: number;
+    nodeLabel?: string | ((d: RealtimeNode) => string);
+    showLabels?: boolean;
+    enableHover?: boolean;
+    tooltipContent?: (d: {
+        type: "node" | "edge";
+        data: any;
+    }) => ReactNode;
+    onTopologyChange?: (nodes: RealtimeNode[], edges: RealtimeEdge[]) => void;
+    background?: string;
+    className?: string;
+}
+export type NetworkChartType = "force" | "sankey" | "chord" | "tree" | "cluster" | "treemap" | "circlepack" | "partition";
+/** Circle node — used by force, tree, cluster, circlepack */
+export interface NetworkCircleNode {
+    type: "circle";
+    cx: number;
+    cy: number;
+    r: number;
+    style: Style;
+    datum: any;
+    id?: string;
+    label?: string;
+    depth?: number;
+}
+/** Rect node — used by sankey, treemap, partition */
+export interface NetworkRectNode {
+    type: "rect";
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    style: Style;
+    datum: any;
+    id?: string;
+    label?: string;
+    depth?: number;
+}
+/** Arc node — used by chord */
+export interface NetworkArcNode {
+    type: "arc";
+    cx: number;
+    cy: number;
+    innerR: number;
+    outerR: number;
+    startAngle: number;
+    endAngle: number;
+    style: Style;
+    datum: any;
+    id?: string;
+    label?: string;
+}
+/** Line edge — used by force */
+export interface NetworkLineEdge {
+    type: "line";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    style: Style;
+    datum: any;
+}
+/** Bezier band edge — used by sankey */
+export interface NetworkBezierEdge {
+    type: "bezier";
+    pathD: string;
+    bezierCache?: BezierCache;
+    style: Style;
+    datum: any;
+}
+/** Ribbon edge — used by chord */
+export interface NetworkRibbonEdge {
+    type: "ribbon";
+    pathD: string;
+    style: Style;
+    datum: any;
+}
+/** Curved edge — used by tree, cluster */
+export interface NetworkCurvedEdge {
+    type: "curved";
+    pathD: string;
+    style: Style;
+    datum: any;
+}
+export type NetworkSceneNode = NetworkCircleNode | NetworkRectNode | NetworkArcNode;
+export type NetworkSceneEdge = NetworkLineEdge | NetworkBezierEdge | NetworkRibbonEdge | NetworkCurvedEdge;
+/** Label data for the SVG overlay */
+export interface NetworkLabel {
+    x: number;
+    y: number;
+    text: string;
+    anchor?: "start" | "middle" | "end";
+    baseline?: string;
+    fontSize?: number;
+    fontWeight?: number | string;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    paintOrder?: string;
+}
+export interface NetworkLayoutPlugin {
+    /**
+     * Run the layout algorithm. May mutate node/edge positions directly.
+     * For bounded data, called once. For streaming, called on topology changes.
+     */
+    computeLayout(nodes: RealtimeNode[], edges: RealtimeEdge[], config: NetworkPipelineConfig, size: [number, number]): void;
+    /**
+     * Build scene nodes + labels from the positioned node/edge data.
+     */
+    buildScene(nodes: RealtimeNode[], edges: RealtimeEdge[], config: NetworkPipelineConfig, size: [number, number]): {
+        sceneNodes: NetworkSceneNode[];
+        sceneEdges: NetworkSceneEdge[];
+        labels: NetworkLabel[];
+    };
+    /** Whether this layout supports incremental streaming updates */
+    supportsStreaming: boolean;
+    /** Whether this layout uses hierarchical (tree) input instead of nodes+edges */
+    hierarchical: boolean;
+}
+export interface NetworkPipelineConfig {
+    chartType: NetworkChartType;
+    nodeIDAccessor?: string | ((d: any) => string);
+    sourceAccessor?: string | ((d: any) => string);
+    targetAccessor?: string | ((d: any) => string);
+    valueAccessor?: string | ((d: any) => number);
+    childrenAccessor?: string | ((d: any) => any[]);
+    hierarchySum?: (d: any) => number;
+    orientation?: "horizontal" | "vertical";
+    nodeAlign?: "justify" | "left" | "right" | "center";
+    nodePaddingRatio?: number;
+    nodeWidth?: number;
+    edgeSort?: (a: any, b: any) => number;
+    iterations?: number;
+    forceStrength?: number;
+    padAngle?: number;
+    groupWidth?: number;
+    sortGroups?: (a: any, b: any) => number;
+    treeOrientation?: "vertical" | "horizontal" | "radial";
+    edgeType?: "line" | "curve";
+    padding?: number;
+    paddingTop?: number;
+    tensionConfig?: TensionConfig;
+    showParticles?: boolean;
+    particleStyle?: ParticleStyle;
+    nodeStyle?: (d: any) => Record<string, any>;
+    edgeStyle?: (d: any) => Record<string, any>;
+    nodeLabel?: string | ((d: any) => string);
+    showLabels?: boolean;
+    colorBy?: string | ((d: any) => string);
+    colorScheme?: string | string[];
+    edgeColorBy?: "source" | "target" | "gradient" | ((d: any) => string);
+    edgeOpacity?: number;
+    colorByDepth?: boolean;
+    nodeSize?: number | string | ((d: any) => number);
+    nodeSizeRange?: [number, number];
+}
+export interface StreamNetworkFrameProps<T = Record<string, any>> {
+    chartType: NetworkChartType;
+    nodes?: T[];
+    edges?: T[] | T;
+    /** Hierarchy root (alias for edges when using tree/treemap/circlepack) */
+    data?: T;
+    initialEdges?: EdgePush[];
+    nodeIDAccessor?: string | ((d: T) => string);
+    sourceAccessor?: string | ((d: T) => string);
+    targetAccessor?: string | ((d: T) => string);
+    valueAccessor?: string | ((d: T) => number);
+    childrenAccessor?: string | ((d: T) => T[]);
+    hierarchySum?: (d: T) => number;
+    orientation?: "horizontal" | "vertical";
+    nodeAlign?: "justify" | "left" | "right" | "center";
+    nodePaddingRatio?: number;
+    nodeWidth?: number;
+    iterations?: number;
+    forceStrength?: number;
+    padAngle?: number;
+    groupWidth?: number;
+    sortGroups?: (a: any, b: any) => number;
+    edgeSort?: (a: any, b: any) => number;
+    treeOrientation?: "vertical" | "horizontal" | "radial";
+    edgeType?: "line" | "curve";
+    padding?: number;
+    paddingTop?: number;
+    tensionConfig?: Partial<TensionConfig>;
+    showParticles?: boolean;
+    particleStyle?: ParticleStyle;
+    nodeStyle?: (d: any) => Record<string, any>;
+    edgeStyle?: (d: any) => Record<string, any>;
+    colorBy?: string | ((d: any) => string);
+    colorScheme?: string | string[];
+    edgeColorBy?: "source" | "target" | "gradient" | ((d: any) => string);
+    edgeOpacity?: number;
+    colorByDepth?: boolean;
+    nodeSize?: number | string | ((d: any) => number);
+    nodeSizeRange?: [number, number];
+    nodeLabel?: string | ((d: any) => string);
+    showLabels?: boolean;
+    size?: [number, number];
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    className?: string;
+    background?: string;
+    enableHover?: boolean;
+    tooltipContent?: (d: {
+        type: "node" | "edge";
+        data: any;
+        x: number;
+        y: number;
+    }) => ReactNode;
+    onTopologyChange?: (nodes: RealtimeNode[], edges: RealtimeEdge[]) => void;
+    annotations?: Record<string, any>[];
+    svgAnnotationRules?: (annotation: Record<string, any>, index: number, context: AnnotationContext) => ReactNode;
+    legend?: ReactNode | {
+        legendGroups: LegendGroup[];
+    };
+    title?: string | ReactNode;
+    foregroundGraphics?: ReactNode;
+    backgroundGraphics?: ReactNode;
+}
+export interface StreamNetworkFrameHandle {
+    push(edge: EdgePush): void;
+    pushMany(edges: EdgePush[]): void;
+    clear(): void;
+    getTopology(): {
+        nodes: RealtimeNode[];
+        edges: RealtimeEdge[];
+    };
+    relayout(): void;
+    getTension(): number;
+}
+export type NetworkRendererFn = (ctx: CanvasRenderingContext2D, nodes: NetworkSceneNode[], edges: NetworkSceneEdge[], size: [number, number]) => void;

package/dist/stream/ordinalSceneBuilders/barScene.d.ts

@@ -0,0 +1,4 @@
+import type { OrdinalSceneNode, OrdinalLayout } from "../ordinalTypes";
+import type { OrdinalSceneContext } from "./types";
+export declare function buildBarScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];
+export declare function buildClusterBarScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];

package/dist/stream/ordinalSceneBuilders/connectorScene.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectorSceneNode, OrdinalSceneNode, OrdinalLayout } from "../ordinalTypes";
+import type { OrdinalSceneContext } from "./types";
+export declare function buildConnectors(ctx: OrdinalSceneContext, pieceNodes: OrdinalSceneNode[], layout: OrdinalLayout): ConnectorSceneNode[];

package/dist/stream/ordinalSceneBuilders/pieScene.d.ts

@@ -0,0 +1,3 @@
+import type { WedgeSceneNode, OrdinalLayout } from "../ordinalTypes";
+import type { OrdinalSceneContext } from "./types";
+export declare function buildPieScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): WedgeSceneNode[];

package/dist/stream/ordinalSceneBuilders/pointScene.d.ts

@@ -0,0 +1,4 @@
+import type { OrdinalSceneNode, OrdinalLayout } from "../ordinalTypes";
+import type { OrdinalSceneContext } from "./types";
+export declare function buildPointScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];
+export declare function buildSwarmScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];

package/dist/stream/ordinalSceneBuilders/statisticalScene.d.ts

@@ -0,0 +1,6 @@
+import type { OrdinalSceneNode, OrdinalLayout } from "../ordinalTypes";
+import type { OrdinalSceneContext } from "./types";
+export declare function buildBoxplotScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];
+export declare function buildViolinScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];
+export declare function buildHistogramScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];
+export declare function buildRidgelineScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];

package/dist/stream/ordinalSceneBuilders/timelineScene.d.ts

@@ -0,0 +1,3 @@
+import type { OrdinalSceneNode, OrdinalLayout } from "../ordinalTypes";
+import type { OrdinalSceneContext } from "./types";
+export declare function buildTimelineScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];

package/dist/stream/ordinalSceneBuilders/types.d.ts

@@ -0,0 +1,21 @@
+import type { ScaleLinear } from "d3-scale";
+import type { OrdinalScales, OrdinalColumn, OrdinalPipelineConfig, OrdinalSceneNode, OrdinalLayout } from "../ordinalTypes";
+import type { Style } from "../types";
+export interface OrdinalSceneContext {
+    scales: OrdinalScales;
+    columns: Record<string, OrdinalColumn>;
+    config: OrdinalPipelineConfig;
+    getR: (d: any) => number;
+    getStack?: (d: any) => string;
+    getGroup?: (d: any) => string;
+    getColor?: (d: any) => string;
+    getConnector?: (d: any) => string;
+    getO: (d: any) => string;
+    multiScales: ScaleLinear<number, number>[];
+    rAccessors: ((d: any) => number)[];
+    resolvePieceStyle: (d: any, category?: string) => Style;
+    resolveSummaryStyle: (d: any, category?: string) => Style;
+    /** For timeline: resolve rAccessor as [start, end] */
+    getRawRange: (d: any) => [number, number] | null;
+}
+export type SceneBuilderFn = (ctx: OrdinalSceneContext, layout: OrdinalLayout) => OrdinalSceneNode[];

package/dist/stream/ordinalTypes.d.ts

@@ -0,0 +1,225 @@
+import type { ReactNode } from "react";
+import type { ScaleLinear, ScaleBand } from "d3-scale";
+import type { ArrowOfTime, WindowMode, HoverAnnotationConfig, HoverData, AnnotationContext } from "../realtime/types";
+import type { Style, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig } from "./types";
+import type { LegendGroup } from "../types/legendTypes";
+export type OrdinalChartType = "bar" | "clusterbar" | "point" | "swarm" | "pie" | "donut" | "boxplot" | "violin" | "histogram" | "ridgeline" | "timeline";
+export interface OrdinalScales {
+    o: ScaleBand<string>;
+    r: ScaleLinear<number, number>;
+    projection: "vertical" | "horizontal" | "radial";
+}
+export interface WedgeSceneNode {
+    type: "wedge";
+    cx: number;
+    cy: number;
+    innerRadius: number;
+    outerRadius: number;
+    startAngle: number;
+    endAngle: number;
+    style: Style;
+    datum: any;
+    category?: string;
+}
+export interface BoxplotSceneNode {
+    type: "boxplot";
+    /** Pixel x position of the column center */
+    x: number;
+    /** Pixel y of the value axis origin */
+    y: number;
+    projection: "vertical" | "horizontal";
+    columnWidth: number;
+    /** Pre-projected pixel positions for each quantile */
+    minPos: number;
+    q1Pos: number;
+    medianPos: number;
+    q3Pos: number;
+    maxPos: number;
+    stats: {
+        min: number;
+        q1: number;
+        median: number;
+        q3: number;
+        max: number;
+    };
+    style: Style;
+    datum: any;
+    category?: string;
+    outliers?: {
+        px: number;
+        py: number;
+        value: number;
+        datum: any;
+    }[];
+}
+export interface ViolinSceneNode {
+    type: "violin";
+    /** Pre-computed SVG path string for Path2D */
+    pathString: string;
+    /** Translation for the path */
+    translateX: number;
+    translateY: number;
+    /** Bounding box for hit testing */
+    bounds?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Optional IQR line overlay */
+    iqrLine?: {
+        q1Pos: number;
+        medianPos: number;
+        q3Pos: number;
+    };
+    style: Style;
+    datum: any;
+    category?: string;
+}
+export interface ConnectorSceneNode {
+    type: "connector";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    style: Style;
+    datum: any;
+    group?: string;
+}
+export type { Style, PointSceneNode, RectSceneNode } from "./types";
+import type { PointSceneNode, RectSceneNode } from "./types";
+export type OrdinalSceneNode = RectSceneNode | PointSceneNode | WedgeSceneNode | BoxplotSceneNode | ViolinSceneNode | ConnectorSceneNode;
+export interface OrdinalColumn {
+    name: string;
+    x: number;
+    y: number;
+    width: number;
+    middle: number;
+    padding: number;
+    pieceData: Record<string, any>[];
+    /** For radial: proportion of total (0-1) */
+    pct: number;
+    /** For radial: cumulative start proportion */
+    pctStart: number;
+}
+export interface OrdinalPipelineConfig {
+    chartType: OrdinalChartType;
+    runtimeMode?: "bounded" | "streaming";
+    windowSize: number;
+    windowMode: WindowMode;
+    extentPadding: number;
+    projection: "vertical" | "horizontal" | "radial";
+    oAccessor?: string | ((d: any) => string);
+    rAccessor?: string | ((d: any) => number) | Array<string | ((d: any) => number)>;
+    colorAccessor?: string | ((d: any) => string);
+    stackBy?: string | ((d: any) => string);
+    groupBy?: string | ((d: any) => string);
+    multiAxis?: boolean;
+    timeAccessor?: string | ((d: any) => number);
+    valueAccessor?: string | ((d: any) => number);
+    categoryAccessor?: string | ((d: any) => string);
+    rExtent?: [number?, number?];
+    oExtent?: string[];
+    barPadding?: number;
+    innerRadius?: number;
+    normalize?: boolean;
+    startAngle?: number;
+    bins?: number;
+    showOutliers?: boolean;
+    showIQR?: boolean;
+    amplitude?: number;
+    oSort?: ((a: string, b: string) => number) | boolean | "asc" | "desc";
+    connectorAccessor?: string | ((d: any) => string);
+    connectorStyle?: Style | ((d: any) => Style);
+    dynamicColumnWidth?: string | ((data: any[]) => number);
+    pieceStyle?: (d: any, category?: string) => Style;
+    summaryStyle?: (d: any, category?: string) => Style;
+    colorScheme?: string | string[];
+    barColors?: Record<string, string>;
+    decay?: DecayConfig;
+    pulse?: PulseConfig;
+    transition?: TransitionConfig;
+    staleness?: StalenessConfig;
+}
+export interface StreamOrdinalFrameProps<T = Record<string, any>> {
+    chartType: OrdinalChartType;
+    runtimeMode?: "bounded" | "streaming";
+    data?: T[];
+    oAccessor?: string | ((d: T) => string);
+    rAccessor?: string | ((d: T) => number) | Array<string | ((d: T) => number)>;
+    colorAccessor?: string | ((d: T) => string);
+    stackBy?: string | ((d: T) => string);
+    groupBy?: string | ((d: T) => string);
+    multiAxis?: boolean;
+    timeAccessor?: string | ((d: T) => number);
+    valueAccessor?: string | ((d: T) => number);
+    categoryAccessor?: string | ((d: T) => string);
+    projection?: "vertical" | "horizontal" | "radial";
+    size?: [number, number];
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    barPadding?: number;
+    innerRadius?: number;
+    normalize?: boolean;
+    startAngle?: number;
+    dynamicColumnWidth?: string | ((data: T[]) => number);
+    bins?: number;
+    showOutliers?: boolean;
+    showIQR?: boolean;
+    amplitude?: number;
+    rExtent?: [number?, number?];
+    oExtent?: string[];
+    extentPadding?: number;
+    oSort?: ((a: string, b: string) => number) | boolean | "asc" | "desc";
+    arrowOfTime?: ArrowOfTime;
+    windowMode?: WindowMode;
+    windowSize?: number;
+    connectorAccessor?: string | ((d: T) => string);
+    connectorStyle?: Style | ((d: any) => Style);
+    pieceStyle?: (d: any, category?: string) => Style;
+    summaryStyle?: (d: any, category?: string) => Style;
+    colorScheme?: string | string[];
+    barColors?: Record<string, string>;
+    showAxes?: boolean;
+    oLabel?: string;
+    rLabel?: string;
+    oFormat?: (d: string) => string;
+    rFormat?: (d: number) => string;
+    enableHover?: boolean;
+    hoverAnnotation?: boolean | HoverAnnotationConfig;
+    tooltipContent?: (d: HoverData) => ReactNode;
+    customHoverBehavior?: (d: HoverData | null) => void;
+    annotations?: Record<string, any>[];
+    svgAnnotationRules?: (annotation: Record<string, any>, index: number, context: AnnotationContext) => ReactNode;
+    showGrid?: boolean;
+    legend?: ReactNode | {
+        legendGroups: LegendGroup[];
+    };
+    backgroundGraphics?: ReactNode;
+    foregroundGraphics?: ReactNode;
+    title?: string | ReactNode;
+    className?: string;
+    background?: string;
+    centerContent?: ReactNode;
+    decay?: DecayConfig;
+    pulse?: PulseConfig;
+    transition?: TransitionConfig;
+    staleness?: StalenessConfig;
+}
+export interface StreamOrdinalFrameHandle<T = Record<string, any>> {
+    push(datum: T): void;
+    pushMany(data: T[]): void;
+    clear(): void;
+    getData(): T[];
+    getScales(): OrdinalScales | null;
+}
+export interface OrdinalLayout {
+    width: number;
+    height: number;
+}
+export type OrdinalRendererFn = (ctx: CanvasRenderingContext2D, nodes: OrdinalSceneNode[], scales: OrdinalScales, layout: OrdinalLayout) => void;
+export type { HoverData, HoverAnnotationConfig, AnnotationContext, ArrowOfTime, WindowMode };

package/dist/stream/renderers/areaCanvasRenderer.d.ts

@@ -0,0 +1,7 @@
+import type { StreamRendererFn } from "./types";
+/**
+ * Canvas area renderer.
+ * Renders AreaSceneNode as filled regions between topPath and bottomPath.
+ * Supports both overlapping areas and stacked areas.
+ */
+export declare const areaCanvasRenderer: StreamRendererFn;

package/dist/stream/renderers/barCanvasRenderer.d.ts

@@ -0,0 +1,7 @@
+import type { StreamRendererFn } from "./types";
+/**
+ * Canvas bar renderer.
+ * Renders RectSceneNode as filled rectangles. Supports icon/isotype mode
+ * where an image is stamped repeatedly to fill the bar instead of a solid fill.
+ */
+export declare const barCanvasRenderer: StreamRendererFn;

package/dist/stream/renderers/boxplotCanvasRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { OrdinalSceneNode, OrdinalScales, OrdinalLayout } from "../ordinalTypes";
+export declare const boxplotCanvasRenderer: (ctx: CanvasRenderingContext2D, nodes: OrdinalSceneNode[], _scales: OrdinalScales, _layout: OrdinalLayout) => void;

package/dist/stream/renderers/candlestickCanvasRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { StreamRendererFn } from "./types";
+export declare const candlestickCanvasRenderer: StreamRendererFn;

package/dist/stream/renderers/connectorCanvasRenderer.d.ts

@@ -0,0 +1,2 @@
+import type { OrdinalSceneNode, OrdinalScales, OrdinalLayout } from "../ordinalTypes";
+export declare const connectorCanvasRenderer: (ctx: CanvasRenderingContext2D, nodes: OrdinalSceneNode[], _scales: OrdinalScales, _layout: OrdinalLayout) => void;

package/dist/stream/renderers/heatmapCanvasRenderer.d.ts

@@ -0,0 +1,6 @@
+import type { StreamRendererFn } from "./types";
+/**
+ * Canvas heatmap renderer.
+ * Renders HeatcellSceneNode as filled rectangles with color encoding.
+ */
+export declare const heatmapCanvasRenderer: StreamRendererFn;

package/dist/stream/renderers/lineCanvasRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { StreamRendererFn } from "./types";
+/**
+ * Canvas line renderer.
+ * Renders LineSceneNode paths using moveTo/lineTo.
+ * Supports threshold-based segment coloring when colorThresholds + rawValues
+ * are present on the node.
+ */
+export declare const lineCanvasRenderer: StreamRendererFn;

package/dist/stream/renderers/networkArcRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { NetworkSceneNode } from "../networkTypes";
+/**
+ * Canvas painter for NetworkArcNode (chord diagram arc segments).
+ */
+export declare function networkArcRenderer(ctx: CanvasRenderingContext2D, nodes: NetworkSceneNode[]): void;

package/dist/stream/renderers/networkCircleRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { NetworkSceneNode } from "../networkTypes";
+/**
+ * Canvas painter for NetworkCircleNode (force nodes, tree nodes, circlepack).
+ */
+export declare function networkCircleRenderer(ctx: CanvasRenderingContext2D, nodes: NetworkSceneNode[]): void;