@getuserfeedback/react-native 2.0.14 → 2.0.15

package/dist/index.d.ts

@@ -27,6 +27,8 @@ type TrackOptions = {
 };
 type OpenOptions = Pick<OpenCommand, "hideCloseButton">;
 type PrerenderOptions = Pick<PrerenderCommand, "hideCloseButton">;
+export type OpenFlowOptions = Pick<OpenCommand, "hideCloseButton" | "metadata">;
+export type PrerenderFlowOptions = Pick<PrerenderCommand, "hideCloseButton">;
 type HostContext = Extract<PublicCommandPayload, {
     kind: "updateHostContext";
 }>["context"];
@@ -39,6 +41,13 @@ export interface ReactNativeCommandResult {
 export interface ReactNativeCommandOptions {
     idempotencyKey?: string;
 }
+export interface ReactNativeFlowRun {
+    readonly flowId: string;
+    open: (options?: OpenFlowOptions) => Promise<void>;
+    prefetch: () => Promise<void>;
+    prerender: (options?: PrerenderFlowOptions) => Promise<void>;
+    close: () => Promise<void>;
+}
 export interface ReactNativeGetUserFeedbackClient {
     readonly instanceId: string;
     readonly nativeMessages: readonly ReactNativeWidgetNativeMessage[];
@@ -53,6 +62,7 @@ export interface ReactNativeGetUserFeedbackClient {
     open: (flowId: string, options?: OpenOptions, commandOptions?: ReactNativeCommandOptions) => Promise<ReactNativeCommandResult>;
     prefetch: (flowId: string, options?: ReactNativeCommandOptions) => Promise<ReactNativeCommandResult>;
     prerender: (flowId: string, options?: PrerenderOptions, commandOptions?: ReactNativeCommandOptions) => Promise<ReactNativeCommandResult>;
+    flow: (flowId: string) => ReactNativeFlowRun;
     close: (flowHandleId?: string, options?: ReactNativeCommandOptions) => Promise<ReactNativeCommandResult>;
     reset: (options?: ReactNativeCommandOptions) => Promise<ReactNativeCommandResult>;
     updateHostContext: (context: HostContext, options?: ReactNativeCommandOptions) => Promise<ReactNativeCommandResult>;

package/dist/index.js

@@ -9,7 +9,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { assertNoSegmentExternalIdsInValueArgument, CommandSettlementTimeoutError, getWidgetLayoutPlanNowMs, } from "@getuserfeedback/protocol/host";
+import { assertNoSegmentExternalIdsInValueArgument, CommandSettlementError, CommandSettlementTimeoutError, createFlowCommandHandleController, getFlowHandleFromSettlementDetail, getWidgetLayoutPlanNowMs, } from "@getuserfeedback/protocol/host";
 import { parseWebViewTransportNativeMessage } from "@getuserfeedback/protocol/webview-transport";
 import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { useResolvedHostViewport } from "./host-viewport.js";
@@ -26,6 +26,102 @@ const GetUserFeedbackNativeContext = createContext(null);
 const DEFAULT_COMMAND_TIMEOUT_MS = 30000;
 const PROVIDER_UNMOUNTED_ERROR_MESSAGE = "GetUserFeedbackProvider unmounted before command settled";
 const STARTUP_COMMAND_REPLACED_ERROR_MESSAGE = "GetUserFeedbackProvider replaced startup command before settlement";
+const STALE_HANDLE_ERROR_CODE = "STALE_HANDLE";
+const isStaleHandleError = (error) => {
+    if (error instanceof CommandSettlementError) {
+        return error.code === STALE_HANDLE_ERROR_CODE;
+    }
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.message.includes("flowHandleId is stale");
+};
+const toFlowHandleIdFromResult = (result) => {
+    if (!result.settlement) {
+        return undefined;
+    }
+    const handle = getFlowHandleFromSettlementDetail(result.settlement);
+    return handle === null || handle === void 0 ? void 0 : handle.flowHandleId;
+};
+const createReactNativeFlowRunController = (flowId, { enqueueFlowCommand, enqueueScopedClose, reportCommandError, }) => {
+    let pendingClose = false;
+    const handleClient = createFlowCommandHandleController({
+        getHandleIdFromSettlement: toFlowHandleIdFromResult,
+        isStaleHandleError,
+        onClearResolvedHandle: () => { },
+    });
+    const reportAsyncCommandError = (promise) => promise.catch((error) => {
+        reportCommandError(error instanceof Error ? error : new Error(String(error)));
+        throw error;
+    });
+    const clearResolvedHandle = () => {
+        handleClient.clearResolvedHandle();
+    };
+    const reset = () => {
+        pendingClose = false;
+        handleClient.reset();
+    };
+    const resetIdleHandle = () => {
+        if (handleClient.hasPendingCommands()) {
+            return;
+        }
+        reset();
+    };
+    const enqueueAndWaitForSettlement = async (buildPayload) => {
+        try {
+            await handleClient.runCommand(buildPayload, enqueueFlowCommand);
+        }
+        catch (error) {
+            pendingClose = false;
+            throw error;
+        }
+    };
+    handleClient.subscribeHandle((flowHandleId) => {
+        if (!pendingClose) {
+            return;
+        }
+        pendingClose = false;
+        reportAsyncCommandError(enqueueScopedClose(flowHandleId)).catch(() => { });
+    });
+    return {
+        flowId,
+        open: (options) => reportAsyncCommandError(enqueueAndWaitForSettlement((flowHandleId) => ({
+            kind: "open",
+            flowId,
+            flowHandleId,
+            metadata: options === null || options === void 0 ? void 0 : options.metadata,
+            hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
+        }))),
+        prefetch: () => reportAsyncCommandError(enqueueAndWaitForSettlement((flowHandleId) => ({
+            kind: "prefetch",
+            flowId,
+            flowHandleId,
+        }))),
+        prerender: (options) => reportAsyncCommandError(enqueueAndWaitForSettlement((flowHandleId) => ({
+            kind: "prerender",
+            flowId,
+            flowHandleId,
+            hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
+        }))),
+        close: () => {
+            const flowHandleId = handleClient.getHandleId();
+            if (!flowHandleId) {
+                pendingClose = handleClient.hasPendingCommands();
+                return Promise.resolve();
+            }
+            if (handleClient.hasPendingCommands()) {
+                pendingClose = true;
+                return Promise.resolve();
+            }
+            pendingClose = false;
+            return reportAsyncCommandError(enqueueScopedClose(flowHandleId));
+        },
+        clearResolvedHandle,
+        hasFlowHandleId: (flowHandleId) => handleClient.getHandleId() === flowHandleId,
+        reset,
+        resetIdleHandle,
+    };
+};
 const CLIENT_META = {
     clientName: "@getuserfeedback/react-native",
     clientVersion: REACT_NATIVE_SDK_VERSION,
@@ -124,6 +220,8 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     const startupOptionsKey = useMemo(() => toJsonKey({ configureOptionsKey, initOptionsKey }), [configureOptionsKey, initOptionsKey]);
     const startupIdempotencyKey = useMemo(() => toStableHash({ configureOptionsKey, initOptionsKey }), [configureOptionsKey, initOptionsKey]);
     const widgetHostLifecycleRef = useRef(createProviderWidgetHostLifecycleController(hostSourceKey));
+    const flowRunsRef = useRef(new Map());
+    const flowRunControllerOptionsRef = useRef(null);
     const widgetHostLifecycle = widgetHostLifecycleRef.current;
     const { clearFlowHandleFromVisibility, getCurrentHostEpoch, isWidgetHostVisible: resolveIsWidgetHostVisible, markNotReady, markReady, syncHostSourceKey, toFlowStateVisibility, toReadyVisibility, } = widgetHostLifecycle;
     const createCommandTimeoutError = useCallback((requestId) => new CommandSettlementTimeoutError(requestId), []);
@@ -133,9 +231,20 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         getCurrentHostEpoch,
     });
     const { nativeMessages, nativeMessagesRef, clearStartupQueuedKey, createPendingCommandPromise, getPendingCommand, getPendingCommandEntries, hasDeliveredPendingCommands, isStartupQueuedKey, pausePendingCommandTimeouts, registerNativeMessage, reissuePendingCommand, removeNativeMessageId, replaceNativeMessages, resetStartupQueuedKeyIfChanged, setStartupQueuedKey, startPendingCommandTimeouts, takePendingCommand, cancelStartupCommands, dispose: disposeCommandTransport, } = transport;
+    const clearIdleFlowHandles = useCallback(() => {
+        for (const flowRun of flowRunsRef.current.values()) {
+            flowRun.resetIdleHandle();
+        }
+    }, []);
+    const resetFlowRuns = useCallback(() => {
+        for (const flowRun of flowRunsRef.current.values()) {
+            flowRun.reset();
+        }
+    }, []);
     if (syncHostSourceKey(hostSourceKey)) {
         pausePendingCommandTimeouts();
         clearStartupQueuedKey();
+        clearIdleFlowHandles();
     }
     initOptionsRef.current = initOptions;
     configureOptionsRef.current = configureOptions;
@@ -152,7 +261,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             throw error;
         }, 0);
     }, [onCommandError]);
-    const enqueueTransportCommand = useCallback((command, options, { isStartup = false, prioritizeStartup = false, } = {}) => {
+    const enqueueTransportCommand = useCallback((command, options, { isStartup = false, preserveFlowHandle = false, prioritizeStartup = false, } = {}) => {
         var _a;
         const requestId = createCommandRequestId();
         const idempotencyKey = (_a = normalizeOptionalString(options === null || options === void 0 ? void 0 : options.idempotencyKey)) !== null && _a !== void 0 ? _a : requestId;
@@ -162,7 +271,9 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             requestId,
             idempotencyKey,
             clientMeta: CLIENT_META,
-            command: toReactNativeOneShotCommand(command),
+            command: preserveFlowHandle
+                ? command
+                : toReactNativeOneShotCommand(command),
         };
         const message = {
             kind: "enqueueCommand",
@@ -266,6 +377,50 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         enqueueStartupCommands();
         return enqueueTransportCommand(command, options);
     }, [enqueueStartupCommands, enqueueTransportCommand]);
+    const enqueueFlowCommand = useCallback((command) => {
+        enqueueStartupCommands();
+        return enqueueTransportCommand(command, undefined, {
+            preserveFlowHandle: true,
+        });
+    }, [enqueueStartupCommands, enqueueTransportCommand]);
+    const enqueueScopedFlowClose = useCallback((flowHandleId) => enqueueCommand({ kind: "close", flowHandleId }).then(() => { }), [enqueueCommand]);
+    flowRunControllerOptionsRef.current = {
+        enqueueFlowCommand,
+        enqueueScopedClose: enqueueScopedFlowClose,
+        reportCommandError,
+    };
+    const flow = useCallback((flowId) => {
+        const normalizedFlowId = resolveRequiredString("flowId", flowId);
+        const existing = flowRunsRef.current.get(normalizedFlowId);
+        if (existing) {
+            return existing;
+        }
+        const created = createReactNativeFlowRunController(normalizedFlowId, {
+            enqueueFlowCommand: (command) => {
+                const currentOptions = flowRunControllerOptionsRef.current;
+                if (!currentOptions) {
+                    return Promise.reject(new Error(PROVIDER_UNMOUNTED_ERROR_MESSAGE));
+                }
+                return currentOptions.enqueueFlowCommand(command);
+            },
+            enqueueScopedClose: (flowHandleId) => {
+                const currentOptions = flowRunControllerOptionsRef.current;
+                if (!currentOptions) {
+                    return Promise.reject(new Error(PROVIDER_UNMOUNTED_ERROR_MESSAGE));
+                }
+                return currentOptions.enqueueScopedClose(flowHandleId);
+            },
+            reportCommandError: (error) => {
+                const currentOptions = flowRunControllerOptionsRef.current;
+                if (!currentOptions) {
+                    return;
+                }
+                currentOptions.reportCommandError(error);
+            },
+        });
+        flowRunsRef.current.set(normalizedFlowId, created);
+        return created;
+    }, []);
     const handleWidgetReady = useCallback((event) => {
         const readyResult = markReady(event, {
             hasDeliveredPendingCommands: hasDeliveredPendingCommands(),
@@ -276,6 +431,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         let didReissueDeliveredCommands = false;
         if (readyResult.didResetHostEpoch) {
             clearStartupQueuedKey();
+            clearIdleFlowHandles();
             didReissueDeliveredCommands = reissueDeliveredPendingActionCommands();
         }
         setWidgetHostVisibility((visibility) => toReadyVisibility(visibility, event));
@@ -285,6 +441,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     }, [
         enqueueStartupCommands,
         clearStartupQueuedKey,
+        clearIdleFlowHandles,
         hasDeliveredPendingCommands,
         markReady,
         reissueDeliveredPendingActionCommands,
@@ -304,18 +461,25 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         const notReadyResult = markNotReady();
         if (notReadyResult.wasReady) {
             clearStartupQueuedKey();
+            clearIdleFlowHandles();
             reissueDeliveredPendingActionCommands();
         }
         setWidgetHostVisibility(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
         pausePendingCommandTimeouts();
     }, [
         clearStartupQueuedKey,
+        clearIdleFlowHandles,
         handleWidgetReady,
         markNotReady,
         pausePendingCommandTimeouts,
         reissueDeliveredPendingActionCommands,
     ]);
     const handleFlowHandleInvalidated = useCallback((flowHandleId) => {
+        for (const flowRun of flowRunsRef.current.values()) {
+            if (flowRun.hasFlowHandleId(flowHandleId)) {
+                flowRun.clearResolvedHandle();
+            }
+        }
         setWidgetHostVisibility((visibility) => clearFlowHandleFromVisibility(visibility, flowHandleId));
     }, [clearFlowHandleFromVisibility]);
     const handleInstanceFlowStateChanged = useCallback((detail) => {
@@ -360,6 +524,9 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 else {
                     const settlement = message.event
                         .detail;
+                    if (pendingCommand.result.envelope.command.kind === "reset") {
+                        resetFlowRuns();
+                    }
                     const settledResult = Object.assign(Object.assign({}, pendingCommand.result), { settlement, settlementResult: settlement.result });
                     pendingCommand.resolve(settledResult);
                 }
@@ -368,6 +535,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         onWebMessage === null || onWebMessage === void 0 ? void 0 : onWebMessage(message);
     }, [
         clearStartupQueuedKey,
+        resetFlowRuns,
         getCurrentHostEpoch,
         getPendingCommand,
         handleInstanceFlowStateChanged,
@@ -377,6 +545,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         takePendingCommand,
     ]);
     useEffect(() => () => {
+        flowRunControllerOptionsRef.current = null;
         disposeCommandTransport(new Error(PROVIDER_UNMOUNTED_ERROR_MESSAGE));
     }, [disposeCommandTransport]);
     const getNativeMessages = useCallback(() => nativeMessagesRef.current, [nativeMessagesRef]);
@@ -422,6 +591,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
             }, commandOptions);
         },
+        flow,
         close: (flowHandleId, options) => enqueueCommand(Object.assign({ kind: "close" }, (flowHandleId === undefined
             ? {}
             : {
@@ -431,7 +601,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         updateHostContext: (context, options) => enqueueCommand({ kind: "updateHostContext", context }, options),
         emitHostSignal: (name, data, options) => enqueueCommand(Object.assign({ kind: "emitHostSignal", name: resolveRequiredString("name", name) }, (data === undefined ? {} : { data })), options),
         handleWebMessage,
-    }), [enqueueCommand, getNativeMessages, handleWebMessage, instanceId]);
+    }), [enqueueCommand, flow, getNativeMessages, handleWebMessage, instanceId]);
     const previousSheetHostLayoutUpdateRef = useRef(undefined);
     useEffect(() => {
         resetStartupQueuedKeyIfChanged(startupOptionsKey);

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 : "2.0.14";
+export const REACT_NATIVE_SDK_VERSION = reactNativeSdkVersion.length > 0 ? reactNativeSdkVersion : "2.0.15";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "2.0.14",
+  "version": "2.0.15",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^3.1.3",
-    "@getuserfeedback/sdk": "^0.8.20",
+    "@getuserfeedback/protocol": "^3.1.4",
+    "@getuserfeedback/sdk": "^0.8.21",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {