jfs-components 0.0.72 → 0.0.73

package/lib/module/components/CoverageBarComparison/CoverageBarComparison.js

@@ -0,0 +1,266 @@
+"use strict";
+
+import React from 'react';
+import { View, Text } from 'react-native';
+import Svg, { Rect } from 'react-native-svg';
+import { getVariableByName } from '../../design-tokens/figma-variables-resolver';
+import { useTokens } from '../../design-tokens/JFSThemeProvider';
+import { EMPTY_MODES } from '../../utils/react-utils';
+import MetricLegendItem from '../MetricLegendItem/MetricLegendItem';
+
+/**
+ * One entry in the {@link CoverageBarComparisonProps.bars} array.
+ *
+ * Each entry carries **both** the bar's data and its legend label, so the
+ * number of bars is intrinsically equal to the number of legend items.
+ * There is no separate `legends` prop — that is by design.
+ */
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Default per-index `Emphasis / DataViz` modes applied when the caller does
+ * not provide its own override. Ascends Low → Medium → High so the natural
+ * "Current vs Recommended" two-bar story matches the Figma reference (left
+ * = lighter / Low, right = darker / High). Cycles for >3 bars.
+ */
+const DEFAULT_EMPHASIS_CYCLE = ['Low', 'Medium', 'High'];
+function defaultEmphasisFor(index, total) {
+  if (total <= 1) {
+    return 'High';
+  }
+  if (total === 2) {
+    return index === 0 ? 'Low' : 'High';
+  }
+  return DEFAULT_EMPHASIS_CYCLE[index % DEFAULT_EMPHASIS_CYCLE.length];
+}
+const DEFAULT_BARS = [{
+  value: 40,
+  label: '₹1L (40%)',
+  legend: 'Current coverage'
+}, {
+  value: 100,
+  label: '₹2.5L (100%)',
+  legend: 'Recommended coverage'
+}];
+const toNumber = (value, fallback) => {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : fallback;
+  }
+  if (typeof value === 'string') {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+};
+const toFontWeight = (value, fallback) => {
+  if (typeof value === 'number') {
+    return String(value);
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  return fallback;
+};
+/**
+ * Bar shape rendered with `react-native-svg`. The wrapper measures its width
+ * via `onLayout` so the SVG can use concrete dimensions (RN SVG does not
+ * resolve percentage shape attributes when the parent SVG itself has a
+ * percentage `width`).
+ */
+function BarShape({
+  height,
+  color,
+  radius
+}) {
+  const [width, setWidth] = React.useState(0);
+  const handleLayout = React.useCallback(event => {
+    const next = event.nativeEvent.layout.width;
+    setWidth(prev => prev === next ? prev : next);
+  }, []);
+  if (height <= 0) {
+    return /*#__PURE__*/_jsx(View, {
+      onLayout: handleLayout,
+      style: {
+        width: '100%',
+        height: 0
+      }
+    });
+  }
+  const safeRadius = Math.max(0, Math.min(radius, width / 2, height / 2));
+  return /*#__PURE__*/_jsx(View, {
+    onLayout: handleLayout,
+    style: {
+      width: '100%',
+      height,
+      minWidth: 1
+    },
+    children: width > 0 ? /*#__PURE__*/_jsx(Svg, {
+      width: width,
+      height: height,
+      children: /*#__PURE__*/_jsx(Rect, {
+        x: 0,
+        y: 0,
+        width: width,
+        height: height,
+        rx: safeRadius,
+        ry: safeRadius,
+        fill: color
+      })
+    }) : null
+  });
+}
+
+/**
+ * `CoverageBarComparison` renders a small vertical-bar chart that compares
+ * 2+ values side by side, with a legend row directly below where each item
+ * is intrinsically tied to one bar.
+ *
+ * Cohesiveness guarantees:
+ * - The legend row is **derived** from the same `bars` prop, so the count
+ *   and order can never desynchronise from the chart.
+ * - Each bar's color, its tokenized `Emphasis / DataViz` mode and its
+ *   legend indicator dot are the same value.
+ *
+ * Bars are drawn with `react-native-svg` (`<Rect>` with `rx`), and the
+ * fonts/spacing/colors are sourced from the Figma `valueBar/*` and
+ * `coverageBarComparison/*` tokens.
+ *
+ * @component
+ */
+function CoverageBarComparison({
+  bars = DEFAULT_BARS,
+  max,
+  height = 100,
+  legendGap = 12,
+  modes: propModes = EMPTY_MODES,
+  style,
+  chartStyle,
+  legendStyle,
+  labelStyle,
+  accessibilityLabel
+}) {
+  const {
+    modes: globalModes
+  } = useTokens();
+  const modes = React.useMemo(() => ({
+    ...globalModes,
+    ...propModes
+  }), [globalModes, propModes]);
+  const wrapGap = toNumber(getVariableByName('coverageBarComparison/wrap/gap', modes), 6);
+  const valueBarGap = toNumber(getVariableByName('valueBar/gap', modes), 4);
+  const barRadius = toNumber(getVariableByName('valueBar/bar/radius', modes), 10);
+  const fontFamily = getVariableByName('valueBar/fontFamily', modes) ?? 'JioType Var';
+  const fontSize = toNumber(getVariableByName('valueBar/fontSize', modes), 12);
+  const lineHeight = toNumber(getVariableByName('valueBar/lineHeight', modes), 16);
+  const fontWeight = toFontWeight(getVariableByName('valueBar/fontWeight', modes), '700');
+  const foreground = getVariableByName('valueBar/foreground', modes) ?? '#000000';
+  const labelHeight = lineHeight;
+  const barAreaHeight = Math.max(0, height - labelHeight - valueBarGap);
+  const total = bars.length;
+  const computedMax = max ?? bars.reduce((acc, bar) => Math.max(acc, bar.value), 0);
+  const safeMax = computedMax > 0 ? computedMax : 1;
+  const resolvedBars = React.useMemo(() => bars.map((bar, index) => {
+    const barModes = {
+      ...modes,
+      'Emphasis / DataViz': defaultEmphasisFor(index, total),
+      ...(bar.modes || {})
+    };
+    const ratio = Math.max(0, Math.min(1, bar.value / safeMax));
+    const tokenColor = getVariableByName('valueBar/bar/background', barModes) ?? '#c9b7ff';
+    const bgColor = bar.color ?? tokenColor;
+    return {
+      original: bar,
+      index,
+      barModes,
+      ratio,
+      bgColor
+    };
+  }), [bars, modes, safeMax, total]);
+  const computedLabelStyle = {
+    color: foreground,
+    fontFamily,
+    fontSize,
+    lineHeight,
+    fontWeight,
+    textAlign: 'center'
+  };
+  const defaultAccessibilityLabel = accessibilityLabel ?? `Comparison of ${total} bar${total === 1 ? '' : 's'}: ` + bars.map((bar, i) => {
+    const legend = typeof bar.legend === 'string' ? bar.legend : `bar ${i + 1}`;
+    return `${legend} ${bar.value}`;
+  }).join(', ');
+  return /*#__PURE__*/_jsxs(View, {
+    accessibilityLabel: defaultAccessibilityLabel,
+    style: [{
+      width: '100%'
+    }, style],
+    children: [/*#__PURE__*/_jsx(View, {
+      accessibilityRole: "image",
+      style: [{
+        flexDirection: 'row',
+        alignItems: 'flex-end',
+        height,
+        gap: wrapGap,
+        width: '100%'
+      }, chartStyle],
+      children: resolvedBars.map(({
+        original,
+        index,
+        ratio,
+        bgColor
+      }) => {
+        const barHeightPx = Math.max(0, barAreaHeight * ratio);
+        const valueBarTotalHeight = labelHeight + valueBarGap + barHeightPx;
+        const hasLabel = original.label !== undefined && original.label !== null && original.label !== false;
+        return /*#__PURE__*/_jsxs(View, {
+          accessibilityLabel: original.accessibilityLabel,
+          style: {
+            flex: 1,
+            flexDirection: 'column',
+            alignItems: 'stretch',
+            justifyContent: 'flex-end',
+            height: valueBarTotalHeight,
+            gap: valueBarGap,
+            minWidth: 1
+          },
+          children: [hasLabel ? /*#__PURE__*/_jsx(Text, {
+            numberOfLines: 1,
+            style: [computedLabelStyle, labelStyle],
+            children: original.label
+          }) : null, /*#__PURE__*/_jsx(BarShape, {
+            height: barHeightPx,
+            color: bgColor,
+            radius: barRadius
+          })]
+        }, original.key ?? `bar-${index}`);
+      })
+    }), /*#__PURE__*/_jsx(View, {
+      style: [{
+        marginTop: legendGap,
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        width: '100%'
+      }, legendStyle],
+      children: resolvedBars.map(({
+        original,
+        index,
+        barModes,
+        bgColor
+      }) => {
+        const indicatorOverride = original.color ? bgColor : undefined;
+        return /*#__PURE__*/_jsx(MetricLegendItem, {
+          label: original.legend,
+          value: original.legendValue,
+          modes: barModes,
+          ...(indicatorOverride !== undefined ? {
+            indicatorColor: indicatorOverride
+          } : {}),
+          style: {
+            flex: 1,
+            minWidth: 0
+          }
+        }, original.key ?? `legend-${index}`);
+      })
+    })]
+  });
+}
+export default CoverageBarComparison;

package/lib/module/components/CoverageRing/CoverageRing.js

@@ -0,0 +1,136 @@
+"use strict";
+
+import React from 'react';
+import { View } from 'react-native';
+import { getVariableByName } from '../../design-tokens/figma-variables-resolver';
+import { useTokens } from '../../design-tokens/JFSThemeProvider';
+import { EMPTY_MODES, cloneChildrenWithModes } from '../../utils/react-utils';
+import Button from '../Button/Button';
+import CircularProgressBar from '../CircularProgressBar/CircularProgressBar';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const toNumber = (value, fallback) => {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : fallback;
+  }
+  if (typeof value === 'string') {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+};
+const clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+
+// The Figma "Coverage Ring" pairs a `circularProgressBar Size: M` ring with a
+// `Button / Size: S` Secondary button. Locking these in as component defaults
+// keeps the visual identical to the Figma reference when the caller supplies
+// only their own brand/theme modes — caller modes are still merged on top so
+// any of these can be overridden per-instance.
+const COMPONENT_DEFAULT_MODES = Object.freeze({
+  'circularProgressBar Size': 'M',
+  'Button / Size': 'S'
+});
+
+// Match the Figma source: regardless of the overall AppearanceBrand/Emphasis
+// the caller picks (used to colour the ring), the Coverage Ring CTA renders
+// with the Secondary brand at Medium emphasis — which resolves to the
+// pale-lavender background (`#dbcfff`) + deep-purple foreground (`#5d00b5`)
+// shown in Figma. Mirrors the pattern used by `CardFinancialCondition.tsx`.
+const BUTTON_FORCED_BRAND = Object.freeze({
+  AppearanceBrand: 'Secondary',
+  Emphasis: 'Medium'
+});
+
+/**
+ * `CoverageRing` renders a single-purpose insight: how many items out of a
+ * total have been covered (e.g. "4 of 7 benefits availed"), paired with a
+ * call-to-action button below the ring.
+ *
+ * It composes the existing {@link CircularProgressBar} (in its `M` size so
+ * there is room for a caption + value inside the ring) and {@link Button}
+ * (in its `S`, Secondary brand variant) — both driven by the same design
+ * tokens used by the rest of the design system.
+ *
+ * The ring fill is derived from `value / total`, so the percentage, the
+ * displayed `"{value} of {total}"` label and the support caption stay in
+ * sync automatically. There is no separate `progress` prop.
+ *
+ * @component
+ */
+function CoverageRing({
+  value = 4,
+  total = 7,
+  supportText = 'Benefits availed',
+  valueLabel,
+  actionLabel = 'Learn more',
+  onActionPress,
+  actionProps,
+  action,
+  children,
+  modes: propModes = EMPTY_MODES,
+  style,
+  supportTextStyle,
+  valueStyle,
+  accessibilityLabel,
+  ...rest
+}) {
+  const {
+    modes: globalModes
+  } = useTokens();
+
+  // Merge order matches the rest of the design system (see `Gauge.tsx`):
+  // 1. Component-level defaults — the lowest-priority safety net.
+  // 2. Global modes from `JFSThemeProvider` — app-wide theme.
+  // 3. Caller-supplied `propModes` — highest priority, overrides everything.
+  const modes = React.useMemo(() => ({
+    ...COMPONENT_DEFAULT_MODES,
+    ...globalModes,
+    ...propModes
+  }), [propModes, globalModes]);
+
+  // Force the Secondary brand on the button only; the ring stays on whatever
+  // brand the caller selected. Done via a forcedModes layer so callers can't
+  // accidentally bring back a Primary-coloured CTA through their own modes.
+  const buttonModes = React.useMemo(() => ({
+    ...modes,
+    ...BUTTON_FORCED_BRAND
+  }), [modes]);
+  const safeTotal = total > 0 ? total : 0;
+  const clampedValue = clamp(value, 0, safeTotal);
+  const progressPercent = safeTotal > 0 ? clampedValue / safeTotal * 100 : 0;
+  const computedValueLabel = valueLabel ?? `${clampedValue} of ${safeTotal}`;
+  const gap = toNumber(getVariableByName('coverageRing/gap', modes), 16);
+  const containerStyle = {
+    alignItems: 'center',
+    gap
+  };
+
+  // Custom action slot resolution order: explicit `action` prop wins over
+  // `children`. We pass `modes` down via cloneChildrenWithModes so any
+  // token-driven child (e.g. a custom `<Button>`) inherits the parent theme.
+  const customAction = action ?? children;
+  const hasCustomAction = customAction !== undefined && customAction !== null;
+  const defaultAccessibilityLabel = accessibilityLabel ?? `${supportText}, ${computedValueLabel}`;
+  return /*#__PURE__*/_jsxs(View, {
+    accessibilityLabel: defaultAccessibilityLabel,
+    style: [containerStyle, style],
+    ...rest,
+    children: [/*#__PURE__*/_jsx(CircularProgressBar, {
+      state: "Active",
+      value: progressPercent,
+      valueLabel: computedValueLabel,
+      supportText: supportText,
+      supportTextStyle: supportTextStyle,
+      valueStyle: valueStyle,
+      modes: modes,
+      accessibilityLabel: `${supportText}, ${computedValueLabel}`
+    }), hasCustomAction ? cloneChildrenWithModes(customAction, buttonModes) : /*#__PURE__*/_jsx(Button, {
+      label: actionLabel,
+      modes: buttonModes,
+      ...(onActionPress !== undefined ? {
+        onPress: onActionPress
+      } : {}),
+      ...actionProps
+    })]
+  });
+}
+export default CoverageRing;

package/lib/module/components/DonutChart/DonutChart.js

@@ -0,0 +1,303 @@
+"use strict";
+
+import React from 'react';
+import { StyleSheet, Text, View } from 'react-native';
+import Svg, { Circle } from 'react-native-svg';
+import { getVariableByName } from '../../design-tokens/figma-variables-resolver';
+import { useTokens } from '../../design-tokens/JFSThemeProvider';
+import { EMPTY_MODES, flattenChildren } from '../../utils/react-utils';
+
+/**
+ * Per-segment data definition for the data-driven `segments` prop.
+ *
+ * Each segment renders one arc on the donut ring. `value` controls the
+ * arc's angular share (its weight relative to the sum of all values).
+ * Use `modes` per segment to override the default `Appearance / DataViz`
+ * mode (the parent injects per-index defaults of `Senary`, `Primary`,
+ * `Secondary`, `Tertiary`, `Quaternary`, `Quinary`, then cycles).
+ */
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const DEFAULT_APPEARANCE_CYCLE = ['Senary', 'Primary', 'Secondary', 'Tertiary', 'Quaternary', 'Quinary'];
+const DEFAULT_SEGMENTS = [{
+  value: 1
+}, {
+  value: 1
+}, {
+  value: 1
+}, {
+  value: 1
+}, {
+  value: 1
+}, {
+  value: 1
+}];
+const STROKE_WIDTH_RATIO = 18 / 194;
+const toNumber = (value, fallback) => {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : fallback;
+  }
+  if (typeof value === 'string') {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+};
+const toFontWeight = (value, fallback) => {
+  if (typeof value === 'number') {
+    return String(value);
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  return fallback;
+};
+
+/**
+ * Compute the default `Appearance / DataViz` mode for a segment at `index`.
+ * Cycles through {@link DEFAULT_APPEARANCE_CYCLE} so any number of segments
+ * gets a sensible default (Senary, Primary, Secondary, Tertiary,
+ * Quaternary, Quinary, then repeats).
+ */
+function defaultAppearanceFor(index) {
+  return DEFAULT_APPEARANCE_CYCLE[index % DEFAULT_APPEARANCE_CYCLE.length];
+}
+
+/**
+ * Resolve a single segment's stroke color through the design tokens. Honors
+ * any explicit `color` override, then falls back to `dataViz/bg` for the
+ * supplied `modes`, then to the Figma reference purple.
+ */
+function resolveSegmentColor(color, modes) {
+  if (color) return color;
+  return getVariableByName('dataViz/bg', modes) ?? '#5d00b5';
+}
+
+/**
+ * Coerce a slot child into a `DonutChartSegmentData` so the rendering path
+ * is uniform. Reads `value`, `color`, `modes` and `accessibilityLabel`
+ * from the child's props and ignores anything else.
+ */
+function segmentDataFromChild(child, fallbackKey) {
+  const props = child.props ?? {};
+  return {
+    key: child.key ?? fallbackKey,
+    value: toNumber(props.value, 1),
+    color: typeof props.color === 'string' ? props.color : undefined,
+    modes: props.modes,
+    accessibilityLabel: props.accessibilityLabel
+  };
+}
+/**
+ * Inert helper used purely to author donut segments declaratively as
+ * `DonutChart.Segment` slot children. The parent reads its props and
+ * renders the actual SVG arcs — this component never renders anything by
+ * itself.
+ */
+function DonutChartSegment(_) {
+  return null;
+}
+
+/**
+ * `DonutChart` renders a circular ring split into categorical segments.
+ * It is the segmented counterpart of `CircularProgressBar`: there is **no
+ * track background** behind the segments — the colored ring *is* the
+ * data, and each slice is a sibling category rather than a directional or
+ * temporal value.
+ *
+ * The default 6-segment layout receives per-index `Appearance / DataViz`
+ * defaults (segment 1 → `Senary`, 2 → `Primary`, 3 → `Secondary`, 4 →
+ * `Tertiary`, 5 → `Quaternary`, 6 → `Quinary`) so the wheel reads as one
+ * concept split into six color-coded categories. Override `modes` per
+ * segment to remix appearances, or set `Emphasis / DataViz` on the
+ * parent `modes` to dim or brighten the whole wheel at once.
+ *
+ * @component
+ * @param {DonutChartProps} props
+ */
+function DonutChart({
+  segments,
+  value,
+  label,
+  children,
+  size = 194,
+  strokeWidth: strokeWidthProp,
+  gap = 0,
+  modes: propModes = EMPTY_MODES,
+  style,
+  valueStyle,
+  labelStyle,
+  accessibilityLabel
+}) {
+  const {
+    modes: globalModes
+  } = useTokens();
+  const modes = {
+    ...globalModes,
+    ...propModes
+  };
+  const strokeWidth = Math.max(1, toNumber(strokeWidthProp, Math.max(1, size * STROKE_WIDTH_RATIO)));
+  const radius = Math.max(0, (size - strokeWidth) / 2);
+  const center = size / 2;
+  const circumference = 2 * Math.PI * radius;
+  const gapLength = Math.max(0, gap) / 360 * circumference;
+  const slotChildren = flattenChildren(children).filter(child => /*#__PURE__*/React.isValidElement(child));
+  const slotSegmentChildren = slotChildren.filter(child => child.type === DonutChartSegment);
+  let resolvedSegments;
+  if (slotSegmentChildren.length > 0) {
+    resolvedSegments = slotSegmentChildren.map((child, index) => segmentDataFromChild(child, `segment-${index}`));
+  } else if (segments && segments.length > 0) {
+    resolvedSegments = segments;
+  } else {
+    resolvedSegments = DEFAULT_SEGMENTS;
+  }
+  const totalValue = resolvedSegments.reduce((sum, segment) => sum + Math.max(0, toNumber(segment.value, 0)), 0);
+  const hasData = totalValue > 0 && resolvedSegments.length > 0;
+  const arcs = hasData ? buildArcs({
+    segments: resolvedSegments,
+    totalValue,
+    circumference,
+    gapLength,
+    modes
+  }) : [];
+  const customCenterChildren = slotChildren.filter(child => child.type !== DonutChartSegment);
+  const hasChildrenSlot = customCenterChildren.length > 0;
+  const showValueLabel = !hasChildrenSlot && shouldRenderText(value);
+  const showLabel = !hasChildrenSlot && shouldRenderText(label);
+  const valueColor = getVariableByName('donutChart/value/color', modes) ?? getVariableByName('value/fg', modes) ?? '#000000';
+  const valueFontFamily = getVariableByName('donutChart/value/fontFamily', modes) ?? getVariableByName('value/fontFamily', modes) ?? 'JioType Var';
+  const valueFontSize = toNumber(getVariableByName('donutChart/value/fontSize', modes) ?? getVariableByName('value/fontSize', modes), 29);
+  const valueLineHeight = toNumber(getVariableByName('donutChart/value/lineHeight', modes) ?? getVariableByName('value/lineHeight', modes), 29);
+  const valueFontWeight = toFontWeight(getVariableByName('donutChart/value/fontWeight', modes) ?? getVariableByName('value/fontWeight', modes), '900');
+  const labelColor = getVariableByName('donutChart/label/color', modes) ?? getVariableByName('label/fg', modes) ?? '#000000';
+  const labelFontFamily = getVariableByName('donutChart/label/fontFamily', modes) ?? getVariableByName('label/fontFamily', modes) ?? 'JioType Var';
+  const labelFontSize = toNumber(getVariableByName('donutChart/label/fontSize', modes) ?? getVariableByName('label/fontSize', modes), 12);
+  const labelLineHeight = toNumber(getVariableByName('donutChart/label/lineHeight', modes) ?? getVariableByName('label/lineHeight', modes), 15.6);
+  const labelFontWeight = toFontWeight(getVariableByName('donutChart/label/fontWeight', modes) ?? getVariableByName('label/fontWeight', modes), '400');
+  const textWrapGap = toNumber(getVariableByName('donutChart/textWrap/gap', modes) ?? getVariableByName('textWrap/gap', modes), 7);
+  const containerStyle = {
+    alignItems: 'center',
+    height: size,
+    justifyContent: 'center',
+    position: 'relative',
+    width: size
+  };
+  return /*#__PURE__*/_jsxs(View, {
+    accessibilityRole: "image",
+    accessibilityLabel: accessibilityLabel,
+    style: [containerStyle, style],
+    children: [/*#__PURE__*/_jsx(Svg, {
+      width: size,
+      height: size,
+      viewBox: `0 0 ${size} ${size}`,
+      children: arcs.map(arc => /*#__PURE__*/_jsx(Circle, {
+        cx: center,
+        cy: center,
+        r: radius,
+        stroke: arc.color,
+        strokeWidth: strokeWidth,
+        fill: "none",
+        strokeDasharray: arc.dashArray,
+        strokeDashoffset: arc.dashOffset,
+        strokeLinecap: "butt",
+        rotation: "-90",
+        originX: center,
+        originY: center
+      }, arc.key))
+    }), hasChildrenSlot ? /*#__PURE__*/_jsx(View, {
+      pointerEvents: "box-none",
+      style: StyleSheet.absoluteFill,
+      children: /*#__PURE__*/_jsx(View, {
+        style: styles.centerSlot,
+        children: customCenterChildren
+      })
+    }) : showValueLabel || showLabel ? /*#__PURE__*/_jsxs(View, {
+      pointerEvents: "none",
+      style: [styles.centerSlot, {
+        gap: textWrapGap
+      }],
+      children: [showValueLabel ? /*#__PURE__*/_jsx(Text, {
+        style: [{
+          color: valueColor,
+          fontFamily: valueFontFamily,
+          fontSize: valueFontSize,
+          lineHeight: valueLineHeight,
+          fontWeight: valueFontWeight,
+          textAlign: 'center'
+        }, valueStyle],
+        numberOfLines: 1,
+        children: value
+      }) : null, showLabel ? /*#__PURE__*/_jsx(Text, {
+        style: [{
+          color: labelColor,
+          fontFamily: labelFontFamily,
+          fontSize: labelFontSize,
+          lineHeight: labelLineHeight,
+          fontWeight: labelFontWeight,
+          textAlign: 'center'
+        }, labelStyle],
+        numberOfLines: 1,
+        children: label
+      }) : null]
+    }) : null]
+  });
+}
+function shouldRenderText(node) {
+  return node !== undefined && node !== null && node !== false && node !== '';
+}
+/**
+ * Convert the resolved segment list into a list of stroke-dasharray /
+ * stroke-dashoffset descriptors that can be drawn as SVG `Circle`s. Each
+ * arc's length is its share of `circumference`, and its rotational offset
+ * is the cumulative offset of all preceding segments. Visual gaps are
+ * applied symmetrically — half a gap is shaved from each end of the arc
+ * so the visible separation between two segments equals one full `gap`.
+ */
+function buildArcs({
+  segments,
+  totalValue,
+  circumference,
+  gapLength,
+  modes
+}) {
+  const arcs = [];
+  const halfGap = gapLength / 2;
+  let cumulativeOffset = 0;
+  segments.forEach((segment, index) => {
+    const safeValue = Math.max(0, toNumber(segment.value, 0));
+    if (safeValue <= 0) {
+      return;
+    }
+    const arcLength = safeValue / totalValue * circumference;
+    const drawnLength = Math.max(0, arcLength - gapLength);
+    const segmentModes = {
+      ...modes,
+      'Appearance / DataViz': defaultAppearanceFor(index),
+      ...(segment.modes || {})
+    };
+    const color = resolveSegmentColor(segment.color, segmentModes);
+    const dashArray = `${drawnLength} ${circumference - drawnLength}`;
+    const dashOffset = -cumulativeOffset - halfGap;
+    arcs.push({
+      key: segment.key ?? `segment-${index}`,
+      color,
+      dashArray,
+      dashOffset
+    });
+    cumulativeOffset += arcLength;
+  });
+  return arcs;
+}
+const styles = StyleSheet.create({
+  centerSlot: {
+    alignItems: 'center',
+    bottom: 0,
+    justifyContent: 'center',
+    left: 0,
+    position: 'absolute',
+    right: 0,
+    top: 0
+  }
+});
+DonutChart.Segment = DonutChartSegment;
+export { DonutChartSegment };
+export default DonutChart;