@getuserfeedback/react-native 1.3.2 → 1.3.3

package/dist/index.js

@@ -13,6 +13,7 @@ import { assertNoSegmentExternalIdsInValueArgument, CommandSettlementError, Comm
 import { parseWebViewTransportNativeMessage } from "@getuserfeedback/protocol/webview-transport";
 import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
 import { useResolvedHostViewport } from "./host-viewport.js";
+import { applyProviderOverlayFlowState, applyProviderOverlayHandleInvalidated, createDefaultProviderOverlayState, DEFAULT_PROVIDER_OVERLAY_VISIBILITY, updateProviderOverlayReadySequence, } from "./provider-overlay-state.js";
 import { REACT_NATIVE_SDK_VERSION } from "./version.js";
 import { WidgetHost, } from "./widget-host.js";
 export { REACT_NATIVE_SDK_VERSION } from "./version.js";
@@ -102,14 +103,6 @@ const VISIBLE_WIDGET_HOST_LAYOUT_STYLE_KEYS = new Set([
 ]);
 const DEFAULT_WIDGET_SHEET_HEIGHT_RATIO = 0.86;
 const DEFAULT_WIDGET_SHEET_MIN_HEIGHT = 320;
-const DEFAULT_WIDGET_HOST_VISIBILITY = {
-    flowHandleId: null,
-    hostSourceVersion: null,
-    isVisible: false,
-    origin: null,
-    readySequence: null,
-    sourceKey: null,
-};
 const createUniqueId = (prefix) => {
     if (typeof globalThis.crypto !== "undefined" &&
         typeof globalThis.crypto.randomUUID === "function") {
@@ -258,7 +251,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     const NativeView = useMemo(resolveNativeView, []);
     const [instanceId] = useState(() => { var _a; return (_a = normalizeOptionalString(instanceIdProp)) !== null && _a !== void 0 ? _a : createUniqueId("rn"); });
     const [nativeMessages, setNativeMessages] = useState([]);
-    const [widgetHostVisibility, setWidgetHostVisibility] = useState(DEFAULT_WIDGET_HOST_VISIBILITY);
+    const [widgetHostVisibility, setWidgetHostVisibility] = useState(DEFAULT_PROVIDER_OVERLAY_VISIBILITY);
     const resolvedHostViewport = useResolvedHostViewport(hostViewport);
     const nativeMessagesRef = useRef([]);
     const pendingCommandsRef = useRef(new Map());
@@ -266,7 +259,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     const flowHandleCacheEpochRef = useRef(0);
     const flowHandleIdsByFlowIdRef = useRef(new Map());
     const flowCommandSequencesByFlowIdRef = useRef(new Map());
-    const visibleFlowHandleIdsRef = useRef(new Set());
+    const providerOverlayStateRef = useRef(createDefaultProviderOverlayState());
     const initOptionsRef = useRef(initOptions);
     const configureOptionsRef = useRef(configureOptions);
     const initOptionsKey = useMemo(() => toJsonKey(initOptions), [initOptions]);
@@ -293,7 +286,7 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         startupQueuedKeyRef.current = null;
         flowHandleCacheEpochRef.current += 1;
         flowHandleIdsByFlowIdRef.current.clear();
-        visibleFlowHandleIdsRef.current.clear();
+        providerOverlayStateRef.current = createDefaultProviderOverlayState();
     }
     initOptionsRef.current = initOptions;
     configureOptionsRef.current = configureOptions;
@@ -528,14 +521,16 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             didReissueDeliveredCommands = reissueDeliveredPendingActionCommands();
         }
         lastReadyRef.current = Object.assign(Object.assign({}, event), { hostEpoch: hostEpochRef.current });
-        setWidgetHostVisibility((visibility) => {
-            if (!visibility.isVisible ||
-                visibility.sourceKey !== event.sourceKey ||
-                visibility.hostSourceVersion !== hostSourceVersionRef.current) {
-                return visibility;
-            }
-            return Object.assign(Object.assign({}, visibility), { readySequence: event.readySequence });
+        const nextVisibility = updateProviderOverlayReadySequence({
+            ready: {
+                hostSourceVersion: hostSourceVersionRef.current,
+                readySequence: event.readySequence,
+                sourceKey: event.sourceKey,
+            },
+            visibility: providerOverlayStateRef.current.visibility,
         });
+        providerOverlayStateRef.current = Object.assign(Object.assign({}, providerOverlayStateRef.current), { visibility: nextVisibility });
+        setWidgetHostVisibility(nextVisibility);
         enqueueStartupCommands({ force: previous !== null });
         startPendingCommandTimeouts();
         return didReissueDeliveredCommands;
@@ -562,8 +557,8 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             reissueDeliveredPendingActionCommands();
         }
         lastReadyRef.current = null;
-        setWidgetHostVisibility(DEFAULT_WIDGET_HOST_VISIBILITY);
-        visibleFlowHandleIdsRef.current.clear();
+        providerOverlayStateRef.current = createDefaultProviderOverlayState();
+        setWidgetHostVisibility(providerOverlayStateRef.current.visibility);
         pausePendingCommandTimeouts();
     }, [
         handleWidgetReady,
@@ -580,26 +575,14 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
     }, []);
     const handleFlowHandleInvalidated = useCallback((flowHandleId) => {
         deleteCachedFlowHandleId(flowHandleId);
-        visibleFlowHandleIdsRef.current.delete(flowHandleId);
-        if (visibleFlowHandleIdsRef.current.size > 0) {
-            return;
-        }
-        setWidgetHostVisibility((visibility) => {
-            if (visibility.origin !== "handle") {
-                return visibility;
-            }
-            return {
-                flowHandleId: null,
-                hostSourceVersion: visibility.hostSourceVersion,
-                isVisible: false,
-                origin: null,
-                readySequence: visibility.readySequence,
-                sourceKey: visibility.sourceKey,
-            };
+        const nextState = applyProviderOverlayHandleInvalidated({
+            flowHandleId,
+            state: providerOverlayStateRef.current,
         });
+        providerOverlayStateRef.current = nextState;
+        setWidgetHostVisibility(nextState.visibility);
     }, [deleteCachedFlowHandleId]);
     const handleFlowStateChanged = useCallback((detail, options) => {
-        var _a, _b;
         if (detail.instanceId !== instanceId) {
             return;
         }
@@ -607,83 +590,18 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
         if (!readyState) {
             return;
         }
-        const isVisible = detail.isOpen || detail.isLoading;
-        if (options.origin === "aggregate") {
-            if (isVisible) {
-                visibleFlowHandleIdsRef.current.clear();
-            }
-            else if (visibleFlowHandleIdsRef.current.size > 0) {
-                const flowHandleId = (_a = visibleFlowHandleIdsRef.current.values().next().value) !== null && _a !== void 0 ? _a : null;
-                setWidgetHostVisibility({
-                    flowHandleId,
-                    hostSourceVersion: hostSourceVersionRef.current,
-                    isVisible: true,
-                    origin: "handle",
-                    readySequence: readyState.readySequence,
-                    sourceKey: readyState.sourceKey,
-                });
-                return;
-            }
-        }
-        if (options.origin === "handle") {
-            if (detail.flowHandleId === undefined) {
-                return;
-            }
-            if (isVisible) {
-                visibleFlowHandleIdsRef.current.add(detail.flowHandleId);
-            }
-            else {
-                visibleFlowHandleIdsRef.current.delete(detail.flowHandleId);
-            }
-        }
-        if (!isVisible && options.origin === "handle") {
-            if (visibleFlowHandleIdsRef.current.size > 0) {
-                return;
-            }
-            setWidgetHostVisibility((visibility) => {
-                if (visibility.origin !== "handle") {
-                    return visibility;
-                }
-                return {
-                    flowHandleId: null,
-                    hostSourceVersion: hostSourceVersionRef.current,
-                    isVisible: false,
-                    origin: null,
-                    readySequence: readyState.readySequence,
-                    sourceKey: readyState.sourceKey,
-                };
-            });
-            return;
-        }
-        if (isVisible && options.origin === "handle") {
-            setWidgetHostVisibility((visibility) => {
-                var _a;
-                if (visibility.isVisible &&
-                    visibility.origin === "aggregate" &&
-                    visibility.hostSourceVersion === hostSourceVersionRef.current &&
-                    visibility.readySequence === readyState.readySequence &&
-                    visibility.sourceKey === readyState.sourceKey) {
-                    return visibility;
-                }
-                return {
-                    flowHandleId: (_a = detail.flowHandleId) !== null && _a !== void 0 ? _a : null,
-                    hostSourceVersion: hostSourceVersionRef.current,
-                    isVisible: true,
-                    origin: "handle",
-                    readySequence: readyState.readySequence,
-                    sourceKey: readyState.sourceKey,
-                };
-            });
-            return;
-        }
-        setWidgetHostVisibility({
-            flowHandleId: options.origin === "handle" ? ((_b = detail.flowHandleId) !== null && _b !== void 0 ? _b : null) : null,
-            hostSourceVersion: hostSourceVersionRef.current,
-            isVisible,
+        const nextState = applyProviderOverlayFlowState({
+            detail,
             origin: options.origin,
-            readySequence: readyState.readySequence,
-            sourceKey: readyState.sourceKey,
+            ready: {
+                hostSourceVersion: hostSourceVersionRef.current,
+                readySequence: readyState.readySequence,
+                sourceKey: readyState.sourceKey,
+            },
+            state: providerOverlayStateRef.current,
         });
+        providerOverlayStateRef.current = nextState;
+        setWidgetHostVisibility(nextState.visibility);
     }, [instanceId]);
     const handleWebMessage = useCallback((message) => {
         var _a;
@@ -778,7 +696,8 @@ export function GetUserFeedbackProvider({ autoInit = true, children, commandTime
             return;
         }
         visibilitySourceKeyRef.current = hostSourceKey;
-        setWidgetHostVisibility(DEFAULT_WIDGET_HOST_VISIBILITY);
+        providerOverlayStateRef.current = createDefaultProviderOverlayState();
+        setWidgetHostVisibility(providerOverlayStateRef.current.visibility);
     }, [hostSourceKey]);
     const contextValue = useMemo(() => ({
         instanceId,

package/dist/provider-overlay-state.d.ts

@@ -0,0 +1,43 @@
+export type ProviderOverlayVisibilityOrigin = "aggregate" | "handle";
+export type ProviderOverlayVisibility = {
+    flowHandleId: string | null;
+    hostSourceVersion: number | null;
+    isVisible: boolean;
+    origin: ProviderOverlayVisibilityOrigin | null;
+    readySequence: number | null;
+    sourceKey: string | null;
+};
+export type ProviderOverlayReadyIdentity = {
+    hostSourceVersion: number;
+    readySequence: number;
+    sourceKey: string;
+};
+export type ProviderOverlayFlowStateDetail = {
+    flowHandleId?: string;
+    isLoading: boolean;
+    isOpen: boolean;
+};
+export type ProviderOverlayState = {
+    visibility: ProviderOverlayVisibility;
+    visibleFlowHandleIds: Set<string>;
+};
+export type ProviderOverlayStateInput = {
+    visibility: ProviderOverlayVisibility;
+    visibleFlowHandleIds: ReadonlySet<string>;
+};
+export declare const DEFAULT_PROVIDER_OVERLAY_VISIBILITY: ProviderOverlayVisibility;
+export declare const createDefaultProviderOverlayState: () => ProviderOverlayState;
+export declare function updateProviderOverlayReadySequence({ ready, visibility, }: {
+    ready: ProviderOverlayReadyIdentity;
+    visibility: ProviderOverlayVisibility;
+}): ProviderOverlayVisibility;
+export declare function applyProviderOverlayFlowState({ detail, origin, ready, state, }: {
+    detail: ProviderOverlayFlowStateDetail;
+    origin: ProviderOverlayVisibilityOrigin;
+    ready: ProviderOverlayReadyIdentity;
+    state: ProviderOverlayStateInput;
+}): ProviderOverlayState;
+export declare function applyProviderOverlayHandleInvalidated({ flowHandleId, state, }: {
+    flowHandleId: string;
+    state: ProviderOverlayStateInput;
+}): ProviderOverlayState;

package/dist/provider-overlay-state.js

@@ -0,0 +1,134 @@
+export const DEFAULT_PROVIDER_OVERLAY_VISIBILITY = {
+    flowHandleId: null,
+    hostSourceVersion: null,
+    isVisible: false,
+    origin: null,
+    readySequence: null,
+    sourceKey: null,
+};
+export const createDefaultProviderOverlayState = () => ({
+    visibility: DEFAULT_PROVIDER_OVERLAY_VISIBILITY,
+    visibleFlowHandleIds: new Set(),
+});
+const toVisibleProviderOverlayVisibility = ({ flowHandleId, origin, ready, }) => ({
+    flowHandleId,
+    hostSourceVersion: ready.hostSourceVersion,
+    isVisible: true,
+    origin,
+    readySequence: ready.readySequence,
+    sourceKey: ready.sourceKey,
+});
+const toHiddenProviderOverlayVisibility = (visibility) => ({
+    flowHandleId: null,
+    hostSourceVersion: visibility.hostSourceVersion,
+    isVisible: false,
+    origin: null,
+    readySequence: visibility.readySequence,
+    sourceKey: visibility.sourceKey,
+});
+const isVisibilityForReadyIdentity = (visibility, ready) => visibility.hostSourceVersion === ready.hostSourceVersion &&
+    visibility.readySequence === ready.readySequence &&
+    visibility.sourceKey === ready.sourceKey;
+export function updateProviderOverlayReadySequence({ ready, visibility, }) {
+    if (!visibility.isVisible ||
+        visibility.sourceKey !== ready.sourceKey ||
+        visibility.hostSourceVersion !== ready.hostSourceVersion) {
+        return visibility;
+    }
+    return Object.assign(Object.assign({}, visibility), { readySequence: ready.readySequence });
+}
+export function applyProviderOverlayFlowState({ detail, origin, ready, state, }) {
+    var _a;
+    const isVisible = detail.isOpen || detail.isLoading;
+    const visibleFlowHandleIds = new Set(state.visibleFlowHandleIds);
+    if (origin === "aggregate") {
+        if (isVisible) {
+            visibleFlowHandleIds.clear();
+            return {
+                visibleFlowHandleIds,
+                visibility: toVisibleProviderOverlayVisibility({
+                    flowHandleId: null,
+                    origin,
+                    ready,
+                }),
+            };
+        }
+        if (visibleFlowHandleIds.size > 0) {
+            return {
+                visibleFlowHandleIds,
+                visibility: toVisibleProviderOverlayVisibility({
+                    flowHandleId: (_a = visibleFlowHandleIds.values().next().value) !== null && _a !== void 0 ? _a : null,
+                    origin: "handle",
+                    ready,
+                }),
+            };
+        }
+        return {
+            visibleFlowHandleIds,
+            visibility: {
+                flowHandleId: null,
+                hostSourceVersion: ready.hostSourceVersion,
+                isVisible: false,
+                origin,
+                readySequence: ready.readySequence,
+                sourceKey: ready.sourceKey,
+            },
+        };
+    }
+    if (detail.flowHandleId === undefined) {
+        return {
+            visibleFlowHandleIds,
+            visibility: state.visibility,
+        };
+    }
+    if (isVisible) {
+        visibleFlowHandleIds.add(detail.flowHandleId);
+        if (state.visibility.isVisible &&
+            state.visibility.origin === "aggregate" &&
+            isVisibilityForReadyIdentity(state.visibility, ready)) {
+            return {
+                visibleFlowHandleIds,
+                visibility: state.visibility,
+            };
+        }
+        return {
+            visibleFlowHandleIds,
+            visibility: toVisibleProviderOverlayVisibility({
+                flowHandleId: detail.flowHandleId,
+                origin,
+                ready,
+            }),
+        };
+    }
+    visibleFlowHandleIds.delete(detail.flowHandleId);
+    if (visibleFlowHandleIds.size > 0) {
+        return {
+            visibleFlowHandleIds,
+            visibility: state.visibility,
+        };
+    }
+    if (state.visibility.origin !== "handle") {
+        return {
+            visibleFlowHandleIds,
+            visibility: state.visibility,
+        };
+    }
+    return {
+        visibleFlowHandleIds,
+        visibility: toHiddenProviderOverlayVisibility(state.visibility),
+    };
+}
+export function applyProviderOverlayHandleInvalidated({ flowHandleId, state, }) {
+    const visibleFlowHandleIds = new Set(state.visibleFlowHandleIds);
+    visibleFlowHandleIds.delete(flowHandleId);
+    if (visibleFlowHandleIds.size > 0 || state.visibility.origin !== "handle") {
+        return {
+            visibleFlowHandleIds,
+            visibility: state.visibility,
+        };
+    }
+    return {
+        visibleFlowHandleIds,
+        visibility: toHiddenProviderOverlayVisibility(state.visibility),
+    };
+}

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

package/package.json

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