@getuserfeedback/react-native 5.9.0 → 5.11.0

package/dist/expo-router.d.ts

@@ -0,0 +1,24 @@
+import type { EventProperties } from "./client.js";
+import { type ScreenTrackingErrorHandler } from "./screen-tracking.js";
+export type ExpoRouterScreen = {
+    name: string;
+    properties?: EventProperties;
+};
+export type ExpoRouterScreenTrackingOptions = {
+    /**
+     * Maps the current pathname to a stable screen name and safe properties.
+     * Return `null` to ignore a pathname.
+     */
+    toScreen?: (pathname: string) => ExpoRouterScreen | null | undefined;
+    /** Receives rejected `screen()` calls. */
+    onError?: ScreenTrackingErrorHandler;
+};
+/**
+ * Reports Expo Router pathname changes through `client.screen()`.
+ *
+ * Pass the value returned by Expo Router's `usePathname()`. Keeping that hook
+ * in application code lets this adapter stay optional and avoids making Expo a
+ * dependency of the React Native SDK. Consecutive renders of the same pathname
+ * are treated as one screen transition.
+ */
+export declare function useExpoRouterScreenTracking(pathname: string, options?: ExpoRouterScreenTrackingOptions): void;

package/dist/expo-router.js

@@ -0,0 +1,24 @@
+import { useEffect } from "react";
+import { useScreenOccurrenceReporter, } from "./screen-tracking.js";
+/**
+ * Reports Expo Router pathname changes through `client.screen()`.
+ *
+ * Pass the value returned by Expo Router's `usePathname()`. Keeping that hook
+ * in application code lets this adapter stay optional and avoids making Expo a
+ * dependency of the React Native SDK. Consecutive renders of the same pathname
+ * are treated as one screen transition.
+ */
+export function useExpoRouterScreenTracking(pathname, options = {}) {
+    const reportScreen = useScreenOccurrenceReporter(options.onError);
+    useEffect(() => {
+        const screen = options.toScreen
+            ? options.toScreen(pathname)
+            : { name: pathname };
+        reportScreen({
+            key: pathname,
+            screen: screen
+                ? { name: screen.name, properties: screen.properties }
+                : null,
+        });
+    }, [options.toScreen, pathname, reportScreen]);
+}

package/dist/native-provider-client.js

@@ -39,14 +39,14 @@ export function createNativeProviderClient({ dispatchCommand, flow, instanceId,
     const track = (eventName, properties, options) => {
         return dispatchCommand(buildCustomerOccurrenceCommand({
             type: "track",
-            event: parseRequiredString("eventName", eventName),
+            event: eventName,
             properties,
             options,
         }));
     };
     const screen = (name, properties, options) => dispatchCommand(buildCustomerOccurrenceCommand({
         type: "screen",
-        event: parseRequiredString("screenName", name),
+        event: name,
         properties,
         options,
     }));

package/dist/react-navigation-screen-observer.d.ts

@@ -0,0 +1,24 @@
+import type { EventProperties } from "./client.js";
+import type { ScreenTrackingObservation } from "./screen-tracking.js";
+/** The active-route fields used by the React Navigation adapter. */
+export type ReactNavigationRoute = {
+    key: string;
+    name: string;
+    params?: unknown;
+};
+/** Structural subset of a React Navigation container ref. */
+export type ReactNavigationContainerRef = {
+    addListener: (event: "state", listener: () => void) => () => void;
+    getCurrentRoute: () => ReactNavigationRoute | undefined;
+    isReady: () => boolean;
+};
+export type ReactNavigationScreen = {
+    name: string;
+    properties?: EventProperties;
+};
+export type ReactNavigationScreenMapper = (route: ReactNavigationRoute) => ReactNavigationScreen | null | undefined;
+export declare function observeReactNavigationScreens(input: {
+    navigationRef: ReactNavigationContainerRef;
+    observeScreen: (observation: ScreenTrackingObservation) => void;
+    toScreen?: ReactNavigationScreenMapper;
+}): () => void;

package/dist/react-navigation-screen-observer.js

@@ -0,0 +1,29 @@
+export function observeReactNavigationScreens(input) {
+    const reportCurrentRoute = () => {
+        if (!input.navigationRef.isReady()) {
+            return;
+        }
+        const route = input.navigationRef.getCurrentRoute();
+        if (!route) {
+            return;
+        }
+        const screen = input.toScreen
+            ? input.toScreen(route)
+            : { name: route.name };
+        input.observeScreen({
+            key: route.key,
+            screen: screen
+                ? { name: screen.name, properties: screen.properties }
+                : null,
+        });
+    };
+    const unsubscribeState = input.navigationRef.addListener("state", reportCurrentRoute);
+    try {
+        reportCurrentRoute();
+    }
+    catch (error) {
+        unsubscribeState();
+        throw error;
+    }
+    return unsubscribeState;
+}

package/dist/react-navigation.d.ts

@@ -0,0 +1,20 @@
+import { type ReactNavigationContainerRef, type ReactNavigationScreenMapper } from "./react-navigation-screen-observer.js";
+import { type ScreenTrackingErrorHandler } from "./screen-tracking.js";
+export type { ReactNavigationContainerRef, ReactNavigationRoute, ReactNavigationScreen, } from "./react-navigation-screen-observer.js";
+export type ReactNavigationScreenTrackingOptions = {
+    /**
+     * Maps an active route to a stable screen name and safe event properties.
+     * Return `null` to ignore a route.
+     */
+    toScreen?: ReactNavigationScreenMapper;
+    /** Receives rejected `screen()` calls. */
+    onError?: ScreenTrackingErrorHandler;
+};
+/**
+ * Reports the active React Navigation route through `client.screen()`.
+ *
+ * Mount once below `GetUserFeedbackProvider` and pass the same ref used by the
+ * root navigation container. Consecutive notifications for the same route
+ * occurrence are ignored.
+ */
+export declare function useReactNavigationScreenTracking(navigationRef: ReactNavigationContainerRef, options?: ReactNavigationScreenTrackingOptions): void;

package/dist/react-navigation.js

@@ -0,0 +1,18 @@
+import { useEffect } from "react";
+import { observeReactNavigationScreens, } from "./react-navigation-screen-observer.js";
+import { useScreenOccurrenceReporter, } from "./screen-tracking.js";
+/**
+ * Reports the active React Navigation route through `client.screen()`.
+ *
+ * Mount once below `GetUserFeedbackProvider` and pass the same ref used by the
+ * root navigation container. Consecutive notifications for the same route
+ * occurrence are ignored.
+ */
+export function useReactNavigationScreenTracking(navigationRef, options = {}) {
+    const reportScreen = useScreenOccurrenceReporter(options.onError);
+    useEffect(() => observeReactNavigationScreens({
+        navigationRef,
+        observeScreen: reportScreen,
+        toScreen: options.toScreen,
+    }), [navigationRef, options.toScreen, reportScreen]);
+}

package/dist/screen-tracking.d.ts

@@ -0,0 +1,23 @@
+import { type MutableRefObject } from "react";
+import type { Client, EventProperties } from "./client.js";
+type ScreenTrackingScreen = {
+    name: string;
+    properties?: EventProperties;
+};
+export type ScreenTrackingObservation = {
+    key: string;
+    screen: ScreenTrackingScreen | null;
+};
+export type ScreenTrackingErrorHandler = (error: Error) => void | PromiseLike<void>;
+type LastReportedScreen = {
+    client: Client;
+    key: string;
+};
+export declare const reportScreenOccurrence: (input: {
+    client: Client;
+    observation: ScreenTrackingObservation;
+    lastReportedRef: MutableRefObject<LastReportedScreen | null>;
+    onError?: ScreenTrackingErrorHandler;
+}) => void;
+export declare const useScreenOccurrenceReporter: (onError?: ScreenTrackingErrorHandler) => ((observation: ScreenTrackingObservation) => void);
+export {};

package/dist/screen-tracking.js

@@ -0,0 +1,45 @@
+import { useCallback, useRef } from "react";
+import { useGetUserFeedback } from "./native-provider.js";
+const toError = (value) => value instanceof Error ? value : new Error(String(value));
+const reportTrackingError = (onError, error) => {
+    try {
+        void Promise.resolve(onError === null || onError === void 0 ? void 0 : onError(toError(error))).catch(() => { });
+    }
+    catch (_a) {
+        // Error observers cannot destabilize router listeners or React effects.
+    }
+};
+export const reportScreenOccurrence = (input) => {
+    var _a;
+    if (((_a = input.lastReportedRef.current) === null || _a === void 0 ? void 0 : _a.client) === input.client &&
+        input.lastReportedRef.current.key === input.observation.key) {
+        return;
+    }
+    input.lastReportedRef.current = {
+        client: input.client,
+        key: input.observation.key,
+    };
+    if (!input.observation.screen) {
+        return;
+    }
+    try {
+        void input.client
+            .screen(input.observation.screen.name, input.observation.screen.properties)
+            .catch((error) => reportTrackingError(input.onError, error));
+    }
+    catch (error) {
+        reportTrackingError(input.onError, error);
+    }
+};
+export const useScreenOccurrenceReporter = (onError) => {
+    const client = useGetUserFeedback();
+    const lastReportedRef = useRef(null);
+    const onErrorRef = useRef(onError);
+    onErrorRef.current = onError;
+    return useCallback((observation) => reportScreenOccurrence({
+        client,
+        observation,
+        lastReportedRef,
+        onError: onErrorRef.current,
+    }), [client]);
+};

package/dist/version.js

@@ -3,4 +3,4 @@ const reactNativeSdkVersion = typeof __GX_REACT_NATIVE_SDK_VERSION__ === "string
     : "";
 // Build scripts patch this fallback to the package version for published artifacts.
 // Source-linked workspace usage keeps the local fallback.
-export const REACT_NATIVE_SDK_VERSION = reactNativeSdkVersion.length > 0 ? reactNativeSdkVersion : "5.9.0";
+export const REACT_NATIVE_SDK_VERSION = reactNativeSdkVersion.length > 0 ? reactNativeSdkVersion : "5.11.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "5.9.0",
+  "version": "5.11.0",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -26,6 +26,16 @@
       "types": "./dist/public-api.d.ts",
       "import": "./dist/public-api.js",
       "default": "./dist/public-api.js"
+    },
+    "./expo-router": {
+      "types": "./dist/expo-router.d.ts",
+      "import": "./dist/expo-router.js",
+      "default": "./dist/expo-router.js"
+    },
+    "./react-navigation": {
+      "types": "./dist/react-navigation.d.ts",
+      "import": "./dist/react-navigation.js",
+      "default": "./dist/react-navigation.js"
     }
   },
   "files": [
@@ -44,8 +54,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^5.4.1",
-    "@getuserfeedback/sdk": "^0.17.1",
+    "@getuserfeedback/protocol": "^5.4.2",
+    "@getuserfeedback/sdk": "^0.18.0",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {