semiotic 3.7.1 → 3.7.3

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

@@ -1,6 +1,7 @@
 import { ParticlePool } from "./ParticlePool";
 import type { ActiveTransition } from "./pipelineTransitionUtils";
-import type { NetworkPipelineConfig, NetworkSceneNode, NetworkSceneEdge, NetworkLabel, RealtimeNode, RealtimeEdge, EdgePush } from "./networkTypes";
+import { type Quadtree } from "d3-quadtree";
+import type { NetworkPipelineConfig, NetworkSceneNode, NetworkSceneEdge, NetworkCircleNode, NetworkLabel, RealtimeNode, RealtimeEdge, EdgePush } from "./networkTypes";
 import type { Datum } from "../charts/shared/datumTypes";
 /**
  * NetworkPipelineStore — stateful store for the StreamNetworkFrame.
@@ -15,12 +16,28 @@ export declare class NetworkPipelineStore {
     nodes: Map<string, RealtimeNode>;
     edges: Map<string, RealtimeEdge>;
     tension: number;
+    /**
+     * Monotonic scene/layout-rebuild counter — Network's equivalent of the
+     * `version` field on the XY/Ordinal/Geo stores. Shared cross-store
+     * convention: bumps on every layout rebuild and on clear(); never resets to
+     * a prior value, so a consumer comparing against a last-seen value can
+     * always detect "something changed."
+     */
     layoutVersion: number;
     sceneNodes: NetworkSceneNode[];
     sceneEdges: NetworkSceneEdge[];
     labels: NetworkLabel[];
     /** Overlays returned from customNetworkLayout (consumed by StreamNetworkFrame). */
     customLayoutOverlays: import("react").ReactNode;
+    private _nodeQuadtree;
+    private _maxNodeRadius;
+    /** Bumped whenever sceneNodes is rebuilt; keys the quadtree cache. */
+    private _sceneNodesRevision;
+    private _nodeQuadtreeRevision;
+    private static readonly QUADTREE_THRESHOLD;
+    private _nodesArrCache;
+    private _edgesArrCache;
+    private _arrCacheVersion;
     particlePool: ParticlePool | null;
     private config;
     private tensionConfig;
@@ -35,6 +52,8 @@ export declare class NetworkPipelineStore {
     private edgeTimestamps;
     /** Cached sorted node-timestamp entries for applyDecay(); null = needs rebuild */
     private _decaySortedNodes;
+    /** id→age-index map derived from _decaySortedNodes; rebuilt with it, not per frame. */
+    private _decayAgeMap;
     /** Node IDs added in the most recent layout */
     addedNodes: Set<string>;
     /** Node IDs removed in the most recent layout */
@@ -90,6 +109,32 @@ export declare class NetworkPipelineStore {
      * Build the scene graph from current layout positions.
      */
     buildScene(size: [number, number]): void;
+    /**
+     * Lazily (re)build the circle-node spatial index. Only built when the scene
+     * holds more than QUADTREE_THRESHOLD circle nodes (force/orbit graphs); for
+     * rect (sankey/treemap) and arc (chord) scenes — which carry far fewer marks
+     * and need area/angular hit logic — it stays null and the hit tester scans
+     * linearly. Always tracks `_maxNodeRadius` so the hit query can widen its
+     * search to cover the largest node.
+     */
+    private rebuildNodeQuadtree;
+    /**
+     * Circle-node spatial index for hit testing, or null when the scene is small
+     * or not circle-based. Rebuilt on demand only after the scene changed, so a
+     * settled graph indexes once and animation frames without a hover pay nothing.
+     */
+    get nodeQuadtree(): Quadtree<NetworkCircleNode> | null;
+    /** Largest circle-node radius in the current scene (widens the hit query). */
+    get maxNodeRadius(): number;
+    /**
+     * Per-frame-stable node/edge arrays (see field docs). Rebuilt only when
+     * layoutVersion changes — i.e. on a Map mutation, never on an animation tick.
+     */
+    private _ensureArrays;
+    /** Cached node array — safe only for read / position-mutate consumers. */
+    get nodesArray(): RealtimeNode[];
+    /** Cached edge array — safe only for read / position-mutate consumers. */
+    get edgesArray(): RealtimeEdge[];
     /** Whether the current layout plugin drives continuous animation (respects orbitAnimated config) */
     get isAnimating(): boolean;
     /**

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/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/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;