semiotic 3.7.0 → 3.7.2

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

@@ -1,4 +1,5 @@
 import type { Datum } from "../charts/shared/datumTypes";
+import * as React from "react";
 import type { ReactNode } from "react";
 import type { NetworkLabel } from "./networkTypes";
 import type { LegendGroup, GradientLegendConfig, LegendLayout } from "../types/legendTypes";
@@ -69,7 +70,7 @@ export interface NetworkSVGOverlayProps {
  * Unlike XY/ordinal overlays, network charts don't have axes or grid lines.
  * The overlay is positioned absolutely over the canvas.
  */
-export declare function NetworkSVGOverlay(props: NetworkSVGOverlayProps): import("react/jsx-runtime").JSX.Element;
+export declare function NetworkSVGOverlay(props: NetworkSVGOverlayProps): React.JSX.Element;
 export declare namespace NetworkSVGOverlay {
     var displayName: string;
 }

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

@@ -1,3 +1,21 @@
+/**
+ * OrdinalBrushOverlay — d3-brush SVG overlay for ordinal frames.
+ *
+ * Renders a transparent SVG positioned above the canvas. Brushes along the
+ * r-axis (value axis) only: horizontal projection → brushX, vertical → brushY.
+ *
+ * Key design decisions:
+ *   - Outer SVG has pointerEvents:"none", inner brush-g has "all", so
+ *     axes/legends rendered underneath remain clickable.
+ *   - d3-brush lifecycle (useEffect) depends on [width, height, isHorizontal]
+ *     only — NOT scales. Scales are read from a ref to avoid brush teardown
+ *     mid-drag (scales change every render due to new object identity).
+ *   - A separate useEffect repositions the brush when scales change (streaming).
+ *
+ * Consumed by: StreamOrdinalFrame (rendered when brush prop is set).
+ * Wired by: useOrdinalBrush hook in HOC charts.
+ */
+import * as React from "react";
 import type { OrdinalScales } from "./ordinalTypes";
 interface OrdinalBrushOverlayProps {
     width: number;
@@ -21,5 +39,5 @@ interface OrdinalBrushOverlayProps {
  * In horizontal projection, r maps to x-pixels → uses brushX.
  * In vertical projection, r maps to y-pixels → uses brushY.
  */
-export declare function OrdinalBrushOverlay({ width, height, totalWidth, totalHeight, margin, scales, onBrush }: OrdinalBrushOverlayProps): import("react/jsx-runtime").JSX.Element;
+export declare function OrdinalBrushOverlay({ width, height, totalWidth, totalHeight, margin, scales, onBrush }: OrdinalBrushOverlayProps): React.JSX.Element;
 export {};

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

@@ -81,6 +81,6 @@ interface OrdinalSVGUnderlayProps {
     rTickValues?: number[];
     axisExtent?: AxisExtentMode;
 }
-export declare function OrdinalSVGUnderlay(props: OrdinalSVGUnderlayProps): import("react/jsx-runtime").JSX.Element | null;
-export declare function OrdinalSVGOverlay(props: OrdinalSVGOverlayProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function OrdinalSVGUnderlay(props: OrdinalSVGUnderlayProps): React.JSX.Element | null;
+export declare function OrdinalSVGOverlay(props: OrdinalSVGOverlayProps): React.JSX.Element | null;
 export {};

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

@@ -174,6 +174,12 @@ export declare class PipelineStore {
     lastIngestTime: number;
     /** Unified color map cache keyed by sorted category set — shared across point, swarm, etc. */
     private _colorMapCache;
+    /** groupData() result cache. The line/area/stacked-area builders all re-bucket
+     *  the same buffer by group on every scene build (twice per frame for stacked
+     *  area); cache keyed on (_ingestVersion, group accessor, data ref) so a
+     *  streaming push re-buckets once rather than per builder. Mirrors the
+     *  resolveColorMap cache. Buckets are read-only downstream, so sharing is safe. */
+    private _groupDataCache;
     /** Separate group→color map for resolveGroupColor (insertion-order based, never invalidates _colorMapCache).
      *  FIFO-bounded to `GROUP_COLOR_MAP_CAP` entries — in long-running streams with unique group IDs (e.g. UUIDs
      *  as `lineBy` keys) this would otherwise grow unboundedly. Evicted groups that re-appear get a new palette

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

@@ -1,4 +1,5 @@
 import type { Datum } from "../charts/shared/datumTypes";
+import * as React from "react";
 import type { StreamScales, MarginalGraphicsConfig, XYFrameAxisConfig } from "./types";
 import type { AnnotationContext } from "../realtime/types";
 import type { ReactNode } from "react";
@@ -111,6 +112,6 @@ interface SVGUnderlayProps {
     yFormat?: (d: number | Date | string) => string | ReactNode;
     axisExtent?: import("../charts/shared/axisExtent").AxisExtentMode;
 }
-export declare function SVGUnderlay(props: SVGUnderlayProps): import("react/jsx-runtime").JSX.Element | null;
-export declare function SVGOverlay(props: SVGOverlayProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function SVGUnderlay(props: SVGUnderlayProps): React.JSX.Element | null;
+export declare function SVGOverlay(props: SVGOverlayProps): React.JSX.Element | null;
 export {};

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

@@ -0,0 +1,19 @@
+import type { StalenessConfig } from "./types";
+interface StalenessBadgeProps {
+    isStale: boolean;
+    position?: StalenessConfig["badgePosition"];
+}
+/**
+ * Live/stale indicator chip shown in a corner of a streaming chart when
+ * `staleness.showBadge` is set.
+ *
+ * Shared by all four Stream Frames (XY / ordinal / network / geo) so the badge
+ * is pixel-identical across families. Previously each frame inlined its own
+ * copy and they had drifted — the network frame used a smaller, heavier variant
+ * (10px/700, tighter padding, letterSpacing). This is the canonical style: the
+ * more legible 11px/600 the other three shared, plus `zIndex`/`pointerEvents`
+ * hardening so the badge always sits above the canvas and never intercepts
+ * pointer events.
+ */
+export declare function StalenessBadge({ isStale, position }: StalenessBadgeProps): import("react").JSX.Element;
+export {};

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

@@ -1,3 +1,23 @@
+/**
+ * XYBrushOverlay — d3-brush SVG overlay for XY frames.
+ *
+ * Renders a transparent SVG positioned above the canvas. Supports x, y, and
+ * xy brush dimensions, bin snapping, and streaming brush tracking (shrinks/
+ * clears the brush as data scrolls past the selected range).
+ *
+ * Key design decisions:
+ *   - d3-brush lifecycle depends on [width, height, dimension, snap, binSize, snapDuring]
+ *     only — scales and binBoundaries are read from refs to avoid teardown mid-drag.
+ *   - Data-driven snapping (binBoundaries) uses binary search to snap to actual bin
+ *     edges. Falls back to uniform grid math (binSize) when no boundaries are provided.
+ *   - Bin snapping applies on "end" events by default. Set snapDuring=true to also
+ *     snap during drag (the "brush" event).
+ *   - Streaming tracking guards against y-only dimension (no x-domain to track).
+ *   - isProgrammaticMoveRef prevents re-entrant brush events from .move() calls.
+ *
+ * Consumed by: StreamXYFrame (rendered when brush prop is set).
+ */
+import * as React from "react";
 import type { StreamScales } from "./types";
 export interface XYBrushOverlayProps {
     width: number;
@@ -24,4 +44,4 @@ export interface XYBrushOverlayProps {
     snapDuring?: boolean;
     streaming?: boolean;
 }
-export declare function XYBrushOverlay({ width, height, totalWidth, totalHeight, margin, dimension, scales, onBrush, binSize, snap, binBoundaries, snapDuring, streaming }: XYBrushOverlayProps): import("react/jsx-runtime").JSX.Element;
+export declare function XYBrushOverlay({ width, height, totalWidth, totalHeight, margin, dimension, scales, onBrush, binSize, snap, binBoundaries, snapDuring, streaming }: XYBrushOverlayProps): React.JSX.Element;

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

@@ -13,10 +13,16 @@ export interface QuadtreeHit<T> {
  * much larger visual radius can still be a valid hit that `find()` would
  * hide.
  *
- * `T` must expose `x`, `y`, and `r` — the standard `PointSceneNode` shape.
+ * For the standard `{ x, y, r }` node shape (e.g. `PointSceneNode`) call it
+ * without accessors. For nodes that store their center under different field
+ * names (e.g. network circle nodes use `cx`/`cy`) pass `getX`/`getY`/`getR` —
+ * the typed overload requires them, so an incompatible shape is a compile
+ * error rather than a runtime NaN. The quadtree itself must be built with
+ * matching `.x()`/`.y()` accessors.
  */
 export declare function findHitPointInQuadtree<T extends {
     x: number;
     y: number;
     r: number;
 }>(qt: Quadtree<T>, px: number, py: number, maxDistance: number, maxPointRadius: number): QuadtreeHit<T> | null;
+export declare function findHitPointInQuadtree<T>(qt: Quadtree<T>, px: number, py: number, maxDistance: number, maxPointRadius: number, getX: (n: T) => number, getY: (n: T) => number, getR: (n: T) => number): QuadtreeHit<T> | null;