@getuserfeedback/react-native 3.0.47 → 3.0.49

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/provider-widget-frame-appearance.d.ts

@@ -1,5 +1,11 @@
-import type { WidgetFrameAppearance } from "@getuserfeedback/protocol/host";
+import type { WidgetFrameAppearance, WidgetFrameResolvedBorder } from "@getuserfeedback/protocol/host";
+export type ProviderWidgetFrameBorderStyle = {
+    borderColor: string;
+    borderStyle: "dashed" | "dotted" | "solid";
+    borderWidth: number;
+};
 export type ProviderWidgetFrameAppearanceProjection = {
+    borderStyle?: ProviderWidgetFrameBorderStyle;
     shadowPolicy: "clear" | "legacy";
     topLeftRadius: number;
     topRightRadius: number;
@@ -8,4 +14,5 @@ export declare function safeParseProviderWidgetCanonicalTopRadii(value: string):
     topLeft: number;
     topRight: number;
 } | undefined;
+export declare function toProviderWidgetFrameBorderStyle(border?: WidgetFrameResolvedBorder): ProviderWidgetFrameBorderStyle;
 export declare function toProviderWidgetFrameAppearance(appearance?: WidgetFrameAppearance): ProviderWidgetFrameAppearanceProjection;

package/dist/provider-widget-frame-appearance.js

@@ -1,5 +1,10 @@
 const LEGACY_WIDGET_SHEET_RADIUS = 24;
 const CANONICAL_PX_PATTERN = /^(?:0|[1-9]\d*)(?:\.\d+)?px$/;
