semiotic 3.0.0 → 3.1.0

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

@@ -0,0 +1,186 @@
+import type { ReactNode } from "react";
+import type { GeoProjection, GeoPath, GeoPermissibleObjects } from "d3-geo";
+import type { Style, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig, PointSceneNode, LineSceneNode } from "./types";
+import type { HoverAnnotationConfig } from "../realtime/types";
+import type { GeoParticleStyle } from "./GeoParticlePool";
+export type ProjectionProp = GeoProjection | ProjectionName | ProjectionConfig;
+export type ProjectionName = "mercator" | "equalEarth" | "albersUsa" | "orthographic" | "naturalEarth" | "equirectangular";
+export interface ProjectionConfig {
+    type: ProjectionName;
+    rotate?: [number, number] | [number, number, number];
+    center?: [number, number];
+    parallels?: [number, number];
+}
+export interface GraticuleConfig {
+    step?: [number, number];
+    stroke?: string;
+    strokeWidth?: number;
+    strokeDasharray?: string;
+    showLabels?: boolean;
+}
+export interface DistanceCartogramConfig {
+    center: string;
+    centerAccessor?: string | ((d: any) => string);
+    costAccessor: string | ((d: any) => number);
+    strength?: number;
+    lineMode?: "straight" | "fractional";
+}
+export interface GeoAreaSceneNode {
+    type: "geoarea";
+    /** Pre-computed SVG path string from d3.geoPath(projection)(feature) */
+    pathData: string;
+    /** Centroid in screen coords (for tooltip/annotation positioning) */
+    centroid: [number, number];
+    /** Bounding box in screen coords [[x0,y0],[x1,y1]] */
+    bounds: [[number, number], [number, number]];
+    /** Screen-space area in px² */
+    screenArea: number;
+    style: Style;
+    datum: any;
+    group?: string;
+    interactive?: boolean;
+    /** Lazily-cached Path2D parsed from pathData (avoids re-parsing on every hit test) */
+    _cachedPath2D?: Path2D;
+    _decayOpacity?: number;
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+}
+/** Union of all scene node types that GeoFrame produces */
+export type GeoSceneNode = GeoAreaSceneNode | PointSceneNode | LineSceneNode;
+export interface GeoScales {
+    projection: GeoProjection;
+    geoPath: GeoPath<any, GeoPermissibleObjects>;
+    projectedPoint: (lon: number, lat: number) => [number, number] | null;
+    invertedPoint: (px: number, py: number) => [number, number] | null;
+}
+export interface GeoPipelineConfig {
+    projection: ProjectionProp;
+    projectionExtent?: [[number, number], [number, number]];
+    /** Padding fraction for auto-fit projection. 0.1 = 10% inset from edges. @default 0 */
+    fitPadding?: number;
+    xAccessor?: string | ((d: any) => number);
+    yAccessor?: string | ((d: any) => number);
+    lineDataAccessor?: string | ((d: any) => any[]);
+    lineType?: "geo" | "line";
+    /** Flow rendering style: "basic" (straight/great-circle), "offset" (bidirectional offset), "arc" (curved arcs) @default "basic" */
+    flowStyle?: "basic" | "offset" | "arc";
+    areaStyle?: Style | ((d: any) => Style);
+    pointStyle?: (d: any) => Style & {
+        r?: number;
+    };
+    lineStyle?: Style | ((d: any, group?: string) => Style);
+    colorScheme?: string | string[];
+    graticule?: boolean | GraticuleConfig;
+    projectionTransform?: DistanceCartogramConfig;
+    decay?: DecayConfig;
+    pulse?: PulseConfig;
+    transition?: TransitionConfig;
+    annotations?: Record<string, any>[];
+    pointIdAccessor?: string | ((d: any) => string);
+}
+export interface StreamGeoFrameProps<T = Record<string, any>> {
+    projection: ProjectionProp;
+    projectionExtent?: [[number, number], [number, number]];
+    /** Padding fraction for auto-fit projection. 0.1 = 10% inset from edges. @default 0 */
+    fitPadding?: number;
+    areas?: GeoJSON.Feature[];
+    points?: T[];
+    lines?: T[];
+    xAccessor?: string | ((d: T) => number);
+    yAccessor?: string | ((d: T) => number);
+    lineDataAccessor?: string | ((d: T) => any[]);
+    pointIdAccessor?: string | ((d: T) => string);
+    lineType?: "geo" | "line";
+    /** Flow rendering style: "basic" (straight/great-circle), "offset" (bidirectional offset), "arc" (curved arcs) @default "basic" */
+    flowStyle?: "basic" | "offset" | "arc";
+    graticule?: boolean | GraticuleConfig;
+    zoomable?: boolean;
+    zoomExtent?: [number, number];
+    onZoom?: (state: {
+        projection: GeoProjection;
+        zoom: number;
+    }) => void;
+    /**
+     * When true, drag gestures rotate the projection (globe spinning)
+     * instead of panning. Defaults to true for orthographic projection.
+     * Scroll-wheel zoom still works normally.
+     */
+    dragRotate?: boolean;
+    projectionTransform?: DistanceCartogramConfig;
+    /** Show animated particles flowing along line paths */
+    showParticles?: boolean;
+    /** Particle appearance and behavior config */
+    particleStyle?: GeoParticleStyle;
+    /** Raster tile URL template or function. Enables tile basemap (Mercator only). */
+    tileURL?: string | ((z: number, x: number, y: number, dpr: number) => string);
+    /** Attribution text for tile provider (e.g., "© OpenStreetMap contributors") */
+    tileAttribution?: string;
+    /** Max cached tiles @default 256 */
+    tileCacheSize?: number;
+    size?: [number, number];
+    width?: number;
+    height?: number;
+    responsiveWidth?: boolean;
+    responsiveHeight?: boolean;
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    className?: string;
+    background?: string;
+    runtimeMode?: "bounded" | "streaming";
+    areaStyle?: Style | ((d: any) => Style);
+    pointStyle?: (d: any) => Style & {
+        r?: number;
+    };
+    lineStyle?: Style | ((d: any, group?: string) => Style);
+    colorScheme?: string | string[];
+    enableHover?: boolean;
+    hoverAnnotation?: boolean | HoverAnnotationConfig;
+    tooltipContent?: (d: any) => ReactNode;
+    customClickBehavior?: (d: any) => void;
+    customHoverBehavior?: (d: any) => void;
+    annotations?: Record<string, any>[];
+    decay?: DecayConfig;
+    pulse?: PulseConfig;
+    transition?: TransitionConfig;
+    staleness?: StalenessConfig;
+    backgroundGraphics?: ReactNode;
+    foregroundGraphics?: ReactNode;
+    title?: string | ReactNode;
+    legend?: any;
+    legendPosition?: "right" | "left" | "top" | "bottom";
+    legendHoverBehavior?: (item: {
+        label: string;
+    } | null) => void;
+    legendClickBehavior?: (item: {
+        label: string;
+    }) => void;
+    legendHighlightedCategory?: string | null;
+    legendIsolatedCategories?: Set<string>;
+    showAxes?: boolean;
+    /** Render a visually-hidden data table from the scene graph for screen readers (first 50 rows) */
+    accessibleTable?: boolean;
+}
+export interface StreamGeoFrameHandle {
+    push(datum: Record<string, any>): void;
+    pushMany(data: Record<string, any>[]): void;
+    clear(): void;
+    getProjection(): GeoProjection | null;
+    getGeoPath(): GeoPath<any, GeoPermissibleObjects> | null;
+    /** Get cartogram layout info (center position, max cost, radius) */
+    getCartogramLayout(): {
+        cx: number;
+        cy: number;
+        maxCost: number;
+        availableRadius: number;
+    } | null;
+    /** Get current zoom level (1 = default) */
+    getZoom(): number;
+    /** Animate back to initial view */
+    resetZoom(): void;
+    /** Get current data points */
+    getData(): Record<string, any>[];
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Shared hit-testing utilities used by CanvasHitTester, OrdinalCanvasHitTester,
+ * and NetworkCanvasHitTester.
+ */
+export interface RectHitResult {
+    hit: boolean;
+    cx: number;
+    cy: number;
+}
+/**
+ * Test whether a point (px, py) falls within a rectangle defined by
+ * { x, y, w, h } and return the rectangle's center coordinates.
+ */
+export declare function hitTestRect(px: number, py: number, node: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}): RectHitResult;
+/**
+ * Normalize an angle to the [0, 2π) range.
+ */
+export declare function normalizeAngle(angle: number): number;

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

@@ -0,0 +1,2 @@
+import type { NetworkLayoutPlugin } from "../networkTypes";
+export declare const forceLayoutPlugin: NetworkLayoutPlugin;

package/dist/{stream → components/stream}/layouts/index.d.ts

@@ -3,9 +3,10 @@ import { sankeyLayoutPlugin } from "./sankeyLayoutPlugin";
 import { forceLayoutPlugin } from "./forceLayoutPlugin";
 import { chordLayoutPlugin } from "./chordLayoutPlugin";
 import { hierarchyLayoutPlugin } from "./hierarchyLayoutPlugin";
+import { orbitLayoutPlugin } from "./orbitLayoutPlugin";
 /**
  * Registry mapping network chart types to their layout plugins.
  */
 export declare const networkLayoutRegistry: Record<string, NetworkLayoutPlugin>;
 export declare function getLayoutPlugin(chartType: NetworkChartType): NetworkLayoutPlugin | undefined;
-export { sankeyLayoutPlugin, forceLayoutPlugin, chordLayoutPlugin, hierarchyLayoutPlugin };
+export { sankeyLayoutPlugin, forceLayoutPlugin, chordLayoutPlugin, hierarchyLayoutPlugin, orbitLayoutPlugin };

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

@@ -0,0 +1,2 @@
+import type { NetworkLayoutPlugin } from "../networkTypes";
+export declare const orbitLayoutPlugin: NetworkLayoutPlugin;

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

@@ -0,0 +1,33 @@
+import type { ReactNode } from "react";
+import type { LegendGroup, GradientLegendConfig } from "../types/legendTypes";
+export interface LegendRenderConfig {
+    legend: ReactNode | {
+        legendGroups: LegendGroup[];
+    } | {
+        gradient: GradientLegendConfig;
+    };
+    totalWidth: number;
+    totalHeight: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    legendPosition?: "right" | "left" | "top" | "bottom";
+    title?: string | ReactNode;
+    legendHoverBehavior?: (item: {
+        label: string;
+    } | null) => void;
+    legendClickBehavior?: (item: {
+        label: string;
+    }) => void;
+    legendHighlightedCategory?: string | null;
+    legendIsolatedCategories?: Set<string>;
+    legendInteraction?: string;
+}
+/**
+ * Renders a legend (categorical, gradient, or custom ReactNode) inside an SVG overlay.
+ * Computes position based on `legendPosition` and chart dimensions.
+ */
+export declare function renderLegendFromConfig(config: LegendRenderConfig): ReactNode;

package/dist/{stream → components/stream}/networkTypes.d.ts

@@ -124,7 +124,7 @@ export interface RealtimeNetworkFrameProps {
     background?: string;
     className?: string;
 }
-export type NetworkChartType = "force" | "sankey" | "chord" | "tree" | "cluster" | "treemap" | "circlepack" | "partition";
+export type NetworkChartType = "force" | "sankey" | "chord" | "tree" | "cluster" | "treemap" | "circlepack" | "orbit" | "partition";
 /** Circle node — used by force, tree, cluster, circlepack */
 export interface NetworkCircleNode {
     type: "circle";
@@ -240,6 +240,17 @@ export interface NetworkLayoutPlugin {
     supportsStreaming: boolean;
     /** Whether this layout uses hierarchical (tree) input instead of nodes+edges */
     hierarchical: boolean;
+    /**
+     * Whether this layout drives continuous animation (e.g. orbiting nodes).
+     * When true, StreamNetworkFrame keeps its RAF loop alive and calls `tick()` each frame.
+     */
+    supportsAnimation?: boolean;
+    /**
+     * Advance one animation frame. Called by StreamNetworkFrame on each RAF tick
+     * when `supportsAnimation` is true. Should mutate node positions in-place.
+     * Returns true if the scene needs a rebuild (always true for orbit animation).
+     */
+    tick?: (nodes: RealtimeNode[], edges: RealtimeEdge[], config: NetworkPipelineConfig, size: [number, number], deltaTime: number) => boolean;
 }
 /** Threshold alerting configuration for streaming network nodes */
 export interface ThresholdAlertConfig {
@@ -284,7 +295,8 @@ export interface NetworkPipelineConfig {
     edgeStyle?: (d: any) => Record<string, any>;
     nodeLabel?: string | ((d: any) => string);
     showLabels?: boolean;
-    colorBy?: string | ((d: any) => string);
+    labelMode?: "leaf" | "parent" | "all";
+    colorBy?: string | ((d: any) => string | number);
     colorScheme?: string | string[];
     edgeColorBy?: "source" | "target" | "gradient" | ((d: any) => string);
     edgeOpacity?: number;
@@ -295,6 +307,30 @@ export interface NetworkPipelineConfig {
     pulse?: PulseConfig;
     staleness?: StalenessConfig;
     thresholds?: ThresholdAlertConfig;
+    /** Ring arrangement mode: "flat" (all children in one ring), "solar" (one per ring),
+     *  "atomic" ([2,8] electron shell), or custom capacities. @default "flat" */
+    orbitMode?: "flat" | "solar" | "atomic" | number[];
+    /** Ring size divisor per depth. Larger = tighter orbits. @default 2.95 */
+    orbitSize?: number | ((node: any) => number);
+    /** Orbit speed multiplier (higher = faster rotation). @default 0.25 */
+    orbitSpeed?: number;
+    /** Per-node speed modifier. @default (node) => 1 / (node.depth + 1) */
+    orbitRevolution?: (node: any) => number;
+    /**
+     * Built-in revolution style presets:
+     * - "locked": children rotate with parent at decreasing speed (default)
+     * - "decay": each depth level progressively slower, independent of parent
+     * - "alternate": odd-depth rings reverse direction
+     * Ignored when `orbitRevolution` is provided.
+     * @default "locked"
+     */
+    orbitRevolutionStyle?: "locked" | "decay" | "alternate";
+    /** Vertical squash for elliptical orbits. 1 = circle. @default 1 */
+    orbitEccentricity?: number | ((node: any) => number);
+    /** Show orbital ring ellipses as foreground graphics. @default true */
+    orbitShowRings?: boolean;
+    /** Enable orbit animation. @default true */
+    orbitAnimated?: boolean;
 }
 export interface StreamNetworkFrameProps<T = Record<string, any>> {
     chartType: NetworkChartType;
@@ -328,7 +364,7 @@ export interface StreamNetworkFrameProps<T = Record<string, any>> {
     particleStyle?: ParticleStyle;
     nodeStyle?: (d: any) => Record<string, any>;
     edgeStyle?: (d: any) => Record<string, any>;
-    colorBy?: string | ((d: any) => string);
+    colorBy?: string | ((d: any) => string | number);
     colorScheme?: string | string[];
     edgeColorBy?: "source" | "target" | "gradient" | ((d: any) => string);
     edgeOpacity?: number;
@@ -337,6 +373,7 @@ export interface StreamNetworkFrameProps<T = Record<string, any>> {
     nodeSizeRange?: [number, number];
     nodeLabel?: string | ((d: any) => string);
     showLabels?: boolean;
+    labelMode?: "leaf" | "parent" | "all";
     size?: [number, number];
     responsiveWidth?: boolean;
     responsiveHeight?: boolean;
@@ -377,6 +414,15 @@ export interface StreamNetworkFrameProps<T = Record<string, any>> {
     legend?: ReactNode | {
         legendGroups: LegendGroup[];
     };
+    legendPosition?: "right" | "left" | "top" | "bottom";
+    legendHoverBehavior?: (item: {
+        label: string;
+    } | null) => void;
+    legendClickBehavior?: (item: {
+        label: string;
+    }) => void;
+    legendHighlightedCategory?: string | null;
+    legendIsolatedCategories?: Set<string>;
     title?: string | ReactNode;
     foregroundGraphics?: ReactNode;
     backgroundGraphics?: ReactNode;
@@ -384,6 +430,16 @@ export interface StreamNetworkFrameProps<T = Record<string, any>> {
     pulse?: PulseConfig;
     staleness?: StalenessConfig;
     thresholds?: ThresholdAlertConfig;
+    orbitMode?: "flat" | "solar" | "atomic" | number[];
+    orbitSize?: number | ((node: any) => number);
+    orbitSpeed?: number;
+    orbitRevolution?: (node: any) => number;
+    orbitRevolutionStyle?: "locked" | "decay" | "alternate";
+    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) */
+    accessibleTable?: boolean;
 }
 export interface StreamNetworkFrameHandle {
     push(edge: EdgePush): void;

package/dist/{stream → components/stream}/ordinalTypes.d.ts

@@ -20,6 +20,12 @@ export interface WedgeSceneNode {
     style: Style;
     datum: any;
     category?: string;
+    /** Pulse intensity 0–1 (set when aggregated category value changes) */
+    _pulseIntensity?: number;
+    /** Pulse color */
+    _pulseColor?: string;
+    /** Animation target opacity (set during enter/exit transitions) */
+    _targetOpacity?: number;
 }
 export interface BoxplotSceneNode {
     type: "boxplot";
@@ -35,13 +41,7 @@ export interface BoxplotSceneNode {
     medianPos: number;
     q3Pos: number;
     maxPos: number;
-    stats: {
-        min: number;
-        q1: number;
-        median: number;
-        q3: number;
-        max: number;
-    };
+    stats: DistributionStats;
     style: Style;
     datum: any;
     category?: string;
@@ -51,6 +51,7 @@ export interface BoxplotSceneNode {
         value: number;
         datum: any;
     }[];
+    _targetOpacity?: number;
 }
 export interface DistributionStats {
     n: number;
@@ -88,6 +89,7 @@ export interface ViolinSceneNode {
     style: Style;
     datum: any;
     category?: string;
+    _targetOpacity?: number;
 }
 export interface ConnectorSceneNode {
     type: "connector";
@@ -98,6 +100,7 @@ export interface ConnectorSceneNode {
     style: Style;
     datum: any;
     group?: string;
+    _targetOpacity?: number;
 }
 export type { Style, PointSceneNode, RectSceneNode } from "./types";
 import type { PointSceneNode, RectSceneNode } from "./types";
@@ -141,7 +144,7 @@ export interface OrdinalPipelineConfig {
     showOutliers?: boolean;
     showIQR?: boolean;
     amplitude?: number;
-    oSort?: ((a: string, b: string) => number) | boolean | "asc" | "desc";
+    oSort?: ((a: any, b: any) => number) | boolean | "asc" | "desc";
     connectorAccessor?: string | ((d: any) => string);
     connectorStyle?: Style | ((d: any) => Style);
     dynamicColumnWidth?: string | ((data: any[]) => number);
@@ -189,7 +192,7 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
     rExtent?: [number?, number?];
     oExtent?: string[];
     extentPadding?: number;
-    oSort?: ((a: string, b: string) => number) | boolean | "asc" | "desc";
+    oSort?: ((a: any, b: any) => number) | boolean | "asc" | "desc";
     arrowOfTime?: ArrowOfTime;
     windowMode?: WindowMode;
     windowSize?: number;
@@ -203,7 +206,7 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
     oLabel?: string;
     rLabel?: string;
     oFormat?: (d: string) => string;
-    rFormat?: (d: number) => string;
+    rFormat?: (d: number | string) => string;
     enableHover?: boolean;
     hoverAnnotation?: boolean | HoverAnnotationConfig;
     tooltipContent?: (d: HoverData) => ReactNode;
@@ -213,7 +216,18 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
     showGrid?: boolean;
     legend?: ReactNode | {
         legendGroups: LegendGroup[];
+    } | {
+        gradient: import("../types/legendTypes").GradientLegendConfig;
     };
+    legendHoverBehavior?: (item: {
+        label: string;
+    } | null) => void;
+    legendClickBehavior?: (item: {
+        label: string;
+    }) => void;
+    legendHighlightedCategory?: string | null;
+    legendIsolatedCategories?: Set<string>;
+    legendPosition?: "right" | "left" | "top" | "bottom";
     backgroundGraphics?: ReactNode;
     foregroundGraphics?: ReactNode;
     title?: string | ReactNode;
@@ -224,6 +238,8 @@ export interface StreamOrdinalFrameProps<T = Record<string, any>> {
     pulse?: PulseConfig;
     transition?: TransitionConfig;
     staleness?: StalenessConfig;
+    /** Render a visually-hidden data table from the scene graph for screen readers (first 50 rows) */
+    accessibleTable?: boolean;
 }
 export interface StreamOrdinalFrameHandle<T = Record<string, any>> {
     push(datum: T): void;

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

@@ -0,0 +1,42 @@
+/**
+ * Shared transition utilities for PipelineStores.
+ *
+ * Extracts common easing logic and types used by PipelineStore,
+ * OrdinalPipelineStore, NetworkPipelineStore, and GeoPipelineStore.
+ */
+/** Active transition state tracked by each PipelineStore */
+export interface ActiveTransition {
+    startTime: number;
+    duration: number;
+}
+/** Easing mode — determines interpolation curve */
+export type EasingMode = "linear" | "ease-out-cubic";
+/**
+ * Compute the eased interpolation parameter from raw progress.
+ *
+ * @param rawT   - Raw linear progress in [0, 1]
+ * @param easing - Easing mode. "linear" returns rawT unchanged;
+ *                 "ease-out-cubic" (default) applies 1 - (1 - t)^3.
+ * @returns Eased progress in [0, 1]
+ */
+export declare function computeEasing(rawT: number, easing?: EasingMode): number;
+/**
+ * Compute the raw linear progress of a transition.
+ *
+ * @param now        - Current timestamp (e.g. performance.now())
+ * @param transition - The active transition state
+ * @returns Raw progress clamped to [0, 1]
+ */
+export declare function computeRawProgress(now: number, transition: ActiveTransition): number;
+/**
+ * Linearly interpolate between two values.
+ *
+ * @param from - Start value
+ * @param to   - End value
+ * @param t    - Eased progress in [0, 1]
+ */
+export declare function lerp(from: number, to: number, t: number): number;
+/**
+ * Get the current timestamp in a way that works both in browser and Node.
+ */
+export declare function now(): number;

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

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

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

@@ -0,0 +1,9 @@
+import type { GeoSceneNode } from "../geoTypes";
+/**
+ * Canvas renderer for GeoAreaSceneNode — projected geographic polygons.
+ * Uses Path2D for GPU-accelerated rendering of complex geo paths.
+ *
+ * Points and lines in a geo frame are rendered by the existing
+ * pointCanvasRenderer and lineCanvasRenderer respectively.
+ */
+export declare function geoCanvasRenderer(ctx: CanvasRenderingContext2D, nodes: GeoSceneNode[], _scales: any, _layout: any): void;

package/dist/{stream → components/stream}/renderers/heatmapCanvasRenderer.d.ts

@@ -1,6 +1,7 @@
 import type { StreamRendererFn } from "./types";
 /**
  * Canvas heatmap renderer.
- * Renders HeatcellSceneNode as filled rectangles with color encoding.
+ * Renders HeatcellSceneNode as filled rectangles with color encoding,
+ * and optionally draws cell value text when showValues is enabled.
  */
 export declare const heatmapCanvasRenderer: StreamRendererFn;

package/dist/{stream → components/stream}/renderers/lineCanvasRenderer.d.ts

@@ -4,5 +4,6 @@ import type { StreamRendererFn } from "./types";
  * Renders LineSceneNode paths using moveTo/lineTo.
  * Supports threshold-based segment coloring when colorThresholds + rawValues
  * are present on the node.
+ * Supports d3-shape curve interpolation when node.curve is set.
  */
 export declare const lineCanvasRenderer: StreamRendererFn;

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

@@ -0,0 +1,50 @@
+/**
+ * Shared pulse overlay rendering utilities.
+ *
+ * Pulse is a brief visual flash (glow/overlay) applied to scene nodes when
+ * their aggregated value changes. Each node carries `_pulseIntensity` (0–1),
+ * `_pulseColor`, and optionally `_pulseGlowRadius`.
+ *
+ * Three visual variants:
+ * - **Rect overlay**: semi-transparent fillRect on top of the bar/cell
+ * - **Circle glow ring**: expanding stroke ring around a point
+ * - **Path fill overlay**: re-traces an arbitrary path and fills with glow
+ */
+interface PulseFields {
+    _pulseIntensity?: number;
+    _pulseColor?: string;
+    _pulseGlowRadius?: number;
+}
+/**
+ * Returns true if the node has an active pulse effect.
+ */
+export declare function hasPulse(node: PulseFields): boolean;
+/**
+ * Render a rectangular pulse overlay (used by bar, heatmap, and network rect renderers).
+ * Call this after drawing the main fill/stroke for the rectangle.
+ */
+export declare function renderRectPulse(ctx: CanvasRenderingContext2D, node: PulseFields & {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}, alphaMultiplier?: number): void;
+/**
+ * Render a circular glow ring pulse (used by point and network circle renderers).
+ * Call this after drawing the main circle fill/stroke.
+ */
+export declare function renderCirclePulse(ctx: CanvasRenderingContext2D, node: PulseFields & {
+    x?: number;
+    y?: number;
+    cx?: number;
+    cy?: number;
+    r: number;
+}, alphaMultiplier?: number): void;
+/**
+ * Render a path-based fill pulse (used by area, wedge, and geo renderers).
+ * The caller must trace the path onto ctx BEFORE calling this function,
+ * or pass a Path2D object as the third argument (for geo renderers).
+ * This function sets alpha/fillStyle and calls ctx.fill().
+ */
+export declare function renderPathPulse(ctx: CanvasRenderingContext2D, node: PulseFields, path?: Path2D, alphaMultiplier?: number): void;
+export {};