semiotic 3.2.0 → 3.2.2

package/dist/components/stream/keyboardNav.d.ts

@@ -1,36 +1,112 @@
 /**
  * Keyboard navigation utilities for Stream Frames.
  *
- * Extracts navigable data points from the scene graph, sorts them
- * spatially, and provides an index-based iteration API for arrow-key
- * navigation. Reuses the existing hover/tooltip system — keyboard
- * focus sets the same HoverData state that mouse hover does.
+ * Supports two navigation modes:
+ * - **Flat**: ArrowRight/Left and ArrowUp/Down both advance linearly (geo, simple charts)
+ * - **Graph**: ArrowRight/Left navigates within a series/group, ArrowUp/Down switches
+ *   between series/groups at a similar position (XY lines, stacked bars, networks)
+ *
+ * Reuses the existing hover/tooltip system — keyboard focus sets the same
+ * HoverData state that mouse hover does.
  */
 import type { HoverData } from "../realtime/types";
 export interface NavPoint {
     x: number;
     y: number;
     datum: any;
+    /** Shape hint for focus ring rendering */
+    shape?: "circle" | "rect" | "wedge";
+    /** Width of rect-shaped elements (bars, sankey nodes) */
+    w?: number;
+    /** Height of rect-shaped elements */
+    h?: number;
+    /** Group identifier for graph navigation (series name, category, node id) */
+    group?: string;
+    /** Index in NavGraph.flat — set by buildNavGraph for O(1) lookup */
+    _flatIndex?: number;
+    /** Index within its group — set by buildNavGraph for O(1) resolvePosition */
+    _groupIndex?: number;
+}
+/**
+ * A navigation graph that organizes NavPoints into groups (series/categories)
+ * and positions within each group, enabling 2D keyboard navigation.
+ *
+ * ArrowRight/Left = next/prev within the current group (e.g. along a line series)
+ * ArrowUp/Down = switch to the nearest point in an adjacent group (e.g. switch series)
+ */
+export interface NavGraph {
+    /** All points in flat order (for PageUp/Down, Home/End) */
+    flat: NavPoint[];
+    /** Group names in stable order */
+    groups: string[];
+    /** Points per group, in position order */
+    byGroup: Map<string, NavPoint[]>;
+    /** Precomputed node id → flat index lookup (for network navigation) */
+    idToIdx: Map<string, number>;
 }
+export interface NavPosition {
+    /** Index into NavGraph.flat */
+    flatIndex: number;
+    /** Current group name */
+    group: string;
+    /** Index within the current group */
+    indexInGroup: number;
+}
+/**
+ * Build a navigation graph from grouped NavPoints.
+ * Points within each group are sorted by x then y.
+ * Groups are sorted by their first-point y position (top to bottom).
+ */
+export declare function buildNavGraph(points: NavPoint[]): NavGraph;
+/**
+ * Resolve the current NavPosition from a flat index.
+ * Clamps to valid range if the index is stale (e.g. scene changed between key presses).
+ */
+export declare function resolvePosition(graph: NavGraph, flatIndex: number): NavPosition;
+/**
+ * Compute the next navigation position given a key press and current position.
+ * Returns the flat index into graph.flat, -1 to clear, or null for unhandled keys.
+ */
+export declare function nextGraphIndex(key: string, pos: NavPosition, graph: NavGraph): number | null;
 /**
  * Extract navigable data points from XY scene nodes.
- * Points/rects yield one point each. Lines/areas yield their path points
- * paired with the underlying data. Sorted left-to-right by x.
+ * Lines/areas carry a `group` field identifying the series.
+ * ArrowRight/Left = within series, ArrowUp/Down = switch series.
  */
 export declare function extractXYNavPoints(scene: any[]): NavPoint[];
 /**
  * Extract navigable points from ordinal scene nodes.
- * Sorted left-to-right (horizontal) or top-to-bottom (vertical).
+ * Bars use `node.group` (stack/group key) falling back to `datum.category`.
+ * ArrowRight/Left = across categories, ArrowUp/Down = within stacked segments.
  */
 export declare function extractOrdinalNavPoints(scene: any[]): NavPoint[];
 /**
  * Extract navigable points from network scene nodes.
- * Node-only (edges are not individually navigable).
+ * Each node's group is its own id, enabling neighbor traversal via edges.
  */
 export declare function extractNetworkNavPoints(scene: any[]): NavPoint[];
+/**
+ * Network-specific navigation: spatial arrow keys + edge following.
+ *
+ * ArrowRight/Left/Up/Down: move to the nearest node in that direction.
+ * Enter: follow an edge to a connected neighbor of the current node.
+ * PageUp/Down, Home/End, Escape: flat navigation.
+ *
+ * Returns the flat index of the target node, -1 to clear, or null for unhandled keys.
+ */
+export declare function nextNetworkIndex(key: string, pos: NavPosition, graph: NavGraph, edges: any[], neighborIndexRef: {
+    current: number;
+}): number | null;
+/**
+ * Extract navigable points from geo scene nodes.
+ * Flat navigation only (no meaningful grouping for geo).
+ */
+export declare function extractGeoNavPoints(scene: any[]): NavPoint[];
 /**
  * Compute the next focus index given a key and current index.
- * Returns -1 to clear focus.
+ * Returns -1 to clear focus. Returns null for unhandled keys.
+ *
+ * Used by Geo frame (flat navigation) and as fallback.
  */
 export declare function nextIndex(key: string, current: number, total: number): number | null;
 /**

package/dist/components/stream/layouts/hierarchySceneBuilders.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Scene builders for hierarchy layouts (tree, treemap, circlepack).
+ *
+ * Converts RealtimeNode/Edge arrays (positioned by d3-hierarchy) into
+ * NetworkSceneNode/Edge arrays for canvas rendering.
+ *
+ * Three builder functions, one per visual form:
+ *   buildTreeScene    — circle nodes + curved edges (tree/cluster)
+ *   buildRectScene    — rect nodes, no edges (treemap/partition)
+ *   buildCircleScene  — circle nodes, no edges (circlepack)
+ *
+ * Dependencies: hierarchyUtils (palette, contrast, label resolution)
+ * Consumed by: hierarchyLayoutPlugin.ts (buildScene dispatcher)
+ */
+import type { NetworkPipelineConfig, NetworkSceneNode, NetworkSceneEdge, NetworkLabel, RealtimeNode, RealtimeEdge } from "../networkTypes";
+export declare function buildTreeScene(nodes: RealtimeNode[], edges: RealtimeEdge[], config: NetworkPipelineConfig, size: [number, number], nodeStyleFn: (d: any) => Record<string, any>, edgeStyleFn: (d: any) => Record<string, any>): {
+    sceneNodes: NetworkSceneNode[];
+    sceneEdges: NetworkSceneEdge[];
+    labels: NetworkLabel[];
+};
+export declare function buildRectScene(nodes: RealtimeNode[], config: NetworkPipelineConfig, size: [number, number], nodeStyleFn: (d: any) => Record<string, any>): {
+    sceneNodes: NetworkSceneNode[];
+    sceneEdges: NetworkSceneEdge[];
+    labels: NetworkLabel[];
+};
+export declare function buildCircleScene(nodes: RealtimeNode[], config: NetworkPipelineConfig, size: [number, number], nodeStyleFn: (d: any) => Record<string, any>): {
+    sceneNodes: NetworkSceneNode[];
+    sceneEdges: NetworkSceneEdge[];
+    labels: NetworkLabel[];
+};
+/**
+ * Generate a cubic bezier path string for a tree/cluster edge.
+ * Uses different curve strategies based on tree orientation.
+ */
+export declare function generateTreeEdgePath(sx: number, sy: number, tx: number, ty: number, orientation: string): string;

package/dist/components/stream/layouts/hierarchyUtils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shared utilities for hierarchy layout plugins.
+ *
+ * CSS color parsing, contrast text, depth palette, and accessor resolution
+ * used across tree, treemap, and circlepack scene builders.
+ *
+ * Consumed by: hierarchyLayoutPlugin.ts, hierarchySceneBuilders.ts
+ */
+import type { NetworkPipelineConfig } from "../networkTypes";
+/** Depth-based color palette shared across all hierarchy scene builders */
+export declare const DEPTH_PALETTE: string[];
+/**
+ * Parse a CSS color string (hex or rgb/rgba) into [r, g, b].
+ * Falls back to mid-gray if the format is unrecognized.
+ */
+export declare function parseColor(color: string): [number, number, number];
+/**
+ * Return a high-contrast text color (white or near-black) for the given background.
+ * Uses perceived luminance (ITU-R BT.601).
+ */
+export declare function contrastTextColor(bgColor: string): string;
+export declare function resolveChildrenAccessor(accessor: string | ((d: any) => any[]) | undefined): ((d: any) => any[]) | undefined;
+export declare function resolveNodeId(d: any, config: NetworkPipelineConfig, index: number): string;
+export declare function resolveLabelFn(nodeLabel: string | ((d: any) => string) | undefined): ((d: any) => string) | null;
+export declare function resolveDefaultNodeSize(nodeSize: number | string | ((d: any) => number) | undefined): number;

package/dist/components/stream/networkTypes.d.ts

@@ -440,8 +440,12 @@ export interface StreamNetworkFrameProps<T = Record<string, any>> {
     orbitEccentricity?: number | ((node: any) => number);
     orbitShowRings?: boolean;
     orbitAnimated?: boolean;
-    /** Render a visually-hidden data table from the scene graph for screen readers (first 50 rows) */
+    /** Render a visually-hidden data table from the scene graph for screen readers */
     accessibleTable?: boolean;
+    /** Accessible description overriding the auto-generated aria-label on the chart container */
+    description?: string;
+    /** Accessible summary rendered as a screen-reader-only note */
+    summary?: string;
 }
 export interface StreamNetworkFrameHandle {
     push(edge: EdgePush): void;

package/dist/components/stream/ordinalSceneBuilders/swimlaneScene.d.ts

@@ -0,0 +1,12 @@
+import type { OrdinalSceneNode, OrdinalLayout } from "../ordinalTypes";
+import type { OrdinalSceneContext } from "./types";
+/**
+ * Swimlane scene builder.
+ *
+ * Each category (oAccessor) defines a horizontal lane.
+ * Items within a lane are stacked left-to-right (or bottom-to-top in vertical),
+ * colored by subcategory (stackBy/colorBy). Unlike a standard stacked bar,
+ * multiple items with the same subcategory can appear in the same lane —
+ * they simply stack sequentially.
+ */
+export declare function buildSwimlaneScene(ctx: OrdinalSceneContext, layout: OrdinalLayout): OrdinalSceneNode[];

package/dist/components/stream/ordinalTypes.d.ts

@@ -3,7 +3,7 @@ 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" | "funnel" | "bar-funnel";
+export type OrdinalChartType = "bar" | "clusterbar" | "point" | "swarm" | "pie" | "donut" | "boxplot" | "violin" | "histogram" | "ridgeline" | "timeline" | "funnel" | "bar-funnel" | "swimlane";
 export interface OrdinalScales {
     o: ScaleBand<string>;
     r: ScaleLinear<number, number>;
@@ -219,7 +219,7 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
     showCategoryTicks?: boolean;
     oLabel?: string;
     rLabel?: string;
-    oFormat?: (d: string) => string;
+    oFormat?: (d: string, index?: number) => string;
     rFormat?: (d: number | string) => string;
     enableHover?: boolean;
     hoverAnnotation?: boolean | HoverAnnotationConfig;
@@ -248,12 +248,24 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
     className?: string;
     background?: string;
     centerContent?: ReactNode;
+    /** Brush configuration. "r" brushes the value axis. */
+    brush?: boolean | "r" | {
+        dimension?: "r";
+    };
+    /** Callback when brush selection changes. Extent is in data coordinates, or null when cleared. */
+    onBrush?: (extent: {
+        r: [number, number];
+    } | null) => void;
     decay?: DecayConfig;
     pulse?: PulseConfig;
     transition?: TransitionConfig;
     staleness?: StalenessConfig;
-    /** Render a visually-hidden data table from the scene graph for screen readers (first 50 rows) */
+    /** Render a visually-hidden data table from the scene graph for screen readers */
     accessibleTable?: boolean;
+    /** Accessible description overriding the auto-generated aria-label on the chart container */
+    description?: string;
+    /** Accessible summary rendered as a screen-reader-only note */
+    summary?: string;
 }
 export interface StreamOrdinalFrameHandle<T = Record<string, any>> {
     push(datum: T): void;

package/dist/components/stream/pipelineDecay.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Decay encoding for XY pipeline scene nodes.
+ *
+ * Applies age-based opacity fade to scene nodes — linear, exponential, or step.
+ * Per-vertex decay for line/area nodes, uniform for discrete nodes (point, rect, etc.).
+ *
+ * Dependencies: types (SceneNode, DecayConfig)
+ * Consumed by: PipelineStore.computeScene (after scene build, before transitions)
+ */
+import type { SceneNode, DecayConfig } from "./types";
+/**
+ * Compute decay opacity for a datum at `bufferIndex` out of `bufferSize` items.
+ * Index 0 = oldest, bufferSize-1 = newest. Returns 0–1.
+ */
+export declare function computeDecayOpacity(decay: DecayConfig, bufferIndex: number, bufferSize: number): number;
+/**
+ * Apply decay opacity to a list of scene nodes.
+ * Uses the datum's index in the buffer data array.
+ */
+export declare function applyDecay(decay: DecayConfig, nodes: SceneNode[], data: Record<string, any>[]): void;

package/dist/components/stream/pipelinePulse.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pulse encoding for XY pipeline scene nodes.
+ *
+ * Applies time-based glow to recently-inserted data points. Intensity fades
+ * from 1 (just inserted) to 0 (pulse expired) over a configurable duration.
+ *
+ * Dependencies: types (SceneNode, PulseConfig), RingBuffer (timestamp buffer)
+ * Consumed by: PipelineStore.computeScene (after decay, before transitions)
+ */
+import type { SceneNode, PulseConfig } from "./types";
+import type { RingBuffer } from "../realtime/RingBuffer";
+/**
+ * Compute pulse intensity for a datum inserted at `insertTime`.
+ * Returns 0–1 (1 = just inserted, 0 = pulse expired).
+ */
+export declare function computePulseIntensity(pulse: PulseConfig, insertTime: number, now: number): number;
+/**
+ * Apply pulse glow to scene nodes using insertion timestamps.
+ */
+export declare function applyPulse(pulse: PulseConfig, nodes: SceneNode[], data: Record<string, any>[], timestampBuffer: RingBuffer<number>): void;
+/**
+ * Check whether there are active pulse animations needing continuous rendering.
+ */
+export declare function hasActivePulses(pulse: PulseConfig, timestampBuffer: RingBuffer<number> | null): boolean;

package/dist/components/stream/pipelineTransitions.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Transition animation for XY pipeline scene nodes.
+ *
+ * Handles identity-based enter/update/exit transitions:
+ *   - snapshotPositions: captures current scene state before rebuild
+ *   - getNodeIdentity: stable key generation per node type
+ *   - startTransition: sets up interpolation from old→new positions
+ *   - advanceTransition: per-frame tick with easing
+ *
+ * Dependencies: pipelineTransitionUtils (lerp, easing, ActiveTransition)
+ * Consumed by: PipelineStore.computeScene (after decay/pulse)
+ */
+import type { SceneNode, TransitionConfig } from "./types";
+import type { ActiveTransition } from "./pipelineTransitionUtils";
+export type PrevPosition = {
+    x: number;
+    y: number;
+    w?: number;
+    h?: number;
+    r?: number;
+    opacity?: number;
+};
+export type PrevPath = {
+    topPath?: [number, number][];
+    bottomPath?: [number, number][];
+    path?: [number, number][];
+    opacity?: number;
+};
+/** Context needed from PipelineStore for identity resolution */
+export interface TransitionContext {
+    runtimeMode?: "streaming" | "bounded";
+    getX: (d: any) => number;
+    getY: (d: any) => number;
+    getCategory?: (d: any) => string;
+}
+/**
+ * Get a stable identity key for a scene node.
+ */
+export declare function getNodeIdentity(ctx: TransitionContext, node: SceneNode, index: number): string | null;
+/**
+ * Snapshot current scene node positions before rebuild.
+ */
+export declare function snapshotPositions(ctx: TransitionContext, scene: SceneNode[], prevPositionMap: Map<string, PrevPosition>, prevPathMap: Map<string, PrevPath>): void;
+export interface TransitionState {
+    scene: SceneNode[];
+    exitNodes: SceneNode[];
+    activeTransition: ActiveTransition | null;
+}
+/**
+ * After scene rebuild, set up transition from old to new positions.
+ * Detects entering nodes (new, no prev match) and exiting nodes (prev, no new match).
+ * Mutates scene and exitNodes in place. Returns updated state.
+ */
+export declare function startTransition(ctx: TransitionContext, transition: TransitionConfig, state: TransitionState, prevPositionMap: Map<string, PrevPosition>, prevPathMap: Map<string, PrevPath>): TransitionState;
+/**
+ * Advance the transition animation. Returns true if still animating.
+ * Mutates scene nodes in place.
+ */
+export declare function advanceTransition(now: number, transition: TransitionConfig, state: TransitionState, prevPositionMap: Map<string, PrevPosition>, prevPathMap: Map<string, PrevPath>): boolean;

package/dist/components/stream/renderers/pointCanvasRenderer.d.ts

@@ -1,7 +1,8 @@
 import type { StreamRendererFn } from "./types";
 /**
  * Canvas point renderer.
- * Renders PointSceneNode as circles. Used for Scatterplot, BubbleChart, and SwarmChart.
+ * Renders PointSceneNode as circles. Used by Scatterplot, BubbleChart, SwarmChart,
+ * and showPoints on LineChart, AreaChart, and StackedAreaChart.
  * Supports pulse glow effect via _pulseIntensity/_pulseColor fields.
  */
 export declare const pointCanvasRenderer: StreamRendererFn;

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

@@ -92,6 +92,8 @@ export interface LineSceneNode {
     _decayOpacities?: number[];
     /** Animation target opacity (set during enter/exit transitions) */
     _targetOpacity?: number;
+    /** Captured start opacity for linear interpolation (avoids compounding from per-tick mutation) */
+    _startOpacity?: number;
     /** Stable identity key for transition tracking */
     _transitionKey?: string;
     /** Previous path coordinates for interpolation during transitions */
@@ -123,6 +125,8 @@ export interface AreaSceneNode {
     _decayOpacities?: number[];
     /** Animation target opacity (set during enter/exit transitions) */
     _targetOpacity?: number;
+    /** Captured start opacity for linear interpolation (avoids compounding from per-tick mutation) */
+    _startOpacity?: number;
     /** Stable identity key for transition tracking */
     _transitionKey?: string;
     /** Previous top path coordinates for interpolation during transitions */
@@ -363,6 +367,12 @@ export interface StreamXYFrameProps<T = Record<string, any>> {
     brush?: {
         /** Which dimension(s) to brush: "x", "y", or "xy" (default "xy") */
         dimension?: "x" | "y" | "xy";
+        /** Snap mode: "continuous" (default) for pixel-precise, "bin" to snap to bin boundaries */
+        snap?: "continuous" | "bin";
+        /** Actual bin boundary values for data-driven snapping (overrides uniform grid math) */
+        binBoundaries?: number[];
+        /** When true, snap during drag (not just on release). Default false. */
+        snapDuring?: boolean;
     };
     /** Callback when brush selection changes. Called with data-space extent, or null when cleared. */
     onBrush?: (extent: {
@@ -418,8 +428,16 @@ export interface StreamXYFrameProps<T = Record<string, any>> {
     showValues?: boolean;
     /** Format function for heatmap cell value labels */
     heatmapValueFormat?: (v: number) => string;
-    /** Render a visually-hidden data table from the scene graph for screen readers (first 50 rows) */
+    /** Render a visually-hidden data table from the scene graph for screen readers */
     accessibleTable?: boolean;
+    /** Accessible description overriding the auto-generated aria-label on the chart container */
+    description?: string;
+    /** Accessible summary rendered as a screen-reader-only note */
+    summary?: string;
+    /** Name of the linked crosshair store entry — enables coordinate-based crosshair rendering */
+    linkedCrosshairName?: string;
+    /** Source chart ID — crosshair is suppressed on the source chart to avoid double rendering */
+    linkedCrosshairSourceId?: string;
 }
 export interface StreamXYFrameHandle<T = Record<string, any>> {
     push(datum: T): void;

package/dist/components/stream/useMediaPreferences.d.ts

@@ -0,0 +1,11 @@
+/** Safari 14 fallback for MediaQueryList listener registration */
+export declare function addMqlListener(mql: MediaQueryList, handler: (e: MediaQueryListEvent) => void): () => void;
+/**
+ * SSR-safe hook that returns true when the user prefers reduced motion.
+ * Initializes from matchMedia synchronously to avoid a flash of animation.
+ */
+export declare function useReducedMotion(): boolean;
+/**
+ * SSR-safe hook that returns true when forced-colors or high-contrast mode is active.
+ */
+export declare function useHighContrast(): boolean;

package/dist/components/stream/xySceneBuilders/areaScene.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Area and stacked area scene builders.
+ *
+ * buildAreaScene — single/multi-group areas with gradient fill and curve support.
+ * buildStackedAreaScene — stable-order stacking with optional normalization.
+ *
+ * Dependencies: SceneGraph (buildAreaNode, buildStackedAreaNodes)
+ * Consumed by: PipelineStore.buildSceneNodes (chartTypes "area", "stackedarea")
+ */
+import type { SceneNode } from "../types";
+import type { XYSceneContext } from "./types";
+export declare function buildAreaScene(ctx: XYSceneContext, data: Record<string, any>[]): SceneNode[];
+export declare function buildStackedAreaScene(ctx: XYSceneContext, data: Record<string, any>[]): SceneNode[];

package/dist/components/stream/xySceneBuilders/barScene.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Realtime histogram bar scene builder.
+ *
+ * Builds binned bars with optional category stacking. Maintains stable
+ * category order via barColors keys + alphabetical fallback to prevent
+ * flicker when bins partially exit the sliding window.
+ *
+ * Dependencies: BinAccumulator (computeBins), SceneGraph (buildRectNode)
+ * Consumed by: PipelineStore.buildSceneNodes (chartType "bar")
+ */
+import type { SceneNode } from "../types";
+import type { XYSceneContext } from "./types";
+export interface BarSceneResult {
+    nodes: SceneNode[];
+    /** Sorted bin boundary values (edges of all bins) for data-driven brush snapping */
+    binBoundaries: number[];
+}
+export declare function buildBarScene(ctx: XYSceneContext, data: Record<string, any>[]): BarSceneResult;

package/dist/components/stream/xySceneBuilders/boundsScene.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bounds scene builder — produces an AreaSceneNode for confidence bands/envelopes.
+ *
+ * Consumed by: lineScene (renders bounds behind lines)
+ */
+import type { AreaSceneNode } from "../types";
+import type { XYSceneContext } from "./types";
+export declare function buildBoundsForGroup(ctx: XYSceneContext, data: Record<string, any>[], group: string): AreaSceneNode | null;

package/dist/components/stream/xySceneBuilders/candlestickScene.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Candlestick (OHLC) scene builder.
+ *
+ * Renders open-high-low-close bars with auto-width sizing based on data spacing.
+ *
+ * Consumed by: PipelineStore.buildSceneNodes (chartType "candlestick")
+ */
+import type { SceneNode, StreamLayout } from "../types";
+import type { XYSceneContext } from "./types";
+export declare function buildCandlestickScene(ctx: XYSceneContext, data: Record<string, any>[], layout: StreamLayout): SceneNode[];

package/dist/components/stream/xySceneBuilders/emitPointNodes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared helper for emitting PointSceneNodes from grouped data.
+ *
+ * Used by line, area, and stacked area scene builders when the HOC's
+ * `showPoints` prop is active (i.e., `ctx.config.pointStyle` is set).
+ * Handles group color fallback for push API mode and pointId passthrough.
+ */
+import type { SceneNode } from "../types";
+import type { XYSceneContext } from "./types";
+export declare function emitPointNodes(ctx: XYSceneContext, groups: {
+    key: string;
+    data: Record<string, any>[];
+}[], nodes: SceneNode[], yGetOverride?: (d: Record<string, any>) => number): void;

package/dist/components/stream/xySceneBuilders/heatmapScene.d.ts

@@ -0,0 +1,3 @@
+import type { SceneNode, StreamLayout } from "../types";
+import type { XYSceneContext } from "./types";
+export declare function buildHeatmapScene(ctx: XYSceneContext, data: Record<string, any>[], layout: StreamLayout): SceneNode[];

package/dist/components/stream/xySceneBuilders/lineScene.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Line scene builder — produces LineSceneNode[] from grouped data.
+ *
+ * Handles: color thresholds from annotations, bounds/envelope areas,
+ * and curve type attachment for canvas interpolation.
+ *
+ * Dependencies: SceneGraph (buildLineNode), boundsScene (buildBoundsForGroup)
+ * Consumed by: PipelineStore.buildSceneNodes (chartType "line")
+ */
+import type { SceneNode } from "../types";
+import type { XYSceneContext } from "./types";
+export declare function buildLineScene(ctx: XYSceneContext, data: Record<string, any>[]): SceneNode[];

package/dist/components/stream/xySceneBuilders/pointScene.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Point/scatter/bubble scene builder.
+ *
+ * Handles: size scaling from sizeAccessor, color mapping from colorAccessor,
+ * and pointId attachment for hit testing.
+ *
+ * Dependencies: SceneGraph (buildPointNode)
+ * Consumed by: PipelineStore.buildSceneNodes (chartTypes "scatter", "bubble")
+ */
+import type { SceneNode } from "../types";
+import type { XYSceneContext } from "./types";
+export declare function buildPointScene(ctx: XYSceneContext, data: Record<string, any>[]): SceneNode[];

package/dist/components/stream/xySceneBuilders/swarmScene.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Realtime swarm chart scene builder.
+ *
+ * Simple point scatter with category-based coloring from barColors config.
+ *
+ * Consumed by: PipelineStore.buildSceneNodes (chartType "swarm")
+ */
+import type { SceneNode } from "../types";
+import type { XYSceneContext } from "./types";
+export declare function buildSwarmScene(ctx: XYSceneContext, data: Record<string, any>[]): SceneNode[];

package/dist/components/stream/xySceneBuilders/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * XYSceneContext — shared context passed to all XY scene builder functions.
+ *
+ * Mirrors the ordinal pattern (OrdinalSceneContext in ordinalSceneBuilders/).
+ * Scene builders are pure functions that receive this context instead of
+ * accessing PipelineStore instance fields directly.
+ */
+import type { StreamScales, Style, CurveType } from "../types";
+export interface XYSceneContext {
+    scales: StreamScales;
+    config: XYSceneConfig;
+    getX: (d: any) => number;
+    getY: (d: any) => number;
+    getY0?: (d: any) => number | null;
+    getSize?: (d: any) => number;
+    getColor?: (d: any) => string;
+    getGroup?: (d: any) => string;
+    getCategory?: (d: any) => string;
+    getPointId?: (d: any) => string;
+    getBounds?: (d: any) => number | null;
+    getOpen?: (d: any) => number;
+    getHigh?: (d: any) => number;
+    getLow?: (d: any) => number;
+    getClose?: (d: any) => number;
+    /** Style resolvers — delegate to PipelineStore's cached color management */
+    resolveLineStyle: (group: string, sampleDatum?: Record<string, any>) => Style;
+    resolveAreaStyle: (group: string, sampleDatum?: Record<string, any>) => Style;
+    resolveBoundsStyle: (group: string, sampleDatum?: Record<string, any>) => Style;
+    resolveColorMap: (data: Record<string, any>[]) => Map<string, string>;
+    resolveGroupColor: (group: string) => string | null;
+    /** Group data by lineBy/colorBy accessor */
+    groupData: (data: Record<string, any>[]) => {
+        key: string;
+        data: Record<string, any>[];
+    }[];
+    /** Instance-scoped mutable cache for bar category ordering (prevents cross-instance leaks) */
+    barCategoryCache?: {
+        key: string;
+        order: string[];
+    } | null;
+}
+/** Subset of PipelineConfig fields that scene builders need */
+export interface XYSceneConfig {
+    chartType: string;
+    curve?: CurveType;
+    colorScheme?: string | string[];
+    normalize?: boolean;
+    gradientFill?: boolean | {
+        topOpacity?: number;
+        bottomOpacity?: number;
+    };
+    annotations?: Record<string, any>[];
+    pointStyle?: (d: any) => Style & {
+        r?: number;
+    };
+    sizeRange?: [number, number];
+    xAccessor?: string | ((d: any) => any);
+    yAccessor?: string | ((d: any) => any);
+    valueAccessor?: string | ((d: any) => any);
+    heatmapAggregation?: "count" | "sum" | "mean";
+    heatmapXBins?: number;
+    heatmapYBins?: number;
+    showValues?: boolean;
+    heatmapValueFormat?: (v: number) => string;
+    binSize?: number;
+    barColors?: Record<string, string>;
+    swarmStyle?: {
+        radius?: number;
+        fill?: string;
+        opacity?: number;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+    waterfallStyle?: {
+        positiveColor?: string;
+        negativeColor?: string;
+        gap?: number;
+        stroke?: string;
+        strokeWidth?: number;
+        connectorStroke?: string;
+        connectorWidth?: number;
+    };
+    candlestickStyle?: {
+        upColor?: string;
+        downColor?: string;
+        wickColor?: string;
+        wickWidth?: number;
+        bodyWidth?: number;
+    };
+    boundsStyle?: Style | ((d: any, group: string) => Style);
+    lineStyle?: Style | ((d: any, group: string) => Style);
+    areaStyle?: (d: any) => Style;
+}