@getuserfeedback/react-native 4.0.31 → 5.0.6

package/README.md

@@ -1,170 +1,32 @@
 # @getuserfeedback/react-native
 
-React Native bindings for getuserfeedback.
+In-product surveys for React Native apps, from [getuserfeedback.com](https://getuserfeedback.com).
 
-This package hosts the existing getuserfeedback WebView runtime from React Native and exposes a provider/hook API for enqueueing widget commands from non-ejected Expo or React Native apps.
+## Get started
 
-## Install
+Install the SDK and its WebView peer dependency:
 
 ```bash
 npm install @getuserfeedback/react-native react-native-webview
 ```
 
-Requires React, React Native, and `react-native-webview`.
-
-## API
-
-- `GetUserFeedbackProvider`
-- `useGetUserFeedback`
-- `WidgetHost`
-- `useGetUserFeedbackNative`
+Add the provider near the root of your app. You can find your Public API key in
+[Widget settings](https://getuserfeedback.com/app/_/settings/widget).
 
 ```tsx
-import {
-	GetUserFeedbackProvider,
-	useGetUserFeedback,
-} from "@getuserfeedback/react-native";
-
-function FeedbackActions() {
-	const feedback = useGetUserFeedback();
-
-	return (
-		<Button
-			title="Send feedback"
-			onPress={() => {
-				void feedback.flow("flow_123").open();
-			}}
-		/>
-	);
-}
+import { GetUserFeedbackProvider } from "@getuserfeedback/react-native";
 
 export function App() {
 	return (
-		<GetUserFeedbackProvider
-			initOptions={{ apiKey: "YOUR_API_KEY" }}
-			loaderUrl="https://cdn.example.com/loader.js"
-		>
-			<FeedbackActions />
+		<GetUserFeedbackProvider clientOptions={{ apiKey: "YOUR_API_KEY" }}>
+			<YourApp />
 		</GetUserFeedbackProvider>
 	);
 }
 ```
 
-`GetUserFeedbackProvider` renders `WidgetHost` internally, auto-enqueues `init`, measures the React Native window for the hosted WebView viewport, shows the hosted WebView inside a native bottom sheet while a flow is loading or open, and resolves command promises when the WebView transport reports command settlement. Pass either `loaderUrl` or a custom WebView `source` so the hosted WebView has a loader runtime to execute commands. Use `onCommandError` to receive automatic setup failures from `init` or `configure`.
-
-Custom `source` documents must implement the current WebView transport contract. Provider-owned presentation is driven by `instance:view-host:snapshots-changed`; the legacy aggregate `instance:flow:state-changed:instance` event does not control the native sheet.
-
-`WidgetHost` remains exported for advanced hosts that need direct WebView control.
-
-The host message types are re-exported from `@getuserfeedback/protocol/webview-transport` through package-owned aliases so the React Native package stays aligned with the shared WebView transport contract.
-
-## Local Expo smoke test
-
-Use the repo sandbox when testing a non-ejected Expo app against the local
-loader/core/API stack:
-
-```bash
-bun run start:sandbox
-```
-
-Create a React Native manifest:
-
-```bash
-curl -sS -X POST http://127.0.0.1:3710/api/sandbox/react-native-flow-assignment
-```
-
-For a physical device, use an address the device can reach:
-
-```bash
-curl -sS -X POST "http://127.0.0.1:3710/api/sandbox/react-native-flow-assignment?publicHost=192.168.1.10"
-```
-
-Then pass `manifest.initOptions` and `manifest.loaderUrl` to the provider:
+That's it. Flows configured for automatic Widget delivery now appear based on
+the targeting rules you set in the dashboard.
 
-```tsx
-import {
-	type GetUserFeedbackProviderProps,
-	GetUserFeedbackProvider,
-	useGetUserFeedback,
-} from "@getuserfeedback/react-native";
-import { Button, View } from "react-native";
-
-const manifest = {
-	// Paste the sandbox manifest while manually testing on device.
-	initOptions: {
-		apiKey: "gx_sandbox_...",
-		defaultConsent: ["analytics.measurement", "analytics.storage"],
-		disableTelemetry: true,
-		enableDebug: true,
-		runtimeEndpoints: {
-			apiUrl: "http://192.168.1.10:3712/v1",
-			coreUrl: "http://192.168.1.10:3711/widget/core/v1/core.html",
-		},
-	},
-	loaderUrl: "http://192.168.1.10:3711/widget/loader/v1/gx_sandbox_.../loader.js",
-	commands: {
-		identify: {
-			userId: "sandbox-user-...",
-			traits: { email: "sandbox-user-...@example.test" },
-		},
-		open: { flowId: "sur_..." },
-		track: {
-			name: "Checkout Started",
-			properties: { source: "react-native-sandbox" },
-		},
-	},
-} satisfies {
-	commands: {
-		identify: { traits: Record<string, unknown>; userId: string };
-		open: { flowId: string };
-		track: { name: string; properties: Record<string, unknown> };
-	};
-	initOptions: GetUserFeedbackProviderProps["initOptions"];
-	loaderUrl: string;
-};
-
-function SandboxActions() {
-	const feedback = useGetUserFeedback();
-
-	return (
-		<View>
-			<Button
-				title="Identify"
-				onPress={() => {
-					void feedback.identify(
-						manifest.commands.identify.userId,
-						manifest.commands.identify.traits,
-					);
-				}}
-			/>
-			<Button
-				title="Track"
-				onPress={() => {
-					void feedback.track(
-						manifest.commands.track.name,
-						manifest.commands.track.properties,
-					);
-				}}
-			/>
-			<Button
-				title="Open"
-				onPress={() => {
-					void feedback.flow(manifest.commands.open.flowId).open();
-				}}
-			/>
-		</View>
-	);
-}
-
-export function App() {
-	return (
-		<GetUserFeedbackProvider
-			initOptions={manifest.initOptions}
-			loaderUrl={manifest.loaderUrl}
-			onCommandError={console.error}
-		>
-			<SandboxActions />
-		</GetUserFeedbackProvider>
-	);
-}
-```
+For user identity, manual flow controls, and troubleshooting, read the
+[React Native SDK guide](https://getuserfeedback.com/docs/get-started/react-native-sdk).

package/dist/client.d.ts

@@ -0,0 +1,64 @@
+import type { AppEventExternalId, AppEventJsonValue, PublicCommandPayload } from "@getuserfeedback/protocol";
+import type { ConfigureOptions, InitOptions } from "@getuserfeedback/sdk";
+type IdentifyTraits = Record<string, unknown>;
+type TrackProperties = Record<string, AppEventJsonValue>;
+type OpenCommand = Extract<PublicCommandPayload, {
+    kind: "open";
+}>;
+type PrerenderCommand = Extract<PublicCommandPayload, {
+    kind: "prerender";
+}>;
+type IdentifyOptions = {
+    externalIds?: AppEventExternalId[];
+};
+type TrackOptions = {
+    externalIds?: AppEventExternalId[];
+};
+type OpenFlowOptions = Pick<OpenCommand, "hideCloseButton" | "metadata">;
+type PrerenderFlowOptions = Pick<PrerenderCommand, "hideCloseButton">;
+type HostContext = Extract<PublicCommandPayload, {
+    kind: "updateHostContext";
+}>["context"];
+type CommandOptions = {
+    idempotencyKey?: string;
+};
+/** React Native provider initialization options. */
+export type ClientOptions = InitOptions;
+/** Operations for one on-demand flow lifecycle. */
+export interface FlowRun {
+    readonly flowId: string;
+    /** Opens the flow. The flow must be published with Widget / On-demand delivery. */
+    open: (options?: OpenFlowOptions) => Promise<void>;
+    /** Loads the flow's network resources before it opens. */
+    prefetch: () => Promise<void>;
+    /** Loads the flow and warms its UI before it opens. */
+    prerender: (options?: PrerenderFlowOptions) => Promise<void>;
+    /** Closes this flow lifecycle. */
+    close: () => Promise<void>;
+}
+/**
+ * Public client exposed by `useGetUserFeedback`.
+ *
+ * @see https://getuserfeedback.com/docs/get-started/react-native-sdk
+ */
+export interface Client {
+    readonly instanceId: string;
+    /** Updates consent and other client configuration. */
+    configure: (opts: ConfigureOptions, options?: CommandOptions) => Promise<void>;
+    identify: {
+        (userId: string, traits?: IdentifyTraits, options?: IdentifyOptions): Promise<void>;
+        (traits: IdentifyTraits, placeholder: undefined, options?: IdentifyOptions): Promise<void>;
+        (traits: IdentifyTraits, options?: IdentifyOptions): Promise<void>;
+    };
+    /** Records a product event for targeting and analysis. */
+    track: (eventName: string, properties?: TrackProperties, options?: TrackOptions) => Promise<void>;
+    /** Returns the controller for one on-demand flow lifecycle. */
+    flow: (flowId: string) => FlowRun;
+    /** Closes every open flow owned by this provider. */
+    close: () => Promise<void>;
+    /** Resets widget state and the current user identity. */
+    reset: (options?: CommandOptions) => Promise<void>;
+    updateHostContext: (context: HostContext, options?: CommandOptions) => Promise<void>;
+    emitHostSignal: (name: string, data?: unknown, options?: CommandOptions) => Promise<void>;
+}
+export {};

package/dist/client.js

@@ -0,0 +1 @@
+export {};

package/dist/core-webview-host.d.ts

@@ -7,6 +7,5 @@ export type CoreWebViewHostProps = {
     onDisconnected?: () => void;
     onInvalidMessage?: (error: Error, value: unknown) => void;
     webViewComponent?: ComponentType<Record<string, unknown>>;
-    webViewProps?: Record<string, unknown>;
 };
 export declare function CoreWebViewHost({ coreUrl, ...props }: CoreWebViewHostProps): ReactElement;

package/dist/core-webview-host.js

@@ -14,15 +14,7 @@ import { buildCoreWebViewBridgeScript, parseCoreWebViewBridgeMessage, toExternal
 import { createCoreWebViewHostController, } from "./core-webview-host-controller.js";
 import { WebViewDocumentHost } from "./webview-document-host.js";
 let nextBridgeId = 0;
-const CORE_WEBVIEW_HOST_STYLE = {
-    height: 1,
-    left: -10000,
-    opacity: 0,
-    position: "absolute",
-    top: 0,
-    width: 1,
-};
-function CoreWebViewHostDocument({ externalCoreUrl, onConnected, onActivationRetryExhausted, onDisconnected, onInvalidMessage, webViewComponent, webViewProps, }) {
+function CoreWebViewHostDocument({ externalCoreUrl, onConnected, onActivationRetryExhausted, onDisconnected, onInvalidMessage, webViewComponent, }) {
     const bridgeIdRef = useRef(null);
     if (bridgeIdRef.current === null) {
         nextBridgeId += 1;
@@ -55,15 +47,13 @@ function CoreWebViewHostDocument({ externalCoreUrl, onConnected, onActivationRet
     const controller = controllerRef.current;
     const buildDocumentStartScript = useMemo(() => () => buildCoreWebViewBridgeScript({ bridgeId, phase: "documentStart" }), [bridgeId]);
     const source = useMemo(() => ({ uri: externalCoreUrl }), [externalCoreUrl]);
-    const resolvedWebViewProps = useMemo(() => (Object.assign(Object.assign({}, webViewProps), { containerStyle: CORE_WEBVIEW_HOST_STYLE, pointerEvents: "none", style: CORE_WEBVIEW_HOST_STYLE })), [webViewProps]);
     return createElement((WebViewDocumentHost), {
-        bridgeId,
         buildDocumentStartScript,
         controller,
         parseMessage: parseCoreWebViewBridgeMessage,
         source,
         webViewComponent,
-        webViewProps: resolvedWebViewProps,
+        webViewRole: "core",
         onInvalidMessage,
     });
 }

package/dist/native-core-command-channel.d.ts

@@ -14,5 +14,6 @@ export declare function createNativeCoreCommandChannel(input: {
     coreConnection: CoreWebViewHostConnection;
     onHandleInvalidated?: (message: EventHandleInvalidated) => void;
     onInvalidMessage?: (error: Error, value: unknown) => void;
+    onSessionFailure?: (error: Error) => void;
 }): OwnedNativeCoreCommandChannel;
 export {};

package/dist/native-core-command-channel.js

@@ -1,20 +1,36 @@
 import { coreCommandEnvelopeSchema, } from "@getuserfeedback/protocol";
 import { eventHandleInvalidatedSchema, } from "@getuserfeedback/protocol/internal/core-handle-invalidation";
 import { eventCommandSettledSchema, } from "@getuserfeedback/protocol/internal/core-host-command-settlement";
+import { CORE_SESSION_FAILED_CODE, eventCoreSessionFailedSchema, } from "@getuserfeedback/protocol/internal/core-session-failure";
 const DISPOSED_MESSAGE = "Core command channel is disposed";
 const isRecord = (value) => typeof value === "object" && value !== null;
 export function createNativeCoreCommandChannel(input) {
     const listeners = new Set();
     let disposed = false;
     const handleMessage = (value) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         if (disposed || !isRecord(value)) {
             return;
         }
+        if (value.t === "getuserfeedback:event:error" &&
+            value.code === CORE_SESSION_FAILED_CODE) {
+            const parsed = eventCoreSessionFailedSchema.safeParse(value);
+            if (!parsed.success) {
+                (_a = input.onInvalidMessage) === null || _a === void 0 ? void 0 : _a.call(input, parsed.error instanceof Error
+                    ? parsed.error
+                    : new Error("Invalid Core session failure message"), value);
+                return;
+            }
+            if (parsed.data.gen !== input.coreConnection.generation) {
+                return;
+            }
+            (_b = input.onSessionFailure) === null || _b === void 0 ? void 0 : _b.call(input, new Error(parsed.data.details.message));
+            return;
+        }
         if (value.t === "getuserfeedback:event:commandSettled") {
             const parsed = eventCommandSettledSchema.safeParse(value);
             if (!parsed.success) {
-                (_a = input.onInvalidMessage) === null || _a === void 0 ? void 0 : _a.call(input, parsed.error instanceof Error
+                (_c = input.onInvalidMessage) === null || _c === void 0 ? void 0 : _c.call(input, parsed.error instanceof Error
                     ? parsed.error
                     : new Error("Invalid core command settlement message"), value);
                 return;
@@ -32,7 +48,7 @@ export function createNativeCoreCommandChannel(input) {
         }
         const parsed = eventHandleInvalidatedSchema.safeParse(value);
         if (!parsed.success) {
-            (_b = input.onInvalidMessage) === null || _b === void 0 ? void 0 : _b.call(input, parsed.error instanceof Error
+            (_d = input.onInvalidMessage) === null || _d === void 0 ? void 0 : _d.call(input, parsed.error instanceof Error
                 ? parsed.error
                 : new Error("Invalid core handle invalidation message"), value);
             return;
@@ -40,7 +56,7 @@ export function createNativeCoreCommandChannel(input) {
         if (parsed.data.gen !== input.coreConnection.generation) {
             return;
         }
-        (_c = input.onHandleInvalidated) === null || _c === void 0 ? void 0 : _c.call(input, parsed.data);
+        (_e = input.onHandleInvalidated) === null || _e === void 0 ? void 0 : _e.call(input, parsed.data);
     };
     const unsubscribeTransport = input.coreConnection.transport.subscribe(handleMessage);
     const channel = {

package/dist/native-provider-client-controller.d.ts

@@ -0,0 +1,11 @@
+import type { EventHandleInvalidated } from "@getuserfeedback/protocol/internal/core-handle-invalidation";
+export declare function createNativeProviderClientController(input: {
+    instanceId: string;
+    onError?: (error: Error) => void;
+}): {
+    client: import("./native-provider-client.js").NativeProviderClient<void>;
+    directSessionController: import("./native-direct-command-session-controller.js").NativeDirectCommandSessionController;
+    dispose: () => void;
+    onHandleInvalidated: (message: EventHandleInvalidated) => void;
+    onSessionEnded: () => void;
+};

package/dist/native-provider-client-controller.js

@@ -0,0 +1,38 @@
+import { createNativeProviderClient, parseRequiredString, } from "./native-provider-client.js";
+import { createNativeProviderCommandController } from "./native-provider-command-controller.js";
+import { createNativeProviderFlowRegistry } from "./native-provider-flow-registry.js";
+export function createNativeProviderClientController(input) {
+    const commands = createNativeProviderCommandController(input);
+    const flows = createNativeProviderFlowRegistry(commands);
+    const session = commands.directSessionController;
+    const client = createNativeProviderClient({
+        dispatchCommand: (command, options) => {
+            if (command.kind === "close" || command.kind === "reset") {
+                return commands.runBarrier(command.kind, flows.reset, options);
+            }
+            return commands
+                .runOperation((dispatch) => dispatch(command), options)
+                .then(() => undefined);
+        },
+        flow: (flowId) => flows.flow(parseRequiredString("flowId", flowId)),
+        instanceId: input.instanceId,
+    });
+    return {
+        client,
+        directSessionController: session,
+        dispose: () => {
+            flows.reset();
+            commands.dispose();
+        },
+        onHandleInvalidated: (message) => {
+            if (message.instanceId === input.instanceId &&
+                message.handleKind === "flow")
+                flows.invalidate(message.handleId);
+        },
+        onSessionEnded: () => {
+            session.rejectUntilAttached(new Error("Core session ended"));
+            void commands.runBarrier(null, flows.reset);
+            session.beginAttachmentAttempt();
+        },
+    };
+}

package/dist/native-provider-client.d.ts

@@ -1,13 +1,8 @@
 import type { AppEventExternalId, AppEventJsonValue, PublicCommandPayload } from "@getuserfeedback/protocol";
 import type { ConfigureOptions } from "@getuserfeedback/sdk";
+import type { FlowRun } from "./client.js";
 type IdentifyTraits = Record<string, unknown>;
 type TrackProperties = Record<string, AppEventJsonValue>;
-type OpenCommand = Extract<PublicCommandPayload, {
-    kind: "open";
-}>;
-type PrerenderCommand = Extract<PublicCommandPayload, {
-    kind: "prerender";
-}>;
 type NativeProviderClientCommand = Extract<PublicCommandPayload, {
     kind: "configure" | "identify" | "track" | "close" | "reset" | "updateHostContext" | "emitHostSignal";
 }>;
@@ -17,21 +12,12 @@ type IdentifyOptions = {
 type TrackOptions = {
     externalIds?: AppEventExternalId[];
 };
-type OpenFlowOptions = Pick<OpenCommand, "hideCloseButton" | "metadata">;
-type PrerenderFlowOptions = Pick<PrerenderCommand, "hideCloseButton">;
 type HostContext = Extract<PublicCommandPayload, {
     kind: "updateHostContext";
 }>["context"];
 interface NativeProviderCommandOptions {
     idempotencyKey?: string;
 }
-export interface ReactNativeFlowRun {
-    readonly flowId: string;
-    open: (options?: OpenFlowOptions) => Promise<void>;
-    prefetch: () => Promise<void>;
-    prerender: (options?: PrerenderFlowOptions) => Promise<void>;
-    close: () => Promise<void>;
-}
 export interface NativeProviderClient<TResult> {
     readonly instanceId: string;
     configure: (opts: ConfigureOptions, options?: NativeProviderCommandOptions) => Promise<TResult>;
@@ -41,7 +27,7 @@ export interface NativeProviderClient<TResult> {
         (traits: IdentifyTraits, options?: IdentifyOptions): Promise<TResult>;
     };
     track: (eventName: string, properties?: TrackProperties, options?: TrackOptions) => Promise<TResult>;
-    flow: (flowId: string) => ReactNativeFlowRun;
+    flow: (flowId: string) => FlowRun;
     close: () => Promise<TResult>;
     reset: (options?: NativeProviderCommandOptions) => Promise<TResult>;
     updateHostContext: (context: HostContext, options?: NativeProviderCommandOptions) => Promise<TResult>;
@@ -49,7 +35,7 @@ export interface NativeProviderClient<TResult> {
 }
 type NativeProviderClientOptions<TResult> = {
     dispatchCommand: (command: NativeProviderClientCommand, options?: NativeProviderCommandOptions) => Promise<TResult>;
-    flow: (flowId: string) => ReactNativeFlowRun;
+    flow: (flowId: string) => FlowRun;
     instanceId: string;
 };
 export declare const parseRequiredString: (name: string, value?: string) => string;

package/dist/native-provider-command-controller.d.ts

@@ -0,0 +1,19 @@
+import type { CommandSettledSuccessDetail } from "@getuserfeedback/protocol/host";
+import type { NativeDirectCommandEnvelope } from "./native-direct-command-session.js";
+type Command = NativeDirectCommandEnvelope["command"];
+type CommandOptions = {
+    idempotencyKey?: string;
+};
+type Dispatch = (command: Command) => Promise<CommandSettledSuccessDetail>;
+type RunOperation = <T>(run: (dispatch: Dispatch) => Promise<T>, options?: CommandOptions) => Promise<T | undefined>;
+export declare function createNativeProviderCommandController(input: {
+    instanceId: string;
+    onError?: (error: Error) => void;
+}): {
+    directSessionController: import("./native-direct-command-session-controller.js").NativeDirectCommandSessionController;
+    dispose: () => void;
+    reject: (error: unknown) => Promise<never>;
+    runBarrier: (kind: "close" | "reset" | null, onGenerationAdvanced: () => void, options?: CommandOptions) => Promise<void>;
+    runOperation: RunOperation;
+};
+export {};

package/dist/native-provider-command-controller.js

@@ -0,0 +1,79 @@
+import { parsePublicCommand } from "@getuserfeedback/protocol";
+import { createCommandEnvelopeWithInstanceId } from "@getuserfeedback/protocol/host";
+import { createClientTransportAdmission } from "@getuserfeedback/sdk/internal/client-transport-admission";
+import { createNativeDirectCommandSessionController } from "./native-direct-command-session-controller.js";
+import { REACT_NATIVE_CLIENT_META } from "./provider-command-helpers.js";
+const parseIdempotencyKey = (options) => {
+    var _a;
+    const idempotencyKey = (_a = options === null || options === void 0 ? void 0 : options.idempotencyKey) === null || _a === void 0 ? void 0 : _a.trim();
+    if ((options === null || options === void 0 ? void 0 : options.idempotencyKey) !== undefined && !idempotencyKey)
+        throw new Error("idempotencyKey must be a non-empty string");
+    return idempotencyKey;
+};
+export function createNativeProviderCommandController(input) {
+    const directSessionController = createNativeDirectCommandSessionController();
+    const admission = createClientTransportAdmission();
+    const report = (value) => {
+        var _a;
+        const error = value instanceof Error ? value : new Error(String(value));
+        try {
+            (_a = input.onError) === null || _a === void 0 ? void 0 : _a.call(input, error);
+        }
+        catch (_b) { }
+        return error;
+    };
+    const observe = (promise) => promise.catch((error) => Promise.reject(report(error)));
+    const dispatch = (command, idempotencyKey) => {
+        const envelope = createCommandEnvelopeWithInstanceId({
+            clientMeta: REACT_NATIVE_CLIENT_META,
+            command: parsePublicCommand(command),
+            idempotencyKey,
+            instanceId: input.instanceId,
+        });
+        return directSessionController.session.dispatch(envelope);
+    };
+    const runOperation = (run, options) => {
+        let idempotencyKey;
+        try {
+            idempotencyKey = parseIdempotencyKey(options);
+        }
+        catch (error) {
+            return observe(Promise.reject(error));
+        }
+        return observe(admission
+            .runOperation(({ attemptHandoff }) => run((command) => attemptHandoff({
+            handOff: () => ({
+                settlement: dispatch(command, idempotencyKey),
+            }),
+            prepare: () => { },
+        })))
+            .then((result) => result.status === "settled" ? result.result : undefined));
+    };
+    const runBarrier = (kind, onGenerationAdvanced, options) => {
+        let idempotencyKey;
+        try {
+            idempotencyKey = parseIdempotencyKey(options);
+        }
+        catch (error) {
+            return observe(Promise.reject(error));
+        }
+        return observe(admission
+            .runBarrier({
+            handOff: () => ({
+                settlement: kind === null
+                    ? Promise.resolve()
+                    : dispatch({ kind }, idempotencyKey).then(() => undefined),
+            }),
+            onGenerationAdvanced,
+            prepare: () => { },
+        })
+            .then(() => undefined));
+    };
+    return {
+        directSessionController,
+        dispose: () => directSessionController.dispose(new Error("Native provider client has been disposed")),
+        reject: (error) => Promise.reject(report(error)),
+        runBarrier,
+        runOperation,
+    };
+}

package/dist/native-provider-flow-registry.d.ts

@@ -0,0 +1,7 @@
+import type { FlowRun } from "./client.js";
+import type { createNativeProviderCommandController } from "./native-provider-command-controller.js";
+export declare function createNativeProviderFlowRegistry(commands: ReturnType<typeof createNativeProviderCommandController>): {
+    flow: (flowId: string) => FlowRun;
+    invalidate: (handleId: string) => void;
+    reset: () => void;
+};

package/dist/native-provider-flow-registry.js

@@ -0,0 +1,70 @@
+import { parsePublicCommand } from "@getuserfeedback/protocol";
+import { CommandSettlementError, createFlowCommandHandleController, getFlowHandleFromSettlementDetail, } from "@getuserfeedback/protocol/host";
+import { createFlowOpenRequestController } from "@getuserfeedback/sdk/internal/flow-open-request-controller";
+const isStaleHandleError = (error) => error instanceof CommandSettlementError
+    ? error.code === "STALE_HANDLE"
+    : error instanceof Error && error.message.includes("flowHandleId is stale");
+export function createNativeProviderFlowRegistry(commands) {
+    const create = (flowId) => {
+        const openRequests = createFlowOpenRequestController();
+        const handle = createFlowCommandHandleController({
+            getHandleIdFromSettlement: (settlement) => { var _a; return (_a = getFlowHandleFromSettlementDetail(settlement)) === null || _a === void 0 ? void 0 : _a.flowHandleId; },
+            isStaleHandleError,
+        });
+        const allocation = (command) => commands
+            .runOperation((dispatch) => handle.runCommand((flowHandleId) => (Object.assign(Object.assign({}, command), { flowHandleId })), dispatch))
+            .then(() => undefined);
+        const prepare = (build, start = allocation) => {
+            try {
+                return start(parsePublicCommand(build()));
+            }
+            catch (error) {
+                return commands.reject(error);
+            }
+        };
+        const run = {
+            flowId,
+            open: (options) => prepare(() => ({
+                flowId,
+                hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
+                kind: "open",
+                metadata: options === null || options === void 0 ? void 0 : options.metadata,
+            }), (command) => openRequests.run(() => allocation(command))),
+            prefetch: () => prepare(() => ({
+                flowId,
+                kind: "prefetch",
+            })),
+            prerender: (options) => prepare(() => ({
+                flowId,
+                hideCloseButton: options === null || options === void 0 ? void 0 : options.hideCloseButton,
+                kind: "prerender",
+            })),
+            close: () => {
+                openRequests.clear();
+                return commands
+                    .runOperation((dispatch) => handle.runResolvedHandleCommand((flowHandleId) => ({ flowHandleId, kind: "close" }), async (command) => void (await dispatch(command))))
+                    .then(() => undefined);
+            },
+        };
+        return { clearPendingOpen: openRequests.clear, handle, run };
+    };
+    const controllers = new Map();
+    return {
+        flow: (flowId) => {
+            var _a;
+            const current = (_a = controllers.get(flowId)) !== null && _a !== void 0 ? _a : create(flowId);
+            controllers.set(flowId, current);
+            return current.run;
+        },
+        invalidate: (handleId) => {
+            for (const controller of controllers.values())
+                controller.handle.invalidateResolvedHandle(handleId);
+        },
+        reset: () => {
+            for (const controller of controllers.values()) {
+                controller.clearPendingOpen();
+                controller.handle.reset();
+            }
+        },
+    };
+}