@getuserfeedback/react-native 1.3.12 → 1.3.14

package/dist/index.js

@@ -14,9 +14,9 @@ import { parseWebViewTransportNativeMessage } from "@getuserfeedback/protocol/we
 import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { useResolvedHostViewport } from "./host-viewport.js";
 import { toCommandFlowId, toCommandSettlementError, toRetryWithoutFlowHandle, } from "./provider-command-helpers.js";
+import { useProviderCommandTransport } from "./provider-command-transport.js";
 import { clearProviderFlowHandleCache, createProviderFlowHandleCache, deleteCachedProviderFlowHandleId, deleteCachedProviderFlowId, getCachedProviderFlowHandleId, snapshotProviderFlowCommand, writeSettledProviderFlowHandleId, } from "./provider-flow-handle-cache.js";
-import { enqueueProviderNativeMessage, removeProviderNativeMessageId, removeProviderNativeMessageIds, replaceProviderNativeMessages, } from "./provider-message-queue.js";
-import { cancelProviderStartupCommands, clearProviderPendingCommands, createProviderPendingCommandRegistry, getProviderPendingCommand, getProviderPendingCommandEntries, getProviderPendingCommands, hasDeliveredProviderPendingCommands, isProviderPendingMessageStartup, registerProviderPendingCommand, reissueProviderPendingCommand, takeProviderPendingCommand, } from "./provider-pending-commands.js";
+import { createProviderWidgetHostLifecycleController, HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY, } from "./provider-widget-host-lifecycle.js";
 import { ProviderWidgetHostOverlay, toProviderWidgetHostStyle, toProviderWidgetSheetHostViewport, } from "./provider-widget-host-overlay.js";
 import { REACT_NATIVE_SDK_VERSION } from "./version.js";
 import { WidgetHost, } from "./widget-host.js";
@@ -33,12 +33,6 @@ const CLIENT_META = {
     loader: "sdk",
     transport: "loader",
 };
-const HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY = {
-    hostSourceVersion: null,
-    isVisible: false,
-    readySequence: null,
-    sourceKey: null,
-};
 const createUniqueId = (prefix) => {
     if (typeof globalThis.crypto !== "undefined" &&
         typeof globalThis.crypto.randomUUID === "function") {
@@ -118,15 +112,10 @@ const toIdentifyCommandPayload = (identifyInput, traitsOrOptions, options) => {
     };
 };
 export function GetUserFeedbackProvider({ autoInit = true, children, commandTimeoutMs = DEFAULT_COMMAND_TIMEOUT_MS, configureOptions, hostViewport, instanceId: instanceIdProp, initOptions, loaderUrl, onCommandError, onInvalidWebMessage, onWebMessage, source, webViewComponent, webViewProps, }) {
-    var _a, _b;
     const { View: NativeView } = useMemo(resolveReactNativeComponents, []);
     const [instanceId] = useState(() => { var _a; return (_a = normalizeOptionalString(instanceIdProp)) !== null && _a !== void 0 ? _a : createUniqueId("rn"); });
-    const [nativeMessages, setNativeMessages] = useState([]);
     const [widgetHostVisibility, setWidgetHostVisibility] = useState(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
     const resolvedHostViewport = useResolvedHostViewport(hostViewport);
-    const nativeMessagesRef = useRef([]);
-    const pendingCommandsRef = useRef(createProviderPendingCommandRegistry());
-    const hostEpochRef = useRef(0);
     const flowHandleCacheRef = useRef(createProviderFlowHandleCache());
     const initOptionsRef = useRef(initOptions);
     const configureOptionsRef = useRef(configureOptions);
@@ -135,28 +124,23 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     const hostSourceKey = useMemo(() => toJsonKey({ loaderUrl: loaderUrl !== null && loaderUrl !== void 0 ? loaderUrl : null, source: source !== null && source !== void 0 ? source : null }), [loaderUrl, source]);
     const startupOptionsKey = useMemo(() => toJsonKey({ configureOptionsKey, initOptionsKey }), [configureOptionsKey, initOptionsKey]);
     const startupIdempotencyKey = useMemo(() => toStableHash({ configureOptionsKey, initOptionsKey }), [configureOptionsKey, initOptionsKey]);
-    const startupQueuedKeyRef = useRef(null);
-    const lastReadyRef = useRef(null);
-    const visibilitySourceKeyRef = useRef(hostSourceKey);
-    const hostSourceKeyRef = useRef(hostSourceKey);
-    const hostSourceVersionRef = useRef(0);
-    if (hostSourceKeyRef.current !== hostSourceKey) {
-        hostSourceKeyRef.current = hostSourceKey;
-        hostSourceVersionRef.current += 1;
-        for (const pendingCommand of getProviderPendingCommands(pendingCommandsRef.current)) {
-            if (!pendingCommand.timeout) {
-                continue;
-            }
-            clearTimeout(pendingCommand.timeout);
-            pendingCommand.timeout = null;
-        }
-        lastReadyRef.current = null;
-        startupQueuedKeyRef.current = null;
+    const widgetHostLifecycleRef = useRef(createProviderWidgetHostLifecycleController(hostSourceKey));
+    const widgetHostLifecycle = widgetHostLifecycleRef.current;
+    const { clearFlowHandleFromVisibility, getCurrentHostEpoch, isWidgetHostVisible: resolveIsWidgetHostVisible, markNotReady, markReady, syncHostSourceKey, toFlowStateVisibility, toReadyVisibility, } = widgetHostLifecycle;
+    const createCommandTimeoutError = useCallback((requestId) => new CommandSettlementTimeoutError(requestId), []);
+    const transport = useProviderCommandTransport({
+        commandTimeoutMs,
+        createTimeoutError: createCommandTimeoutError,
+        getCurrentHostEpoch,
+    });
+    const { nativeMessages, nativeMessagesRef, clearStartupQueuedKey, createPendingCommandPromise, getPendingCommand, getPendingCommandEntries, hasDeliveredPendingCommands, isStartupQueuedKey, pausePendingCommandTimeouts, registerNativeMessage, reissuePendingCommand, removeNativeMessageId, replaceNativeMessages, resetStartupQueuedKeyIfChanged, setStartupQueuedKey, startPendingCommandTimeouts, takePendingCommand, cancelStartupCommands, dispose: disposeCommandTransport, } = transport;
+    if (syncHostSourceKey(hostSourceKey)) {
+        pausePendingCommandTimeouts();
+        clearStartupQueuedKey();
         clearProviderFlowHandleCache(flowHandleCacheRef.current);
     }
     initOptionsRef.current = initOptions;
     configureOptionsRef.current = configureOptions;
-    nativeMessagesRef.current = nativeMessages;
     const reportCommandError = useCallback((error) => {
         if (error.message === PROVIDER_UNMOUNTED_ERROR_MESSAGE ||
             error.message === STARTUP_COMMAND_REPLACED_ERROR_MESSAGE) {
@@ -170,45 +154,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             throw error;
         }, 0);
     }, [onCommandError]);
-    const rejectPendingCommand = useCallback((requestId, pendingCommand, error) => {
-        takeProviderPendingCommand(pendingCommandsRef.current, requestId);
-        if (pendingCommand.timeout) {
-            clearTimeout(pendingCommand.timeout);
-            pendingCommand.timeout = null;
-        }
-        if (pendingCommand.isStartup) {
-            startupQueuedKeyRef.current = null;
-        }
-        setNativeMessages((messages) => removeProviderNativeMessageId(messages, pendingCommand.messageId));
-        pendingCommand.reject(error);
-    }, []);
-    const startPendingCommandTimeout = useCallback((requestId, pendingCommand) => {
-        var _a, _b;
-        pendingCommand.hostEpoch = (_b = (_a = lastReadyRef.current) === null || _a === void 0 ? void 0 : _a.hostEpoch) !== null && _b !== void 0 ? _b : null;
-        if (commandTimeoutMs <= 0) {
-            return;
-        }
-        if (pendingCommand.timeout) {
-            clearTimeout(pendingCommand.timeout);
-        }
-        pendingCommand.timeout = setTimeout(() => {
-            rejectPendingCommand(requestId, pendingCommand, new CommandSettlementTimeoutError(requestId));
-        }, commandTimeoutMs);
-    }, [commandTimeoutMs, rejectPendingCommand]);
-    const startPendingCommandTimeouts = useCallback(() => {
-        for (const [requestId, pendingCommand] of getProviderPendingCommandEntries(pendingCommandsRef.current)) {
-            startPendingCommandTimeout(requestId, pendingCommand);
-        }
-    }, [startPendingCommandTimeout]);
-    const pausePendingCommandTimeouts = useCallback(() => {
-        for (const pendingCommand of getProviderPendingCommands(pendingCommandsRef.current)) {
-            if (!pendingCommand.timeout) {
-                continue;
-            }
-            clearTimeout(pendingCommand.timeout);
-            pendingCommand.timeout = null;
-        }
-    }, []);
     const enqueueTransportCommand = useCallback((command, options, { isStartup = false, prioritizeStartup = false, } = {}) => {
         var _a;
         const requestId = createCommandRequestId();
@@ -232,7 +177,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         }
         catch (error) {
             if (isStartup) {
-                startupQueuedKeyRef.current = null;
+                clearStartupQueuedKey();
             }
             return Promise.reject(error instanceof Error ? error : new Error(String(error)));
         }
@@ -241,35 +186,26 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             message: validatedMessage,
         };
         const flowCommandSnapshot = snapshotProviderFlowCommand(flowHandleCacheRef.current, validatedMessage.envelope.command);
-        const promise = new Promise((resolve, reject) => {
-            const pendingCommand = {
-                flowCommandSequence: flowCommandSnapshot.flowCommandSequence,
-                flowHandleCacheEpoch: flowCommandSnapshot.flowHandleCacheEpoch,
-                hostEpoch: null,
-                isStartup,
-                messageId: validatedMessage.id,
-                reject,
-                resolve,
-                result,
-                timeout: null,
-            };
-            registerProviderPendingCommand(pendingCommandsRef.current, requestId, pendingCommand);
-            if (lastReadyRef.current !== null) {
-                startPendingCommandTimeout(requestId, pendingCommand);
-            }
-        });
-        setNativeMessages((messages) => enqueueProviderNativeMessage(messages, {
+        const promise = createPendingCommandPromise({
+            flowCommandSequence: flowCommandSnapshot.flowCommandSequence,
+            flowHandleCacheEpoch: flowCommandSnapshot.flowHandleCacheEpoch,
             isStartup,
-            isStartupMessage: (entry) => isProviderPendingMessageStartup(pendingCommandsRef.current, entry.envelope.requestId),
             message: validatedMessage,
-            prioritizeStartup,
-        }));
+            requestId,
+            result,
+        });
+        registerNativeMessage(validatedMessage, { isStartup, prioritizeStartup });
         return promise;
-    }, [instanceId, startPendingCommandTimeout]);
+    }, [
+        clearStartupQueuedKey,
+        createPendingCommandPromise,
+        instanceId,
+        registerNativeMessage,
+    ]);
     const reissueDeliveredPendingActionCommands = useCallback(() => {
         var _a;
         const replacements = new Map();
-        for (const [requestId, pendingCommand] of getProviderPendingCommandEntries(pendingCommandsRef.current)) {
+        for (const [requestId, pendingCommand] of getPendingCommandEntries()) {
             if (pendingCommand.isStartup || pendingCommand.hostEpoch === null) {
                 continue;
             }
@@ -284,9 +220,9 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 id: createTransportMessageId(),
                 envelope: nextEnvelope,
             });
-            const reissuedCommand = reissueProviderPendingCommand(pendingCommandsRef.current, {
+            const reissuedCommand = reissuePendingCommand({
                 flowHandleCacheEpoch: flowHandleCacheRef.current.epoch,
-                nextMessageId: nextMessage.id,
+                nextMessage,
                 nextRequestId: nextEnvelope.requestId,
                 nextResult: {
                     envelope: nextMessage.envelope,
@@ -302,34 +238,21 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         if (replacements.size === 0) {
             return false;
         }
-        setNativeMessages((messages) => replaceProviderNativeMessages(messages, replacements));
+        replaceNativeMessages(replacements);
         return true;
-    }, []);
-    const cancelPendingStartupCommands = useCallback(() => {
-        const canceled = cancelProviderStartupCommands(pendingCommandsRef.current);
-        for (const pendingCommand of canceled.commands) {
-            if (pendingCommand.timeout) {
-                clearTimeout(pendingCommand.timeout);
-            }
-            pendingCommand.reject(new Error(STARTUP_COMMAND_REPLACED_ERROR_MESSAGE));
-        }
-        if (canceled.messageIds.size === 0) {
-            return;
-        }
-        setNativeMessages((messages) => removeProviderNativeMessageIds(messages, canceled.messageIds));
-    }, []);
+    }, [getPendingCommandEntries, reissuePendingCommand, replaceNativeMessages]);
     const enqueueStartupCommands = useCallback(({ force = false } = {}) => {
         if (!autoInit) {
             return;
         }
-        if (!force && startupQueuedKeyRef.current === startupOptionsKey) {
+        if (!force && isStartupQueuedKey(startupOptionsKey)) {
             return;
         }
-        const isReplacingStartup = force || startupQueuedKeyRef.current !== startupOptionsKey;
+        const isReplacingStartup = force || !isStartupQueuedKey(startupOptionsKey);
         if (isReplacingStartup) {
-            cancelPendingStartupCommands();
+            cancelStartupCommands(new Error(STARTUP_COMMAND_REPLACED_ERROR_MESSAGE));
         }
-        startupQueuedKeyRef.current = startupOptionsKey;
+        setStartupQueuedKey(startupOptionsKey);
         enqueueTransportCommand({ kind: "init", opts: initOptionsRef.current }, { idempotencyKey: `${instanceId}:init:${startupIdempotencyKey}` }, { isStartup: true, prioritizeStartup: isReplacingStartup }).catch(reportCommandError);
         if (configureOptionsRef.current === undefined) {
             return;
@@ -337,10 +260,12 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         enqueueTransportCommand({ kind: "configure", opts: configureOptionsRef.current }, { idempotencyKey: `${instanceId}:configure:${startupIdempotencyKey}` }, { isStartup: true, prioritizeStartup: isReplacingStartup }).catch(reportCommandError);
     }, [
         autoInit,
-        cancelPendingStartupCommands,
+        cancelStartupCommands,
         enqueueTransportCommand,
         instanceId,
+        isStartupQueuedKey,
         reportCommandError,
+        setStartupQueuedKey,
         startupIdempotencyKey,
         startupOptionsKey,
     ]);
@@ -349,36 +274,30 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         return enqueueTransportCommand(command, options);
     }, [enqueueStartupCommands, enqueueTransportCommand]);
     const handleWidgetReady = useCallback((event) => {
-        const previous = lastReadyRef.current;
-        const alreadySeen = (previous === null || previous === void 0 ? void 0 : previous.sourceKey) === event.sourceKey &&
-            previous.readySequence === event.readySequence;
-        if (alreadySeen) {
+        const readyResult = markReady(event, {
+            hasDeliveredPendingCommands: hasDeliveredPendingCommands(),
+        });
+        if (readyResult.alreadySeen) {
             return false;
         }
-        const hasDeliveredPendingCommands = hasDeliveredProviderPendingCommands(pendingCommandsRef.current);
         let didReissueDeliveredCommands = false;
-        if (previous !== null || hasDeliveredPendingCommands) {
-            hostEpochRef.current += 1;
-            startupQueuedKeyRef.current = null;
+        if (readyResult.didResetHostEpoch) {
+            clearStartupQueuedKey();
             clearProviderFlowHandleCache(flowHandleCacheRef.current);
             didReissueDeliveredCommands = reissueDeliveredPendingActionCommands();
         }
-        lastReadyRef.current = Object.assign(Object.assign({}, event), { hostEpoch: hostEpochRef.current });
-        setWidgetHostVisibility((visibility) => {
-            if (!visibility.isVisible ||
-                visibility.sourceKey !== event.sourceKey ||
-                visibility.hostSourceVersion !== hostSourceVersionRef.current) {
-                return visibility;
-            }
-            return Object.assign(Object.assign({}, visibility), { readySequence: event.readySequence });
-        });
-        enqueueStartupCommands({ force: previous !== null });
+        setWidgetHostVisibility((visibility) => toReadyVisibility(visibility, event));
+        enqueueStartupCommands({ force: readyResult.previousReady !== null });
         startPendingCommandTimeouts();
         return didReissueDeliveredCommands;
     }, [
         enqueueStartupCommands,
+        clearStartupQueuedKey,
+        hasDeliveredPendingCommands,
+        markReady,
         reissueDeliveredPendingActionCommands,
         startPendingCommandTimeouts,
+        toReadyVisibility,
     ]);
     const handleWidgetReadyStateChange = useCallback((event) => {
         if (event.isReady) {
@@ -390,17 +309,18 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 deferNativeMessageInjection: didReissueDeliveredCommands,
             };
         }
-        if (lastReadyRef.current !== null) {
-            hostEpochRef.current += 1;
-            startupQueuedKeyRef.current = null;
+        const notReadyResult = markNotReady();
+        if (notReadyResult.wasReady) {
+            clearStartupQueuedKey();
             clearProviderFlowHandleCache(flowHandleCacheRef.current);
             reissueDeliveredPendingActionCommands();
         }
-        lastReadyRef.current = null;
         setWidgetHostVisibility(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
         pausePendingCommandTimeouts();
     }, [
+        clearStartupQueuedKey,
         handleWidgetReady,
+        markNotReady,
         pausePendingCommandTimeouts,
         reissueDeliveredPendingActionCommands,
     ]);
@@ -409,29 +329,16 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     }, []);
     const handleFlowHandleInvalidated = useCallback((flowHandleId) => {
         deleteCachedFlowHandleId(flowHandleId);
-        setWidgetHostVisibility((visibility) => visibility.flowHandleId === flowHandleId
-            ? Object.assign(Object.assign({}, visibility), { flowHandleId: undefined }) : visibility);
-    }, [deleteCachedFlowHandleId]);
+        setWidgetHostVisibility((visibility) => clearFlowHandleFromVisibility(visibility, flowHandleId));
+    }, [clearFlowHandleFromVisibility, deleteCachedFlowHandleId]);
     const handleInstanceFlowStateChanged = useCallback((detail) => {
-        if (detail.instanceId !== instanceId) {
-            return;
-        }
-        const readyState = lastReadyRef.current;
-        if (!readyState) {
+        const visibility = toFlowStateVisibility(detail, instanceId);
+        if (!visibility) {
             return;
         }
-        const isVisible = detail.isOpen || detail.isLoading;
-        setWidgetHostVisibility({
-            flowHeight: detail.height,
-            flowHandleId: detail.flowHandleId,
-            hostSourceVersion: hostSourceVersionRef.current,
-            isVisible,
-            readySequence: readyState.readySequence,
-            sourceKey: readyState.sourceKey,
-        });
-    }, [instanceId]);
+        setWidgetHostVisibility(visibility);
+    }, [instanceId, toFlowStateVisibility]);
     const handleWebMessage = useCallback((message) => {
-        var _a;
         if (message.kind === "hostEvent" &&
             message.event.name === "instance:handle:invalidated" &&
             message.event.detail.handleKind === "flow") {
@@ -444,22 +351,22 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         if (message.kind === "hostEvent" &&
             message.event.name === "instance:command:settled") {
             const requestId = message.event.detail.requestId;
-            const pendingCommand = getProviderPendingCommand(pendingCommandsRef.current, requestId);
+            const pendingCommand = getPendingCommand(requestId);
             if (pendingCommand) {
                 if (pendingCommand.hostEpoch !== null &&
-                    pendingCommand.hostEpoch !== ((_a = lastReadyRef.current) === null || _a === void 0 ? void 0 : _a.hostEpoch)) {
+                    pendingCommand.hostEpoch !== getCurrentHostEpoch()) {
                     onWebMessage === null || onWebMessage === void 0 ? void 0 : onWebMessage(message);
                     return;
                 }
-                takeProviderPendingCommand(pendingCommandsRef.current, requestId);
-                setNativeMessages((messages) => removeProviderNativeMessageId(messages, pendingCommand.messageId));
+                takePendingCommand(requestId);
+                removeNativeMessageId(pendingCommand.messageId);
                 if (pendingCommand.timeout) {
                     clearTimeout(pendingCommand.timeout);
                 }
                 const error = toCommandSettlementError(message.event);
                 if (error) {
                     if (pendingCommand.isStartup) {
-                        startupQueuedKeyRef.current = null;
+                        clearStartupQueuedKey();
                     }
                     const flowId = toCommandFlowId(pendingCommand.result.envelope.command);
                     const isStaleFlowHandleError = error.code === "STALE_HANDLE" ||
@@ -496,30 +403,23 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         onWebMessage === null || onWebMessage === void 0 ? void 0 : onWebMessage(message);
     }, [
         enqueueTransportCommand,
+        clearStartupQueuedKey,
+        getCurrentHostEpoch,
+        getPendingCommand,
         handleInstanceFlowStateChanged,
         handleFlowHandleInvalidated,
         onWebMessage,
+        removeNativeMessageId,
+        takePendingCommand,
     ]);
     useEffect(() => () => {
-        for (const pendingCommand of getProviderPendingCommands(pendingCommandsRef.current)) {
-            if (pendingCommand.timeout) {
-                clearTimeout(pendingCommand.timeout);
-            }
-            pendingCommand.reject(new Error(PROVIDER_UNMOUNTED_ERROR_MESSAGE));
-        }
-        clearProviderPendingCommands(pendingCommandsRef.current);
-    }, []);
-    useEffect(() => {
-        if (visibilitySourceKeyRef.current === hostSourceKey) {
-            return;
-        }
-        visibilitySourceKeyRef.current = hostSourceKey;
-        setWidgetHostVisibility(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
-    }, [hostSourceKey]);
+        disposeCommandTransport(new Error(PROVIDER_UNMOUNTED_ERROR_MESSAGE));
+    }, [disposeCommandTransport]);
+    const getNativeMessages = useCallback(() => nativeMessagesRef.current, [nativeMessagesRef]);
     const contextValue = useMemo(() => ({
         instanceId,
         get nativeMessages() {
-            return nativeMessagesRef.current;
+            return getNativeMessages();
         },
         enqueueCommand,
         configure: (opts, options) => enqueueCommand({ kind: "configure", opts }, options),
@@ -570,22 +470,20 @@ 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, handleWebMessage, instanceId]);
+    }), [enqueueCommand, getNativeMessages, handleWebMessage, instanceId]);
     useEffect(() => {
-        if (startupQueuedKeyRef.current !== startupOptionsKey) {
-            startupQueuedKeyRef.current = null;
-        }
+        resetStartupQueuedKeyIfChanged(startupOptionsKey);
         enqueueStartupCommands();
-    }, [enqueueStartupCommands, startupOptionsKey]);
+    }, [
+        enqueueStartupCommands,
+        resetStartupQueuedKeyIfChanged,
+        startupOptionsKey,
+    ]);
     const providerHostViewport = hostViewport !== null && hostViewport !== void 0 ? hostViewport : resolvedHostViewport;
     const sheetHostViewport = toProviderWidgetSheetHostViewport(providerHostViewport, {
         height: widgetHostVisibility.flowHeight,
     });
-    const isWidgetHostVisible = widgetHostVisibility.isVisible &&
-        sheetHostViewport !== undefined &&
-        widgetHostVisibility.hostSourceVersion === hostSourceVersionRef.current &&
-        widgetHostVisibility.sourceKey === ((_a = lastReadyRef.current) === null || _a === void 0 ? void 0 : _a.sourceKey) &&
-        widgetHostVisibility.readySequence === ((_b = lastReadyRef.current) === null || _b === void 0 ? void 0 : _b.readySequence);
+    const isWidgetHostVisible = resolveIsWidgetHostVisible(widgetHostVisibility, sheetHostViewport !== undefined);
     const widgetHostViewport = providerHostViewport;
     const composedWebViewStyle = toProviderWidgetHostStyle({
         isVisible: isWidgetHostVisible,

package/dist/provider-command-transport.d.ts

@@ -0,0 +1,54 @@
+import type { WebViewTransportNativeMessage } from "@getuserfeedback/protocol/webview-transport";
+import { type ProviderPendingCommand } from "./provider-pending-commands.js";
+export type ProviderCommandTransportOptions = {
+    commandTimeoutMs: number;
+    createTimeoutError: (requestId: string) => Error;
+    getCurrentHostEpoch: () => number | null;
+};
+export type ProviderPendingCommandRegistration<Result> = {
+    flowCommandSequence: number | null;
+    flowHandleCacheEpoch: number;
+    isStartup: boolean;
+    message: WebViewTransportNativeMessage;
+    requestId: string;
+    result: Result;
+};
+export type ProviderPendingCommandReissue<Result> = {
+    flowHandleCacheEpoch: number;
+    nextMessage: WebViewTransportNativeMessage;
+    nextRequestId: string;
+    nextResult: Result;
+    requestId: string;
+};
+export type ProviderCommandTransport<Result> = {
+    clearStartupQueuedKey: () => void;
+    createPendingCommandPromise: (input: ProviderPendingCommandRegistration<Result>) => Promise<Result>;
+    dispose: (error: Error) => void;
+    getPendingCommand: (requestId: string) => ProviderPendingCommand<Result> | undefined;
+    getPendingCommandEntries: () => Array<[
+        string,
+        ProviderPendingCommand<Result>
+    ]>;
+    hasDeliveredPendingCommands: () => boolean;
+    isStartupQueuedKey: (key: string) => boolean;
+    nativeMessages: WebViewTransportNativeMessage[];
+    nativeMessagesRef: {
+        current: WebViewTransportNativeMessage[];
+    };
+    pausePendingCommandTimeouts: () => void;
+    registerNativeMessage: (message: WebViewTransportNativeMessage, options: {
+        isStartup: boolean;
+        prioritizeStartup: boolean;
+    }) => void;
+    reissuePendingCommand: (input: ProviderPendingCommandReissue<Result>) => {
+        previousMessageId: string;
+    } | null;
+    removeNativeMessageId: (messageId: string) => void;
+    replaceNativeMessages: (replacements: ReadonlyMap<string, WebViewTransportNativeMessage>) => void;
+    resetStartupQueuedKeyIfChanged: (key: string) => void;
+    setStartupQueuedKey: (key: string) => void;
+    startPendingCommandTimeouts: () => void;
+    takePendingCommand: (requestId: string) => ProviderPendingCommand<Result> | undefined;
+    cancelStartupCommands: (error: Error) => void;
+};
+export declare function useProviderCommandTransport<Result>({ commandTimeoutMs, createTimeoutError, getCurrentHostEpoch, }: ProviderCommandTransportOptions): ProviderCommandTransport<Result>;

package/dist/provider-command-transport.js

@@ -0,0 +1,153 @@
+import { useCallback, useRef, useState } from "react";
+import { enqueueProviderNativeMessage, removeProviderNativeMessageId, removeProviderNativeMessageIds, replaceProviderNativeMessages, } from "./provider-message-queue.js";
+import { cancelProviderStartupCommands, clearProviderPendingCommands, createProviderPendingCommandRegistry, getProviderPendingCommand, getProviderPendingCommandEntries, getProviderPendingCommands, hasDeliveredProviderPendingCommands, isProviderPendingMessageStartup, registerProviderPendingCommand, reissueProviderPendingCommand, takeProviderPendingCommand, } from "./provider-pending-commands.js";
+export function useProviderCommandTransport({ commandTimeoutMs, createTimeoutError, getCurrentHostEpoch, }) {
+    const [nativeMessages, setNativeMessages] = useState([]);
+    const nativeMessagesRef = useRef([]);
+    const pendingCommandsRef = useRef(createProviderPendingCommandRegistry());
+    const startupQueuedKeyRef = useRef(null);
+    nativeMessagesRef.current = nativeMessages;
+    const removeNativeMessageId = useCallback((messageId) => {
+        setNativeMessages((messages) => removeProviderNativeMessageId(messages, messageId));
+    }, []);
+    const removeNativeMessageIds = useCallback((messageIds) => {
+        setNativeMessages((messages) => removeProviderNativeMessageIds(messages, messageIds));
+    }, []);
+    const rejectPendingCommand = useCallback((requestId, pendingCommand, error) => {
+        takeProviderPendingCommand(pendingCommandsRef.current, requestId);
+        if (pendingCommand.timeout) {
+            clearTimeout(pendingCommand.timeout);
+            pendingCommand.timeout = null;
+        }
+        if (pendingCommand.isStartup) {
+            startupQueuedKeyRef.current = null;
+        }
+        removeNativeMessageId(pendingCommand.messageId);
+        pendingCommand.reject(error);
+    }, [removeNativeMessageId]);
+    const startPendingCommandTimeout = useCallback((requestId, pendingCommand) => {
+        pendingCommand.hostEpoch = getCurrentHostEpoch();
+        if (commandTimeoutMs <= 0) {
+            return;
+        }
+        if (pendingCommand.timeout) {
+            clearTimeout(pendingCommand.timeout);
+        }
+        pendingCommand.timeout = setTimeout(() => {
+            rejectPendingCommand(requestId, pendingCommand, createTimeoutError(requestId));
+        }, commandTimeoutMs);
+    }, [
+        commandTimeoutMs,
+        createTimeoutError,
+        getCurrentHostEpoch,
+        rejectPendingCommand,
+    ]);
+    const startPendingCommandTimeouts = useCallback(() => {
+        for (const [requestId, pendingCommand] of getProviderPendingCommandEntries(pendingCommandsRef.current)) {
+            startPendingCommandTimeout(requestId, pendingCommand);
+        }
+    }, [startPendingCommandTimeout]);
+    const pausePendingCommandTimeouts = useCallback(() => {
+        for (const pendingCommand of getProviderPendingCommands(pendingCommandsRef.current)) {
+            if (!pendingCommand.timeout) {
+                continue;
+            }
+            clearTimeout(pendingCommand.timeout);
+            pendingCommand.timeout = null;
+        }
+    }, []);
+    const createPendingCommandPromise = useCallback(({ flowCommandSequence, flowHandleCacheEpoch, isStartup, message, requestId, result, }) => new Promise((resolve, reject) => {
+        const pendingCommand = {
+            flowCommandSequence,
+            flowHandleCacheEpoch,
+            hostEpoch: null,
+            isStartup,
+            messageId: message.id,
+            reject,
+            resolve,
+            result,
+            timeout: null,
+        };
+        registerProviderPendingCommand(pendingCommandsRef.current, requestId, pendingCommand);
+        if (getCurrentHostEpoch() !== null) {
+            startPendingCommandTimeout(requestId, pendingCommand);
+        }
+    }), [getCurrentHostEpoch, startPendingCommandTimeout]);
+    const registerNativeMessage = useCallback((message, options) => {
+        setNativeMessages((messages) => enqueueProviderNativeMessage(messages, Object.assign(Object.assign({}, options), { isStartupMessage: (entry) => isProviderPendingMessageStartup(pendingCommandsRef.current, entry.envelope.requestId), message })));
+    }, []);
+    const replaceNativeMessages = useCallback((replacements) => {
+        setNativeMessages((messages) => replaceProviderNativeMessages(messages, replacements));
+    }, []);
+    const reissuePendingCommand = useCallback(({ flowHandleCacheEpoch, nextMessage, nextRequestId, nextResult, requestId, }) => {
+        const reissuedCommand = reissueProviderPendingCommand(pendingCommandsRef.current, {
+            flowHandleCacheEpoch,
+            nextMessageId: nextMessage.id,
+            nextRequestId,
+            nextResult,
+            requestId,
+        });
+        return reissuedCommand
+            ? { previousMessageId: reissuedCommand.previousMessageId }
+            : null;
+    }, []);
+    const cancelStartupCommands = useCallback((error) => {
+        const canceled = cancelProviderStartupCommands(pendingCommandsRef.current);
+        for (const pendingCommand of canceled.commands) {
+            if (pendingCommand.timeout) {
+                clearTimeout(pendingCommand.timeout);
+            }
+            pendingCommand.reject(error);
+        }
+        if (canceled.messageIds.size > 0) {
+            removeNativeMessageIds(canceled.messageIds);
+        }
+    }, [removeNativeMessageIds]);
+    const dispose = useCallback((error) => {
+        for (const pendingCommand of getProviderPendingCommands(pendingCommandsRef.current)) {
+            if (pendingCommand.timeout) {
+                clearTimeout(pendingCommand.timeout);
+            }
+            pendingCommand.reject(error);
+        }
+        clearProviderPendingCommands(pendingCommandsRef.current);
+        startupQueuedKeyRef.current = null;
+    }, []);
+    const clearStartupQueuedKey = useCallback(() => {
+        startupQueuedKeyRef.current = null;
+    }, []);
+    const getPendingCommand = useCallback((requestId) => getProviderPendingCommand(pendingCommandsRef.current, requestId), []);
+    const getPendingCommandEntries = useCallback(() => getProviderPendingCommandEntries(pendingCommandsRef.current), []);
+    const hasDeliveredPendingCommands = useCallback(() => hasDeliveredProviderPendingCommands(pendingCommandsRef.current), []);
+    const isStartupQueuedKey = useCallback((key) => startupQueuedKeyRef.current === key, []);
+    const resetStartupQueuedKeyIfChanged = useCallback((key) => {
+        if (startupQueuedKeyRef.current !== key) {
+            startupQueuedKeyRef.current = null;
+        }
+    }, []);
+    const setStartupQueuedKey = useCallback((key) => {
+        startupQueuedKeyRef.current = key;
+    }, []);
+    const takePendingCommand = useCallback((requestId) => takeProviderPendingCommand(pendingCommandsRef.current, requestId), []);
+    return {
+        cancelStartupCommands,
+        clearStartupQueuedKey,
+        createPendingCommandPromise,
+        dispose,
+        getPendingCommand,
+        getPendingCommandEntries,
+        hasDeliveredPendingCommands,
+        isStartupQueuedKey,
+        nativeMessages,
+        nativeMessagesRef,
+        pausePendingCommandTimeouts,
+        registerNativeMessage,
+        reissuePendingCommand,
+        removeNativeMessageId,
+        replaceNativeMessages,
+        resetStartupQueuedKeyIfChanged,
+        setStartupQueuedKey,
+        startPendingCommandTimeouts,
+        takePendingCommand,
+    };
+}

package/dist/provider-widget-host-lifecycle.d.ts

@@ -0,0 +1,46 @@
+export type ProviderWidgetHostReadyState = {
+    hostEpoch: number;
+    readySequence: number;
+    sourceKey: string;
+};
+export type ProviderWidgetHostVisibility = {
+    flowHeight?: number;
+    flowHandleId?: string;
+    hostSourceVersion: number | null;
+    isVisible: boolean;
+    readySequence: number | null;
+    sourceKey: string | null;
+};
+export type ProviderWidgetHostFlowState = {
+    height?: number;
+    flowHandleId?: string;
+    instanceId: string;
+    isLoading: boolean;
+    isOpen: boolean;
+};
+export declare const HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY: ProviderWidgetHostVisibility;
+export type ProviderWidgetHostLifecycleController = {
+    clearFlowHandleFromVisibility: (visibility: ProviderWidgetHostVisibility, flowHandleId: string) => ProviderWidgetHostVisibility;
+    getCurrentHostEpoch: () => number | null;
+    isWidgetHostVisible: (visibility: ProviderWidgetHostVisibility, hasSheetHostViewport: boolean) => boolean;
+    markNotReady: () => {
+        wasReady: boolean;
+    };
+    markReady: (event: {
+        readySequence: number;
+        sourceKey: string;
+    }, options: {
+        hasDeliveredPendingCommands: boolean;
+    }) => {
+        alreadySeen: boolean;
+        didResetHostEpoch: boolean;
+        previousReady: ProviderWidgetHostReadyState | null;
+    };
+    syncHostSourceKey: (hostSourceKey: string) => boolean;
+    toFlowStateVisibility: (detail: ProviderWidgetHostFlowState, instanceId: string) => ProviderWidgetHostVisibility | null;
+    toReadyVisibility: (visibility: ProviderWidgetHostVisibility, event: {
+        readySequence: number;
+        sourceKey: string;
+    }) => ProviderWidgetHostVisibility;
+};
+export declare function createProviderWidgetHostLifecycleController(initialHostSourceKey: string): ProviderWidgetHostLifecycleController;

package/dist/provider-widget-host-lifecycle.js

@@ -0,0 +1,82 @@
+export const HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY = {
+    hostSourceVersion: null,
+    isVisible: false,
+    readySequence: null,
+    sourceKey: null,
+};
+export function createProviderWidgetHostLifecycleController(initialHostSourceKey) {
+    let hostEpoch = 0;
+    let hostSourceKey = initialHostSourceKey;
+    let hostSourceVersion = 0;
+    let lastReady = null;
+    return {
+        clearFlowHandleFromVisibility: (visibility, flowHandleId) => visibility.flowHandleId === flowHandleId
+            ? Object.assign(Object.assign({}, visibility), { flowHandleId: undefined }) : visibility,
+        getCurrentHostEpoch: () => { var _a; return (_a = lastReady === null || lastReady === void 0 ? void 0 : lastReady.hostEpoch) !== null && _a !== void 0 ? _a : null; },
+        isWidgetHostVisible: (visibility, hasSheetHostViewport) => visibility.isVisible &&
+            hasSheetHostViewport &&
+            visibility.hostSourceVersion === hostSourceVersion &&
+            visibility.sourceKey === (lastReady === null || lastReady === void 0 ? void 0 : lastReady.sourceKey) &&
+            visibility.readySequence === (lastReady === null || lastReady === void 0 ? void 0 : lastReady.readySequence),
+        markNotReady: () => {
+            const wasReady = lastReady !== null;
+            if (wasReady) {
+                hostEpoch += 1;
+            }
+            lastReady = null;
+            return { wasReady };
+        },
+        markReady: (event, { hasDeliveredPendingCommands }) => {
+            const previousReady = lastReady;
+            const alreadySeen = (previousReady === null || previousReady === void 0 ? void 0 : previousReady.sourceKey) === event.sourceKey &&
+                previousReady.readySequence === event.readySequence;
+            if (alreadySeen) {
+                return {
+                    alreadySeen: true,
+                    didResetHostEpoch: false,
+                    previousReady,
+                };
+            }
+            const didResetHostEpoch = previousReady !== null || hasDeliveredPendingCommands;
+            if (didResetHostEpoch) {
+                hostEpoch += 1;
+            }
+            lastReady = Object.assign(Object.assign({}, event), { hostEpoch });
+            return {
+                alreadySeen: false,
+                didResetHostEpoch,
+                previousReady,
+            };
+        },
+        syncHostSourceKey: (nextHostSourceKey) => {
+            if (hostSourceKey === nextHostSourceKey) {
+                return false;
+            }
+            hostSourceKey = nextHostSourceKey;
+            hostSourceVersion += 1;
+            lastReady = null;
+            return true;
+        },
+        toFlowStateVisibility: (detail, instanceId) => {
+            if (detail.instanceId !== instanceId || lastReady === null) {
+                return null;
+            }
+            return {
+                flowHeight: detail.height,
+                flowHandleId: detail.flowHandleId,
+                hostSourceVersion,
+                isVisible: detail.isOpen || detail.isLoading,
+                readySequence: lastReady.readySequence,
+                sourceKey: lastReady.sourceKey,
+            };
+        },
+        toReadyVisibility: (visibility, event) => {
+            if (!visibility.isVisible ||
+                visibility.sourceKey !== event.sourceKey ||
+                visibility.hostSourceVersion !== hostSourceVersion) {
+                return visibility;
+            }
+            return Object.assign(Object.assign({}, visibility), { readySequence: event.readySequence });
+        },
+    };
+}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "1.3.12",
+  "version": "1.3.14",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "ultracite check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^1.6.0",
-    "@getuserfeedback/sdk": "^0.7.5",
+    "@getuserfeedback/protocol": "^2.0.0",
+    "@getuserfeedback/sdk": "^0.7.7",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {