@getuserfeedback/react-native 3.0.32 → 3.0.33

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

package/dist/view-webview-bridge-adapter.d.ts

@@ -0,0 +1,25 @@
+import { type WebViewConnectionBridgeMessage } from "./webview-connection-bridge-message.js";
+export type ViewWebViewBridgeMessage = WebViewConnectionBridgeMessage;
+export declare const parseViewWebViewBridgeMessage: (value: unknown) => ViewWebViewBridgeMessage;
+export declare const buildViewWebViewBridgeScript: (input: {
+    bridgeId: string;
+    phase: "documentStart";
+} | {
+    bridgeId: string;
+    epoch: number;
+    phase: "afterLoad";
+}) => string;
+export declare const toExternalViewSource: (input: {
+    bridgeId: string;
+    srcdoc: string;
+}) => {
+    html: string;
+    baseUrl: string;
+};
+export declare const buildViewWebViewHostMessageScript: (input: {
+    bridgeId: string;
+    connectionId: string;
+    epoch: number;
+    generation: number;
+    message: unknown;
+}) => string;

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

@@ -0,0 +1,124 @@
+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 { 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";
+const VIEW_WEBVIEW_BRIDGE_GLOBAL_KEY = "__getuserfeedback_view_webview_bridge";
+const VIEW_WEBVIEW_BRIDGE_PROTOCOL_VERSION = "v1";
+const VIEW_WEBVIEW_BRIDGE_CONFIG = {
+    bridgeGlobalKey: VIEW_WEBVIEW_BRIDGE_GLOBAL_KEY,
+    bridgeProtocolVersion: VIEW_WEBVIEW_BRIDGE_PROTOCOL_VERSION,
+    connectTimeoutMessage: "Timed out connecting view to the native host",
+    connectTimeoutMs: 30000,
+    inactiveConnectionMessage: "View WebView bridge connection is not active",
+};
+export const parseViewWebViewBridgeMessage = (value) => parseWebViewConnectionBridgeMessage(value, {
+    invalidIdentity: "Invalid view WebView bridge message identity",
+    invalidKind: "Invalid view WebView bridge message kind",
+    invalidMessage: "Invalid view WebView bridge message",
+    missingPayload: "View WebView bridge payload is missing",
+});
+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 bootstrapReadyEventName = serializeForJavaScript(VIEW_HOST_BOOTSTRAP_READY_EVENT_NAME);
+    const inactiveConnectionMessage = serializeForJavaScript(VIEW_WEBVIEW_BRIDGE_CONFIG.inactiveConnectionMessage);
+    return `
+(function () {
+  var bridge = window[${bridgeGlobalKey}];
+  window[${bootstrapGlobalKey}] = {
+    protocolVersion: ${bootstrapProtocolVersion},
+    createViewHostConnection: function (options) {
+      var config = options.config;
+      var transport = null;
+      var connection = bridge.createConnection({
+        connectionIdentity: { viewId: config.viewId },
+        generation: config.generation,
+        onActivated: function (activeTransport) {
+          transport = activeTransport;
+          if (typeof options.onMessage === "function") {
+            activeTransport.subscribe(options.onMessage);
+          }
+          activeTransport.postMessage({
+            t: "getuserfeedback:action:viewConnect",
+            gen: config.generation,
+            viewId: config.viewId
+          });
+        },
+        onError: options.onError
+      });
+
+      function post(message) {
+        return connection.connect().then(function () {
+          if (!transport) {
+            throw new Error(${inactiveConnectionMessage});
+          }
+          transport.postMessage(message);
+        });
+      }
+
+      return {
+        connect: connection.connect,
+        disconnect: connection.disconnect,
+        requestClose: function () {
+          return post({
+            t: "getuserfeedback:action:requestCloseView",
+            gen: config.generation,
+            viewId: config.viewId
+          });
+        },
+        postViewSize: function (measurement) {
+          return post({
+            t: "getuserfeedback:event:viewSize",
+            gen: config.generation,
+            viewId: config.viewId,
+            width: measurement.width,
+            height: measurement.height,
+            intrinsicWidth: measurement.intrinsicWidth,
+            frameAppearance: measurement.frameAppearance,
+            placement: measurement.placement,
+            transitionPolicy: measurement.transitionPolicy,
+            layoutTransactionId: measurement.layoutTransactionId
+          });
+        },
+        post: post
+      };
+    }
+  };
+  window.dispatchEvent(new Event(${bootstrapReadyEventName}));
+})();
+true;`;
+};
+export const buildViewWebViewBridgeScript = (input) => `${buildWebViewConnectionBridgeScript(Object.assign(Object.assign({}, input), { config: VIEW_WEBVIEW_BRIDGE_CONFIG }))}\n${buildViewHostBootstrapScript()}`;
+const escapeInlineScript = (value) => value.replace(/<\/script/gi, "<\\/script");
+export const toExternalViewSource = (input) => {
+    const headStart = input.srcdoc.match(/<head(?:\s[^>]*)?>/i);
+    if (!headStart || headStart.index === undefined) {
+        throw new Error("View srcdoc must include a head element");
+    }
+    const insertionIndex = headStart.index + headStart[0].length;
+    const bridgeScript = buildViewWebViewBridgeScript({
+        bridgeId: input.bridgeId,
+        phase: "documentStart",
+    });
+    const requiredFragment = serializeForJavaScript(VIEW_HOST_BOOTSTRAP_REQUIRED_FRAGMENT);
+    const selectExternalHost = `
+(function () {
+  var fragment = ${requiredFragment};
+  try {
+    history.replaceState(null, "", "#" + fragment);
+  } catch {
+    location.hash = fragment;
+  }
+})();
+true;`;
+    // The inline bootstrap guarantees it precedes the bundled view runtime.
+    // WebViewDocumentHost also installs the same idempotent script through the
+    // native document-start hook because that hook's timing varies by platform.
+    const bootstrap = `<script>${escapeInlineScript(`${selectExternalHost}\n${bridgeScript}`)}</script>`;
+    return {
+        html: `${input.srcdoc.slice(0, insertionIndex)}${bootstrap}${input.srcdoc.slice(insertionIndex)}`,
+        baseUrl: `https://view.getuserfeedback.invalid/#${VIEW_HOST_BOOTSTRAP_REQUIRED_FRAGMENT}`,
+    };
+};
+export const buildViewWebViewHostMessageScript = (input) => buildWebViewConnectionHostMessageScript(Object.assign(Object.assign({}, input), { bridgeGlobalKey: VIEW_WEBVIEW_BRIDGE_GLOBAL_KEY }));

package/dist/view-webview-host-controller.d.ts

@@ -0,0 +1,19 @@
+import { type ViewWebViewBridgeMessage } from "./view-webview-bridge-adapter.js";
+import { type WebViewHostController } from "./webview-host-controller.js";
+export type ViewWebViewHostConnection = {
+    generation: number;
+    transport: {
+        postMessage: (message: unknown) => void;
+        subscribe: (listener: (message: unknown) => void) => () => void;
+    };
+};
+export type ViewWebViewHostController = WebViewHostController<ViewWebViewBridgeMessage>;
+export declare const createViewWebViewHostController: (input: {
+    bridgeId: string;
+    viewId: string;
+    generation: number;
+    onConnected: (connection: ViewWebViewHostConnection) => void;
+    onDisconnected?: () => void;
+    activationRetryIntervalMs?: number;
+    activationRetryTimeoutMs?: number;
+}) => ViewWebViewHostController;

package/dist/view-webview-host-controller.js

@@ -0,0 +1,33 @@
+import { buildViewWebViewBridgeScript, buildViewWebViewHostMessageScript, } from "./view-webview-bridge-adapter.js";
+import { createWebViewHostController, } from "./webview-host-controller.js";
+const hasViewIdentity = (value, viewId) => typeof value === "object" &&
+    value !== null &&
+    "viewId" in value &&
+    value.viewId === viewId;
+export const createViewWebViewHostController = (input) => {
+    const controller = createWebViewHostController({
+        bridgeId: input.bridgeId,
+        connectionLabel: "View WebView host",
+        buildActivationScript: buildViewWebViewBridgeScript,
+        buildHostMessageScript: buildViewWebViewHostMessageScript,
+        onConnected: (connection) => {
+            input.onConnected({
+                generation: connection.generation,
+                transport: {
+                    postMessage: connection.postMessage,
+                    subscribe: (listener) => connection.subscribe((message) => {
+                        if (message.kind === "message") {
+                            listener(message.message);
+                        }
+                    }),
+                },
+            });
+        },
+        onDisconnected: input.onDisconnected,
+        activationRetryIntervalMs: input.activationRetryIntervalMs,
+        activationRetryTimeoutMs: input.activationRetryTimeoutMs,
+    });
+    return Object.assign(Object.assign({}, controller), { handleMessage: (message) => message.generation === input.generation &&
+            hasViewIdentity(message.connectionIdentity, input.viewId) &&
+            controller.handleMessage(message) });
+};

package/dist/view-webview-host.d.ts

@@ -0,0 +1,13 @@
+import { type ComponentType, type ReactElement } from "react";
+import { type ViewWebViewHostConnection } from "./view-webview-host-controller.js";
+export type ViewWebViewHostProps = {
+    viewId: string;
+    generation: number;
+    srcdoc: string;
+    onConnected: (connection: ViewWebViewHostConnection) => void;
+    onDisconnected?: () => void;
+    onInvalidMessage?: (error: Error, value: unknown) => void;
+    webViewComponent?: ComponentType<Record<string, unknown>>;
+    webViewProps?: Record<string, unknown>;
+};
+export declare function ViewWebViewHost(props: ViewWebViewHostProps): ReactElement;

package/dist/view-webview-host.js

@@ -0,0 +1,54 @@
+import { createElement, useMemo, useRef, } from "react";
+import { buildViewWebViewBridgeScript, parseViewWebViewBridgeMessage, toExternalViewSource, } from "./view-webview-bridge-adapter.js";
+import { createViewWebViewHostController, } from "./view-webview-host-controller.js";
+import { WebViewDocumentHost } from "./webview-document-host.js";
+let nextBridgeId = 0;
+function ViewWebViewHostDocument({ generation, onConnected, onDisconnected, onInvalidMessage, srcdoc, viewId, webViewComponent, webViewProps, }) {
+    const bridgeIdRef = useRef(null);
+    if (bridgeIdRef.current === null) {
+        nextBridgeId += 1;
+        bridgeIdRef.current = `view-webview-${nextBridgeId}`;
+    }
+    const bridgeId = bridgeIdRef.current;
+    const onConnectedRef = useRef(onConnected);
+    const onDisconnectedRef = useRef(onDisconnected);
+    onConnectedRef.current = onConnected;
+    onDisconnectedRef.current = onDisconnected;
+    const controllerRef = useRef(null);
+    if (controllerRef.current === null) {
+        controllerRef.current = createViewWebViewHostController({
+            bridgeId,
+            generation,
+            viewId,
+            onConnected: (connection) => {
+                onConnectedRef.current(connection);
+            },
+            onDisconnected: () => {
+                var _a;
+                (_a = onDisconnectedRef.current) === null || _a === void 0 ? void 0 : _a.call(onDisconnectedRef);
+            },
+        });
+    }
+    const controller = controllerRef.current;
+    const buildDocumentStartScript = useMemo(() => () => buildViewWebViewBridgeScript({ bridgeId, phase: "documentStart" }), [bridgeId]);
+    const source = useMemo(() => toExternalViewSource({ bridgeId, srcdoc }), [bridgeId, srcdoc]);
+    const resolvedWebViewProps = useMemo(() => {
+        var _a;
+        return (Object.assign(Object.assign({}, webViewProps), { originWhitelist: (_a = webViewProps === null || webViewProps === void 0 ? void 0 : webViewProps.originWhitelist) !== null && _a !== void 0 ? _a : ["*"] }));
+    }, [webViewProps]);
+    return createElement((WebViewDocumentHost), {
+        bridgeId,
+        buildDocumentStartScript,
+        controller,
+        parseMessage: parseViewWebViewBridgeMessage,
+        source,
+        webViewComponent,
+        webViewProps: resolvedWebViewProps,
+        onInvalidMessage,
+    });
+}
+export function ViewWebViewHost(props) {
+    return createElement(ViewWebViewHostDocument, Object.assign(Object.assign({}, props), { key: JSON.stringify([props.viewId, props.generation, props.srcdoc]) }));
+}
+// TODO(migration): Wire core-native view allocation and message routing through the preparation registry into this private per-view host. Keep the provider runtime active while proving one native-owned view end to end.
+// [from=private-native-per-view-webview-adapter] [to=private-native-view-allocation-routing] [scope=slice] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=20]

package/dist/webview-connection-bridge-message.d.ts

