@getuserfeedback/react-native 3.0.79 → 3.0.81

package/dist/native-direct-command-session-controller.d.ts

@@ -0,0 +1,9 @@
+import type { NativeDirectCommandSession } from "./native-direct-command-session.js";
+export type NativeDirectCommandSessionController = {
+    attach: (session: NativeDirectCommandSession) => void;
+    detach: (session: NativeDirectCommandSession) => void;
+    dispose: (error: Error) => void;
+    rejectUntilAttached: (error: Error) => void;
+    session: NativeDirectCommandSession;
+};
+export declare function createNativeDirectCommandSessionController(): NativeDirectCommandSessionController;

package/dist/native-direct-command-session-controller.js

@@ -0,0 +1,78 @@
+export function createNativeDirectCommandSessionController() {
+    let attachedSession = null;
+    let disposed = false;
+    let disposalError;
+    let pendingCommands = [];
+    let unavailableError;
+    const dispatchThrough = (session, envelope) => {
+        try {
+            return Promise.resolve(session.dispatch(envelope));
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    };
+    const session = {
+        dispatch: (envelope) => {
+            if (disposed) {
+                return Promise.reject(disposalError);
+            }
+            if (attachedSession !== null) {
+                return dispatchThrough(attachedSession, envelope);
+            }
+            if (unavailableError !== undefined) {
+                return Promise.reject(unavailableError);
+            }
+            return new Promise((resolve, reject) => {
+                pendingCommands.push({ envelope, reject, resolve });
+            });
+        },
+    };
+    const dispose = (error) => {
+        if (disposed) {
+            return;
+        }
+        disposed = true;
+        disposalError = error;
+        attachedSession = null;
+        const queuedCommands = pendingCommands;
+        pendingCommands = [];
+        for (const command of queuedCommands) {
+            command.reject(error);
+        }
+    };
+    return {
+        attach: (nextSession) => {
+            if (disposed) {
+                return;
+            }
+            attachedSession = nextSession;
+            unavailableError = undefined;
+            const queuedCommands = pendingCommands;
+            pendingCommands = [];
+            for (const command of queuedCommands) {
+                if (disposed) {
+                    command.reject(disposalError);
+                    continue;
+                }
+                void dispatchThrough(nextSession, command.envelope).then(command.resolve, command.reject);
+            }
+        },
+        detach: (sessionToDetach) => {
+            if (attachedSession === sessionToDetach) {
+                attachedSession = null;
+            }
+        },
+        dispose,
+        rejectUntilAttached: (error) => {
+            attachedSession = null;
+            unavailableError = error;
+            const queuedCommands = pendingCommands;
+            pendingCommands = [];
+            for (const command of queuedCommands) {
+                command.reject(error);
+            }
+        },
+        session,
+    };
+}

package/dist/native-direct-command-session.d.ts

@@ -10,7 +10,7 @@ type NativeFlowAllocationCommand = (Omit<Extract<CoreTranslatablePublicCommandPa
 }>;
 /** Public commands accepted by the direct native provider session. */
 type NativeDirectCommandPayload = Exclude<CoreTranslatablePublicCommandPayload, {
-    kind: "init" | "open" | "prefetch" | "prerender" | "reset";
+    kind: "init" | "open" | "prefetch" | "prerender";
 }> | NativeFlowAllocationCommand;
 /** Public command envelope accepted by the direct native provider session. */
 export type NativeDirectCommandEnvelope = Omit<CommandEnvelopeWithInstanceId, "command"> & {

package/dist/native-direct-command-session.js

@@ -1,6 +1,6 @@
 import { getFlowHandleFromSettlementDetail } from "@getuserfeedback/protocol/host";
 import { toCoreCommandPayload, } from "@getuserfeedback/protocol/internal/public-core-command";
-// TODO(migration): Route reset and the public provider client through this core-ordered direct session.
+// TODO(migration): Route the public provider client through this core-ordered direct session.
 // [from=native-core-ordered-command-session] [to=native-provider-direct-session] [scope=slice] [principle=core-owned-flow-lifecycle] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=180]
 export function createNativeDirectCommandSession(input) {
     const dispatchToCore = (envelope, command) => {

package/dist/native-runtime-root.d.ts

@@ -13,6 +13,7 @@ export type NativeRuntimeRootProps = {
     onCommandSessionChange?: (session: NativeCoreCommandSession | null) => void;
     onError?: (error: Error) => void;
     onInvalidMessage?: (error: Error, value: unknown) => void;
+    onStartupTerminalError?: (error: Error) => void;
     startupCommandSettlementTimeoutMs?: number;
     viewWebViewComponent?: NativeViewHostProjectionProps["webViewComponent"];
     viewWebViewProps?: NativeViewHostProjectionProps["webViewProps"];
@@ -28,12 +29,12 @@ type NativeRuntimeConfigureCommand = Omit<CoreCommandEnvelope, "command"> & {
     }>;
 };
 type NativeRuntimeStartupCommands = readonly [NativeRuntimeInitCommand] | readonly [NativeRuntimeInitCommand, NativeRuntimeConfigureCommand];
-type NativeProviderRuntimeProps = Omit<NativeRuntimeRootProps, "onCommandSessionChange" | "startupCommands"> & {
+type NativeProviderRuntimeProps = Omit<NativeRuntimeRootProps, "onCommandSessionChange" | "onStartupTerminalError" | "startupCommands"> & {
     initialConfigureOptions?: ConfigureOptions;
     initOptions: InitOptions;
     instanceId: string;
     onCommandSessionChange?: (session: NativeDirectCommandSession | null) => void;
 };
-export declare function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onCommandSessionChange, onError, onInvalidMessage, startupCommandSettlementTimeoutMs, startupCommands, viewWebViewComponent, viewWebViewProps, }: NativeRuntimeRootProps): ReactElement;
-export declare function NativeProviderRuntime({ initOptions, initialConfigureOptions, instanceId, onCommandSessionChange, ...runtimeProps }: NativeProviderRuntimeProps): ReactElement;
+export declare function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onCommandSessionChange, onError, onInvalidMessage, onStartupTerminalError, startupCommandSettlementTimeoutMs, startupCommands, viewWebViewComponent, viewWebViewProps, }: NativeRuntimeRootProps): ReactElement;
+export declare function NativeProviderRuntime({ initOptions, initialConfigureOptions, instanceId, onCommandSessionChange, onError, ...runtimeProps }: NativeProviderRuntimeProps): ReactElement;
 export {};

package/dist/native-runtime-root.js

@@ -18,6 +18,7 @@ import { createNativeDirectCommandSession, } from "./native-direct-command-sessi
 import { NativeViewHostProjection, } from "./native-view-host-projection.js";
 import { createNativeViewRecordController, } from "./native-view-record-controller.js";
 import { createProviderCommandEnvelope, REACT_NATIVE_CLIENT_META, } from "./provider-command-helpers.js";
+import { useNativeDirectCommandSessionController } from "./use-native-direct-command-session-controller.js";
 const DEFAULT_STARTUP_COMMAND_SETTLEMENT_TIMEOUT_MS = 30000;
 function dispatchStartupCommand(input) {
     let timeoutId;
@@ -42,7 +43,7 @@ async function dispatchStartupCommands(input) {
         });
     }
 }
-export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onCommandSessionChange, onError, onInvalidMessage, startupCommandSettlementTimeoutMs = DEFAULT_STARTUP_COMMAND_SETTLEMENT_TIMEOUT_MS, startupCommands, viewWebViewComponent, viewWebViewProps, }) {
+export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onCommandSessionChange, onError, onInvalidMessage, onStartupTerminalError, startupCommandSettlementTimeoutMs = DEFAULT_STARTUP_COMMAND_SETTLEMENT_TIMEOUT_MS, startupCommands, viewWebViewComponent, viewWebViewProps, }) {
     const [coreHostRevision, setCoreHostRevision] = useState(0);
     const [session, setSession] = useState(null);
     const sessionRef = useRef(null);
@@ -54,6 +55,8 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
     onCommandSessionChangeRef.current = onCommandSessionChange;
     const onInvalidMessageRef = useRef(onInvalidMessage);
     onInvalidMessageRef.current = onInvalidMessage;
+    const onStartupTerminalErrorRef = useRef(onStartupTerminalError);
+    onStartupTerminalErrorRef.current = onStartupTerminalError;
     const startupCommandsRef = useRef(startupCommands);
     startupCommandsRef.current = startupCommands;
     const reportError = useCallback((error) => {
@@ -124,6 +127,7 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
             })
                 .then(commitSession)
                 .catch((error) => {
+                var _a;
                 if (sessionRef.current !== nextSession) {
                     return;
                 }
@@ -131,11 +135,21 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
                 commandSessionOwner.dispose();
                 commandChannelOwner.dispose();
                 controller.dispose();
-                if (!(error instanceof CommandSettlementError) &&
-                    !startupRetryAttemptedRef.current) {
+                const shouldRetry = !(error instanceof CommandSettlementError) &&
+                    !startupRetryAttemptedRef.current;
+                if (shouldRetry) {
                     startupRetryAttemptedRef.current = true;
                     setCoreHostRevision((revision) => revision + 1);
                 }
+                else {
+                    startupRetryAttemptedRef.current = false;
+                    try {
+                        (_a = onStartupTerminalErrorRef.current) === null || _a === void 0 ? void 0 : _a.call(onStartupTerminalErrorRef, error instanceof Error ? error : new Error(String(error)));
+                    }
+                    catch (observerError) {
+                        reportError(observerError);
+                    }
+                }
                 reportError(error);
             });
             return;
@@ -205,11 +219,19 @@ export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewPr
         }));
 }
 export function NativeProviderRuntime(_a) {
-    var { initOptions, initialConfigureOptions, instanceId, onCommandSessionChange } = _a, runtimeProps = __rest(_a, ["initOptions", "initialConfigureOptions", "instanceId", "onCommandSessionChange"]);
+    var { initOptions, initialConfigureOptions, instanceId, onCommandSessionChange, onError } = _a, runtimeProps = __rest(_a, ["initOptions", "initialConfigureOptions", "instanceId", "onCommandSessionChange", "onError"]);
+    const directSessionController = useNativeDirectCommandSessionController();
     const directSessionRef = useRef(null);
+    const handleStartupTerminalError = useCallback((error) => {
+        directSessionController.rejectUntilAttached(error);
+    }, [directSessionController]);
     const handleCommandSessionChange = useCallback((session) => {
         var _a;
         if (session === null) {
+            if (directSessionRef.current !== null) {
+                directSessionController.detach(directSessionRef.current.directSession);
+                directSessionRef.current = null;
+            }
             onCommandSessionChange === null || onCommandSessionChange === void 0 ? void 0 : onCommandSessionChange(null);
             return;
         }
@@ -220,9 +242,10 @@ export function NativeProviderRuntime(_a) {
                     coreSession: session,
                 }),
             };
+            directSessionController.attach(directSessionRef.current.directSession);
         }
-        onCommandSessionChange === null || onCommandSessionChange === void 0 ? void 0 : onCommandSessionChange(directSessionRef.current.directSession);
-    }, [onCommandSessionChange]);
+        onCommandSessionChange === null || onCommandSessionChange === void 0 ? void 0 : onCommandSessionChange(directSessionController.session);
+    }, [directSessionController, onCommandSessionChange]);
     const startupCommands = useMemo(() => {
         const initCommand = createProviderCommandEnvelope({
             clientMeta: REACT_NATIVE_CLIENT_META,
@@ -240,5 +263,5 @@ export function NativeProviderRuntime(_a) {
             }),
         ];
     }, [initialConfigureOptions, initOptions, instanceId]);
-    return createElement(NativeRuntimeRoot, Object.assign(Object.assign({}, runtimeProps), { onCommandSessionChange: handleCommandSessionChange, startupCommands }));
+    return createElement(NativeRuntimeRoot, Object.assign(Object.assign({}, runtimeProps), { onCommandSessionChange: handleCommandSessionChange, onError, onStartupTerminalError: handleStartupTerminalError, startupCommands }));
 }

package/dist/use-native-direct-command-session-controller.d.ts

@@ -0,0 +1,2 @@
+import { type NativeDirectCommandSessionController } from "./native-direct-command-session-controller.js";
+export declare function useNativeDirectCommandSessionController(): NativeDirectCommandSessionController;

package/dist/use-native-direct-command-session-controller.js

@@ -0,0 +1,21 @@
+import { useEffect, useRef } from "react";
+import { createNativeDirectCommandSessionController, } from "./native-direct-command-session-controller.js";
+export function useNativeDirectCommandSessionController() {
+    var _a;
+    const controllerRef = useRef(null);
+    (_a = controllerRef.current) !== null && _a !== void 0 ? _a : (controllerRef.current = createNativeDirectCommandSessionController());
+    const controller = controllerRef.current;
+    const lifecycleRevisionRef = useRef(0);
+    useEffect(() => {
+        lifecycleRevisionRef.current += 1;
+        const lifecycleRevision = lifecycleRevisionRef.current;
+        return () => {
+            queueMicrotask(() => {
+                if (lifecycleRevisionRef.current === lifecycleRevision) {
+                    controller.dispose(new Error("Native provider runtime unmounted"));
+                }
+            });
+        };
+    }, [controller]);
+    return controller;
+}

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

package/package.json

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