@getuserfeedback/react-native 3.0.7 → 3.0.23

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

@@ -0,0 +1,19 @@
+import { type WebViewConnectionBridgeMessage } from "./webview-connection-bridge-message.js";
+export type CoreWebViewBridgeMessage = WebViewConnectionBridgeMessage;
+export declare const parseCoreWebViewBridgeMessage: (value: unknown) => CoreWebViewBridgeMessage;
+export declare const toExternalCoreUrl: (coreUrl: string) => string;
+export declare const buildCoreWebViewBridgeScript: (input: {
+    bridgeId: string;
+    phase: "documentStart";
+} | {
+    bridgeId: string;
+    epoch: number;
+    phase: "afterLoad";
+}) => string;
+export declare const buildCoreWebViewHostMessageScript: (input: {
+    bridgeId: string;
+    connectionId: string;
+    epoch: number;
+    generation: number;
+    message: unknown;
+}) => string;

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

@@ -0,0 +1,48 @@
+import { CORE_HOST_BOOTSTRAP_GLOBAL_KEY, CORE_HOST_BOOTSTRAP_PROTOCOL_VERSION, CORE_HOST_BOOTSTRAP_READY_EVENT_NAME, CORE_HOST_BOOTSTRAP_REQUIRED_FRAGMENT, } from "@getuserfeedback/protocol/internal/core-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 CORE_WEBVIEW_BRIDGE_GLOBAL_KEY = "__getuserfeedback_core_webview_bridge";
+const CORE_WEBVIEW_BRIDGE_PROTOCOL_VERSION = "v2";
+const CORE_WEBVIEW_BRIDGE_CONFIG = {
+    bridgeGlobalKey: CORE_WEBVIEW_BRIDGE_GLOBAL_KEY,
+    bridgeProtocolVersion: CORE_WEBVIEW_BRIDGE_PROTOCOL_VERSION,
+    connectTimeoutMessage: "Timed out connecting core to the native host",
+    connectTimeoutMs: 30000,
+    inactiveConnectionMessage: "Core WebView bridge connection is not active",
+};
+export const parseCoreWebViewBridgeMessage = (value) => parseWebViewConnectionBridgeMessage(value, {
+    invalidIdentity: "Invalid core WebView bridge message identity",
+    invalidKind: "Invalid core WebView bridge message kind",
+    invalidMessage: "Invalid core WebView bridge message",
+    missingPayload: "Core WebView bridge payload is missing",
+});
+export const toExternalCoreUrl = (coreUrl) => {
+    const url = new URL(coreUrl);
+    url.hash = CORE_HOST_BOOTSTRAP_REQUIRED_FRAGMENT;
+    return url.toString();
+};
+const buildCoreHostBootstrapScript = () => {
+    const bridgeGlobalKey = serializeForJavaScript(CORE_WEBVIEW_BRIDGE_GLOBAL_KEY);
+    const bootstrapGlobalKey = serializeForJavaScript(CORE_HOST_BOOTSTRAP_GLOBAL_KEY);
+    const bootstrapProtocolVersion = serializeForJavaScript(CORE_HOST_BOOTSTRAP_PROTOCOL_VERSION);
+    const bootstrapReadyEventName = serializeForJavaScript(CORE_HOST_BOOTSTRAP_READY_EVENT_NAME);
+    return `
+(function () {
+  var bridge = window[${bridgeGlobalKey}];
+  window[${bootstrapGlobalKey}] = {
+    protocolVersion: ${bootstrapProtocolVersion},
+    createCoreHostConnection: function (options) {
+      return bridge.createConnection({
+        generation: options.generation,
+        onActivated: options.onConnected,
+        onError: options.onError
+      });
+    }
+  };
+  window.dispatchEvent(new Event(${bootstrapReadyEventName}));
+})();
+true;`;
+};
+export const buildCoreWebViewBridgeScript = (input) => `${buildWebViewConnectionBridgeScript(Object.assign(Object.assign({}, input), { config: CORE_WEBVIEW_BRIDGE_CONFIG }))}\n${buildCoreHostBootstrapScript()}`;
+export const buildCoreWebViewHostMessageScript = (input) => buildWebViewConnectionHostMessageScript(Object.assign(Object.assign({}, input), { bridgeGlobalKey: CORE_WEBVIEW_BRIDGE_GLOBAL_KEY }));

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

@@ -0,0 +1,16 @@
+import type { CoreHostBootstrapTransport } from "@getuserfeedback/protocol/internal/core-host-bootstrap";
+import { type CoreWebViewBridgeMessage } from "./core-webview-bridge-adapter.js";
+import { type WebViewHandle, type WebViewHostController } from "./webview-host-controller.js";
+export type CoreWebViewHandle = WebViewHandle;
+export type CoreWebViewHostConnection = {
+    generation: number;
+    transport: CoreHostBootstrapTransport;
+};
+export type CoreWebViewHostController = WebViewHostController<CoreWebViewBridgeMessage>;
+export declare const createCoreWebViewHostController: (input: {
+    bridgeId: string;
+    onConnected: (connection: CoreWebViewHostConnection) => void;
+    onDisconnected?: () => void;
+    activationRetryIntervalMs?: number;
+    activationRetryTimeoutMs?: number;
+}) => CoreWebViewHostController;

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

@@ -0,0 +1,15 @@
+import { buildCoreWebViewBridgeScript, buildCoreWebViewHostMessageScript, } from "./core-webview-bridge-adapter.js";
+import { createWebViewHostController, } from "./webview-host-controller.js";
+export const createCoreWebViewHostController = (input) => createWebViewHostController(Object.assign(Object.assign({}, input), { connectionLabel: "Core WebView host", buildActivationScript: buildCoreWebViewBridgeScript, buildHostMessageScript: buildCoreWebViewHostMessageScript, onConnected: (connection) => {
+        input.onConnected({
+            generation: connection.generation,
+            transport: {
+                postMessage: connection.postMessage,
+                subscribe: (listener) => connection.subscribe((message) => {
+                    if (message.kind === "message") {
+                        listener(message.message);
+                    }
+                }),
+            },
+        });
+    } }));

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

@@ -0,0 +1,14 @@
+import type { CoreHostBootstrapTransport } from "@getuserfeedback/protocol/internal/core-host-bootstrap";
+import { type ComponentType, type ReactElement } from "react";
+export type CoreWebViewHostProps = {
+    coreUrl: string;
+    onConnected: (connection: {
+        generation: number;
+        transport: CoreHostBootstrapTransport;
+    }) => void;
+    onDisconnected?: () => void;
+    onInvalidMessage?: (error: Error, value: unknown) => void;
+    webViewComponent?: ComponentType<Record<string, unknown>>;
+    webViewProps?: Record<string, unknown>;
+};
+export declare function CoreWebViewHost({ coreUrl, ...props }: CoreWebViewHostProps): ReactElement;

package/dist/core-webview-host.js

@@ -0,0 +1,124 @@
+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 { createElement, useCallback, useEffect, useMemo, useRef, } from "react";
+import { buildCoreWebViewBridgeScript, parseCoreWebViewBridgeMessage, toExternalCoreUrl, } from "./core-webview-bridge-adapter.js";
+import { createCoreWebViewHostController, } from "./core-webview-host-controller.js";
+let nextBridgeId = 0;
+const resolveWebViewComponent = () => {
+    var _a;
+    const webViewModule = require("react-native-webview");
+    const WebView = (_a = webViewModule.WebView) !== null && _a !== void 0 ? _a : webViewModule.default;
+    if (!WebView) {
+        throw new Error("react-native-webview must export WebView to render the core host");
+    }
+    return WebView;
+};
+const toMessageData = (value) => {
+    if (typeof value !== "string") {
+        return value;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch (_a) {
+        return value;
+    }
+};
+const toEventHandler = (value) => typeof value === "function" ? value : undefined;
+const toInjectionScript = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+const toTruthyInjectionScript = (value) => {
+    const script = toInjectionScript(value);
+    return script ? `${script}\ntrue;` : undefined;
+};
+const isBridgeMessageCandidate = (value, bridgeId) => typeof value === "object" &&
+    value !== null &&
+    "bridgeId" in value &&
+    value.bridgeId === bridgeId;
+const composeInjectionScripts = (bridgeScript, callerScript) => {
+    const script = toInjectionScript(callerScript);
+    return script ? `${bridgeScript}\n${script}\ntrue;` : bridgeScript;
+};
+function CoreWebViewHostDocument({ externalCoreUrl, onConnected, onDisconnected, onInvalidMessage, webViewComponent, webViewProps, }) {
+    const WebView = webViewComponent !== null && webViewComponent !== void 0 ? webViewComponent : resolveWebViewComponent();
+    const bridgeIdRef = useRef(null);
+    if (bridgeIdRef.current === null) {
+        nextBridgeId += 1;
+        bridgeIdRef.current = `core-webview-${nextBridgeId}`;
+    }
+    const bridgeId = bridgeIdRef.current;
+    const onConnectedRef = useRef(onConnected);
+    const onDisconnectedRef = useRef(onDisconnected);
+    const onInvalidMessageRef = useRef(onInvalidMessage);
+    onConnectedRef.current = onConnected;
+    onDisconnectedRef.current = onDisconnected;
+    onInvalidMessageRef.current = onInvalidMessage;
+    const controllerRef = useRef(null);
+    if (controllerRef.current === null) {
+        controllerRef.current = createCoreWebViewHostController({
+            bridgeId,
+            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 documentStartBridgeScript = useMemo(() => buildCoreWebViewBridgeScript({ bridgeId, phase: "documentStart" }), [bridgeId]);
+    const source = useMemo(() => ({ uri: externalCoreUrl }), [externalCoreUrl]);
+    const callerOnLoadStart = toEventHandler(webViewProps === null || webViewProps === void 0 ? void 0 : webViewProps.onLoadStart);
+    const callerOnLoad = toEventHandler(webViewProps === null || webViewProps === void 0 ? void 0 : webViewProps.onLoad);
+    const callerOnMessage = toEventHandler(webViewProps === null || webViewProps === void 0 ? void 0 : webViewProps.onMessage);
+    useEffect(() => () => {
+        controller.detach();
+    }, [controller]);
+    const setWebViewRef = useCallback((handle) => {
+        if (!handle || typeof handle.injectJavaScript !== "function") {
+            controller.detach();
+            return;
+        }
+        controller.attach(handle);
+    }, [controller]);
+    const handleLoadStart = useCallback((event) => {
+        controller.beginLoad();
+        callerOnLoadStart === null || callerOnLoadStart === void 0 ? void 0 : callerOnLoadStart(event);
+    }, [callerOnLoadStart, controller]);
+    const handleLoad = useCallback((event) => {
+        controller.completeLoad();
+        callerOnLoad === null || callerOnLoad === void 0 ? void 0 : callerOnLoad(event);
+    }, [callerOnLoad, controller]);
+    const handleMessage = useCallback((event) => {
+        var _a, _b;
+        const value = toMessageData((_a = event.nativeEvent) === null || _a === void 0 ? void 0 : _a.data);
+        let message;
+        try {
+            message = parseCoreWebViewBridgeMessage(value);
+        }
+        catch (error) {
+            if (!callerOnMessage || isBridgeMessageCandidate(value, bridgeId)) {
+                (_b = onInvalidMessageRef.current) === null || _b === void 0 ? void 0 : _b.call(onInvalidMessageRef, error instanceof Error ? error : new Error(String(error)), value);
+            }
+            callerOnMessage === null || callerOnMessage === void 0 ? void 0 : callerOnMessage(event);
+            return;
+        }
+        controller.handleMessage(message);
+        callerOnMessage === null || callerOnMessage === void 0 ? void 0 : callerOnMessage(event);
+    }, [bridgeId, callerOnMessage, controller]);
+    return createElement(WebView, Object.assign(Object.assign({}, webViewProps), { injectedJavaScript: toTruthyInjectionScript(webViewProps === null || webViewProps === void 0 ? void 0 : webViewProps.injectedJavaScript), injectedJavaScriptBeforeContentLoaded: composeInjectionScripts(documentStartBridgeScript, webViewProps === null || webViewProps === void 0 ? void 0 : webViewProps.injectedJavaScriptBeforeContentLoaded), onLoad: handleLoad, onLoadStart: handleLoadStart, onMessage: handleMessage, ref: setWebViewRef, source }));
+}
+export function CoreWebViewHost(_a) {
+    var { coreUrl } = _a, props = __rest(_a, ["coreUrl"]);
+    const externalCoreUrl = toExternalCoreUrl(coreUrl);
+    return createElement(CoreWebViewHostDocument, Object.assign(Object.assign({}, props), { externalCoreUrl, key: externalCoreUrl }));
+}

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

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

@@ -0,0 +1,22 @@
+type WebViewConnectionBridgeMessageIdentity = {
+    bridgeId: string;
+    connectionId: string;
+    epoch: number;
+    generation: number;
+};
+export type WebViewConnectionBridgeMessage = (WebViewConnectionBridgeMessageIdentity & {
+    kind: "connected";
+}) | (WebViewConnectionBridgeMessageIdentity & {
+    kind: "disconnected";
+}) | (WebViewConnectionBridgeMessageIdentity & {
+    kind: "message";
+    message: unknown;
+});
+export type WebViewConnectionBridgeMessageParseErrors = {
+    invalidIdentity: string;
+    invalidKind: string;
+    invalidMessage: string;
+    missingPayload: string;
+};
+export declare const parseWebViewConnectionBridgeMessage: (value: unknown, errors: WebViewConnectionBridgeMessageParseErrors) => WebViewConnectionBridgeMessage;
+export {};

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

@@ -0,0 +1,24 @@
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isGeneration = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+export const parseWebViewConnectionBridgeMessage = (value, errors) => {
+    if (!isRecord(value)) {
+        throw new Error(errors.invalidMessage);
+    }
+    if (typeof value.bridgeId !== "string" ||
+        value.bridgeId.length === 0 ||
+        typeof value.connectionId !== "string" ||
+        value.connectionId.length === 0 ||
+        !isGeneration(value.epoch) ||
+        !isGeneration(value.generation)) {
+        throw new Error(errors.invalidIdentity);
+    }
+    if (value.kind !== "connected" &&
+        value.kind !== "disconnected" &&
+        value.kind !== "message") {
+        throw new Error(errors.invalidKind);
+    }
+    if (value.kind === "message" && !("message" in value)) {
+        throw new Error(errors.missingPayload);
+    }
+    return value;
+};

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

@@ -0,0 +1,16 @@
+export type WebViewConnectionBridgeScriptConfig = {
+    bridgeGlobalKey: string;
+    bridgeProtocolVersion: string;
+    connectTimeoutMessage: string;
+    connectTimeoutMs: number;
+    inactiveConnectionMessage: string;
+};
+export declare const buildWebViewConnectionBridgeScript: (input: ({
+    phase: "documentStart";
+} | {
+    epoch: number;
+    phase: "afterLoad";
+}) & {
+    bridgeId: string;
+    config: WebViewConnectionBridgeScriptConfig;
+}) => string;

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

@@ -0,0 +1,255 @@
+import { serializeForJavaScript } from "./webview-connection-host-message-script.js";
+export const buildWebViewConnectionBridgeScript = (input) => {
+    const bridgeId = serializeForJavaScript(input.bridgeId);
+    const activateNative = input.phase === "afterLoad";
+    const activationEpoch = activateNative ? input.epoch : null;
+    const connectTimeoutMs = String(input.config.connectTimeoutMs);
+    const bridgeGlobalKey = serializeForJavaScript(input.config.bridgeGlobalKey);
+    const bridgeProtocolVersion = serializeForJavaScript(input.config.bridgeProtocolVersion);
+    const connectTimeoutMessage = serializeForJavaScript(input.config.connectTimeoutMessage);
+    const inactiveConnectionMessage = serializeForJavaScript(input.config.inactiveConnectionMessage);
+    return `
+(function () {
+  var bridgeId = ${bridgeId};
+  var bridgeGlobalKey = ${bridgeGlobalKey};
+  var bridgeProtocolVersion = ${bridgeProtocolVersion};
+  var connectTimeoutMessage = ${connectTimeoutMessage};
+  var inactiveConnectionMessage = ${inactiveConnectionMessage};
+  var existingBridge = window[bridgeGlobalKey];
+
+  if (
+    existingBridge &&
+    existingBridge.protocolVersion === bridgeProtocolVersion &&
+    existingBridge.bridgeId === bridgeId
+  ) {
+    var didConnect = false;
+    if (${String(activateNative)}) {
+      didConnect = existingBridge.activateNative(${String(activationEpoch)});
+    }
+    if (!didConnect) {
+      existingBridge.notifyConnected();
+    }
+    return;
+  }
+
+  var connectionSequence = 0;
+  var documentId =
+    typeof crypto === "object" && typeof crypto.randomUUID === "function"
+      ? crypto.randomUUID()
+      : String(Date.now()) + ":" + String(Math.random());
+  var activeConnection = null;
+  var isNativeActivated = ${String(activateNative)};
+  var nativeEpoch = ${String(activationEpoch)};
+
+  function postToNative(message) {
+    var nativeBridge = window.ReactNativeWebView;
+    if (!nativeBridge || typeof nativeBridge.postMessage !== "function") {
+      return false;
+    }
+    nativeBridge.postMessage(JSON.stringify(message));
+    return true;
+  }
+
+  function toConnectionMessage(kind, connection, message) {
+    var envelope = {
+      bridgeId: bridgeId,
+      connectionId: connection.connectionId,
+      epoch: nativeEpoch,
+      generation: connection.generation,
+      kind: kind
+    };
+    if (kind === "message") {
+      envelope.message = message;
+    }
+    return envelope;
+  }
+
+  function reportConnectionError(connection, error) {
+    try {
+      if (typeof connection.onError === "function") {
+        connection.onError(error);
+      }
+    } catch {
+      // Error observers cannot change connection settlement.
+    }
+  }
+
+  function createConnection(options) {
+    var connection = {
+      connectionId:
+        bridgeId + ":" + documentId + ":" + String(++connectionSequence),
+      generation: options.generation,
+      listener: null,
+      isConnected: false,
+      connectTimeout: null,
+      onActivated: options.onActivated,
+      onError: options.onError,
+      rejectConnect: null,
+      resolveConnect: null,
+      transport: null
+    };
+    var transport = {
+      postMessage: function (message) {
+        if (activeConnection !== connection) {
+          return;
+        }
+        postToNative(toConnectionMessage("message", connection, message));
+      },
+      subscribe: function (listener) {
+        if (activeConnection !== connection) {
+          throw new Error(inactiveConnectionMessage);
+        }
+        connection.listener = listener;
+        return function () {
+          if (connection.listener === listener) {
+            connection.listener = null;
+          }
+        };
+      }
+    };
+    connection.transport = transport;
+
+    return {
+      connect: function () {
+        activeConnection = connection;
+        return new Promise(function (resolve, reject) {
+          connection.rejectConnect = reject;
+          connection.resolveConnect = resolve;
+          connection.connectTimeout = setTimeout(function () {
+            if (activeConnection !== connection || connection.isConnected) {
+              return;
+            }
+            activeConnection = null;
+            var error = new Error(connectTimeoutMessage);
+            reportConnectionError(connection, error);
+            connection.rejectConnect(error);
+            connection.rejectConnect = null;
+            connection.resolveConnect = null;
+            connection.connectTimeout = null;
+          }, ${connectTimeoutMs});
+          bridge.activateConnection();
+        });
+      },
+      disconnect: function () {
+        if (activeConnection === connection) {
+          activeConnection = null;
+          connection.listener = null;
+          if (connection.connectTimeout) {
+            clearTimeout(connection.connectTimeout);
+            connection.connectTimeout = null;
+          }
+          if (connection.isConnected) {
+            try {
+              postToNative(toConnectionMessage("disconnected", connection));
+            } catch {
+              // Native navigation/ref lifecycle is authoritative for local teardown.
+            }
+          }
+          if (connection.resolveConnect) {
+            connection.resolveConnect();
+            connection.rejectConnect = null;
+            connection.resolveConnect = null;
+          }
+        }
+        return Promise.resolve();
+      }
+    };
+  }
+
+  var bridge = {
+    bridgeId: bridgeId,
+    protocolVersion: bridgeProtocolVersion,
+    createConnection: createConnection,
+    activateConnection: function () {
+      var connection = activeConnection;
+      if (
+        !isNativeActivated ||
+        !connection ||
+        connection.isConnected
+      ) {
+        return false;
+      }
+      try {
+        if (!postToNative(toConnectionMessage("connected", connection))) {
+          return false;
+        }
+      } catch (error) {
+        reportConnectionError(connection, error);
+        return false;
+      }
+      connection.isConnected = true;
+      try {
+        connection.onActivated(connection.transport);
+      } catch (error) {
+        connection.isConnected = false;
+        try {
+          postToNative(toConnectionMessage("disconnected", connection));
+        } catch {
+          // Preserve the original connection error.
+        }
+        reportConnectionError(connection, error);
+        if (connection.rejectConnect) {
+          connection.rejectConnect(error);
+        }
+        connection.rejectConnect = null;
+        connection.resolveConnect = null;
+        if (connection.connectTimeout) {
+          clearTimeout(connection.connectTimeout);
+          connection.connectTimeout = null;
+        }
+        return false;
+      }
+      if (connection.resolveConnect) {
+        if (connection.connectTimeout) {
+          clearTimeout(connection.connectTimeout);
+          connection.connectTimeout = null;
+        }
+        connection.resolveConnect();
+        connection.rejectConnect = null;
+        connection.resolveConnect = null;
+      }
+      return true;
+    },
+    activateNative: function (epoch) {
+      if (typeof epoch !== "number" || !Number.isSafeInteger(epoch) || epoch < 0) {
+        return false;
+      }
+      if (nativeEpoch !== null && epoch < nativeEpoch) {
+        return false;
+      }
+      isNativeActivated = true;
+      nativeEpoch = epoch;
+      return bridge.activateConnection();
+    },
+    notifyConnected: function () {
+      if (activeConnection && activeConnection.isConnected) {
+        try {
+          postToNative(toConnectionMessage("connected", activeConnection));
+        } catch {
+          return false;
+        }
+      }
+      return true;
+    },
+    receive: function (envelope) {
+      if (
+        !activeConnection ||
+        !envelope ||
+        envelope.bridgeId !== bridgeId ||
+        envelope.connectionId !== activeConnection.connectionId ||
+        envelope.epoch !== nativeEpoch ||
+        envelope.generation !== activeConnection.generation ||
+        envelope.kind !== "message" ||
+        typeof activeConnection.listener !== "function"
+      ) {
+        return false;
+      }
+      activeConnection.listener(envelope.message);
+      return true;
+    }
+  };
+
+  window[bridgeGlobalKey] = bridge;
+})();
+true;`;
+};

package/dist/webview-connection-host-message-script.d.ts

@@ -0,0 +1,9 @@
+export declare const serializeForJavaScript: (value: unknown) => string;
+export declare const buildWebViewConnectionHostMessageScript: (input: {
+    bridgeGlobalKey: string;
+    bridgeId: string;
+    connectionId: string;
+    epoch: number;
+    generation: number;
+    message: unknown;
+}) => string;

package/dist/webview-connection-host-message-script.js

@@ -0,0 +1,20 @@
+export const serializeForJavaScript = (value) => JSON.stringify(value).replace(/</g, "\\u003c");
+export const buildWebViewConnectionHostMessageScript = (input) => {
+    const envelope = serializeForJavaScript({
+        bridgeId: input.bridgeId,
+        connectionId: input.connectionId,
+        epoch: input.epoch,
+        generation: input.generation,
+        kind: "message",
+        message: input.message,
+    });
+    const bridgeGlobalKey = serializeForJavaScript(input.bridgeGlobalKey);
+    return `
+(function () {
+  var bridge = window[${bridgeGlobalKey}];
+  if (bridge && typeof bridge.receive === "function") {
+    bridge.receive(${envelope});
+  }
+})();
+true;`;
+};

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

@@ -0,0 +1,45 @@
+export type WebViewHandle = {
+    injectJavaScript: (script: string) => void;
+};
+export type WebViewBridgeMessageIdentity = {
+    bridgeId: string;
+    connectionId: string;
+    epoch: number;
+    generation: number;
+    kind: string;
+};
+export type WebViewHostConnection<TMessage extends WebViewBridgeMessageIdentity> = {
+    connectionId: string;
+    epoch: number;
+    generation: number;
+    postMessage: (message: unknown) => void;
+    subscribe: (listener: (message: TMessage) => void) => () => void;
+};
+export type WebViewHostController<TMessage extends WebViewBridgeMessageIdentity> = {
+    attach: (handle: WebViewHandle) => void;
+    beginLoad: () => void;
+    completeLoad: () => void;
+    detach: () => void;
+    disconnect: () => void;
+    handleMessage: (message: TMessage) => boolean;
+};
+export declare const createWebViewHostController: <TMessage extends WebViewBridgeMessageIdentity>(input: {
+    bridgeId: string;
+    connectionLabel: string;
+    buildActivationScript: (input: {
+        bridgeId: string;
+        epoch: number;
+        phase: "afterLoad";
+    }) => string;
+    buildHostMessageScript: (input: {
+        bridgeId: string;
+        connectionId: string;
+        epoch: number;
+        generation: number;
+        message: unknown;
+    }) => string;
+    onConnected: (connection: WebViewHostConnection<TMessage>) => void;
+    onDisconnected?: () => void;
+    activationRetryIntervalMs?: number;
+    activationRetryTimeoutMs?: number;
+}) => WebViewHostController<TMessage>;

package/dist/webview-host-controller.js

@@ -0,0 +1,198 @@
+import { createWebViewHostSessionController } from "./webview-host-session-machine.js";
+const DEFAULT_ACTIVATION_RETRY_INTERVAL_MS = 50;
+const DEFAULT_ACTIVATION_RETRY_TIMEOUT_MS = 30000;
+export const createWebViewHostController = (input) => {
+    var _a, _b;
+    let handle = null;
+    let activeConnection = null;
+    let isLoadComplete = false;
+    let activationRetryDeadline = null;
+    let activationRetryTimer = null;
+    const activationRetryIntervalMs = (_a = input.activationRetryIntervalMs) !== null && _a !== void 0 ? _a : DEFAULT_ACTIVATION_RETRY_INTERVAL_MS;
+    const activationRetryTimeoutMs = (_b = input.activationRetryTimeoutMs) !== null && _b !== void 0 ? _b : DEFAULT_ACTIVATION_RETRY_TIMEOUT_MS;
+    const session = createWebViewHostSessionController();
+    const clearActivationRetry = () => {
+        if (activationRetryTimer !== null) {
+            clearTimeout(activationRetryTimer);
+            activationRetryTimer = null;
+        }
+        activationRetryDeadline = null;
+    };
+    const injectActivation = () => {
+        const snapshot = session.getSnapshot();
+        if (!handle || !isLoadComplete || snapshot.state !== "awaitingConnection") {
+            return;
+        }
+        const script = input.buildActivationScript({
+            bridgeId: input.bridgeId,
+            epoch: snapshot.epoch,
+            phase: "afterLoad",
+        });
+        try {
+            handle.injectJavaScript(script);
+        }
+        catch (_a) {
+            // A newly attached WebView can reject injection transiently. The
+            // existing activation retry and page-side timeout own recovery.
+        }
+    };
+    const scheduleActivationRetry = () => {
+        if (activationRetryTimer !== null ||
+            activationRetryDeadline === null ||
+            Date.now() >= activationRetryDeadline ||
+            !handle ||
+            !isLoadComplete ||
+            session.getSnapshot().state !== "awaitingConnection") {
+            return;
+        }
+        activationRetryTimer = setTimeout(() => {
+            activationRetryTimer = null;
+            if (activationRetryDeadline === null ||
+                Date.now() >= activationRetryDeadline) {
+                clearActivationRetry();
+                return;
+            }
+            injectActivation();
+            scheduleActivationRetry();
+        }, activationRetryIntervalMs);
+    };
+    const activateUntilConnected = () => {
+        if (session.getSnapshot().state !== "awaitingConnection") {
+            return;
+        }
+        if (activationRetryDeadline === null) {
+            activationRetryDeadline = Date.now() + activationRetryTimeoutMs;
+        }
+        injectActivation();
+        scheduleActivationRetry();
+    };
+    const announceConnection = () => {
+        const connection = activeConnection;
+        if (!connection || connection.isAnnounced || !handle) {
+            return;
+        }
+        connection.isAnnounced = true;
+        try {
+            input.onConnected(connection);
+        }
+        finally {
+            const pendingMessages = connection.pendingMessages;
+            connection.pendingMessages = [];
+            for (const message of pendingMessages) {
+                for (const listener of connection.listeners) {
+                    listener(message);
+                }
+            }
+        }
+    };
+    const dropActiveConnection = () => {
+        var _a;
+        if (!activeConnection) {
+            return;
+        }
+        const shouldNotify = activeConnection.isAnnounced;
+        activeConnection.listeners.clear();
+        activeConnection.pendingMessages = [];
+        activeConnection = null;
+        if (shouldNotify) {
+            (_a = input.onDisconnected) === null || _a === void 0 ? void 0 : _a.call(input);
+        }
+    };
+    const disconnect = () => {
+        session.close();
+        dropActiveConnection();
+    };
+    return {
+        attach: (nextHandle) => {
+            handle = nextHandle;
+            if (isLoadComplete) {
+                activateUntilConnected();
+            }
+            announceConnection();
+        },
+        beginLoad: () => {
+            clearActivationRetry();
+            session.advanceEpoch();
+            isLoadComplete = false;
+            dropActiveConnection();
+        },
+        completeLoad: () => {
+            isLoadComplete = true;
+            activateUntilConnected();
+        },
+        detach: () => {
+            clearActivationRetry();
+            session.advanceEpoch();
+            handle = null;
+            dropActiveConnection();
+        },
+        disconnect,
+        handleMessage: (message) => {
+            if (message.bridgeId !== input.bridgeId) {
+                return false;
+            }
+            if (message.kind === "connected") {
+                const acceptance = session.acceptConnection(message);
+                if (acceptance === "duplicate") {
+                    return true;
+                }
+                if (acceptance === "rejected") {
+                    return false;
+                }
+                const listeners = new Set();
+                const connection = {
+                    connectionId: message.connectionId,
+                    epoch: message.epoch,
+                    generation: message.generation,
+                    isAnnounced: false,
+                    listeners,
+                    pendingMessages: [],
+                    postMessage: (hostMessage) => {
+                        if (activeConnection !== connection || !handle) {
+                            throw new Error(`${input.connectionLabel} is disconnected`);
+                        }
+                        handle.injectJavaScript(input.buildHostMessageScript({
+                            bridgeId: input.bridgeId,
+                            connectionId: connection.connectionId,
+                            epoch: connection.epoch,
+                            generation: connection.generation,
+                            message: hostMessage,
+                        }));
+                    },
+                    subscribe: (listener) => {
+                        if (activeConnection !== connection) {
+                            throw new Error(`${input.connectionLabel} is disconnected`);
+                        }
+                        listeners.add(listener);
+                        return () => {
+                            listeners.delete(listener);
+                        };
+                    },
+                };
+                activeConnection = connection;
+                if (session.confirmActivation(message) !== "accepted") {
+                    throw new Error(`${input.connectionLabel} activation was not confirmed`);
+                }
+                clearActivationRetry();
+                announceConnection();
+                return true;
+            }
+            if (!session.isCurrentConnection(message) || !activeConnection) {
+                return false;
+            }
+            if (message.kind === "disconnected") {
+                session.close();
+                dropActiveConnection();
+                return true;
+            }
+            if (!activeConnection.isAnnounced) {
+                activeConnection.pendingMessages.push(message);
+                return true;
+            }
+            for (const listener of activeConnection.listeners) {
+                listener(message);
+            }
+            return true;
+        },
+    };
+};

package/dist/webview-host-session-machine.d.ts

@@ -0,0 +1,22 @@
+export type WebViewHostSessionIdentity = {
+    connectionId: string;
+    epoch: number;
+    generation: number;
+};
+type WebViewHostSessionState = "awaitingActivation" | "awaitingConnection" | "connected" | "closed";
+type WebViewHostSessionSnapshot = {
+    connection: WebViewHostSessionIdentity | null;
+    epoch: number;
+    state: WebViewHostSessionState;
+};
+type WebViewHostSessionAcceptance = "accepted" | "duplicate" | "rejected";
+export type WebViewHostSessionController = {
+    getSnapshot: () => WebViewHostSessionSnapshot;
+    advanceEpoch: () => number;
+    acceptConnection: (identity: WebViewHostSessionIdentity) => WebViewHostSessionAcceptance;
+    confirmActivation: (identity: WebViewHostSessionIdentity) => WebViewHostSessionAcceptance;
+    isCurrentConnection: (identity: WebViewHostSessionIdentity) => boolean;
+    close: () => void;
+};
+export declare function createWebViewHostSessionController(): WebViewHostSessionController;
+export {};

package/dist/webview-host-session-machine.js

@@ -0,0 +1,82 @@
+import { createMachine, guard, interpret, reduce, state, transition, } from "robot3";
+const SESSION_STATES = {
+    awaitingActivation: true,
+    awaitingConnection: true,
+    connected: true,
+    closed: true,
+};
+const identitiesMatch = (left, right) => left !== null &&
+    left.connectionId === right.connectionId &&
+    left.epoch === right.epoch &&
+    left.generation === right.generation;
+const advanceEpoch = reduce((context) => ({
+    acceptance: null,
+    connection: null,
+    epoch: context.epoch + 1,
+}));
+const isCurrentEpoch = guard((context, event) => event.identity.epoch === context.epoch);
+const acceptConnection = reduce((context, event) => (Object.assign(Object.assign({}, context), { acceptance: "accepted", connection: event.identity })));
+const acceptDuplicateConnection = reduce((context) => (Object.assign(Object.assign({}, context), { acceptance: "duplicate" })));
+const rejectConnection = reduce((context) => (Object.assign(Object.assign({}, context), { acceptance: "rejected" })));
+const acceptActivation = reduce((context) => (Object.assign(Object.assign({}, context), { acceptance: "accepted" })));
+const acceptDuplicateActivation = reduce((context) => (Object.assign(Object.assign({}, context), { acceptance: "duplicate" })));
+const rejectActivation = reduce((context) => (Object.assign(Object.assign({}, context), { acceptance: "rejected" })));
+const isDuplicateConnection = guard((context, event) => identitiesMatch(context.connection, event.identity));
+const isCurrentActivation = guard((context, event) => identitiesMatch(context.connection, event.identity));
+const closeSession = reduce((context) => (Object.assign(Object.assign({}, context), { connection: null })));
+function createWebViewHostSessionMachine() {
+    const states = {
+        awaitingConnection: state(transition("advanceEpoch", "awaitingConnection", advanceEpoch), transition("acceptConnection", "awaitingActivation", isCurrentEpoch, acceptConnection), transition("acceptConnection", "awaitingConnection", rejectConnection), transition("confirmActivation", "awaitingConnection", rejectActivation), transition("close", "closed", closeSession)),
+        awaitingActivation: state(transition("advanceEpoch", "awaitingConnection", advanceEpoch), transition("acceptConnection", "awaitingActivation", isDuplicateConnection, acceptDuplicateConnection), transition("acceptConnection", "awaitingActivation", rejectConnection), transition("confirmActivation", "connected", isCurrentActivation, acceptActivation), transition("confirmActivation", "awaitingActivation", rejectActivation), transition("close", "closed", closeSession)),
+        connected: state(transition("advanceEpoch", "awaitingConnection", advanceEpoch), transition("acceptConnection", "connected", isDuplicateConnection, acceptDuplicateConnection), transition("acceptConnection", "connected", rejectConnection), transition("confirmActivation", "connected", isCurrentActivation, acceptDuplicateActivation), transition("confirmActivation", "connected", rejectActivation), transition("close", "closed", closeSession)),
+        closed: state(transition("advanceEpoch", "awaitingConnection", advanceEpoch), transition("acceptConnection", "closed", rejectConnection), transition("confirmActivation", "closed", rejectActivation), transition("close", "closed")),
+    };
+    return createMachine(states, () => ({
+        acceptance: null,
+        connection: null,
+        epoch: 0,
+    }));
+}
+export function createWebViewHostSessionController() {
+    const service = interpret(createWebViewHostSessionMachine(), () => { });
+    const getSnapshot = () => ({
+        connection: service.context.connection,
+        epoch: service.context.epoch,
+        state: readSessionState(service.machine.current),
+    });
+    return {
+        getSnapshot,
+        advanceEpoch: () => {
+            service.send({ type: "advanceEpoch" });
+            return service.context.epoch;
+        },
+        acceptConnection: (identity) => {
+            service.send({ type: "acceptConnection", identity });
+            if (service.context.acceptance === null) {
+                throw new Error("WebView host connection was not evaluated");
+            }
+            return service.context.acceptance;
+        },
+        confirmActivation: (identity) => {
+            service.send({ type: "confirmActivation", identity });
+            if (service.context.acceptance === null) {
+                throw new Error("WebView host activation was not evaluated");
+            }
+            return service.context.acceptance;
+        },
+        isCurrentConnection: (identity) => {
+            const snapshot = getSnapshot();
+            return (snapshot.state === "connected" &&
+                identitiesMatch(snapshot.connection, identity));
+        },
+        close: () => {
+            service.send({ type: "close" });
+        },
+    };
+}
+function readSessionState(value) {
+    if (typeof value !== "string" || !(value in SESSION_STATES)) {
+        throw new Error(`Unknown WebView host session state: ${String(value)}`);
+    }
+    return value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "3.0.7",
+  "version": "3.0.23",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^3.5.1",
-    "@getuserfeedback/sdk": "^0.9.1",
+    "@getuserfeedback/protocol": "^3.6.1",
+    "@getuserfeedback/sdk": "^0.9.8",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {