@getuserfeedback/react-native 1.3.5 → 1.3.7

package/dist/index.js

@@ -13,7 +13,9 @@ import { assertNoSegmentExternalIdsInValueArgument, CommandSettlementTimeoutErro
 import { parseWebViewTransportNativeMessage } from "@getuserfeedback/protocol/webview-transport";
 import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { useResolvedHostViewport } from "./host-viewport.js";
-import { toCommandFlowId, toCommandSettlementError, toRetryWithoutFlowHandle, toSettledFlowHandleId, } from "./provider-command-helpers.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 { ProviderWidgetHostOverlay, toProviderWidgetHostStyle, toProviderWidgetSheetHostViewport, } from "./provider-widget-host-overlay.js";
 import { REACT_NATIVE_SDK_VERSION } from "./version.js";
@@ -115,9 +117,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     const nativeMessagesRef = useRef([]);
     const pendingCommandsRef = useRef(new Map());
     const hostEpochRef = useRef(0);
-    const flowHandleCacheEpochRef = useRef(0);
-    const flowHandleIdsByFlowIdRef = useRef(new Map());
-    const flowCommandSequencesByFlowIdRef = useRef(new Map());
+    const flowHandleCacheRef = useRef(createProviderFlowHandleCache());
     const providerOverlayStateRef = useRef(createDefaultProviderOverlayState());
     const initOptionsRef = useRef(initOptions);
     const configureOptionsRef = useRef(configureOptions);
@@ -143,8 +143,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         }
         lastReadyRef.current = null;
         startupQueuedKeyRef.current = null;
-        flowHandleCacheEpochRef.current += 1;
-        flowHandleIdsByFlowIdRef.current.clear();
+        clearProviderFlowHandleCache(flowHandleCacheRef.current);
         providerOverlayStateRef.current = createDefaultProviderOverlayState();
     }
     initOptionsRef.current = initOptions;
@@ -172,7 +171,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) => {
@@ -203,7 +202,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         }
     }, []);
     const enqueueTransportCommand = useCallback((command, options, { isStartup = false, prioritizeStartup = false, } = {}) => {
-        var _a, _b;
+        var _a;
         const requestId = createCommandRequestId();
         const idempotencyKey = (_a = normalizeOptionalString(options === null || options === void 0 ? void 0 : options.idempotencyKey)) !== null && _a !== void 0 ? _a : requestId;
         const envelope = {
@@ -233,17 +232,11 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             envelope: validatedMessage.envelope,
             message: validatedMessage,
         };
-        const flowId = toCommandFlowId(validatedMessage.envelope.command);
-        const flowCommandSequence = flowId === undefined
-            ? null
-            : ((_b = flowCommandSequencesByFlowIdRef.current.get(flowId)) !== null && _b !== void 0 ? _b : 0) + 1;
-        if (flowId !== undefined && flowCommandSequence !== null) {
-            flowCommandSequencesByFlowIdRef.current.set(flowId, flowCommandSequence);
-        }
+        const flowCommandSnapshot = snapshotProviderFlowCommand(flowHandleCacheRef.current, validatedMessage.envelope.command);
         const promise = new Promise((resolve, reject) => {
             pendingCommandsRef.current.set(requestId, {
-                flowCommandSequence,
-                flowHandleCacheEpoch: flowHandleCacheEpochRef.current,
+                flowCommandSequence: flowCommandSnapshot.flowCommandSequence,
+                flowHandleCacheEpoch: flowCommandSnapshot.flowHandleCacheEpoch,
                 hostEpoch: null,
                 isStartup,
                 messageId: validatedMessage.id,
@@ -256,23 +249,15 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 startPendingCommandTimeout(requestId, pendingCommandsRef.current.get(requestId));
             }
         });
-        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) => {
+                var _a;
+                return ((_a = pendingCommandsRef.current.get(entry.envelope.requestId)) === null || _a === void 0 ? void 0 : _a.isStartup) === true;
+            },
+            message: validatedMessage,
+            prioritizeStartup,
+        }));
         return promise;
     }, [instanceId, startPendingCommandTimeout]);
     const reissueDeliveredPendingActionCommands = useCallback(() => {
@@ -297,7 +282,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 envelope: nextEnvelope,
             });
             const previousMessageId = pendingCommand.messageId;
