@wireai/activation 0.1.0

package/dist/questionnaire/index.mjs

@@ -0,0 +1,906 @@
+import React4, { createContext, forwardRef, useRef, useState, useEffect, useCallback, useImperativeHandle, useContext, useMemo } from 'react';
+import { StyleSheet, Animated, Easing, BackHandler, Modal, Pressable, Text, AccessibilityInfo, TextInput } from 'react-native';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { SafeAreaView } from 'react-native-safe-area-context';
+
+// src/questionnaire/QuestionnaireGate.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/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 _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
+  }
+});
+
+// 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/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" };
+};
+
+// src/questionnaire/decision.ts
+var decideQuestionnaire = (local, decision) => decideReview(local, decision);
+var buildQuestionnaireSubmission = (input) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  const opinion = input.answers.opinion.trim();
+  const improve = (_a = input.answers.improve) == null ? void 0 : _a.trim();
+  const suggestions = (_b = input.answers.suggestions) == null ? void 0 : _b.trim();
+  return {
+    session_id: (_c = input.sessionId) != null ? _c : null,
+    answers: {
+      opinion,
+      improve: improve ? improve : null,
+      suggestions: suggestions ? suggestions : null
+    },
+    meta: {
+      user_id: (_e = (_d = input.meta) == null ? void 0 : _d.user_id) != null ? _e : null,
+      device_key: (_g = (_f = input.meta) == null ? void 0 : _f.device_key) != null ? _g : null,
+      session_count: (_i = (_h = input.meta) == null ? void 0 : _h.session_count) != null ? _i : null
+    }
+  };
+};
+
+// src/questionnaire/transport.ts
+var submitQuestionnaireResponse = (target, id, submission) => {
+  if (!(target == null ? void 0 : target.serverUrl) || !id) return;
+  try {
+    const base = target.serverUrl.replace(/\/$/, "");
+    const url = `${base}/v1/questionnaires/${encodeURIComponent(id)}/responses`;
+    const headers = { "Content-Type": "application/json" };
+    if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
+    void fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(submission)
+    }).catch(() => {
+    });
+  } catch {
+  }
+};
+var fetchQuestionnaireDecision = async (target, options = {}) => {
+  if (!(target == null ? void 0 : target.serverUrl)) return null;
+  try {
+    const base = target.serverUrl.replace(/\/$/, "");
+    const params = new URLSearchParams();
+    if (options.sessionId) params.set("session_id", options.sessionId);
+    if (options.deviceKey) params.set("device_key", options.deviceKey);
+    const qs = params.toString();
+    const url = `${base}/v1/questionnaires/decision${qs ? `?${qs}` : ""}`;
+    const headers = {};
+    if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
+    const res = await fetch(url, { headers });
+    if (!res || !res.ok) return null;
+    const json = await res.json();
+    return json != null ? json : null;
+  } catch {
+    return null;
+  }
+};
+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 QuestionnaireGate = ({
+  questionnaire,
+  target,
+  sessionId,
+  meta,
+  onEvent,
+  onResolved,
+  onShown,
+  theme: themeOverride,
+  dismissible = true
+}) => {
+  var _a, _b, _c, _d;
+  const active = useOnboardingTheme();
+  const t = useMemo(() => mergeThemeOver(active, themeOverride), [active, themeOverride]);
+  const modalRef = React4.useRef(null);
+  const id = questionnaire.id;
+  const [phase, setPhase] = useState("form");
+  const [opinion, setOpinion] = useState("");
+  const [improve, setImprove] = useState("");
+  const [suggestions, setSuggestions] = 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 _a2, _b2;
+    if (shownRef.current) return;
+    shownRef.current = true;
+    (_a2 = onShownRef.current) == null ? void 0 : _a2.call(onShownRef);
+    (_b2 = onEventRef.current) == null ? void 0 : _b2.call(onEventRef, { name: "questionnaire_prompt_shown", id });
+  }, []);
+  const resolve = useCallback(() => {
+    onResolved == null ? void 0 : onResolved();
+  }, [onResolved]);
+  const canSend = opinion.trim().length > 0;
+  const send = useCallback(() => {
+    if (!canSend) return;
+    const submission = buildQuestionnaireSubmission({
+      answers: { opinion, improve, suggestions },
+      sessionId,
+      meta
+    });
+    submitQuestionnaireResponse(target, id, submission);
+    onEvent == null ? void 0 : onEvent({ name: "questionnaire_submitted", id });
+    setPhase("thanks");
+    resolve();
+  }, [canSend, opinion, improve, suggestions, sessionId, meta, target, id, onEvent, resolve]);
+  const handleDismissTap = useCallback(() => {
+    var _a2;
+    onEvent == null ? void 0 : onEvent({ name: "questionnaire_dismissed", id });
+    (_a2 = modalRef.current) == null ? void 0 : _a2.close();
+  }, [onEvent, id]);
+  const title = (_a = questionnaire.title) != null ? _a : "How's it going so far?";
+  const opinionLabel = (_b = questionnaire.opinion_label) != null ? _b : "What do you think about the app?";
+  const improveLabel = (_c = questionnaire.improve_label) != null ? _c : "How can we improve? (optional)";
+  const suggestionsLabel = (_d = questionnaire.suggestions_label) != null ? _d : "Any suggestions? (optional)";
+  const opinionBox = 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 === "form" && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), { color: t.colors.textMuted }], children: "A few words is plenty. Only the first box is required." }),
+      /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), { color: t.colors.textMuted }], children: opinionLabel }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value: opinion,
+          onChangeText: setOpinion,
+          placeholder: "e.g. it feels fast and clear",
+          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: opinionBox.minHeight,
+              maxHeight: opinionBox.maxHeight
+            }
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx(Text, { style: [captionStyle(t.fonts), { color: t.colors.textMuted }], children: improveLabel }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value: improve,
+          onChangeText: setImprove,
+          placeholder: "e.g. fewer steps to start",
+          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(Text, { style: [captionStyle(t.fonts), { color: t.colors.textMuted }], children: suggestionsLabel }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          value: suggestions,
+          onChangeText: setSuggestions,
+          placeholder: "e.g. a dark theme",
+          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", onPress: send, variant: "primary", fullWidth: true, disabled: !canSend }),
+      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 === "thanks" && /* @__PURE__ */ jsx(Text, { style: [bodyStyle(t.fonts), { color: t.colors.textMuted }], children: "Thank you. This helps us make it better." })
+  ] });
+  return /* @__PURE__ */ jsx(CenteredModal, { ref: modalRef, theme: t, dismissible, onDismiss: resolve, children: content });
+};
+QuestionnaireGate.displayName = "QuestionnaireGate";
+var styles3 = StyleSheet.create({
+  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 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/questionnaire/runtime.ts
+var questionnaireSeenKey = (id, version) => version ? `wire_questionnaire_${id}_${version}_seen` : `wire_questionnaire_${id}_seen`;
+var questionnaireLastShownKey = (id) => `wire_questionnaire_${id}_last`;
+var questionnaireSessionsKey = (id) => `wire_questionnaire_${id}_sessions`;
+
+// src/questionnaire/useQuestionnaireGate.ts
+var useStableValue2 = (value, isEqual) => {
+  const ref = useRef(value);
+  if (!isEqual(ref.current, value)) ref.current = value;
+  return ref.current;
+};
+var useQuestionnaireGate = ({
+  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 }).questionnaire.enabled;
+  const testing2 = isTesting != null ? isTesting : isCoachmarkTesting();
+  const seenKey = questionnaireSeenKey(
+    config.id,
+    config.oncePerVersion === false ? void 0 : config.appVersion
+  );
+  const lastKey = questionnaireLastShownKey(config.id);
+  const sessionsKey = questionnaireSessionsKey(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 = decideQuestionnaire(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 { QuestionnaireGate, buildQuestionnaireSubmission, decideQuestionnaire, evaluateGate, fetchQuestionnaireDecision, questionnaireLastShownKey, questionnaireSeenKey, questionnaireSessionsKey, resolveRules, submitQuestionnaireResponse, useQuestionnaireGate };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map