@getuserfeedback/react-native 1.3.4 → 1.3.6

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import type { AppEventExternalId, AppEventJsonValue, PublicCommandPayload } from "@getuserfeedback/protocol";
-import type { WebViewCommandEnvelope, WebViewTransportHostEvent, WebViewTransportNativeMessage, WebViewTransportWebMessage } from "@getuserfeedback/protocol/webview-transport";
+import type { WebViewCommandEnvelope, WebViewTransportNativeMessage, WebViewTransportWebMessage } from "@getuserfeedback/protocol/webview-transport";
 import type { ConfigureOptions, InitOptions } from "@getuserfeedback/sdk";
 import { type ReactElement, type ReactNode } from "react";
+import { type CommandSettledEvent, type CommandSettledSuccessDetail } from "./provider-command-helpers.js";
 import { WidgetHost, type WidgetHostProps, type WidgetHostSource } from "./widget-host.js";
 export { REACT_NATIVE_SDK_VERSION } from "./version.js";
 export { buildNativeMessageInjectionScript, buildWebViewBridgeScript, } from "./webview-bridge-script.js";
@@ -29,12 +30,6 @@ type PrerenderOptions = Pick<PrerenderCommand, "hideCloseButton">;
 type HostContext = Extract<PublicCommandPayload, {
     kind: "updateHostContext";
 }>["context"];
-type CommandSettledEvent = Extract<WebViewTransportHostEvent, {
-    name: "instance:command:settled";
-}>;
-type CommandSettledSuccessDetail = Extract<CommandSettledEvent["detail"], {
-    ok: true;
-}>;
 export interface ReactNativeCommandResult {
     envelope: ReactNativeWidgetCommandEnvelope;
     message: ReactNativeWidgetNativeMessage;

package/dist/index.js

@@ -9,10 +9,12 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { assertNoSegmentExternalIdsInValueArgument, CommandSettlementError, CommandSettlementTimeoutError, } from "@getuserfeedback/protocol/host";
+import { assertNoSegmentExternalIdsInValueArgument, CommandSettlementTimeoutError, } from "@getuserfeedback/protocol/host";
 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, } 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";
@@ -104,42 +106,6 @@ const toIdentifyCommandPayload = (identifyInput, traitsOrOptions, options) => {
         options: options !== null && options !== void 0 ? options : traitsOrOptions,
     };
 };
-const isFlowCommand = (command) => command.kind === "open" ||
-    command.kind === "prefetch" ||
-    command.kind === "prerender";
-const toSettledFlowHandleId = (result) => {
-    if (typeof result !== "object" || result === null) {
-        return undefined;
-    }
-    const flowHandleId = result.flowHandleId;
-    return typeof flowHandleId === "string" && flowHandleId.trim().length > 0
-        ? flowHandleId
-        : undefined;
-};
-const toCommandFlowId = (command) => {
-    if (!isFlowCommand(command)) {
-        return undefined;
-    }
-    return command.flowId;
-};
-const toRetryWithoutFlowHandle = (command) => {
-    if (!isFlowCommand(command) || command.flowHandleId === undefined) {
-        return null;
-    }
-    return Object.assign(Object.assign({}, command), { flowHandleId: undefined });
-};
-const toCommandSettlementError = (event) => {
-    if (event.detail.ok) {
-        return null;
-    }
-    return new CommandSettlementError({
-        code: event.detail.error.code,
-        instanceId: event.detail.instanceId,
-        kind: event.detail.kind,
-        message: event.detail.error.message,
-        requestId: event.detail.requestId,
-    });
-};
 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, []);
@@ -150,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);
@@ -178,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;
@@ -238,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 = {
@@ -268,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,
@@ -332,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 = {
@@ -410,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 });
@@ -446,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;
@@ -460,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);
@@ -535,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)
@@ -549,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);
@@ -617,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);
         },
@@ -626,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) => {
@@ -634,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-command-helpers.d.ts

@@ -0,0 +1,14 @@
+import { CommandSettlementError } from "@getuserfeedback/protocol/host";
+import type { WebViewCommandEnvelope, WebViewTransportHostEvent } from "@getuserfeedback/protocol/webview-transport";
+type ReactNativeWidgetCommand = WebViewCommandEnvelope["command"];
+export type CommandSettledEvent = Extract<WebViewTransportHostEvent, {
+    name: "instance:command:settled";
+}>;
+export type CommandSettledSuccessDetail = Extract<CommandSettledEvent["detail"], {
+    ok: true;
+}>;
+export declare function toSettledFlowHandleId(result: unknown): string | undefined;
+export declare function toCommandFlowId(command: ReactNativeWidgetCommand): string | undefined;
+export declare function toRetryWithoutFlowHandle(command: ReactNativeWidgetCommand): ReactNativeWidgetCommand | null;
+export declare function toCommandSettlementError(event: CommandSettledEvent): CommandSettlementError | null;
+export {};

package/dist/provider-command-helpers.js

@@ -0,0 +1,40 @@
+import { CommandSettlementError } from "@getuserfeedback/protocol/host";
+function isReactNativeFlowCommand(command) {
+    return (command.kind === "open" ||
+        command.kind === "prefetch" ||
+        command.kind === "prerender");
+}
+export function toSettledFlowHandleId(result) {
+    if (typeof result !== "object" || result === null) {
+        return undefined;
+    }
+    const flowHandleId = result.flowHandleId;
+    return typeof flowHandleId === "string" && flowHandleId.trim().length > 0
+        ? flowHandleId
+        : undefined;
+}
+export function toCommandFlowId(command) {
+    if (!isReactNativeFlowCommand(command)) {
+        return undefined;
+    }
+    return command.flowId;
+}
+export function toRetryWithoutFlowHandle(command) {
+    if (!isReactNativeFlowCommand(command) ||
+        command.flowHandleId === undefined) {
+        return null;
+    }
+    return Object.assign(Object.assign({}, command), { flowHandleId: undefined });
+}
+export function toCommandSettlementError(event) {
+    if (event.detail.ok) {
+        return null;
+    }
+    return new CommandSettlementError({
+        code: event.detail.error.code,
+        instanceId: event.detail.instanceId,
+        kind: event.detail.kind,
+        message: event.detail.error.message,
+        requestId: event.detail.requestId,
+    });
+}

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.4";
+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.4",
+  "version": "1.3.6",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -40,6 +40,7 @@
     "build": "bun scripts/build.ts",
     "typecheck": "tsc -b tsconfig.json",
     "test": "bun test --dots",
+    "test:changed": "bun test --changed=${TEST_CHANGED_BASE:-HEAD} --pass-with-no-tests --dots",
     "lint": "ultracite check ."
   },
   "dependencies": {