@usechatting/react-native 0.1.0

package/README.md

@@ -0,0 +1,122 @@
+# @usechatting/react-native
+
+Expo-friendly React Native chat package for Chatting.
+
+## What it includes
+
+- JavaScript client for Chatting public chat APIs
+- pluggable async session storage
+- React hook for conversation state
+- simple React Native chat screen
+- live conversation sync with automatic polling fallback
+
+## Install
+
+```bash
+npm install @usechatting/react-native
+```
+
+If you want session persistence across app restarts, also install an async storage adapter in your app, for example React Native Async Storage.
+
+For Expo push notifications in your host app, also install:
+
+```bash
+npx expo install expo-notifications
+```
+
+## Required config
+
+- `baseURL`: use `https://usechatting.com`
+- `siteId`: your site/workspace ID inside Chatting
+
+## Exact Expo integration snippet
+
+```tsx
+import { useEffect, useMemo, useState } from "react";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import * as Notifications from "expo-notifications";
+import { AppState, Platform } from "react-native";
+import {
+  ChattingClient,
+  ChattingConversationScreen,
+  createKeyValueSessionStore
+} from "@usechatting/react-native";
+
+Notifications.setNotificationHandler({
+  handleNotification: async () => ({
+    shouldShowAlert: false,
+    shouldPlaySound: false,
+    shouldSetBadge: false
+  })
+});
+
+const client = new ChattingClient({
+  baseURL: "https://usechatting.com",
+  siteId: "your-site-id",
+  sessionStore: createKeyValueSessionStore(AsyncStorage, "your-site-id")
+});
+
+export function SupportScreen() {
+  const [refreshKey, setRefreshKey] = useState(0);
+  const context = useMemo(() => ({ pageUrl: "myapp://support" }), []);
+
+  useEffect(() => {
+    let mounted = true;
+    const refreshChat = async () => {
+      await client.syncPushToken();
+      if (mounted) {
+        setRefreshKey((current) => current + 1);
+      }
+    };
+
+    const registerPush = async () => {
+      const permission = await Notifications.requestPermissionsAsync();
+      if (!mounted || permission.status !== "granted") {
+        return;
+      }
+
+      const token = await Notifications.getExpoPushTokenAsync({
+        projectId: "your-expo-project-id"
+      });
+
+      await client.registerPushToken({
+        pushToken: token.data,
+        platform: Platform.OS
+      });
+    };
+
+    void registerPush();
+
+    const appStateSubscription = AppState.addEventListener("change", (nextState) => {
+      if (nextState === "active") {
+        void refreshChat();
+      }
+    });
+
+    const responseSubscription = Notifications.addNotificationResponseReceivedListener(() => {
+      void refreshChat();
+    });
+
+    return () => {
+      mounted = false;
+      appStateSubscription.remove();
+      responseSubscription.remove();
+    };
+  }, []);
+
+  return (
+    <ChattingConversationScreen
+      key={refreshKey}
+      client={client}
+      context={context}
+      draftVisitorEmail="customer@example.com"
+    />
+  );
+}
+```
+
+## Realtime behavior
+
+This package uses a dedicated React Native live transport for Chatting's SSE conversation stream, so new team messages and team typing updates show up immediately while the app is open. If that live connection drops, the hook falls back to foreground polling so the conversation stays usable while reconnecting.
+
+Expo push delivery is now supported for background and suspended apps once the host app registers an Expo push token through `client.registerPushToken(...)`. When the app becomes active again or a notification is tapped, call `client.syncPushToken()` and remount or refresh your chat screen so the conversation refetches cleanly.

package/dist/chatting-client-shared.d.ts

@@ -0,0 +1,13 @@
+import { resolveContext } from "./chatting-utils";
+import type { ChattingSessionState } from "./chatting-types";
+export declare const DEFAULT_CHATTING_BASE_URL = "https://usechatting.com";
+export declare function requireChattingText(value: string | null | undefined, message: string): string;
+export declare function buildChattingSiteQuery(siteId: string, state: ChattingSessionState, context: ReturnType<typeof resolveContext>): {
+    siteId: string;
+    sessionId: string;
+    email: string | null;
+    pageUrl: string | null;
+    referrer: string | null;
+    timezone: string | null;
+    locale: string | null;
+};

package/dist/chatting-client-shared.js

@@ -0,0 +1,20 @@
+import { normalizeText } from "./chatting-utils";
+export const DEFAULT_CHATTING_BASE_URL = "https://usechatting.com";
+export function requireChattingText(value, message) {
+    const nextValue = normalizeText(value);
+    if (!nextValue) {
+        throw new Error(message);
+    }
+    return nextValue;
+}
+export function buildChattingSiteQuery(siteId, state, context) {
+    return {
+        siteId,
+        sessionId: state.sessionId,
+        email: state.email ?? null,
+        pageUrl: context.pageUrl,
+        referrer: context.referrer,
+        timezone: context.timezone,
+        locale: context.locale
+    };
+}

package/dist/chatting-client.d.ts

@@ -0,0 +1,27 @@
+import type { ChattingClientOptions, ChattingConversationState, ChattingLiveEvent, ChattingPushRegistrationInput, ChattingSendMessageResult, ChattingSessionState, ChattingSiteConfig, ChattingSiteStatus, ChattingVisitorContext, ChattingVisitorProfile } from "./chatting-types";
+export declare class ChattingClient {
+    readonly siteId: string;
+    private readonly sessionStore;
+    private readonly transport;
+    constructor(options: ChattingClientOptions);
+    currentSessionState(): Promise<ChattingSessionState>;
+    clearConversation(): Promise<void>;
+    saveEmail(email: string): Promise<void>;
+    fetchSiteConfig(context?: ChattingVisitorContext): Promise<ChattingSiteConfig>;
+    fetchSiteStatus(context?: ChattingVisitorContext): Promise<ChattingSiteStatus>;
+    fetchConversationIfAvailable(): Promise<ChattingConversationState | null>;
+    fetchConversation(): Promise<ChattingConversationState>;
+    sendMessage(content: string, options?: {
+        context?: ChattingVisitorContext;
+        email?: string | null;
+    }): Promise<ChattingSendMessageResult>;
+    identify(profile: ChattingVisitorProfile, context?: ChattingVisitorContext): Promise<void>;
+    updateTyping(isTyping: boolean): Promise<void>;
+    registerPushToken(registration: ChattingPushRegistrationInput): Promise<void>;
+    unregisterPushToken(pushToken?: string | null): Promise<void>;
+    syncPushToken(): Promise<void>;
+    subscribeLiveEvents(input: {
+        onEvent(event: ChattingLiveEvent): void;
+        onDisconnect?(error?: unknown): void;
+    }): Promise<() => void>;
+}

package/dist/chatting-client.js

@@ -0,0 +1,147 @@
+import { createMemorySessionStore } from "./chatting-session-store";
+import { buildChattingSiteQuery, DEFAULT_CHATTING_BASE_URL, requireChattingText } from "./chatting-client-shared";
+import { clearConversationPushState, registerChattingPushToken, syncChattingPushToken, unregisterChattingPushToken } from "./chatting-push-registration";
+import { ChattingTransport } from "./chatting-transport";
+import { createSessionId, normalizeText, resolveContext } from "./chatting-utils";
+export class ChattingClient {
+    siteId;
+    sessionStore;
+    transport;
+    constructor(options) {
+        this.siteId = options.siteId;
+        this.sessionStore = options.sessionStore ?? createMemorySessionStore();
+        this.transport = new ChattingTransport(options.baseURL ?? DEFAULT_CHATTING_BASE_URL, options.fetchImpl ?? fetch);
+    }
+    async currentSessionState() {
+        const stored = await this.sessionStore.load();
+        if (stored) {
+            return stored;
+        }
+        const nextState = { sessionId: createSessionId() };
+        await this.sessionStore.save(nextState);
+        return nextState;
+    }
+    async clearConversation() {
+        const state = await this.currentSessionState();
+        await this.sessionStore.save(clearConversationPushState(state));
+    }
+    async saveEmail(email) {
+        const nextEmail = requireChattingText(email, "Email is required.");
+        const state = await this.currentSessionState();
+        if (!state.conversationId) {
+            await this.sessionStore.save({ ...state, email: nextEmail });
+            return;
+        }
+        await this.transport.post("/api/public/conversation-email", {
+            siteId: this.siteId,
+            sessionId: state.sessionId,
+            conversationId: state.conversationId,
+            email: nextEmail
+        });
+        await this.sessionStore.save({ ...state, email: nextEmail });
+    }
+    async fetchSiteConfig(context = {}) {
+        const state = await this.currentSessionState();
+        const response = await this.transport.get("/api/public/site-config", {
+            ...buildChattingSiteQuery(this.siteId, state, resolveContext(context)),
+            conversationId: state.conversationId ?? null
+        });
+        return response.site;
+    }
+    async fetchSiteStatus(context = {}) {
+        const state = await this.currentSessionState();
+        const response = await this.transport.get("/api/public/site-status", {
+            ...buildChattingSiteQuery(this.siteId, state, resolveContext(context)),
+            conversationId: state.conversationId ?? null
+        });
+        return response;
+    }
+    async fetchConversationIfAvailable() {
+        const state = await this.currentSessionState();
+        return state.conversationId ? this.fetchConversation() : null;
+    }
+    async fetchConversation() {
+        const state = await this.currentSessionState();
+        const conversationId = requireChattingText(state.conversationId, "No active Chatting conversation exists yet.");
+        return this.transport.get("/api/public/conversation", {
+            siteId: this.siteId,
+            sessionId: state.sessionId,
+            conversationId
+        });
+    }
+    async sendMessage(content, options = {}) {
+        const nextContent = requireChattingText(content, "Message content cannot be empty.");
+        const state = await this.currentSessionState();
+        const email = normalizeText(options.email) ?? state.email ?? null;
+        const result = await this.transport.post("/api/public/messages", {
+            siteId: this.siteId,
+            sessionId: state.sessionId,
+            conversationId: state.conversationId ?? null,
+            content: nextContent,
+            email,
+            ...resolveContext(options.context)
+        });
+        await this.sessionStore.save(await syncChattingPushToken({
+            siteId: this.siteId,
+            transport: this.transport,
+            state: { ...state, conversationId: result.conversationId, email }
+        }));
+        return result;
+    }
+    async identify(profile, context = {}) {
+        const state = await this.currentSessionState();
+        await this.transport.post("/api/public/identify", {
+            siteId: this.siteId,
+            sessionId: state.sessionId,
+            conversationId: state.conversationId ?? null,
+            ...resolveContext(context),
+            ...profile
+        });
+        await this.sessionStore.save({ ...state, email: profile.email });
+    }
+    async updateTyping(isTyping) {
+        const state = await this.currentSessionState();
+        const conversationId = requireChattingText(state.conversationId, "No active Chatting conversation exists yet.");
+        await this.transport.post("/api/public/typing", {
+            siteId: this.siteId,
+            sessionId: state.sessionId,
+            conversationId,
+            typing: isTyping
+        });
+    }
+    async registerPushToken(registration) {
+        const state = await this.currentSessionState();
+        await this.sessionStore.save(await registerChattingPushToken({
+            siteId: this.siteId,
+            state,
+            transport: this.transport,
+            registration
+        }));
+    }
+    async unregisterPushToken(pushToken) {
+        const state = await this.currentSessionState();
+        await this.sessionStore.save(await unregisterChattingPushToken({
+            siteId: this.siteId,
+            state,
+            transport: this.transport,
+            pushToken
+        }));
+    }
+    async syncPushToken() {
+        const state = await this.currentSessionState();
+        await this.sessionStore.save(await syncChattingPushToken({
+            siteId: this.siteId,
+            state,
+            transport: this.transport
+        }));
+    }
+    async subscribeLiveEvents(input) {
+        const state = await this.currentSessionState();
+        const conversationId = requireChattingText(state.conversationId, "No active Chatting conversation exists yet.");
+        return this.transport.connectLive("/api/public/conversation-live", {
+            siteId: this.siteId,
+            sessionId: state.sessionId,
+            conversationId
+        }, input);
+    }
+}

