semiotic 2.0.3 → 3.0.0-beta.2

package/dist/stream/OrdinalPipelineStore.d.ts

@@ -0,0 +1,65 @@
+import { type ScaleLinear } from "d3-scale";
+import type { OrdinalPipelineConfig, OrdinalScales, OrdinalSceneNode, OrdinalColumn, OrdinalLayout } from "./ordinalTypes";
+import type { Changeset } from "./types";
+export declare class OrdinalPipelineStore {
+    private buffer;
+    private rExtent;
+    /** Per-accessor extents for multiAxis mode */
+    private rExtents;
+    private config;
+    private getO;
+    private getR;
+    /** All resolved rAccessors (length > 1 when multiAxis) */
+    private rAccessors;
+    private getStack;
+    private getGroup;
+    private getColor;
+    private getConnector;
+    /** Discovered categories in insertion order */
+    private categories;
+    /** Lazy color map built from colorScheme for resolvePieceStyle */
+    private _colorSchemeMap;
+    private _colorSchemeIndex;
+    private timestampBuffer;
+    activeTransition: {
+        startTime: number;
+        duration: number;
+    } | null;
+    private prevPositionMap;
+    lastIngestTime: number;
+    scales: OrdinalScales | null;
+    /** Per-accessor scales for multiAxis */
+    multiScales: (ScaleLinear<number, number>)[];
+    scene: OrdinalSceneNode[];
+    columns: Record<string, OrdinalColumn>;
+    version: number;
+    constructor(config: OrdinalPipelineConfig);
+    ingest(changeset: Changeset): boolean;
+    private pushValueExtent;
+    private evictValueExtent;
+    /** For timeline type: resolve rAccessor as a [start, end] pair */
+    private getRawRange;
+    computeScene(layout: OrdinalLayout): void;
+    private resolveRAccessorName;
+    private resolveCategories;
+    private computeValueDomain;
+    private buildColumns;
+    private getSceneContext;
+    private buildSceneNodes;
+    private resolvePieceStyle;
+    private getColorFromScheme;
+    private resolveSummaryStyle;
+    computeDecayOpacity(bufferIndex: number, bufferSize: number): number;
+    private applyDecay;
+    private applyPulse;
+    get hasActivePulses(): boolean;
+    private snapshotPositions;
+    private startTransition;
+    advanceTransition(now: number): boolean;
+    getData(): Record<string, any>[];
+    clear(): void;
+    get size(): number;
+    getOAccessor(): (d: any) => string;
+    getRAccessor(): (d: any) => number;
+    updateConfig(config: Partial<OrdinalPipelineConfig>): void;
+}

package/dist/stream/OrdinalSVGOverlay.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+import type { OrdinalScales, AnnotationContext } from "./ordinalTypes";
+import type { ReactNode } from "react";
+import type { LegendGroup } from "../types/legendTypes";
+interface OrdinalSVGOverlayProps {
+    width: number;
+    height: number;
+    totalWidth: number;
+    totalHeight: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    scales: OrdinalScales | null;
+    showAxes?: boolean;
+    oLabel?: string;
+    rLabel?: string;
+    oFormat?: (d: string) => string;
+    rFormat?: (d: number) => string;
+    showGrid?: boolean;
+    title?: string | ReactNode;
+    legend?: ReactNode | {
+        legendGroups: LegendGroup[];
+    };
+    foregroundGraphics?: ReactNode;
+    annotations?: Record<string, any>[];
+    svgAnnotationRules?: (annotation: Record<string, any>, index: number, context: AnnotationContext) => ReactNode;
+    annotationFrame?: number;
+    children?: ReactNode;
+}
+export declare function OrdinalSVGOverlay(props: OrdinalSVGOverlayProps): React.JSX.Element;
+export {};

package/dist/stream/ParticlePool.d.ts

@@ -0,0 +1,28 @@
+import type { Particle, RealtimeEdge } from "./networkTypes";
+/**
+ * Object-pool particle manager for high-performance canvas rendering.
+ *
+ * Pre-allocates a fixed-size array to avoid GC pressure.
+ * Particles travel along bezier paths within link bands.
+ */
+export declare class ParticlePool {
+    particles: Particle[];
+    private capacity;
+    constructor(capacity: number);
+    /**
+     * Spawn a new particle on the given edge.
+     * Returns the particle if a free slot was found, null otherwise.
+     */
+    spawn(edgeIndex: number): Particle | null;
+    /**
+     * Advance all active particles by deltaTime.
+     * Recycles particles that have completed their journey (t >= 1).
+     */
+    step(deltaTime: number, speed: number, edges: RealtimeEdge[]): void;
+    /** Count active particles for a specific edge index */
+    countForEdge(edgeIndex: number): number;
+    /** Deactivate all particles */
+    clear(): void;
+    /** Resize the pool (creates a new array) */
+    resize(newCapacity: number): void;
+}

package/dist/stream/PipelineStore.d.ts

@@ -0,0 +1,161 @@
+import { RingBuffer } from "../realtime/RingBuffer";
+import type { Changeset, StreamChartType, StreamScales, StreamLayout, SceneNode, CandlestickStyle, Style, ArrowOfTime, WindowMode, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig } from "./types";
+export interface PipelineConfig {
+    chartType: StreamChartType;
+    runtimeMode?: "streaming" | "bounded";
+    windowSize: number;
+    windowMode: WindowMode;
+    arrowOfTime: ArrowOfTime;
+    extentPadding: number;
+    xAccessor?: string | ((d: any) => number);
+    yAccessor?: string | ((d: any) => number);
+    timeAccessor?: string | ((d: any) => number);
+    valueAccessor?: string | ((d: any) => number);
+    colorAccessor?: string | ((d: any) => string);
+    sizeAccessor?: string | ((d: any) => number);
+    groupAccessor?: string | ((d: any) => string);
+    categoryAccessor?: string | ((d: any) => string);
+    lineDataAccessor?: string;
+    xExtent?: [number | undefined, number | undefined] | [number];
+    yExtent?: [number | undefined, number | undefined] | [number];
+    sizeRange?: [number, number];
+    binSize?: number;
+    normalize?: boolean;
+    openAccessor?: string | ((d: any) => number);
+    highAccessor?: string | ((d: any) => number);
+    lowAccessor?: string | ((d: any) => number);
+    closeAccessor?: string | ((d: any) => number);
+    candlestickStyle?: CandlestickStyle;
+    boundsAccessor?: string | ((d: any) => number);
+    boundsStyle?: any;
+    lineStyle?: any;
+    pointStyle?: (d: any) => Style & {
+        r?: number;
+    };
+    areaStyle?: (d: any) => Style;
+    swarmStyle?: {
+        radius?: number;
+        fill?: string;
+        opacity?: number;
+        stroke?: string;
+        strokeWidth?: number;
+    };
+    colorScheme?: string | string[];
+    barColors?: Record<string, string>;
+    annotations?: Record<string, any>[];
+    decay?: DecayConfig;
+    pulse?: PulseConfig;
+    transition?: TransitionConfig;
+    staleness?: StalenessConfig;
+    heatmapAggregation?: "count" | "sum" | "mean";
+    heatmapXBins?: number;
+    heatmapYBins?: number;
+}
+export declare class PipelineStore {
+    private buffer;
+    private xExtent;
+    private yExtent;
+    private config;
+    private growingCap;
+    private getX;
+    private getY;
+    private getGroup;
+    private getCategory;
+    private getSize;
+    private getColor;
+    private getBounds;
+    private getOpen;
+    private getHigh;
+    private getLow;
+    private getClose;
+    private timestampBuffer;
+    activeTransition: {
+        startTime: number;
+        duration: number;
+    } | null;
+    private prevPositionMap;
+    lastIngestTime: number;
+    scales: StreamScales | null;
+    scene: SceneNode[];
+    version: number;
+    constructor(config: PipelineConfig);
+    /**
+     * Process a changeset from DataSourceAdapter.
+     * Returns true if the scene needs re-rendering.
+     */
+    ingest(changeset: Changeset): boolean;
+    /**
+     * Recompute scales and scene graph for the current buffer contents.
+     */
+    computeScene(layout: StreamLayout): void;
+    private buildSceneNodes;
+    private buildLineScene;
+    private buildAreaScene;
+    private buildStackedAreaScene;
+    private buildPointScene;
+    private buildHeatmapScene;
+    /**
+     * Streaming heatmap: discretize continuous x/y into a grid and aggregate.
+     */
+    private buildStreamingHeatmapScene;
+    private buildBarScene;
+    private buildSwarmScene;
+    private buildWaterfallScene;
+    private buildCandlestickScene;
+    private buildBoundsForGroup;
+    private resolveBoundsStyle;
+    /**
+     * Compute decay opacity for a datum at `bufferIndex` out of `bufferSize` items.
+     * Index 0 = oldest, bufferSize-1 = newest. Returns 0–1.
+     */
+    computeDecayOpacity(bufferIndex: number, bufferSize: number): number;
+    /**
+     * Apply decay opacity to a list of discrete scene nodes.
+     * Uses the datum's index in the buffer data array.
+     */
+    private applyDecay;
+    /**
+     * Compute pulse intensity for a datum inserted at `insertTime`.
+     * Returns 0–1 (1 = just inserted, 0 = pulse expired).
+     */
+    private computePulseIntensity;
+    /**
+     * Apply pulse glow to discrete scene nodes.
+     */
+    private applyPulse;
+    /**
+     * Returns true if there are active pulse animations that need continuous rendering.
+     */
+    get hasActivePulses(): boolean;
+    /**
+     * Snapshot current scene node positions before rebuild.
+     */
+    private snapshotPositions;
+    /**
+     * Get a stable identity key for a scene node.
+     */
+    private getNodeIdentity;
+    /**
+     * After scene rebuild, set up transition from old to new positions.
+     */
+    private startTransition;
+    /**
+     * Advance the transition animation. Returns true if still animating.
+     */
+    advanceTransition(now: number): boolean;
+    private groupData;
+    private resolveLineStyle;
+    private resolveAreaStyle;
+    getData(): Record<string, any>[];
+    getExtents(): {
+        x: [number, number];
+        y: [number, number];
+    } | null;
+    clear(): void;
+    get size(): number;
+    getBuffer(): RingBuffer<Record<string, any>>;
+    getXAccessor(): (d: any) => number;
+    getYAccessor(): (d: any) => number;
+    getCategoryAccessor(): ((d: any) => string) | undefined;
+    updateConfig(config: Partial<PipelineConfig>): void;
+}

package/dist/stream/SVGOverlay.d.ts

@@ -0,0 +1,37 @@
+import * as React from "react";
+import type { StreamScales, AnnotationContext, MarginalGraphicsConfig } from "./types";
+import type { ReactNode } from "react";
+import type { LegendGroup } from "../types/legendTypes";
+interface SVGOverlayProps {
+    width: number;
+    height: number;
+    totalWidth: number;
+    totalHeight: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    scales: StreamScales | null;
+    showAxes?: boolean;
+    xLabel?: string;
+    yLabel?: string;
+    xFormat?: (d: any) => string;
+    yFormat?: (d: any) => string;
+    showGrid?: boolean;
+    title?: string | ReactNode;
+    legend?: ReactNode | {
+        legendGroups: LegendGroup[];
+    };
+    foregroundGraphics?: ReactNode;
+    marginalGraphics?: MarginalGraphicsConfig;
+    xValues?: number[];
+    yValues?: number[];
+    annotations?: Record<string, any>[];
+    svgAnnotationRules?: (annotation: Record<string, any>, index: number, context: AnnotationContext) => ReactNode;
+    annotationFrame?: number;
+    children?: ReactNode;
+}
+export declare function SVGOverlay(props: SVGOverlayProps): React.JSX.Element;
+export {};

package/dist/stream/SceneGraph.d.ts

@@ -0,0 +1,16 @@
+import type { SceneNode, LineSceneNode, AreaSceneNode, PointSceneNode, RectSceneNode, HeatcellSceneNode, Style, StreamScales } from "./types";
+export declare function buildLineNode(data: Record<string, any>[], scales: StreamScales, xGet: (d: Record<string, any>) => number, yGet: (d: Record<string, any>) => number, style: Style, group?: string): LineSceneNode;
+export declare function buildAreaNode(data: Record<string, any>[], scales: StreamScales, xGet: (d: Record<string, any>) => number, yGet: (d: Record<string, any>) => number, baselineY: number, style: Style, group?: string): AreaSceneNode;
+export declare function buildStackedAreaNodes(groups: {
+    key: string;
+    data: Record<string, any>[];
+}[], scales: StreamScales, xGet: (d: Record<string, any>) => number, yGet: (d: Record<string, any>) => number, styleFn: (group: string, sampleDatum?: Record<string, any>) => Style, normalize?: boolean): AreaSceneNode[];
+export declare function buildPointNode(datum: Record<string, any>, scales: StreamScales, xGet: (d: Record<string, any>) => number, yGet: (d: Record<string, any>) => number, r: number, style: Style): PointSceneNode | null;
+export declare function buildRectNode(x: number, y: number, w: number, h: number, style: Style, datum: any, group?: string): RectSceneNode;
+export declare function buildHeatcellNode(x: number, y: number, w: number, h: number, fill: string, datum: any): HeatcellSceneNode;
+export interface SceneGraphData {
+    nodes: SceneNode[];
+    version: number;
+}
+export declare function createSceneGraph(): SceneGraphData;
+export declare function updateSceneGraph(scene: SceneGraphData, nodes: SceneNode[]): SceneGraphData;

package/dist/stream/StreamNetworkFrame.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { StreamNetworkFrameProps, StreamNetworkFrameHandle } from "./networkTypes";
+declare const StreamNetworkFrame: React.ForwardRefExoticComponent<StreamNetworkFrameProps<Record<string, any>> & React.RefAttributes<StreamNetworkFrameHandle>>;
+export default StreamNetworkFrame;

package/dist/stream/StreamOrdinalFrame.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { StreamOrdinalFrameProps, StreamOrdinalFrameHandle } from "./ordinalTypes";
+declare const StreamOrdinalFrame: React.ForwardRefExoticComponent<StreamOrdinalFrameProps<Record<string, any>> & React.RefAttributes<StreamOrdinalFrameHandle<Record<string, any>>>>;
+export default StreamOrdinalFrame;

package/dist/stream/StreamXYFrame.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import type { StreamXYFrameProps, StreamXYFrameHandle } from "./types";
+declare const StreamXYFrame: React.ForwardRefExoticComponent<StreamXYFrameProps<Record<string, any>> & React.RefAttributes<StreamXYFrameHandle<Record<string, any>>>>;
+export default StreamXYFrame;

package/dist/stream/accessorUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveAccessor<T>(accessor: string | ((d: T) => number) | undefined, fallback: string): (d: T) => number;
+export declare function resolveStringAccessor<T>(accessor: string | ((d: T) => string) | undefined, fallback?: string): ((d: T) => string) | undefined;

package/dist/stream/index.d.ts

@@ -0,0 +1,16 @@
+export { default as StreamXYFrame } from "./StreamXYFrame";
+export { SVGOverlay } from "./SVGOverlay";
+export { DataSourceAdapter } from "./DataSourceAdapter";
+export { PipelineStore } from "./PipelineStore";
+export { findNearestNode, findNearestIndex } from "./CanvasHitTester";
+export { lineCanvasRenderer } from "./renderers/lineCanvasRenderer";
+export { areaCanvasRenderer } from "./renderers/areaCanvasRenderer";
+export { pointCanvasRenderer } from "./renderers/pointCanvasRenderer";
+export { barCanvasRenderer } from "./renderers/barCanvasRenderer";
+export { swarmCanvasRenderer } from "./renderers/swarmCanvasRenderer";
+export { waterfallCanvasRenderer } from "./renderers/waterfallCanvasRenderer";
+export { heatmapCanvasRenderer } from "./renderers/heatmapCanvasRenderer";
+export type { StreamXYFrameProps, StreamXYFrameHandle, StreamChartType, RuntimeMode, SceneNode, LineSceneNode, AreaSceneNode, PointSceneNode, RectSceneNode, HeatcellSceneNode, Changeset, StreamScales, StreamLayout, CurveType, CanvasRendererFn, Style } from "./types";
+export type { StreamRendererFn } from "./renderers/types";
+export type { HitResult } from "./CanvasHitTester";
+export type { PipelineConfig } from "./PipelineStore";

package/dist/stream/layouts/chordLayoutPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { NetworkLayoutPlugin } from "../networkTypes";
+/**
+ * Chord layout plugin — uses d3-chord for layout computation.
+ *
+ * Produces arc scene nodes for chord group arcs and ribbon scene edges
+ * for the chord ribbons. Labels are positioned outside arcs.
+ */
+export declare const chordLayoutPlugin: NetworkLayoutPlugin;

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

@@ -0,0 +1,9 @@
+import type { NetworkLayoutPlugin } from "../networkTypes";
+/**
+ * Force-directed layout plugin — uses d3-force for physics-based node positioning.
+ *
+ * Produces circle scene nodes and line scene edges. Runs the force simulation
+ * synchronously for a configurable number of iterations, using phyllotaxis
+ * spiral for deterministic initial positions.
+ */
+export declare const forceLayoutPlugin: NetworkLayoutPlugin;

package/dist/stream/layouts/hierarchyLayoutPlugin.d.ts

@@ -0,0 +1,17 @@
+import type { NetworkLayoutPlugin } from "../networkTypes";
+/**
+ * Hierarchy layout plugin — handles tree, cluster, treemap, circlepack, and partition layouts.
+ *
+ * Uses d3-hierarchy for all layout computations. This plugin is `hierarchical: true`,
+ * meaning the input data is a single root node object rather than flat nodes+edges arrays.
+ *
+ * The hierarchy root is passed via `(config as any).__hierarchyRoot`, set by the store
+ * before calling computeLayout. The plugin builds the d3 hierarchy internally, runs the
+ * appropriate layout algorithm, and populates the nodes/edges arrays.
+ *
+ * Scene output varies by layout type:
+ * - tree/cluster: NetworkCircleNode[] + NetworkCurvedEdge[] (cubic bezier parent-child links)
+ * - treemap/partition: NetworkRectNode[] (space-filling rectangles, no edges)
+ * - circlepack: NetworkCircleNode[] (nested circles, no edges)
+ */
+export declare const hierarchyLayoutPlugin: NetworkLayoutPlugin;

package/dist/stream/layouts/index.d.ts

@@ -0,0 +1,11 @@
+import type { NetworkLayoutPlugin, NetworkChartType } from "../networkTypes";
+import { sankeyLayoutPlugin } from "./sankeyLayoutPlugin";
+import { forceLayoutPlugin } from "./forceLayoutPlugin";
+import { chordLayoutPlugin } from "./chordLayoutPlugin";
+import { hierarchyLayoutPlugin } from "./hierarchyLayoutPlugin";
+/**
+ * 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 };

package/dist/stream/layouts/sankeyLayoutPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { NetworkLayoutPlugin } from "../networkTypes";
+/**
+ * Sankey layout plugin — uses d3-sankey-circular for layout computation.
+ *
+ * Produces rect scene nodes for Sankey node bars and bezier band scene edges
+ * for the flow links. Supports both horizontal and vertical orientation.
+ */
+export declare const sankeyLayoutPlugin: NetworkLayoutPlugin;