@getdevteam/analytics-react-native 0.2.0 → 0.3.1

package/README.md

@@ -26,6 +26,46 @@ analytics.track("add_to_cart", { sku: "A-1" });
 The SDK auto-flushes when the app goes to the background.
 On a physical device use your machine's LAN IP instead of `localhost` when pointing at a local backend.
 
+## User feedback
+
+Create the client with `allowUserFeedback: true` and wrap your app in the exported provider:
+
+```tsx
+import { createAnalytics, FeedbackProvider } from "@getdevteam/analytics-react-native";
+
+const analytics = createAnalytics({
+  key: "dtp_your_public_key",
+  host: "https://ingest.analytics.getdevteam.ai",
+  allowUserFeedback: true,
+});
+
+export default function App() {
+  return (
+    <FeedbackProvider client={analytics}>
+      <RootNavigator />
+    </FeedbackProvider>
+  );
+}
+```
+
+A floating button opens a modal with a screenshot of the app, drawing tools, and a comment box; submit sends it to the platform's feedback inbox.
+`analytics.submitFeedback({ text, screenshot?, screenshotContentType?, pageUrl? })` sends feedback programmatically and resolves `false` instead of throwing on any failure.
+Customize with `feedback: { colors, accentColor, buttonLabel, title, submitLabel, commentPlaceholder, successMessage, position }`.
+
+Screenshot and drawing come from two optional peers, and each degrades instead of breaking:
+
+| Installed | Behavior |
+|---|---|
+| `react-native-view-shot` + `react-native-svg` | Screenshot, drawing tools, comment. |
+| `react-native-view-shot` only | Screenshot + comment, no drawing tools. |
+| neither | Comment-only feedback. |
+| app not wrapped in `FeedbackProvider`, or flag off | Nothing renders; the app is untouched. |
+
+The optional peers are loaded with literal `require` calls, each inside a try/catch, in the CJS build.
+That assumes Metro resolves this package's `require` export condition (the default) and keeps `transformer.allowOptionalDependencies` enabled (the React Native and Expo template default, and it only covers string-literal requires inside a try/catch), so a missing optional peer never fails the bundle.
+Import-condition consumers (react-native-web, Node ESM) cannot load the optional peers and degrade to comment-only feedback.
+Native views (maps, video, web views) may come out blank in captures; a failed capture falls back to comment-only.
+
 You need a public ingest key (`dtp_...`) and the ingest host URL for your environment - see [Getting a key](https://github.com/getdevteam-ai/analytics/tree/main/src/sdk#getting-a-key) in the full SDK docs.
 
 Full client API, config options, and release process: [src/sdk README](https://github.com/getdevteam-ai/analytics/tree/main/src/sdk).

package/dist/index.cjs

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  FeedbackProvider: () => FeedbackProvider,
   REACT_NATIVE_SDK_NAME: () => REACT_NATIVE_SDK_NAME,
   REACT_NATIVE_SDK_VERSION: () => REACT_NATIVE_SDK_VERSION,
   collectReactNativeContext: () => collectReactNativeContext,
@@ -39,7 +40,7 @@ __export(index_exports, {
   osNameFromPlatform: () => osNameFromPlatform
 });
 module.exports = __toCommonJS(index_exports);
-var import_analytics_core = require("@getdevteam/analytics-core");
+var import_analytics_core2 = require("@getdevteam/analytics-core");
 
 // src/appState.ts
 var import_react_native = require("react-native");
@@ -80,6 +81,55 @@ function collectReactNativeContext() {
   return context;
 }
 
+// src/feedback.ts
+var import_analytics_core = require("@getdevteam/analytics-core");
+var FEEDBACK_DEFAULT_COLORS = ["#f44336", "#4caf50", "#2196f3", "#ffeb3b"];
+var FEEDBACK_DEFAULT_ACCENT = "#5b9cf5";
+var MAX_TEXT_LENGTH = 1e4;
+var MAX_PAGE_URL_LENGTH = 2048;
+function createFeedbackSender(config) {
+  const url = `${String(config.host ?? "").replace(/\/+$/, "")}/v1/ingest/feedback`;
+  return async (input) => {
+    try {
+      const text = typeof input?.text === "string" ? input.text.trim() : "";
+      if (text.length === 0) {
+        config.onError(new Error("feedback text must be a non-empty string"));
+        return false;
+      }
+      const body = {
+        feedback_id: (0, import_analytics_core.uuidV7)(),
+        text: text.slice(0, MAX_TEXT_LENGTH)
+      };
+      if (typeof input.screenshot === "string" && input.screenshot.length > 0) {
+        body.screenshot = input.screenshot;
+        body.screenshot_content_type = input.screenshotContentType ?? "image/png";
+      }
+      const distinctId = config.getDistinctId();
+      if (distinctId) body.distinct_id = distinctId;
+      const sessionId = config.getSessionId();
+      if (sessionId) body.session_id = sessionId;
+      if (typeof input.pageUrl === "string" && input.pageUrl.length > 0) {
+        body.page_url = input.pageUrl.slice(0, MAX_PAGE_URL_LENGTH);
+      }
+      body.context = config.getContext();
+      if (!config.fetch) throw new Error("fetch is not available in this environment");
+      const response = await config.fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-DevTeam-Key": config.key },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        config.onError(new Error(`feedback ingest responded ${response.status}`));
+        return false;
+      }
+      return true;
+    } catch (error) {
+      config.onError(error);
+      return false;
+    }
+  };
+}
+
 // src/storage.ts
 var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"), 1);
 function createAsyncStorageAdapter() {
@@ -106,31 +156,540 @@ function createAsyncStorageAdapter() {
   };
 }
 
+// src/feedbackProvider.ts
+var import_react = require("react");
+var import_react_native3 = require("react-native");
+
+// src/optionalPeers.ts
+var testLoaderOverride;
+function requireViewShot() {
+  if (typeof require !== "function") return void 0;
+  try {
+    return require("react-native-view-shot");
+  } catch {
+    return void 0;
+  }
+}
+function requireSvg() {
+  if (typeof require !== "function") return void 0;
+  try {
+    return require("react-native-svg");
+  } catch {
+    return void 0;
+  }
+}
+function loadOptionalModule(name, requirePeer) {
+  if (testLoaderOverride) {
+    try {
+      return testLoaderOverride(name);
+    } catch {
+      return void 0;
+    }
+  }
+  return requirePeer();
+}
+function loadViewShot() {
+  const loaded = loadOptionalModule("react-native-view-shot", requireViewShot);
+  const captureRef = loaded?.captureRef ?? loaded?.default?.captureRef;
+  if (typeof captureRef !== "function") return void 0;
+  return { captureRef };
+}
+function loadSvg() {
+  const loaded = loadOptionalModule("react-native-svg", requireSvg);
+  const svg = loaded?.Svg ?? loaded?.default;
+  const polyline = loaded?.Polyline;
+  if (svg == null || polyline == null) return void 0;
+  return {
+    Svg: svg,
+    Polyline: polyline
+  };
+}
+
+// src/feedbackProvider.ts
+var PEN_WIDTH = 5;
+var SUCCESS_CLOSE_DELAY_MS = 1600;
+function FeedbackProvider(props) {
+  const options = props.client.feedbackOptions ?? {};
+  const colors = options.colors && options.colors.length > 0 ? options.colors : FEEDBACK_DEFAULT_COLORS;
+  const firstColor = colors[0] ?? FEEDBACK_DEFAULT_COLORS[0];
+  const accent = options.accentColor ?? FEEDBACK_DEFAULT_ACCENT;
+  const [visible, setVisible] = (0, import_react.useState)(false);
+  const [screenshot, setScreenshot] = (0, import_react.useState)(void 0);
+  const [screenshotSize, setScreenshotSize] = (0, import_react.useState)(void 0);
+  const [comment, setComment] = (0, import_react.useState)("");
+  const [sending, setSending] = (0, import_react.useState)(false);
+  const [sent, setSent] = (0, import_react.useState)(false);
+  const [errorMessage, setErrorMessage] = (0, import_react.useState)(void 0);
+  const [activeColor, setActiveColor] = (0, import_react.useState)(firstColor);
+  const [, setStrokeVersion] = (0, import_react.useState)(0);
+  const contentRef = (0, import_react.useRef)(null);
+  const previewRef = (0, import_react.useRef)(null);
+  const strokesRef = (0, import_react.useRef)([]);
+  const activeStrokeRef = (0, import_react.useRef)(void 0);
+  const activeColorRef = (0, import_react.useRef)(firstColor);
+  const closeTimerRef = (0, import_react.useRef)(void 0);
+  const sessionRef = (0, import_react.useRef)(0);
+  (0, import_react.useEffect)(
+    () => () => {
+      if (closeTimerRef.current !== void 0) clearTimeout(closeTimerRef.current);
+    },
+    []
+  );
+  const bumpStrokes = (0, import_react.useCallback)(() => setStrokeVersion((version) => version + 1), []);
+  const panResponderRef = (0, import_react.useRef)(
+    import_react_native3.PanResponder.create({
+      onStartShouldSetPanResponder: () => true,
+      onMoveShouldSetPanResponder: () => true,
+      onPanResponderGrant: (event) => {
+        const { locationX, locationY } = event.nativeEvent;
+        const stroke = {
+          points: [{ x: locationX, y: locationY }],
+          color: activeColorRef.current,
+          width: PEN_WIDTH
+        };
+        activeStrokeRef.current = stroke;
+        strokesRef.current.push(stroke);
+        bumpStrokes();
+      },
+      onPanResponderMove: (event) => {
+        const stroke = activeStrokeRef.current;
+        if (!stroke) return;
+        stroke.points.push({ x: event.nativeEvent.locationX, y: event.nativeEvent.locationY });
+        bumpStrokes();
+      },
+      onPanResponderRelease: () => {
+        activeStrokeRef.current = void 0;
+      },
+      onPanResponderTerminate: () => {
+        activeStrokeRef.current = void 0;
+      }
+    })
+  );
+  const close = (0, import_react.useCallback)(() => {
+    sessionRef.current += 1;
+    if (closeTimerRef.current !== void 0) {
+      clearTimeout(closeTimerRef.current);
+      closeTimerRef.current = void 0;
+    }
+    setVisible(false);
+    setScreenshot(void 0);
+    setScreenshotSize(void 0);
+    setComment("");
+    setSending(false);
+    setSent(false);
+    setErrorMessage(void 0);
+    strokesRef.current = [];
+    activeStrokeRef.current = void 0;
+  }, []);
+  const open = (0, import_react.useCallback)(async () => {
+    sessionRef.current += 1;
+    try {
+      strokesRef.current = [];
+      activeStrokeRef.current = void 0;
+      activeColorRef.current = firstColor;
+      setActiveColor(firstColor);
+      setComment("");
+      setSent(false);
+      setSending(false);
+      setErrorMessage(void 0);
+      let shot;
+      const viewShot = loadViewShot();
+      if (viewShot && contentRef.current) {
+        try {
+          shot = await viewShot.captureRef(contentRef.current, {
+            format: "png",
+            quality: 0.9,
+            result: "base64"
+          });
+        } catch (captureError) {
+          props.client.reportError(captureError);
+          shot = void 0;
+        }
+      }
+      setScreenshotSize(shot ? await capturedImageSize(shot) : void 0);
+      setScreenshot(shot);
+      setVisible(true);
+    } catch (openError) {
+      props.client.reportError(openError);
+      setScreenshotSize(void 0);
+      setScreenshot(void 0);
+      setVisible(true);
+    }
+  }, [firstColor, props.client]);
+  const submit = (0, import_react.useCallback)(async () => {
+    if (sending || sent) return;
+    const text = comment.trim();
+    if (text.length === 0) {
+      setErrorMessage("Please add a short comment before sending.");
+      return;
+    }
+    const session = sessionRef.current;
+    setSending(true);
+    setErrorMessage(void 0);
+    try {
+      let finalScreenshot = screenshot;
+      const viewShot = loadViewShot();
+      if (screenshot && strokesRef.current.length > 0 && viewShot && previewRef.current) {
+        try {
+          finalScreenshot = await viewShot.captureRef(previewRef.current, {
+            format: "png",
+            quality: 0.9,
+            result: "base64"
+          });
+        } catch (flattenError) {
+          props.client.reportError(flattenError);
+        }
+      }
+      const submission = { text };
+      if (finalScreenshot) {
+        submission.screenshot = finalScreenshot;
+        submission.screenshotContentType = "image/png";
+      }
+      const ok = await props.client.submitFeedback(submission);
+      if (sessionRef.current !== session) return;
+      if (ok) {
+        setSent(true);
+        closeTimerRef.current = setTimeout(close, SUCCESS_CLOSE_DELAY_MS);
+      } else {
+        setErrorMessage("Could not send feedback. Please try again.");
+      }
+    } catch {
+      if (sessionRef.current === session) {
+        setErrorMessage("Could not send feedback. Please try again.");
+      }
+    } finally {
+      if (sessionRef.current === session) {
+        setSending(false);
+      }
+    }
+  }, [close, comment, props.client, screenshot, sending, sent]);
+  const undo = (0, import_react.useCallback)(() => {
+    if (activeStrokeRef.current) return;
+    strokesRef.current.pop();
+    bumpStrokes();
+  }, [bumpStrokes]);
+  const clear = (0, import_react.useCallback)(() => {
+    if (activeStrokeRef.current) return;
+    strokesRef.current = [];
+    bumpStrokes();
+  }, [bumpStrokes]);
+  if (props.client.userFeedbackAllowed !== true || typeof props.client.submitFeedback !== "function") {
+    return (0, import_react.createElement)(import_react.Fragment, null, props.children);
+  }
+  const svg = loadSvg();
+  const window = import_react_native3.Dimensions.get("window");
+  const previewAspectRatio = screenshotSize && screenshotSize.height > 0 ? screenshotSize.width / screenshotSize.height : window.height > 0 ? window.width / window.height : 1;
+  const positionStyle = options.position === "bottom-left" ? styles.fabLeft : styles.fabRight;
+  const preview = screenshot ? (0, import_react.createElement)(
+    import_react_native3.View,
+    {
+      style: [styles.preview, { aspectRatio: previewAspectRatio }],
+      testID: "devteam-feedback-preview-frame"
+    },
+    (0, import_react.createElement)(
+      import_react_native3.View,
+      { ref: previewRef, collapsable: false, style: styles.previewSurface },
+      (0, import_react.createElement)(import_react_native3.Image, {
+        source: { uri: `data:image/png;base64,${screenshot}` },
+        style: styles.previewImage,
+        resizeMode: "stretch",
+        testID: "devteam-feedback-preview"
+      }),
+      svg ? (0, import_react.createElement)(
+        import_react_native3.View,
+        { style: styles.drawLayer, ...panResponderRef.current.panHandlers },
+        (0, import_react.createElement)(
+          svg.Svg,
+          { width: "100%", height: "100%" },
+          ...strokesRef.current.map(
+            (stroke, index) => (0, import_react.createElement)(svg.Polyline, {
+              key: String(index),
+              points: stroke.points.map((point) => `${point.x},${point.y}`).join(" "),
+              fill: "none",
+              stroke: stroke.color,
+              strokeWidth: stroke.width,
+              strokeLinecap: "round",
+              strokeLinejoin: "round"
+            })
+          )
+        )
+      ) : null
+    )
+  ) : null;
+  const tools = screenshot && svg ? (0, import_react.createElement)(
+    import_react_native3.View,
+    { style: styles.tools },
+    ...colors.map(
+      (color) => (0, import_react.createElement)(import_react_native3.Pressable, {
+        key: color,
+        accessibilityRole: "button",
+        testID: `devteam-feedback-color-${color}`,
+        onPress: () => {
+          activeColorRef.current = color;
+          setActiveColor(color);
+        },
+        style: [
+          styles.swatch,
+          { backgroundColor: color },
+          activeColor === color ? styles.swatchActive : null
+        ]
+      })
+    ),
+    (0, import_react.createElement)(
+      import_react_native3.Pressable,
+      {
+        accessibilityRole: "button",
+        testID: "devteam-feedback-undo",
+        onPress: undo,
+        style: styles.toolButton
+      },
+      (0, import_react.createElement)(import_react_native3.Text, { style: styles.toolLabel }, "Undo")
+    ),
+    (0, import_react.createElement)(
+      import_react_native3.Pressable,
+      {
+        accessibilityRole: "button",
+        testID: "devteam-feedback-clear",
+        onPress: clear,
+        style: styles.toolButton
+      },
+      (0, import_react.createElement)(import_react_native3.Text, { style: styles.toolLabel }, "Clear")
+    )
+  ) : null;
+  const modal = (0, import_react.createElement)(
+    import_react_native3.Modal,
+    { visible, transparent: true, animationType: "fade", onRequestClose: close },
+    (0, import_react.createElement)(
+      import_react_native3.View,
+      { style: styles.backdrop },
+      (0, import_react.createElement)(
+        import_react_native3.View,
+        { style: styles.panel },
+        (0, import_react.createElement)(import_react_native3.Text, { style: styles.title }, options.title ?? "Send feedback"),
+        preview,
+        tools,
+        (0, import_react.createElement)(import_react_native3.TextInput, {
+          multiline: true,
+          value: comment,
+          onChangeText: setComment,
+          placeholder: options.commentPlaceholder ?? "What went wrong, or what could be better?",
+          style: styles.input,
+          testID: "devteam-feedback-comment"
+        }),
+        errorMessage ? (0, import_react.createElement)(import_react_native3.Text, { style: styles.error, testID: "devteam-feedback-error" }, errorMessage) : null,
+        sent ? (0, import_react.createElement)(
+          import_react_native3.Text,
+          { style: styles.success, testID: "devteam-feedback-success" },
+          options.successMessage ?? "Thanks for the feedback!"
+        ) : null,
+        (0, import_react.createElement)(
+          import_react_native3.View,
+          { style: styles.actions },
+          (0, import_react.createElement)(
+            import_react_native3.Pressable,
+            {
+              accessibilityRole: "button",
+              testID: "devteam-feedback-cancel",
+              onPress: close,
+              style: styles.cancelButton
+            },
+            (0, import_react.createElement)(import_react_native3.Text, { style: styles.cancelLabel }, "Cancel")
+          ),
+          (0, import_react.createElement)(
+            import_react_native3.Pressable,
+            {
+              accessibilityRole: "button",
+              testID: "devteam-feedback-submit",
+              disabled: sending || sent,
+              onPress: () => {
+                void submit();
+              },
+              style: [styles.submitButton, { backgroundColor: accent }]
+            },
+            (0, import_react.createElement)(import_react_native3.Text, { style: styles.submitLabel }, options.submitLabel ?? "Send")
+          )
+        )
+      )
+    )
+  );
+  return (0, import_react.createElement)(
+    import_react_native3.View,
+    { style: styles.root },
+    (0, import_react.createElement)(
+      import_react_native3.View,
+      { ref: contentRef, collapsable: false, style: styles.content },
+      props.children
+    ),
+    (0, import_react.createElement)(
+      import_react_native3.Pressable,
+      {
+        accessibilityRole: "button",
+        testID: "devteam-feedback-button",
+        onPress: () => {
+          void open();
+        },
+        style: [styles.fab, positionStyle, { backgroundColor: accent }]
+      },
+      (0, import_react.createElement)(import_react_native3.Text, { style: styles.fabLabel }, options.buttonLabel ?? "Feedback")
+    ),
+    modal
+  );
+}
+function capturedImageSize(base64) {
+  return new Promise((resolve) => {
+    try {
+      import_react_native3.Image.getSize(
+        `data:image/png;base64,${base64}`,
+        (width, height) => resolve(width > 0 && height > 0 ? { width, height } : void 0),
+        () => resolve(void 0)
+      );
+    } catch {
+      resolve(void 0);
+    }
+  });
+}
+var styles = import_react_native3.StyleSheet.create({
+  root: { flex: 1 },
+  content: { flex: 1 },
+  fab: {
+    position: "absolute",
+    bottom: 24,
+    borderRadius: 999,
+    paddingVertical: 10,
+    paddingHorizontal: 18,
+    elevation: 4
+  },
+  fabRight: { right: 20 },
+  fabLeft: { left: 20 },
+  fabLabel: { color: "#ffffff", fontSize: 14, fontWeight: "600" },
+  backdrop: {
+    flex: 1,
+    backgroundColor: "rgba(15, 23, 42, 0.55)",
+    alignItems: "center",
+    justifyContent: "center",
+    padding: 16
+  },
+  panel: {
+    width: "100%",
+    maxWidth: 560,
+    backgroundColor: "#ffffff",
+    borderRadius: 12,
+    padding: 16,
+    gap: 10
+  },
+  title: { fontSize: 16, fontWeight: "600", color: "#1f2933" },
+  preview: {
+    width: "100%",
+    borderRadius: 8,
+    borderWidth: 1,
+    borderColor: "#d3dce6",
+    overflow: "hidden"
+  },
+  previewSurface: { width: "100%", height: "100%" },
+  previewImage: { width: "100%", height: "100%" },
+  drawLayer: { position: "absolute", top: 0, right: 0, bottom: 0, left: 0 },
+  tools: { flexDirection: "row", alignItems: "center", gap: 8 },
+  swatch: { width: 24, height: 24, borderRadius: 12, borderWidth: 2, borderColor: "transparent" },
+  swatchActive: { borderColor: "#1f2933" },
+  toolButton: {
+    borderWidth: 1,
+    borderColor: "#d3dce6",
+    borderRadius: 6,
+    paddingVertical: 4,
+    paddingHorizontal: 10
+  },
+  toolLabel: { fontSize: 13, color: "#1f2933" },
+  input: {
+    minHeight: 72,
+    borderWidth: 1,
+    borderColor: "#d3dce6",
+    borderRadius: 8,
+    padding: 10,
+    color: "#1f2933",
+    textAlignVertical: "top"
+  },
+  error: { color: "#b91c1c", fontSize: 13 },
+  success: { color: "#15803d", fontSize: 14, fontWeight: "600" },
+  actions: { flexDirection: "row", justifyContent: "flex-end", gap: 8 },
+  cancelButton: {
+    borderWidth: 1,
+    borderColor: "#d3dce6",
+    borderRadius: 8,
+    paddingVertical: 8,
+    paddingHorizontal: 14
+  },
+  cancelLabel: { fontSize: 14, color: "#1f2933" },
+  submitButton: { borderRadius: 8, paddingVertical: 8, paddingHorizontal: 16 },
+  submitLabel: { fontSize: 14, fontWeight: "600", color: "#ffffff" }
+});
+
 // src/index.ts
 var REACT_NATIVE_SDK_NAME = "@getdevteam/analytics-react-native";
-var REACT_NATIVE_SDK_VERSION = "0.2.0";
+var REACT_NATIVE_SDK_VERSION = "0.3.1";
 function createAnalytics(config) {
-  const client = (0, import_analytics_core.createClient)({
+  const client = (0, import_analytics_core2.createClient)({
     ...config,
     storage: config.storage ?? createAsyncStorageAdapter()
   });
-  client.setContext({
+  const reactNativeContext = {
     sdk_name: REACT_NATIVE_SDK_NAME,
     sdk_version: REACT_NATIVE_SDK_VERSION,
     ...collectReactNativeContext(),
     ...config.context
-  });
+  };
+  client.setContext(reactNativeContext);
+  let currentContext = reactNativeContext;
+  const setContext = (partial) => {
+    client.setContext(partial);
+    try {
+      const next = { ...currentContext };
+      for (const [key, value] of Object.entries(partial)) {
+        if (value === void 0) {
+          delete next[key];
+        } else {
+          next[key] = value;
+        }
+      }
+      currentContext = next;
+    } catch {
+    }
+  };
   const removeAppStateFlush = installAppStateFlush(client);
+  const reportError = (error) => {
+    try {
+      config.onError?.(error);
+    } catch {
+    }
+  };
+  const submitFeedback = createFeedbackSender({
+    host: config.host,
+    key: config.key,
+    fetch: config.fetch ?? defaultReactNativeFetch(),
+    getDistinctId: () => client.getDistinctId(),
+    getSessionId: () => client.getSessionId(),
+    getContext: () => currentContext,
+    onError: reportError
+  });
   return {
     ...client,
+    setContext,
+    submitFeedback,
+    reportError,
+    userFeedbackAllowed: config.allowUserFeedback === true,
+    feedbackOptions: config.feedback ?? {},
     shutdown: async () => {
       removeAppStateFlush();
       await client.shutdown();
     }
   };
 }
+function defaultReactNativeFetch() {
+  if (typeof fetch !== "function") return void 0;
+  return (url, init) => fetch(url, init);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  FeedbackProvider,
   REACT_NATIVE_SDK_NAME,
   REACT_NATIVE_SDK_VERSION,
   collectReactNativeContext,