semiotic 3.5.0 → 3.5.2

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

@@ -10,6 +10,17 @@ export interface AxisConfig {
     tickFormat?: (d: any, index?: number, allTicks?: number[]) => string | ReactNode;
     baseline?: boolean | "under";
     jaggedBase?: boolean;
+    /** Explicit tick values. When provided, bypasses both d3's "nice"
+     *  generator and `axisExtent: "exact"` — the caller has hand-picked
+     *  the positions. Pixel-distance filtering downstream still drops
+     *  overlapping labels. Accepts `number | Date`: values pass through
+     *  to the scale (d3-scale's `scaleTime` reads Dates natively;
+     *  `scaleLinear` accepts numbers — feeding a Date into a linear
+     *  scale via `valueOf()` works at runtime but `tickFormat` receives
+     *  the Date as-is, so user formatters should match the axis's
+     *  underlying scale type). Mirrors the ordinal frame's
+     *  `rTickValues` contract. */
+    tickValues?: Array<number | Date>;
     /** Grid line stroke style: "dashed" (6,4), "dotted" (2,4), or a custom strokeDasharray string. Applied to grid lines extending from ticks across the chart area. */
     gridStyle?: "dashed" | "dotted" | string;
     /** Always include the domain max as a tick, even if d3 omits it. */
@@ -40,6 +51,12 @@ interface SVGOverlayProps {
     yLabelRight?: string;
     xFormat?: (d: number | Date | string, index?: number, allTicks?: number[]) => string | ReactNode;
     yFormat?: (d: number | Date | string) => string | ReactNode;
+    /** Axis extent mode. "nice" (default) uses d3-scale's rounded
+     *  tick generator — labels stay round but the first/last tick
+     *  may sit inside the data domain. "exact" pins the first and
+     *  last tick to the actual data min and max with equidistant
+     *  intermediate ticks. Applies to both x and y axes. */
+    axisExtent?: import("../charts/shared/axisExtent").AxisExtentMode;
     showGrid?: boolean;
     title?: string | ReactNode;
     legend?: ReactNode | {
@@ -116,6 +133,7 @@ interface SVGUnderlayProps {
     showGrid?: boolean;
     xFormat?: (d: number | Date | string, index?: number, allTicks?: number[]) => string | ReactNode;
     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;

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

@@ -0,0 +1,39 @@
+/**
+ * Annotation-context accessors must be string keys — SVG overlay
+ * rules look up coordinates with `data[xAccessor]`. When a chart's
+ * user accessor is a function, we bake the resolved value under a
+ * synthetic stable key on each annotation datum and forward the
+ * synthetic key as the annotation's xAccessor / yAccessor.
+ *
+ * Originally inline in `StreamXYFrame.tsx`; lifted here so
+ * `StreamOrdinalFrame` (and any future frame with the same need)
+ * can share the same plumbing rather than re-implementing it.
+ */
+import type { Datum } from "../charts/shared/datumTypes";
+export interface ResolvedAnnotationAccessor {
+    /** String key the annotation context will read on each datum. */
+    key: string | undefined;
+    /** Accessor function when the user supplied one (synthetic key
+     *  gets baked from this); `null` when the user supplied a string
+     *  or nothing. */
+    fn: ((d: Datum) => any) | null;
+}
+/**
+ * Resolve an accessor pair to the (key, fn) shape the annotation
+ * pipeline needs. Probes the primary accessor first, then the
+ * fallback (e.g. `valueAccessor` when no `yAccessor` was supplied).
+ *
+ * - String accessor → use it as the key, no enrichment needed.
+ * - Function accessor → use the synthetic resolved-key, run the fn
+ *   per-datum to bake the value.
+ * - Otherwise undefined.
+ */
+export declare function resolveAnnotationAccessor(primary: unknown, fallback: unknown, resolvedKey: string, fallbackKey: string): ResolvedAnnotationAccessor;
+/**
+ * Build an `enrichAnnotationData(rawData)` function that walks the
+ * data array and bakes synthetic-key values for any function
+ * accessors. Returns the original array reference unchanged when no
+ * enrichment is needed (no annotations, no function accessors, or
+ * synthetic keys already present).
+ */
+export declare function buildEnrichAnnotationData(xResolved: ResolvedAnnotationAccessor, yResolved: ResolvedAnnotationAccessor, hasAnnotations: boolean): (rawData: Datum[] | undefined) => Datum[] | undefined;

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

@@ -95,6 +95,8 @@ export interface GeoPipelineConfig {
     introAnimation?: boolean;
     annotations?: Datum[];
     pointIdAccessor?: string | ((d: Datum) => string);
+    /** ID accessor on line data — required for `removeLine` by id. */
+    lineIdAccessor?: string | ((d: Datum) => string);
 }
 export interface StreamGeoFrameProps<T = Datum> {
     projection: ProjectionProp;
@@ -108,6 +110,8 @@ export interface StreamGeoFrameProps<T = Datum> {
     yAccessor?: string | ((d: T) => number);
     lineDataAccessor?: string | ((d: T) => Datum[]);
     pointIdAccessor?: string | ((d: T) => string);
+    /** ID accessor on line data — required for ref `removeLine` by id. */
+    lineIdAccessor?: string | ((d: T) => string);
     lineType?: "geo" | "line";
     /** Flow rendering style: "basic" (straight/great-circle), "offset" (bidirectional offset), "arc" (curved arcs) @default "basic" */
     flowStyle?: "basic" | "offset" | "arc";
@@ -212,6 +216,14 @@ export interface StreamGeoFrameHandle {
     pushMany(data: Datum[]): void;
     /** Remove points by ID. Requires pointIdAccessor. */
     removePoint(id: string | string[]): Datum[];
+    /** Append a single line/flow record. Coordinates pre-resolved per `lineDataAccessor`. */
+    pushLine(line: Datum): void;
+    /** Append multiple line/flow records in one batch. */
+    pushManyLines(lines: Datum[]): void;
+    /** Remove lines by ID. Requires `lineIdAccessor`. */
+    removeLine(id: string | string[]): Datum[];
+    /** Read the current line/flow set. */
+    getLines(): Datum[];
     clear(): void;
     getProjection(): GeoProjection | null;
     getGeoPath(): GeoPath<any, GeoPermissibleObjects> | null;

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

@@ -156,6 +156,11 @@ export interface OrdinalPipelineConfig {
     windowSize: number;
     windowMode: WindowMode;
     extentPadding: number;
+    /** When `"exact"`, the value-axis domain is pinned to the literal data
+     *  min/max — `extentPadding` is skipped so the first and last ticks
+     *  land on the actual data bounds. Default `"nice"` keeps the existing
+     *  padded domain so symbols at the extremes don't clip the plot edge. */
+    axisExtent?: import("../charts/shared/axisExtent").AxisExtentMode;
     projection: "vertical" | "horizontal" | "radial";
     categoryAccessor?: string | ((d: Datum) => string);
     valueAccessor?: string | ((d: Datum) => number) | Array<string | ((d: Datum) => number)>;
@@ -315,6 +320,13 @@ export interface StreamOrdinalFrameProps<T = Datum> {
     rTickValues?: number[];
     /** Align first tick label to start and last tick label to end. Default false. */
     tickLabelEdgeAlign?: boolean;
+    /** Axis extent mode for the value (r) axis. `"nice"` (default) uses
+     *  d3-scale's rounded tick generator. `"exact"` pins the first and
+     *  last tick to the actual data min and max with equidistant
+     *  intermediate ticks. The categorical (o) axis is unaffected since
+     *  it's a band scale, not a continuous one. Ignored when explicit
+     *  `rTickValues` are provided — caller has hand-picked positions. */
+    axisExtent?: import("../charts/shared/axisExtent").AxisExtentMode;
     pieceStyle?: (d: Datum, category?: string) => Style;
     summaryStyle?: (d: Datum, category?: string) => Style;
     colorScheme?: string | string[];

package/dist/components/stream/renderers/cornerRadii.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Per-corner radius utilities shared between the canvas (`barCanvasRenderer`)
+ * and SVG (`SceneToSVG`) paint paths.
+ *
+ * Both paths previously carried the same `hasAnyCornerRadius` predicate
+ * and the same `min(radius, w/2, h/2)` clamp inline. Splitting them by
+ * renderer left two near-identical implementations that drifted in
+ * comments more than once; centralizing here keeps the swimlane rounding
+ * contract — and any future per-corner shape (cards, tab corners,
+ * partial-stack rounding) — in one place.
+ *
+ * The actual path-tracing primitives (canvas `arcTo` vs SVG `A`) stay in
+ * each renderer because their output formats differ — this module owns
+ * the geometry, the renderers own the drawing language.
+ */
+import type { RectSceneNode } from "../types";
+/** True when at least one corner has a positive radius. */
+export declare function hasAnyCornerRadius(c: NonNullable<RectSceneNode["cornerRadii"]>): boolean;
+export interface ClampedCornerRadii {
+    tl: number;
+    tr: number;
+    br: number;
+    bl: number;
+}
+/**
+ * Read each corner's radius and clamp to `[0, min(w, h) / 2]` so a
+ * corner never overdraws past the rect's center on thin lanes AND a
+ * negative input never leaks into the `moveTo` / `lineTo` math (where
+ * a negative radius would offset the start point into invalid space,
+ * producing visibly bent or escaping paths even though the `arcTo`
+ * is gated on `> 0`). Missing corners collapse to 0 (square).
+ */
+export declare function clampCornerRadii(node: RectSceneNode): ClampedCornerRadii;

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

@@ -227,6 +227,19 @@ export interface RectSceneNode {
      *  bar scene builders unconditionally so gradients resolve without
      *  requiring roundedTop. */
     roundedEdge?: "top" | "bottom" | "right" | "left";
+    /** Explicit per-corner radii. Overrides the `roundedTop` + `roundedEdge`
+     *  shortcut when present. Used by swimlanes (and any future chart that
+     *  needs to round arbitrary subsets of a rect's four corners) — the
+     *  outermost pieces of a lane round their leading/trailing corners and
+     *  middle pieces stay square. Keys map to physical corners: `tl`
+     *  top-left, `tr` top-right, `br` bottom-right, `bl` bottom-left.
+     *  Missing keys are treated as 0 (square). */
+    cornerRadii?: {
+        tl?: number;
+        tr?: number;
+        br?: number;
+        bl?: number;
+    };
     /** Gradient fill — same shape as the area-scene version. Runs tip → base
      *  along the bar axis (inferred from `roundedEdge`). */
     fillGradient?: {
@@ -479,6 +492,10 @@ export interface StreamXYFrameProps<T = Datum> {
         orient: "left" | "right" | "top" | "bottom";
         label?: string;
         ticks?: number;
+        /** Explicit tick values. When provided, bypasses both d3's nice-tick
+         *  generator and `axisExtent`; pixel-distance filtering still drops
+         *  overlapping labels. Mirrors the ordinal frame's `rTickValues`. */
+        tickValues?: Array<number | Date>;
         tickFormat?: AxisTickFormat;
         baseline?: boolean | "under";
         jaggedBase?: boolean;
@@ -489,6 +506,12 @@ export interface StreamXYFrameProps<T = Datum> {
     yLabelRight?: string;
     xFormat?: (d: number | Date | string, index?: number, allTicks?: number[]) => string | ReactNode;
     yFormat?: (d: number | Date | string) => string | ReactNode;
+    /** Axis extent mode. `"nice"` (default) uses d3-scale's rounded
+     *  tick generator — round tick labels at the cost of ticks not
+     *  reaching the exact data min/max. `"exact"` pins the first
+     *  and last tick to the data domain and spaces intermediate
+     *  ticks equidistantly. Applies to both x and y axes. */
+    axisExtent?: import("../charts/shared/axisExtent").AxisExtentMode;
     tickFormatTime?: (value: number) => string;
     tickFormatValue?: (value: number) => string;
     hoverAnnotation?: boolean | HoverAnnotationConfig;

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

@@ -41,7 +41,7 @@ export interface LegendProps {
     highlightedCategory?: string | null;
     /** Legend interaction mode — used to set aria-multiselectable on the listbox */
     legendInteraction?: string;
-    title?: string;
+    title?: string | boolean;
     width?: number;
     height?: number;
     orientation?: string;