@getuserfeedback/react-native 1.3.7 → 1.3.9

package/dist/index.js

@@ -16,7 +16,7 @@ import { useResolvedHostViewport } from "./host-viewport.js";
 import { toCommandFlowId, toCommandSettlementError, toRetryWithoutFlowHandle, } from "./provider-command-helpers.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 { applyProviderOverlayFlowState, applyProviderOverlayHandleInvalidated, createDefaultProviderOverlayState, DEFAULT_PROVIDER_OVERLAY_VISIBILITY, updateProviderOverlayReadySequence, } from "./provider-overlay-state.js";
+import { cancelProviderStartupCommands, clearProviderPendingCommands, createProviderPendingCommandRegistry, getProviderPendingCommand, getProviderPendingCommandEntries, getProviderPendingCommands, hasDeliveredProviderPendingCommands, isProviderPendingMessageStartup, registerProviderPendingCommand, reissueProviderPendingCommand, takeProviderPendingCommand, } from "./provider-pending-commands.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,6 +33,12 @@ 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") {
@@ -70,14 +76,24 @@ const FallbackNativeView = (_a) => {
     var { children } = _a, props = __rest(_a, ["children"]);
     return createElement("div", props, children);
 };
-function resolveNativeView() {
-    var _a;
+const FallbackNativePressable = FallbackNativeView;
+const FallbackNativeText = FallbackNativeView;
+function resolveReactNativeComponents() {
+    var _a, _b, _c;
     try {
         const reactNativeModule = require("react-native");
-        return (_a = reactNativeModule.View) !== null && _a !== void 0 ? _a : FallbackNativeView;
+        return {
+            Pressable: (_a = reactNativeModule.Pressable) !== null && _a !== void 0 ? _a : FallbackNativePressable,
+            Text: (_b = reactNativeModule.Text) !== null && _b !== void 0 ? _b : FallbackNativeText,
+            View: (_c = reactNativeModule.View) !== null && _c !== void 0 ? _c : FallbackNativeView,
+        };
     }
-    catch (_b) {
-        return FallbackNativeView;
+    catch (_d) {
+        return {
+            Pressable: FallbackNativePressable,
+            Text: FallbackNativeText,
+            View: FallbackNativeView,
+        };
     }
 }
 const toIdentifyCommandPayload = (identifyInput, traitsOrOptions, options) => {
@@ -109,16 +125,15 @@ 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 NativeView = useMemo(resolveNativeView, []);
+    const { Pressable: NativePressable, Text: NativeText, 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(DEFAULT_PROVIDER_OVERLAY_VISIBILITY);
+    const [widgetHostVisibility, setWidgetHostVisibility] = useState(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
     const resolvedHostViewport = useResolvedHostViewport(hostViewport);
     const nativeMessagesRef = useRef([]);
-    const pendingCommandsRef = useRef(new Map());
+    const pendingCommandsRef = useRef(createProviderPendingCommandRegistry());
     const hostEpochRef = useRef(0);
     const flowHandleCacheRef = useRef(createProviderFlowHandleCache());
-    const providerOverlayStateRef = useRef(createDefaultProviderOverlayState());
     const initOptionsRef = useRef(initOptions);
     const configureOptionsRef = useRef(configureOptions);
     const initOptionsKey = useMemo(() => toJsonKey(initOptions), [initOptions]);
@@ -134,7 +149,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     if (hostSourceKeyRef.current !== hostSourceKey) {
         hostSourceKeyRef.current = hostSourceKey;
         hostSourceVersionRef.current += 1;
-        for (const pendingCommand of pendingCommandsRef.current.values()) {
+        for (const pendingCommand of getProviderPendingCommands(pendingCommandsRef.current)) {
             if (!pendingCommand.timeout) {
                 continue;
             }
@@ -144,7 +159,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         lastReadyRef.current = null;
         startupQueuedKeyRef.current = null;
         clearProviderFlowHandleCache(flowHandleCacheRef.current);
-        providerOverlayStateRef.current = createDefaultProviderOverlayState();
     }
     initOptionsRef.current = initOptions;
     configureOptionsRef.current = configureOptions;
@@ -163,7 +177,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         }, 0);
     }, [onCommandError]);
     const rejectPendingCommand = useCallback((requestId, pendingCommand, error) => {
-        pendingCommandsRef.current.delete(requestId);
+        takeProviderPendingCommand(pendingCommandsRef.current, requestId);
         if (pendingCommand.timeout) {
             clearTimeout(pendingCommand.timeout);
             pendingCommand.timeout = null;
@@ -188,12 +202,12 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         }, commandTimeoutMs);
     }, [commandTimeoutMs, rejectPendingCommand]);
     const startPendingCommandTimeouts = useCallback(() => {
-        for (const [requestId, pendingCommand] of pendingCommandsRef.current) {
+        for (const [requestId, pendingCommand] of getProviderPendingCommandEntries(pendingCommandsRef.current)) {
             startPendingCommandTimeout(requestId, pendingCommand);
         }
     }, [startPendingCommandTimeout]);
     const pausePendingCommandTimeouts = useCallback(() => {
-        for (const pendingCommand of pendingCommandsRef.current.values()) {
+        for (const pendingCommand of getProviderPendingCommands(pendingCommandsRef.current)) {
             if (!pendingCommand.timeout) {
                 continue;
             }
@@ -234,7 +248,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         };
         const flowCommandSnapshot = snapshotProviderFlowCommand(flowHandleCacheRef.current, validatedMessage.envelope.command);
         const promise = new Promise((resolve, reject) => {
-            pendingCommandsRef.current.set(requestId, {
+            const pendingCommand = {
                 flowCommandSequence: flowCommandSnapshot.flowCommandSequence,
                 flowHandleCacheEpoch: flowCommandSnapshot.flowHandleCacheEpoch,
                 hostEpoch: null,
@@ -244,17 +258,15 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 resolve,
                 result,
                 timeout: null,
-            });
+            };
+            registerProviderPendingCommand(pendingCommandsRef.current, requestId, pendingCommand);
             if (lastReadyRef.current !== null) {
-                startPendingCommandTimeout(requestId, pendingCommandsRef.current.get(requestId));
+                startPendingCommandTimeout(requestId, pendingCommand);
             }
         });
         setNativeMessages((messages) => enqueueProviderNativeMessage(messages, {
             isStartup,
-            isStartupMessage: (entry) => {
-                var _a;
-                return ((_a = pendingCommandsRef.current.get(entry.envelope.requestId)) === null || _a === void 0 ? void 0 : _a.isStartup) === true;
-            },
+            isStartupMessage: (entry) => isProviderPendingMessageStartup(pendingCommandsRef.current, entry.envelope.requestId),
             message: validatedMessage,
             prioritizeStartup,
         }));
@@ -263,13 +275,10 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     const reissueDeliveredPendingActionCommands = useCallback(() => {
         var _a;
         const replacements = new Map();
-        for (const [requestId, pendingCommand] of [
-            ...pendingCommandsRef.current.entries(),
-        ]) {
+        for (const [requestId, pendingCommand] of getProviderPendingCommandEntries(pendingCommandsRef.current)) {
             if (pendingCommand.isStartup || pendingCommand.hostEpoch === null) {
                 continue;
             }
-            pendingCommandsRef.current.delete(requestId);
             if (pendingCommand.timeout) {
                 clearTimeout(pendingCommand.timeout);
                 pendingCommand.timeout = null;
@@ -281,16 +290,20 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 id: createTransportMessageId(),
                 envelope: nextEnvelope,
             });
-            const previousMessageId = pendingCommand.messageId;
-            pendingCommand.flowHandleCacheEpoch = flowHandleCacheRef.current.epoch;
-            pendingCommand.hostEpoch = null;
-            pendingCommand.messageId = nextMessage.id;
-            pendingCommand.result = {
-                envelope: nextMessage.envelope,
-                message: nextMessage,
-            };
-            pendingCommandsRef.current.set(nextEnvelope.requestId, pendingCommand);
-            replacements.set(previousMessageId, nextMessage);
+            const reissuedCommand = reissueProviderPendingCommand(pendingCommandsRef.current, {
+                flowHandleCacheEpoch: flowHandleCacheRef.current.epoch,
+                nextMessageId: nextMessage.id,
+                nextRequestId: nextEnvelope.requestId,
+                nextResult: {
+                    envelope: nextMessage.envelope,
+                    message: nextMessage,
+                },
+                requestId,
+            });
+            if (!reissuedCommand) {
+                continue;
+            }
+            replacements.set(reissuedCommand.previousMessageId, nextMessage);
         }
         if (replacements.size === 0) {
             return false;
@@ -299,22 +312,17 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         return true;
     }, []);
     const cancelPendingStartupCommands = useCallback(() => {
-        const canceledMessageIds = new Set();
-        for (const [requestId, pendingCommand] of pendingCommandsRef.current) {
-            if (!pendingCommand.isStartup) {
-                continue;
-            }
-            pendingCommandsRef.current.delete(requestId);
-            canceledMessageIds.add(pendingCommand.messageId);
+        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 (canceledMessageIds.size === 0) {
+        if (canceled.messageIds.size === 0) {
             return;
         }
-        setNativeMessages((messages) => removeProviderNativeMessageIds(messages, canceledMessageIds));
+        setNativeMessages((messages) => removeProviderNativeMessageIds(messages, canceled.messageIds));
     }, []);
     const enqueueStartupCommands = useCallback(({ force = false } = {}) => {
         if (!autoInit) {
@@ -353,9 +361,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         if (alreadySeen) {
             return false;
         }
-        const hasDeliveredPendingCommands = [
-            ...pendingCommandsRef.current.values(),
-        ].some((pendingCommand) => pendingCommand.hostEpoch !== null);
+        const hasDeliveredPendingCommands = hasDeliveredProviderPendingCommands(pendingCommandsRef.current);
         let didReissueDeliveredCommands = false;
         if (previous !== null || hasDeliveredPendingCommands) {
             hostEpochRef.current += 1;
@@ -364,16 +370,14 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             didReissueDeliveredCommands = reissueDeliveredPendingActionCommands();
         }
         lastReadyRef.current = Object.assign(Object.assign({}, event), { hostEpoch: hostEpochRef.current });
-        const nextVisibility = updateProviderOverlayReadySequence({
-            ready: {
-                hostSourceVersion: hostSourceVersionRef.current,
-                readySequence: event.readySequence,
-                sourceKey: event.sourceKey,
-            },
-            visibility: providerOverlayStateRef.current.visibility,
+        setWidgetHostVisibility((visibility) => {
+            if (!visibility.isVisible ||
+                visibility.sourceKey !== event.sourceKey ||
+                visibility.hostSourceVersion !== hostSourceVersionRef.current) {
+                return visibility;
+            }
+            return Object.assign(Object.assign({}, visibility), { readySequence: event.readySequence });
         });
-        providerOverlayStateRef.current = Object.assign(Object.assign({}, providerOverlayStateRef.current), { visibility: nextVisibility });
-        setWidgetHostVisibility(nextVisibility);
         enqueueStartupCommands({ force: previous !== null });
         startPendingCommandTimeouts();
         return didReissueDeliveredCommands;
@@ -399,8 +403,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             reissueDeliveredPendingActionCommands();
         }
         lastReadyRef.current = null;
-        providerOverlayStateRef.current = createDefaultProviderOverlayState();
-        setWidgetHostVisibility(providerOverlayStateRef.current.visibility);
+        setWidgetHostVisibility(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
         pausePendingCommandTimeouts();
     }, [
         handleWidgetReady,
@@ -412,14 +415,10 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     }, []);
     const handleFlowHandleInvalidated = useCallback((flowHandleId) => {
         deleteCachedFlowHandleId(flowHandleId);
-        const nextState = applyProviderOverlayHandleInvalidated({
-            flowHandleId,
-            state: providerOverlayStateRef.current,
-        });
-        providerOverlayStateRef.current = nextState;
-        setWidgetHostVisibility(nextState.visibility);
+        setWidgetHostVisibility((visibility) => visibility.flowHandleId === flowHandleId
+            ? Object.assign(Object.assign({}, visibility), { flowHandleId: undefined }) : visibility);
     }, [deleteCachedFlowHandleId]);
-    const handleFlowStateChanged = useCallback((detail, options) => {
+    const handleInstanceFlowStateChanged = useCallback((detail) => {
         if (detail.instanceId !== instanceId) {
             return;
         }
@@ -427,44 +426,37 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         if (!readyState) {
             return;
         }
-        const nextState = applyProviderOverlayFlowState({
-            detail,
-            origin: options.origin,
-            ready: {
-                hostSourceVersion: hostSourceVersionRef.current,
-                readySequence: readyState.readySequence,
-                sourceKey: readyState.sourceKey,
-            },
-            state: providerOverlayStateRef.current,
+        const isVisible = detail.isOpen || detail.isLoading;
+        setWidgetHostVisibility({
+            flowHandleId: detail.flowHandleId,
+            hostSourceVersion: hostSourceVersionRef.current,
+            isVisible,
+            readySequence: readyState.readySequence,
+            sourceKey: readyState.sourceKey,
         });
-        providerOverlayStateRef.current = nextState;
-        setWidgetHostVisibility(nextState.visibility);
     }, [instanceId]);
     const handleWebMessage = useCallback((message) => {
         var _a;
         if (message.kind === "hostEvent" &&
-            message.event.name === "instance:handle:invalidated") {
+            message.event.name === "instance:handle:invalidated" &&
+            message.event.detail.handleKind === "flow") {
             handleFlowHandleInvalidated(message.event.detail.handleId);
         }
-        if (message.kind === "hostEvent" &&
-            message.event.name === "instance:flow:state-changed") {
-            handleFlowStateChanged(message.event.detail, { origin: "handle" });
-        }
         if (message.kind === "hostEvent" &&
             message.event.name === "instance:flow:state-changed:instance") {
-            handleFlowStateChanged(message.event.detail, { origin: "aggregate" });
+            handleInstanceFlowStateChanged(message.event.detail);
         }
         if (message.kind === "hostEvent" &&
             message.event.name === "instance:command:settled") {
             const requestId = message.event.detail.requestId;
-            const pendingCommand = pendingCommandsRef.current.get(requestId);
+            const pendingCommand = getProviderPendingCommand(pendingCommandsRef.current, requestId);
             if (pendingCommand) {
                 if (pendingCommand.hostEpoch !== null &&
                     pendingCommand.hostEpoch !== ((_a = lastReadyRef.current) === null || _a === void 0 ? void 0 : _a.hostEpoch)) {
                     onWebMessage === null || onWebMessage === void 0 ? void 0 : onWebMessage(message);
                     return;
                 }
-                pendingCommandsRef.current.delete(requestId);
+                takeProviderPendingCommand(pendingCommandsRef.current, requestId);
                 setNativeMessages((messages) => removeProviderNativeMessageId(messages, pendingCommand.messageId));
                 if (pendingCommand.timeout) {
                     clearTimeout(pendingCommand.timeout);
@@ -509,26 +501,25 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         onWebMessage === null || onWebMessage === void 0 ? void 0 : onWebMessage(message);
     }, [
         enqueueTransportCommand,
-        handleFlowStateChanged,
+        handleInstanceFlowStateChanged,
         handleFlowHandleInvalidated,
         onWebMessage,
     ]);
     useEffect(() => () => {
-        for (const pendingCommand of pendingCommandsRef.current.values()) {
+        for (const pendingCommand of getProviderPendingCommands(pendingCommandsRef.current)) {
             if (pendingCommand.timeout) {
                 clearTimeout(pendingCommand.timeout);
             }
             pendingCommand.reject(new Error(PROVIDER_UNMOUNTED_ERROR_MESSAGE));
         }
-        pendingCommandsRef.current.clear();
+        clearProviderPendingCommands(pendingCommandsRef.current);
     }, []);
     useEffect(() => {
         if (visibilitySourceKeyRef.current === hostSourceKey) {
             return;
         }
         visibilitySourceKeyRef.current = hostSourceKey;
-        providerOverlayStateRef.current = createDefaultProviderOverlayState();
-        setWidgetHostVisibility(providerOverlayStateRef.current.visibility);
+        setWidgetHostVisibility(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
     }, [hostSourceKey]);
     const contextValue = useMemo(() => ({
         instanceId,
@@ -615,11 +606,20 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         webViewComponent,
         webViewProps: Object.assign(Object.assign({}, webViewProps), { pointerEvents: isWidgetHostVisible ? "auto" : "none", style: composedWebViewStyle }),
     });
+    const handleWidgetHostClose = useCallback(() => {
+        enqueueCommand(Object.assign({ kind: "close" }, (widgetHostVisibility.flowHandleId === undefined
+            ? {}
+            : { flowHandleId: widgetHostVisibility.flowHandleId }))).catch(reportCommandError);
+    }, [enqueueCommand, reportCommandError, widgetHostVisibility.flowHandleId]);
     return createElement(GetUserFeedbackNativeContext.Provider, {
         value: contextValue,
     }, children, createElement(ProviderWidgetHostOverlay, {
         isVisible: isWidgetHostVisible,
+        isCloseVisible: true,
+        nativePressable: NativePressable,
+        nativeText: NativeText,
         nativeView: NativeView,
+        onRequestClose: handleWidgetHostClose,
         sheetHostViewport,
     }, widgetHost));
 }

package/dist/provider-pending-commands.d.ts

@@ -0,0 +1,37 @@
+export type ProviderPendingCommand<Result> = {
+    flowCommandSequence: number | null;
+    flowHandleCacheEpoch: number;
+    hostEpoch: number | null;
+    isStartup: boolean;
+    messageId: string;
+    reject: (error: Error) => void;
+    resolve: (result: Result) => void;
+    result: Result;
+    timeout: ReturnType<typeof setTimeout> | null;
+};
+export type ProviderPendingCommandRegistry<Result> = Map<string, ProviderPendingCommand<Result>>;
+export type ProviderCanceledStartupCommands<Result> = {
+    commands: ProviderPendingCommand<Result>[];
+    messageIds: Set<string>;
+};
+export type ProviderReissuedPendingCommand<Result> = {
+    command: ProviderPendingCommand<Result>;
+    previousMessageId: string;
+};
+export declare function createProviderPendingCommandRegistry<Result>(): ProviderPendingCommandRegistry<Result>;
+export declare function registerProviderPendingCommand<Result>(registry: ProviderPendingCommandRegistry<Result>, requestId: string, command: ProviderPendingCommand<Result>): void;
+export declare function getProviderPendingCommand<Result>(registry: ProviderPendingCommandRegistry<Result>, requestId: string): ProviderPendingCommand<Result> | undefined;
+export declare function takeProviderPendingCommand<Result>(registry: ProviderPendingCommandRegistry<Result>, requestId: string): ProviderPendingCommand<Result> | undefined;
+export declare function hasDeliveredProviderPendingCommands<Result>(registry: ProviderPendingCommandRegistry<Result>): boolean;
+export declare function isProviderPendingMessageStartup<Result>(registry: ProviderPendingCommandRegistry<Result>, requestId: string): boolean;
+export declare function getProviderPendingCommandEntries<Result>(registry: ProviderPendingCommandRegistry<Result>): Array<[string, ProviderPendingCommand<Result>]>;
+export declare function getProviderPendingCommands<Result>(registry: ProviderPendingCommandRegistry<Result>): ProviderPendingCommand<Result>[];
+export declare function cancelProviderStartupCommands<Result>(registry: ProviderPendingCommandRegistry<Result>): ProviderCanceledStartupCommands<Result>;
+export declare function reissueProviderPendingCommand<Result>(registry: ProviderPendingCommandRegistry<Result>, { flowHandleCacheEpoch, nextMessageId, nextRequestId, nextResult, requestId, }: {
+    flowHandleCacheEpoch: number;
+    nextMessageId: string;
+    nextRequestId: string;
+    nextResult: Result;
+    requestId: string;
+}): ProviderReissuedPendingCommand<Result> | null;
+export declare function clearProviderPendingCommands<Result>(registry: ProviderPendingCommandRegistry<Result>): void;

package/dist/provider-pending-commands.js

@@ -0,0 +1,59 @@
+export function createProviderPendingCommandRegistry() {
+    return new Map();
+}
+export function registerProviderPendingCommand(registry, requestId, command) {
+    registry.set(requestId, command);
+}
+export function getProviderPendingCommand(registry, requestId) {
+    return registry.get(requestId);
+}
+export function takeProviderPendingCommand(registry, requestId) {
+    const command = registry.get(requestId);
+    if (command) {
+        registry.delete(requestId);
+    }
+    return command;
+}
+export function hasDeliveredProviderPendingCommands(registry) {
+    return [...registry.values()].some((command) => command.hostEpoch !== null);
+}
+export function isProviderPendingMessageStartup(registry, requestId) {
+    var _a;
+    return ((_a = registry.get(requestId)) === null || _a === void 0 ? void 0 : _a.isStartup) === true;
+}
+export function getProviderPendingCommandEntries(registry) {
+    return [...registry.entries()];
+}
+export function getProviderPendingCommands(registry) {
+    return [...registry.values()];
+}
+export function cancelProviderStartupCommands(registry) {
+    const commands = [];
+    const messageIds = new Set();
+    for (const [requestId, command] of registry) {
+        if (!command.isStartup) {
+            continue;
+        }
+        registry.delete(requestId);
+        commands.push(command);
+        messageIds.add(command.messageId);
+    }
+    return { commands, messageIds };
+}
+export function reissueProviderPendingCommand(registry, { flowHandleCacheEpoch, nextMessageId, nextRequestId, nextResult, requestId, }) {
+    const command = registry.get(requestId);
+    if (!command || command.isStartup || command.hostEpoch === null) {
+        return null;
+    }
+    registry.delete(requestId);
+    const previousMessageId = command.messageId;
+    command.flowHandleCacheEpoch = flowHandleCacheEpoch;
+    command.hostEpoch = null;
+    command.messageId = nextMessageId;
+    command.result = nextResult;
+    registry.set(nextRequestId, command);
+    return { command, previousMessageId };
+}
+export function clearProviderPendingCommands(registry) {
+    registry.clear();
+}

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

@@ -1,15 +1,21 @@
 import { type ComponentType, type ReactElement, type ReactNode } from "react";
 import type { WidgetHostProps } from "./widget-host.js";
 type NativeViewComponent = ComponentType<Record<string, unknown>>;
+type NativePressableComponent = ComponentType<Record<string, unknown>>;
+type NativeTextComponent = ComponentType<Record<string, unknown>>;
 export declare function toProviderWidgetSheetHostViewport(viewport: WidgetHostProps["hostViewport"]): WidgetHostProps["hostViewport"];
 export declare function toProviderWidgetHostStyle({ isVisible, webViewStyle, }: {
     isVisible: boolean;
     webViewStyle: unknown;
 }): unknown;
-export declare function ProviderWidgetHostOverlay({ children, isVisible, nativeView, sheetHostViewport, }: {
+export declare function ProviderWidgetHostOverlay({ children, isVisible, isCloseVisible, nativeView, nativePressable, nativeText, onRequestClose, sheetHostViewport, }: {
     children?: ReactNode;
+    isCloseVisible: boolean;
     isVisible: boolean;
+    nativePressable: NativePressableComponent;
+    nativeText: NativeTextComponent;
     nativeView: NativeViewComponent;
+    onRequestClose: () => void;
     sheetHostViewport: WidgetHostProps["hostViewport"];
 }): ReactElement;
 export {};

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

@@ -38,6 +38,23 @@ const WIDGET_SHEET_STYLE = {
     shadowRadius: 18,
     elevation: 18,
 };
+const WIDGET_SHEET_CLOSE_STYLE = {
+    alignItems: "center",
+    backgroundColor: "rgba(15, 23, 42, 0.08)",
+    borderRadius: 18,
+    height: 36,
+    justifyContent: "center",
+    position: "absolute",
+    right: 12,
+    top: 12,
+    width: 72,
+    zIndex: 1,
+};
+const WIDGET_SHEET_CLOSE_TEXT_STYLE = {
+    color: "#0f172a",
+    fontSize: 14,
+    fontWeight: "600",
+};
 const VISIBLE_WIDGET_HOST_STYLE = {
     flex: 1,
 };
@@ -115,7 +132,7 @@ export function toProviderWidgetHostStyle({ isVisible, webViewStyle, }) {
         ? [visiblePresentationStyle, VISIBLE_WIDGET_HOST_STYLE]
         : VISIBLE_WIDGET_HOST_STYLE;
 }
-export function ProviderWidgetHostOverlay({ children, isVisible, nativeView, sheetHostViewport, }) {
+export function ProviderWidgetHostOverlay({ children, isVisible, isCloseVisible, nativeView, nativePressable, nativeText, onRequestClose, sheetHostViewport, }) {
     const widgetSheetStyle = sheetHostViewport
         ? Object.assign(Object.assign({}, WIDGET_SHEET_STYLE), { height: sheetHostViewport.height }) : Object.assign(Object.assign({}, WIDGET_SHEET_STYLE), { height: "86%" });
     const pointerEvents = isVisible ? "auto" : "none";
@@ -131,5 +148,15 @@ export function ProviderWidgetHostOverlay({ children, isVisible, nativeView, she
         pointerEvents,
         style: isVisible ? widgetSheetStyle : HIDDEN_WIDGET_HOST_STYLE,
         testID: "gx-widget-host-sheet",
-    }, children));
+    }, children, isVisible && isCloseVisible
+        ? createElement(nativePressable, {
+            accessibilityLabel: "Close widget",
+            accessibilityRole: "button",
+            onPress: onRequestClose,
+            style: WIDGET_SHEET_CLOSE_STYLE,
+            testID: "gx-widget-host-close",
+        }, createElement(nativeText, {
+            style: WIDGET_SHEET_CLOSE_TEXT_STYLE,
+        }, "Close"))
+        : null));
 }

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "1.3.7",
+  "version": "1.3.9",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "ultracite check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^1.3.0",
-    "@getuserfeedback/sdk": "^0.7.1",
+    "@getuserfeedback/protocol": "^1.3.1",
+    "@getuserfeedback/sdk": "^0.7.2",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {

package/dist/provider-overlay-state.d.ts

@@ -1,43 +0,0 @@
-export type ProviderOverlayVisibilityOrigin = "aggregate" | "handle";
-export type ProviderOverlayVisibility = {
-    flowHandleId: string | null;
-    hostSourceVersion: number | null;
-    isVisible: boolean;
-    origin: ProviderOverlayVisibilityOrigin | null;
-    readySequence: number | null;
-    sourceKey: string | null;
-};
-export type ProviderOverlayReadyIdentity = {
-    hostSourceVersion: number;
-    readySequence: number;
-    sourceKey: string;
-};
-export type ProviderOverlayFlowStateDetail = {
-    flowHandleId?: string;
-    isLoading: boolean;
-    isOpen: boolean;
-};
-export type ProviderOverlayState = {
-    visibility: ProviderOverlayVisibility;
-    visibleFlowHandleIds: Set<string>;
-};
-export type ProviderOverlayStateInput = {
-    visibility: ProviderOverlayVisibility;
-    visibleFlowHandleIds: ReadonlySet<string>;
-};
-export declare const DEFAULT_PROVIDER_OVERLAY_VISIBILITY: ProviderOverlayVisibility;
-export declare const createDefaultProviderOverlayState: () => ProviderOverlayState;
-export declare function updateProviderOverlayReadySequence({ ready, visibility, }: {
-    ready: ProviderOverlayReadyIdentity;
-    visibility: ProviderOverlayVisibility;
-}): ProviderOverlayVisibility;
-export declare function applyProviderOverlayFlowState({ detail, origin, ready, state, }: {
-    detail: ProviderOverlayFlowStateDetail;
-    origin: ProviderOverlayVisibilityOrigin;
-    ready: ProviderOverlayReadyIdentity;
-    state: ProviderOverlayStateInput;
-}): ProviderOverlayState;
-export declare function applyProviderOverlayHandleInvalidated({ flowHandleId, state, }: {
-    flowHandleId: string;
-    state: ProviderOverlayStateInput;
-}): ProviderOverlayState;

package/dist/provider-overlay-state.js

@@ -1,134 +0,0 @@
-export const DEFAULT_PROVIDER_OVERLAY_VISIBILITY = {
-    flowHandleId: null,
-    hostSourceVersion: null,
-    isVisible: false,
-    origin: null,
-    readySequence: null,
-    sourceKey: null,
-};
-export const createDefaultProviderOverlayState = () => ({
-    visibility: DEFAULT_PROVIDER_OVERLAY_VISIBILITY,
-    visibleFlowHandleIds: new Set(),
-});
-const toVisibleProviderOverlayVisibility = ({ flowHandleId, origin, ready, }) => ({
-    flowHandleId,
-    hostSourceVersion: ready.hostSourceVersion,
-    isVisible: true,
-    origin,
-    readySequence: ready.readySequence,
-    sourceKey: ready.sourceKey,
-});
-const toHiddenProviderOverlayVisibility = (visibility) => ({
-    flowHandleId: null,
-    hostSourceVersion: visibility.hostSourceVersion,
-    isVisible: false,
-    origin: null,
-    readySequence: visibility.readySequence,
-    sourceKey: visibility.sourceKey,
-});
-const isVisibilityForReadyIdentity = (visibility, ready) => visibility.hostSourceVersion === ready.hostSourceVersion &&
-    visibility.readySequence === ready.readySequence &&
-    visibility.sourceKey === ready.sourceKey;
-export function updateProviderOverlayReadySequence({ ready, visibility, }) {
-    if (!visibility.isVisible ||
-        visibility.sourceKey !== ready.sourceKey ||
-        visibility.hostSourceVersion !== ready.hostSourceVersion) {
-        return visibility;
-    }
-    return Object.assign(Object.assign({}, visibility), { readySequence: ready.readySequence });
-}
-export function applyProviderOverlayFlowState({ detail, origin, ready, state, }) {
-    var _a;
-    const isVisible = detail.isOpen || detail.isLoading;
-    const visibleFlowHandleIds = new Set(state.visibleFlowHandleIds);
-    if (origin === "aggregate") {
-        if (isVisible) {
-            visibleFlowHandleIds.clear();
-            return {
-                visibleFlowHandleIds,
-                visibility: toVisibleProviderOverlayVisibility({
-                    flowHandleId: null,
-                    origin,
-                    ready,
-                }),
-            };
-        }
-        if (visibleFlowHandleIds.size > 0) {
-            return {
-                visibleFlowHandleIds,
-                visibility: toVisibleProviderOverlayVisibility({
-                    flowHandleId: (_a = visibleFlowHandleIds.values().next().value) !== null && _a !== void 0 ? _a : null,
-                    origin: "handle",
-                    ready,
-                }),
-            };
-        }
-        return {
-            visibleFlowHandleIds,
-            visibility: {
-                flowHandleId: null,
-                hostSourceVersion: ready.hostSourceVersion,
-                isVisible: false,
-                origin,
-                readySequence: ready.readySequence,
-                sourceKey: ready.sourceKey,
-            },
-        };
-    }
-    if (detail.flowHandleId === undefined) {
-        return {
-            visibleFlowHandleIds,
-            visibility: state.visibility,
-        };
-    }
-    if (isVisible) {
-        visibleFlowHandleIds.add(detail.flowHandleId);
-        if (state.visibility.isVisible &&
-            state.visibility.origin === "aggregate" &&
-            isVisibilityForReadyIdentity(state.visibility, ready)) {
-            return {
-                visibleFlowHandleIds,
-                visibility: state.visibility,
-            };
-        }
-        return {
-            visibleFlowHandleIds,
-            visibility: toVisibleProviderOverlayVisibility({
-                flowHandleId: detail.flowHandleId,
-                origin,
-                ready,
-            }),
-        };
-    }
-    visibleFlowHandleIds.delete(detail.flowHandleId);
-    if (visibleFlowHandleIds.size > 0) {
-        return {
-            visibleFlowHandleIds,
-            visibility: state.visibility,
-        };
-    }
-    if (state.visibility.origin !== "handle") {
-        return {
-            visibleFlowHandleIds,
-            visibility: state.visibility,
-        };
-    }
-    return {
-        visibleFlowHandleIds,
-        visibility: toHiddenProviderOverlayVisibility(state.visibility),
-    };
-}
-export function applyProviderOverlayHandleInvalidated({ flowHandleId, state, }) {
-    const visibleFlowHandleIds = new Set(state.visibleFlowHandleIds);
-    visibleFlowHandleIds.delete(flowHandleId);
-    if (visibleFlowHandleIds.size > 0 || state.visibility.origin !== "handle") {
-        return {
-            visibleFlowHandleIds,
-            visibility: state.visibility,
-        };
-    }
-    return {
-        visibleFlowHandleIds,
-        visibility: toHiddenProviderOverlayVisibility(state.visibility),
-    };
-}