@getuserfeedback/react-native 2.0.11 → 2.0.12

package/dist/index.js

@@ -13,9 +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, } from "./provider-command-helpers.js";
+import { toCommandSettlementError, toReactNativeOneShotCommand, } from "./provider-command-helpers.js";
 import { useProviderCommandTransport } from "./provider-command-transport.js";
-import { clearProviderFlowHandleCache, createProviderFlowHandleCache, deleteCachedProviderFlowHandleId, deleteCachedProviderFlowId, getCachedProviderFlowHandleId, snapshotProviderFlowCommand, writeSettledProviderFlowHandleId, } from "./provider-flow-handle-cache.js";
 import { createProviderWidgetHostLifecycleController, HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY, } from "./provider-widget-host-lifecycle.js";
 import { ProviderWidgetHostOverlay, toProviderWidgetHostStyle, toProviderWidgetSheetHostLayoutPlan, } from "./provider-widget-host-overlay.js";
 import { REACT_NATIVE_SDK_VERSION } from "./version.js";
@@ -117,7 +116,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     const [instanceId] = useState(() => { var _a; return (_a = normalizeOptionalString(instanceIdProp)) !== null && _a !== void 0 ? _a : createUniqueId("rn"); });
     const [widgetHostVisibility, setWidgetHostVisibility] = useState(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
     const resolvedHostViewport = useResolvedHostViewport(hostViewport);
-    const flowHandleCacheRef = useRef(createProviderFlowHandleCache());
     const initOptionsRef = useRef(initOptions);
     const configureOptionsRef = useRef(configureOptions);
     const initOptionsKey = useMemo(() => toJsonKey(initOptions), [initOptions]);
@@ -138,7 +136,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     if (syncHostSourceKey(hostSourceKey)) {
         pausePendingCommandTimeouts();
         clearStartupQueuedKey();
-        clearProviderFlowHandleCache(flowHandleCacheRef.current);
     }
     initOptionsRef.current = initOptions;
     configureOptionsRef.current = configureOptions;
@@ -165,7 +162,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             requestId,
             idempotencyKey,
             clientMeta: CLIENT_META,
-            command,
+            command: toReactNativeOneShotCommand(command),
         };
         const message = {
             kind: "enqueueCommand",
@@ -186,10 +183,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             envelope: validatedMessage.envelope,
             message: validatedMessage,
         };
-        const flowCommandSnapshot = snapshotProviderFlowCommand(flowHandleCacheRef.current, validatedMessage.envelope.command);
         const promise = createPendingCommandPromise({
-            flowCommandSequence: flowCommandSnapshot.flowCommandSequence,
-            flowHandleCacheEpoch: flowCommandSnapshot.flowHandleCacheEpoch,
             isStartup,
             message: validatedMessage,
             requestId,
@@ -204,7 +198,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         registerNativeMessage,
     ]);
     const reissueDeliveredPendingActionCommands = useCallback(() => {
-        var _a;
         const replacements = new Map();
         for (const [requestId, pendingCommand] of getPendingCommandEntries()) {
             if (pendingCommand.isStartup || pendingCommand.hostEpoch === null) {
@@ -215,14 +208,13 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                 pendingCommand.timeout = null;
             }
             const command = pendingCommand.result.envelope.command;
-            const nextEnvelope = Object.assign(Object.assign({}, pendingCommand.result.envelope), { command: (_a = toRetryWithoutFlowHandle(command)) !== null && _a !== void 0 ? _a : command, requestId: createCommandRequestId() });
+            const nextEnvelope = Object.assign(Object.assign({}, pendingCommand.result.envelope), { command: toReactNativeOneShotCommand(command), requestId: createCommandRequestId() });
             const nextMessage = parseWebViewTransportNativeMessage({
                 kind: "enqueueCommand",
                 id: createTransportMessageId(),
                 envelope: nextEnvelope,
             });
             const reissuedCommand = reissuePendingCommand({
-                flowHandleCacheEpoch: flowHandleCacheRef.current.epoch,
                 nextMessage,
                 nextRequestId: nextEnvelope.requestId,
                 nextResult: {
@@ -284,7 +276,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         let didReissueDeliveredCommands = false;
         if (readyResult.didResetHostEpoch) {
             clearStartupQueuedKey();
-            clearProviderFlowHandleCache(flowHandleCacheRef.current);
             didReissueDeliveredCommands = reissueDeliveredPendingActionCommands();
         }
         setWidgetHostVisibility((visibility) => toReadyVisibility(visibility, event));
@@ -313,7 +304,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         const notReadyResult = markNotReady();
         if (notReadyResult.wasReady) {
             clearStartupQueuedKey();
-            clearProviderFlowHandleCache(flowHandleCacheRef.current);
             reissueDeliveredPendingActionCommands();
         }
         setWidgetHostVisibility(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
@@ -325,13 +315,9 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         pausePendingCommandTimeouts,
         reissueDeliveredPendingActionCommands,
     ]);
-    const deleteCachedFlowHandleId = useCallback((flowHandleId) => {
-        deleteCachedProviderFlowHandleId(flowHandleCacheRef.current, flowHandleId);
-    }, []);
     const handleFlowHandleInvalidated = useCallback((flowHandleId) => {
-        deleteCachedFlowHandleId(flowHandleId);
         setWidgetHostVisibility((visibility) => clearFlowHandleFromVisibility(visibility, flowHandleId));
-    }, [clearFlowHandleFromVisibility, deleteCachedFlowHandleId]);
+    }, [clearFlowHandleFromVisibility]);
     const handleInstanceFlowStateChanged = useCallback((detail) => {
         const visibility = toFlowStateVisibility(detail, instanceId);
         if (!visibility) {
@@ -369,33 +355,11 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
                     if (pendingCommand.isStartup) {
                         clearStartupQueuedKey();
                     }
-                    const flowId = toCommandFlowId(pendingCommand.result.envelope.command);
-                    const isStaleFlowHandleError = error.code === "STALE_HANDLE" ||
-                        error.message.includes("flowHandleId is stale");
-                    if (flowId && isStaleFlowHandleError) {
-                        deleteCachedProviderFlowId(flowHandleCacheRef.current, flowId);
-                    }
-                    const retryCommand = isStaleFlowHandleError
-                        ? toRetryWithoutFlowHandle(pendingCommand.result.envelope.command)
-                        : null;
-                    if (retryCommand) {
-                        enqueueTransportCommand(retryCommand).then(pendingCommand.resolve, pendingCommand.reject);
-                        return;
-                    }
                     pendingCommand.reject(error);
                 }
                 else {
                     const settlement = message.event
                         .detail;
-                    writeSettledProviderFlowHandleId(flowHandleCacheRef.current, {
-                        command: pendingCommand.result.envelope.command,
-                        flowCommandSequence: pendingCommand.flowCommandSequence,
-                        flowHandleCacheEpoch: pendingCommand.flowHandleCacheEpoch,
-                        settlementResult: settlement.result,
-                    });
-                    if (pendingCommand.result.envelope.command.kind === "reset") {
-                        clearProviderFlowHandleCache(flowHandleCacheRef.current);
-                    }
                     const settledResult = Object.assign(Object.assign({}, pendingCommand.result), { settlement, settlementResult: settlement.result });
                     pendingCommand.resolve(settledResult);
                 }
@@ -403,7 +367,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         }
         onWebMessage === null || onWebMessage === void 0 ? void 0 : onWebMessage(message);
     }, [
-        enqueueTransportCommand,
         clearStartupQueuedKey,
         getCurrentHostEpoch,
         getPendingCommand,
@@ -441,7 +404,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             return enqueueCommand({
                 kind: "open",
                 flowId: normalizedFlowId,
-                flowHandleId: getCachedProviderFlowHandleId(flowHandleCacheRef.current, normalizedFlowId),
                 hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
             }, commandOptions);
         },
@@ -450,7 +412,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             return enqueueCommand({
                 kind: "prefetch",
                 flowId: normalizedFlowId,
-                flowHandleId: getCachedProviderFlowHandleId(flowHandleCacheRef.current, normalizedFlowId),
             }, options);
         },
         prerender: (flowId, options, commandOptions) => {
@@ -458,7 +419,6 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             return enqueueCommand({
                 kind: "prerender",
                 flowId: normalizedFlowId,
-                flowHandleId: getCachedProviderFlowHandleId(flowHandleCacheRef.current, normalizedFlowId),
                 hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
             }, commandOptions);
         },

package/dist/provider-command-helpers.d.ts

@@ -7,8 +7,6 @@ export type CommandSettledEvent = Extract<WebViewTransportHostEvent, {
 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 toReactNativeOneShotCommand(command: ReactNativeWidgetCommand): ReactNativeWidgetCommand;
 export declare function toCommandSettlementError(event: CommandSettledEvent): CommandSettlementError | null;
 export {};

package/dist/provider-command-helpers.js

@@ -1,30 +1,27 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 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) {
+export function toReactNativeOneShotCommand(command) {
     if (!isReactNativeFlowCommand(command) ||
         command.flowHandleId === undefined) {
-        return null;
+        return command;
     }
-    return Object.assign(Object.assign({}, command), { flowHandleId: undefined });
+    const { flowHandleId: _flowHandleId } = command, commandWithoutFlowHandle = __rest(command, ["flowHandleId"]);
+    return commandWithoutFlowHandle;
 }
 export function toCommandSettlementError(event) {
     if (event.detail.ok) {

package/dist/provider-command-transport.d.ts

@@ -6,15 +6,12 @@ export type ProviderCommandTransportOptions = {
     getCurrentHostEpoch: () => number | null;
 };
 type ProviderPendingCommandRegistration<Result> = {
-    flowCommandSequence: number | null;
-    flowHandleCacheEpoch: number;
     isStartup: boolean;
     message: WebViewTransportNativeMessage;
     requestId: string;
     result: Result;
 };
 type ProviderPendingCommandReissue<Result> = {
-    flowHandleCacheEpoch: number;
     nextMessage: WebViewTransportNativeMessage;
     nextRequestId: string;
     nextResult: Result;

package/dist/provider-command-transport.js

@@ -56,10 +56,8 @@ export function useProviderCommandTransport({ commandTimeoutMs, createTimeoutErr
             pendingCommand.timeout = null;
         }
     }, []);
-    const createPendingCommandPromise = useCallback(({ flowCommandSequence, flowHandleCacheEpoch, isStartup, message, requestId, result, }) => new Promise((resolve, reject) => {
+    const createPendingCommandPromise = useCallback(({ isStartup, message, requestId, result, }) => new Promise((resolve, reject) => {
         const pendingCommand = {
-            flowCommandSequence,
-            flowHandleCacheEpoch,
             hostEpoch: null,
             isStartup,
             messageId: message.id,
@@ -79,9 +77,8 @@ export function useProviderCommandTransport({ commandTimeoutMs, createTimeoutErr
     const replaceNativeMessages = useCallback((replacements) => {
         setNativeMessages((messages) => replaceProviderNativeMessages(messages, replacements));
     }, []);
-    const reissuePendingCommand = useCallback(({ flowHandleCacheEpoch, nextMessage, nextRequestId, nextResult, requestId, }) => {
+    const reissuePendingCommand = useCallback(({ nextMessage, nextRequestId, nextResult, requestId, }) => {
         const reissuedCommand = reissueProviderPendingCommand(pendingCommandsRef.current, {
-            flowHandleCacheEpoch,
             nextMessageId: nextMessage.id,
             nextRequestId,
             nextResult,

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

@@ -1,6 +1,4 @@
 export type ProviderPendingCommand<Result> = {
-    flowCommandSequence: number | null;
-    flowHandleCacheEpoch: number;
     hostEpoch: number | null;
     isStartup: boolean;
     messageId: string;
@@ -27,8 +25,7 @@ export declare function isProviderPendingMessageStartup<Result>(registry: Provid
 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;
+export declare function reissueProviderPendingCommand<Result>(registry: ProviderPendingCommandRegistry<Result>, { nextMessageId, nextRequestId, nextResult, requestId, }: {
     nextMessageId: string;
     nextRequestId: string;
     nextResult: Result;

package/dist/provider-pending-commands.js

@@ -40,14 +40,13 @@ export function cancelProviderStartupCommands(registry) {
     }
     return { commands, messageIds };
 }
-export function reissueProviderPendingCommand(registry, { flowHandleCacheEpoch, nextMessageId, nextRequestId, nextResult, requestId, }) {
+export function reissueProviderPendingCommand(registry, { 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;

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "2.0.11",
+  "version": "2.0.12",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^3.1.0",
-    "@getuserfeedback/sdk": "^0.8.17",
+    "@getuserfeedback/protocol": "^3.1.1",
+    "@getuserfeedback/sdk": "^0.8.18",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {

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

@@ -1,24 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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;
-}