semiotic 3.8.2 → 3.8.3

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

@@ -0,0 +1,12 @@
+/**
+ * Scene graph → SVG element converters for the network family.
+ *
+ * Split out of SceneToSVG.tsx (see scripts/file-size-policy.json) to keep
+ * that module under the file-size ratchet ceiling. Re-exported from
+ * SceneToSVG.tsx so existing imports are unaffected.
+ */
+import * as React from "react";
+import type { NetworkSceneNode, NetworkSceneEdge, NetworkLabel } from "./networkTypes";
+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;

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

@@ -17,6 +17,13 @@ export interface PaintCanvasBackgroundOptions {
     width: number;
     height: number;
 }
+export type CanvasBackgroundOptions = Pick<PaintCanvasBackgroundOptions, "background" | "hasBackgroundGraphics" | "themeBackground">;
+/**
+ * Select the background token a canvas will attempt to paint. This is kept
+ * separate from the drawing operation so SVG layer composition can use the
+ * exact same visibility decision as the canvas renderer.
+ */
+export declare function resolveCanvasBackground(options: CanvasBackgroundOptions): string | null;
 /**
  * Paint an opaque chart background when appropriate.
  * Returns true if a fill was applied.

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

@@ -5,7 +5,7 @@ type NetworkDatumComparator = {
     bivarianceHack(a: Datum, b: Datum): number;
 }["bivarianceHack"];
 type NetworkGroupComparator = (a: number, b: number) => number;
-import type { LegendGroup, LegendLayout } from "../types/legendTypes";
+import type { LegendLayout, LegendValue } from "../types/legendTypes";
 import type { Style, DecayConfig, PulseConfig, TransitionConfig, StalenessConfig, ThemeSemanticColors, SceneDatum, SceneAccessibilityMetadata, SceneRenderMode } from "./types";
 import type { AnimateProp } from "./pipelineTransitionUtils";
 import type { NetworkSymbolName } from "./symbolPath";
@@ -616,9 +616,7 @@ export interface StreamNetworkFrameProps<T = Datum> extends StreamNetworkInterac
     };
     className?: string;
     background?: string;
-    legend?: ReactNode | {
-        legendGroups: LegendGroup[];
-    };
+    legend?: LegendValue;
     legendPosition?: "right" | "left" | "top" | "bottom";
     legendLayout?: LegendLayout;
     legendHoverBehavior?: (item: {

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

@@ -23,5 +23,19 @@ export declare function renderSceneWithBackend<Node extends SceneLike>(args: {
     renderMode: SceneRenderMode<Node> | undefined;
     fallback: () => React.ReactNode;
 }): React.ReactNode;
+export interface RenderedSceneEntry<Node> {
+    node: Node;
+    element: React.ReactNode;
+}
+/**
+ * Render a scene once and retain only nodes that produced static output.
+ * Static evidence and SVG markup consume the same entries, preventing an
+ * unpaintable node from being reported as a successful rendered mark.
+ */
+export declare function renderSceneListWithBackend<Node extends SceneLike>(args: {
+    nodes: Node[];
+    renderMode: SceneRenderMode<Node> | undefined;
+    fallback: (node: Node, index: number) => React.ReactNode;
+}): RenderedSceneEntry<Node>[];
 export declare function resetRenderBackendWarningsForTests(): void;
 export {};

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

@@ -0,0 +1,51 @@
+/**
+ * Low-level SVG serialization helpers shared across SceneToSVG.tsx,
+ * SceneToSVGNetwork.tsx, and SceneToSVGGeo.tsx. Split out so the three
+ * scene-family serializers can import a common base without a circular
+ * dependency between them.
+ */
+import * as React from "react";
+import type { DefaultArcObject } from "d3-shape";
+import { type HatchFill } from "../charts/shared/hatchFill";
+import type { GlyphDef } from "./glyphDef";
+import type { Style } from "./types";
+/**
+ * Sentinel arg for d3-shape arc generators that have all four
+ * accessors set to constants. The generator's call signature requires
+ * a `DefaultArcObject` even though it never reads the argument when
+ * accessors are non-functional. Typing this once avoids local unsafe casts at
+ * the arc-emit sites in the network/ordinal serializers.
+ */
+export declare const ARC_NOOP: DefaultArcObject;
+export declare function svgFill(fill: string | HatchFill | CanvasPattern | undefined, fallback?: string): string;
+/**
+ * Coerce a candidate SVG `id` value to the strict `[A-Za-z0-9_-]` charset.
+ * Scene-node keys embed user-provided category/group strings, which can
+ * contain spaces, colons, parentheses, or other characters that are either
+ * invalid in an SVG id or break a `url(#id)` reference. Non-matching
+ * characters are replaced with underscores; an empty/leading-digit result
+ * is prefixed so the final id is a legal SVG identifier.
+ */
+export declare function safeSvgId(candidate: string): string;
+/**
+ * Shared SVG serializer for glyph nodes across all four pipelines — the
+ * composite-pictogram sibling of `symbolSceneNodeToSVG`. Callers pass the
+ * node's position explicitly (`x`/`y` for XY/ordinal/geo, `cx`/`cy` for
+ * network) so one implementation matches `glyphCanvasRenderer` exactly:
+ * anchor + scale transform, role-token paints, optional ghost silhouette,
+ * and a deterministic `clipPath` for partial fills.
+ */
+export declare function glyphNodeToSVG(g: {
+    size: number;
+    glyph: GlyphDef;
+    color?: string;
+    accent?: string;
+    fraction?: number;
+    fractionStart?: number;
+    fractionDirection?: "horizontal" | "vertical";
+    ghostColor?: string;
+    rotation?: number;
+    style: Style;
+    pointId?: string;
+    _decayOpacity?: number;
+}, x: number, y: number, key: string): React.ReactNode;

package/dist/components/types/legendTypes.d.ts

@@ -1,4 +1,4 @@
-import type { CSSProperties, ReactElement } from "react";
+import type { CSSProperties, ReactElement, ReactNode } from "react";
 export type SupportedLegendGlyphs = "fill" | "line";
 export type ItemType = SupportedLegendGlyphs | ((item: LegendItem) => ReactElement);
 export interface LegendItem {
@@ -23,10 +23,23 @@ export interface GradientLegendConfig {
     /** Optional format function for tick labels */
     format?: (v: number) => string;
 }
-/** Type guard: categorical legend config */
-export declare function isLegendConfig(value: unknown): value is {
+export interface CategoricalLegendConfig {
     legendGroups: LegendGroup[];
+}
+/** Public legend slot accepted by stream frames and legend-aware chart HOCs. */
+export type LegendValue = ReactNode | CategoricalLegendConfig | {
+    gradient: GradientLegendConfig;
 };
+/**
+ * Compose inferred and caller-supplied legends without discarding either
+ * categorical domain. Configured groups are appended in argument order, so
+ * the chart's inferred series remain first and caller context follows.
+ * Gradient/custom-node legends remain exclusive slots; the last explicit
+ * value wins because those forms cannot be laid out as categorical groups.
+ */
+export declare function composeLegendConfigs(...values: Array<LegendValue | null | undefined | false>): LegendValue | undefined;
+/** Type guard: categorical legend config */
+export declare function isLegendConfig(value: unknown): value is CategoricalLegendConfig;
 /** Type guard: gradient legend config */
 export declare function isGradientLegendConfig(value: unknown): value is {
     gradient: GradientLegendConfig;