@ledgerhq/lumen-ui-react 0.1.55 → 0.1.57

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/DonutChart/types.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,3 @@
+export { useDonutSeries } from './useDonutSeries';
+export { prepareDonutSeries } from './utils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/DonutChart/useDonutSeries/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC"}

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

@@ -0,0 +1,10 @@
+import { DonutSegment, DonutSeriesOptions, DonutSeriesResult } from '../types';
+/**
+ * Prepares a raw series for the ring: sorts by value descending and folds the
+ * long tail into a single aggregate segment.
+ *
+ * The result is memoized on `segments` identity, so hoist or memoize the array
+ * you pass in if you rely on a stable `segments` reference downstream.
+ */
+export declare const useDonutSeries: (segments: DonutSegment[], options: DonutSeriesOptions) => DonutSeriesResult;
+//# sourceMappingURL=useDonutSeries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDonutSeries.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/DonutChart/useDonutSeries/useDonutSeries.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAIlB;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GACzB,UAAU,YAAY,EAAE,EACxB,SAAS,kBAAkB,KAC1B,iBAeF,CAAC"}

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

@@ -0,0 +1,16 @@
+import { useMemo as u } from "react";
+import { prepareDonutSeries as i } from "./utils.js";
+const l = (o, p) => {
+  const { groupBelowShare: e, maxSegments: r, other: s } = p, { id: t, label: m, color: n } = s;
+  return u(
+    () => i(o, {
+      groupBelowShare: e,
+      maxSegments: r,
+      other: { id: t, label: m, color: n }
+    }),
+    [o, e, r, t, m, n]
+  );
+};
+export {
+  l as useDonutSeries
+};

package/dist/lib/Components/visualization/DonutChart/useDonutSeries/utils.d.ts

@@ -0,0 +1,9 @@
+import { DonutSegment, DonutSeriesOptions, DonutSeriesResult } from '../types';
+/**
+ * Sorts a raw series by value descending and folds its long tail into a single
+ * aggregate segment. Pure counterpart of `useDonutSeries`. The aggregate keeps
+ * its color unset unless `other.color` is given, so the ring paints it with the
+ * neutral default like any colorless segment.
+ */
+export declare const prepareDonutSeries: (segments: DonutSegment[], options: DonutSeriesOptions) => DonutSeriesResult;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/Components/visualization/DonutChart/useDonutSeries/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/DonutChart/useDonutSeries/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AA4ClB;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAC7B,UAAU,YAAY,EAAE,EACxB,SAAS,kBAAkB,KAC1B,iBAsCF,CAAC"}

package/dist/lib/Components/visualization/DonutChart/useDonutSeries/utils.js

@@ -0,0 +1,46 @@
+import { chartConfig as g } from "../../config.js";
+const {
+  maxSegments: d,
+  otherId: x,
+  minGroupedSegments: S,
+  minKeptSegments: f
+} = g.donut.series, p = (t) => t.reduce((n, s) => n + Math.max(s.value, 0), 0), v = (t, n, s) => {
+  const a = p(t), r = n > 0 && a > 0 ? n * a : 0, e = r > 0 ? t.findIndex((o) => Math.max(o.value, 0) < r) : -1;
+  return Math.max(
+    f,
+    Math.min(
+      s,
+      e === -1 ? t.length : e
+    )
+  );
+}, I = (t, n) => {
+  const {
+    groupBelowShare: s = 0,
+    maxSegments: a = d,
+    other: r
+  } = n, e = [...t].sort((m, c) => c.value - m.value);
+  if (a <= 0)
+    return { segments: e, others: [] };
+  const o = v(e, s, a), l = e.slice(o);
+  if (l.length < S)
+    return { segments: e, others: [] };
+  const { id: u = x, label: i, color: h } = r;
+  return {
+    segments: [
+      ...e.slice(0, o),
+      {
+        id: u,
+        label: i,
+        color: h,
+        value: l.reduce(
+          (m, c) => m + Math.max(c.value, 0),
+          0
+        )
+      }
+    ],
+    others: l
+  };
+};
+export {
+  I as prepareDonutSeries
+};

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

@@ -0,0 +1,37 @@
+import { DonutGeometry, DonutPlaceholderSegment, DonutRingSegment, DonutSegment, DonutSize } from './types';
+export declare const DONUT_GEOMETRY: Readonly<Record<DonutSize, DonutGeometry>>;
+export declare const resolveSegmentColor: (segment: DonutSegment) => string;
+export declare const getDonutViewBox: (geometry: DonutGeometry) => string;
+export declare const getCenterContentInset: (size: DonutSize) => number;
+/** Max width (px) for center content, inner diameter minus inset on both sides. */
+export declare const getCenterMaxWidth: (size: DonutSize) => number;
+/** Round a percent to at most 1 decimal. */
+export declare const roundPercent: (percent: number) => number;
+/**
+ * Display-ready percent, e.g. `7%`, `7.3%` or `<0.1%`. Rounding here keeps
+ * float artifacts — `7 / 100 * 100` is `7.000000000000001` — out of labels
+ * while leaving the exact `percent` intact for consumers who compute with it.
+ */
+export declare const formatPercentLabel: (percent: number) => string;
+/** Percent (0–100) of the total per segment. Negatives count as 0; a zero total yields all zeros. */
+export declare const getSegmentPercents: (series: DonutSegment[]) => number[];
+/**
+ * Drawing weights summing to 1, none below `minShare`, so a value too small to
+ * see still gets a visible sliver. The room comes out of the segments above the
+ * minimum, which shrinks them and can push another under it — hence the loop.
+ */
+export declare const applyMinSegmentShare: (values: number[], minShare: number) => number[];
+/**
+ * One ring segment per drawable series entry, in series order, clockwise from
+ * 12 o'clock. Zero and negative segments are dropped so they don't emit
+ * degenerate paths; percents are still computed against the full series total,
+ * and what survives is drawn at `minSegmentArc` or wider.
+ */
+export declare const buildRingSegments: (series: DonutSegment[], geometry: DonutGeometry) => DonutRingSegment[];
+/**
+ * Fixed placeholder segments shared by the empty ring and the loading wave: a
+ * full ring (values sum to 100) of unequal segments separated only by the
+ * same small `padAngle` gaps as real segments — no missing segment.
+ */
+export declare const buildPlaceholderSegments: (geometry: DonutGeometry) => DonutPlaceholderSegment[];
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/DonutChart/utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EACvB,gBAAgB,EAChB,YAAY,EACZ,SAAS,EACV,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,aAAa,CAAC,CAC9C,CAAC;AAEzB,eAAO,MAAM,mBAAmB,GAAI,SAAS,YAAY,KAAG,MACJ,CAAC;AAEzD,eAAO,MAAM,eAAe,GAAI,UAAU,aAAa,KAAG,MAIzD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,MAAM,SAAS,KAAG,MACZ,CAAC;AAE7C,mFAAmF;AACnF,eAAO,MAAM,iBAAiB,GAAI,MAAM,SAAS,KAAG,MACoB,CAAC;AAEzE,4CAA4C;AAC5C,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,KAAG,MAChB,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,KAAG,MAMpD,CAAC;AAEF,qGAAqG;AACrG,eAAO,MAAM,kBAAkB,GAAI,QAAQ,YAAY,EAAE,KAAG,MAAM,EAMjE,CAAC;AAeF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,MAAM,EAAE,EAChB,UAAU,MAAM,KACf,MAAM,EAuBR,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,YAAY,EAAE,EACtB,UAAU,aAAa,KACtB,gBAAgB,EAkDlB,CAAC;AAiBF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,UAAU,aAAa,KACtB,uBAAuB,EA6BzB,CAAC"}