+const CLEARED_WIDGET_FRAME_BORDER_STYLE = {
+    borderColor: "transparent",
+    borderStyle: "solid",
+    borderWidth: 0,
+};
 const safeParseCanonicalPx = (value) => {
     if (!CANONICAL_PX_PATTERN.test(value)) {
         return undefined;
@@ -22,6 +27,22 @@ export function safeParseProviderWidgetCanonicalTopRadii(value) {
         ? undefined
         : { topLeft, topRight };
 }
+export function toProviderWidgetFrameBorderStyle(border) {
+    if (border === undefined ||
+        border.widthPx === 0 ||
+        border.style === "none" ||
+        border.style === "hidden") {
+        return Object.assign({}, CLEARED_WIDGET_FRAME_BORDER_STYLE);
+    }
+    const { alpha, blue, green, red } = border.color;
+    return {
+        borderColor: `rgba(${red}, ${green}, ${blue}, ${alpha})`,
+        borderStyle: border.style === "dashed" || border.style === "dotted"
+            ? border.style
+            : "solid",
+        borderWidth: border.widthPx,
+    };
+}
 export function toProviderWidgetFrameAppearance(appearance) {
     var _a, _b;
     if (appearance === undefined) {
@@ -33,6 +54,7 @@ export function toProviderWidgetFrameAppearance(appearance) {
     }
     if (appearance.kind === "none") {
         return {
+            borderStyle: toProviderWidgetFrameBorderStyle(),
             shadowPolicy: "clear",
             topLeftRadius: 0,
             topRightRadius: 0,
@@ -40,6 +62,7 @@ export function toProviderWidgetFrameAppearance(appearance) {
     }
     const radius = safeParseProviderWidgetCanonicalTopRadii(appearance.borderRadius);
     return {
+        borderStyle: toProviderWidgetFrameBorderStyle(appearance.resolvedBorder),
         shadowPolicy: "clear",
         topLeftRadius: (_a = radius === null || radius === void 0 ? void 0 : radius.topLeft) !== null && _a !== void 0 ? _a : 0,
         topRightRadius: (_b = radius === null || radius === void 0 ? void 0 : radius.topRight) !== null && _b !== void 0 ? _b : 0,

package/dist/provider-widget-host-overlay.d.ts

@@ -30,6 +30,7 @@ export declare function toProviderWidgetSheetSurfaceStyles(input: {
     sheetHostLayoutUpdate: WidgetLayoutComparableSizeUpdate | undefined;
 }): {
     contentStyle: unknown;
+    frameStyle: unknown;
     sheetStyle: unknown;
 };
 export declare function ProviderWidgetHostOverlay({ children, frameAppearance, isVisible, nativeView, onRequestDismiss, sheetHostLayoutUpdate, }: {

package/dist/provider-widget-host-overlay.js

@@ -51,6 +51,13 @@ const WIDGET_SHEET_CONTENT_BASE_STYLE = {
     flex: 1,
     overflow: "hidden",
 };
+const WIDGET_SHEET_FRAME_OVERLAY_STYLE = {
+    bottom: 0,
+    left: 0,
+    position: "absolute",
+    right: 0,
+    top: 0,
+};
 const WIDGET_SHEET_DRAG_HANDLE_TOUCH_STYLE = {
     alignItems: "center",
     elevation: 19,
@@ -210,13 +217,15 @@ export function toProviderWidgetSheetSurfaceStyles(input) {
         borderTopLeftRadius: appearance.topLeftRadius,
         borderTopRightRadius: appearance.topRightRadius,
     };
-    const frameStyle = appearance.shadowPolicy === "legacy"
+    const shadowStyle = appearance.shadowPolicy === "legacy"
         ? WIDGET_SHEET_LEGACY_FRAME_STYLE
         : WIDGET_SHEET_CLEARED_FRAME_STYLE;
     return {
         contentStyle: Object.assign(Object.assign({}, WIDGET_SHEET_CONTENT_BASE_STYLE), radiusStyle),
+        frameStyle: input.isVisible && sheetHostViewport !== undefined
+            ? Object.assign(Object.assign(Object.assign({}, WIDGET_SHEET_FRAME_OVERLAY_STYLE), radiusStyle), appearance.borderStyle) : HIDDEN_WIDGET_HOST_STYLE,
         sheetStyle: input.isVisible && sheetHostViewport !== undefined
-            ? Object.assign(Object.assign(Object.assign(Object.assign({}, WIDGET_SHEET_LAYOUT_STYLE), radiusStyle), frameStyle), { height: sheetHostViewport.height }) : HIDDEN_WIDGET_HOST_STYLE,
+            ? Object.assign(Object.assign(Object.assign(Object.assign({}, WIDGET_SHEET_LAYOUT_STYLE), radiusStyle), shadowStyle), { height: sheetHostViewport.height }) : HIDDEN_WIDGET_HOST_STYLE,
     };
 }
 function useProviderWidgetSheetPresentation(input) {
@@ -386,5 +395,9 @@ export function ProviderWidgetHostOverlay({ children, frameAppearance, isVisible
             style: WIDGET_SHEET_DRAG_HANDLE_INDICATOR_STYLE,
             testID: "gx-widget-host-drag-handle-indicator",
         }))
-        : null)));
+        : null), createElement(nativeView, {
+        pointerEvents: "none",
+        style: surfaceStyles.frameStyle,
+        testID: "gx-widget-host-sheet-frame",
+    })));
 }

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.49";

package/dist/view-webview-bridge-adapter.js

@@ -1,4 +1,4 @@
-import { VIEW_HOST_BOOTSTRAP_GLOBAL_KEY, VIEW_HOST_BOOTSTRAP_PROTOCOL_VERSION, VIEW_HOST_BOOTSTRAP_READY_EVENT_NAME, VIEW_HOST_BOOTSTRAP_REQUIRED_FRAGMENT, } from "@getuserfeedback/protocol/internal/view-host-bootstrap";
+import { VIEW_HOST_BOOTSTRAP_CAPABILITIES, VIEW_HOST_BOOTSTRAP_GLOBAL_KEY, VIEW_HOST_BOOTSTRAP_PROTOCOL_VERSION, VIEW_HOST_BOOTSTRAP_READY_EVENT_NAME, VIEW_HOST_BOOTSTRAP_REQUIRED_FRAGMENT, } from "@getuserfeedback/protocol/internal/view-host-bootstrap";
 import { parseWebViewConnectionBridgeMessage, } from "./webview-connection-bridge-message.js";
 import { buildWebViewConnectionBridgeScript, } from "./webview-connection-bridge-script.js";
 import { buildWebViewConnectionHostMessageScript, serializeForJavaScript, } from "./webview-connection-host-message-script.js";
@@ -21,6 +21,9 @@ const buildViewHostBootstrapScript = () => {
     const bridgeGlobalKey = serializeForJavaScript(VIEW_WEBVIEW_BRIDGE_GLOBAL_KEY);
     const bootstrapGlobalKey = serializeForJavaScript(VIEW_HOST_BOOTSTRAP_GLOBAL_KEY);
     const bootstrapProtocolVersion = serializeForJavaScript(VIEW_HOST_BOOTSTRAP_PROTOCOL_VERSION);
+    const bootstrapCapabilities = serializeForJavaScript([
+        VIEW_HOST_BOOTSTRAP_CAPABILITIES.RESOLVED_FRAME_BORDER,
+    ]);
     const bootstrapReadyEventName = serializeForJavaScript(VIEW_HOST_BOOTSTRAP_READY_EVENT_NAME);
     const inactiveConnectionMessage = serializeForJavaScript(VIEW_WEBVIEW_BRIDGE_CONFIG.inactiveConnectionMessage);
     return `
@@ -28,6 +31,7 @@ const buildViewHostBootstrapScript = () => {
   var bridge = window[${bridgeGlobalKey}];
   window[${bootstrapGlobalKey}] = {
     protocolVersion: ${bootstrapProtocolVersion},
+    capabilities: ${bootstrapCapabilities},
     createViewHostConnection: function (options) {
       var config = options.config;
       var transport = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "3.0.47",
+  "version": "3.0.49",
   "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.13.0",
+    "@getuserfeedback/sdk": "^0.10.14",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {