@ledgerhq/lumen-ui-react 0.1.55 → 0.1.57

package/dist/lib/Components/visualization/Axis/YAxis/YAxis.js

@@ -0,0 +1,85 @@
+import { jsxs as D, jsx as a } from "react/jsx-runtime";
+import { useMemo as v } from "react";
+import { chartConfig as z } from "../../config.js";
+import { buildTicksData as M } from "../../utils/ticks/ticks.js";
+import { useCartesianChartContext as W } from "../../CartesianChart/context/cartesianChartContext.js";
+const { axis: i, color: m, strokeWidth: l, font: p } = z;
+function q({
+  gridLineStyle: g = "solid",
+  position: d = "start",
+  showGrid: u = !1,
+  showLine: k = !1,
+  showTickMark: C = !1,
+  showLabels: S = !0,
+  ticks: x,
+  tickLabelFormatter: h
+}) {
+  const { getYScale: A, getYAxisConfig: $, drawingArea: e } = W(), r = A(), c = $(), n = v(
+    () => r ? M(r, c, x, h) : [],
+    [r, c, x, h]
+  );
+  if (!r || e.height <= 0)
+    return null;
+  const f = d === "start", s = f ? e.x : e.x + e.width, y = f ? -1 : 1, b = s + y * (i.tickMarkSize + i.tickLabelOffset);
+  return /* @__PURE__ */ D("g", { "data-testid": "y-axis", children: [
+    u && n.map((t, o) => /* @__PURE__ */ a(
+      "line",
+      {
+        x1: e.x,
+        y1: t.position,
+        x2: e.x + e.width,
+        y2: t.position,
+        style: {
+          stroke: m.gridLine
+        },
+        strokeWidth: l.hairline,
+        strokeDasharray: g === "dashed" ? i.gridDashArray : void 0
+      },
+      `grid-${t.value}-${o}`
+    )),
+    k && /* @__PURE__ */ a(
+      "line",
+      {
+        x1: s,
+        y1: e.y,
+        x2: s,
+        y2: e.y + e.height,
+        style: { stroke: i.lineColor },
+        strokeWidth: l.hairline,
+        shapeRendering: "crispEdges",
+        strokeLinecap: "square"
+      }
+    ),
+    C && n.map((t, o) => /* @__PURE__ */ a(
+      "line",
+      {
+        x1: s,
+        y1: t.position,
+        x2: s + y * i.tickMarkSize,
+        y2: t.position,
+        style: { stroke: i.lineColor },
+        strokeWidth: l.hairline
+      },
+      `tick-${t.value}-${o}`
+    )),
+    S && n.map((t, o) => /* @__PURE__ */ a(
+      "text",
+      {
+        x: b,
+        y: t.position,
+        textAnchor: d === "start" ? "end" : "start",
+        dominantBaseline: "central",
+        style: {
+          fill: m.textMuted,
+          fontSize: p.labelSize,
+          fontFamily: p.family
+        },
+        children: t.label
+      },
+      `label-${t.value}-${o}`
+    ))
+  ] });
+}
+export {
+  q as YAxis
+};

package/dist/lib/Components/visualization/Axis/YAxis/index.d.ts

@@ -0,0 +1,3 @@
+export { YAxis } from './YAxis';
+export type { YAxisProps } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/Components/visualization/Axis/YAxis/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/Axis/YAxis/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC"}

package/dist/lib/Components/visualization/Axis/YAxis/types.d.ts

@@ -0,0 +1,14 @@
+import { BaseAxisProps } from '../types';
+export type YAxisProps = BaseAxisProps & {
+    /**
+     * Where the y-axis is rendered relative to the drawing area.
+     * @default 'start'
+     */
+    position?: 'start' | 'end';
+    /**
+     * Width of the axis in pixels.
+     * @default 40
+     */
+    width?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/Components/visualization/Axis/YAxis/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/Axis/YAxis/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG;IACvC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;IAC3B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC"}

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

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

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

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

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

@@ -0,0 +1,80 @@
+export type AxisBounds = {
+    min: number;
+    max: number;
+};
+export type BaseAxisProps = {
+    /**
+     * Whether to render grid lines at each tick.
+     * @default false
+     */
+    showGrid?: boolean;
+    /**
+     * Appearance of the grid lines.
+     * @default 'dashed'
+     */
+    gridLineStyle?: 'solid' | 'dashed';
+    /**
+     * Whether to render the axis baseline.
+     * @default false
+     */
+    showLine?: boolean;
+    /**
+     * Whether to render tick marks at each tick position.
+     * @default false
+     */
+    showTickMark?: boolean;
+    /**
+     * Whether to render the text labels at each tick position.
+     * When false, tick marks, grid lines, and the baseline still render.
+     * @default true
+     */
+    showLabels?: boolean;
+    /**
+     * Explicit tick positions along the axis.
+     * When omitted, ticks are computed automatically from the scale. An empty
+     * array is honoured literally and renders no ticks — to keep ticks while
+     * hiding their marks or labels, use `showTickMark` / `showLabels` instead.
+     */
+    ticks?: number[];
+    /**
+     * Formats a tick value into its display label.
+     * Receives the raw tick value (number or string label) and must return a string.
+     */
+    tickLabelFormatter?: (value: number | string) => string;
+    /**
+     * Scale algorithm used by this axis.
+     * @default 'linear'
+     */
+    scaleType?: 'linear' | 'log' | 'band';
+    /**
+     * Explicit data values for band scales or category labels.
+     * For band scales, provides the discrete domain. For numeric scales, string values
+     * are used as tick labels at corresponding indices.
+     */
+    data?: string[] | number[];
+    /**
+     * Fixed domain bounds or a function that adjusts the computed bounds.
+     * A partial object overrides only the specified bound(s).
+     * A function receives the auto-computed bounds and returns adjusted ones.
+     *
+     * Applied before {@link BaseAxisProps.nice}. To keep your bounds exactly as
+     * provided, set `nice: false` alongside a full `{ min, max }` override.
+     */
+    domain?: Partial<AxisBounds> | ((bounds: AxisBounds) => AxisBounds);
+    /**
+     * Round the domain outward to clean boundaries via d3's `.nice()`
+     * (e.g. `[4, 98]` becomes `[0, 100]`).
+     *
+     * Defaults to `true` in `CartesianChart`. `LineChart` overrides this per axis,
+     * defaulting to `false` for the X axis and `true` for the Y axis.
+     *
+     * Set to `false` to keep the domain exactly as provided so data fills the plot
+     * area boundary-to-boundary — typically only useful when you also pass a full
+     * `domain: { min, max }` and don't have overlays (reference lines, scrubber
+     * positions, annotations) that may sit outside the data range.
+     *
+     * Applied after any {@link BaseAxisProps.domain} override.
+     */
+    nice?: boolean;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/Axis/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IACnC;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,KAAK,MAAM,CAAC;IACxD;;;OAGG;IACH,SAAS,CAAC,EAAE,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;IACtC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;IAC3B;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,UAAU,KAAK,UAAU,CAAC,CAAC;IACpE;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC"}

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

@@ -0,0 +1,3 @@
+import { CartesianChartProps } from './types';
+export declare function CartesianChart({ series, xAxis, yAxis, width, height, inset, axisPadding, ariaLabel, ariaBusy, overlay: htmlOverlay, enableScrubbing, onScrubberPositionChange, animate, magnetRadius, children, }: CartesianChartProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=CartesianChart.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CartesianChart.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/CartesianChart/CartesianChart.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGnD,wBAAgB,cAAc,CAAC,EAC7B,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAc,EACd,MAAuC,EACvC,KAAK,EACL,WAAW,EACX,SAAmB,EACnB,QAAgB,EAChB,OAAO,EAAE,WAAW,EACpB,eAAuB,EACvB,wBAAwB,EACxB,OAAc,EACd,YAAY,EACZ,QAAQ,GACT,EAAE,mBAAmB,2CAuGrB"}

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

@@ -0,0 +1,107 @@
+import { jsx as r, jsxs as k, Fragment as O } from "react/jsx-runtime";
+import { useRef as h, useState as B, useCallback as E, useEffect as F, useMemo as b } from "react";
+import { chartConfig as H } from "../config.js";
+import { ScrubberProvider as V } from "../Scrubber/ScrubberProvider.js";
+import { resolveInset as q, resolveAxisPadding as D } from "./utils.js";
+import { useBuildChartContext as G } from "./context/useBuildChartContext.js";
+import { CartesianChartProvider as J } from "./context/cartesianChartContext.js";
+import { MagneticPointsProvider as K } from "../Point/pointContext/MagneticPointsProvider.js";
+import { RevealAnimationProvider as L } from "./RevealAnimation/RevealAnimationProvider.js";
+function $({
+  series: d,
+  xAxis: y,
+  yAxis: C,
+  width: e = "100%",
+  height: n = H.root.defaultHeight,
+  inset: l,
+  axisPadding: c,
+  ariaLabel: g = "Chart",
+  ariaBusy: x = !1,
+  overlay: R,
+  enableScrubbing: s = !1,
+  onScrubberPositionChange: P,
+  animate: A = !0,
+  magnetRadius: w,
+  children: M
+}) {
+  const a = h(null), v = h(null), [W, z] = B(
+    typeof e == "number" ? e : void 0
+  ), t = typeof e != "number", f = E((i) => {
+    const [p] = i;
+    p && z(p.contentRect.width);
+  }, []);
+  F(() => {
+    if (!t || !a.current || typeof ResizeObserver > "u")
+      return;
+    const i = new ResizeObserver(f);
+    return i.observe(a.current), () => i.disconnect();
+  }, [t, f]);
+  const o = typeof e == "number" ? e : W ?? 0, m = o > 0 ? o : 0, I = b(() => q(l), [l]), j = b(
+    () => D(c),
+    [c]
+  ), u = G({
+    series: d,
+    xAxis: y,
+    yAxis: C,
+    width: m,
+    height: n,
+    inset: I,
+    axisPadding: j
+  });
+  return /* @__PURE__ */ r(
+    "div",
+    {
+      ref: t ? a : void 0,
+      "data-testid": "chart-container",
+      style: {
+        width: t ? e : o,
+        height: n,
+        overflow: "visible",
+        position: "relative"
+      },
+      children: o > 0 && /* @__PURE__ */ k(O, { children: [
+        /* @__PURE__ */ r(
+          "svg",
+          {
+            ref: v,
+            "data-testid": "chart-svg",
+            width: m,
+            height: n,
+            role: "img",
+            "aria-label": g || "Chart",
+            "aria-busy": x || void 0,
+            tabIndex: s ? 0 : void 0,
+            style: {
+              display: "block",
+              overflow: "visible",
+              position: "relative",
+              outline: s ? "none" : void 0
+            },
+            children: /* @__PURE__ */ r(J, { value: u, children: /* @__PURE__ */ r(K, { children: /* @__PURE__ */ r(
+              V,
+              {
+                svgRef: v,
+                enableScrubbing: s,
+                onScrubberPositionChange: P,
+                magnetRadius: w,
+                children: /* @__PURE__ */ r(
+                  L,
+                  {
+                    drawingArea: u.drawingArea,
+                    series: d,
+                    animate: A,
+                    children: M
+                  }
+                )
+              }
+            ) }) })
+          }
+        ),
+        R
+      ] })
+    }
+  );
+}
+export {
+  $ as CartesianChart
+};

package/dist/lib/Components/visualization/CartesianChart/ChartEmptyLabel/ChartEmptyLabel.d.ts

@@ -0,0 +1,11 @@
+import { PropsWithChildren } from 'react';
+type ChartEmptyLabelProps = PropsWithChildren;
+/**
+ * Centred HTML overlay label shown when a chart has no data (and is not
+ * loading). Rendered through the `overlay` prop of `CartesianChart` so it shares
+ * the chart's positioned container and aligns with the chart footprint. Shared
+ * across cartesian charts.
+ */
+export declare function ChartEmptyLabel({ children }: Readonly<ChartEmptyLabelProps>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=ChartEmptyLabel.d.ts.map

package/dist/lib/Components/visualization/CartesianChart/ChartEmptyLabel/ChartEmptyLabel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartEmptyLabel.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/CartesianChart/ChartEmptyLabel/ChartEmptyLabel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAE/C,KAAK,oBAAoB,GAAG,iBAAiB,CAAC;AAE9C;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,EAAE,QAAQ,CAAC,oBAAoB,CAAC,2CAc3E"}

package/dist/lib/Components/visualization/CartesianChart/ChartEmptyLabel/ChartEmptyLabel.js

@@ -0,0 +1,21 @@
+import { jsx as e } from "react/jsx-runtime";
+function n({ children: t }) {
+  return /* @__PURE__ */ e(
+    "div",
+    {
+      "aria-hidden": "true",
+      className: "pointer-events-none absolute inset-0 flex items-center justify-center",
+      children: /* @__PURE__ */ e(
+        "span",
+        {
+          "data-testid": "chart-empty-label",
+          className: "animate-fade-in rounded-xs bg-muted px-12 py-6 body-3 text-muted",
+          children: t
+        }
+      )
+    }
+  );
+}
+export {
+  n as ChartEmptyLabel
+};

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/RevealAnimationProvider.d.ts

@@ -0,0 +1,3 @@
+import { RevealAnimationProps } from './types';
+export declare function RevealAnimationProvider({ children, drawingArea, series, animate, transitions, }: RevealAnimationProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RevealAnimationProvider.d.ts.map

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/RevealAnimationProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RevealAnimationProvider.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/CartesianChart/RevealAnimation/RevealAnimationProvider.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAGpD,wBAAgB,uBAAuB,CAAC,EACtC,QAAQ,EACR,WAAW,EACX,MAAM,EACN,OAAc,EACd,WAAW,GACZ,EAAE,oBAAoB,2CA2CtB"}

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/RevealAnimationProvider.js

@@ -0,0 +1,41 @@
+import { jsx as t, Fragment as v, jsxs as y } from "react/jsx-runtime";
+import { useMemo as g } from "react";
+import { chartConfig as l } from "../../config.js";
+import { RevealAnimationContext as x } from "./context.js";
+import { useDataFingerprint as P, useRevealAnimation as R } from "./utils.js";
+function C({
+  children: n,
+  drawingArea: e,
+  series: m,
+  animate: s = !0,
+  transitions: o
+}) {
+  const c = !s, d = o?.enter?.duration ?? l.reveal.durationInSeconds, h = o?.enter?.easing ?? l.reveal.easing, f = P(m), { clipId: p, clipPathAttr: r, clipPathAnimation: a, fadeAnimation: i } = R({
+    duration: d,
+    easing: h,
+    drawingArea: e
+  }), u = g(
+    () => ({
+      clipPathAttr: r,
+      getPointRevealStyle: i.getPointRevealStyle
+    }),
+    [r, i]
+  );
+  return c ? /* @__PURE__ */ t(v, { children: n }) : /* @__PURE__ */ y(x.Provider, { value: u, children: [
+    /* @__PURE__ */ t("defs", { children: /* @__PURE__ */ t("clipPath", { id: p, children: /* @__PURE__ */ t(
+      "rect",
+      {
+        x: e.x,
+        y: e.y,
+        height: e.height,
+        width: e.width,
+        style: { animation: a.style }
+      }
+    ) }) }),
+    /* @__PURE__ */ t("style", { children: `${a.keyframe} ${i.keyframe}` }),
+    n
+  ] }, f);
+}
+export {
+  C as RevealAnimationProvider
+};

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/context.d.ts

@@ -0,0 +1,15 @@
+import { CSSProperties } from 'react';
+import { RevealAnimationContextValue } from './types';
+export declare const RevealAnimationContext: import('react').Context<RevealAnimationContextValue | undefined>;
+/**
+ * Clip-path attribute for path-based consumers (e.g. `Line`).
+ * Returns `undefined` when the reveal animation is disabled.
+ */
+export declare const usePathReveal: () => string | undefined;
+/**
+ * Opacity fade-in style for accessory consumers (e.g. `Point`). Returns
+ * `undefined` when the reveal animation is disabled, leaving the consumer fully
+ * visible.
+ */
+export declare const usePointReveal: () => CSSProperties | undefined;
+//# sourceMappingURL=context.d.ts.map

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/CartesianChart/RevealAnimation/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE3C,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAE3D,eAAO,MAAM,sBAAsB,kEAEvB,CAAC;AAEb;;;GAGG;AACH,eAAO,MAAM,aAAa,QAAO,MAAM,GAAG,SAEzC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAO,aAAa,GAAG,SAGjD,CAAC"}

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/context.js

@@ -0,0 +1,10 @@
+import { createContext as n, useContext as e, useMemo as r } from "react";
+const o = n(void 0), s = () => e(o)?.clipPathAttr, c = () => {
+  const t = e(o);
+  return r(() => t?.getPointRevealStyle(), [t]);
+};
+export {
+  o as RevealAnimationContext,
+  s as usePathReveal,
+  c as usePointReveal
+};

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/index.d.ts

@@ -0,0 +1,3 @@
+export { RevealAnimationProvider } from './RevealAnimationProvider';
+export { usePathReveal, usePointReveal } from './context';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/CartesianChart/RevealAnimation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC"}

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/types.d.ts

@@ -0,0 +1,57 @@
+import { CSSProperties, ReactNode } from 'react';
+import { DrawingArea, Series } from '../../utils';
+/**
+ * Value shared by the reveal animation provider.
+ *
+ * - `clipPathAttr` drives the left-to-right clip wipe consumed by path-based
+ *   components (e.g. `Line`).
+ * - `getPointRevealStyle` returns the opacity fade-in style for accessory
+ *   components (e.g. `Point`) that must not be clipped, so edge content stays
+ *   visible.
+ */
+export type RevealAnimationContextValue = {
+    /**
+     * `clip-path` attribute (`url(#id)`) used by the line/area wipe.
+     */
+    clipPathAttr: string;
+    /**
+     * Builds the opacity fade-in style for an accessory (e.g. `Point`) so it
+     * reveals without being clipped, keeping edge content visible.
+     */
+    getPointRevealStyle: () => CSSProperties;
+};
+export type EnterTransitionConfig = {
+    /**
+     * Duration in seconds. @default 0.8
+     */
+    duration?: number;
+    /**
+     * CSS easing function. @default 'linear'
+     */
+    easing?: string;
+};
+export type RevealAnimationProps = {
+    children: ReactNode;
+    /**
+     * The drawing area whose bounds define the clip rectangle.
+     */
+    drawingArea: DrawingArea;
+    /**
+     * Whether to animate the chart.
+     * @default true
+     */
+    animate?: boolean;
+    /**
+     * Transition configuration.
+     * @default { enter: { duration: 0.8, easing: 'linear' } }
+     */
+    transitions?: {
+        enter?: EnterTransitionConfig;
+    };
+    /**
+     * Data series used to compute a fingerprint that restarts
+     * the animation when data changes.
+     */
+    series: Series[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/CartesianChart/RevealAnimation/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAEvD;;;;;;;;GAQG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,mBAAmB,EAAE,MAAM,aAAa,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,SAAS,CAAC;IACpB;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC;IACzB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,WAAW,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,qBAAqB,CAAA;KAAE,CAAC;IAChD;;;OAGG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC"}

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/utils.d.ts

@@ -0,0 +1,35 @@
+import { CSSProperties } from 'react';
+import { DrawingArea, Series } from '../../utils/types';
+type RevealAnimationConfig = {
+    duration: number;
+    easing: string;
+    drawingArea: DrawingArea;
+};
+/**
+ * Creates the reveal animation for the chart.
+ * It returns
+ * - the clip id
+ * - the clip path animation
+ * - and the fade animation.
+ */
+export declare const useRevealAnimation: ({ duration, easing, drawingArea, }: RevealAnimationConfig) => {
+    clipId: string;
+    clipPathAttr: string;
+    clipPathAnimation: {
+        keyframe: string;
+        style: string;
+    };
+    fadeAnimation: {
+        keyframe: string;
+        getPointRevealStyle: () => CSSProperties;
+    };
+};
+/**
+ * Stable signature of every series' data points, memoized on the `series`
+ * reference. Used to key the reveal provider so the reveal animation only
+ * replays when the underlying data actually changes — not on unrelated
+ * re-renders such as scrubbing or hover.
+ */
+export declare const useDataFingerprint: (series: Series[]) => string;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/CartesianChart/RevealAnimation/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAG3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAI7D,KAAK,qBAAqB,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,GAAI,oCAIhC,qBAAqB;;;;;;;;;mCA2CO,aAAa;;CAnB3C,CAAC;AA2DF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,EAAE,KAAG,MAKrD,CAAC"}

package/dist/lib/Components/visualization/CartesianChart/RevealAnimation/utils.js

@@ -0,0 +1,69 @@
+import { useMemo as r, useId as m } from "react";
+import { chartConfig as c } from "../../config.js";
+const { reveal: l } = c, A = ({
+  duration: a,
+  easing: t,
+  drawingArea: o
+}) => {
+  const e = m(), n = s({
+    clipId: e,
+    duration: a,
+    easing: t
+  }), i = p({
+    clipId: e,
+    duration: a,
+    easing: t,
+    drawingArea: o
+  });
+  return r(
+    () => ({
+      clipId: e,
+      clipPathAttr: `url(#${e})`,
+      clipPathAnimation: i,
+      fadeAnimation: n
+    }),
+    [e, i, n]
+  );
+}, s = ({
+  clipId: a,
+  duration: t,
+  easing: o
+}) => {
+  const e = `reveal-fade-${a.replaceAll(":", "")}`;
+  return r(
+    () => ({
+      keyframe: `@keyframes ${e} { from { opacity: 0; } to { opacity: 1; } }`,
+      getPointRevealStyle: () => {
+        const n = Math.max(
+          0,
+          t + l.pointFadeInAfterClipInSeconds
+        );
+        return {
+          animation: `${e} ${l.pointFadeDurationInSeconds}s ${o} ${n}s both`
+        };
+      }
+    }),
+    [t, o, e]
+  );
+}, p = ({
+  clipId: a,
+  duration: t,
+  easing: o,
+  drawingArea: e
+}) => {
+  const n = `reveal-clip-${a.replaceAll(":", "")}`, i = e.width;
+  return r(
+    () => ({
+      keyframe: `@keyframes ${n} { from { width: 0; } to { width: ${i}px; } }`,
+      style: `${n} ${t}s ${o} forwards`
+    }),
+    [n, t, o, i]
+  );
+}, $ = (a) => r(
+  () => a.map((t) => t.data?.join(",") ?? "").join("|"),
+  [a]
+);
+export {
+  $ as useDataFingerprint,
+  A as useRevealAnimation
+};

package/dist/lib/Components/visualization/CartesianChart/context/cartesianChartContext.d.ts

@@ -0,0 +1,8 @@
+import { CartesianChartContextValue } from '../types';
+declare const CartesianChartProvider: import('react').FC<{
+    children: import('react').ReactNode;
+    value: CartesianChartContextValue;
+}>;
+export declare const useCartesianChartContext: () => CartesianChartContextValue;
+export { CartesianChartProvider };
+//# sourceMappingURL=cartesianChartContext.d.ts.map

package/dist/lib/Components/visualization/CartesianChart/context/cartesianChartContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianChartContext.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/CartesianChart/context/cartesianChartContext.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAE3D,QAAA,MAAO,sBAAsB;;;EACoC,CAAC;AAElE,eAAO,MAAM,wBAAwB,kCAIjC,CAAC;AAEL,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/lib/Components/visualization/CartesianChart/context/cartesianChartContext.js

@@ -0,0 +1,9 @@
+import { createSafeContext as t } from "../../../../../libs/utils-shared/dist/index.js";
+const [r, e] = t("CartesianChart"), C = () => e({
+  consumerName: "useCartesianChartContext",
+  contextRequired: !0
+});
+export {
+  r as CartesianChartProvider,
+  C as useCartesianChartContext
+};

package/dist/lib/Components/visualization/CartesianChart/context/index.d.ts

@@ -0,0 +1,3 @@
+export { CartesianChartProvider, useCartesianChartContext, } from './cartesianChartContext';
+export { buildScale, computeAxisRange, computeDrawingArea, useBuildChartContext, } from './useBuildChartContext';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/Components/visualization/CartesianChart/context/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/CartesianChart/context/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,wBAAwB,GACzB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,wBAAwB,CAAC"}