-            pendingCommand.flowHandleCacheEpoch = flowHandleCacheEpochRef.current;
+            pendingCommand.flowHandleCacheEpoch = flowHandleCacheRef.current.epoch;
             pendingCommand.hostEpoch = null;
             pendingCommand.messageId = nextMessage.id;
             pendingCommand.result = {
@@ -310,7 +295,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         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(() => {
@@ -329,7 +314,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         if (canceledMessageIds.size === 0) {
             return;
         }
-        setNativeMessages((messages) => messages.filter((entry) => !canceledMessageIds.has(entry.id)));
+        setNativeMessages((messages) => removeProviderNativeMessageIds(messages, canceledMessageIds));
     }, []);
     const enqueueStartupCommands = useCallback(({ force = false } = {}) => {
         if (!autoInit) {
@@ -375,8 +360,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         if (previous !== null || hasDeliveredPendingCommands) {
             hostEpochRef.current += 1;
             startupQueuedKeyRef.current = null;
-            flowHandleCacheEpochRef.current += 1;
-            flowHandleIdsByFlowIdRef.current.clear();
+            clearProviderFlowHandleCache(flowHandleCacheRef.current);
             didReissueDeliveredCommands = reissueDeliveredPendingActionCommands();
         }
         lastReadyRef.current = Object.assign(Object.assign({}, event), { hostEpoch: hostEpochRef.current });
@@ -411,8 +395,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         if (lastReadyRef.current !== null) {
             hostEpochRef.current += 1;
             startupQueuedKeyRef.current = null;
-            flowHandleCacheEpochRef.current += 1;
-            flowHandleIdsByFlowIdRef.current.clear();
+            clearProviderFlowHandleCache(flowHandleCacheRef.current);
             reissueDeliveredPendingActionCommands();
         }
         lastReadyRef.current = null;
@@ -425,12 +408,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         reissueDeliveredPendingActionCommands,
     ]);
     const deleteCachedFlowHandleId = useCallback((flowHandleId) => {
-        for (const [flowId, cachedFlowHandleId,] of flowHandleIdsByFlowIdRef.current) {
-            if (cachedFlowHandleId === flowHandleId) {
-                flowHandleIdsByFlowIdRef.current.delete(flowId);
-            }
-        }
-        flowHandleCacheEpochRef.current += 1;
+        deleteCachedProviderFlowHandleId(flowHandleCacheRef.current, flowHandleId);
     }, []);
     const handleFlowHandleInvalidated = useCallback((flowHandleId) => {
         deleteCachedFlowHandleId(flowHandleId);
@@ -487,7 +465,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                     return;
                 }
                 pendingCommandsRef.current.delete(requestId);
-                setNativeMessages((messages) => messages.filter((entry) => entry.id !== pendingCommand.messageId));
+                setNativeMessages((messages) => removeProviderNativeMessageId(messages, pendingCommand.messageId));
                 if (pendingCommand.timeout) {
                     clearTimeout(pendingCommand.timeout);
                 }
@@ -500,7 +478,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                     const isStaleFlowHandleError = error.code === "STALE_HANDLE" ||
                         error.message.includes("flowHandleId is stale");
                     if (flowId && isStaleFlowHandleError) {
-                        flowHandleIdsByFlowIdRef.current.delete(flowId);
+                        deleteCachedProviderFlowId(flowHandleCacheRef.current, flowId);
                     }
                     const retryCommand = isStaleFlowHandleError
                         ? toRetryWithoutFlowHandle(pendingCommand.result.envelope.command)
@@ -514,20 +492,14 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 else {
                     const settlement = message.event
                         .detail;
-                    const flowId = toCommandFlowId(pendingCommand.result.envelope.command);
-                    const flowHandleId = toSettledFlowHandleId(settlement.result);
-                    const canWriteFlowHandle = flowId &&
-                        flowHandleId &&
-                        pendingCommand.flowHandleCacheEpoch ===
-                            flowHandleCacheEpochRef.current &&
-                        pendingCommand.flowCommandSequence ===
-                            flowCommandSequencesByFlowIdRef.current.get(flowId);
-                    if (canWriteFlowHandle) {
-                        flowHandleIdsByFlowIdRef.current.set(flowId, flowHandleId);
-                    }
+                    writeSettledProviderFlowHandleId(flowHandleCacheRef.current, {
+                        command: pendingCommand.result.envelope.command,
+                        flowCommandSequence: pendingCommand.flowCommandSequence,
+                        flowHandleCacheEpoch: pendingCommand.flowHandleCacheEpoch,
+                        settlementResult: settlement.result,
+                    });
                     if (pendingCommand.result.envelope.command.kind === "reset") {
-                        flowHandleCacheEpochRef.current += 1;
-                        flowHandleIdsByFlowIdRef.current.clear();
+                        clearProviderFlowHandleCache(flowHandleCacheRef.current);
                     }
                     const settledResult = Object.assign(Object.assign({}, pendingCommand.result), { settlement, settlementResult: settlement.result });
                     pendingCommand.resolve(settledResult);
@@ -582,7 +554,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             return enqueueCommand({
                 kind: "open",
                 flowId: normalizedFlowId,
-                flowHandleId: flowHandleIdsByFlowIdRef.current.get(normalizedFlowId),
+                flowHandleId: getCachedProviderFlowHandleId(flowHandleCacheRef.current, normalizedFlowId),
                 hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
             }, commandOptions);
         },
@@ -591,7 +563,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             return enqueueCommand({
                 kind: "prefetch",
                 flowId: normalizedFlowId,
-                flowHandleId: flowHandleIdsByFlowIdRef.current.get(normalizedFlowId),
+                flowHandleId: getCachedProviderFlowHandleId(flowHandleCacheRef.current, normalizedFlowId),
             }, options);
         },
         prerender: (flowId, options, commandOptions) => {
@@ -599,7 +571,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             return enqueueCommand({
                 kind: "prerender",
                 flowId: normalizedFlowId,
-                flowHandleId: flowHandleIdsByFlowIdRef.current.get(normalizedFlowId),
+                flowHandleId: getCachedProviderFlowHandleId(flowHandleCacheRef.current, normalizedFlowId),
                 hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
             }, commandOptions);
         },

package/dist/provider-flow-handle-cache.d.ts

@@ -0,0 +1,24 @@
+import type { WebViewCommandEnvelope } from "@getuserfeedback/protocol/webview-transport";
+type ReactNativeWidgetCommand = WebViewCommandEnvelope["command"];
+export type ProviderFlowCommandSnapshot = {
+    flowCommandSequence: number | null;
+    flowHandleCacheEpoch: number;
+};
+export type ProviderFlowHandleCache = {
+    epoch: number;
+    flowCommandSequencesByFlowId: Map<string, number>;
+    flowHandleIdsByFlowId: Map<string, string>;
+};
+export declare function createProviderFlowHandleCache(): ProviderFlowHandleCache;
+export declare function clearProviderFlowHandleCache(cache: ProviderFlowHandleCache): void;
+export declare function deleteCachedProviderFlowHandleId(cache: ProviderFlowHandleCache, flowHandleId: string): void;
+export declare function deleteCachedProviderFlowId(cache: ProviderFlowHandleCache, flowId: string): void;
+export declare function getCachedProviderFlowHandleId(cache: ProviderFlowHandleCache, flowId: string): string | undefined;
+export declare function snapshotProviderFlowCommand(cache: ProviderFlowHandleCache, command: ReactNativeWidgetCommand): ProviderFlowCommandSnapshot;
+export declare function writeSettledProviderFlowHandleId(cache: ProviderFlowHandleCache, { command, flowCommandSequence, flowHandleCacheEpoch, settlementResult, }: {
+    command: ReactNativeWidgetCommand;
+    flowCommandSequence: number | null;
+    flowHandleCacheEpoch: number;
+    settlementResult: unknown;
+}): boolean;
+export {};

package/dist/provider-flow-handle-cache.js

@@ -0,0 +1,53 @@
+import { toCommandFlowId, toSettledFlowHandleId, } from "./provider-command-helpers.js";
+export function createProviderFlowHandleCache() {
+    return {
+        epoch: 0,
+        flowCommandSequencesByFlowId: new Map(),
+        flowHandleIdsByFlowId: new Map(),
+    };
+}
+export function clearProviderFlowHandleCache(cache) {
+    cache.epoch += 1;
+    cache.flowHandleIdsByFlowId.clear();
+}
+export function deleteCachedProviderFlowHandleId(cache, flowHandleId) {
+    for (const [flowId, cachedFlowHandleId] of cache.flowHandleIdsByFlowId) {
+        if (cachedFlowHandleId === flowHandleId) {
+            cache.flowHandleIdsByFlowId.delete(flowId);
+        }
+    }
+    cache.epoch += 1;
+}
+export function deleteCachedProviderFlowId(cache, flowId) {
+    cache.flowHandleIdsByFlowId.delete(flowId);
+}
+export function getCachedProviderFlowHandleId(cache, flowId) {
+    return cache.flowHandleIdsByFlowId.get(flowId);
+}
+export function snapshotProviderFlowCommand(cache, command) {
+    var _a;
+    const flowId = toCommandFlowId(command);
+    const flowCommandSequence = flowId === undefined
+        ? null
+        : ((_a = cache.flowCommandSequencesByFlowId.get(flowId)) !== null && _a !== void 0 ? _a : 0) + 1;
+    if (flowId !== undefined && flowCommandSequence !== null) {
+        cache.flowCommandSequencesByFlowId.set(flowId, flowCommandSequence);
+    }
+    return {
+        flowCommandSequence,
+        flowHandleCacheEpoch: cache.epoch,
+    };
+}
+export function writeSettledProviderFlowHandleId(cache, { command, flowCommandSequence, flowHandleCacheEpoch, settlementResult, }) {
+    const flowId = toCommandFlowId(command);
+    const flowHandleId = toSettledFlowHandleId(settlementResult);
+    const canWriteFlowHandle = flowId &&
+        flowHandleId &&
+        flowHandleCacheEpoch === cache.epoch &&
+        flowCommandSequence === cache.flowCommandSequencesByFlowId.get(flowId);
+    if (!canWriteFlowHandle) {
+        return false;
+    }
+    cache.flowHandleIdsByFlowId.set(flowId, flowHandleId);
+    return true;
+}

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

package/package.json

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