jfs-components 0.1.0 → 0.1.8

package/lib/module/components/PdpCcCard/PdpCcCard.js

@@ -0,0 +1,267 @@
+"use strict";
+
+import React, { useMemo } from 'react';
+import { View, Text, Pressable, StyleSheet } from 'react-native';
+import { getVariableByName } from '../../design-tokens/figma-variables-resolver';
+import { EMPTY_MODES, cloneChildrenWithModes } from '../../utils/react-utils';
+import Title from '../Title/Title';
+import Divider from '../Divider/Divider';
+import Button from '../Button/Button';
+import Image from '../Image/Image';
+import Icon from '../Icon/Icon';
+
+/**
+ * A single metric column inside the card's stats row: a small title, a bold
+ * value and an optional muted caption.
+ */
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * PdpCcCard — Figma node 5352:935 ("PDP cc card").
+ *
+ * A centered white product/PDP card composed from the shared design-system
+ * primitives so it stays in sync with the rest of the library:
+ *
+ *  - **Media** — a top image slot (`Image`, rounded via `image/radius`). Pass
+ *    `imageSource` for the default image or `media` for a full slot override.
+ *  - **Title** — a centered headline + subtitle rendered through the shared
+ *    {@link Title} component (`title/*`, `pageSubtitle/*` tokens).
+ *  - **Metrics** — a row of {@link PdpCcCardMetric} columns (title / value /
+ *    caption) separated by vertical `Divider`s (`metricdata/*` tokens).
+ *  - **CTA** — a small tonal {@link Button} (`Button / Size: S`,
+ *    `AppearanceBrand: Secondary`, `Emphasis: Medium`) with a leading icon.
+ *
+ * All defaults can be overridden via `modes`.
+ */
+function PdpCcCard({
+  imageSource,
+  imageWidth = 100,
+  imageHeight = 60,
+  media,
+  title = 'Title',
+  subtitle = 'Subtitle',
+  metrics = DEFAULT_METRICS,
+  buttonLabel = 'button',
+  buttonIcon = 'ic_add_circle',
+  onButtonPress,
+  button,
+  showButton = true,
+  onPress,
+  width = 344,
+  modes = EMPTY_MODES,
+  style,
+  accessibilityLabel
+}) {
+  const tokens = useMemo(() => resolveTokens(modes), [modes]);
+
+  // The CTA uses the brand "Secondary" appearance at "Medium" emphasis (lilac
+  // fill + purple label) and the small size — matching the design. A
+  // consumer-supplied `modes` value still wins via spread order.
+  const ctaModes = useMemo(() => ({
+    AppearanceBrand: 'Secondary',
+    Emphasis: 'Medium',
+    'Button / Size': 'S',
+    ...modes
+  }), [modes]);
+  const buttonForeground = useMemo(() => asStr(getVariableByName('button/foreground', ctaModes), '#5d00b5'), [ctaModes]);
+  const mediaNode = media ? cloneChildrenWithModes(media, modes) : /*#__PURE__*/_jsx(Image, {
+    imageSource: imageSource,
+    width: imageWidth,
+    height: imageHeight,
+    borderRadius: tokens.imageRadius,
+    resizeMode: "cover",
+    accessibilityElementsHidden: true,
+    importantForAccessibility: "no"
+  });
+  const ctaNode = button ? cloneChildrenWithModes(button, ctaModes) : /*#__PURE__*/_jsx(Button, {
+    label: buttonLabel,
+    modes: ctaModes,
+    onPress: onButtonPress,
+    leading: buttonIcon ? /*#__PURE__*/_jsx(Icon, {
+      iconName: buttonIcon,
+      size: tokens.buttonIconSize,
+      color: buttonForeground
+    }) : undefined
+  });
+  const content = /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(View, {
+      style: styles.mediaSlot,
+      children: mediaNode
+    }), /*#__PURE__*/_jsx(Title, {
+      title: title,
+      subtitle: subtitle,
+      textAlign: "Center",
+      modes: modes
+    }), metrics.length > 0 ? /*#__PURE__*/_jsx(View, {
+      style: styles.metricsRow,
+      children: metrics.map((metric, index) => /*#__PURE__*/_jsxs(React.Fragment, {
+        children: [index > 0 ? /*#__PURE__*/_jsx(Divider, {
+          direction: "vertical",
+          modes: modes,
+          style: styles.metricDivider
+        }) : null, /*#__PURE__*/_jsx(Metricdata, {
+          metric: metric,
+          tokens: tokens
+        })]
+      }, index))
+    }) : null, showButton ? ctaNode : null]
+  });
+  const containerStyle = useMemo(() => ({
+    ...tokens.container,
+    width
+  }), [tokens.container, width]);
+  if (onPress) {
+    return /*#__PURE__*/_jsx(Pressable, {
+      style: ({
+        pressed
+      }) => [containerStyle, pressed ? styles.pressed : null, style],
+      accessibilityRole: "button",
+      accessibilityLabel: accessibilityLabel ?? title,
+      onPress: onPress,
+      children: content
+    });
+  }
+  return /*#__PURE__*/_jsx(View, {
+    style: [containerStyle, style],
+    accessibilityLabel: accessibilityLabel,
+    children: content
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Metricdata — internal metric column (Figma node 5352:256)
+// ---------------------------------------------------------------------------
+
+function Metricdata({
+  metric,
+  tokens
+}) {
+  return /*#__PURE__*/_jsxs(View, {
+    style: tokens.metric,
+    children: [metric.title != null ? /*#__PURE__*/_jsx(Text, {
+      style: tokens.metricTitle,
+      children: metric.title
+    }) : null, metric.value != null ? /*#__PURE__*/_jsx(Text, {
+      style: tokens.metricValue,
+      children: metric.value
+    }) : null, metric.caption != null ? /*#__PURE__*/_jsx(Text, {
+      style: tokens.metricCaption,
+      children: metric.caption
+    }) : null]
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Tokens / static styles
+// ---------------------------------------------------------------------------
+
+function asNum(raw, fallback) {
+  const n = typeof raw === 'number' ? raw : parseFloat(raw);
+  return Number.isFinite(n) ? n : fallback;
+}
+function asStr(raw, fallback) {
+  return raw != null ? String(raw) : fallback;
+}
+function resolveTokens(modes) {
+  // NOTE: token names are passed as string literals DIRECTLY to
+  // getVariableByName so the `extract-component-tokens` script can statically
+  // collect them for the generated docs. Do not refactor these into a helper
+  // that receives the name as a variable.
+  const background = asStr(getVariableByName('PDPcccard/bg/color', modes), '#ffffff');
+  const paddingHorizontal = asNum(getVariableByName('PDPcccard/padding/horizontal', modes), 16);
+  const paddingVertical = asNum(getVariableByName('PDPcccard/padding/vertical', modes), 20);
+  const gap = asNum(getVariableByName('PDPcccard/gap', modes), 12);
+  const imageRadius = asNum(getVariableByName('image/radius', modes), 8);
+  const buttonIconSize = asNum(getVariableByName('button/iconSize', modes), 16);
+  const metricGap = asNum(getVariableByName('metricdata/gap', modes), 4);
+  const metricPadH = asNum(getVariableByName('metricdata/padding/horizontal', modes), 10);
+  const metricPadV = asNum(getVariableByName('metricdata/padding/vertical', modes), 10);
+  const titleColor = asStr(getVariableByName('metricdata/title/color', modes), '#000000');
+  const titleSize = asNum(getVariableByName('metricdata/title/fontsize', modes), 12);
+  const titleFamily = asStr(getVariableByName('metricdata/title/fontfamily', modes), 'JioType Var');
+  const titleWeight = asStr(getVariableByName('metricdata/title/fontweight', modes), '400');
+  const valueColor = asStr(getVariableByName('metricdata/value/color', modes), '#000000');
+  const valueSize = asNum(getVariableByName('metricdata/value/fontsize', modes), 20);
+  const valueFamily = asStr(getVariableByName('metricdata/value/fontfamily', modes), 'JioType Var');
+  const valueWeight = asStr(getVariableByName('metricdata/value/fontweight', modes), '700');
+  const captionColor = asStr(getVariableByName('metricdata/caption/color', modes), '#777777');
+  const captionSize = asNum(getVariableByName('metricdata/caption/fontsize', modes), 12);
+  const captionFamily = asStr(getVariableByName('metricdata/caption/fontfamily', modes), 'JioType Var');
+  const captionWeight = asStr(getVariableByName('metricdata/caption/fontweight', modes), '500');
+  return {
+    container: {
+      backgroundColor: background,
+      paddingHorizontal,
+      paddingVertical,
+      gap,
+      flexDirection: 'column',
+      alignItems: 'center',
+      justifyContent: 'center'
+    },
+    imageRadius,
+    buttonIconSize,
+    metric: {
+      flex: 1,
+      gap: metricGap,
+      paddingHorizontal: metricPadH,
+      paddingVertical: metricPadV,
+      alignItems: 'center',
+      justifyContent: 'center'
+    },
+    metricTitle: {
+      color: titleColor,
+      fontSize: titleSize,
+      fontFamily: titleFamily,
+      fontWeight: titleWeight,
+      lineHeight: Math.round(titleSize * 1.2),
+      textAlign: 'center',
+      includeFontPadding: false
+    },
+    metricValue: {
+      color: valueColor,
+      fontSize: valueSize,
+      fontFamily: valueFamily,
+      fontWeight: valueWeight,
+      lineHeight: Math.round(valueSize * 1.2),
+      textAlign: 'center',
+      includeFontPadding: false
+    },
+    metricCaption: {
+      color: captionColor,
+      fontSize: captionSize,
+      fontFamily: captionFamily,
+      fontWeight: captionWeight,
+      lineHeight: Math.round(captionSize * 1.2),
+      textAlign: 'center',
+      includeFontPadding: false
+    }
+  };
+}
+const DEFAULT_METRICS = [{
+  title: 'Title',
+  value: 'Value',
+  caption: 'caption'
+}, {
+  title: 'Title',
+  value: 'Value',
+  caption: 'caption'
+}];
+const styles = StyleSheet.create({
+  mediaSlot: {
+    alignSelf: 'stretch',
+    alignItems: 'center',
+    justifyContent: 'center'
+  },
+  metricsRow: {
+    alignSelf: 'stretch',
+    flexDirection: 'row',
+    alignItems: 'stretch'
+  },
+  metricDivider: {
+    alignSelf: 'center',
+    height: '70%'
+  },
+  pressed: {
+    opacity: 0.92
+  }
+});
+export default PdpCcCard;

package/lib/module/components/PlanComparisonCard/PlanComparisonCard.js

@@ -5,9 +5,8 @@ import { View, Text, Pressable, Platform } from 'react-native';
 import { getVariableByName } from '../../design-tokens/figma-variables-resolver';
 import { EMPTY_MODES, cloneChildrenWithModes } from '../../utils/react-utils';
 import Icon from '../../icons/Icon';
-
-/** Figma grid: label column 1.8fr, each plan column 1fr. */
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Figma grid: label column 1.8fr, each plan column 1fr. */
 const LABEL_COLUMN_FR = 1.8;
 const PLAN_COLUMN_FR = 1;
 

package/lib/module/components/PoweredByLabel/PoweredByLabel.js

@@ -6,10 +6,9 @@ import { getVariableByName } from '../../design-tokens/figma-variables-resolver'
 import { useTokens } from '../../design-tokens/JFSThemeProvider';
 import { EMPTY_MODES, cloneChildrenWithModes } from '../../utils/react-utils';
 import MediaSource from '../../utils/MediaSource';
-
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 // Default bundled FINVU brand logo, matching the Figma reference so the
 // component renders correctly out of the box without any image prop.
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 const DEFAULT_LOGO = require('./finvu.png');
 const DEFAULT_LABEL = 'Powered by RBI-regulated account aggregator';
 const DEFAULT_IMAGE_WIDTH = 33;

package/lib/module/components/ProductMerchandisingCard/GlassFill.js

@@ -0,0 +1,257 @@
+"use strict";
+
+import React, { useId } from 'react';
+import { View, StyleSheet, Platform, UIManager } from 'react-native';
+import { BlurView } from '@react-native-community/blur';
+import MaskedView from '@react-native-masked-view/masked-view';
+import Svg, { Defs, LinearGradient, Stop, Rect } from 'react-native-svg';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+const DEFAULT_FALLBACK_DARK = '#1414174a';
+const DEFAULT_FALLBACK_LIGHT = '#ffffff66';
+
+// The native view-manager name registered by `@react-native-community/blur`
+// (`AndroidBlurView` on Android, `BlurView` on iOS).
+const NATIVE_BLUR_NAME = Platform.OS === 'android' ? 'AndroidBlurView' : 'BlurView';
+
+/**
+ * Alpha stop on a layer's vertical reveal mask. `offset` is the vertical
+ * position (0 = top of the surface, 1 = bottom); `opacity` is the mask alpha
+ * there (0 = layer hidden / fully clear, 1 = layer fully applied).
+ *
+ * Using several stops (rather than a single linear 0 → 1 ramp) lets each layer
+ * EASE in, so the blur swells smoothly toward the bottom instead of appearing
+ * along a hard horizontal seam. That soft S-curve is what gives the surface its
+ * "glass" feel rather than a flat translucent panel.
+ */
+
+/**
+ * A single layer of the progressive ramp.
+ *  - `stops` describe how this layer is revealed from top to bottom.
+ *  - `amount` is this layer's share (0–1) of the max `blurAmount`.
+ *
+ * We stack just TWO layers on both platforms: a faint base blur that covers
+ * most of the footer and a slightly stronger accent concentrated near the
+ * bottom. Keeping the overlap shallow avoids compounding the dark tint of
+ * multiple `BlurView`s (which is what made the earlier 3-layer ramp read as a
+ * heavy block), while still giving a genuine variable-radius result — the blur
+ * radius grows toward the bottom where the two layers overlap.
+ */
+
+// Base reveal: a faint trace of blur begins near the very top and grows
+// steadily downward, so the upper half still carries visible glass rather than
+// snapping clear. Also reused for the no-native-blur fallback scrim.
+const BASE_MASK_STOPS = [{
+  offset: 0.0,
+  opacity: 0
+}, {
+  offset: 0.08,
+  opacity: 0.12
+}, {
+  offset: 0.35,
+  opacity: 0.4
+}, {
+  offset: 0.65,
+  opacity: 0.8
+}, {
+  offset: 1.0,
+  opacity: 1
+}];
+const PROGRESSIVE_LAYERS = [{
+  amount: 0.65,
+  stops: BASE_MASK_STOPS
+},
+// Accent: the strongest blur, gathering over the lower portion for depth.
+{
+  amount: 1.0,
+  stops: [{
+    offset: 0.0,
+    opacity: 0
+  }, {
+    offset: 0.3,
+    opacity: 0.15
+  }, {
+    offset: 0.65,
+    opacity: 0.65
+  }, {
+    offset: 1.0,
+    opacity: 1
+  }]
+}];
+
+/**
+ * Probe ONCE whether the native blur view is actually present in this binary.
+ *
+ * `@react-native-community/blur` is a peer dependency so its JS always imports,
+ * but on a build where the native module was never linked (e.g. `pod install`
+ * wasn't run on iOS) rendering `<BlurView>` shows React Native's red
+ * "Unimplemented component <BlurView>" placeholder. Detecting availability up
+ * front lets us fall back to a tinted scrim instead of crashing the surface.
+ *
+ *   - New architecture (bridgeless): `getViewManagerConfig` raises a soft error,
+ *     so we MUST use `hasViewManagerConfig` -> Fabric component registry.
+ *   - Old architecture (Paper): `getViewManagerConfig` returns null when the
+ *     view manager isn't registered.
+ */
+const NATIVE_BLUR_SUPPORTED = (() => {
+  try {
+    const um = UIManager;
+    if (typeof um.hasViewManagerConfig === 'function') {
+      return um.hasViewManagerConfig(NATIVE_BLUR_NAME) === true;
+    }
+    if (typeof um.getViewManagerConfig === 'function') {
+      return um.getViewManagerConfig(NATIVE_BLUR_NAME) != null;
+    }
+  } catch {
+    // Any probe failure -> treat blur as unavailable and use the fallback.
+  }
+  return false;
+})();
+
+/**
+ * Vertical alpha-gradient mask drawn with `react-native-svg`. `MaskedView`
+ * reveals its child in proportion to this mask's alpha, so feeding it an eased
+ * multi-stop gradient makes the layer's blur swell in smoothly from top to
+ * bottom instead of along a hard seam.
+ */
+function GradientMask({
+  id,
+  stops
+}) {
+  return /*#__PURE__*/_jsxs(Svg, {
+    width: "100%",
+    height: "100%",
+    children: [/*#__PURE__*/_jsx(Defs, {
+      children: /*#__PURE__*/_jsx(LinearGradient, {
+        id: id,
+        x1: "0",
+        y1: "0",
+        x2: "0",
+        y2: "1",
+        children: stops.map((s, i) => /*#__PURE__*/_jsx(Stop, {
+          offset: s.offset,
+          stopColor: "#000000",
+          stopOpacity: s.opacity
+        }, i))
+      })
+    }), /*#__PURE__*/_jsx(Rect, {
+      x: "0",
+      y: "0",
+      width: "100%",
+      height: "100%",
+      fill: `url(#${id})`
+    })]
+  });
+}
+
+/**
+ * Glass / frosted surface for native (iOS + Android).
+ *
+ * Why this lives in its own platform-split file (mirrors `MediaCard/GlassFill`):
+ *   - `@react-native-community/blur` is a native-only module; importing it on
+ *     web throws because it references native components not registered there.
+ *     Metro's platform-extension resolution picks `GlassFill.tsx` for native
+ *     and `GlassFill.web.tsx` for web, keeping the web bundle native-free.
+ *   - Centralizes the `intensity` (0–100) -> `blurAmount` (0–32) mapping so the
+ *     Figma `blur/minimal` token semantics survive across platforms.
+ *
+ * On iOS (with the pod installed) this is a real `UIVisualEffectView` (true
+ * OS-level live blur). On Android it uses the community blur view. When the
+ * native module isn't linked in the running binary, the component degrades to
+ * a translucent tinted scrim (`reducedTransparencyFallbackColor` / fallback
+ * color) instead of rendering the "Unimplemented component" placeholder.
+ */
+function GlassFill({
+  tint = 'dark',
+  intensity = 50,
+  overlayColor,
+  progressive = false,
+  style
+}) {
+  const rawId = useId();
+  const maskId = `glass-mask-${rawId.replace(/[^a-zA-Z0-9_-]/g, '')}`;
+  const blurType = tint === 'light' ? 'light' : 'dark';
+  const uniformBlurAmount = Math.max(0, Math.min(32, Math.round(intensity * 0.32)));
+  const fallbackColor = overlayColor ?? (tint === 'light' ? DEFAULT_FALLBACK_LIGHT : DEFAULT_FALLBACK_DARK);
+
+  // ----- Progressive (variable) blur -------------------------------------
+  if (progressive) {
+    // Peak blur radius (at the bottom). Full strength so the frosted glass
+    // is clearly engaged where the layers overlap, while the eased masks
+    // keep the top of the surface fully clear.
+    const peakBlur = Math.max(1, Math.min(32, Math.round(intensity * 0.32)));
+
+    // Native blur not linked -> tint eases from transparent (top) to a soft
+    // fallback color (bottom) so the surface still reads as gentle glass.
+    if (!NATIVE_BLUR_SUPPORTED) {
+      return /*#__PURE__*/_jsx(View, {
+        style: [StyleSheet.absoluteFill, style],
+        pointerEvents: "none",
+        children: /*#__PURE__*/_jsx(MaskedView, {
+          style: StyleSheet.absoluteFill,
+          maskElement: /*#__PURE__*/_jsx(GradientMask, {
+            id: `${maskId}-fb`,
+            stops: BASE_MASK_STOPS
+          }),
+          children: /*#__PURE__*/_jsx(View, {
+            style: [StyleSheet.absoluteFill, {
+              backgroundColor: fallbackColor
+            }]
+          })
+        })
+      });
+    }
+    return /*#__PURE__*/_jsx(View, {
+      style: [StyleSheet.absoluteFill, style],
+      pointerEvents: "none",
+      children: PROGRESSIVE_LAYERS.map((layer, i) => {
+        const amount = Math.max(1, Math.round(peakBlur * layer.amount));
+        return /*#__PURE__*/_jsx(MaskedView, {
+          style: StyleSheet.absoluteFill,
+          maskElement: /*#__PURE__*/_jsx(GradientMask, {
+            id: `${maskId}-${i}`,
+            stops: layer.stops
+          }),
+          children: /*#__PURE__*/_jsx(BlurView, {
+            style: StyleSheet.absoluteFill,
+            blurType: blurType,
+            blurAmount: amount,
+            reducedTransparencyFallbackColor: fallbackColor
+          })
+        }, i);
+      })
+    });
+  }
+
+  // ----- Uniform blur (default) ------------------------------------------
+  // Native blur not linked in this build -> render a translucent tinted scrim
+  // so the surface still reads as frosted glass and never shows RN's
+  // "Unimplemented component <BlurView>" box.
+  if (!NATIVE_BLUR_SUPPORTED) {
+    return /*#__PURE__*/_jsx(View, {
+      style: [StyleSheet.absoluteFill, {
+        backgroundColor: fallbackColor
+      }, style],
+      pointerEvents: "none"
+    });
+  }
+  return /*#__PURE__*/_jsxs(View, {
+    style: [StyleSheet.absoluteFill, style],
+    pointerEvents: "none",
+    children: [/*#__PURE__*/_jsx(BlurView, {
+      style: StyleSheet.absoluteFill,
+      blurType: blurType,
+      blurAmount: uniformBlurAmount,
+      reducedTransparencyFallbackColor: fallbackColor
+    }), overlayColor != null ? /*#__PURE__*/_jsx(View, {
+      style: [StyleSheet.absoluteFill, {
+        backgroundColor: overlayColor
+      }]
+    }) : null, Platform.OS === 'android' ? /*#__PURE__*/_jsx(View, {
+      style: [StyleSheet.absoluteFill, {
+        backgroundColor: 'rgba(255,255,255,0.03)',
+        opacity: 0.6
+      }]
+    }) : null]
+  });
+}
+export default GlassFill;

package/lib/module/components/ProductMerchandisingCard/GlassFill.web.js

@@ -0,0 +1,111 @@
+"use strict";
+
+import React from 'react';
+import { View, StyleSheet } from 'react-native';
+import { jsx as _jsx } from "react/jsx-runtime";
+const DEFAULT_FALLBACK_DARK = '#1414174a';
+const DEFAULT_FALLBACK_LIGHT = '#ffffff66';
+
+// Mirror of the native ramp (see GlassFill.tsx). Each layer is a `mask-image`
+// gradient whose alpha stops (0 = top, 1 = bottom) ease the blur in; `amount`
+// is the layer's share of the max blur. Two gently-overlapping layers (faint
+// base + bottom accent) keep the surface subtle and glass-like rather than a
+// heavy frosted block.
+
+const PROGRESSIVE_LAYERS = [{
+  amount: 0.65,
+  stops: [{
+    offset: 0.0,
+    opacity: 0
+  }, {
+    offset: 0.08,
+    opacity: 0.12
+  }, {
+    offset: 0.35,
+    opacity: 0.4
+  }, {
+    offset: 0.65,
+    opacity: 0.8
+  }, {
+    offset: 1.0,
+    opacity: 1
+  }]
+}, {
+  amount: 1.0,
+  stops: [{
+    offset: 0.0,
+    opacity: 0
+  }, {
+    offset: 0.3,
+    opacity: 0.15
+  }, {
+    offset: 0.65,
+    opacity: 0.65
+  }, {
+    offset: 1.0,
+    opacity: 1
+  }]
+}];
+function toGradient(stops) {
+  const parts = stops.map(s => `rgba(0,0,0,${s.opacity}) ${Math.round(s.offset * 100)}%`).join(', ');
+  return `linear-gradient(to bottom, ${parts})`;
+}
+
+/**
+ * Web counterpart of `GlassFill`.
+ *
+ * `@react-native-community/blur` ships no web implementation, so on web we
+ * render a translucent `View` with `backdrop-filter: blur()`. Native bundles
+ * pick up `GlassFill.tsx` instead via Metro's platform resolver; the web
+ * bundle picks up this file, so the native-only module is never imported here.
+ */
+function GlassFill({
+  tint = 'dark',
+  intensity = 50,
+  overlayColor,
+  progressive = false,
+  style
+}) {
+  // intensity 0-100 -> ~0-32px CSS blur, kept in parity with the native scale.
+  const blurPx = Math.max(0, Math.min(32, Math.round(intensity * 0.32)));
+  const tintColor = overlayColor ?? (tint === 'light' ? DEFAULT_FALLBACK_LIGHT : DEFAULT_FALLBACK_DARK);
+  if (progressive) {
+    // Full peak blur (parity with native) so the frosted glass is clearly
+    // engaged at the bottom; the eased masks keep the top fully clear.
+    const peakPx = Math.max(1, Math.min(32, Math.round(intensity * 0.32)));
+    return /*#__PURE__*/_jsx(View, {
+      style: [StyleSheet.absoluteFill, style],
+      pointerEvents: "none",
+      children: PROGRESSIVE_LAYERS.map((layer, i) => {
+        const px = Math.max(1, Math.round(peakPx * layer.amount));
+        const gradient = toGradient(layer.stops);
+        // web-only CSS (backdrop-filter / mask-image); cast because
+        // these keys aren't in RN's ViewStyle.
+        const webStyle = {
+          backdropFilter: `blur(${px}px)`,
+          WebkitBackdropFilter: `blur(${px}px)`,
+          maskImage: gradient,
+          WebkitMaskImage: gradient
+        };
+        return /*#__PURE__*/_jsx(View, {
+          style: [StyleSheet.absoluteFill, webStyle],
+          pointerEvents: "none"
+        }, i);
+      })
+    });
+  }
+  return /*#__PURE__*/_jsx(View, {
+    style: [StyleSheet.absoluteFill, {
+      backgroundColor: tintColor
+    },
+    // backdrop-filter is web-only CSS; ignored by RN on native
+    // (we never bundle this file there anyway).
+    // @ts-ignore web-only style
+    {
+      backdropFilter: `blur(${blurPx}px)`,
+      WebkitBackdropFilter: `blur(${blurPx}px)`
+    }, style],
+    pointerEvents: "none"
+  });
+}
+export default GlassFill;