@getuserfeedback/react-native 4.0.31 → 5.0.7

package/dist/provider-command-transport.js

@@ -1,150 +0,0 @@
-import { useCallback, useRef, useState } from "react";
-import { enqueueProviderNativeMessage, removeProviderNativeMessageId, removeProviderNativeMessageIds, replaceProviderNativeMessages, } from "./provider-message-queue.js";
-import { cancelProviderStartupCommands, clearProviderPendingCommands, createProviderPendingCommandRegistry, getProviderPendingCommand, getProviderPendingCommandEntries, getProviderPendingCommands, hasDeliveredProviderPendingCommands, isProviderPendingMessageStartup, registerProviderPendingCommand, reissueProviderPendingCommand, takeProviderPendingCommand, } from "./provider-pending-commands.js";
-export function useProviderCommandTransport({ commandTimeoutMs, createTimeoutError, getCurrentHostEpoch, }) {
-    const [nativeMessages, setNativeMessages] = useState([]);
-    const nativeMessagesRef = useRef([]);
-    const pendingCommandsRef = useRef(createProviderPendingCommandRegistry());
-    const startupQueuedKeyRef = useRef(null);
-    nativeMessagesRef.current = nativeMessages;
-    const removeNativeMessageId = useCallback((messageId) => {
-        setNativeMessages((messages) => removeProviderNativeMessageId(messages, messageId));
-    }, []);
-    const removeNativeMessageIds = useCallback((messageIds) => {
-        setNativeMessages((messages) => removeProviderNativeMessageIds(messages, messageIds));
-    }, []);
-    const rejectPendingCommand = useCallback((requestId, pendingCommand, error) => {
-        takeProviderPendingCommand(pendingCommandsRef.current, requestId);
-        if (pendingCommand.timeout) {
-            clearTimeout(pendingCommand.timeout);
-            pendingCommand.timeout = null;
-        }
-        if (pendingCommand.isStartup) {
-            startupQueuedKeyRef.current = null;
-        }
-        removeNativeMessageId(pendingCommand.messageId);
-        pendingCommand.reject(error);
-    }, [removeNativeMessageId]);
-    const startPendingCommandTimeout = useCallback((requestId, pendingCommand) => {
-        pendingCommand.hostEpoch = getCurrentHostEpoch();
-        if (commandTimeoutMs <= 0) {
-            return;
-        }
-        if (pendingCommand.timeout) {
-            clearTimeout(pendingCommand.timeout);
-        }
-        pendingCommand.timeout = setTimeout(() => {
-            rejectPendingCommand(requestId, pendingCommand, createTimeoutError(requestId));
-        }, commandTimeoutMs);
-    }, [
-        commandTimeoutMs,
-        createTimeoutError,
-        getCurrentHostEpoch,
-        rejectPendingCommand,
-    ]);
-    const startPendingCommandTimeouts = useCallback(() => {
-        for (const [requestId, pendingCommand] of getProviderPendingCommandEntries(pendingCommandsRef.current)) {
-            startPendingCommandTimeout(requestId, pendingCommand);
-        }
-    }, [startPendingCommandTimeout]);
-    const pausePendingCommandTimeouts = useCallback(() => {
-        for (const pendingCommand of getProviderPendingCommands(pendingCommandsRef.current)) {
-            if (!pendingCommand.timeout) {
-                continue;
-            }
-            clearTimeout(pendingCommand.timeout);
-            pendingCommand.timeout = null;
-        }
-    }, []);
-    const createPendingCommandPromise = useCallback(({ isStartup, message, requestId, result, }) => new Promise((resolve, reject) => {
-        const pendingCommand = {
-            hostEpoch: null,
-            isStartup,
-            messageId: message.id,
-            reject,
-            resolve,
-            result,
-            timeout: null,
-        };
-        registerProviderPendingCommand(pendingCommandsRef.current, requestId, pendingCommand);
-        if (getCurrentHostEpoch() !== null) {
-            startPendingCommandTimeout(requestId, pendingCommand);
-        }
-    }), [getCurrentHostEpoch, startPendingCommandTimeout]);
-    const registerNativeMessage = useCallback((message, options) => {
-        setNativeMessages((messages) => enqueueProviderNativeMessage(messages, Object.assign(Object.assign({}, options), { isStartupMessage: (entry) => isProviderPendingMessageStartup(pendingCommandsRef.current, entry.envelope.requestId), message })));
-    }, []);
-    const replaceNativeMessages = useCallback((replacements) => {
-        setNativeMessages((messages) => replaceProviderNativeMessages(messages, replacements));
-    }, []);
-    const reissuePendingCommand = useCallback(({ nextMessage, nextRequestId, nextResult, requestId, }) => {
-        const reissuedCommand = reissueProviderPendingCommand(pendingCommandsRef.current, {
-            nextMessageId: nextMessage.id,
-            nextRequestId,
-            nextResult,
-            requestId,
-        });
-        return reissuedCommand
-            ? { previousMessageId: reissuedCommand.previousMessageId }
-            : null;
-    }, []);
-    const cancelStartupCommands = useCallback((error) => {
-        const canceled = cancelProviderStartupCommands(pendingCommandsRef.current);
-        for (const pendingCommand of canceled.commands) {
-            if (pendingCommand.timeout) {
-                clearTimeout(pendingCommand.timeout);
-            }
-            pendingCommand.reject(error);
-        }
-        if (canceled.messageIds.size > 0) {
-            removeNativeMessageIds(canceled.messageIds);
-        }
-    }, [removeNativeMessageIds]);
-    const dispose = useCallback((error) => {
-        for (const pendingCommand of getProviderPendingCommands(pendingCommandsRef.current)) {
-            if (pendingCommand.timeout) {
-                clearTimeout(pendingCommand.timeout);
-            }
-            pendingCommand.reject(error);
-        }
-        clearProviderPendingCommands(pendingCommandsRef.current);
-        startupQueuedKeyRef.current = null;
-    }, []);
-    const clearStartupQueuedKey = useCallback(() => {
-        startupQueuedKeyRef.current = null;
-    }, []);
-    const getPendingCommand = useCallback((requestId) => getProviderPendingCommand(pendingCommandsRef.current, requestId), []);
-    const getPendingCommandEntries = useCallback(() => getProviderPendingCommandEntries(pendingCommandsRef.current), []);
-    const hasDeliveredPendingCommands = useCallback(() => hasDeliveredProviderPendingCommands(pendingCommandsRef.current), []);
-    const isStartupQueuedKey = useCallback((key) => startupQueuedKeyRef.current === key, []);
-    const resetStartupQueuedKeyIfChanged = useCallback((key) => {
-        if (startupQueuedKeyRef.current !== key) {
-            startupQueuedKeyRef.current = null;
-        }
-    }, []);
-    const setStartupQueuedKey = useCallback((key) => {
-        startupQueuedKeyRef.current = key;
-    }, []);
-    const takePendingCommand = useCallback((requestId) => takeProviderPendingCommand(pendingCommandsRef.current, requestId), []);
-    return {
-        cancelStartupCommands,
-        clearStartupQueuedKey,
-        createPendingCommandPromise,
-        dispose,
-        getPendingCommand,
-        getPendingCommandEntries,
-        hasDeliveredPendingCommands,
-        isStartupQueuedKey,
-        nativeMessages,
-        nativeMessagesRef,
-        pausePendingCommandTimeouts,
-        registerNativeMessage,
-        reissuePendingCommand,
-        removeNativeMessageId,
-        replaceNativeMessages,
-        resetStartupQueuedKeyIfChanged,
-        setStartupQueuedKey,
-        startPendingCommandTimeouts,
-        takePendingCommand,
-    };
-}

package/dist/provider-message-queue.d.ts

@@ -1,11 +0,0 @@
-import type { WebViewTransportNativeMessage } from "@getuserfeedback/protocol/webview-transport";
-export type ProviderNativeMessageQueue = readonly WebViewTransportNativeMessage[];
-export declare function enqueueProviderNativeMessage(messages: ProviderNativeMessageQueue, { isStartup, isStartupMessage, message, prioritizeStartup, }: {
-    isStartup: boolean;
-    isStartupMessage: (message: WebViewTransportNativeMessage) => boolean;
-    message: WebViewTransportNativeMessage;
-    prioritizeStartup: boolean;
-}): WebViewTransportNativeMessage[];
-export declare function removeProviderNativeMessageIds(messages: ProviderNativeMessageQueue, messageIds: ReadonlySet<string>): WebViewTransportNativeMessage[];
-export declare function removeProviderNativeMessageId(messages: ProviderNativeMessageQueue, messageId: string): WebViewTransportNativeMessage[];
-export declare function replaceProviderNativeMessages(messages: ProviderNativeMessageQueue, replacementsByMessageId: ReadonlyMap<string, WebViewTransportNativeMessage>): WebViewTransportNativeMessage[];

package/dist/provider-message-queue.js

@@ -1,23 +0,0 @@
-export function enqueueProviderNativeMessage(messages, { isStartup, isStartupMessage, message, prioritizeStartup, }) {
-    if (!(isStartup && prioritizeStartup)) {
-        return [...messages, message];
-    }
-    const firstActionIndex = messages.findIndex((entry) => !isStartupMessage(entry));
-    if (firstActionIndex === -1) {
-        return [...messages, message];
-    }
-    return [
-        ...messages.slice(0, firstActionIndex),
-        message,
-        ...messages.slice(firstActionIndex),
-    ];
-}
-export function removeProviderNativeMessageIds(messages, messageIds) {
-    return messages.filter((entry) => !messageIds.has(entry.id));
-}
-export function removeProviderNativeMessageId(messages, messageId) {
-    return removeProviderNativeMessageIds(messages, new Set([messageId]));
-}
-export function replaceProviderNativeMessages(messages, replacementsByMessageId) {
-    return messages.map((message) => { var _a; return (_a = replacementsByMessageId.get(message.id)) !== null && _a !== void 0 ? _a : message; });
-}

package/dist/provider-pending-commands.d.ts

@@ -1,34 +0,0 @@
-export type ProviderPendingCommand<Result> = {
-    hostEpoch: number | null;
-    isStartup: boolean;
-    messageId: string;
-    reject: (error: Error) => void;
-    resolve: (result: Result) => void;
-    result: Result;
-    timeout: ReturnType<typeof setTimeout> | null;
-};
-export type ProviderPendingCommandRegistry<Result> = Map<string, ProviderPendingCommand<Result>>;
-export type ProviderCanceledStartupCommands<Result> = {
-    commands: ProviderPendingCommand<Result>[];
-    messageIds: Set<string>;
-};
-export type ProviderReissuedPendingCommand<Result> = {
-    command: ProviderPendingCommand<Result>;
-    previousMessageId: string;
-};
-export declare function createProviderPendingCommandRegistry<Result>(): ProviderPendingCommandRegistry<Result>;
-export declare function registerProviderPendingCommand<Result>(registry: ProviderPendingCommandRegistry<Result>, requestId: string, command: ProviderPendingCommand<Result>): void;
-export declare function getProviderPendingCommand<Result>(registry: ProviderPendingCommandRegistry<Result>, requestId: string): ProviderPendingCommand<Result> | undefined;
-export declare function takeProviderPendingCommand<Result>(registry: ProviderPendingCommandRegistry<Result>, requestId: string): ProviderPendingCommand<Result> | undefined;
-export declare function hasDeliveredProviderPendingCommands<Result>(registry: ProviderPendingCommandRegistry<Result>): boolean;
-export declare function isProviderPendingMessageStartup<Result>(registry: ProviderPendingCommandRegistry<Result>, requestId: string): boolean;
-export declare function getProviderPendingCommandEntries<Result>(registry: ProviderPendingCommandRegistry<Result>): Array<[string, ProviderPendingCommand<Result>]>;
-export declare function getProviderPendingCommands<Result>(registry: ProviderPendingCommandRegistry<Result>): ProviderPendingCommand<Result>[];
-export declare function cancelProviderStartupCommands<Result>(registry: ProviderPendingCommandRegistry<Result>): ProviderCanceledStartupCommands<Result>;
-export declare function reissueProviderPendingCommand<Result>(registry: ProviderPendingCommandRegistry<Result>, { nextMessageId, nextRequestId, nextResult, requestId, }: {
-    nextMessageId: string;
-    nextRequestId: string;
-    nextResult: Result;
-    requestId: string;
-}): ProviderReissuedPendingCommand<Result> | null;
-export declare function clearProviderPendingCommands<Result>(registry: ProviderPendingCommandRegistry<Result>): void;

package/dist/provider-pending-commands.js

@@ -1,58 +0,0 @@
-export function createProviderPendingCommandRegistry() {
-    return new Map();
-}
-export function registerProviderPendingCommand(registry, requestId, command) {
-    registry.set(requestId, command);
-}
-export function getProviderPendingCommand(registry, requestId) {
-    return registry.get(requestId);
-}
-export function takeProviderPendingCommand(registry, requestId) {
-    const command = registry.get(requestId);
-    if (command) {
-        registry.delete(requestId);
-    }
-    return command;
-}
-export function hasDeliveredProviderPendingCommands(registry) {
-    return [...registry.values()].some((command) => command.hostEpoch !== null);
-}
-export function isProviderPendingMessageStartup(registry, requestId) {
-    var _a;
-    return ((_a = registry.get(requestId)) === null || _a === void 0 ? void 0 : _a.isStartup) === true;
-}
-export function getProviderPendingCommandEntries(registry) {
-    return [...registry.entries()];
-}
-export function getProviderPendingCommands(registry) {
-    return [...registry.values()];
-}
-export function cancelProviderStartupCommands(registry) {
-    const commands = [];
-    const messageIds = new Set();
-    for (const [requestId, command] of registry) {
-        if (!command.isStartup) {
-            continue;
-        }
-        registry.delete(requestId);
-        commands.push(command);
-        messageIds.add(command.messageId);
-    }
-    return { commands, messageIds };
-}
-export function reissueProviderPendingCommand(registry, { nextMessageId, nextRequestId, nextResult, requestId, }) {
-    const command = registry.get(requestId);
-    if (!command || command.isStartup || command.hostEpoch === null) {
-        return null;
-    }
-    registry.delete(requestId);
-    const previousMessageId = command.messageId;
-    command.hostEpoch = null;
-    command.messageId = nextMessageId;
-    command.result = nextResult;
-    registry.set(nextRequestId, command);
-    return { command, previousMessageId };
-}
-export function clearProviderPendingCommands(registry) {
-    registry.clear();
-}

package/dist/provider-widget-border-radius.d.ts

@@ -1,11 +0,0 @@
-import type { WidgetFrameResolvedBorderRadius } from "@getuserfeedback/protocol/host";
-type ProviderWidgetFrameSize = {
-    height: number;
-    width: number;
-};
-export declare function safeParseProviderWidgetCanonicalTopRadii(value: string): {
-    topLeft: number;
-    topRight: number;
-} | undefined;
-export declare function resolveProviderWidgetCanonicalBorderRadius(value: string, frameSize: ProviderWidgetFrameSize): WidgetFrameResolvedBorderRadius | undefined;
-export {};

package/dist/provider-widget-border-radius.js

@@ -1,102 +0,0 @@
-import { safeParseNativeWidgetCanonicalRadii } from "./native-widget-corner-radii.js";
-const CANONICAL_RADIUS_COMPONENT_PATTERN = /^((?:\d+(?:\.\d+)?|\.\d+))(px|%)$/;
-export function safeParseProviderWidgetCanonicalTopRadii(value) {
-    if (value !== value.trim()) {
-        return undefined;
-    }
-    const radii = safeParseNativeWidgetCanonicalRadii(value);
-    return radii === undefined
-        ? undefined
-        : { topLeft: radii.topLeft, topRight: radii.topRight };
-}
-const parseCanonicalRadiusComponent = (value) => {
-    var _a;
-    const match = CANONICAL_RADIUS_COMPONENT_PATTERN.exec(value);
-    if (match === null) {
-        return undefined;
-    }
-    const parsed = Number.parseFloat((_a = match[1]) !== null && _a !== void 0 ? _a : "");
-    const unit = match[2];
-    return Number.isFinite(parsed) && (unit === "px" || unit === "%")
-        ? { unit, value: parsed }
-        : undefined;
-};
-const expandRadiusComponents = (values) => {
-    const [topLeft, topRight, bottomRight, bottomLeft] = values;
-    if (topLeft === undefined || values.length > 4) {
-        return undefined;
-    }
-    if (values.length === 1) {
-        return [topLeft, topLeft, topLeft, topLeft];
-    }
-    if (topRight === undefined) {
-        return undefined;
-    }
-    if (values.length === 2) {
-        return [topLeft, topRight, topLeft, topRight];
-    }
-    if (bottomRight === undefined) {
-        return undefined;
-    }
-    if (values.length === 3) {
-        return [topLeft, topRight, bottomRight, topRight];
-    }
-    return bottomLeft === undefined
-        ? undefined
-        : [topLeft, topRight, bottomRight, bottomLeft];
-};
-const parseCanonicalRadiusComponents = (value) => {
-    const components = value
-        .trim()
-        .split(/\s+/)
-        .map(parseCanonicalRadiusComponent);
-    return components.some((component) => component === undefined)
-        ? undefined
-        : expandRadiusComponents(components);
-};
-const resolveCanonicalRadiusComponent = (component, basis) => component.unit === "%" ? (component.value / 100) * basis : component.value;
-const toRadiusOverlapRatio = (limit, first, second) => {
-    const max = Math.max(first, second);
-    return max === 0 ? 1 : limit / max / (first / max + second / max);
-};
-export function resolveProviderWidgetCanonicalBorderRadius(value, frameSize) {
-    var _a, _b, _c;
-    if (!Number.isFinite(frameSize.width) ||
-        frameSize.width < 0 ||
-        !Number.isFinite(frameSize.height) ||
-        frameSize.height < 0) {
-        return undefined;
-    }
-    const axes = value.split("/");
-    if (axes.length > 2) {
-        return undefined;
-    }
-    const horizontal = parseCanonicalRadiusComponents((_a = axes[0]) !== null && _a !== void 0 ? _a : "");
-    const vertical = parseCanonicalRadiusComponents((_c = (_b = axes[1]) !== null && _b !== void 0 ? _b : axes[0]) !== null && _c !== void 0 ? _c : "");
-    if (horizontal === undefined || vertical === undefined) {
-        return undefined;
-    }
-    const resolveCorner = (index) => ({
-        horizontalPx: resolveCanonicalRadiusComponent(horizontal[index], frameSize.width),
-        verticalPx: resolveCanonicalRadiusComponent(vertical[index], frameSize.height),
-    });
-    const topLeft = resolveCorner(0);
-    const topRight = resolveCorner(1);
-    const bottomRight = resolveCorner(2);
-    const bottomLeft = resolveCorner(3);
-    if ([topLeft, topRight, bottomRight, bottomLeft].some((corner) => !Number.isFinite(corner.horizontalPx) ||
-        !Number.isFinite(corner.verticalPx))) {
-        return undefined;
-    }
-    const overlapScale = Math.min(1, toRadiusOverlapRatio(frameSize.width, topLeft.horizontalPx, topRight.horizontalPx), toRadiusOverlapRatio(frameSize.width, bottomLeft.horizontalPx, bottomRight.horizontalPx), toRadiusOverlapRatio(frameSize.height, topLeft.verticalPx, bottomLeft.verticalPx), toRadiusOverlapRatio(frameSize.height, topRight.verticalPx, bottomRight.verticalPx));
-    const scaleCorner = (corner) => ({
-        horizontalPx: corner.horizontalPx * overlapScale,
-        verticalPx: corner.verticalPx * overlapScale,
-    });
-    return {
-        topLeft: scaleCorner(topLeft),
-        topRight: scaleCorner(topRight),
-        bottomRight: scaleCorner(bottomRight),
-        bottomLeft: scaleCorner(bottomLeft),
-    };
-}

package/dist/provider-widget-frame-appearance.d.ts

@@ -1,17 +0,0 @@
-import type { WidgetFrameAppearance } from "@getuserfeedback/protocol/host";
-import { type NativeWidgetFrameBorderStyle } from "./native-widget-frame-border.js";
-import { type NativeWidgetFrameShadowProjection } from "./native-widget-frame-shadow.js";
-type ProviderWidgetFrameShadowProjection = NativeWidgetFrameShadowProjection | {
-    kind: "legacy";
-};
-export type ProviderWidgetFrameAppearanceProjection = {
-    borderStyle?: NativeWidgetFrameBorderStyle;
-    shadow: ProviderWidgetFrameShadowProjection;
-    topLeftRadius: number;
-    topRightRadius: number;
-};
-export declare function toProviderWidgetFrameAppearance(appearance?: WidgetFrameAppearance, nativeSheetSize?: {
-    height: number;
-    width: number;
-}): ProviderWidgetFrameAppearanceProjection;
-export {};

package/dist/provider-widget-frame-appearance.js

@@ -1,43 +0,0 @@
-import { toNativeWidgetConservativeResolvedCornerRadii } from "./native-widget-corner-radii.js";
-import { toNativeWidgetResolvedBorderStyle, } from "./native-widget-frame-border.js";
-import { toNativeWidgetFrameShadow, } from "./native-widget-frame-shadow.js";
-import { resolveProviderWidgetCanonicalBorderRadius, safeParseProviderWidgetCanonicalTopRadii, } from "./provider-widget-border-radius.js";
-const LEGACY_WIDGET_SHEET_RADIUS = 24;
-const toProviderWidgetConservativeResolvedTopRadii = (radius) => {
-    const resolved = toNativeWidgetConservativeResolvedCornerRadii(radius);
-    return { topLeft: resolved.topLeft, topRight: resolved.topRight };
-};
-export function toProviderWidgetFrameAppearance(appearance, nativeSheetSize) {
-    var _a, _b;
-    if (appearance === undefined) {
-        return {
-            shadow: { kind: "legacy" },
-            topLeftRadius: LEGACY_WIDGET_SHEET_RADIUS,
-            topRightRadius: LEGACY_WIDGET_SHEET_RADIUS,
-        };
-    }
-    if (appearance.kind === "none") {
-        return {
-            borderStyle: toNativeWidgetResolvedBorderStyle(),
-            shadow: toNativeWidgetFrameShadow(),
-            topLeftRadius: 0,
-            topRightRadius: 0,
-        };
-    }
-    // Percentage radii depend on the host-owned sheet box, which can differ from
-    // the view's reported plan. Browser-only expressions keep the structured fallback.
-    const nativeResolvedRadius = nativeSheetSize === undefined || !appearance.borderRadius.includes("%")
-        ? undefined
-        : resolveProviderWidgetCanonicalBorderRadius(appearance.borderRadius, nativeSheetSize);
-    const radius = nativeResolvedRadius !== undefined
-        ? toProviderWidgetConservativeResolvedTopRadii(nativeResolvedRadius)
-        : appearance.resolvedBorderRadius === undefined
-            ? safeParseProviderWidgetCanonicalTopRadii(appearance.borderRadius)
-            : toProviderWidgetConservativeResolvedTopRadii(appearance.resolvedBorderRadius);
-    return {
-        borderStyle: toNativeWidgetResolvedBorderStyle(appearance.resolvedBorder),
-        shadow: toNativeWidgetFrameShadow(appearance.resolvedBoxShadow),
-        topLeftRadius: (_a = radius === null || radius === void 0 ? void 0 : radius.topLeft) !== null && _a !== void 0 ? _a : 0,
-        topRightRadius: (_b = radius === null || radius === void 0 ? void 0 : radius.topRight) !== null && _b !== void 0 ? _b : 0,
-    };
-}

package/dist/provider-widget-host-lifecycle.d.ts

@@ -1,46 +0,0 @@
-import { type InstanceViewHostSnapshotsChangedDetail, type ViewHostSnapshot, type WidgetFrameAppearance, type WidgetLayoutTransitionPolicy, type WidgetLayoutTransitionSchedule } from "@getuserfeedback/protocol/host";
-type ProviderWidgetHostReadyState = {
-    hostEpoch: number;
-    readySequence: number;
-    sourceKey: string;
-};
-export type ProviderWidgetHostVisibility = {
-    frameAppearance?: WidgetFrameAppearance;
-    flowHeight?: number;
-    flowHandleId?: string;
-    hostSourceVersion: number | null;
-    isVisible: boolean;
-    readySequence: number | null;
-    sourceKey: string | null;
-    transitionPolicy?: WidgetLayoutTransitionPolicy;
-    transitionSchedule?: WidgetLayoutTransitionSchedule;
-    transitionPolicySequence?: number;
-};
-export declare const HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY: ProviderWidgetHostVisibility;
-export type ProviderWidgetHostLifecycleController = {
-    clearFlowHandleFromVisibility: (visibility: ProviderWidgetHostVisibility, flowHandleId: string) => ProviderWidgetHostVisibility;
-    getCurrentHostEpoch: () => number | null;
-    getViewHostSnapshots: () => readonly ViewHostSnapshot[];
-    isWidgetHostVisible: (visibility: ProviderWidgetHostVisibility, hasSheetHostViewport: boolean) => boolean;
-    markNotReady: () => {
-        wasReady: boolean;
-    };
-    markReady: (event: {
-        readySequence: number;
-        sourceKey: string;
-    }, options: {
-        hasDeliveredPendingCommands: boolean;
-    }) => {
-        alreadySeen: boolean;
-        didResetHostEpoch: boolean;
-        previousReady: ProviderWidgetHostReadyState | null;
-    };
-    replaceViewHostSnapshots: (detail: InstanceViewHostSnapshotsChangedDetail, instanceId: string) => ProviderWidgetHostVisibility | null;
-    syncHostSourceKey: (hostSourceKey: string) => boolean;
-    toReadyVisibility: (visibility: ProviderWidgetHostVisibility, event: {
-        readySequence: number;
-        sourceKey: string;
-    }) => ProviderWidgetHostVisibility;
-};
-export declare function createProviderWidgetHostLifecycleController(initialHostSourceKey: string): ProviderWidgetHostLifecycleController;
-export {};

package/dist/provider-widget-host-lifecycle.js

@@ -1,138 +0,0 @@
-import { areViewHostSnapshotsEqual, } from "@getuserfeedback/protocol/host";
-import { createActiveViewSnapshotListController } from "./view-orchestration-runtime.js";
-export const HIDDEN_PROVIDER_WIDGET_HOST_VISIBILITY = {
-    hostSourceVersion: null,
-    isVisible: false,
-    readySequence: null,
-    sourceKey: null,
-};
-export function createProviderWidgetHostLifecycleController(initialHostSourceKey) {
-    let hostEpoch = 0;
-    let hostSourceKey = initialHostSourceKey;
-    let hostSourceVersion = 0;
-    let lastReady = null;
-    let transitionPolicySequence = 0;
-    let lastTransitionScheduleSequence;
-    const viewHostSnapshots = createActiveViewSnapshotListController();
-    let selectedViewHostSnapshot;
-    const toVisibility = (snapshot) => {
-        var _a;
-        if (lastReady === null) {
-            return null;
-        }
-        let nextTransitionPolicySequence;
-        const hasNewTransitionSchedule = snapshot.transitionSchedule !== undefined &&
-            (lastTransitionScheduleSequence === undefined ||
-                snapshot.transitionSchedule.sequence > lastTransitionScheduleSequence);
-        if (snapshot.transitionPolicy !== undefined &&
-            (snapshot.transitionSchedule === undefined || hasNewTransitionSchedule)) {
-            transitionPolicySequence += 1;
-            nextTransitionPolicySequence = transitionPolicySequence;
-        }
-        if (hasNewTransitionSchedule) {
-            lastTransitionScheduleSequence = (_a = snapshot.transitionSchedule) === null || _a === void 0 ? void 0 : _a.sequence;
-        }
-        return {
-            frameAppearance: snapshot.frameAppearance,
-            flowHeight: snapshot.height,
-            flowHandleId: snapshot.flowHandleId,
-            hostSourceVersion,
-            isVisible: snapshot.shouldRender,
-            readySequence: lastReady.readySequence,
-            sourceKey: lastReady.sourceKey,
-            transitionPolicy: nextTransitionPolicySequence === undefined
-                ? undefined
-                : snapshot.transitionPolicy,
-            transitionSchedule: hasNewTransitionSchedule
-                ? snapshot.transitionSchedule
-                : undefined,
-            transitionPolicySequence: nextTransitionPolicySequence,
-        };
-    };
-    return {
-        clearFlowHandleFromVisibility: (visibility, flowHandleId) => visibility.flowHandleId === flowHandleId
-            ? Object.assign(Object.assign({}, visibility), { flowHandleId: undefined }) : visibility,
-        getCurrentHostEpoch: () => { var _a; return (_a = lastReady === null || lastReady === void 0 ? void 0 : lastReady.hostEpoch) !== null && _a !== void 0 ? _a : null; },
-        getViewHostSnapshots: () => viewHostSnapshots.getSnapshots(),
-        isWidgetHostVisible: (visibility, hasSheetHostViewport) => visibility.isVisible &&
-            hasSheetHostViewport &&
-            visibility.hostSourceVersion === hostSourceVersion &&
-            visibility.sourceKey === (lastReady === null || lastReady === void 0 ? void 0 : lastReady.sourceKey) &&
-            visibility.readySequence === (lastReady === null || lastReady === void 0 ? void 0 : lastReady.readySequence),
-        markNotReady: () => {
-            const wasReady = lastReady !== null;
-            if (wasReady) {
-                hostEpoch += 1;
-            }
-            lastReady = null;
-            viewHostSnapshots.clear();
-            selectedViewHostSnapshot = undefined;
-            lastTransitionScheduleSequence = undefined;
-            return { wasReady };
-        },
-        markReady: (event, { hasDeliveredPendingCommands }) => {
-            const previousReady = lastReady;
-            const alreadySeen = (previousReady === null || previousReady === void 0 ? void 0 : previousReady.sourceKey) === event.sourceKey &&
-                previousReady.readySequence === event.readySequence;
-            if (alreadySeen) {
-                return {
-                    alreadySeen: true,
-                    didResetHostEpoch: false,
-                    previousReady,
-                };
-            }
-            const didResetHostEpoch = previousReady !== null || hasDeliveredPendingCommands;
-            if (didResetHostEpoch) {
-                hostEpoch += 1;
-                viewHostSnapshots.clear();
-                selectedViewHostSnapshot = undefined;
-                lastTransitionScheduleSequence = undefined;
-            }
-            lastReady = Object.assign(Object.assign({}, event), { hostEpoch });
-            return {
-                alreadySeen: false,
-                didResetHostEpoch,
-                previousReady,
-            };
-        },
-        replaceViewHostSnapshots: (detail, instanceId) => {
-            if (detail.instanceId !== instanceId || lastReady === null) {
-                return null;
-            }
-            viewHostSnapshots.replace(detail.snapshots);
-            const nextSelectedSnapshot = viewHostSnapshots.getSnapshots()[0];
-            if (areViewHostSnapshotsEqual(selectedViewHostSnapshot, nextSelectedSnapshot)) {
-                return null;
-            }
-            selectedViewHostSnapshot = nextSelectedSnapshot;
-            if (!nextSelectedSnapshot) {
-                return toVisibility({
-                    isLoading: false,
-                    isOpen: false,
-                    shouldRender: false,
-                });
-            }
-            return toVisibility(Object.assign(Object.assign({}, nextSelectedSnapshot), { shouldRender: true }));
-        },
-        syncHostSourceKey: (nextHostSourceKey) => {
-            if (hostSourceKey === nextHostSourceKey) {
-                return false;
-            }
-            hostSourceKey = nextHostSourceKey;
-            hostSourceVersion += 1;
-            lastReady = null;
-            viewHostSnapshots.clear();
-            selectedViewHostSnapshot = undefined;
-            lastTransitionScheduleSequence = undefined;
-            return true;
-        },
-        toReadyVisibility: (visibility, event) => {
-            if (!visibility.isVisible ||
-                visibility.sourceKey !== event.sourceKey ||
-                visibility.hostSourceVersion !== hostSourceVersion) {
-                return visibility;
-            }
-            return Object.assign(Object.assign({}, visibility), { readySequence: event.readySequence });
-        },
-    };
-}