@@ -3,6 +3,7 @@ type WebViewConnectionBridgeMessageIdentity = {
     connectionId: string;
     epoch: number;
     generation: number;
+    connectionIdentity?: unknown;
 };
 export type WebViewConnectionBridgeMessage = (WebViewConnectionBridgeMessageIdentity & {
     kind: "connected";

package/dist/webview-connection-bridge-script.js

@@ -38,6 +38,7 @@ export const buildWebViewConnectionBridgeScript = (input) => {
       ? crypto.randomUUID()
       : String(Date.now()) + ":" + String(Math.random());
   var activeConnection = null;
+  var isClosed = false;
   var isNativeActivated = ${String(activateNative)};
   var nativeEpoch = ${String(activationEpoch)};
 
@@ -58,6 +59,9 @@ export const buildWebViewConnectionBridgeScript = (input) => {
       generation: connection.generation,
       kind: kind
     };
+    if (connection.connectionIdentity !== undefined) {
+      envelope.connectionIdentity = connection.connectionIdentity;
+    }
     if (kind === "message") {
       envelope.message = message;
     }
@@ -79,8 +83,11 @@ export const buildWebViewConnectionBridgeScript = (input) => {
       connectionId:
         bridgeId + ":" + documentId + ":" + String(++connectionSequence),
       generation: options.generation,
+      connectionIdentity: options.connectionIdentity,
       listener: null,
       isConnected: false,
+      isDisconnected: false,
+      connectPromise: null,
       connectTimeout: null,
       onActivated: options.onActivated,
       onError: options.onError,
@@ -91,6 +98,9 @@ export const buildWebViewConnectionBridgeScript = (input) => {
     var transport = {
       postMessage: function (message) {
         if (activeConnection !== connection) {
+          if (connection.isDisconnected) {
+            throw new Error(inactiveConnectionMessage);
+          }
           return;
         }
         postToNative(toConnectionMessage("message", connection, message));
@@ -111,8 +121,20 @@ export const buildWebViewConnectionBridgeScript = (input) => {
 
     return {
       connect: function () {
+        if (connection.isDisconnected || isClosed) {
+          return Promise.reject(new Error(inactiveConnectionMessage));
+        }
+        if (connection.connectPromise) {
+          return connection.connectPromise;
+        }
+        if (activeConnection && activeConnection !== connection) {
+          connection.isDisconnected = true;
+          var error = new Error(inactiveConnectionMessage);
+          reportConnectionError(connection, error);
+          return Promise.reject(error);
+        }
         activeConnection = connection;
-        return new Promise(function (resolve, reject) {
+        var connectPromise = new Promise(function (resolve, reject) {
           connection.rejectConnect = reject;
           connection.resolveConnect = resolve;
           connection.connectTimeout = setTimeout(function () {
@@ -120,18 +142,25 @@ export const buildWebViewConnectionBridgeScript = (input) => {
               return;
             }
             activeConnection = null;
+            connection.isDisconnected = true;
+            isClosed = true;
             var error = new Error(connectTimeoutMessage);
             reportConnectionError(connection, error);
             connection.rejectConnect(error);
             connection.rejectConnect = null;
             connection.resolveConnect = null;
+            connection.connectPromise = null;
             connection.connectTimeout = null;
           }, ${connectTimeoutMs});
-          bridge.activateConnection();
         });
+        connection.connectPromise = connectPromise;
+        bridge.activateConnection();
+        return connectPromise;
       },
       disconnect: function () {
+        connection.isDisconnected = true;
         if (activeConnection === connection) {
+          isClosed = true;
           activeConnection = null;
           connection.listener = null;
           if (connection.connectTimeout) {
@@ -151,6 +180,7 @@ export const buildWebViewConnectionBridgeScript = (input) => {
             connection.resolveConnect = null;
           }
         }
+        connection.connectPromise = null;
         return Promise.resolve();
       }
     };
@@ -182,6 +212,9 @@ export const buildWebViewConnectionBridgeScript = (input) => {
         connection.onActivated(connection.transport);
       } catch (error) {
         connection.isConnected = false;
+        connection.isDisconnected = true;
+        isClosed = true;
+        activeConnection = null;
         try {
           postToNative(toConnectionMessage("disconnected", connection));
         } catch {
@@ -197,6 +230,7 @@ export const buildWebViewConnectionBridgeScript = (input) => {
           clearTimeout(connection.connectTimeout);
           connection.connectTimeout = null;
         }
+        connection.connectPromise = null;
         return false;
       }
       if (connection.resolveConnect) {

package/package.json

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