@ledgerhq/lumen-ui-react 0.1.56 → 0.1.58

package/dist/lib/Components/visualization/ReferenceLine/ReferenceLine.js

@@ -0,0 +1,42 @@
+import { jsxs as f, jsx as i } from "react/jsx-runtime";
+import { chartConfig as h } from "../config.js";
+import { useReferenceLineGeometry as m } from "./useReferenceLineGeometry.js";
+const { color: o, font: t, referenceLine: y, strokeWidth: x } = h, u = {
+  fill: o.textMuted,
+  fontSize: t.labelSize,
+  fontWeight: t.labelWeightMedium,
+  fontFamily: t.family
+};
+function A(n) {
+  const r = m(n), { label: l, stroke: a = o.stroke, lineStyle: s = "dashed" } = n, d = s === "dashed" ? y.dashArray : void 0;
+  if (!r) return null;
+  const { linePoints: c, labelCoords: e } = r;
+  return /* @__PURE__ */ f("g", { "data-testid": "reference-line", children: [
+    /* @__PURE__ */ i(
+      "line",
+      {
+        "data-testid": "reference-line-line",
+        ...c,
+        stroke: a,
+        strokeWidth: x.line,
+        strokeDasharray: d,
+        strokeLinecap: "round"
+      }
+    ),
+    e && /* @__PURE__ */ i(
+      "text",
+      {
+        "data-testid": "reference-line-label",
+        x: e.x,
+        y: e.y,
+        textAnchor: e.textAnchor,
+        dominantBaseline: e.dominantBaseline,
+        style: u,
+        children: l
+      }
+    )
+  ] });
+}
+export {
+  A as ReferenceLine
+};

package/dist/lib/Components/visualization/ReferenceLine/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ReferenceLine';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/Components/visualization/ReferenceLine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/ReferenceLine/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC"}

package/dist/lib/Components/visualization/ReferenceLine/types.d.ts

@@ -0,0 +1,74 @@
+export type LabelAlignment = 'start' | 'center' | 'end';
+export type LabelPosition = 'start' | 'center' | 'end';
+export type ReferenceLineBaseProps = {
+    /**
+     * Label text displayed near the reference line.
+     */
+    label?: string;
+    /**
+     * Horizontal pixel offset applied to the label position.
+     * @default 0
+     */
+    labelDx?: number;
+    /**
+     * Vertical pixel offset applied to the label position.
+     * @default 0
+     */
+    labelDy?: number;
+    /**
+     * Position of the label along the line.
+     * @default 'end'
+     */
+    labelPosition?: LabelPosition;
+    /**
+     * Controls the direction the label text extends from its position.
+     * - `'start'`: text extends toward the start of the axis (left)
+     * - `'center'`: text is centered on the position
+     * - `'end'`: text extends toward the end of the axis (right)
+     *
+     * Defaults: `'center'` for vertical lines, inferred from `labelPosition` for horizontal lines.
+     */
+    labelHorizontalAlignment?: LabelAlignment;
+    /**
+     * Controls the direction the label text extends from its position.
+     * - `'start'`: text extends toward the start of the axis (up)
+     * - `'center'`: text is vertically centered on the position
+     * - `'end'`: text extends toward the end of the axis (down)
+     *
+     * Defaults: `'end'` for horizontal lines, inferred from `labelPosition` for vertical lines.
+     */
+    labelVerticalAlignment?: LabelAlignment;
+    /**
+     * Line color.
+     * @default cssVar('var(--border-muted)')
+     */
+    stroke?: string;
+    /**
+     * Line dash style.
+     * - `'dashed'`: rounded dots with `strokeDasharray="0.1 6"`
+     * - `'solid'`: continuous line
+     * @default 'dashed'
+     */
+    lineStyle?: 'solid' | 'dashed';
+};
+export type HorizontalReferenceLineProps = ReferenceLineBaseProps & {
+    /**
+     * Y-axis value in data space where the horizontal line is drawn.
+     * The horizontal line is rendered at this Y position spanning the full
+     * width of the drawing area.
+     */
+    dataY: number;
+    dataX?: never;
+};
+export type VerticalReferenceLineProps = ReferenceLineBaseProps & {
+    /**
+     * Data index along the X axis. When `xAxis.data` contains numeric values,
+     * the index is mapped to the corresponding axis value automatically.
+     * The vertical line is drawn at this position spanning the full height
+     * of the drawing area.
+     */
+    dataX: number;
+    dataY?: never;
+};
+export type ReferenceLineProps = HorizontalReferenceLineProps | VerticalReferenceLineProps;
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/Components/visualization/ReferenceLine/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/ReferenceLine/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;AACxD,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;AAEvD,MAAM,MAAM,sBAAsB,GAAG;IACnC;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;;;;;;OAOG;IACH,wBAAwB,CAAC,EAAE,cAAc,CAAC;IAC1C;;;;;;;OAOG;IACH,sBAAsB,CAAC,EAAE,cAAc,CAAC;IACxC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,sBAAsB,GAAG;IAClE;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,KAAK,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,sBAAsB,GAAG;IAChE;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,KAAK,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAC1B,4BAA4B,GAC5B,0BAA0B,CAAC"}

package/dist/lib/Components/visualization/ReferenceLine/useReferenceLineGeometry.d.ts

@@ -0,0 +1,21 @@
+import { ReferenceLineProps } from './types';
+import { LabelCoordinates } from './utils';
+type ReferenceLineGeometry = {
+    linePoints: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    };
+    labelCoords: LabelCoordinates | null;
+};
+/**
+ * Resolves a reference line's chart geometry: reads the chart context, projects
+ * the targeted `dataX` (vertical) or `dataY` (horizontal) value to a validated
+ * pixel, and derives the line endpoints and optional label coordinates.
+ * Returns `null` when the value cannot be projected into the drawing area
+ * (see {@link resolvePixel}) or when neither axis is set.
+ */
+export declare const useReferenceLineGeometry: (props: Readonly<ReferenceLineProps>) => ReferenceLineGeometry | null;
+export {};
+//# sourceMappingURL=useReferenceLineGeometry.d.ts.map

package/dist/lib/Components/visualization/ReferenceLine/useReferenceLineGeometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReferenceLineGeometry.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/ReferenceLine/useReferenceLineGeometry.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,EAIL,KAAK,gBAAgB,EACtB,MAAM,SAAS,CAAC;AAEjB,KAAK,qBAAqB,GAAG;IAC3B,UAAU,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/D,WAAW,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACtC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACnC,OAAO,QAAQ,CAAC,kBAAkB,CAAC,KAClC,qBAAqB,GAAG,IAwD1B,CAAC"}

package/dist/lib/Components/visualization/ReferenceLine/useReferenceLineGeometry.js

@@ -0,0 +1,49 @@
+import { resolvePixel as n, computeHorizontalLabelCoordinates as s, computeVerticalLabelCoordinates as c } from "./utils.js";
+import { useCartesianChartContext as g } from "../CartesianChart/context/cartesianChartContext.js";
+const m = (e) => {
+  const { getXScale: o, getYScale: x, getXAxisConfig: r, getYAxisConfig: d, drawingArea: l } = g(), t = {
+    labelPosition: e.labelPosition ?? "end",
+    drawingArea: l,
+    dx: e.labelDx ?? 0,
+    dy: e.labelDy ?? 0,
+    horizontalAlignment: e.labelHorizontalAlignment,
+    verticalAlignment: e.labelVerticalAlignment
+  };
+  if (e.dataY !== void 0) {
+    const a = n({
+      dataValue: e.dataY,
+      scale: x(),
+      axis: "y",
+      drawingArea: l,
+      axisConfig: d()
+    });
+    return a === void 0 ? null : {
+      linePoints: {
+        x1: l.x,
+        y1: a,
+        x2: l.x + l.width,
+        y2: a
+      },
+      labelCoords: e.label ? s({ pixel: a, ...t }) : null
+    };
+  }
+  const i = n({
+    dataValue: e.dataX,
+    scale: o(),
+    axis: "x",
+    drawingArea: l,
+    axisConfig: r()
+  });
+  return i === void 0 ? null : {
+    linePoints: {
+      x1: i,
+      y1: l.y,
+      x2: i,
+      y2: l.y + l.height
+    },
+    labelCoords: e.label ? c({ pixel: i, ...t }) : null
+  };
+};
+export {
+  m as useReferenceLineGeometry
+};

package/dist/lib/Components/visualization/ReferenceLine/utils.d.ts

@@ -0,0 +1,50 @@
+import { BaseAxisProps } from '../Axis';
+import { ChartScaleFunction, DrawingArea } from '../utils/types';
+import { LabelAlignment, LabelPosition } from './types';
+export type LabelCoordinates = {
+    x: number;
+    y: number;
+    textAnchor: 'start' | 'middle' | 'end';
+    dominantBaseline: 'hanging' | 'central' | 'auto';
+};
+type ResolvePixelParams = {
+    dataValue: number;
+    scale: ChartScaleFunction | undefined;
+    axis: 'x' | 'y';
+    drawingArea: DrawingArea;
+    axisConfig?: BaseAxisProps;
+};
+type LabelParams = {
+    pixel: number;
+    labelPosition: LabelPosition;
+    drawingArea: DrawingArea;
+    dx?: number;
+    dy?: number;
+    horizontalAlignment?: LabelAlignment;
+    verticalAlignment?: LabelAlignment;
+};
+/**
+ * Checks whether a pixel coordinate falls within the drawing area
+ * along a single axis.
+ */
+export declare const isPixelWithinDrawingArea: (pixel: number, axis: "x" | "y", drawingArea: DrawingArea) => boolean;
+/**
+ * Resolves a data-space value to a validated pixel coordinate.
+ * When `axisConfig` is provided, the data value is first translated
+ * through the axis data array before being projected onto the scale.
+ * Returns `undefined` if the value is out of bounds, the scale is missing,
+ * the result is not finite, or the pixel falls outside the drawing area.
+ */
+export declare const resolvePixel: ({ dataValue, scale, axis, drawingArea, axisConfig, }: ResolvePixelParams) => number | undefined;
+/**
+ * Computes the label pixel coordinates and text alignment attributes
+ * for a horizontal reference line.
+ */
+export declare const computeHorizontalLabelCoordinates: ({ pixel, labelPosition, drawingArea, dx, dy, horizontalAlignment, verticalAlignment, }: LabelParams) => LabelCoordinates;
+/**
+ * Computes the label pixel coordinates and text alignment attributes
+ * for a vertical reference line.
+ */
+export declare const computeVerticalLabelCoordinates: ({ pixel, labelPosition, drawingArea, dx, dy, horizontalAlignment, verticalAlignment, }: LabelParams) => LabelCoordinates;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/Components/visualization/ReferenceLine/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/ReferenceLine/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG7C,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEtE,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAK7D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IACvC,gBAAgB,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;CAClD,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACtC,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,CAAC,EAAE,aAAa,CAAC;CAC5B,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,EAAE,WAAW,CAAC;IACzB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,mBAAmB,CAAC,EAAE,cAAc,CAAC;IACrC,iBAAiB,CAAC,EAAE,cAAc,CAAC;CACpC,CAAC;AAuBF;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GACnC,OAAO,MAAM,EACb,MAAM,GAAG,GAAG,GAAG,EACf,aAAa,WAAW,KACvB,OAKF,CAAC;AAqBF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,GAAI,sDAM1B,kBAAkB,KAAG,MAAM,GAAG,SAehC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iCAAiC,GAAI,wFAQ/C,WAAW,KAAG,gBAKf,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,+BAA+B,GAAI,wFAQ7C,WAAW,KAAG,gBAKf,CAAC"}

package/dist/lib/Components/visualization/ReferenceLine/utils.js

@@ -0,0 +1,66 @@
+import { isFiniteNumber as d } from "../utils/numbers.js";
+import { isCategoricalScale as h, getPointOnScale as m } from "../utils/scales/scales.js";
+const l = "center", f = "end", c = {
+  start: "end",
+  center: "middle",
+  end: "start"
+}, a = {
+  start: "auto",
+  center: "central",
+  end: "hanging"
+}, u = {
+  start: 0,
+  center: 0.5,
+  end: 1
+}, v = (n, e, t) => e === "x" ? n >= t.x && n <= t.x + t.width : n >= t.y && n <= t.y + t.height, p = (n, e) => {
+  const t = e?.data;
+  if (!t || t.length === 0) return n;
+  if (n < 0 || n >= t.length) return;
+  const o = t[n];
+  return typeof o == "number" ? o : n;
+}, L = ({
+  dataValue: n,
+  scale: e,
+  axis: t,
+  drawingArea: o,
+  axisConfig: s
+}) => {
+  const r = p(n, s);
+  if (r === void 0 || !e || h(e) && e(r) === void 0)
+    return;
+  const i = m(r, e);
+  if (!(!d(i) || !v(i, t, o)))
+    return i;
+}, D = ({
+  pixel: n,
+  labelPosition: e,
+  drawingArea: t,
+  dx: o = 0,
+  dy: s = 0,
+  horizontalAlignment: r,
+  verticalAlignment: i
+}) => ({
+  x: t.x + t.width * u[e] + o,
+  y: n + s,
+  textAnchor: c[r ?? e],
+  dominantBaseline: a[i ?? f]
+}), V = ({
+  pixel: n,
+  labelPosition: e,
+  drawingArea: t,
+  dx: o = 0,
+  dy: s = 0,
+  horizontalAlignment: r,
+  verticalAlignment: i
+}) => ({
+  x: n + o,
+  y: t.y + t.height * u[e] + s,
+  textAnchor: c[r ?? l],
+  dominantBaseline: a[i ?? e]
+});
+export {
+  D as computeHorizontalLabelCoordinates,
+  V as computeVerticalLabelCoordinates,
+  v as isPixelWithinDrawingArea,
+  L as resolvePixel
+};

package/dist/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/ChartTooltipItem.d.ts

@@ -0,0 +1,9 @@
+import { ChartTooltipItemProps } from '../types';
+/**
+ * Memoized so it only re-renders when one of its primitive props actually
+ * changes. Combined with the stable per-index ref callbacks built in
+ * `DefaultScrubberTooltip`, this keeps the row out of the per-scrub-frame
+ * reconciliation path when its label / value / position have not changed.
+ */
+export declare const ChartTooltipItem: import('react').NamedExoticComponent<Readonly<ChartTooltipItemProps>>;
+//# sourceMappingURL=ChartTooltipItem.d.ts.map

package/dist/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/ChartTooltipItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartTooltipItem.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/ChartTooltipItem.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAiBtD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,uEAgC3B,CAAC"}

package/dist/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/ChartTooltipItem.js

@@ -0,0 +1,50 @@
+import { jsxs as c, jsx as i } from "react/jsx-runtime";
+import { memo as s } from "react";
+import { chartConfig as h } from "../../config.js";
+const { color: l, font: t, tooltip: n } = h, p = {
+  fontSize: t.bodySize,
+  fontFamily: t.family,
+  fill: l.textMuted
+}, x = {
+  fontSize: t.bodySize,
+  fontFamily: t.family,
+  fill: l.text,
+  fontWeight: t.bodyWeightSemiBold
+}, z = s(function({
+  label: d,
+  value: m,
+  x: o = 0,
+  y: e = 0,
+  width: r,
+  labelRef: f,
+  valueRef: a
+}) {
+  return /* @__PURE__ */ c("g", { children: [
+    /* @__PURE__ */ i(
+      "text",
+      {
+        ref: f,
+        x: o + n.paddingX,
+        y: e,
+        dominantBaseline: "middle",
+        style: p,
+        children: d
+      }
+    ),
+    /* @__PURE__ */ i(
+      "text",
+      {
+        ref: a,
+        x: o + r - n.paddingX,
+        y: e,
+        dominantBaseline: "middle",
+        textAnchor: "end",
+        style: x,
+        children: m
+      }
+    )
+  ] });
+});
+export {
+  z as ChartTooltipItem
+};

package/dist/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/DefaultScrubberTooltip.d.ts

@@ -0,0 +1,12 @@
+import { ScrubberTooltipProps } from '../types';
+/**
+ * Default structured tooltip anchored to the scrubber line.
+ *
+ * The tooltip auto-fits its width to the rendered content via `getBBox`,
+ * with `minWidth` acting as an optional minimum width override. Use with
+ * {@link ScrubberProps.tooltip}; layout options (`offset`, `minWidth`) belong
+ * on the object returned from the `tooltip` callback. Return `{ items: [] }`
+ * from the callback to hide the tooltip at a given index.
+ */
+export declare function DefaultScrubberTooltip({ pixelX, drawingArea, title, items, offset, minWidth, }: Readonly<ScrubberTooltipProps>): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=DefaultScrubberTooltip.d.ts.map

package/dist/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/DefaultScrubberTooltip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultScrubberTooltip.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/DefaultScrubberTooltip.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAoBrD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,MAAM,EACN,WAAW,EACX,KAAK,EACL,KAAK,EACL,MAA8B,EAC9B,QAAkC,GACnC,EAAE,QAAQ,CAAC,oBAAoB,CAAC,kDAuEhC"}

package/dist/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/DefaultScrubberTooltip.js

@@ -0,0 +1,82 @@
+import { jsxs as S, jsx as a } from "react/jsx-runtime";
+import { chartConfig as H } from "../../config.js";
+import { ChartTooltipItem as W } from "./ChartTooltipItem.js";
+import { useTooltipMeasurement as w, useBuildRefSetters as h, computeTooltipWidth as B, computeTooltipHeight as M, computeTooltipX as Y, computeItemsBaseY as E } from "./utils.js";
+const { color: I, font: f, tooltip: t } = H, X = {
+  fontSize: f.bodySize,
+  fontFamily: f.family,
+  fill: I.textMuted,
+  fontWeight: f.bodyWeightMedium
+};
+function k({
+  pixelX: u,
+  drawingArea: l,
+  title: n,
+  items: e,
+  offset: c = t.defaultOffset,
+  minWidth: m = t.defaultMinWidth
+}) {
+  const o = n !== void 0, { widths: p, titleRef: g, labelRefs: y, valueRefs: b } = w(
+    e,
+    o,
+    n
+  ), T = h(y, e.length), x = h(b, e.length);
+  if (e.length === 0)
+    return null;
+  const r = B(p, o, m), s = Y(u, c, r, l), R = M(e.length, o), v = E(l.y, o);
+  return /* @__PURE__ */ S(
+    "g",
+    {
+      "data-testid": "chart-tooltip",
+      role: "tooltip",
+      style: {
+        opacity: p === null ? 0 : 1,
+        transition: t.transition,
+        pointerEvents: "none"
+      },
+      children: [
+        /* @__PURE__ */ a(
+          "rect",
+          {
+            x: s,
+            y: l.y,
+            width: r,
+            height: R,
+            fill: t.background,
+            style: {
+              rx: t.borderRadius
+            }
+          }
+        ),
+        o && /* @__PURE__ */ a(
+          "text",
+          {
+            ref: g,
+            "data-testid": "chart-tooltip-title",
+            x: s + t.paddingX,
+            y: l.y + t.paddingY + t.rowHeight / 2,
+            dominantBaseline: "middle",
+            style: X,
+            children: n
+          }
+        ),
+        e.map((d, i) => /* @__PURE__ */ a(
+          W,
+          {
+            label: d.label,
+            value: d.value,
+            x: s,
+            y: v + i * (t.rowHeight + t.rowGap) + t.rowHeight / 2,
+            width: r,
+            labelRef: T[i],
+            valueRef: x[i]
+          },
+          i
+        ))
+      ]
+    }
+  );
+}
+export {
+  k as DefaultScrubberTooltip
+};

package/dist/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/utils.d.ts

@@ -0,0 +1,58 @@
+import { RefObject } from 'react';
+import { DrawingArea } from '../../utils/types';
+import { ChartTooltipItemData, SvgTextContent } from '../types';
+type Widths = {
+    title: number;
+    labels: number[];
+    values: number[];
+};
+type UseTooltipMeasurementReturn = {
+    widths: Widths | null;
+    titleRef: RefObject<SVGTextElement | null>;
+    labelRefs: RefObject<(SVGTextElement | null)[]>;
+    valueRefs: RefObject<(SVGTextElement | null)[]>;
+};
+export declare const safeGetBBoxWidth: (el: SVGGraphicsElement | null) => number;
+/**
+ * Derive the auto-fit tooltip width from measured text widths,
+ * clamped to a minimum floor.
+ */
+export declare const computeTooltipWidth: (widths: Widths | null, hasTitle: boolean, minWidth: number) => number;
+/**
+ * Compute the tooltip's horizontal position, flipping to the left
+ * of the scrubber line when it would overflow the drawing area.
+ */
+export declare const computeTooltipX: (pixelX: number, offset: number, tooltipWidth: number, drawingArea: DrawingArea) => number;
+/**
+ * Compute the total tooltip height from item count and title presence.
+ */
+export declare const computeTooltipHeight: (itemCount: number, hasTitle: boolean) => number;
+/**
+ * Vertical offset where tooltip rows begin, accounting for title presence.
+ */
+export declare const computeItemsBaseY: (drawingAreaY: number, hasTitle: boolean) => number;
+/**
+ * Manages SVG text measurement for the tooltip via `getBBox`.
+ *
+ * A single `ResizeObserver` is created on mount and reused for the component's
+ * entire lifetime, avoiding the cost of tearing down and recreating an observer
+ * on every scrubber movement.
+ *
+ * The re-measure / re-observe effect's dependency is a shape signature (labels
+ * + title + count) rather than the raw `items` reference, so high-frequency
+ * value updates during a scrub do not trigger a fresh measurement or
+ * disconnect / re-observe cycle. The `ResizeObserver` still picks up real
+ * geometry changes (e.g. value strings widening past the current rect).
+ */
+export declare function useTooltipMeasurement(items: ChartTooltipItemData[], hasTitle: boolean, title: SvgTextContent | undefined): UseTooltipMeasurementReturn;
+type SvgTextRefSetter = (el: SVGTextElement | null) => void;
+/**
+ * Builds stable per-index ref-callback arrays that mutate the given refs in
+ * place. Recomputed only when `length` changes, so the same callback identity
+ * is passed to each `ChartTooltipItem` across scrub frames. This unlocks
+ * `React.memo` on `ChartTooltipItem` and avoids the per-frame detach /
+ * re-attach dance of inline arrow ref callbacks.
+ */
+export declare const useBuildRefSetters: (refs: RefObject<(SVGTextElement | null)[]>, length: number) => SvgTextRefSetter[];
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAIrE,KAAK,MAAM,GAAG;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,KAAK,2BAA2B,GAAG;IACjC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IAC3C,SAAS,EAAE,SAAS,CAAC,CAAC,cAAc,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC;IAChD,SAAS,EAAE,SAAS,CAAC,CAAC,cAAc,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC;CACjD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,IAAI,kBAAkB,GAAG,IAAI,KAAG,MAOhE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,MAAM,GAAG,IAAI,EACrB,UAAU,OAAO,EACjB,UAAU,MAAM,KACf,MAUF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,GAC1B,QAAQ,MAAM,EACd,QAAQ,MAAM,EACd,cAAc,MAAM,EACpB,aAAa,WAAW,KACvB,MAOF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,WAAW,MAAM,EACjB,UAAU,OAAO,KAChB,MAQF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,cAAc,MAAM,EACpB,UAAU,OAAO,KAChB,MAGF,CAAC;AA4BF;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,oBAAoB,EAAE,EAC7B,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,cAAc,GAAG,SAAS,GAChC,2BAA2B,CAuD7B;AAED,KAAK,gBAAgB,GAAG,CAAC,EAAE,EAAE,cAAc,GAAG,IAAI,KAAK,IAAI,CAAC;AAE5D;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAC7B,MAAM,SAAS,CAAC,CAAC,cAAc,GAAG,IAAI,CAAC,EAAE,CAAC,EAC1C,QAAQ,MAAM,KACb,gBAAgB,EAUlB,CAAC"}

package/dist/lib/Components/visualization/Scrubber/DefaultScrubberTooltip/utils.js

@@ -0,0 +1,80 @@
+import { useRef as a, useState as B, useEffect as R, useLayoutEffect as x, useMemo as W } from "react";
+import { chartConfig as H } from "../../config.js";
+const { tooltip: u } = H, d = (t) => {
+  if (!t || typeof t.getBBox != "function") return 0;
+  try {
+    return t.getBBox().width;
+  } catch {
+    return 0;
+  }
+}, w = (t, r, n) => {
+  const e = t && r ? t.title : 0, o = t ? t.labels.map(
+    (f, h) => f + u.labelValueGap + (t.values[h] ?? 0)
+  ) : [], s = Math.max(e, ...o) + u.paddingX * 2;
+  return Math.max(s, n);
+}, E = (t, r, n, e) => {
+  const o = t + r + n > e.x + e.width;
+  return Math.max(
+    e.x,
+    o ? t - r - n : t + r
+  );
+}, T = (t, r) => {
+  const n = r ? u.rowHeight + u.titleGap : 0;
+  return u.paddingY * 2 + n + t * u.rowHeight + (t - 1) * u.rowGap;
+}, L = (t, r) => {
+  const n = r ? u.rowHeight + u.titleGap : 0;
+  return t + u.paddingY + n;
+}, S = (t, r, n) => {
+  let e = "";
+  for (let c = 0; c < t.length; c++) {
+    c > 0 && (e += "");
+    const s = t[c].label;
+    e += typeof s == "string" || typeof s == "number" ? String(s) : "";
+  }
+  const o = typeof n == "string" || typeof n == "number" ? String(n) : "";
+  return `${r ? "1" : "0"}|${e}|${o}`;
+};
+function Y(t, r, n) {
+  const e = a(null), o = a([]), c = a([]), s = a(null), f = a(() => {
+  }), [h, b] = B(null);
+  f.current = () => {
+    const p = r ? d(e.current) : 0, i = t.map(
+      (v, g) => d(o.current[g])
+    ), l = t.map(
+      (v, g) => d(c.current[g])
+    );
+    b({
+      title: p,
+      labels: i,
+      values: l
+    });
+  }, R(() => {
+    if (!(typeof ResizeObserver > "u"))
+      return s.current = new ResizeObserver(() => f.current()), () => s.current?.disconnect();
+  }, []);
+  const y = S(t, r, n), m = a(t.length);
+  return m.current = t.length, x(() => {
+    const p = m.current;
+    if (p === 0) return;
+    o.current.length = p, c.current.length = p, f.current();
+    const i = s.current;
+    i && (i.disconnect(), e.current && i.observe(e.current), o.current.forEach((l) => l && i.observe(l)), c.current.forEach((l) => l && i.observe(l)));
+  }, [y]), { widths: h, titleRef: e, labelRefs: o, valueRefs: c };
+}
+const $ = (t, r) => W(() => {
+  const n = new Array(r);
+  for (let e = 0; e < r; e++)
+    n[e] = (o) => {
+      t.current[e] = o;
+    };
+  return n;
+}, [t, r]);
+export {
+  L as computeItemsBaseY,
+  T as computeTooltipHeight,
+  w as computeTooltipWidth,
+  E as computeTooltipX,
+  d as safeGetBBoxWidth,
+  $ as useBuildRefSetters,
+  Y as useTooltipMeasurement
+};

package/dist/lib/Components/visualization/Scrubber/Scrubber.d.ts

@@ -0,0 +1,29 @@
+import { ScrubberProps } from './types';
+/**
+ * Renders the scrubber visuals: vertical reference line, future-data overlay
+ * rect, per-series beacon dots, and an optional tooltip when
+ * {@link ScrubberProps.tooltip} is set, using {@link DefaultScrubberTooltip}.
+ *
+ * Must be used as a child of `LineChart` (or `CartesianChart`) with
+ * `enableScrubbing` enabled. Renders nothing when no scrubber position is active.
+ *
+ * @example
+ * ```tsx
+ * <LineChart series={data} enableScrubbing>
+ *   <Scrubber showBeacons />
+ * </LineChart>
+ * ```
+ *
+ * @example Tooltip
+ * ```tsx
+ * <Scrubber
+ *   tooltip={(i) => ({
+ *     title: `${counts[i]} Transactions`,
+ *     items: [{ label: 'Index', value: String(i) }],
+ *     minWidth: 160,
+ *   })}
+ * />
+ * ```
+ */
+export declare function Scrubber({ hideLine, hideOverlay, showBeacons, tooltip, }: Readonly<ScrubberProps>): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=Scrubber.d.ts.map

package/dist/lib/Components/visualization/Scrubber/Scrubber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scrubber.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/Scrubber/Scrubber.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAoD7C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CAAC,EACvB,QAAgB,EAChB,WAAmB,EACnB,WAAmB,EACnB,OAAO,GACR,EAAE,QAAQ,CAAC,aAAa,CAAC,kDAwDzB"}