@getuserfeedback/react-native 4.0.29 → 5.0.6

package/dist/index.js

@@ -1,613 +0,0 @@
-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 { CommandSettlementError, CommandSettlementTimeoutError, createFlowCommandHandleController, getFlowHandleFromSettlementDetail, getWidgetLayoutPlanNowMs, } from "@getuserfeedback/protocol/host";
-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 { createNativeProviderClient, parseRequiredString, } from "./native-provider-client.js";
-import { createProviderCommandEnvelope, REACT_NATIVE_LOADER_CLIENT_META, toCommandSettlementError, toReactNativeOneShotCommand, } from "./provider-command-helpers.js";
-import { useProviderCommandTransport } from "./provider-command-transport.js";
-import { createProviderWidgetHostLifecycleController, HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY, } from "./provider-widget-host-lifecycle.js";
-import { ProviderWidgetHostOverlay, toProviderWidgetHostStyle, toProviderWidgetSheetHostLayoutPlan, } from "./provider-widget-host-overlay.js";
-import { WidgetHost, } from "./widget-host.js";
-export { REACT_NATIVE_SDK_VERSION } from "./version.js";
-export { buildNativeMessageInjectionScript, buildWebViewBridgeScript, } from "./webview-bridge-script.js";
-export { WidgetHost };
-const GetUserFeedbackNativeContext = createContext(null);
-const DEFAULT_COMMAND_TIMEOUT_MS = 30000;
-const PROVIDER_UNMOUNTED_ERROR_MESSAGE = "GetUserFeedbackProvider unmounted before command settled";
-const STARTUP_COMMAND_REPLACED_ERROR_MESSAGE = "GetUserFeedbackProvider replaced startup command before settlement";
-const STALE_HANDLE_ERROR_CODE = "STALE_HANDLE";
-const isStaleHandleError = (error) => {
-    if (error instanceof CommandSettlementError) {
-        return error.code === STALE_HANDLE_ERROR_CODE;
-    }
-    if (!(error instanceof Error)) {
-        return false;
-    }
-    return error.message.includes("flowHandleId is stale");
-};
-const toFlowHandleIdFromResult = (result) => {
-    if (!result.settlement) {
-        return undefined;
-    }
-    const handle = getFlowHandleFromSettlementDetail(result.settlement);
-    return handle === null || handle === void 0 ? void 0 : handle.flowHandleId;
-};
-const createReactNativeFlowRunController = (flowId, { enqueueFlowCommand, enqueueScopedClose, reportCommandError, }) => {
-    const handleClient = createFlowCommandHandleController({
-        getHandleIdFromSettlement: toFlowHandleIdFromResult,
-        isStaleHandleError,
-        onClearResolvedHandle: () => { },
-    });
-    const reportAsyncCommandError = (promise) => promise.catch((error) => {
-        reportCommandError(error instanceof Error ? error : new Error(String(error)));
-        throw error;
-    });
-    const reset = () => {
-        handleClient.reset();
-    };
-    const resetIdleHandle = () => {
-        if (handleClient.hasPendingCommands()) {
-            return;
-        }
-        reset();
-    };
-    const enqueueAndWaitForSettlement = async (buildPayload) => {
-        await handleClient.runCommand(buildPayload, enqueueFlowCommand);
-    };
-    return {
-        flowId,
-        open: (options) => reportAsyncCommandError(enqueueAndWaitForSettlement((flowHandleId) => ({
-            kind: "open",
-            flowId,
-            flowHandleId,
-            metadata: options === null || options === void 0 ? void 0 : options.metadata,
-            hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
-        }))),
-        prefetch: () => reportAsyncCommandError(enqueueAndWaitForSettlement((flowHandleId) => ({
-            kind: "prefetch",
-            flowId,
-            flowHandleId,
-        }))),
-        prerender: (options) => reportAsyncCommandError(enqueueAndWaitForSettlement((flowHandleId) => ({
-            kind: "prerender",
-            flowId,
-            flowHandleId,
-            hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
-        }))),
-        close: () => {
-            return reportAsyncCommandError(handleClient.runResolvedHandleCommand((flowHandleId) => flowHandleId, enqueueScopedClose));
-        },
-        hasFlowHandleId: (flowHandleId) => handleClient.getHandleId() === flowHandleId,
-        invalidateResolvedHandle: (flowHandleId) => {
-            handleClient.invalidateResolvedHandle(flowHandleId);
-        },
-        reset,
-        resetIdleHandle,
-    };
-};
-const createUniqueId = (prefix) => {
-    if (typeof globalThis.crypto !== "undefined" &&
-        typeof globalThis.crypto.randomUUID === "function") {
-        return `${prefix}_${globalThis.crypto.randomUUID()}`;
-    }
-    return `${prefix}_${Date.now()}_${Math.random().toString(16).slice(2)}`;
-};
-const createTransportMessageId = () => createUniqueId("native");
-const normalizeOptionalString = (value) => {
-    if (value === undefined) {
-        return undefined;
-    }
-    const normalized = value.trim();
-    return normalized.length > 0 ? normalized : undefined;
-};
-const toJsonKey = (value) => JSON.stringify(value);
-const toStableHash = (value) => {
-    const json = toJsonKey(value);
-    let hash = 0x811c9dc5;
-    for (let index = 0; index < json.length; index += 1) {
-        hash ^= json.charCodeAt(index);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return (hash >>> 0).toString(16);
-};
-const FallbackNativeView = (_a) => {
-    var { children } = _a, props = __rest(_a, ["children"]);
-    return createElement("div", props, children);
-};
-function resolveReactNativeComponents() {
-    var _a;
-    try {
-        const reactNativeModule = require("react-native");
-        return {
-            View: (_a = reactNativeModule.View) !== null && _a !== void 0 ? _a : FallbackNativeView,
-        };
-    }
-    catch (_b) {
-        return {
-            View: FallbackNativeView,
-        };
-    }
-}
-export function GetUserFeedbackProvider({ autoInit = true, children, commandTimeoutMs = DEFAULT_COMMAND_TIMEOUT_MS, configureOptions, hostViewport, instanceId: instanceIdProp, initOptions, loaderUrl, onCommandError, onInvalidWebMessage, onWebMessage, source, webViewComponent, webViewProps, }) {
-    var _a;
-    const { View: NativeView } = useMemo(resolveReactNativeComponents, []);
-    const [instanceId] = useState(() => { var _a; return (_a = normalizeOptionalString(instanceIdProp)) !== null && _a !== void 0 ? _a : createUniqueId("rn"); });
-    const [widgetHostVisibility, setWidgetHostVisibility] = useState(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
-    const resolvedHostViewport = useResolvedHostViewport(hostViewport);
-    const initOptionsRef = useRef(initOptions);
-    const configureOptionsRef = useRef(configureOptions);
-    const initOptionsKey = useMemo(() => toJsonKey(initOptions), [initOptions]);
-    const configureOptionsKey = useMemo(() => (configureOptions === undefined ? null : toJsonKey(configureOptions)), [configureOptions]);
-    const hostSourceKey = useMemo(() => toJsonKey({ loaderUrl: loaderUrl !== null && loaderUrl !== void 0 ? loaderUrl : null, source: source !== null && source !== void 0 ? source : null }), [loaderUrl, source]);
-    const startupOptionsKey = useMemo(() => toJsonKey({ configureOptionsKey, initOptionsKey }), [configureOptionsKey, initOptionsKey]);
-    const startupIdempotencyKey = useMemo(() => toStableHash({ configureOptionsKey, initOptionsKey }), [configureOptionsKey, initOptionsKey]);
-    const widgetHostLifecycleRef = useRef(createProviderWidgetHostLifecycleController(hostSourceKey));
-    const flowRunsRef = useRef(new Map());
-    const flowRunControllerOptionsRef = useRef(null);
-    const widgetHostLifecycle = widgetHostLifecycleRef.current;
-    const { clearFlowHandleFromVisibility, getCurrentHostEpoch, isWidgetHostVisible: resolveIsWidgetHostVisible, markNotReady, markReady, replaceViewHostSnapshots, syncHostSourceKey, toReadyVisibility, } = widgetHostLifecycle;
-    const createCommandTimeoutError = useCallback((requestId) => new CommandSettlementTimeoutError(requestId), []);
-    const transport = useProviderCommandTransport({
-        commandTimeoutMs,
-        createTimeoutError: createCommandTimeoutError,
-        getCurrentHostEpoch,
-    });
-    const { nativeMessages, nativeMessagesRef, clearStartupQueuedKey, createPendingCommandPromise, getPendingCommand, getPendingCommandEntries, hasDeliveredPendingCommands, isStartupQueuedKey, pausePendingCommandTimeouts, registerNativeMessage, reissuePendingCommand, removeNativeMessageId, replaceNativeMessages, resetStartupQueuedKeyIfChanged, setStartupQueuedKey, startPendingCommandTimeouts, takePendingCommand, cancelStartupCommands, dispose: disposeCommandTransport, } = transport;
-    const clearIdleFlowHandles = useCallback(() => {
-        for (const flowRun of flowRunsRef.current.values()) {
-            flowRun.resetIdleHandle();
-        }
-    }, []);
-    const resetFlowRuns = useCallback(() => {
-        for (const flowRun of flowRunsRef.current.values()) {
-            flowRun.reset();
-        }
-    }, []);
-    if (syncHostSourceKey(hostSourceKey)) {
-        pausePendingCommandTimeouts();
-        clearStartupQueuedKey();
-        clearIdleFlowHandles();
-    }
-    initOptionsRef.current = initOptions;
-    configureOptionsRef.current = configureOptions;
-    const reportCommandError = useCallback((error) => {
-        if (error.message === PROVIDER_UNMOUNTED_ERROR_MESSAGE ||
-            error.message === STARTUP_COMMAND_REPLACED_ERROR_MESSAGE) {
-            return;
-        }
-        if (onCommandError) {
-            onCommandError(error);
-            return;
-        }
-        setTimeout(() => {
-            throw error;
-        }, 0);
-    }, [onCommandError]);
-    const enqueueTransportCommand = useCallback((command, options, { isStartup = false, preserveFlowHandle = false, prioritizeStartup = false, } = {}) => {
-        const envelope = createProviderCommandEnvelope({
-            clientMeta: REACT_NATIVE_LOADER_CLIENT_META,
-            command: preserveFlowHandle
-                ? command
-                : toReactNativeOneShotCommand(command),
-            idempotencyKey: options === null || options === void 0 ? void 0 : options.idempotencyKey,
-            instanceId,
-        });
-        const { requestId } = envelope;
-        const message = {
-            kind: "enqueueCommand",
-            id: createTransportMessageId(),
-            envelope,
-        };
-        let validatedMessage;
-        try {
-            validatedMessage = parseWebViewTransportNativeMessage(message);
-        }
-        catch (error) {
-            if (isStartup) {
-                clearStartupQueuedKey();
-            }
-            return Promise.reject(error instanceof Error ? error : new Error(String(error)));
-        }
-        const result = {
-            envelope: validatedMessage.envelope,
-            message: validatedMessage,
-        };
-        const promise = createPendingCommandPromise({
-            isStartup,
-            message: validatedMessage,
-            requestId,
-            result,
-        });
-        registerNativeMessage(validatedMessage, { isStartup, prioritizeStartup });
-        return promise;
-    }, [
-        clearStartupQueuedKey,
-        createPendingCommandPromise,
-        instanceId,
-        registerNativeMessage,
-    ]);
-    const reissueDeliveredPendingActionCommands = useCallback(() => {
-        const replacements = new Map();
-        for (const [requestId, pendingCommand] of getPendingCommandEntries()) {
-            if (pendingCommand.isStartup || pendingCommand.hostEpoch === null) {
-                continue;
-            }
-            if (pendingCommand.timeout) {
-                clearTimeout(pendingCommand.timeout);
-                pendingCommand.timeout = null;
-            }
-            const previousEnvelope = pendingCommand.result.envelope;
-            const nextEnvelope = createProviderCommandEnvelope({
-                clientMeta: previousEnvelope.clientMeta,
-                command: toReactNativeOneShotCommand(previousEnvelope.command),
-                idempotencyKey: previousEnvelope.idempotencyKey,
-                instanceId: previousEnvelope.instanceId,
-            });
-            const nextMessage = parseWebViewTransportNativeMessage({
-                kind: "enqueueCommand",
-                id: createTransportMessageId(),
-                envelope: nextEnvelope,
-            });
-            const reissuedCommand = reissuePendingCommand({
-                nextMessage,
-                nextRequestId: nextEnvelope.requestId,
-                nextResult: {
-                    envelope: nextMessage.envelope,
-                    message: nextMessage,
-                },
-                requestId,
-            });
-            if (!reissuedCommand) {
-                continue;
-            }
-            replacements.set(reissuedCommand.previousMessageId, nextMessage);
-        }
-        if (replacements.size === 0) {
-            return false;
-        }
-        replaceNativeMessages(replacements);
-        return true;
-    }, [getPendingCommandEntries, reissuePendingCommand, replaceNativeMessages]);
-    const enqueueStartupCommands = useCallback(({ force = false } = {}) => {
-        if (!autoInit) {
-            return;
-        }
-        if (!force && isStartupQueuedKey(startupOptionsKey)) {
-            return;
-        }
-        const isReplacingStartup = force || !isStartupQueuedKey(startupOptionsKey);
-        if (isReplacingStartup) {
-            cancelStartupCommands(new Error(STARTUP_COMMAND_REPLACED_ERROR_MESSAGE));
-        }
-        setStartupQueuedKey(startupOptionsKey);
-        enqueueTransportCommand({ kind: "init", opts: initOptionsRef.current }, { idempotencyKey: `${instanceId}:init:${startupIdempotencyKey}` }, { isStartup: true, prioritizeStartup: isReplacingStartup }).catch(reportCommandError);
-        if (configureOptionsRef.current === undefined) {
-            return;
-        }
-        enqueueTransportCommand({ kind: "configure", opts: configureOptionsRef.current }, { idempotencyKey: `${instanceId}:configure:${startupIdempotencyKey}` }, { isStartup: true, prioritizeStartup: isReplacingStartup }).catch(reportCommandError);
-    }, [
-        autoInit,
-        cancelStartupCommands,
-        enqueueTransportCommand,
-        instanceId,
-        isStartupQueuedKey,
-        reportCommandError,
-        setStartupQueuedKey,
-        startupIdempotencyKey,
-        startupOptionsKey,
-    ]);
-    const enqueueCommand = useCallback((command, options) => {
-        enqueueStartupCommands();
-        return enqueueTransportCommand(command, options);
-    }, [enqueueStartupCommands, enqueueTransportCommand]);
-    const enqueueFlowCommand = useCallback((command) => {
-        enqueueStartupCommands();
-        return enqueueTransportCommand(command, undefined, {
-            preserveFlowHandle: true,
-        });
-    }, [enqueueStartupCommands, enqueueTransportCommand]);
-    const enqueueScopedFlowClose = useCallback((flowHandleId) => enqueueCommand({ kind: "close", flowHandleId }).then(() => { }), [enqueueCommand]);
-    flowRunControllerOptionsRef.current = {
-        enqueueFlowCommand,
-        enqueueScopedClose: enqueueScopedFlowClose,
-        reportCommandError,
-    };
-    const flow = useCallback((flowId) => {
-        const normalizedFlowId = parseRequiredString("flowId", flowId);
-        const existing = flowRunsRef.current.get(normalizedFlowId);
-        if (existing) {
-            return existing;
-        }
-        const created = createReactNativeFlowRunController(normalizedFlowId, {
-            enqueueFlowCommand: (command) => {
-                const currentOptions = flowRunControllerOptionsRef.current;
-                if (!currentOptions) {
-                    return Promise.reject(new Error(PROVIDER_UNMOUNTED_ERROR_MESSAGE));
-                }
-                return currentOptions.enqueueFlowCommand(command);
-            },
-            enqueueScopedClose: (flowHandleId) => {
-                const currentOptions = flowRunControllerOptionsRef.current;
-                if (!currentOptions) {
-                    return Promise.reject(new Error(PROVIDER_UNMOUNTED_ERROR_MESSAGE));
-                }
-                return currentOptions.enqueueScopedClose(flowHandleId);
-            },
-            reportCommandError: (error) => {
-                const currentOptions = flowRunControllerOptionsRef.current;
-                if (!currentOptions) {
-                    return;
-                }
-                currentOptions.reportCommandError(error);
-            },
-        });
-        flowRunsRef.current.set(normalizedFlowId, created);
-        return created;
-    }, []);
-    const handleWidgetReady = useCallback((event) => {
-        const readyResult = markReady(event, {
-            hasDeliveredPendingCommands: hasDeliveredPendingCommands(),
-        });
-        if (readyResult.alreadySeen) {
-            return false;
-        }
-        let didReissueDeliveredCommands = false;
-        if (readyResult.didResetHostEpoch) {
-            clearStartupQueuedKey();
-            clearIdleFlowHandles();
-            didReissueDeliveredCommands = reissueDeliveredPendingActionCommands();
-        }
-        setWidgetHostVisibility((visibility) => readyResult.didResetHostEpoch
-            ? HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY
-            : toReadyVisibility(visibility, event));
-        enqueueStartupCommands({ force: readyResult.previousReady !== null });
-        startPendingCommandTimeouts();
-        return didReissueDeliveredCommands;
-    }, [
-        enqueueStartupCommands,
-        clearStartupQueuedKey,
-        clearIdleFlowHandles,
-        hasDeliveredPendingCommands,
-        markReady,
-        reissueDeliveredPendingActionCommands,
-        startPendingCommandTimeouts,
-        toReadyVisibility,
-    ]);
-    const handleWidgetReadyStateChange = useCallback((event) => {
-        if (event.isReady) {
-            const didReissueDeliveredCommands = handleWidgetReady({
-                readySequence: event.readySequence,
-                sourceKey: event.sourceKey,
-            });
-            return {
-                deferNativeMessageInjection: didReissueDeliveredCommands,
-            };
-        }
-        const notReadyResult = markNotReady();
-        if (notReadyResult.wasReady) {
-            clearStartupQueuedKey();
-            clearIdleFlowHandles();
-            reissueDeliveredPendingActionCommands();
-        }
-        setWidgetHostVisibility(HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY);
-        pausePendingCommandTimeouts();
-    }, [
-        clearStartupQueuedKey,
-        clearIdleFlowHandles,
-        handleWidgetReady,
-        markNotReady,
-        pausePendingCommandTimeouts,
-        reissueDeliveredPendingActionCommands,
-    ]);
-    const handleFlowHandleInvalidated = useCallback((flowHandleId) => {
-        for (const flowRun of flowRunsRef.current.values()) {
-            if (flowRun.hasFlowHandleId(flowHandleId)) {
-                flowRun.invalidateResolvedHandle(flowHandleId);
-            }
-        }
-        setWidgetHostVisibility((visibility) => clearFlowHandleFromVisibility(visibility, flowHandleId));
-    }, [clearFlowHandleFromVisibility]);
-    const handleWebMessage = useCallback((message) => {
-        if (message.kind === "hostEvent" &&
-            message.event.name === "instance:handle:invalidated" &&
-            message.event.detail.handleKind === "flow") {
-            handleFlowHandleInvalidated(message.event.detail.handleId);
-        }
-        if (message.kind === "hostEvent" &&
-            message.event.name === "instance:view-host:snapshots-changed") {
-            const visibility = replaceViewHostSnapshots(message.event.detail, instanceId);
-            if (visibility) {
-                setWidgetHostVisibility(visibility);
-            }
-        }
-        if (message.kind === "hostEvent" &&
-            message.event.name === "instance:command:settled") {
-            const requestId = message.event.detail.requestId;
-            const pendingCommand = getPendingCommand(requestId);
-            if (pendingCommand) {
-                if (pendingCommand.hostEpoch !== null &&
-                    pendingCommand.hostEpoch !== getCurrentHostEpoch()) {
-                    onWebMessage === null || onWebMessage === void 0 ? void 0 : onWebMessage(message);
-                    return;
-                }
-                takePendingCommand(requestId);
-                removeNativeMessageId(pendingCommand.messageId);
-                if (pendingCommand.timeout) {
-                    clearTimeout(pendingCommand.timeout);
-                }
-                const error = toCommandSettlementError(message.event);
-                if (error) {
-                    if (pendingCommand.isStartup) {
-                        clearStartupQueuedKey();
-                    }
-                    pendingCommand.reject(error);
-                }
-                else {
-                    const settlement = message.event
-                        .detail;
-                    if (pendingCommand.result.envelope.command.kind === "reset") {
-                        resetFlowRuns();
-                    }
-                    const settledResult = Object.assign(Object.assign({}, pendingCommand.result), { settlement, settlementResult: settlement.result });
-                    pendingCommand.resolve(settledResult);
-                }
-            }
-        }
-        onWebMessage === null || onWebMessage === void 0 ? void 0 : onWebMessage(message);
-    }, [
-        clearStartupQueuedKey,
-        resetFlowRuns,
-        getCurrentHostEpoch,
-        getPendingCommand,
-        handleFlowHandleInvalidated,
-        instanceId,
-        onWebMessage,
-        replaceViewHostSnapshots,
-        removeNativeMessageId,
-        takePendingCommand,
-    ]);
-    useEffect(() => () => {
-        flowRunControllerOptionsRef.current = null;
-        disposeCommandTransport(new Error(PROVIDER_UNMOUNTED_ERROR_MESSAGE));
-    }, [disposeCommandTransport]);
-    const getNativeMessages = useCallback(() => nativeMessagesRef.current, [nativeMessagesRef]);
-    const contextValue = useMemo(() => {
-        const client = createNativeProviderClient({
-            dispatchCommand: enqueueCommand,
-            flow,
-            instanceId,
-        });
-        return {
-            close: client.close,
-            configure: client.configure,
-            emitHostSignal: client.emitHostSignal,
-            enqueueCommand,
-            flow: client.flow,
-            handleWebMessage,
-            identify: client.identify,
-            instanceId: client.instanceId,
-            get nativeMessages() {
-                return getNativeMessages();
-            },
-            reset: client.reset,
-            track: client.track,
-            updateHostContext: client.updateHostContext,
-        };
-    }, [enqueueCommand, flow, getNativeMessages, handleWebMessage, instanceId]);
-    const previousSheetHostLayoutUpdateRef = useRef(undefined);
-    const consumedTransitionPolicySequenceRef = useRef(undefined);
-    useEffect(() => {
-        resetStartupQueuedKeyIfChanged(startupOptionsKey);
-        enqueueStartupCommands();
-    }, [
-        enqueueStartupCommands,
-        resetStartupQueuedKeyIfChanged,
-        startupOptionsKey,
-    ]);
-    const providerHostViewport = hostViewport !== null && hostViewport !== void 0 ? hostViewport : resolvedHostViewport;
-    const transitionPolicySequence = widgetHostVisibility.transitionPolicySequence;
-    const pendingTransitionPolicy = transitionPolicySequence !== undefined &&
-        consumedTransitionPolicySequenceRef.current !== transitionPolicySequence
-        ? widgetHostVisibility.transitionPolicy
-        : undefined;
-    const sheetHostLayoutPlan = toProviderWidgetSheetHostLayoutPlan({
-        previous: previousSheetHostLayoutUpdateRef.current,
-        viewport: providerHostViewport,
-        flowSize: {
-            height: widgetHostVisibility.flowHeight,
-        },
-        nowMs: getWidgetLayoutPlanNowMs(),
-        transitionPolicy: pendingTransitionPolicy,
-    });
-    useEffect(() => {
-        if (transitionPolicySequence !== undefined &&
-            pendingTransitionPolicy !== undefined &&
-            sheetHostLayoutPlan !== undefined) {
-            consumedTransitionPolicySequenceRef.current = transitionPolicySequence;
-        }
-    }, [pendingTransitionPolicy, sheetHostLayoutPlan, transitionPolicySequence]);
-    let sheetHostLayoutUpdate;
-    if (sheetHostLayoutPlan) {
-        switch (sheetHostLayoutPlan.kind) {
-            case "unchanged":
-                sheetHostLayoutUpdate =
-                    (_a = previousSheetHostLayoutUpdateRef.current) !== null && _a !== void 0 ? _a : sheetHostLayoutPlan.update;
-                break;
-            case "instant": {
-                const previousSheetHostLayoutUpdate = previousSheetHostLayoutUpdateRef.current;
-                sheetHostLayoutUpdate =
-                    pendingTransitionPolicy === undefined &&
-                        (previousSheetHostLayoutUpdate === null || previousSheetHostLayoutUpdate === void 0 ? void 0 : previousSheetHostLayoutUpdate.transition.kind) === "timed" &&
-                        previousSheetHostLayoutUpdate.size.height ===
-                            sheetHostLayoutPlan.size.height
-                        ? Object.assign(Object.assign({}, previousSheetHostLayoutUpdate), { size: sheetHostLayoutPlan.size }) : sheetHostLayoutPlan.update;
-                break;
-            }
-            case "timed":
-                sheetHostLayoutUpdate = sheetHostLayoutPlan.update;
-                break;
-            default: {
-                const unreachable = sheetHostLayoutPlan;
-                throw new Error(`Unsupported widget layout transition plan: ${JSON.stringify(unreachable)}`);
-            }
-        }
-    }
-    const isWidgetHostVisible = resolveIsWidgetHostVisible(widgetHostVisibility, sheetHostLayoutUpdate !== undefined);
-    useEffect(() => {
-        previousSheetHostLayoutUpdateRef.current = isWidgetHostVisible
-            ? sheetHostLayoutUpdate
-            : undefined;
-    }, [isWidgetHostVisible, sheetHostLayoutUpdate]);
-    const widgetHostViewport = providerHostViewport;
-    const composedWebViewStyle = toProviderWidgetHostStyle({
-        isVisible: isWidgetHostVisible,
-        webViewStyle: webViewProps === null || webViewProps === void 0 ? void 0 : webViewProps.style,
-    });
-    const widgetHost = createElement(WidgetHost, {
-        hostViewport: widgetHostViewport,
-        instanceId,
-        loaderUrl,
-        nativeMessages,
-        onInvalidWebMessage,
-        onReadyStateChange: handleWidgetReadyStateChange,
-        onWebMessage: handleWebMessage,
-        source,
-        webViewComponent,
-        webViewProps: Object.assign(Object.assign({}, webViewProps), { pointerEvents: isWidgetHostVisible ? "auto" : "none", style: composedWebViewStyle }),
-    });
-    const handleWidgetHostDismiss = useCallback(() => {
-        enqueueCommand(Object.assign({ kind: "close" }, (widgetHostVisibility.flowHandleId === undefined
-            ? {}
-            : { flowHandleId: widgetHostVisibility.flowHandleId }))).catch(reportCommandError);
-    }, [enqueueCommand, reportCommandError, widgetHostVisibility.flowHandleId]);
-    return createElement(GetUserFeedbackNativeContext.Provider, {
-        value: contextValue,
-    }, children, createElement(ProviderWidgetHostOverlay, {
-        frameAppearance: widgetHostVisibility.frameAppearance,
-        isVisible: isWidgetHostVisible,
-        nativeView: NativeView,
-        onRequestDismiss: handleWidgetHostDismiss,
-        sheetHostLayoutUpdate,
-        transitionSequence: transitionPolicySequence,
-        transitionSchedule: widgetHostVisibility.transitionSchedule,
-    }, widgetHost));
-}
-export function useGetUserFeedbackNative() {
-    const context = useContext(GetUserFeedbackNativeContext);
-    if (context === null) {
-        throw new Error("useGetUserFeedbackNative must be used within GetUserFeedbackProvider");
-    }
-    return context;
-}
-export const useGetUserFeedback = useGetUserFeedbackNative;

package/dist/provider-command-transport.d.ts

@@ -1,52 +0,0 @@
-import type { WebViewTransportNativeMessage } from "@getuserfeedback/protocol/webview-transport";
-import { type ProviderPendingCommand } from "./provider-pending-commands.js";
-export type ProviderCommandTransportOptions = {
-    commandTimeoutMs: number;
-    createTimeoutError: (requestId: string) => Error;
-    getCurrentHostEpoch: () => number | null;
-};
-type ProviderPendingCommandRegistration<Result> = {
-    isStartup: boolean;
-    message: WebViewTransportNativeMessage;
-    requestId: string;
-    result: Result;
-};
-type ProviderPendingCommandReissue<Result> = {
-    nextMessage: WebViewTransportNativeMessage;
-    nextRequestId: string;
-    nextResult: Result;
-    requestId: string;
-};
-export type ProviderCommandTransport<Result> = {
-    clearStartupQueuedKey: () => void;
-    createPendingCommandPromise: (input: ProviderPendingCommandRegistration<Result>) => Promise<Result>;
-    dispose: (error: Error) => void;
-    getPendingCommand: (requestId: string) => ProviderPendingCommand<Result> | undefined;
-    getPendingCommandEntries: () => Array<[
-        string,
-        ProviderPendingCommand<Result>
-    ]>;
-    hasDeliveredPendingCommands: () => boolean;
-    isStartupQueuedKey: (key: string) => boolean;
-    nativeMessages: WebViewTransportNativeMessage[];
-    nativeMessagesRef: {
-        current: WebViewTransportNativeMessage[];
-    };
-    pausePendingCommandTimeouts: () => void;
-    registerNativeMessage: (message: WebViewTransportNativeMessage, options: {
-        isStartup: boolean;
-        prioritizeStartup: boolean;
-    }) => void;
-    reissuePendingCommand: (input: ProviderPendingCommandReissue<Result>) => {
-        previousMessageId: string;
-    } | null;
-    removeNativeMessageId: (messageId: string) => void;
-    replaceNativeMessages: (replacements: ReadonlyMap<string, WebViewTransportNativeMessage>) => void;
-    resetStartupQueuedKeyIfChanged: (key: string) => void;
-    setStartupQueuedKey: (key: string) => void;
-    startPendingCommandTimeouts: () => void;
-    takePendingCommand: (requestId: string) => ProviderPendingCommand<Result> | undefined;
-    cancelStartupCommands: (error: Error) => void;
-};
-export declare function useProviderCommandTransport<Result>({ commandTimeoutMs, createTimeoutError, getCurrentHostEpoch, }: ProviderCommandTransportOptions): ProviderCommandTransport<Result>;
-export {};