@getuserfeedback/react-native 3.0.47 → 3.0.48

package/dist/native-core-command-channel.d.ts

@@ -0,0 +1,16 @@
+import { type CoreCommandEnvelope } from "@getuserfeedback/protocol";
+import { type EventCommandSettled } from "@getuserfeedback/protocol/internal/core-host-command-settlement";
+import type { CoreWebViewHostConnection } from "./core-webview-host-controller.js";
+export type NativeCoreCommandChannel = {
+    post: (envelope: CoreCommandEnvelope) => void;
+    subscribe: (listener: (message: EventCommandSettled) => void) => () => void;
+};
+type OwnedNativeCoreCommandChannel = {
+    channel: NativeCoreCommandChannel;
+    dispose: () => void;
+};
+export declare function createNativeCoreCommandChannel(input: {
+    coreConnection: CoreWebViewHostConnection;
+    onInvalidMessage?: (error: Error, value: unknown) => void;
+}): OwnedNativeCoreCommandChannel;
+export {};

package/dist/native-core-command-channel.js

@@ -0,0 +1,59 @@
+import { coreCommandEnvelopeSchema, } from "@getuserfeedback/protocol";
+import { eventCommandSettledSchema, } from "@getuserfeedback/protocol/internal/core-host-command-settlement";
+const DISPOSED_MESSAGE = "Core command channel is disposed";
+const isRecord = (value) => typeof value === "object" && value !== null;
+export function createNativeCoreCommandChannel(input) {
+    const listeners = new Set();
+    let disposed = false;
+    const handleMessage = (value) => {
+        var _a;
+        if (disposed ||
+            !isRecord(value) ||
+            value.t !== "getuserfeedback:event:commandSettled") {
+            return;
+        }
+        const parsed = eventCommandSettledSchema.safeParse(value);
+        if (!parsed.success) {
+            (_a = input.onInvalidMessage) === null || _a === void 0 ? void 0 : _a.call(input, parsed.error instanceof Error
+                ? parsed.error
+                : new Error("Invalid core command settlement message"), value);
+            return;
+        }
+        if (parsed.data.gen !== input.coreConnection.generation) {
+            return;
+        }
+        for (const listener of [...listeners]) {
+            listener(parsed.data);
+        }
+    };
+    const unsubscribeTransport = input.coreConnection.transport.subscribe(handleMessage);
+    const channel = {
+        post: (envelope) => {
+            if (disposed) {
+                throw new Error(DISPOSED_MESSAGE);
+            }
+            const validatedEnvelope = coreCommandEnvelopeSchema.parse(envelope);
+            input.coreConnection.transport.postMessage(validatedEnvelope);
+        },
+        subscribe: (listener) => {
+            if (disposed) {
+                return () => { };
+            }
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+    return {
+        channel,
+        dispose: () => {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            unsubscribeTransport();
+            listeners.clear();
+        },
+    };
+}

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

@@ -1,13 +1,15 @@
 import { type ReactElement } from "react";
 import { type CoreWebViewHostProps } from "./core-webview-host.js";
+import { type NativeCoreCommandChannel } from "./native-core-command-channel.js";
 import { type NativeViewHostProjectionProps } from "./native-view-host-projection.js";
 export type NativeRuntimeRootProps = {
     coreUrl: string;
     coreWebViewComponent?: CoreWebViewHostProps["webViewComponent"];
     coreWebViewProps?: CoreWebViewHostProps["webViewProps"];
+    onCommandChannelChange?: (channel: NativeCoreCommandChannel | null) => void;
     onError?: (error: Error) => void;
     onInvalidMessage?: (error: Error, value: unknown) => void;
     viewWebViewComponent?: NativeViewHostProjectionProps["webViewComponent"];
     viewWebViewProps?: NativeViewHostProjectionProps["webViewProps"];
 };
-export declare function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onError, onInvalidMessage, viewWebViewComponent, viewWebViewProps, }: NativeRuntimeRootProps): ReactElement;
+export declare function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onCommandChannelChange, onError, onInvalidMessage, viewWebViewComponent, viewWebViewProps, }: NativeRuntimeRootProps): ReactElement;

package/dist/native-runtime-root.js

@@ -1,42 +1,91 @@
 import { createElement, Fragment, useCallback, useEffect, useRef, useState, } from "react";
 import { CoreWebViewHost, } from "./core-webview-host.js";
+import { createNativeCoreCommandChannel, } from "./native-core-command-channel.js";
 import { NativeViewHostProjection, } from "./native-view-host-projection.js";
 import { createNativeViewRecordController, } from "./native-view-record-controller.js";
-export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onError, onInvalidMessage, viewWebViewComponent, viewWebViewProps, }) {
+// TODO(architecture): Route protocol-owned init/bootstrap commands through the private native runtime channel without moving provider ownership.
+// [from=private-native-command-bootstrap-composition] [to=protocol-owned-native-command-bootstrap-routing] [scope=slice] [principle=preserve-provider-runtime] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=70]
+export function NativeRuntimeRoot({ coreUrl, coreWebViewComponent, coreWebViewProps, onCommandChannelChange, onError, onInvalidMessage, viewWebViewComponent, viewWebViewProps, }) {
     const [session, setSession] = useState(null);
     const sessionRef = useRef(null);
     const nextSessionKeyRef = useRef(0);
     const onErrorRef = useRef(onError);
     onErrorRef.current = onError;
+    const onCommandChannelChangeRef = useRef(onCommandChannelChange);
+    onCommandChannelChangeRef.current = onCommandChannelChange;
+    const onInvalidMessageRef = useRef(onInvalidMessage);
+    onInvalidMessageRef.current = onInvalidMessage;
+    const notifyCommandChannelObserver = useCallback((observer, channel) => {
+        var _a;
+        try {
+            observer === null || observer === void 0 ? void 0 : observer(channel);
+        }
+        catch (error) {
+            try {
+                (_a = onErrorRef.current) === null || _a === void 0 ? void 0 : _a.call(onErrorRef, error instanceof Error ? error : new Error(String(error)));
+            }
+            catch (_b) {
+                // Observer failures must not interrupt connection settlement.
+            }
+        }
+    }, []);
     const handleConnected = useCallback((coreConnection) => {
         const previousSession = sessionRef.current;
-        previousSession === null || previousSession === void 0 ? void 0 : previousSession.controller.dispose();
+        if (previousSession) {
+            sessionRef.current = null;
+            previousSession.commandChannelOwner.dispose();
+            previousSession.controller.dispose();
+            notifyCommandChannelObserver(previousSession.observer, null);
+        }
         const controller = createNativeViewRecordController({
             coreConnection,
             onError: (error) => { var _a; return (_a = onErrorRef.current) === null || _a === void 0 ? void 0 : _a.call(onErrorRef, error); },
         });
+        const commandChannelOwner = createNativeCoreCommandChannel({
+            coreConnection,
+            onInvalidMessage: (error, value) => { var _a; return (_a = onInvalidMessageRef.current) === null || _a === void 0 ? void 0 : _a.call(onInvalidMessageRef, error, value); },
+        });
         const nextSession = {
+            commandChannelOwner,
             controller,
             key: nextSessionKeyRef.current + 1,
+            observer: onCommandChannelChangeRef.current,
         };
         nextSessionKeyRef.current = nextSession.key;
         sessionRef.current = nextSession;
         setSession(nextSession);
-    }, []);
+        notifyCommandChannelObserver(nextSession.observer, commandChannelOwner.channel);
+    }, [notifyCommandChannelObserver]);
     const handleDisconnected = useCallback(() => {
         const currentSession = sessionRef.current;
         if (!currentSession) {
             return;
         }
-        currentSession.controller.dispose();
         sessionRef.current = null;
+        currentSession.commandChannelOwner.dispose();
+        currentSession.controller.dispose();
         setSession(null);
-    }, []);
+        notifyCommandChannelObserver(currentSession.observer, null);
+    }, [notifyCommandChannelObserver]);
+    useEffect(() => {
+        const currentSession = sessionRef.current;
+        if (!currentSession || currentSession.observer === onCommandChannelChange) {
+            return;
+        }
+        const previousObserver = currentSession.observer;
+        currentSession.observer = onCommandChannelChange;
+        notifyCommandChannelObserver(previousObserver, null);
+        notifyCommandChannelObserver(onCommandChannelChange, currentSession.commandChannelOwner.channel);
+    }, [notifyCommandChannelObserver, onCommandChannelChange]);
     useEffect(() => () => {
         const currentSession = sessionRef.current;
         sessionRef.current = null;
-        currentSession === null || currentSession === void 0 ? void 0 : currentSession.controller.dispose();
-    }, []);
+        if (currentSession) {
+            currentSession.commandChannelOwner.dispose();
+            currentSession.controller.dispose();
+            notifyCommandChannelObserver(currentSession.observer, null);
+        }
+    }, [notifyCommandChannelObserver]);
     return createElement(Fragment, null, createElement(CoreWebViewHost, {
         coreUrl,
         onConnected: handleConnected,

package/dist/native-view-host-projection.js

@@ -38,5 +38,3 @@ export function NativeViewHostProjection({ controller, onInvalidMessage, webView
         key: record.allocationId,
     })));
 }
-// TODO(architecture): Prove command/bootstrap composition from the private native runtime root without switching provider ownership.
-// [from=private-native-runtime-composition] [to=private-native-command-bootstrap-composition] [scope=slice] [principle=preserve-provider-runtime] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=60]

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "3.0.47",
+  "version": "3.0.48",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^3.12.2",
-    "@getuserfeedback/sdk": "^0.10.12",
+    "@getuserfeedback/protocol": "^3.12.3",
+    "@getuserfeedback/sdk": "^0.10.13",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {