@getuserfeedback/react-native 3.0.33 → 3.0.35

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

@@ -0,0 +1,23 @@
+type NativeViewActivationState = "idle" | "prerendering" | "activation-requested" | "prerendering-activation-requested" | "prerendered" | "active";
+type NativeViewRecord = Readonly<{
+    allocationId: number;
+    activationState: NativeViewActivationState;
+    generation: number;
+    instanceId: string;
+    srcdoc: string;
+    viewId: string;
+}>;
+export type NativeViewRecordController = {
+    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;
+}): NativeViewRecordController;
+export {};

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

@@ -0,0 +1,159 @@
+import { coreViewHostActionSchema, } from "@getuserfeedback/protocol/internal/core-view-host-actions";
+import { createViewActivationController, createViewPreparationRegistry, } from "./view-orchestration-runtime.js";
+export function createNativeViewRecordController(input) {
+    const entries = new Map();
+    const listeners = new Set();
+    const pendingActivations = new Map();
+    const preparations = createViewPreparationRegistry();
+    let disposed = false;
+    let nextAllocationId = 0;
+    let snapshot = Object.freeze([]);
+    const notify = () => {
+        snapshot = Object.freeze(Array.from(entries.values(), toRecord));
+        for (const listener of listeners) {
+            listener();
+        }
+    };
+    const ensurePendingActivation = (viewId) => {
+        const existing = pendingActivations.get(viewId);
+        if (existing) {
+            return existing;
+        }
+        const created = createViewActivationController();
+        pendingActivations.set(viewId, created);
+        return created;
+    };
+    const removeEntry = (entry) => {
+        if (entries.get(entry.viewId) !== entry) {
+            return false;
+        }
+        entries.delete(entry.viewId);
+        notify();
+        return true;
+    };
+    const handlePrerender = (action) => {
+        var _a;
+        if (entries.has(action.viewId)) {
+            return;
+        }
+        const preparation = preparations.claim(action.viewId);
+        if (!preparation) {
+            return;
+        }
+        const activation = (_a = pendingActivations.get(action.viewId)) !== null && _a !== void 0 ? _a : createViewActivationController();
+        pendingActivations.delete(action.viewId);
+        activation.startPrerender();
+        nextAllocationId += 1;
+        const entry = {
+            activation,
+            allocationId: nextAllocationId,
+            generation: action.gen,
+            instanceId: action.instanceId,
+            preparation,
+            srcdoc: action.srcdoc,
+            viewId: action.viewId,
+        };
+        entries.set(action.viewId, entry);
+        preparation.addCleanup(() => {
+            removeEntry(entry);
+        });
+        notify();
+    };
+    const handleActivate = (action) => {
+        var _a;
+        const entry = entries.get(action.viewId);
+        const activation = (_a = entry === null || entry === void 0 ? void 0 : entry.activation) !== null && _a !== void 0 ? _a : ensurePendingActivation(action.viewId);
+        const previousState = activation.getState();
+        activation.requestActivation();
+        if (entry && activation.getState() !== previousState) {
+            notify();
+        }
+    };
+    const handleClose = (action) => {
+        if (preparations.cancel(action.viewId)) {
+            return;
+        }
+        pendingActivations.delete(action.viewId);
+        const entry = entries.get(action.viewId);
+        if (entry) {
+            removeEntry(entry);
+        }
+    };
+    return {
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            const hadEntries = entries.size > 0;
+            entries.clear();
+            pendingActivations.clear();
+            preparations.cancelAll();
+            if (hadEntries) {
+                snapshot = Object.freeze([]);
+                for (const listener of listeners) {
+                    listener();
+                }
+            }
+            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 () => { };
+            }
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+function toRecord(entry) {
+    return Object.freeze({
+        activationState: entry.activation.getState(),
+        allocationId: entry.allocationId,
+        generation: entry.generation,
+        instanceId: entry.instanceId,
+        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]

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

package/dist/view-orchestration-runtime.js

@@ -79,6 +79,90 @@ function readViewActivationState(value) {
   }
   return value;
 }
+// ../view-orchestration/src/view-preparation-registry.ts
+class ViewPreparationCancelledError extends Error {
+  viewId;
+  constructor(viewId) {
+    super(`View preparation for "${viewId}" was cancelled`);
+    this.name = "AbortError";
+    this.viewId = viewId;
+  }
+}
+function runCleanups(entry) {
+  for (const cleanup of Array.from(entry.cleanups)) {
+    entry.cleanups.delete(cleanup);
+    try {
+      cleanup();
+    } catch {}
+  }
+}
+function createViewPreparationRegistry() {
+  const entries = new Map;
+  return {
+    claim(viewId) {
+      if (entries.has(viewId)) {
+        return null;
+      }
+      const entry = {
+        controller: new AbortController,
+        cleanups: new Set
+      };
+      entries.set(viewId, entry);
+      return {
+        signal: entry.controller.signal,
+        addCleanup: (cleanup) => {
+          if (entry.controller.signal.aborted) {
+            try {
+              cleanup();
+            } catch {}
+            return () => {};
+          }
+          entry.cleanups.add(cleanup);
+          return () => entry.cleanups.delete(cleanup);
+        },
+        commit: () => {
+          if (entry.controller.signal.aborted || entries.get(viewId) !== entry) {
+            return false;
+          }
+          entries.delete(viewId);
+          entry.cleanups.clear();
+          return true;
+        },
+        isCancelled: () => entry.controller.signal.aborted,
+        release: () => {
+          if (entries.get(viewId) === entry) {
+            entries.delete(viewId);
+          }
+          runCleanups(entry);
+        }
+      };
+    },
+    cancel(viewId) {
+      const entry = entries.get(viewId);
+      if (!entry) {
+        return false;
+      }
+      entries.delete(viewId);
+      entry.controller.abort(new ViewPreparationCancelledError(viewId));
+      runCleanups(entry);
+      return true;
+    },
+    cancelAll() {
+      const viewIds = Array.from(entries.keys());
+      for (const viewId of viewIds) {
+        const entry = entries.get(viewId);
+        entries.delete(viewId);
+        entry?.controller.abort(new ViewPreparationCancelledError(viewId));
+        if (entry) {
+          runCleanups(entry);
+        }
+      }
+      return viewIds;
+    },
+    has: (viewId) => entries.has(viewId),
+    isEmpty: () => entries.size === 0
+  };
+}
 // src/view-orchestration-runtime.ts
 function createActiveViewSnapshotListController2() {
   return createActiveViewSnapshotListController();
@@ -86,7 +170,11 @@ function createActiveViewSnapshotListController2() {
 function createViewActivationController2() {
   return createViewActivationController();
 }
+function createViewPreparationRegistry2() {
+  return createViewPreparationRegistry();
+}
 export {
+  createViewPreparationRegistry2 as createViewPreparationRegistry,
   createViewActivationController2 as createViewActivationController,
   createActiveViewSnapshotListController2 as createActiveViewSnapshotListController
 };

package/dist/view-webview-host.js

@@ -50,5 +50,3 @@ function ViewWebViewHostDocument({ generation, onConnected, onDisconnected, onIn
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getuserfeedback/react-native",
-  "version": "3.0.33",
+  "version": "3.0.35",
   "description": "getuserfeedback React Native SDK",
   "keywords": [
     "getuserfeedback",
@@ -44,8 +44,8 @@
     "lint": "biome check ."
   },
   "dependencies": {
-    "@getuserfeedback/protocol": "^3.7.7",
-    "@getuserfeedback/sdk": "^0.10.3",
+    "@getuserfeedback/protocol": "^3.8.0",
+    "@getuserfeedback/sdk": "^0.10.4",
     "robot3": "^1.2.0"
   },
   "peerDependencies": {