@ledgerhq/lumen-ui-react 0.1.55 → 0.1.57

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

@@ -0,0 +1,37 @@
+import { useMemo as t } from "react";
+import { chartConfig as x } from "../config.js";
+import { resolvePixelX as b, resolvePixelY as g, resolveTooltipPayload as C, computeOverlayRect as y } from "./utils.js";
+import { useScrubberContext as P } from "./context/scrubberContext.js";
+import { useCartesianChartContext as S } from "../CartesianChart/context/cartesianChartContext.js";
+const { color: X } = x, D = ({
+  showBeacons: i,
+  tooltip: n
+}) => {
+  const { scrubberPosition: r } = P(), {
+    getXScale: s,
+    getXAxisConfig: l,
+    getYScale: u,
+    drawingArea: a,
+    series: c,
+    seriesMap: d
+  } = S(), o = t(() => {
+    if (r !== void 0)
+      return b(r, s, l());
+  }, [r, s, l]), f = t(() => r === void 0 || !i ? [] : c.map((e) => {
+    const p = d.get(e.id)?.data, m = g(r, p, u);
+    return m === void 0 ? null : { id: e.id, stroke: e.stroke || X.stroke, pixelY: m };
+  }).filter((e) => e !== null), [r, i, c, d, u]), v = t(() => {
+    if (r !== void 0)
+      return C(n, r);
+  }, [r, n]);
+  return r === void 0 || o === void 0 ? null : {
+    pixelX: o,
+    drawingArea: a,
+    beacons: f,
+    overlay: y(o, a),
+    tooltipPayload: v
+  };
+};
+export {
+  D as useScrubberGeometry
+};

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

@@ -0,0 +1,79 @@
+import { BaseAxisProps } from '../Axis';
+import { useCartesianChartContext } from '../CartesianChart/context';
+import { ChartScaleFunction, DrawingArea } from '../utils/types';
+import { ChartTooltipItemData, ScrubberTooltipContent, SvgTextContent } from './types';
+export type MagnetEntry = {
+    index: number;
+    pixelX: number;
+};
+export type OverlayRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type ScrubberTooltipPayload = {
+    items: ChartTooltipItemData[];
+    resolvedTitle: SvgTextContent | undefined;
+    offset?: number;
+    minWidth?: number;
+};
+/**
+ * Resolves each magnetic index to its pixel position and returns them sorted
+ * by `pixelX` ascending. Indices that cannot be projected are filtered out.
+ * The sorted output enables early-exit in {@link applyMagnetization}.
+ */
+export declare const buildSortedMagnets: ({ magneticIndices, getPixelForIndex, }: {
+    magneticIndices: ReadonlySet<number>;
+    getPixelForIndex: (index: number) => number | undefined;
+}) => MagnetEntry[];
+/**
+ * Converts a pixel position along the x-axis into the nearest data index.
+ *
+ * For band (categorical) scales, finds the band whose center is closest to
+ * `pixelX`. For numeric scales, uses `scale.invert()` and rounds to the
+ * nearest integer, clamped to the valid index range.
+ */
+export declare const getDataIndexFromPosition: (pixelX: number, scale: ChartScaleFunction, axisConfig: Partial<BaseAxisProps> | undefined, dataLength: number) => number;
+/**
+ * Resolves the pixel y-coordinate for a given series data point at a data index.
+ * Returns undefined when the value is null/missing or the scale is unavailable.
+ */
+export declare const resolvePixelY: (dataIndex: number, seriesData: (number | null)[] | undefined, getYScale: ReturnType<typeof useCartesianChartContext>["getYScale"]) => number | undefined;
+/**
+ * Resolves the pixel x-coordinate for a given data index using the x-scale.
+ * When numeric x-axis data is provided, the corresponding axis value is used;
+ * otherwise the data index is used as the x input.
+ * Returns undefined when the scale is unavailable or the value cannot be mapped.
+ */
+export declare const resolvePixelX: (dataIndex: number, getXScale: ReturnType<typeof useCartesianChartContext>["getXScale"], axisConfig?: BaseAxisProps) => number | undefined;
+/**
+ * Binary search for the magnet whose `pixelX` is closest to `pixelX`.
+ * Returns -1 when the array is empty. Favors the left neighbor on ties.
+ */
+export declare const nearestIndex: (sortedMagnets: readonly MagnetEntry[], pixelX: number) => number;
+/**
+ * Given a resolved data index and the raw pixel position, checks whether any
+ * magnetic point is within `magnetRadius` pixels of `pixelX`. If so, returns
+ * the closest magnetic index; otherwise returns the original `resolvedIndex`.
+ */
+export declare const applyMagnetization: ({ resolvedIndex, pixelX, sortedMagnets, magnetRadius, }: {
+    resolvedIndex: number;
+    pixelX: number;
+    sortedMagnets: readonly MagnetEntry[];
+    magnetRadius: number;
+}) => number;
+/**
+ * Computes the rect that dims the data after the scrubber line. It starts just
+ * right of the line and spans to the drawing area's right edge, padded by
+ * `overlayOffset` on the top, bottom, and right. Width is clamped at 0 so the
+ * rect never inverts when the line sits at the right edge.
+ */
+export declare const computeOverlayRect: (pixelX: number, drawingArea: DrawingArea) => OverlayRect;
+/**
+ * Resolves the `tooltip` callback for a data index into render-ready payload:
+ * invokes the callback, resolves a function `title`, and returns `undefined`
+ * when there is no callback or it yields no items (so nothing is rendered).
+ */
+export declare const resolveTooltipPayload: (tooltip: ((dataIndex: number) => ScrubberTooltipContent) | undefined, scrubberPosition: number) => ScrubberTooltipPayload | undefined;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/Scrubber/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAQ1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEtE,OAAO,KAAK,EACV,oBAAoB,EACpB,sBAAsB,EACtB,cAAc,EACf,MAAM,SAAS,CAAC;AAIjB,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,oBAAoB,EAAE,CAAC;IAC9B,aAAa,EAAE,cAAc,GAAG,SAAS,CAAC;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,wCAGhC;IACD,eAAe,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACrC,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACzD,KAAG,WAAW,EAad,CAAC;AAgCF;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACnC,QAAQ,MAAM,EACd,OAAO,kBAAkB,EACzB,YAAY,OAAO,CAAC,aAAa,CAAC,GAAG,SAAS,EAC9C,YAAY,MAAM,KACjB,MAwBF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,GACxB,WAAW,MAAM,EACjB,YAAY,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,GAAG,SAAS,EACzC,WAAW,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,WAAW,CAAC,KAClE,MAAM,GAAG,SASX,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,aAAa,GACxB,WAAW,MAAM,EACjB,WAAW,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,WAAW,CAAC,EACnE,aAAa,aAAa,KACzB,MAAM,GAAG,SAMX,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,GACvB,eAAe,SAAS,WAAW,EAAE,EACrC,QAAQ,MAAM,KACb,MAsBF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,yDAKhC;IACD,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC,YAAY,EAAE,MAAM,CAAC;CACtB,KAAG,MAWH,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,MAAM,EACd,aAAa,WAAW,KACvB,WAYD,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAChC,SAAS,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,sBAAsB,CAAC,GAAG,SAAS,EACpE,kBAAkB,MAAM,KACvB,sBAAsB,GAAG,SAiB3B,CAAC"}

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

@@ -0,0 +1,104 @@
+import { chartConfig as h } from "../config.js";
+import { clamp as a } from "../utils/numbers.js";
+import { getPointOnScale as d, isNumericScale as u, isCategoricalScale as v } from "../utils/scales/scales.js";
+const { scrubber: l } = h, g = ({
+  magneticIndices: e,
+  getPixelForIndex: n
+}) => {
+  if (e.size === 0) return [];
+  const t = [];
+  for (const i of e) {
+    const o = n(i);
+    o !== void 0 && t.push({ index: i, pixelX: o });
+  }
+  return t.sort((i, o) => i.pixelX - o.pixelX), t;
+}, m = (e) => typeof e[0] == "number", c = (e, n, t) => {
+  let i = 0, o = 1 / 0;
+  for (let r = 0; r < e; r++) {
+    const s = t(r);
+    if (s === void 0) continue;
+    const f = Math.abs(n - s);
+    f < o && (o = f, i = r);
+  }
+  return i;
+}, O = (e, n, t, i) => {
+  if (v(n)) {
+    const o = n.domain(), r = n.bandwidth();
+    return c(o.length, e, (s) => {
+      const f = n(o[s]);
+      return f === void 0 ? void 0 : f + r / 2;
+    });
+  }
+  if (u(n)) {
+    const o = t?.data;
+    if (o && o.length > 0 && m(o))
+      return c(
+        o.length,
+        e,
+        (s) => n(o[s])
+      );
+    const r = n.invert(e);
+    return a(Math.round(r), 0, i - 1);
+  }
+  return 0;
+}, S = (e, n, t) => {
+  const i = t();
+  if (!i || !u(i) || !n) return;
+  const o = n[e];
+  if (o != null)
+    return i(o);
+}, I = (e, n, t) => {
+  const i = n();
+  if (!i) return;
+  const o = t?.data?.[e];
+  return d(typeof o == "number" ? o : e, i);
+}, y = (e, n) => {
+  if (e.length === 0) return -1;
+  let t = 0, i = e.length;
+  for (; t < i; ) {
+    const s = Math.floor((t + i) / 2);
+    e[s].pixelX < n ? t = s + 1 : i = s;
+  }
+  if (t === 0) return 0;
+  if (t === e.length) return t - 1;
+  const o = n - e[t - 1].pixelX, r = e[t].pixelX - n;
+  return o <= r ? t - 1 : t;
+}, P = ({
+  resolvedIndex: e,
+  pixelX: n,
+  sortedMagnets: t,
+  magnetRadius: i
+}) => {
+  if (i <= 0 || t.length === 0) return e;
+  const o = y(t, n);
+  return o >= 0 && Math.abs(t[o].pixelX - n) <= i ? t[o].index : e;
+}, C = (e, n) => ({
+  x: e + l.overlayLineInset,
+  y: n.y - l.overlayOffset,
+  width: Math.max(
+    0,
+    n.x + n.width - e - l.overlayLineInset + l.overlayOffset
+  ),
+  height: n.height + l.overlayOffset * 2
+}), V = (e, n) => {
+  if (!e) return;
+  const t = e(n);
+  if (t.items.length === 0) return;
+  const i = typeof t.title == "function" ? t.title(n) : t.title;
+  return {
+    items: t.items,
+    resolvedTitle: i,
+    offset: t.offset,
+    minWidth: t.minWidth
+  };
+};
+export {
+  P as applyMagnetization,
+  g as buildSortedMagnets,
+  C as computeOverlayRect,
+  O as getDataIndexFromPosition,
+  y as nearestIndex,
+  I as resolvePixelX,
+  S as resolvePixelY,
+  V as resolveTooltipPayload
+};