package/dist/chatting-conversation-screen.d.ts

@@ -0,0 +1,9 @@
+import type { ChattingClient } from "./chatting-client";
+import type { ChattingVisitorContext, ChattingVisitorProfile } from "./chatting-types";
+export declare function ChattingConversationScreen(input: {
+    client: ChattingClient;
+    context?: ChattingVisitorContext;
+    profile?: ChattingVisitorProfile | null;
+    draftVisitorEmail?: string | null;
+    pollIntervalMs?: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/chatting-conversation-screen.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { ActivityIndicator, ScrollView, Text, TextInput, TouchableOpacity, View } from "react-native";
+import { useChattingConversation } from "./use-chatting-conversation";
+import { styles } from "./chatting-screen-styles";
+export function ChattingConversationScreen(input) {
+    const conversation = useChattingConversation(input);
+    const title = conversation.siteConfig?.widgetTitle ?? "Chatting";
+    const subtitle = conversation.siteConfig?.showOnlineStatus !== false && conversation.siteStatus
+        ? conversation.siteStatus.online
+            ? "Team is online"
+            : "Team is away"
+        : conversation.siteConfig?.greetingText ?? "Start a conversation";
+    return (_jsxs(View, { style: styles.screen, children: [_jsxs(View, { style: styles.header, children: [_jsx(Text, { style: styles.title, children: title }), _jsx(Text, { style: styles.subtitle, children: subtitle })] }), _jsxs(ScrollView, { style: styles.scroll, contentContainerStyle: styles.content, children: [conversation.errorMessage ? (_jsx(View, { style: styles.banner, children: _jsx(Text, { style: [styles.bannerText, styles.error], children: conversation.errorMessage }) })) : null, conversation.isLoading ? _jsx(ActivityIndicator, { color: "#2563EB" }) : null, !conversation.isLoading && conversation.messages.length === 0 ? (_jsx(View, { style: styles.banner, children: _jsx(Text, { style: styles.bannerText, children: "Open support inside your app without rebuilding visitor chat from scratch." }) })) : null, conversation.messages.map((message) => (_jsx(View, { style: styles.row, children: message.sender === "team" ? (_jsxs(_Fragment, { children: [_jsx(Bubble, { message: message.content || "(attachment placeholder)", isUser: false }), _jsx(View, { style: styles.spacer })] })) : (_jsxs(_Fragment, { children: [_jsx(View, { style: styles.spacer }), _jsx(Bubble, { message: message.content || "(attachment placeholder)", isUser: true })] })) }, message.id))), conversation.teamTyping ? (_jsxs(View, { style: styles.row, children: [_jsx(Bubble, { message: "Team is typing...", isUser: false, subtle: true }), _jsx(View, { style: styles.spacer })] })) : null, conversation.faqSuggestions?.items.map((item) => (_jsxs(View, { style: styles.faqCard, children: [_jsx(Text, { style: styles.faqTitle, children: item.question }), _jsx(Text, { style: styles.faqText, children: item.answer })] }, item.id))), conversation.faqSuggestions?.fallbackMessage ? (_jsx(Text, { style: styles.meta, children: conversation.faqSuggestions.fallbackMessage })) : null] }), _jsxs(View, { style: styles.footer, children: [_jsx(TextInput, { value: conversation.emailAddress, onChangeText: conversation.setEmailAddress, placeholder: "Email for follow-up", autoCapitalize: "none", autoCorrect: false, style: styles.input }), _jsx(TextInput, { value: conversation.draftMessage, onChangeText: conversation.setDraftMessage, placeholder: "Type a message", multiline: true, style: [styles.input, styles.composer] }), _jsxs(View, { style: styles.actions, children: [_jsx(TouchableOpacity, { style: [styles.button, styles.secondaryButton], onPress: () => void conversation.saveEmail(), children: _jsx(Text, { style: styles.secondaryButtonText, children: conversation.isSavingEmail ? "Saving..." : "Save email" }) }), _jsx(TouchableOpacity, { style: styles.button, onPress: () => void conversation.sendMessage(), children: _jsx(Text, { style: styles.buttonText, children: conversation.isSending ? "Sending..." : "Send" }) })] })] })] }));
+}
+function Bubble(input) {
+    return (_jsx(View, { style: [
+            styles.bubble,
+            input.isUser ? styles.userBubble : styles.teamBubble,
+            input.subtle ? styles.typingBubble : null
+        ], children: _jsx(Text, { style: input.isUser ? styles.userText : styles.teamText, children: input.message }) }));
+}

package/dist/chatting-hook-helpers.d.ts

@@ -0,0 +1,20 @@
+import type { MutableRefObject } from "react";
+import { ChattingClient } from "./chatting-client";
+import type { ChattingConversationState, ChattingFAQSuggestions, ChattingMessage } from "./chatting-types";
+export declare function applyConversation(conversation: ChattingConversationState, setMessages: (messages: ChattingMessage[]) => void, setFaqSuggestions: (suggestions: ChattingFAQSuggestions | null) => void): void;
+export declare function startConversationSync(input: {
+    client: ChattingClient;
+    pollIntervalMs?: number;
+    stopSyncRef: MutableRefObject<null | (() => void)>;
+    activeConversationIdRef: MutableRefObject<string | null>;
+    setMessages(messages: ChattingMessage[]): void;
+    setFaqSuggestions(suggestions: ChattingFAQSuggestions | null): void;
+    setTeamTyping(value: boolean): void;
+    setErrorMessage(message: string | null): void;
+    refreshConversation(): Promise<ChattingConversationState>;
+}): Promise<void>;
+export declare function syncTyping(input: {
+    client: ChattingClient;
+    value: string;
+    typingTimeoutRef: MutableRefObject<ReturnType<typeof setTimeout> | null>;
+}): Promise<void>;

package/dist/chatting-hook-helpers.js

@@ -0,0 +1,83 @@
+import { ChattingLiveStreamUnsupportedError } from "./chatting-live-stream";
+import { startConversationPolling } from "./chatting-poller";
+import { normalizeText, toErrorMessage } from "./chatting-utils";
+export function applyConversation(conversation, setMessages, setFaqSuggestions) {
+    setMessages(conversation.messages);
+    setFaqSuggestions(conversation.faqSuggestions ?? null);
+}
+export async function startConversationSync(input) {
+    const session = await input.client.currentSessionState();
+    if (!session.conversationId) {
+        return;
+    }
+    if (input.activeConversationIdRef.current === session.conversationId && input.stopSyncRef.current) {
+        return;
+    }
+    input.stopSyncRef.current?.();
+    input.activeConversationIdRef.current = session.conversationId;
+    input.setTeamTyping(false);
+    const fallbackToPolling = () => {
+        input.stopSyncRef.current?.();
+        input.stopSyncRef.current = startConversationPolling({
+            client: input.client,
+            intervalMs: input.pollIntervalMs,
+            onConversation(conversation) {
+                applyConversation(conversation, input.setMessages, input.setFaqSuggestions);
+                input.setErrorMessage(null);
+            },
+            onError(error) {
+                input.setErrorMessage(toErrorMessage(error));
+            }
+        });
+    };
+    try {
+        input.stopSyncRef.current = await input.client.subscribeLiveEvents({
+            onEvent(event) {
+                void handleLiveEvent(event, input).catch((error) => {
+                    input.setErrorMessage(toErrorMessage(error));
+                });
+            },
+            onDisconnect() {
+                fallbackToPolling();
+            }
+        });
+    }
+    catch (error) {
+        if (!(error instanceof ChattingLiveStreamUnsupportedError)) {
+            input.setErrorMessage(toErrorMessage(error));
+        }
+        fallbackToPolling();
+    }
+}
+async function handleLiveEvent(event, input) {
+    if (event.type === "typing.updated" && event.actor === "team") {
+        input.setTeamTyping(Boolean(event.typing));
+        input.setErrorMessage(null);
+        return;
+    }
+    if (event.type !== "message.created" && event.type !== "conversation.updated") {
+        return;
+    }
+    input.setTeamTyping(false);
+    const conversation = await input.refreshConversation();
+    applyConversation(conversation, input.setMessages, input.setFaqSuggestions);
+    input.setErrorMessage(null);
+}
+export async function syncTyping(input) {
+    if (input.typingTimeoutRef.current) {
+        clearTimeout(input.typingTimeoutRef.current);
+    }
+    const isTyping = Boolean(normalizeText(input.value));
+    try {
+        await input.client.updateTyping(isTyping);
+    }
+    catch {
+        return;
+    }
+    if (!isTyping) {
+        return;
+    }
+    input.typingTimeoutRef.current = setTimeout(() => {
+        void input.client.updateTyping(false).catch(() => undefined);
+    }, 1500);
+}

package/dist/chatting-live-stream.d.ts

@@ -0,0 +1,10 @@
+import type { ChattingLiveEvent } from "./chatting-types";
+export declare class ChattingLiveStreamUnsupportedError extends Error {
+    constructor();
+}
+export declare function connectChattingLiveStream(input: {
+    url: string;
+    fetchImpl?: typeof fetch;
+    onEvent(event: ChattingLiveEvent): void;
+    onDisconnect?(error?: unknown): void;
+}): Promise<() => void>;

package/dist/chatting-live-stream.js

@@ -0,0 +1,136 @@
+export class ChattingLiveStreamUnsupportedError extends Error {
+    constructor() {
+        super("This environment cannot open Chatting live events.");
+        this.name = "ChattingLiveStreamUnsupportedError";
+    }
+}
+export function connectChattingLiveStream(input) {
+    if (typeof globalThis.XMLHttpRequest === "function") {
+        return connectViaXHR(input);
+    }
+    const fetchImpl = input.fetchImpl ?? globalThis.fetch;
+    if (!fetchImpl) {
+        throw new ChattingLiveStreamUnsupportedError();
+    }
+    return connectViaFetch({ ...input, fetchImpl });
+}
+function connectViaXHR(input) {
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        let settled = false;
+        let stopped = false;
+        let index = 0;
+        let buffer = "";
+        const stop = () => {
+            stopped = true;
+            xhr.abort();
+        };
+        const settle = (handler, value) => {
+            if (!settled) {
+                settled = true;
+                handler(value);
+            }
+        };
+        const consume = () => {
+            buffer = emitFrames(xhr.responseText.slice(index), buffer, input.onEvent);
+            index = xhr.responseText.length;
+        };
+        xhr.open("GET", input.url, true);
+        xhr.setRequestHeader("Accept", "text/event-stream");
+        xhr.onreadystatechange = () => {
+            if (xhr.readyState !== xhr.HEADERS_RECEIVED) {
+                return;
+            }
+            if (xhr.status >= 400) {
+                settle(reject, new Error(xhr.responseText || `Chatting live stream failed with ${xhr.status}.`));
+                stop();
+                return;
+            }
+            settle(resolve, stop);
+        };
+        xhr.onprogress = consume;
+        xhr.onerror = () => {
+            settle(reject, new Error("Chatting live stream failed."));
+            if (!stopped) {
+                input.onDisconnect?.(new Error("Chatting live stream failed."));
+            }
+        };
+        xhr.onload = () => {
+            consume();
+            if (!stopped) {
+                input.onDisconnect?.();
+            }
+        };
+        xhr.send();
+    });
+}
+async function connectViaFetch(input) {
+    const controller = new AbortController();
+    const response = await input.fetchImpl(input.url, {
+        method: "GET",
+        cache: "no-store",
+        headers: { Accept: "text/event-stream" },
+        signal: controller.signal
+    });
+    if (!response.ok) {
+        controller.abort();
+        throw new Error(await response.text() || `Chatting live stream failed with ${response.status}.`);
+    }
+    const reader = response.body?.getReader?.();
+    if (!reader) {
+        controller.abort();
+        throw new ChattingLiveStreamUnsupportedError();
+    }
+    let stopped = false;
+    let buffer = "";
+    void (async () => {
+        const decoder = new TextDecoder();
+        let disconnectError;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer = emitFrames(decoder.decode(value, { stream: true }), buffer, input.onEvent);
+            }
+        }
+        catch (error) {
+            disconnectError = error;
+        }
+        finally {
+            if (!stopped && !controller.signal.aborted) {
+                input.onDisconnect?.(disconnectError);
+            }
+        }
+    })();
+    return () => {
+        stopped = true;
+        controller.abort();
+        void reader.cancel().catch(() => undefined);
+    };
+}
+function emitFrames(chunk, existing, onEvent) {
+    const frames = `${existing}${chunk}`.split(/\r?\n\r?\n/);
+    const remainder = frames.pop() ?? "";
+    for (const frame of frames) {
+        const data = frame
+            .split(/\r?\n/)
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trimStart())
+            .join("\n");
+        if (!data) {
+            continue;
+        }
+        try {
+            const payload = JSON.parse(data);
+            if (typeof payload.type === "string") {
+                onEvent(payload);
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return remainder;
+}

package/dist/chatting-poller.d.ts

@@ -0,0 +1,11 @@
+import type { ChattingConversationState } from "./chatting-types";
+type PollingClient = {
+    fetchConversation(): Promise<ChattingConversationState>;
+};
+export declare function startConversationPolling(input: {
+    client: PollingClient;
+    intervalMs?: number;
+    onConversation(conversation: ChattingConversationState): void;
+    onError?(error: unknown): void;
+}): () => void;
+export {};

package/dist/chatting-poller.js

@@ -0,0 +1,41 @@
+export function startConversationPolling(input) {
+    let lastKey = "";
+    let timeout = null;
+    let stopped = false;
+    const tick = async () => {
+        try {
+            const conversation = await input.client.fetchConversation();
+            const nextKey = snapshotKey(conversation);
+            if (nextKey !== lastKey) {
+                lastKey = nextKey;
+                input.onConversation(conversation);
+            }
+        }
+        catch (error) {
+            input.onError?.(error);
+        }
+        finally {
+            if (!stopped) {
+                timeout = setTimeout(() => void tick(), input.intervalMs ?? 3000);
+            }
+        }
+    };
+    void tick();
+    return () => {
+        stopped = true;
+        if (timeout) {
+            clearTimeout(timeout);
+        }
+    };
+}
+function snapshotKey(conversation) {
+    const lastMessage = conversation.messages.at(-1);
+    return JSON.stringify({
+        conversationId: conversation.conversationId,
+        count: conversation.messages.length,
+        lastMessageId: lastMessage?.id ?? null,
+        lastMessageAt: lastMessage?.createdAt ?? null,
+        faqCount: conversation.faqSuggestions?.items.length ?? 0,
+        fallback: conversation.faqSuggestions?.fallbackMessage ?? null
+    });
+}