@wireai/activation 0.1.0

package/dist/reviews/index.mjs

@@ -0,0 +1,971 @@
+import React4, { createContext, forwardRef, useRef, useState, useEffect, useCallback, useImperativeHandle, useContext, useMemo } from 'react';
+import { StyleSheet, Animated, Easing, BackHandler, Modal, Pressable, Text, AccessibilityInfo, Platform, Linking, View, TextInput } from 'react-native';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { SafeAreaView } from 'react-native-safe-area-context';
+
+// src/reviews/ReviewGate.tsx
+
+// src/theme/defaultTheme.ts
+var defaultOnboardingTheme = {
+  colors: {
+    background: "#FFFFFF",
+    surface: "#F7F7F8",
+    text: "#101114",
+    textMuted: "#6B7280",
+    primary: "#111111",
+    onPrimary: "#FFFFFF",
+    primarySoft: "rgba(17,17,17,0.06)",
+    border: "#E4E4E7",
+    borderStrong: "#C7C7CC",
+    disabled: "#EBEBEB",
+    success: "#16A34A",
+    warning: "#D97706",
+    error: "#DC2626",
+    info: "#2563EB"
+  },
+  fonts: {
+    regular: void 0,
+    medium: void 0,
+    bold: void 0,
+    baseSize: 16,
+    scale: 1
+  },
+  radius: {
+    sm: 8,
+    md: 12,
+    lg: 16,
+    full: 9999
+  },
+  spacing: {
+    xs: 4,
+    sm: 8,
+    md: 16,
+    lg: 24,
+    xl: 32
+  },
+  // Circled (pill) CTA by default; an app can pass `button: { radius: 12 }` for
+  // a rounded rectangle, or override height/paddingX to match its design system.
+  button: {
+    radius: 9999,
+    height: 52,
+    paddingX: 24
+  }
+};
+var mergeTheme = (override) => {
+  return defaultOnboardingTheme;
+};
+var OnboardingThemeContext = createContext(null);
+var useOnboardingTheme = () => {
+  const ctx = useContext(OnboardingThemeContext);
+  return ctx != null ? ctx : mergeTheme();
+};
+
+// src/theme/typography.ts
+var round = (n) => Math.round(n);
+var bodyStyle = (f) => ({
+  fontFamily: f.regular,
+  fontSize: round(f.baseSize * f.scale),
+  lineHeight: round(f.baseSize * f.scale * 1.5)
+});
+var captionStyle = (f) => ({
+  fontFamily: f.regular,
+  fontSize: round(f.baseSize * 0.8125 * f.scale),
+  lineHeight: round(f.baseSize * 0.8125 * f.scale * 1.5)
+});
+var headingStyle = (f) => ({
+  fontFamily: f.bold,
+  fontSize: round(f.baseSize * 1.25 * f.scale),
+  lineHeight: round(f.baseSize * 1.25 * f.scale * 1.3),
+  fontWeight: f.bold ? void 0 : "700"
+});
+var buttonLabelStyle = (f) => {
+  var _a;
+  return {
+    fontFamily: (_a = f.bold) != null ? _a : f.medium,
+    fontSize: round(f.baseSize * f.scale),
+    fontWeight: f.bold ? void 0 : "600"
+  };
+};
+
+// src/motion/motionSpec.ts
+var REDUCED_FADE_MS = 120;
+var BUTTON_PRESS_SCALE = 0.975;
+var REDUCED_PRESS_OPACITY = 0.85;
+var BUTTON_PRESS_SPRING = { friction: 8, tension: 240 };
+var durationScale = 1;
+var scaledMs = (ms) => Math.round(ms * durationScale);
+var lastKnown = false;
+var useReducedMotion = () => {
+  const [reduced, setReduced] = useState(lastKnown);
+  useEffect(() => {
+    let mounted = true;
+    AccessibilityInfo.isReduceMotionEnabled().then((value) => {
+      lastKnown = value;
+      if (mounted) setReduced(value);
+    }).catch(() => {
+    });
+    const sub = AccessibilityInfo.addEventListener("reduceMotionChanged", (value) => {
+      lastKnown = value;
+      setReduced(value);
+    });
+    return () => {
+      mounted = false;
+      sub == null ? void 0 : sub.remove();
+    };
+  }, []);
+  return reduced;
+};
+var _Button = ({
+  title,
+  onPress,
+  variant = "primary",
+  disabled = false,
+  fullWidth = false
+}) => {
+  const t = useOnboardingTheme();
+  const reduced = useReducedMotion();
+  const isPrimary = variant === "primary";
+  const pressT = useRef(new Animated.Value(0)).current;
+  const pressTo = useCallback(
+    (to) => {
+      if (reduced) {
+        Animated.timing(pressT, {
+          toValue: to,
+          duration: scaledMs(REDUCED_FADE_MS),
+          useNativeDriver: true
+        }).start();
+        return;
+      }
+      Animated.spring(pressT, {
+        toValue: to,
+        friction: BUTTON_PRESS_SPRING.friction,
+        tension: BUTTON_PRESS_SPRING.tension,
+        useNativeDriver: true
+      }).start();
+    },
+    [pressT, reduced]
+  );
+  const handlePressIn = useCallback(() => pressTo(1), [pressTo]);
+  const handlePressOut = useCallback(() => pressTo(0), [pressTo]);
+  const scale = pressT.interpolate({
+    inputRange: [0, 1],
+    outputRange: [1, reduced ? 1 : BUTTON_PRESS_SCALE]
+  });
+  const opacity = pressT.interpolate({
+    inputRange: [0, 1],
+    outputRange: [1, reduced ? REDUCED_PRESS_OPACITY : 1]
+  });
+  return /* @__PURE__ */ jsx(
+    Pressable,
+    {
+      onPress: disabled ? void 0 : onPress,
+      onPressIn: disabled ? void 0 : handlePressIn,
+      onPressOut: disabled ? void 0 : handlePressOut,
+      disabled,
+      accessibilityRole: "button",
+      accessibilityState: { disabled },
+      style: fullWidth ? styles.fill : void 0,
+      children: /* @__PURE__ */ jsx(
+        Animated.View,
+        {
+          style: [
+            styles.base,
+            fullWidth && styles.fill,
+            {
+              borderRadius: t.button.radius,
+              minHeight: t.button.height,
+              paddingHorizontal: t.button.paddingX,
+              opacity,
+              transform: [{ scale }]
+            },
+            isPrimary ? { backgroundColor: disabled ? t.colors.disabled : t.colors.primary } : { borderWidth: 1.5, borderColor: disabled ? t.colors.border : t.colors.primary }
+          ],
+          children: /* @__PURE__ */ jsx(
+            Text,
+            {
+              style: [
+                buttonLabelStyle(t.fonts),
+                {
+                  color: disabled ? t.colors.textMuted : isPrimary ? t.colors.onPrimary : t.colors.primary
+                }
+              ],
+              children: title
+            }
+          )
+        }
+      )
+    }
+  );
+};
+var Button = React4.memo(_Button);
+var styles = StyleSheet.create({
+  base: { alignItems: "center", justifyContent: "center" },
+  fill: { width: "100%" }
+});
+
+// src/reviews/decision.ts
+var decideReview = (local, decision) => decision != null ? decision : local;
+var resolveRules = (config) => {
+  var _a, _b, _c, _d, _e;
+  return {
+    enabled: (_a = config.enabled) != null ? _a : true,
+    minSessions: (_b = config.minSessions) != null ? _b : 0,
+    minEvents: (_c = config.minEvents) != null ? _c : 0,
+    cooldownDays: (_d = config.cooldownDays) != null ? _d : 0,
+    oncePerVersion: (_e = config.oncePerVersion) != null ? _e : true
+  };
+};
+var MS_PER_DAY = 864e5;
+var evaluateGate = (rules, s) => {
+  if (!rules.enabled) return { fire: false, reason: "disabled" };
+  if (rules.oncePerVersion && s.seen) return { fire: false, reason: "already_shown" };
+  if (s.sessions < rules.minSessions) return { fire: false, reason: "min_sessions" };
+  if (s.events < rules.minEvents) return { fire: false, reason: "min_events" };
+  if (rules.cooldownDays > 0 && s.lastShownAt != null) {
+    const elapsedDays = (s.now - s.lastShownAt) / MS_PER_DAY;
+    if (elapsedDays < rules.cooldownDays) return { fire: false, reason: "cooldown" };
+  }
+  return { fire: true, reason: "local_rules_met" };
+};
+var routeRating = (stars) => stars >= 5 ? "store" : "feedback";
+var buildReviewSubmission = (input) => {
+  var _a, _b, _c;
+  const body = { stars: input.stars };
+  const text = (_a = input.feedbackText) == null ? void 0 : _a.trim();
+  if (text) body.feedback_text = text;
+  const suggestion = (_b = input.suggestion) == null ? void 0 : _b.trim();
+  if (suggestion) body.suggestion = suggestion;
+  const contact = (_c = input.contact) == null ? void 0 : _c.trim();
+  if (contact) body.contact = contact;
+  if (input.sessionId) body.session_id = input.sessionId;
+  if (input.source) body.source = input.source;
+  if (input.meta && Object.keys(input.meta).length > 0) body.meta = input.meta;
+  return body;
+};
+
+// src/reviews/feedbackForm.ts
+var FEEDBACK_MIN_LINES = 4;
+var FEEDBACK_MAX_LINES = 5;
+var feedbackInputHeights = (fonts, verticalPadding = 0) => {
+  var _a;
+  const lineHeight = (_a = bodyStyle(fonts).lineHeight) != null ? _a : Math.round(fonts.baseSize * fonts.scale * 1.5);
+  const pad = verticalPadding * 2;
+  return {
+    minHeight: lineHeight * FEEDBACK_MIN_LINES + pad,
+    maxHeight: lineHeight * FEEDBACK_MAX_LINES + pad
+  };
+};
+
+// src/motion/centeredModalMotion.ts
+var CENTERED_MODAL_ANIM = {
+  /** Spring config for the card scale/opacity entrance (mirrors CompletionView's pop). */
+  enterSpring: { friction: 7, tension: 80 },
+  /** Exit timing in ms (fade + shrink back out before unmount). */
+  exitMs: 160,
+  /** Card scale at rest (progress 0); grows to 1 at progress 1. */
+  scaleFrom: 0.9,
+  /** Peak dim of the backdrop at progress 1. */
+  backdropOpacity: 0.55
+};
+var centeredModalFrame = (progress, backdropMax = CENTERED_MODAL_ANIM.backdropOpacity) => {
+  const p = progress < 0 ? 0 : progress > 1 ? 1 : progress;
+  const { scaleFrom } = CENTERED_MODAL_ANIM;
+  return {
+    cardOpacity: p,
+    cardScale: scaleFrom + (1 - scaleFrom) * p,
+    backdropOpacity: backdropMax * p
+  };
+};
+
+// src/reviews/presentation.ts
+var DEFAULT_PRESENTATION = "modal";
+var resolvePresentation = (p) => p != null ? p : DEFAULT_PRESENTATION;
+var _CenteredModal = forwardRef(
+  ({ theme, dismissible = true, onDismiss, children }, ref) => {
+    const progress = useRef(new Animated.Value(0)).current;
+    const [open, setOpen] = useState(true);
+    const closingRef = useRef(false);
+    const reduced = useReducedMotion();
+    useEffect(() => {
+      const anim = reduced ? Animated.timing(progress, {
+        toValue: 1,
+        duration: REDUCED_FADE_MS,
+        useNativeDriver: true
+      }) : Animated.spring(progress, {
+        toValue: 1,
+        useNativeDriver: true,
+        friction: CENTERED_MODAL_ANIM.enterSpring.friction,
+        tension: CENTERED_MODAL_ANIM.enterSpring.tension
+      });
+      anim.start();
+      return () => anim.stop();
+    }, [progress, reduced]);
+    const close = useCallback(() => {
+      if (closingRef.current) return;
+      closingRef.current = true;
+      Animated.timing(progress, {
+        toValue: 0,
+        duration: reduced ? REDUCED_FADE_MS : CENTERED_MODAL_ANIM.exitMs,
+        easing: Easing.in(Easing.cubic),
+        useNativeDriver: true
+      }).start(() => {
+        setOpen(false);
+        onDismiss();
+      });
+    }, [progress, onDismiss, reduced]);
+    useImperativeHandle(ref, () => ({ close }), [close]);
+    useEffect(() => {
+      const sub = BackHandler.addEventListener("hardwareBackPress", () => {
+        if (dismissible) close();
+        return true;
+      });
+      return () => sub.remove();
+    }, [dismissible, close]);
+    const onBackdrop = useCallback(() => {
+      if (dismissible) close();
+    }, [dismissible, close]);
+    const backdropOpacity = progress.interpolate({
+      inputRange: [0, 1],
+      outputRange: [0, CENTERED_MODAL_ANIM.backdropOpacity]
+    });
+    const cardScale = reduced ? 1 : progress.interpolate({
+      inputRange: [0, 1],
+      outputRange: [CENTERED_MODAL_ANIM.scaleFrom, 1]
+    });
+    return /* @__PURE__ */ jsxs(
+      Modal,
+      {
+        visible: open,
+        transparent: true,
+        animationType: "none",
+        statusBarTranslucent: true,
+        onRequestClose: dismissible ? close : void 0,
+        children: [
+          /* @__PURE__ */ jsx(
+            Animated.View,
+            {
+              style: [styles2.backdrop, { opacity: backdropOpacity }],
+              pointerEvents: "none"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Pressable,
+            {
+              style: styles2.fill,
+              onPress: onBackdrop,
+              accessibilityRole: "button",
+              accessibilityLabel: "Dismiss",
+              children: /* @__PURE__ */ jsx(SafeAreaView, { style: styles2.center, pointerEvents: "box-none", children: /* @__PURE__ */ jsx(Pressable, { onPress: () => {
+              }, style: styles2.cardWrap, children: /* @__PURE__ */ jsx(
+                Animated.View,
+                {
+                  accessibilityViewIsModal: true,
+                  accessibilityRole: "alert",
+                  style: [
+                    styles2.card,
+                    {
+                      backgroundColor: theme.colors.surface,
+                      borderRadius: theme.radius.lg,
+                      padding: theme.spacing.lg,
+                      gap: theme.spacing.md,
+                      opacity: progress,
+                      transform: [{ scale: cardScale }]
+                    }
+                  ],
+                  children
+                }
+              ) }) })
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+_CenteredModal.displayName = "CenteredModal";
+var CenteredModal = React4.memo(_CenteredModal);
+var styles2 = StyleSheet.create({
+  fill: { flex: 1 },
+  backdrop: { position: "absolute", top: 0, left: 0, right: 0, bottom: 0, backgroundColor: "#000" },
+  center: { flex: 1, alignItems: "center", justifyContent: "center", padding: 24 },
+  cardWrap: { width: "100%", maxWidth: 420 },
+  card: {
+    width: "100%",
+    // Soft elevation so the popup reads as lifted above the app in both themes.
+    shadowColor: "#000",
+    shadowOffset: { width: 0, height: 8 },
+    shadowOpacity: 0.28,
+    shadowRadius: 24,
+    elevation: 12
+  }
+});
+var storeUrl = (store) => {
+  var _a;
+  if (!store) return null;
+  if (Platform.OS === "ios" && store.iosAppId) {
+    return `itms-apps://itunes.apple.com/app/id${store.iosAppId}?action=write-review`;
+  }
+  if (Platform.OS === "android" && store.androidPackage) {
+    return `market://details?id=${store.androidPackage}`;
+  }
+  return (_a = store.storeUrl) != null ? _a : null;
+};
+var openStoreListing = async (store) => {
+  const url = storeUrl(store);
+  if (!url) return false;
+  try {
+    await Linking.openURL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var requestStoreReview = async (store) => {
+  try {
+    const mod = await import('expo-store-review');
+    if (mod && await mod.isAvailableAsync()) {
+      await mod.requestReview();
+      return "native";
+    }
+  } catch {
+  }
+  const opened = await openStoreListing(store);
+  return opened ? "store_url" : "none";
+};
+
+// src/reviews/transport.ts
+var submitReview = (target, review) => {
+  if (!(target == null ? void 0 : target.serverUrl)) return;
+  try {
+    const url = `${target.serverUrl.replace(/\/$/, "")}/v1/reviews`;
+    const headers = { "Content-Type": "application/json" };
+    if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
+    void fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(review)
+    }).catch(() => {
+    });
+  } catch {
+  }
+};
+var reportAppEvent = (target, name, options = {}) => {
+  if (!(target == null ? void 0 : target.serverUrl) || !name) return;
+  try {
+    const url = `${target.serverUrl.replace(/\/$/, "")}/v1/events`;
+    const headers = { "Content-Type": "application/json" };
+    if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
+    const event = {
+      event_type: "app_event",
+      question_key: name
+    };
+    if (options.sessionId) event.session_id = options.sessionId;
+    if (options.deviceKey) event.user_context = { device_key: options.deviceKey };
+    if (options.meta && Object.keys(options.meta).length > 0) {
+      event.meta = JSON.stringify(options.meta);
+    }
+    void fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ events: [event] })
+    }).catch(() => {
+    });
+  } catch {
+  }
+};
+var mergeThemeOver = (base, override) => {
+  if (!override) return base;
+  return {
+    colors: { ...base.colors, ...override.colors },
+    fonts: { ...base.fonts, ...override.fonts },
+    radius: { ...base.radius, ...override.radius },
+    spacing: { ...base.spacing, ...override.spacing },
+    button: { ...base.button, ...override.button }
+  };
+};
+var ReviewGate = ({
+  appName,
+  store,
+  target,
+  sessionId,
+  meta,
+  onEvent,
+  onResolved,
+  onShown,
+  theme: themeOverride,
+  dismissible = true,
+  presentation,
+  id = "default"
+}) => {
+  const active = useOnboardingTheme();
+  const t = useMemo(() => mergeThemeOver(active, themeOverride), [active, themeOverride]);
+  const mode = resolvePresentation(presentation);
+  const modalRef = React4.useRef(null);
+  const [phase, setPhase] = useState("rating");
+  const [stars, setStars] = useState(0);
+  const [hovered, setHovered] = useState(0);
+  const [feedback, setFeedback] = useState("");
+  const [suggestion, setSuggestion] = useState("");
+  const shownRef = React4.useRef(false);
+  const onShownRef = React4.useRef(onShown);
+  const onEventRef = React4.useRef(onEvent);
+  onShownRef.current = onShown;
+  onEventRef.current = onEvent;
+  React4.useEffect(() => {
+    var _a, _b;
+    if (shownRef.current) return;
+    shownRef.current = true;
+    (_a = onShownRef.current) == null ? void 0 : _a.call(onShownRef);
+    (_b = onEventRef.current) == null ? void 0 : _b.call(onEventRef, { name: "review_prompt_shown", id });
+  }, []);
+  const resolve = useCallback(() => {
+    onResolved == null ? void 0 : onResolved();
+  }, [onResolved]);
+  const pickRating = useCallback(
+    async (value) => {
+      setStars(value);
+      onEvent == null ? void 0 : onEvent({ name: "review_rating_selected", id, stars: value });
+      if (routeRating(value) === "store") {
+        onEvent == null ? void 0 : onEvent({ name: "store_review_requested", id, stars: value });
+        await requestStoreReview(store);
+        setPhase("thanks");
+        resolve();
+      } else {
+        setPhase("feedback");
+      }
+    },
+    [onEvent, id, store, resolve]
+  );
+  const sendFeedback = useCallback(() => {
+    const body = buildReviewSubmission({
+      stars,
+      feedbackText: feedback,
+      suggestion,
+      sessionId,
+      meta
+    });
+    submitReview(target, body);
+    onEvent == null ? void 0 : onEvent({ name: "review_feedback_submitted", id, stars });
+    setPhase("thanks");
+    resolve();
+  }, [stars, feedback, suggestion, sessionId, meta, target, onEvent, id, resolve]);
+  const dismiss = useCallback(() => {
+    setPhase("thanks");
+    resolve();
+  }, [resolve]);
+  const handleDismissTap = useCallback(() => {
+    var _a;
+    if (mode === "modal") (_a = modalRef.current) == null ? void 0 : _a.close();
+    else dismiss();
+  }, [mode, dismiss]);
+  const title = phase === "feedback" ? "What should we improve?" : phase === "thanks" ? "Thank you" : appName ? `Enjoying ${appName}?` : "How's your experience?";
+  const surface = {
+    backgroundColor: t.colors.surface,
+    borderRadius: t.radius.lg,
+    padding: t.spacing.lg,
+    gap: t.spacing.md
+  };
+  const feedbackBox = feedbackInputHeights(t.fonts, t.spacing.md);
+  const content = /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Text, { style: [headingStyle(t.fonts), { color: t.colors.text }], children: title }),
+    phase === "rating" && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), { color: t.colors.textMuted }], children: "Tap a star to let us know." }),
+      /* @__PURE__ */ jsx(View, { style: styles3.stars, children: [1, 2, 3, 4, 5].map((n) => {
+        const filled = n <= (hovered || stars);
+        return /* @__PURE__ */ jsx(
+          Pressable,
+          {
+            onPressIn: () => setHovered(n),
+            onPressOut: () => setHovered(0),
+            onPress: () => void pickRating(n),
+            accessibilityRole: "button",
+            accessibilityLabel: `${n} star${n > 1 ? "s" : ""}`,
+            hitSlop: 8,
+            children: /* @__PURE__ */ jsx(
+              Text,
+              {
+                style: [
+                  styles3.star,
+                  { color: filled ? t.colors.primary : t.colors.border }
+                ],
+                children: filled ? "\u2605" : "\u2606"
+              }
+            )
+          },
+          n
+        );
+      }) }),
+      dismissible && /* @__PURE__ */ jsx(Pressable, { onPress: handleDismissTap, hitSlop: 8, children: /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), styles3.link, { color: t.colors.textMuted }], children: "Not now" }) })
+    ] }),
+    phase === "feedback" && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), { color: t.colors.textMuted }], children: "A few words is plenty. Both boxes are optional, so send whatever you like." }),
+      /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), { color: t.colors.textMuted }], children: "Why this rating? (optional)" }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value: feedback,
+          onChangeText: setFeedback,
+          placeholder: "e.g. too many steps",
+          placeholderTextColor: t.colors.textMuted,
+          multiline: true,
+          textAlignVertical: "top",
+          style: [
+            bodyStyle(t.fonts),
+            styles3.input,
+            {
+              color: t.colors.text,
+              backgroundColor: t.colors.background,
+              borderRadius: t.radius.md,
+              borderColor: t.colors.border,
+              padding: t.spacing.md,
+              minHeight: feedbackBox.minHeight,
+              maxHeight: feedbackBox.maxHeight
+            }
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), { color: t.colors.textMuted }], children: "What can we do better? (optional)" }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value: suggestion,
+          onChangeText: setSuggestion,
+          placeholder: "e.g. save my place between steps",
+          placeholderTextColor: t.colors.textMuted,
+          style: [
+            bodyStyle(t.fonts),
+            styles3.input,
+            {
+              color: t.colors.text,
+              backgroundColor: t.colors.background,
+              borderRadius: t.radius.md,
+              borderColor: t.colors.border,
+              paddingHorizontal: t.spacing.md,
+              paddingVertical: t.spacing.sm,
+              minHeight: t.button.height
+            }
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Button,
+        {
+          title: "Send feedback",
+          onPress: sendFeedback,
+          variant: "primary",
+          fullWidth: true
+        }
+      ),
+      dismissible && /* @__PURE__ */ jsx(Pressable, { onPress: handleDismissTap, hitSlop: 8, children: /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), styles3.link, { color: t.colors.textMuted }], children: "Skip" }) })
+    ] }),
+    phase === "thanks" && /* @__PURE__ */ jsx(Text, { style: [bodyStyle(t.fonts), { color: t.colors.textMuted }], children: "We appreciate you. This helps us make it better." })
+  ] });
+  if (mode === "modal") {
+    return /* @__PURE__ */ jsx(CenteredModal, { ref: modalRef, theme: t, dismissible, onDismiss: resolve, children: content });
+  }
+  return /* @__PURE__ */ jsx(View, { style: [styles3.card, surface], children: content });
+};
+ReviewGate.displayName = "ReviewGate";
+var styles3 = StyleSheet.create({
+  card: { width: "100%" },
+  stars: { flexDirection: "row", justifyContent: "center", gap: 8 },
+  star: { fontSize: 40, lineHeight: 46 },
+  input: { borderWidth: 1 },
+  link: { textAlign: "center", textDecorationLine: "underline" }
+});
+
+// src/coachmarks/runtime.ts
+var storageSingleton = null;
+var testing = false;
+var getCoachmarkStorage = () => storageSingleton;
+var isCoachmarkTesting = () => testing;
+var SEEN_VALUE = "1";
+var hasSeenGate = (key, storageOverride, testingOverride) => {
+  if (testingOverride != null ? testingOverride : testing) return false;
+  const storage = storageOverride != null ? storageOverride : storageSingleton;
+  if (!storage) return false;
+  try {
+    return storage.getItem(key) === SEEN_VALUE;
+  } catch {
+    return false;
+  }
+};
+var markSeenGate = (key, storageOverride, testingOverride) => {
+  if (testingOverride != null ? testingOverride : testing) return;
+  const storage = storageOverride != null ? storageOverride : storageSingleton;
+  if (!storage) return;
+  try {
+    storage.setItem(key, SEEN_VALUE);
+  } catch {
+  }
+};
+
+// src/features/defaults.ts
+var defaultWireFeatures = Object.freeze({
+  coachmarks: Object.freeze({ enabled: true }),
+  showcase: Object.freeze({ enabled: true }),
+  onboarding: Object.freeze({ mode: "ai" }),
+  review: Object.freeze({ enabled: true }),
+  questionnaire: Object.freeze({ enabled: true }),
+  announcements: Object.freeze({ enabled: true })
+});
+var VALID_MODES = ["ai", "static", "off"];
+var readEnabled = (raw) => {
+  if (raw && typeof raw === "object" && typeof raw.enabled === "boolean") {
+    return { enabled: raw.enabled };
+  }
+  return { enabled: true };
+};
+var parseWireFeatures = (raw) => {
+  var _a;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return defaultWireFeatures;
+  const src = raw;
+  const modeRaw = (_a = src.onboarding) == null ? void 0 : _a.mode;
+  const mode = typeof modeRaw === "string" && VALID_MODES.includes(modeRaw) ? modeRaw : "ai";
+  return {
+    coachmarks: readEnabled(src.coachmarks),
+    showcase: readEnabled(src.showcase),
+    onboarding: { mode },
+    review: readEnabled(src.review),
+    questionnaire: readEnabled(src.questionnaire),
+    announcements: readEnabled(src.announcements)
+  };
+};
+var featuresEqual = (a, b) => a === b || a.coachmarks.enabled === b.coachmarks.enabled && a.showcase.enabled === b.showcase.enabled && a.onboarding.mode === b.onboarding.mode && a.review.enabled === b.review.enabled && a.questionnaire.enabled === b.questionnaire.enabled && a.announcements.enabled === b.announcements.enabled;
+
+// src/features/cache.ts
+var READ_TIMEOUT_MS = 1500;
+var featuresCacheKey = (appId) => `wireai:features:${appId && appId.length > 0 ? appId : "default"}`;
+var withTimeout = (p, ms) => {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(void 0), ms);
+  });
+  return Promise.race([p, timeout]).finally(() => clearTimeout(timer));
+};
+var readCachedFeatures = async (storage, key) => {
+  let raw;
+  try {
+    raw = await withTimeout(storage.getItem(key), READ_TIMEOUT_MS);
+  } catch {
+    return void 0;
+  }
+  if (!raw) return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && typeof parsed.ts === "number") {
+      const ts = parsed.ts;
+      return {
+        features: parseWireFeatures(parsed.features),
+        ageMs: Date.now() - ts
+      };
+    }
+  } catch {
+  }
+  return void 0;
+};
+var writeCachedFeatures = (storage, key, features) => {
+  try {
+    void storage.setItem(key, JSON.stringify({ features, ts: Date.now() })).catch(() => {
+    });
+  } catch {
+  }
+};
+
+// src/features/fetchWireFeatures.ts
+var DEFAULT_TIMEOUT_MS = 4e3;
+var failOpen = async (storage, key) => {
+  var _a;
+  if (!storage) return defaultWireFeatures;
+  const cached = await readCachedFeatures(storage, key);
+  return (_a = cached == null ? void 0 : cached.features) != null ? _a : defaultWireFeatures;
+};
+var fetchWithTimeout = async (url, apiKey, timeoutMs) => {
+  const controller = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+  const timer = setTimeout(() => controller == null ? void 0 : controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, {
+      method: "GET",
+      headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
+      signal: controller == null ? void 0 : controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var fetchWireFeatures = async (config) => {
+  const key = featuresCacheKey(config == null ? void 0 : config.appId);
+  const storage = config == null ? void 0 : config.storage;
+  if (!(config == null ? void 0 : config.serverUrl) || !(config == null ? void 0 : config.apiKey)) return failOpen(storage, key);
+  const url = `${config.serverUrl.replace(/\/$/, "")}/v1/features`;
+  const timeoutMs = config.timeoutMs && config.timeoutMs > 0 ? config.timeoutMs : DEFAULT_TIMEOUT_MS;
+  try {
+    const res = await fetchWithTimeout(url, config.apiKey, timeoutMs);
+    if (!res || !res.ok) return failOpen(storage, key);
+    const json = await res.json();
+    const features = parseWireFeatures(json);
+    if (storage) writeCachedFeatures(storage, key, features);
+    return features;
+  } catch {
+    return failOpen(storage, key);
+  }
+};
+
+// src/features/useWireFeatures.ts
+var useStableValue = (value, isEqual) => {
+  const ref = useRef(value);
+  if (!isEqual(ref.current, value)) ref.current = value;
+  return ref.current;
+};
+var sameFetchKey = (a, b) => (a == null ? void 0 : a.serverUrl) === (b == null ? void 0 : b.serverUrl) && (a == null ? void 0 : a.apiKey) === (b == null ? void 0 : b.apiKey) && (a == null ? void 0 : a.appId) === (b == null ? void 0 : b.appId);
+var useWireFeatures = (config) => {
+  const stableConfig = useStableValue(config, sameFetchKey);
+  const [flags, setFlags] = useState(defaultWireFeatures);
+  const canFetch = !!(stableConfig == null ? void 0 : stableConfig.serverUrl) && !!(stableConfig == null ? void 0 : stableConfig.apiKey);
+  useEffect(() => {
+    if (!canFetch) {
+      setFlags((prev) => featuresEqual(prev, defaultWireFeatures) ? prev : defaultWireFeatures);
+      return;
+    }
+    let alive = true;
+    void fetchWireFeatures(stableConfig).then((next) => {
+      if (!alive) return;
+      setFlags((prev) => featuresEqual(prev, next) ? prev : next);
+    });
+    return () => {
+      alive = false;
+    };
+  }, [canFetch, stableConfig]);
+  return flags;
+};
+var WireFeaturesContext = createContext(null);
+var useWireFeaturesContext = () => useContext(WireFeaturesContext);
+var useResolvedFeatures = (options) => {
+  var _a, _b, _c;
+  const ctx = useWireFeaturesContext();
+  const shouldFetch = !(options == null ? void 0 : options.flags) && ctx == null;
+  const fetched = useWireFeatures(shouldFetch ? options == null ? void 0 : options.config : void 0);
+  return (_c = (_b = (_a = options == null ? void 0 : options.flags) != null ? _a : ctx) != null ? _b : fetched) != null ? _c : defaultWireFeatures;
+};
+
+// src/reviews/equality.ts
+var shallowEqual = (a, b) => {
+  if (Object.is(a, b)) return true;
+  if (a == null || b == null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  for (const k of ak) {
+    if (!Object.is(a[k], b[k])) {
+      return false;
+    }
+  }
+  return true;
+};
+var sameDecision = (a, b) => {
+  if (a == null || b == null) return a == b;
+  return a.fire === b.fire && a.reason === b.reason;
+};
+
+// src/reviews/runtime.ts
+var reviewSeenKey = (id, version) => version ? `wire_review_${id}_${version}_seen` : `wire_review_${id}_seen`;
+var reviewLastShownKey = (id) => `wire_review_${id}_last`;
+var reviewSessionsKey = (id) => `wire_review_${id}_sessions`;
+var resolveStorage = (override) => override != null ? override : getCoachmarkStorage();
+var readInt = (storage, key) => {
+  if (!storage) return 0;
+  try {
+    const raw = storage.getItem(key);
+    const n = raw == null ? 0 : parseInt(raw, 10);
+    return Number.isFinite(n) ? n : 0;
+  } catch {
+    return 0;
+  }
+};
+var writeInt = (storage, key, value) => {
+  if (!storage) return;
+  try {
+    storage.setItem(key, String(value));
+  } catch {
+  }
+};
+
+// src/reviews/useReviewGate.ts
+var useStableValue2 = (value, isEqual) => {
+  const ref = useRef(value);
+  if (!isEqual(ref.current, value)) ref.current = value;
+  return ref.current;
+};
+var useReviewGate = ({
+  config: configProp,
+  decision: decisionProp,
+  events = 0,
+  storage,
+  isTesting,
+  features,
+  featuresConfig
+}) => {
+  const config = useStableValue2(configProp, shallowEqual);
+  const decision = useStableValue2(
+    decisionProp,
+    (a, b) => sameDecision(a, b)
+  );
+  const featureEnabled = useResolvedFeatures({ flags: features, config: featuresConfig }).review.enabled;
+  const testing2 = isTesting != null ? isTesting : isCoachmarkTesting();
+  const seenKey = reviewSeenKey(config.id, config.oncePerVersion === false ? void 0 : config.appVersion);
+  const lastKey = reviewLastShownKey(config.id);
+  const sessionsKey = reviewSessionsKey(config.id);
+  const sessions = useState(() => {
+    const store = resolveStorage(storage);
+    const next = readInt(store, sessionsKey) + 1;
+    writeInt(store, sessionsKey, next);
+    return next;
+  })[0];
+  const hasServerDecision = decision != null;
+  const timeoutMs = config.timeoutFallbackMs;
+  const waits = !hasServerDecision && timeoutMs != null && timeoutMs > 0;
+  const [elapsed, setElapsed] = useState(!waits);
+  useEffect(() => {
+    if (!waits) {
+      setElapsed(true);
+      return;
+    }
+    const timer = setTimeout(() => setElapsed(true), timeoutMs);
+    return () => clearTimeout(timer);
+  }, [waits, timeoutMs]);
+  const { visible, verdict } = useMemo(() => {
+    if (!featureEnabled) return { visible: false, verdict: { fire: false, reason: "feature_disabled" } };
+    if (testing2) return { visible: true, verdict: { fire: true, reason: "testing" } };
+    const store = resolveStorage(storage);
+    const local = evaluateGate(resolveRules(config), {
+      sessions,
+      events,
+      lastShownAt: readInt(store, lastKey) || null,
+      seen: hasSeenGate(seenKey, storage, isTesting),
+      now: Date.now()
+    });
+    const resolved = decideReview(local, decision);
+    const alreadySeen = hasSeenGate(seenKey, storage, isTesting);
+    const ready = hasServerDecision || elapsed;
+    return { visible: ready && resolved.fire && !alreadySeen, verdict: resolved };
+  }, [featureEnabled, testing2, config, decision, events, sessions, elapsed, hasServerDecision, seenKey, lastKey, storage, isTesting]);
+  const shownRef = useRef(false);
+  const markShown = useCallback(() => {
+    if (shownRef.current) return;
+    shownRef.current = true;
+    writeInt(resolveStorage(storage), lastKey, Date.now());
+  }, [storage, lastKey]);
+  const markResolved = useCallback(() => {
+    markSeenGate(seenKey, storage, isTesting);
+  }, [seenKey, storage, isTesting]);
+  return useMemo(
+    () => ({ visible, decision: verdict, markShown, markResolved }),
+    [visible, verdict, markShown, markResolved]
+  );
+};
+
+export { DEFAULT_PRESENTATION, FEEDBACK_MAX_LINES, FEEDBACK_MIN_LINES, CENTERED_MODAL_ANIM as REVIEW_MODAL_ANIM, ReviewGate, CenteredModal as ReviewModal, buildReviewSubmission, decideReview, centeredModalFrame as entranceFrame, evaluateGate, feedbackInputHeights, openStoreListing, reportAppEvent, requestStoreReview, resolvePresentation, resolveRules, reviewLastShownKey, reviewSeenKey, reviewSessionsKey, routeRating, sameDecision, shallowEqual, storeUrl, submitReview, useReviewGate };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map