@getuserfeedback/react-native 1.3.6 → 1.3.8

package/dist/index.js

@@ -15,7 +15,9 @@ import { createContext, createElement, useCallback, useContext, useEffect, useMe
 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";
@@ -114,7 +116,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     const [widgetHostVisibility, setWidgetHostVisibility] = useState(DEFAULT_PROVIDER_OVERLAY_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());
@@ -133,7 +135,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;
             }
@@ -162,7 +164,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;
@@ -170,7 +172,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         if (pendingCommand.isStartup) {
             startupQueuedKeyRef.current = null;
         }
-        setNativeMessages((messages) => messages.filter((entry) => entry.id !== pendingCommand.messageId));
+        setNativeMessages((messages) => removeProviderNativeMessageId(messages, pendingCommand.messageId));
         pendingCommand.reject(error);
     }, []);
     const startPendingCommandTimeout = useCallback((requestId, pendingCommand) => {
@@ -187,12 +189,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;
             }
@@ -233,7 +235,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,
@@ -243,40 +245,27 @@ 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) => {
-            if (!(isStartup && prioritizeStartup)) {
-                return [...messages, validatedMessage];
-            }
-            const firstActionIndex = messages.findIndex((entry) => {
-                const pendingCommand = pendingCommandsRef.current.get(entry.envelope.requestId);
-                return !(pendingCommand === null || pendingCommand === void 0 ? void 0 : pendingCommand.isStartup);
-            });
-            if (firstActionIndex === -1) {
-                return [...messages, validatedMessage];
-            }
-            return [
-                ...messages.slice(0, firstActionIndex),
-                validatedMessage,
-                ...messages.slice(firstActionIndex),
-            ];
-        });
+        setNativeMessages((messages) => enqueueProviderNativeMessage(messages, {
+            isStartup,
+            isStartupMessage: (entry) => isProviderPendingMessageStartup(pendingCommandsRef.current, entry.envelope.requestId),
+            message: validatedMessage,
+            prioritizeStartup,
+        }));
         return promise;
     }, [instanceId, startPendingCommandTimeout]);
     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;
@@ -288,40 +277,39 @@ 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;
         }
-        setNativeMessages((messages) => messages.map((message) => { var _a; return (_a = replacements.get(message.id)) !== null && _a !== void 0 ? _a : message; }));
+        setNativeMessages((messages) => replaceProviderNativeMessages(messages, replacements));
         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) => messages.filter((entry) => !canceledMessageIds.has(entry.id)));
+        setNativeMessages((messages) => removeProviderNativeMessageIds(messages, canceled.messageIds));
     }, []);
     const enqueueStartupCommands = useCallback(({ force = false } = {}) => {
         if (!autoInit) {
@@ -360,9 +348,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;
@@ -464,15 +450,15 @@ 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 = 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);
-                setNativeMessages((messages) => messages.filter((entry) => entry.id !== pendingCommand.messageId));
+                takeProviderPendingCommand(pendingCommandsRef.current, requestId);
+                setNativeMessages((messages) => removeProviderNativeMessageId(messages, pendingCommand.messageId));
                 if (pendingCommand.timeout) {
                     clearTimeout(pendingCommand.timeout);
                 }
@@ -521,13 +507,13 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         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) {

package/dist/provider-message-queue.d.ts

@@ -0,0 +1,11 @@
+import type { WebViewTransportNativeMessage } from "@getuserfeedback/protocol/webview-transport";
+export type ProviderNativeMessageQueue = readonly WebViewTransportNativeMessage[];
+export declare function enqueueProviderNativeMessage(messages: ProviderNativeMessageQueue, { isStartup, isStartupMessage, message, prioritizeStartup, }: {
+    isStartup: boolean;
+    isStartupMessage: (message: WebViewTransportNativeMessage) => boolean;
+    message: WebViewTransportNativeMessage;
+    prioritizeStartup: boolean;
+}): WebViewTransportNativeMessage[];
+export declare function removeProviderNativeMessageIds(messages: ProviderNativeMessageQueue, messageIds: ReadonlySet<string>): WebViewTransportNativeMessage[];
+export declare function removeProviderNativeMessageId(messages: ProviderNativeMessageQueue, messageId: string): WebViewTransportNativeMessage[];
+export declare function replaceProviderNativeMessages(messages: ProviderNativeMessageQueue, replacementsByMessageId: ReadonlyMap<string, WebViewTransportNativeMessage>): WebViewTransportNativeMessage[];

package/dist/provider-message-queue.js

@@ -0,0 +1,23 @@
+export function enqueueProviderNativeMessage(messages, { isStartup, isStartupMessage, message, prioritizeStartup, }) {
+    if (!(isStartup && prioritizeStartup)) {
+        return [...messages, message];
+    }
+    const firstActionIndex = messages.findIndex((entry) => !isStartupMessage(entry));
+    if (firstActionIndex === -1) {
+        return [...messages, message];
+    }
+    return [
+        ...messages.slice(0, firstActionIndex),
+        message,
+        ...messages.slice(firstActionIndex),
+    ];
+}
+export function removeProviderNativeMessageIds(messages, messageIds) {
+    return messages.filter((entry) => !messageIds.has(entry.id));
+}
+export function removeProviderNativeMessageId(messages, messageId) {
+    return removeProviderNativeMessageIds(messages, new Set([messageId]));
+}
+export function replaceProviderNativeMessages(messages, replacementsByMessageId) {
+    return messages.map((message) => { var _a; return (_a = replacementsByMessageId.get(message.id)) !== null && _a !== void 0 ? _a : message; });
+}

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "1.3.6",
+  "version": "1.3.8",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",