@getuserfeedback/react-native 1.3.5 → 1.3.6

package/dist/index.js

@@ -13,7 +13,8 @@ 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 { 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 +116,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 +142,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;
@@ -203,7 +201,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 +231,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,
@@ -297,7 +289,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 = {
@@ -375,8 +367,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 +402,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 +415,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);
@@ -500,7 +485,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 +499,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 +561,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 +570,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 +578,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/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.6";

package/package.json

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