@ledgerhq/lumen-ui-react 0.1.56 → 0.1.57

package/dist/lib/Components/visualization/DonutChart/DonutChartAnimatedCenter.js

@@ -0,0 +1,61 @@
+import { jsxs as u, jsx as s } from "react/jsx-runtime";
+import { useState as p, useEffect as h, useMemo as r } from "react";
+import { chartConfig as v } from "../config.js";
+const { centerTextTransition: i } = v.donut.hover, o = 8, j = ({
+  activeSegment: e,
+  renderResting: a,
+  renderActive: c
+}) => {
+  const [l, d] = p(null);
+  h(() => {
+    e && d(e);
+  }, [e]);
+  const t = e != null, n = e ?? l, f = r(
+    () => ({
+      transition: i,
+      opacity: t ? 0 : 1,
+      transform: `translateY(${t ? -o : 0}px)`
+    }),
+    [t]
+  ), m = r(
+    () => ({
+      transition: i,
+      opacity: t ? 1 : 0,
+      transform: `translateY(${t ? 0 : o}px)`
+    }),
+    [t]
+  );
+  return /* @__PURE__ */ u("div", { className: "pointer-events-auto grid", children: [
+    /* @__PURE__ */ s(
+      "div",
+      {
+        "data-visible": !t,
+        "aria-hidden": t,
+        style: {
+          gridArea: "1 / 1",
+          pointerEvents: t ? "none" : "auto",
+          ...f
+        },
+        className: "flex items-center justify-center",
+        children: a()
+      }
+    ),
+    n && /* @__PURE__ */ s(
+      "div",
+      {
+        "data-visible": t,
+        "aria-hidden": !t,
+        style: {
+          gridArea: "1 / 1",
+          pointerEvents: t ? "auto" : "none",
+          ...m
+        },
+        className: "flex items-center justify-center",
+        children: c(n)
+      }
+    )
+  ] });
+};
+export {
+  j as DonutChartAnimatedCenter
+};

package/dist/lib/Components/visualization/DonutChart/DonutChartCenter.d.ts

@@ -0,0 +1,9 @@
+import { DonutChartCenterProps } from './types';
+/**
+ * Layout wrapper for the donut center slot: a centered vertical stack for
+ * `DonutChartTitle` / `DonutChartDescription`. Rendered via `renderCenter` /
+ * `renderCenterActive` as the top-level element.
+ * Use `className` to add custom styles.
+ */
+export declare const DonutChartCenter: ({ ref, className, ...props }: DonutChartCenterProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DonutChartCenter.d.ts.map

package/dist/lib/Components/visualization/DonutChart/DonutChartCenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DonutChartCenter.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/DonutChart/DonutChartCenter.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,8BAI9B,qBAAqB,4CAWvB,CAAC"}

package/dist/lib/Components/visualization/DonutChart/DonutChartCenter.js

@@ -0,0 +1,20 @@
+import { jsx as o } from "react/jsx-runtime";
+import { cn as n } from "../../../../libs/utils-shared/dist/index.js";
+const a = ({
+  ref: t,
+  className: e,
+  ...r
+}) => /* @__PURE__ */ o(
+  "div",
+  {
+    ref: t,
+    className: n(
+      "pointer-events-auto flex min-w-0 flex-col items-center",
+      e
+    ),
+    ...r
+  }
+);
+export {
+  a as DonutChartCenter
+};

package/dist/lib/Components/visualization/DonutChart/DonutChartDescription.d.ts

@@ -0,0 +1,3 @@
+import { DonutChartDescriptionProps } from './types';
+export declare const DonutChartDescription: ({ ref, children, className, style, ...props }: DonutChartDescriptionProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DonutChartDescription.d.ts.map

package/dist/lib/Components/visualization/DonutChart/DonutChartDescription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DonutChartDescription.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/DonutChart/DonutChartDescription.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAoB1D,eAAO,MAAM,qBAAqB,GAAI,+CAMnC,0BAA0B,4CAsB5B,CAAC"}

package/dist/lib/Components/visualization/DonutChart/DonutChartDescription.js

@@ -0,0 +1,49 @@
+import { jsx as m } from "react/jsx-runtime";
+import { isTextChildren as u, cn as d } from "../../../../libs/utils-shared/dist/index.js";
+import { cva as c } from "class-variance-authority";
+import { useDonutSizeContext as x } from "./donutSizeContext.js";
+import { getCenterContentInset as l, getCenterMaxWidth as p } from "./utils.js";
+const f = c("min-w-0 text-muted", {
+  variants: {
+    donutSize: {
+      md: "body-3",
+      sm: "-mt-4 body-4"
+    },
+    layout: {
+      text: "truncate",
+      cluster: "flex items-center gap-2"
+    }
+  },
+  defaultVariants: {
+    donutSize: "md",
+    layout: "text"
+  }
+}), h = ({
+  ref: n,
+  children: e,
+  className: o,
+  style: i,
+  ...r
+}) => {
+  const { size: t = "md" } = x({
+    consumerName: "DonutChartDescription",
+    contextRequired: !1
+  }), s = l(t), a = u(e) ? "text" : "cluster";
+  return /* @__PURE__ */ m(
+    "div",
+    {
+      ref: n,
+      style: {
+        maxWidth: p(t),
+        paddingInline: s,
+        ...i
+      },
+      className: d(f({ donutSize: t, layout: a }), o),
+      ...r,
+      children: e
+    }
+  );
+};
+export {
+  h as DonutChartDescription
+};

package/dist/lib/Components/visualization/DonutChart/DonutChartTitle.d.ts

@@ -0,0 +1,3 @@
+import { DonutChartTitleProps } from './types';
+export declare const DonutChartTitle: ({ ref, children, className, size, style, ...props }: DonutChartTitleProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DonutChartTitle.d.ts.map

package/dist/lib/Components/visualization/DonutChart/DonutChartTitle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DonutChartTitle.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/DonutChart/DonutChartTitle.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AA0BpD,eAAO,MAAM,eAAe,GAAI,qDAO7B,oBAAoB,4CAqBtB,CAAC"}

package/dist/lib/Components/visualization/DonutChart/DonutChartTitle.js

@@ -0,0 +1,55 @@
+import { jsx as a } from "react/jsx-runtime";
+import { cva as r } from "class-variance-authority";
+import { useDonutSizeContext as u } from "./donutSizeContext.js";
+import { getCenterContentInset as l, getCenterMaxWidth as z } from "./utils.js";
+const c = r("min-w-0 truncate text-base", {
+  variants: {
+    donutSize: {
+      md: "",
+      sm: ""
+    },
+    size: {
+      md: "",
+      sm: ""
+    }
+  },
+  compoundVariants: [
+    { donutSize: "md", size: "md", class: "heading-1-semi-bold" },
+    { donutSize: "md", size: "sm", class: "heading-2-semi-bold" },
+    { donutSize: "sm", size: "md", class: "heading-4-semi-bold" },
+    { donutSize: "sm", size: "sm", class: "body-2-semi-bold" }
+  ],
+  defaultVariants: {
+    donutSize: "md",
+    size: "md"
+  }
+}), b = ({
+  ref: t,
+  children: s,
+  className: i,
+  size: n = "md",
+  style: m,
+  ...o
+}) => {
+  const { size: e = "md" } = u({
+    consumerName: "DonutChartTitle",
+    contextRequired: !1
+  }), d = l(e);
+  return /* @__PURE__ */ a(
+    "div",
+    {
+      ref: t,
+      style: {
+        maxWidth: z(e),
+        paddingInline: d,
+        ...m
+      },
+      className: c({ donutSize: e, size: n, className: i }),
+      ...o,
+      children: s
+    }
+  );
+};
+export {
+  b as DonutChartTitle
+};

package/dist/lib/Components/visualization/DonutChart/DonutRing.d.ts

@@ -0,0 +1,12 @@
+import { DonutGeometry, DonutRingSegment } from './types';
+type DonutRingProps = {
+    segments: DonutRingSegment[];
+    geometry: DonutGeometry;
+    ariaLabel?: string;
+    activeId: string | null;
+    loading?: boolean;
+    onSegmentEnter: (id: string) => void;
+};
+export declare const DonutRing: ({ segments, geometry, ariaLabel, activeId, loading, onSegmentEnter, }: DonutRingProps) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=DonutRing.d.ts.map

package/dist/lib/Components/visualization/DonutChart/DonutRing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DonutRing.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/DonutChart/DonutRing.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAoG/D,KAAK,cAAc,GAAG;IACpB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,QAAQ,EAAE,aAAa,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC,CAAC;AAaF,eAAO,MAAM,SAAS,GAAI,uEAOvB,cAAc,4CAqChB,CAAC"}

package/dist/lib/Components/visualization/DonutChart/DonutRing.js

@@ -0,0 +1,110 @@
+import { jsx as i, jsxs as v, Fragment as b } from "react/jsx-runtime";
+import { useRef as h, useMemo as f, useCallback as x } from "react";
+import { chartConfig as c } from "../config.js";
+import { useDonutLoadingAnimation as R } from "./hooks/useDonutLoadingAnimation.js";
+import { RevealAnimation as $ } from "./RevealAnimation.js";
+import { getDonutViewBox as g, buildPlaceholderSegments as m } from "./utils.js";
+const { hover: s } = c.donut, D = ({
+  segment: t,
+  activeId: o,
+  onSegmentEnter: n
+}) => {
+  const a = o === t.id, e = !t.hoverEnabled || o == null || a ? 1 : s.dimOpacity, { x: r, y: l } = a ? t.hoverTranslate : { x: 0, y: 0 }, d = x(() => {
+    n(t.id);
+  }, [t.id, n]);
+  return /* @__PURE__ */ i(
+    "path",
+    {
+      "data-testid": "donut-segment",
+      "data-segment-id": t.id,
+      d: t.path,
+      fill: t.color,
+      role: "button",
+      "aria-label": a ? `${t.id}, selected` : t.id,
+      tabIndex: 0,
+      className: "outline-none focus-visible:outline-2 focus-visible:outline-focus",
+      onMouseEnter: d,
+      onFocus: d,
+      style: {
+        cursor: "pointer",
+        opacity: e,
+        transform: `translate(${r}px, ${l}px)`,
+        transition: t.hoverEnabled ? `${s.opacityTransition}, ${s.popTransition}` : void 0
+      }
+    }
+  );
+}, S = ({ geometry: t }) => {
+  const o = f(
+    () => m(t),
+    [t]
+  );
+  return /* @__PURE__ */ i("g", { "data-testid": "donut-empty", children: o.map((n) => /* @__PURE__ */ i(
+    "path",
+    {
+      "data-testid": "donut-placeholder",
+      d: n.path,
+      fill: c.donut.emptyRingColor
+    },
+    n.id
+  )) });
+}, k = ({ geometry: t }) => {
+  const o = f(
+    () => m(t),
+    [t]
+  ), { animationStyle: n, keyframe: a, getSegmentDelay: e } = R();
+  return /* @__PURE__ */ v(b, { children: [
+    /* @__PURE__ */ i("style", { children: a }),
+    /* @__PURE__ */ i("g", { "data-testid": "donut-loading", children: o.map((r) => /* @__PURE__ */ i(
+      "path",
+      {
+        "data-testid": "donut-placeholder",
+        d: r.path,
+        fill: c.donut.emptyRingColor,
+        style: {
+          animation: n,
+          animationDelay: e(r.midAngle)
+        }
+      },
+      r.id
+    )) })
+  ] });
+};
+function w(t) {
+  const o = h(0), n = h(t);
+  return n.current && !t && (o.current += 1), n.current = t, o.current;
+}
+const F = ({
+  segments: t,
+  geometry: o,
+  ariaLabel: n,
+  activeId: a,
+  loading: e = !1,
+  onSegmentEnter: r
+}) => {
+  const { box: l } = o, d = l / 2, u = t.length > 0, y = w(e);
+  return /* @__PURE__ */ i($, { children: /* @__PURE__ */ i(
+    "svg",
+    {
+      "data-testid": "donut-ring",
+      width: l,
+      height: l,
+      viewBox: g(o),
+      role: e || !u ? "img" : "group",
+      "aria-label": n,
+      "aria-busy": e || void 0,
+      style: { display: "block", overflow: "visible" },
+      children: /* @__PURE__ */ i("g", { transform: `translate(${d}, ${d})`, children: e ? /* @__PURE__ */ i(k, { geometry: o }) : u ? t.map((p) => /* @__PURE__ */ i(
+        D,
+        {
+          segment: p,
+          activeId: a,
+          onSegmentEnter: r
+        },
+        p.id
+      )) : /* @__PURE__ */ i(S, { geometry: o }) })
+    }
+  ) }, y);
+};
+export {
+  F as DonutRing
+};

package/dist/lib/Components/visualization/DonutChart/RevealAnimation.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from 'react';
+type RevealAnimationProps = {
+    children: ReactNode;
+};
+export declare const RevealAnimation: ({ children }: RevealAnimationProps) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=RevealAnimation.d.ts.map

package/dist/lib/Components/visualization/DonutChart/RevealAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RevealAnimation.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/DonutChart/RevealAnimation.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAqBvC,KAAK,oBAAoB,GAAG;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,CAAC;AAEpD,eAAO,MAAM,eAAe,GAAI,cAAc,oBAAoB,4CAMjE,CAAC"}

package/dist/lib/Components/visualization/DonutChart/RevealAnimation.js

@@ -0,0 +1,28 @@
+import { jsxs as r, jsx as a } from "react/jsx-runtime";
+const n = `
+  @property --donut-reveal {
+    syntax: '<percentage>';
+    inherits: false;
+    initial-value: 100%;
+  }
+  @keyframes donut-reveal {
+    from { --donut-reveal: 0%; }
+    to { --donut-reveal: 100%; }
+  }
+  @media (prefers-reduced-motion: no-preference) {
+    .donut-ring-reveal {
+      mask-image: conic-gradient(from 0deg, black var(--donut-reveal), transparent var(--donut-reveal));
+      -webkit-mask-image: conic-gradient(from 0deg, black var(--donut-reveal), transparent var(--donut-reveal));
+      animation: donut-reveal 1000ms ease-out forwards;
+    }
+  }
+`, o = ({ children: e }) => (
+  // eslint-disable-next-line better-tailwindcss/no-unknown-classes
+  /* @__PURE__ */ r("div", { className: "donut-ring-reveal", children: [
+    /* @__PURE__ */ a("style", { children: n }),
+    e
+  ] })
+);
+export {
+  o as RevealAnimation
+};

package/dist/lib/Components/visualization/DonutChart/donutSizeContext.d.ts

@@ -0,0 +1,18 @@
+import { DonutSize } from './types';
+type DonutSizeContextValue = {
+    size: DonutSize;
+};
+/**
+ * Carries the donut ring's `size` down to `DonutChartTitle` /
+ * `DonutChartDescription` (rendered via `renderCenter`), which pick their
+ * typography off it.
+ */
+export declare const DonutSizeProvider: import('react').FC<{
+    children: import('react').ReactNode;
+    value: DonutSizeContextValue;
+}>, useDonutSizeContext: <ContextRequired extends boolean = boolean>({ consumerName, contextRequired, }: {
+    consumerName: string;
+    contextRequired: ContextRequired;
+}) => ContextRequired extends true ? DonutSizeContextValue : Partial<DonutSizeContextValue>;
+export {};
+//# sourceMappingURL=donutSizeContext.d.ts.map

package/dist/lib/Components/visualization/DonutChart/donutSizeContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"donutSizeContext.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/DonutChart/donutSizeContext.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,KAAK,qBAAqB,GAAG;IAC3B,IAAI,EAAE,SAAS,CAAC;CACjB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAO,iBAAiB;;;IAAE,mBAAmB;;;2FACoB,CAAC"}

package/dist/lib/Components/visualization/DonutChart/donutSizeContext.js

@@ -0,0 +1,6 @@
+import { createSafeContext as t } from "../../../../libs/utils-shared/dist/index.js";
+const [o, r] = t("DonutChart", { size: "md" });
+export {
+  o as DonutSizeProvider,
+  r as useDonutSizeContext
+};

package/dist/lib/Components/visualization/DonutChart/hooks/useContrastSafeSeries.d.ts

@@ -0,0 +1,12 @@
+import { DonutSegment } from '../types';
+/**
+ * The series with each segment `color` nudged away from the surface it is drawn
+ * on, so a palette close in lightness to the background stays readable.
+ *
+ * `grey.050` is the base surface fill in both color schemes, and colorless
+ * segments are left alone: the ring paints them with its neutral default, which
+ * is already contrast-safe. Returns `series` untouched when `enabled` is false,
+ * keeping its identity stable for downstream memos.
+ */
+export declare const useContrastSafeSeries: (series: DonutSegment[], enabled: boolean) => DonutSegment[];
+//# sourceMappingURL=useContrastSafeSeries.d.ts.map

package/dist/lib/Components/visualization/DonutChart/hooks/useContrastSafeSeries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContrastSafeSeries.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/DonutChart/hooks/useContrastSafeSeries.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAChC,QAAQ,YAAY,EAAE,EACtB,SAAS,OAAO,KACf,YAAY,EAiBd,CAAC"}

package/dist/lib/Components/visualization/DonutChart/hooks/useContrastSafeSeries.js

@@ -0,0 +1,13 @@
+import { useMemo as i } from "react";
+import { useTheme as f } from "../../../core/ThemeProvider/ThemeProvider.js";
+import { getContrastSafeColor as l } from "../../../../../libs/design-core/dist/lib/colorContrast/colorContrast.js";
+import { primitiveColorTokens as e } from "../../../../../libs/design-core/dist/lib/themes/js/primitives/primitive.colors.js";
+const C = (r, t) => {
+  const { colorScheme: c } = f(), m = c === "dark" ? e.dark.grey["050"] : e.light.grey["050"];
+  return i(() => t ? r.map(
+    (o) => o.color ? { ...o, color: l(o.color, m) } : o
+  ) : r, [r, t, m]);
+};
+export {
+  C as useContrastSafeSeries
+};

package/dist/lib/Components/visualization/DonutChart/hooks/useDonutLoadingAnimation.d.ts

@@ -0,0 +1,8 @@
+type DonutLoadingAnimationResult = {
+    animationStyle: string;
+    keyframe: string;
+    getSegmentDelay: (midAngle: number) => string;
+};
+export declare const useDonutLoadingAnimation: () => DonutLoadingAnimationResult;
+export {};
+//# sourceMappingURL=useDonutLoadingAnimation.d.ts.map

package/dist/lib/Components/visualization/DonutChart/hooks/useDonutLoadingAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDonutLoadingAnimation.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/DonutChart/hooks/useDonutLoadingAnimation.ts"],"names":[],"mappings":"AAQA,KAAK,2BAA2B,GAAG;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CAC/C,CAAC;AAEF,eAAO,MAAM,wBAAwB,QAAO,2BAe3C,CAAC"}

package/dist/lib/Components/visualization/DonutChart/hooks/useDonutLoadingAnimation.js

@@ -0,0 +1,16 @@
+import { useId as i, useMemo as a } from "react";
+import { chartConfig as r } from "../../config.js";
+const { loading: n } = r.donut, o = 2 * Math.PI, c = () => {
+  const e = `donut-loading-wave-${i().replaceAll(":", "")}`;
+  return a(
+    () => ({
+      animationStyle: `${e} ${n.durationInSeconds}s ${n.easing} infinite`,
+      keyframe: `@keyframes ${e} { 0%, 100% { opacity: 1; } 50% { opacity: ${n.minOpacity}; } } @media (prefers-reduced-motion: reduce) { @keyframes ${e} { 0%, 100% { opacity: 1; } } }`,
+      getSegmentDelay: (t) => `-${(o - t) / o * n.durationInSeconds}s`
+    }),
+    [e]
+  );
+};
+export {
+  c as useDonutLoadingAnimation
+};

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

@@ -0,0 +1,7 @@
+export { DonutChart } from './DonutChart';
+export { DonutChartCenter } from './DonutChartCenter';
+export { DonutChartDescription } from './DonutChartDescription';
+export { DonutChartTitle } from './DonutChartTitle';
+export type { DonutActiveSegment, DonutChartCenterProps, DonutChartDescriptionProps, DonutChartProps, DonutChartTitleProps, DonutSegment, DonutSeriesOptions, DonutSeriesResult, } from './types';
+export { prepareDonutSeries, useDonutSeries } from './useDonutSeries';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/DonutChart/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EACV,kBAAkB,EAClB,qBAAqB,EACrB,0BAA0B,EAC1B,eAAe,EACf,oBAAoB,EACpB,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,GAClB,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

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

@@ -0,0 +1,172 @@
+import { ComponentPropsWithRef, ReactNode } from 'react';
+import { chartConfig } from '../config';
+export type DonutSize = keyof typeof chartConfig.donut.size;
+/**
+ * The title's own typography scale.
+ */
+export type DonutTitleSize = 'md' | 'sm';
+/** Ring dimensions for a given size, in SVG user units. */
+export type DonutGeometry = Readonly<{
+    box: number;
+    innerRadius: number;
+    outerRadius: number;
+    cornerRadius: number;
+    padAngle: number;
+    hoverOffset: number;
+    /** Shortest arc a segment may be drawn with, measured at the mid-radius. */
+    minSegmentArc: number;
+}>;
+/** A placeholder segment for the empty ring and loading wave. */
+export type DonutPlaceholderSegment = {
+    id: string;
+    path: string;
+    midAngle: number;
+};
+/** A segment ready to draw: its path is centered at the origin. */
+export type DonutRingSegment = {
+    id: string;
+    path: string;
+    color: string;
+    percent: number;
+    midAngle: number;
+    hoverTranslate: {
+        x: number;
+        y: number;
+    };
+    hoverEnabled: boolean;
+};
+/** A single part-to-whole segment. */
+export type DonutSegment = {
+    /**
+     * Stable identifier for the segment.
+     */
+    id: string;
+    /**
+     * Human-readable label.
+     */
+    label: string;
+    /**
+     * Raw value; the percent is computed from the total.
+     */
+    value: number;
+    /**
+     * Optional CSS color override; defaults to a neutral grey.
+     */
+    color?: string;
+};
+/** How `useDonutSeries` folds a raw series' long tail into a single segment. */
+export type DonutSeriesOptions = {
+    /**
+     * Segments below this share of the total are grouped into the "other" segment.
+     * A fraction of the total, not a percentage: pass `0.04` for 4%. `0` groups
+     * nothing. The top segment is always kept, so `1` or above groups everything
+     * but the largest rather than collapsing the chart.
+     * @default 0
+     */
+    groupBelowShare?: number;
+    /**
+     * Max segments kept before the tail is grouped; `0` disables grouping. A soft
+     * cap: a tail of a single segment is kept as-is, so the result can hold
+     * `maxSegments + 1` segments.
+     * @default 7
+     */
+    maxSegments?: number;
+    /**
+     * Shape of the aggregate segment; `value` is always computed.
+     */
+    other: {
+        /** @default 'other' */
+        id?: DonutSegment['id'];
+        label: DonutSegment['label'];
+        /** Optional color override; defaults to the chart's neutral segment color. */
+        color?: DonutSegment['color'];
+    };
+};
+export type DonutSeriesResult = {
+    /**
+     * Kept segments, sorted by value descending, plus the appended `other` segment.
+     */
+    segments: DonutSegment[];
+    /**
+     * The raw segments folded into `other`; empty when nothing was grouped.
+     */
+    others: DonutSegment[];
+};
+/** A segment enriched with its computed share of the series total. */
+export type DonutActiveSegment = DonutSegment & {
+    /**
+     * Exact share of the total, 0–100. Use it to compute; it is unrounded and can
+     * carry float artifacts (`7.000000000000001`), so prefer `percentLabel` to display.
+     */
+    percent: number;
+    /** Display-ready `percent`, rounded to at most 1 decimal and suffixed, e.g. `7%`. */
+    percentLabel: string;
+};
+export type DonutChartProps = {
+    /**
+     * Part-to-whole segments, rendered in order.
+     */
+    series: DonutSegment[];
+    /**
+     * Ring size. `md` is 168px, `sm` is 80px.
+     * @default 'md'
+     */
+    size?: DonutSize;
+    /**
+     * Accessible label describing what the chart represents, exposed to
+     * assistive tech via the SVG `role="img"`.
+     * @default 'Donut chart'
+     */
+    ariaLabel?: string;
+    /**
+     * Whether the chart is loading. When true, renders an animated placeholder
+     * wave instead of the real segments, regardless of `series`.
+     * @default false
+     */
+    loading?: boolean;
+    /** Controlled active segment id. Active is data-driven, not a state variant. */
+    activeId?: string | null;
+    /**
+     * Default active segment id for uncontrolled mode.
+     */
+    defaultActiveId?: string | null;
+    /**
+     * When `true`, each segment's `color` is nudged so its HSL lightness differs
+     * from the surface background by at least 20 units.
+     *
+     * Colors that already meet that minimum are left untouched. Useful when the
+     * segment palette includes colors that are close in lightness to the app background.
+     * @default false
+     */
+    enableColorContrast?: boolean;
+    /** Fired when the active segment changes (hover or external reset). */
+    onActiveIdChange?: (id: string | null) => void;
+    /**
+     * Renders the resting center content. Return a top-level `DonutChartCenter`
+     * wrapping `DonutChartTitle` and/or `DonutChartDescription`. Receives
+     * `{ activeSegment, series }`; `activeSegment` is enriched with its computed
+     * `percent`/`percentLabel` and is `null` when nothing is active.
+     */
+    renderCenter?: (params: {
+        activeSegment: DonutActiveSegment | null;
+        series: DonutSegment[];
+    }) => ReactNode;
+    /**
+     * Optional active center content on segment hover, wrapped in a top-level
+     * `DonutChartCenter`. When set, the chart crossfades between the resting
+     * slot (`renderCenter`, called with `activeSegment: null`) and this active slot.
+     */
+    renderCenterActive?: (params: {
+        activeSegment: DonutActiveSegment;
+    }) => ReactNode;
+};
+export type DonutChartCenterProps = ComponentPropsWithRef<'div'>;
+export type DonutChartTitleProps = ComponentPropsWithRef<'div'> & {
+    /**
+     * The title's own typography scale.
+     * @default 'md'
+     */
+    size?: DonutTitleSize;
+};
+export type DonutChartDescriptionProps = ComponentPropsWithRef<'div'>;
+//# sourceMappingURL=types.d.ts.map