@getuserfeedback/react-native 3.0.37 → 3.0.39

package/dist/native-view-record-controller.d.ts

@@ -1,23 +1,29 @@
+import { type EventViewSize } from "@getuserfeedback/protocol/internal/view-host-control-messages";
+import type { CoreWebViewHostConnection } from "./core-webview-host-controller.js";
+import type { ViewWebViewHostConnection } from "./view-webview-host-controller.js";
 type NativeViewActivationState = "idle" | "prerendering" | "activation-requested" | "prerendering-activation-requested" | "prerendered" | "active";
+type NativeViewSizeReport = Omit<EventViewSize, "gen" | "t" | "viewId">;
 type NativeViewRecord = Readonly<{
     allocationId: number;
     activationState: NativeViewActivationState;
     generation: number;
     instanceId: string;
+    size: NativeViewSizeReport | null;
     srcdoc: string;
     viewId: string;
 }>;
 export type NativeViewRecordController = {
+    attachViewReadinessConnection(input: {
+        allocationId: number;
+        connection: ViewWebViewHostConnection;
+    }): (() => void) | null;
     dispose(): void;
     getSnapshot(): readonly NativeViewRecord[];
-    handleCoreMessage(value: unknown): void;
-    markPrepared(input: {
-        allocationId: number;
-        viewId: string;
-    }): boolean;
     subscribe(listener: () => void): () => void;
 };
 export declare function createNativeViewRecordController(input: {
-    generation: number;
+    coreConnection: CoreWebViewHostConnection;
+    onError: (error: Error) => void;
+    readinessRetryDelayMs?: number;
 }): NativeViewRecordController;
 export {};

package/dist/native-view-record-controller.js

@@ -1,6 +1,11 @@
 import { coreViewHostActionSchema, } from "@getuserfeedback/protocol/internal/core-view-host-actions";
-import { createViewActivationController, createViewPreparationRegistry, } from "./view-orchestration-runtime.js";
+import { buildEventViewSize, eventViewSizeSchema, } from "@getuserfeedback/protocol/internal/view-host-control-messages";
+import { buildEventViewPrerendered } from "@getuserfeedback/protocol/internal/view-host-lifecycle-events";
+import { createViewActivationController, createViewPreparationReadinessRegistry, createViewPreparationRegistry, } from "./view-orchestration-runtime.js";
+const createNativeViewReadinessRegistry = () => createViewPreparationReadinessRegistry();
+const DEFAULT_READINESS_RETRY_DELAY_MS = 50;
 export function createNativeViewRecordController(input) {
+    var _a;
     const entries = new Map();
     const listeners = new Set();
     const pendingActivations = new Map();
@@ -8,6 +13,15 @@ export function createNativeViewRecordController(input) {
     let disposed = false;
     let nextAllocationId = 0;
     let snapshot = Object.freeze([]);
+    const readinessRetryDelayMs = (_a = input.readinessRetryDelayMs) !== null && _a !== void 0 ? _a : DEFAULT_READINESS_RETRY_DELAY_MS;
+    const reportError = (error, fallbackMessage) => {
+        try {
+            input.onError(error instanceof Error ? error : new Error(fallbackMessage));
+        }
+        catch (_a) {
+            // Error observers cannot change view lifecycle settlement.
+        }
+    };
     const notify = () => {
         snapshot = Object.freeze(Array.from(entries.values(), toRecord));
         for (const listener of listeners) {
@@ -24,11 +38,15 @@ export function createNativeViewRecordController(input) {
         return created;
     };
     const removeEntry = (entry) => {
+        var _a;
         if (entries.get(entry.viewId) !== entry) {
             return false;
         }
+        (_a = entry.viewReadinessDetach) === null || _a === void 0 ? void 0 : _a.call(entry);
         entries.delete(entry.viewId);
-        notify();
+        if (!disposed) {
+            notify();
+        }
         return true;
     };
     const handlePrerender = (action) => {
@@ -50,7 +68,10 @@ export function createNativeViewRecordController(input) {
             generation: action.gen,
             instanceId: action.instanceId,
             preparation,
+            preparationState: "claimed",
+            size: null,
             srcdoc: action.srcdoc,
+            viewReadinessDetach: null,
             viewId: action.viewId,
         };
         entries.set(action.viewId, entry);
@@ -79,16 +100,214 @@ export function createNativeViewRecordController(input) {
             removeEntry(entry);
         }
     };
+    const handleCoreMessage = (value) => {
+        if (disposed) {
+            return;
+        }
+        const parsed = coreViewHostActionSchema.safeParse(value);
+        if (!parsed.success ||
+            parsed.data.gen !== input.coreConnection.generation) {
+            return;
+        }
+        switch (parsed.data.t) {
+            case "getuserfeedback:action:prerenderView":
+                handlePrerender(parsed.data);
+                break;
+            case "getuserfeedback:action:activateView":
+                handleActivate(parsed.data);
+                break;
+            case "getuserfeedback:action:closeView":
+                handleClose(parsed.data);
+                break;
+        }
+    };
+    const completeConnectionReadiness = (delivery, entry, size) => {
+        if (!size || disposed || entries.get(entry.viewId) !== entry) {
+            return false;
+        }
+        if (entry.preparationState === "claimed") {
+            if (!entry.preparation.commit()) {
+                return false;
+            }
+            entry.preparationState = "committed";
+        }
+        if (delivery.stage === "pending-size") {
+            input.coreConnection.transport.postMessage(buildEventViewSize(Object.assign({ gen: entry.generation, viewId: entry.viewId }, size)));
+            delivery.stage = "pending-prerendered";
+        }
+        if (delivery.stage === "pending-prerendered") {
+            input.coreConnection.transport.postMessage(buildEventViewPrerendered({
+                gen: entry.generation,
+                viewId: entry.viewId,
+            }));
+            delivery.stage = "delivered";
+        }
+        if (entry.preparationState !== "prepared") {
+            entry.preparationState = "prepared";
+            entry.activation.markPrerendered();
+        }
+        notify();
+        return true;
+    };
+    const stopCoreTransport = input.coreConnection.transport.subscribe(handleCoreMessage);
     return {
+        attachViewReadinessConnection({ allocationId, connection }) {
+            if (disposed) {
+                return null;
+            }
+            const { viewId } = connection;
+            const entry = entries.get(viewId);
+            if (!entry ||
+                entry.allocationId !== allocationId ||
+                connection.generation !== input.coreConnection.generation) {
+                return null;
+            }
+            const previousDetach = entry.viewReadinessDetach;
+            const connectionReadiness = createNativeViewReadinessRegistry().begin(viewId);
+            const readinessDelivery = {
+                stage: "awaiting-readiness",
+            };
+            let latestReadySize = null;
+            let retryState = "available";
+            let retryTimer = null;
+            let detached = false;
+            let subscribed = false;
+            let unsubscribe = () => { };
+            const bufferedMessages = [];
+            const detach = () => {
+                if (detached) {
+                    return;
+                }
+                detached = true;
+                if (retryTimer !== null) {
+                    clearTimeout(retryTimer);
+                    retryTimer = null;
+                }
+                unsubscribe();
+                connectionReadiness.release();
+                if (entry.viewReadinessDetach === detach) {
+                    entry.viewReadinessDetach = null;
+                }
+            };
+            const attemptReadinessDelivery = (isRetry = false) => {
+                if (!latestReadySize ||
+                    readinessDelivery.stage === "awaiting-readiness" ||
+                    readinessDelivery.stage === "delivered" ||
+                    detached ||
+                    disposed ||
+                    entries.get(viewId) !== entry ||
+                    entry.viewReadinessDetach !== detach) {
+                    return "idle";
+                }
+                if ((isRetry && retryState !== "scheduled") ||
+                    (!isRetry && retryState !== "available")) {
+                    return "failed";
+                }
+                if (isRetry) {
+                    retryState = "exhausted";
+                }
+                try {
+                    if (completeConnectionReadiness(readinessDelivery, entry, latestReadySize)) {
+                        if (retryTimer !== null) {
+                            clearTimeout(retryTimer);
+                            retryTimer = null;
+                        }
+                        return "delivered";
+                    }
+                    return "idle";
+                }
+                catch (error) {
+                    if (!isRetry) {
+                        retryState = "scheduled";
+                        retryTimer = setTimeout(() => {
+                            retryTimer = null;
+                            attemptReadinessDelivery(true);
+                        }, readinessRetryDelayMs);
+                    }
+                    else {
+                        reportError(error, "Native view readiness delivery failed");
+                    }
+                    return "failed";
+                }
+            };
+            const handleMessage = (value) => {
+                if (detached ||
+                    disposed ||
+                    entries.get(viewId) !== entry ||
+                    entry.viewReadinessDetach !== detach) {
+                    return;
+                }
+                const parsed = eventViewSizeSchema.safeParse(value);
+                if (!parsed.success ||
+                    parsed.data.gen !== input.coreConnection.generation ||
+                    (parsed.data.viewId !== undefined && parsed.data.viewId !== viewId)) {
+                    return;
+                }
+                const size = toViewSizeReport(parsed.data);
+                entry.size = size;
+                const readySize = connectionReadiness.recordSize(size);
+                if (readySize) {
+                    latestReadySize = readySize;
+                    readinessDelivery.stage = "pending-size";
+                }
+                else if (readinessDelivery.stage === "pending-size" ||
+                    readinessDelivery.stage === "pending-prerendered") {
+                    latestReadySize = size;
+                }
+                if (attemptReadinessDelivery() !== "delivered") {
+                    notify();
+                }
+            };
+            let subscribedUnsubscribe;
+            try {
+                subscribedUnsubscribe = connection.transport.subscribe((value) => {
+                    if (!subscribed) {
+                        bufferedMessages.push(value);
+                        return;
+                    }
+                    handleMessage(value);
+                });
+            }
+            catch (error) {
+                connectionReadiness.release();
+                reportError(error, "Native view readiness subscription failed");
+                return null;
+            }
+            unsubscribe = subscribedUnsubscribe;
+            if (disposed || entries.get(viewId) !== entry) {
+                subscribedUnsubscribe();
+                connectionReadiness.release();
+                return null;
+            }
+            entry.viewReadinessDetach = detach;
+            previousDetach === null || previousDetach === void 0 ? void 0 : previousDetach();
+            subscribed = true;
+            for (const message of bufferedMessages) {
+                handleMessage(message);
+                if (detached) {
+                    return null;
+                }
+            }
+            const readySize = connectionReadiness.markHostPrepared();
+            if (readySize) {
+                latestReadySize = readySize;
+                readinessDelivery.stage = "pending-size";
+            }
+            attemptReadinessDelivery();
+            return detached ? null : detach;
+        },
         dispose() {
             if (disposed) {
                 return;
             }
             disposed = true;
             const hadEntries = entries.size > 0;
-            entries.clear();
-            pendingActivations.clear();
+            stopCoreTransport();
             preparations.cancelAll();
+            for (const entry of Array.from(entries.values())) {
+                removeEntry(entry);
+            }
+            pendingActivations.clear();
             if (hadEntries) {
                 snapshot = Object.freeze([]);
                 for (const listener of listeners) {
@@ -98,44 +317,6 @@ export function createNativeViewRecordController(input) {
             listeners.clear();
         },
         getSnapshot: () => snapshot,
-        handleCoreMessage(value) {
-            if (disposed) {
-                return;
-            }
-            const parsed = coreViewHostActionSchema.safeParse(value);
-            if (!parsed.success || parsed.data.gen !== input.generation) {
-                return;
-            }
-            switch (parsed.data.t) {
-                case "getuserfeedback:action:prerenderView":
-                    handlePrerender(parsed.data);
-                    break;
-                case "getuserfeedback:action:activateView":
-                    handleActivate(parsed.data);
-                    break;
-                case "getuserfeedback:action:closeView":
-                    handleClose(parsed.data);
-                    break;
-            }
-        },
-        markPrepared({ allocationId, viewId }) {
-            if (disposed) {
-                return false;
-            }
-            const entry = entries.get(viewId);
-            if (!entry || entry.allocationId !== allocationId) {
-                return false;
-            }
-            if (!entry.preparation.commit()) {
-                return false;
-            }
-            const previousState = entry.activation.getState();
-            entry.activation.markPrerendered();
-            if (entry.activation.getState() !== previousState) {
-                notify();
-            }
-            return true;
-        },
         subscribe(listener) {
             if (disposed) {
                 return () => { };
@@ -151,9 +332,21 @@ function toRecord(entry) {
         allocationId: entry.allocationId,
         generation: entry.generation,
         instanceId: entry.instanceId,
+        size: entry.size,
         srcdoc: entry.srcdoc,
         viewId: entry.viewId,
     });
 }
-// TODO(migration): Subscribe this controller to the native core transport, render its identity-safe records through ViewWebViewHost, and complete preparation only after protocol-owned view readiness is observed. Keep the provider runtime active during this proof.
-// [from=private-native-view-allocation-state] [to=private-native-view-readiness-routing] [scope=slice] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=30]
+function toViewSizeReport(event) {
+    return {
+        width: event.width,
+        height: event.height,
+        intrinsicWidth: event.intrinsicWidth,
+        frameAppearance: event.frameAppearance,
+        placement: event.placement,
+        transitionPolicy: event.transitionPolicy,
+        layoutTransactionId: event.layoutTransactionId,
+    };
+}
+// TODO(migration): Render the controller's identity-safe records through ViewWebViewHost and attach each connected view transport. Keep the provider runtime active during this proof.
+// [from=private-native-view-readiness-routing] [to=private-native-view-rendering-proof] [scope=slice] [priority=high] [impact=high] [risk=high] [epic=runtime-neutral-view-host-orchestration] [epic_order=40]

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

package/dist/view-orchestration-runtime.js

@@ -79,6 +79,54 @@ function readViewActivationState(value) {
   }
   return value;
 }
+// ../view-orchestration/src/view-preparation-readiness-registry.ts
+function createViewPreparationReadinessRegistry() {
+  const states = new Map;
+  const resolveReadySize = (state2) => {
+    if (!state2 || state2.status === "ready" || !state2.hostPrepared || state2.size === null) {
+      return null;
+    }
+    state2.status = "ready";
+    return state2.size;
+  };
+  return {
+    begin(viewId) {
+      const state2 = {
+        hostPrepared: false,
+        size: null,
+        status: "pending"
+      };
+      states.set(viewId, state2);
+      const getCurrentState = () => states.get(viewId) === state2 ? state2 : null;
+      return {
+        markHostPrepared() {
+          const current = getCurrentState();
+          if (!current || current.status === "ready") {
+            return null;
+          }
+          current.hostPrepared = true;
+          return resolveReadySize(current);
+        },
+        recordSize(size) {
+          const current = getCurrentState();
+          if (!current || current.status === "ready") {
+            return null;
+          }
+          current.size ??= size;
+          return resolveReadySize(current);
+        },
+        release() {
+          if (getCurrentState()) {
+            states.delete(viewId);
+          }
+        }
+      };
+    },
+    clearAll: () => {
+      states.clear();
+    }
+  };
+}
 // ../view-orchestration/src/view-preparation-registry.ts
 class ViewPreparationCancelledError extends Error {
   viewId;
@@ -173,8 +221,12 @@ function createViewActivationController2() {
 function createViewPreparationRegistry2() {
   return createViewPreparationRegistry();
 }
+function createViewPreparationReadinessRegistry2() {
+  return createViewPreparationReadinessRegistry();
+}
 export {
   createViewPreparationRegistry2 as createViewPreparationRegistry,
+  createViewPreparationReadinessRegistry2 as createViewPreparationReadinessRegistry,
   createViewActivationController2 as createViewActivationController,
   createActiveViewSnapshotListController2 as createActiveViewSnapshotListController
 };

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

@@ -6,6 +6,7 @@ export type ViewWebViewHostConnection = {
         postMessage: (message: unknown) => void;
         subscribe: (listener: (message: unknown) => void) => () => void;
     };
+    viewId: string;
 };
 export type ViewWebViewHostController = WebViewHostController<ViewWebViewBridgeMessage>;
 export declare const createViewWebViewHostController: (input: {

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

@@ -21,6 +21,7 @@ export const createViewWebViewHostController = (input) => {
                         }
                     }),
                 },
+                viewId: input.viewId,
             });
         },
         onDisconnected: input.onDisconnected,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "3.0.37",
+  "version": "3.0.39",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^3.10.0",
-    "@getuserfeedback/sdk": "^0.10.6",
+    "@getuserfeedback/protocol": "^3.11.0",
+    "@getuserfeedback/sdk": "^0.10.8",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {