semiotic 3.0.0 → 3.1.0

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

@@ -0,0 +1,81 @@
+import type { ZoomTransform } from "d3-zoom";
+import type { GeoPipelineConfig, GeoScales, GeoSceneNode } from "./geoTypes";
+import type { StreamLayout } from "./types";
+import type { ActiveTransition } from "./pipelineTransitionUtils";
+export declare class GeoPipelineStore {
+    config: GeoPipelineConfig;
+    scene: GeoSceneNode[];
+    scales: GeoScales | null;
+    version: number;
+    private projection;
+    private geoPath;
+    private baseScale;
+    private baseTranslate;
+    private baseRotation;
+    currentZoom: number;
+    cartogramLayout: {
+        cx: number;
+        cy: number;
+        maxCost: number;
+        availableRadius: number;
+    } | null;
+    private areas;
+    private pointData;
+    private lineData;
+    private pointBuffer;
+    private streaming;
+    lastIngestTime: number;
+    private timestampBuffer;
+    activeTransition: ActiveTransition | null;
+    private prevPositions;
+    constructor(config: GeoPipelineConfig);
+    updateConfig(config: Partial<GeoPipelineConfig>): void;
+    setAreas(features: GeoJSON.Feature[]): void;
+    setPoints(data: Record<string, any>[]): void;
+    setLines(data: Record<string, any>[]): void;
+    /** Initialize streaming mode with a ring buffer */
+    initStreaming(windowSize?: number): void;
+    /** Push a single streaming point */
+    pushPoint(datum: Record<string, any>): void;
+    /** Push multiple streaming points */
+    pushMany(data: Record<string, any>[]): void;
+    clear(): void;
+    computeScene(layout: StreamLayout): void;
+    private fitProjection;
+    /**
+     * Apply a d3-zoom transform to the projection.
+     * Called on zoom end — updates projection scale/translate and rebuilds scene.
+     */
+    applyZoomTransform(transform: ZoomTransform, layout: StreamLayout): void;
+    /**
+     * Apply zoom as scale-only (no translate shift).
+     * Used in drag-rotate mode to prevent globe drift on zoom.
+     */
+    applyZoomScale(k: number, layout: StreamLayout): void;
+    /**
+     * Apply a rotation to the projection and rebuild the scene.
+     * Called during drag-rotate gestures (orthographic globe spinning).
+     */
+    applyRotation(rotation: [number, number, number], layout: StreamLayout): void;
+    /**
+     * Set the projection rotation without rebuilding the scene.
+     * Use when rotation will be followed by another operation that rebuilds
+     * (e.g., applyZoomScale), to avoid redundant scene builds.
+     */
+    setRotation(rotation: [number, number, number]): void;
+    /** Get current rotation (for external tracking) */
+    getRotation(): [number, number, number];
+    /** Get the current base projection state (for zoom reset) */
+    getBaseProjectionState(): {
+        scale: number;
+        translate: [number, number];
+    };
+    private getPoints;
+    private buildSceneNodes;
+    private applyCartogramTransform;
+    private applyDecay;
+    private applyPulse;
+    get hasActivePulses(): boolean;
+    private startTransition;
+    advanceTransition(now: number): boolean;
+}

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

@@ -0,0 +1,31 @@
+import type { GeoProjection } from "d3-geo";
+export type TileURLTemplate = string | ((z: number, x: number, y: number, dpr: number) => string);
+interface CachedTile {
+    img: HTMLImageElement;
+    loaded: boolean;
+    key: string;
+    lastUsed: number;
+}
+export declare class TileCache {
+    private cache;
+    private limit;
+    constructor(limit?: number);
+    get(key: string): CachedTile | undefined;
+    set(key: string, entry: CachedTile): void;
+    private evict;
+    clear(): void;
+}
+export interface TileRenderOptions {
+    tileURL: TileURLTemplate;
+    projection: GeoProjection;
+    width: number;
+    height: number;
+    tileCache: TileCache;
+    onTileLoad?: () => void;
+}
+/**
+ * Render visible tiles onto a canvas context.
+ * Returns true if all visible tiles are loaded (no pending fetches).
+ */
+export declare function renderTiles(ctx: CanvasRenderingContext2D, options: TileRenderOptions): boolean;
+export {};

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

@@ -1,4 +1,5 @@
 import { ParticlePool } from "./ParticlePool";
+import type { ActiveTransition } from "./pipelineTransitionUtils";
 import type { NetworkPipelineConfig, NetworkSceneNode, NetworkSceneEdge, NetworkLabel, RealtimeNode, RealtimeEdge, EdgePush } from "./networkTypes";
 /**
  * NetworkPipelineStore — stateful store for the StreamNetworkFrame.
@@ -20,13 +21,12 @@ export declare class NetworkPipelineStore {
     particlePool: ParticlePool | null;
     private config;
     private tensionConfig;
-    transition: {
-        startTime: number;
-        duration: number;
-    } | null;
+    transition: ActiveTransition | null;
     lastIngestTime: number;
     private nodeTimestamps;
     private edgeTimestamps;
+    /** Cached sorted node-timestamp entries for applyDecay(); null = needs rebuild */
+    private _decaySortedNodes;
     /** Node IDs added in the most recent layout */
     addedNodes: Set<string>;
     /** Node IDs removed in the most recent layout */
@@ -39,6 +39,11 @@ export declare class NetworkPipelineStore {
     lastTopologyChangeTime: number;
     private previousNodeIds;
     private previousEdgeKeys;
+    /** Snapshot of node positions from the last layout — used for force warm-start */
+    _lastPositionSnapshot: Map<string, {
+        x: number;
+        y: number;
+    }> | null;
     constructor(config: NetworkPipelineConfig);
     updateConfig(config: NetworkPipelineConfig): void;
     /**
@@ -68,6 +73,13 @@ export declare class NetworkPipelineStore {
      * Build the scene graph from current layout positions.
      */
     buildScene(size: [number, number]): void;
+    /** Whether the current layout plugin drives continuous animation (respects orbitAnimated config) */
+    get isAnimating(): boolean;
+    /**
+     * Advance the layout animation by one frame (e.g. orbit rotation).
+     * Returns true if the scene should be rebuilt.
+     */
+    tickAnimation(size: [number, number], deltaTime: number): boolean;
     /**
      * Advance the transition animation. Returns true if still animating.
      */

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

@@ -1,7 +1,7 @@
 import * as React from "react";
 import type { ReactNode } from "react";
 import type { NetworkLabel } from "./networkTypes";
-import type { LegendGroup } from "../types/legendTypes";
+import type { LegendGroup, GradientLegendConfig } from "../types/legendTypes";
 export interface NetworkSVGOverlayProps {
     width: number;
     height: number;
@@ -20,9 +20,32 @@ export interface NetworkSVGOverlayProps {
     /** Legend configuration */
     legend?: ReactNode | {
         legendGroups: LegendGroup[];
+    } | {
+        gradient: GradientLegendConfig;
     };
+    legendHoverBehavior?: (item: {
+        label: string;
+    } | null) => void;
+    legendClickBehavior?: (item: {
+        label: string;
+    }) => void;
+    legendHighlightedCategory?: string | null;
+    legendIsolatedCategories?: Set<string>;
+    legendPosition?: "right" | "left" | "top" | "bottom";
     /** User-provided SVG elements on top */
     foregroundGraphics?: ReactNode;
+    /** Scene nodes for annotation positioning */
+    sceneNodes?: Array<{
+        type: string;
+        datum: any;
+        id?: string;
+        x?: number;
+        y?: number;
+        cx?: number;
+        cy?: number;
+        w?: number;
+        h?: number;
+    }>;
     /** Annotations */
     annotations?: Record<string, any>[];
     svgAnnotationRules?: (annotation: Record<string, any>, index: number, context: any) => ReactNode;

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

@@ -1,6 +1,7 @@
 import { type ScaleLinear } from "d3-scale";
 import type { OrdinalPipelineConfig, OrdinalScales, OrdinalSceneNode, OrdinalColumn, OrdinalLayout } from "./ordinalTypes";
 import type { Changeset } from "./types";
+import type { ActiveTransition } from "./pipelineTransitionUtils";
 export declare class OrdinalPipelineStore {
     private buffer;
     private rExtent;
@@ -17,15 +18,16 @@ export declare class OrdinalPipelineStore {
     private getConnector;
     /** Discovered categories in insertion order */
     private categories;
+    /** True once a non-bounded (push) changeset has been ingested */
+    private _hasStreamingData;
     /** Lazy color map built from colorScheme for resolvePieceStyle */
     private _colorSchemeMap;
     private _colorSchemeIndex;
     private timestampBuffer;
-    activeTransition: {
-        startTime: number;
-        duration: number;
-    } | null;
+    activeTransition: ActiveTransition | null;
     private prevPositionMap;
+    /** Exit nodes awaiting fade-out removal */
+    exitNodes: import("./ordinalTypes").OrdinalSceneNode[];
     lastIngestTime: number;
     scales: OrdinalScales | null;
     /** Per-accessor scales for multiAxis */
@@ -53,6 +55,8 @@ export declare class OrdinalPipelineStore {
     private applyDecay;
     private applyPulse;
     get hasActivePulses(): boolean;
+    /** Build a stable identity key for a scene node based on its content, not array index */
+    private getNodeKey;
     private snapshotPositions;
     private startTransition;
     advanceTransition(now: number): boolean;

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

@@ -2,7 +2,7 @@ import * as React from "react";
 import type { OrdinalScales } from "./ordinalTypes";
 import type { AnnotationContext } from "../realtime/types";
 import type { ReactNode } from "react";
-import type { LegendGroup } from "../types/legendTypes";
+import type { LegendGroup, GradientLegendConfig } from "../types/legendTypes";
 interface OrdinalSVGOverlayProps {
     width: number;
     height: number;
@@ -24,7 +24,18 @@ interface OrdinalSVGOverlayProps {
     title?: string | ReactNode;
     legend?: ReactNode | {
         legendGroups: LegendGroup[];
+    } | {
+        gradient: GradientLegendConfig;
     };
+    legendHoverBehavior?: (item: {
+        label: string;
+    } | null) => void;
+    legendClickBehavior?: (item: {
+        label: string;
+    }) => void;
+    legendHighlightedCategory?: string | null;
+    legendIsolatedCategories?: Set<string>;
+    legendPosition?: "right" | "left" | "top" | "bottom";
     foregroundGraphics?: ReactNode;
     annotations?: Record<string, any>[];
     svgAnnotationRules?: (annotation: Record<string, any>, index: number, context: AnnotationContext) => ReactNode;
@@ -32,7 +43,26 @@ interface OrdinalSVGOverlayProps {
     xAccessor?: string;
     yAccessor?: string;
     annotationData?: Record<string, any>[];
+    /** When true, grid lines and axis baselines are skipped (rendered by OrdinalSVGUnderlay instead) */
+    underlayRendered?: boolean;
     children?: ReactNode;
 }
+interface OrdinalSVGUnderlayProps {
+    width: number;
+    height: number;
+    totalWidth: number;
+    totalHeight: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    scales: OrdinalScales | null;
+    showAxes?: boolean;
+    showGrid?: boolean;
+    rFormat?: (d: number) => string;
+}
+export declare function OrdinalSVGUnderlay(props: OrdinalSVGUnderlayProps): React.JSX.Element | null;
 export declare function OrdinalSVGOverlay(props: OrdinalSVGOverlayProps): React.JSX.Element | null;
 export {};

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

@@ -1,5 +1,7 @@
+import { type Quadtree } from "d3-quadtree";
 import { RingBuffer } from "../realtime/RingBuffer";
-import type { Changeset, StreamChartType, StreamScales, StreamLayout, SceneNode, CandlestickStyle, Style, ArrowOfTime, WindowMode, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig } from "./types";
+import type { Changeset, StreamChartType, StreamScales, StreamLayout, SceneNode, PointSceneNode, CandlestickStyle, Style, ArrowOfTime, WindowMode, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig, CurveType } from "./types";
+import type { ActiveTransition } from "./pipelineTransitionUtils";
 export interface PipelineConfig {
     chartType: StreamChartType;
     runtimeMode?: "streaming" | "bounded";
@@ -7,6 +9,7 @@ export interface PipelineConfig {
     windowMode: WindowMode;
     arrowOfTime: ArrowOfTime;
     extentPadding: number;
+    maxCapacity?: number;
     xAccessor?: string | ((d: any) => number);
     yAccessor?: string | ((d: any) => number);
     timeAccessor?: string | ((d: any) => number);
@@ -16,6 +19,8 @@ export interface PipelineConfig {
     groupAccessor?: string | ((d: any) => string);
     categoryAccessor?: string | ((d: any) => string);
     lineDataAccessor?: string;
+    xScaleType?: "linear" | "log";
+    yScaleType?: "linear" | "log";
     xExtent?: [number | undefined, number | undefined] | [number];
     yExtent?: [number | undefined, number | undefined] | [number];
     sizeRange?: [number, number];
@@ -64,7 +69,10 @@ export interface PipelineConfig {
     heatmapAggregation?: "count" | "sum" | "mean";
     heatmapXBins?: number;
     heatmapYBins?: number;
+    showValues?: boolean;
+    heatmapValueFormat?: (v: number) => string;
     pointIdAccessor?: string | ((d: any) => string);
+    curve?: CurveType;
 }
 export declare class PipelineStore {
     private buffer;
@@ -86,15 +94,33 @@ export declare class PipelineStore {
     private getClose;
     private getPointId;
     private timestampBuffer;
-    activeTransition: {
-        startTime: number;
-        duration: number;
-    } | null;
+    activeTransition: ActiveTransition | null;
     private prevPositionMap;
+    /** Previous line/area path arrays for path interpolation */
+    private prevPathMap;
+    /** Exit nodes awaiting fade-out removal */
+    exitNodes: SceneNode[];
     lastIngestTime: number;
+    /** Unified color map cache keyed by sorted category set — shared across point, swarm, etc. */
+    private _colorMapCache;
+    /** Separate group→color map for resolveGroupColor (insertion-order based, never invalidates _colorMapCache) */
+    private _groupColorMap;
+    private _barCategoryCache;
+    /** Cache stacked area cumulative sums to skip recalculation when buffer hasn't changed */
+    private _stackExtentCache;
+    /** Monotonic counter incremented on each ingest — used as part of cache keys */
+    private _ingestVersion;
+    /** Cached materialized array from buffer.toArray() — only rebuilt when buffer changes */
+    private _bufferArrayCache;
+    /** True when the buffer has been mutated since last toArray() call */
+    private _bufferDirty;
+    private needsFullRebuild;
+    private lastLayout;
     scales: StreamScales | null;
     scene: SceneNode[];
     version: number;
+    private _quadtree;
+    private static readonly QUADTREE_THRESHOLD;
     constructor(config: PipelineConfig);
     /**
      * Process a changeset from DataSourceAdapter.
@@ -105,6 +131,21 @@ export declare class PipelineStore {
      * Recompute scales and scene graph for the current buffer contents.
      */
     computeScene(layout: StreamLayout): void;
+    /**
+     * Build or clear the quadtree spatial index for point scene nodes.
+     * Only built for scatter/bubble charts with >QUADTREE_THRESHOLD points.
+     */
+    private rebuildQuadtree;
+    /**
+     * Get the quadtree spatial index, if available.
+     * Returns null when chart type is not scatter/bubble or point count is below threshold.
+     */
+    get quadtree(): Quadtree<PointSceneNode> | null;
+    /**
+     * Remap existing scene node coordinates for a new layout size.
+     * Proportionally scales all pixel coordinates without rebuilding from data.
+     */
+    private remapScene;
     private buildSceneNodes;
     private buildLineScene;
     private buildAreaScene;
@@ -154,6 +195,7 @@ export declare class PipelineStore {
     private getNodeIdentity;
     /**
      * 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).
      */
     private startTransition;
     /**
@@ -161,8 +203,25 @@ export declare class PipelineStore {
      */
     advanceTransition(now: number): boolean;
     private groupData;
+    /**
+     * Resolve a category→color map from data using the colorAccessor.
+     * Caches the result in _colorMapCache keyed by sorted category set —
+     * only rebuilds when the set of categories changes.
+     */
+    private resolveColorMap;
     private resolveLineStyle;
     private resolveAreaStyle;
+    /** Resolve a group name to a color from the cached color map or a dedicated group palette.
+     *  First checks _colorMapCache (populated by resolveColorMap when colorAccessor is set).
+     *  Falls back to _groupColorMap (insertion-order, never mutates _colorMapCache). */
+    private resolveGroupColor;
+    /**
+     * Return a cached materialized array of the buffer contents.
+     * Only calls buffer.toArray() when the buffer has actually changed
+     * (new push, resize, or clear), avoiding per-frame allocation on
+     * transition ticks, hover redraws, and other non-data-changing renders.
+     */
+    private getBufferArray;
     getData(): Record<string, any>[];
     getExtents(): {
         x: [number, number];

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

@@ -0,0 +1,98 @@
+import * as React from "react";
+import type { StreamScales, MarginalGraphicsConfig } from "./types";
+import type { AnnotationContext } from "../realtime/types";
+import type { ReactNode } from "react";
+import type { LegendGroup, GradientLegendConfig } from "../types/legendTypes";
+export interface AxisConfig {
+    orient: "left" | "right" | "top" | "bottom";
+    label?: string;
+    ticks?: number;
+    tickFormat?: (d: any) => string;
+    baseline?: boolean | "under";
+    jaggedBase?: boolean;
+    /** Highlight ticks at time boundaries (new month, year, etc.) with semibold text.
+     * `true` auto-detects Date boundaries. A function receives (value, index) and returns true for landmark ticks. */
+    landmarkTicks?: boolean | ((value: any, index: number) => boolean);
+}
+interface SVGOverlayProps {
+    width: number;
+    height: number;
+    totalWidth: number;
+    totalHeight: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    scales: StreamScales | null;
+    showAxes?: boolean;
+    axes?: AxisConfig[];
+    xLabel?: string;
+    yLabel?: string;
+    xFormat?: (d: any) => string;
+    yFormat?: (d: any) => string;
+    showGrid?: boolean;
+    title?: string | ReactNode;
+    legend?: ReactNode | {
+        legendGroups: LegendGroup[];
+    } | {
+        gradient: GradientLegendConfig;
+    };
+    /** Callback when hovering a legend item */
+    legendHoverBehavior?: (item: {
+        label: string;
+    } | null) => void;
+    /** Callback when clicking a legend item */
+    legendClickBehavior?: (item: {
+        label: string;
+    }) => void;
+    /** Currently highlighted category label (for hover dimming) */
+    legendHighlightedCategory?: string | null;
+    /** Set of isolated category labels (for click isolation) */
+    legendIsolatedCategories?: Set<string>;
+    /** Legend position relative to chart area */
+    legendPosition?: "right" | "left" | "top" | "bottom";
+    foregroundGraphics?: ReactNode;
+    marginalGraphics?: MarginalGraphicsConfig;
+    xValues?: number[];
+    yValues?: number[];
+    annotations?: Record<string, any>[];
+    svgAnnotationRules?: (annotation: Record<string, any>, index: number, context: AnnotationContext) => ReactNode;
+    annotationFrame?: number;
+    xAccessor?: string;
+    yAccessor?: string;
+    annotationData?: Record<string, any>[];
+    pointNodes?: {
+        pointId?: string;
+        x: number;
+        y: number;
+        r: number;
+    }[];
+    /** Curve interpolation type for envelope annotations */
+    curve?: string;
+    /** When true, grid lines and axis baselines are skipped (rendered by SVGUnderlay instead) */
+    underlayRendered?: boolean;
+    children?: ReactNode;
+}
+interface SVGUnderlayProps {
+    width: number;
+    height: number;
+    totalWidth: number;
+    totalHeight: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    scales: StreamScales | null;
+    showAxes?: boolean;
+    axes?: AxisConfig[];
+    showGrid?: boolean;
+    xFormat?: (d: any) => string;
+    yFormat?: (d: any) => string;
+}
+export declare function SVGUnderlay(props: SVGUnderlayProps): React.JSX.Element | null;
+export declare function SVGOverlay(props: SVGOverlayProps): React.JSX.Element | null;
+export {};

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

@@ -1,13 +1,17 @@
-import type { SceneNode, LineSceneNode, AreaSceneNode, PointSceneNode, RectSceneNode, HeatcellSceneNode, Style, StreamScales } from "./types";
+import type { SceneNode, LineSceneNode, AreaSceneNode, PointSceneNode, RectSceneNode, HeatcellSceneNode, Style, StreamScales, CurveType } 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, y0Get?: (d: Record<string, any>) => number): 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[];
+}[], scales: StreamScales, xGet: (d: Record<string, any>) => number, yGet: (d: Record<string, any>) => number, styleFn: (group: string, sampleDatum?: Record<string, any>) => Style, normalize?: boolean, curve?: CurveType): 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, pointId?: string): 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 declare function buildHeatcellNode(x: number, y: number, w: number, h: number, fill: string, datum: any, options?: {
+    value?: number;
+    showValues?: boolean;
+    valueFormat?: (v: number) => string;
+}): HeatcellSceneNode;
 export interface SceneGraphData {
     nodes: SceneNode[];
     version: number;

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

@@ -0,0 +1,22 @@
+/**
+ * Scene graph → SVG element converters.
+ *
+ * Shared module used by Stream Frames for SSR rendering and
+ * by semiotic/server for static SVG export.
+ */
+import * as React from "react";
+import type { SceneNode } from "./types";
+import type { NetworkSceneNode, NetworkSceneEdge, NetworkLabel } from "./networkTypes";
+import type { OrdinalSceneNode } from "./ordinalTypes";
+import type { GeoSceneNode } from "./geoTypes";
+export declare function xySceneNodeToSVG(node: SceneNode, i: number): React.ReactNode;
+export declare function networkSceneNodeToSVG(node: NetworkSceneNode, i: number): React.ReactNode;
+export declare function networkSceneEdgeToSVG(edge: NetworkSceneEdge, i: number): React.ReactNode;
+export declare function networkLabelToSVG(label: NetworkLabel, i: number): React.ReactNode;
+export declare function ordinalSceneNodeToSVG(node: OrdinalSceneNode, i: number): React.ReactNode;
+export declare function geoSceneNodeToSVG(node: GeoSceneNode, i: number): React.ReactNode;
+/**
+ * Returns true when running in a true server/Node.js context where
+ * window and document are not available.
+ */
+export declare const isServerEnvironment: boolean;

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

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

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

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

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

@@ -0,0 +1,26 @@
+/**
+ * Shared canvas setup utilities used by all Stream Frames.
+ *
+ * Eliminates duplicated DPR / sizing / transform logic across
+ * StreamXYFrame, StreamGeoFrame, StreamNetworkFrame, and StreamOrdinalFrame.
+ */
+export interface CanvasMargin {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * Set a canvas element's physical (pixel) and CSS (logical) dimensions,
+ * accounting for devicePixelRatio. Returns the 2D context ready for drawing
+ * with the DPR transform and margin translation already applied.
+ *
+ * After this call the context's coordinate space is:
+ *   (0, 0) = top-left of the chart area (inside margins)
+ *   (-margin.left, -margin.top) = top-left of the full canvas
+ */
+export declare function prepareCanvas(canvas: HTMLCanvasElement, size: [number, number], margin: CanvasMargin, dpr: number): CanvasRenderingContext2D | null;
+/**
+ * Get the current devicePixelRatio, defaulting to 1 in non-browser environments.
+ */
+export declare function getDevicePixelRatio(): number;