@doany-ai/inbox 0.0.0-stage → 0.1.0

package/dist/components/parts.js

@@ -0,0 +1,115 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "@doany-ai/app-core";
+import { Button } from "@doany-ai/app-core/ui/button";
+import { ChevronRight } from "lucide-react";
+import { useEffect, useRef, useState } from "react";
+import { offerDay, textParts } from "../format.js";
+import { eventText } from "../labels.js";
+/** Plain text, with links only to the site's own hosts. */
+export function MessageText({ text, hosts }) {
+    return (_jsx(_Fragment, { children: textParts(text, hosts).map((part, index) => "href" in part ? (_jsx("a", { href: part.href, className: "underline underline-offset-2 [overflow-wrap:anywhere]", children: part.text }, index)) : (_jsx("span", { children: part.text }, index))) }));
+}
+const bubble = "max-w-[85%] whitespace-pre-wrap rounded-2xl px-3.5 py-2.5 text-sm leading-relaxed [overflow-wrap:anywhere]";
+/**
+ * A line from the business's side: the receptionist, a team member, or the
+ * greeting. `byline` goes under the last bubble of a group: who wrote it and when.
+ */
+export function TheirBubble({ children, byline }) {
+    return (_jsxs("div", { className: "flex flex-col items-start gap-1", children: [_jsx("div", { className: cn(bubble, "bg-muted text-foreground"), children: children }), byline ? _jsx("span", { className: "px-1 text-xs text-muted-foreground", children: byline }) : null] }));
+}
+/** The round initial beside a name: the site's primary colour, tinted. */
+export function Avatar({ name, className }) {
+    const initial = Array.from(name.trim())[0]?.toUpperCase() ?? "";
+    return (_jsx("span", { "aria-hidden": "true", className: cn("inline-flex h-9 w-9 shrink-0 items-center justify-center rounded-full bg-primary/15 text-sm font-semibold text-primary", className), children: initial }));
+}
+export function OwnBubble({ children, status }) {
+    return (_jsxs("div", { className: "flex flex-col items-end gap-1", children: [_jsx("div", { className: cn(bubble, "bg-primary text-primary-foreground"), children: children }), status ? _jsx("div", { className: "flex items-center gap-2 px-1 text-xs text-muted-foreground", children: status }) : null] }));
+}
+/** A fixed line the platform wrote (by its code): centered, quiet. The safety line stands out. */
+export function EventLine({ children, urgent }) {
+    return (_jsx("p", { className: cn("mx-auto max-w-[90%] text-center text-xs leading-relaxed", urgent ? "rounded-lg border border-destructive px-3 py-2 text-sm text-destructive" : "text-muted-foreground"), role: urgent ? "alert" : undefined, children: children }));
+}
+export function MessageRow({ message, labels, hosts, wait, byline = null, locale, renderBooking, onBooked = () => { }, newest = false, latestOffer = false, }) {
+    if (message.kind === "event") {
+        const code = typeof message.payload?.code === "string" ? message.payload.code : undefined;
+        const text = eventText(code, labels, wait);
+        return text ? _jsx(EventLine, { urgent: code === "safety", children: text }) : null;
+    }
+    if (message.author === "client") {
+        return message.text ? (_jsx(OwnBubble, { children: _jsx(MessageText, { text: message.text, hosts: hosts }) })) : null;
+    }
+    if (message.kind === "offer") {
+        return (_jsx(OfferCard, { message: message, labels: labels, hosts: hosts, byline: byline, locale: locale, renderBooking: renderBooking, onBooked: onBooked, newest: newest, latest: latestOffer }));
+    }
+    if (!message.text)
+        return null;
+    return (_jsx(TheirBubble, { byline: byline, children: _jsx(MessageText, { text: message.text, hosts: hosts }) }));
+}
+/** The offer a message carries: exactly what `renderBooking` is given. */
+function offerOf(message) {
+    const payload = message.payload ?? {};
+    const { service_setting_id, catalog_item_variant_id, date, timezone } = payload;
+    return typeof service_setting_id === "string" && typeof catalog_item_variant_id === "string" && typeof date === "string" && typeof timezone === "string"
+        ? { service_setting_id, catalog_item_variant_id, date, timezone }
+        : null;
+}
+/**
+ * An offer from the receptionist: the day and that day's open times, written
+ * by the platform with their timezone, and the site's own booking flow on
+ * that day. The flow is already open under the thread's newest message; an
+ * older offer is a card with Book, which opens it. An open flow stays open
+ * when a line follows it (a reply, "You're booked") and gives way to a card
+ * when a newer offer arrives. The times are not held: the flow reads them again.
+ */
+function OfferCard({ message, labels, hosts, byline, locale, renderBooking, onBooked, newest, latest, }) {
+    const [booking, setBooking] = useState(newest);
+    useEffect(() => {
+        if (newest)
+            setBooking(true);
+        else if (!latest)
+            setBooking(false);
+    }, [newest, latest]);
+    const flowRef = useRef(null);
+    const offer = offerOf(message);
+    const day = offer ? offerDay(offer.date, locale) : null;
+    const times = typeof message.payload?.times_text === "string" ? message.payload.times_text : null;
+    useEffect(() => {
+        if (booking)
+            flowRef.current?.scrollIntoView?.({ block: "nearest" });
+    }, [booking]);
+    return (_jsxs("div", { className: "space-y-2", children: [_jsxs(TheirBubble, { byline: byline, children: [message.text ? _jsx(MessageText, { text: message.text, hosts: hosts }) : null, day ? _jsx("span", { className: cn("block font-semibold", message.text && "mt-1"), children: day }) : null, times ? _jsx("span", { className: "block", children: times }) : null, offer && renderBooking && !booking ? (_jsx(Button, { type: "button", size: "sm", className: "mt-2", onClick: () => setBooking(true), children: labels.bookOffer })) : null] }), offer && renderBooking && booking ? (_jsx("div", { ref: flowRef, className: "min-w-0 rounded-lg border border-border bg-background text-foreground", children: renderBooking(offer, { onBooked }) })) : null] }));
+}
+/**
+ * Three dots while an answer is on its way. The words are real text for a
+ * screen reader: the message log around it announces them when they appear.
+ */
+export function TypingDots({ label }) {
+    return (_jsxs("div", { className: "flex items-start", children: [_jsx("span", { className: "sr-only", children: label }), _jsx("div", { className: "flex items-center gap-1 rounded-2xl bg-muted px-3.5 py-3.5", children: [0, 150, 300].map((delay) => (_jsx("span", { "aria-hidden": "true", className: "h-1.5 w-1.5 animate-bounce rounded-full bg-muted-foreground", style: { animationDelay: `${delay}ms` } }, delay))) })] }));
+}
+/** One of Home's cards: a full-width row with an arrow, a button or a link. */
+export function HomeCard({ icon: Icon, title, sub, href, onClick }) {
+    const className = "flex w-full items-center gap-3 rounded-xl border border-border bg-card px-4 py-3 text-left text-card-foreground shadow-soft transition-colors hover:bg-accent hover:text-accent-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring";
+    const body = (_jsxs(_Fragment, { children: [_jsx(Icon, { "aria-hidden": "true", className: "h-5 w-5 shrink-0 text-primary" }), _jsxs("span", { className: "min-w-0 flex-1", children: [_jsx("span", { className: "block text-sm font-semibold", children: title }), sub ? _jsx("span", { className: "block truncate text-xs text-muted-foreground", children: sub }) : null] }), _jsx(ChevronRight, { "aria-hidden": "true", className: "h-4 w-4 shrink-0 text-muted-foreground" })] }));
+    return href ? (_jsx("a", { href: href, className: className, children: body })) : (_jsx("button", { type: "button", className: className, onClick: onClick, children: body }));
+}
+/** Whether the page is in front: replies are marked seen only then. */
+export function usePageVisible(onShow) {
+    const [visible, setVisible] = useState(() => typeof document === "undefined" || document.visibilityState !== "hidden");
+    useEffect(() => {
+        if (typeof document === "undefined")
+            return;
+        const changed = () => {
+            const now = document.visibilityState !== "hidden";
+            setVisible(now);
+            if (now)
+                onShow();
+        };
+        window.addEventListener("focus", onShow);
+        document.addEventListener("visibilitychange", changed);
+        return () => {
+            window.removeEventListener("focus", onShow);
+            document.removeEventListener("visibilitychange", changed);
+        };
+    }, [onShow]);
+    return visible;
+}

package/dist/core.d.ts

@@ -0,0 +1,6 @@
+export { CONFIG_TTL_MS, inboxKeys, useInbox, type UseInboxOptions, type UseInboxResult } from "./hooks.js";
+export { BOOKING_REPORT_FOR_MS, BOOKING_REPORT_MS, IDLE_MS, InboxSession, MAX_BACKOFF_MS, POLL_CLOSED_MS, POLL_OPEN_MS, POLL_REPLY_MS, refusalOf, type InboxDraft, type InboxPendingMessage, type InboxProblem, type InboxSessionOptions, type InboxStartInput, type InboxState, } from "./session.js";
+export { READ_KEY, defaultStorage, memoryStorage, type InboxStorage } from "./storage.js";
+export { aiNoticeText, defaultInboxLabels, eventText, inboxEventLabelKeys, inboxLabels, inboxSuggestedQuestionLabelKeys, isHandoverCode, saysTheWait, suggestedQuestionTexts, waitText, type InboxLabels, type InboxWait, } from "./labels.js";
+export { backAtParts, isHiddenPath, offerDay, relativeTime, textParts, type TextPart } from "./format.js";
+export type { InboxAvailability, InboxBooked, InboxBookingHooks, InboxBookingOffer, InboxClient, InboxConfig, InboxContact, InboxMe, InboxMessage, InboxPaths, InboxPendingStart, InboxSendParams, InboxSendReceipt, InboxStartParams, InboxStartReceipt, InboxSuggestedQuestion, InboxThreadPage, } from "./types.js";

package/dist/core.js

@@ -0,0 +1,7 @@
+// @doany-ai/inbox/core: the chat with no DOM and no router, for a site that
+// draws its own chat UI. `@doany-ai/inbox` adds the default <InboxWidget />.
+export { CONFIG_TTL_MS, inboxKeys, useInbox } from "./hooks.js";
+export { BOOKING_REPORT_FOR_MS, BOOKING_REPORT_MS, IDLE_MS, InboxSession, MAX_BACKOFF_MS, POLL_CLOSED_MS, POLL_OPEN_MS, POLL_REPLY_MS, refusalOf, } from "./session.js";
+export { READ_KEY, defaultStorage, memoryStorage } from "./storage.js";
+export { aiNoticeText, defaultInboxLabels, eventText, inboxEventLabelKeys, inboxLabels, inboxSuggestedQuestionLabelKeys, isHandoverCode, saysTheWait, suggestedQuestionTexts, waitText, } from "./labels.js";
+export { backAtParts, isHiddenPath, offerDay, relativeTime, textParts } from "./format.js";

package/dist/format.d.ts

@@ -0,0 +1,43 @@
+export type TextPart = {
+    text: string;
+} | {
+    text: string;
+    href: string;
+};
+/**
+ * A message's text in parts: plain text, and links where an address points at
+ * one of `hosts` (the site's live hostnames, compared without case). Anything
+ * else, another site included, stays text.
+ */
+export declare function textParts(text: string, hosts: readonly string[]): TextPart[];
+/** The weekday and time of `back_at` as the business's clock reads them (its own offset), in `locale`. */
+export declare function backAtParts(iso: string | null | undefined, locale?: string): {
+    day: string;
+    time: string;
+} | null;
+/**
+ * How long ago a message was written, as people read it in `locale`
+ * ("5 min. ago", "2 hr. ago", "3 days ago"). Null under a minute, which the
+ * chat words itself ("Just now"); empty for a value that is not a time.
+ */
+export declare function relativeTime(iso: string, now: number, locale?: string): string | null;
+/**
+ * An offer's day (`YYYY-MM-DD`, a day on the business's calendar) as people
+ * read it in `locale`: `Sat, Nov 14`. Read from the date's own fields, never as
+ * an instant, so it is the same day wherever the visitor is. Null for a value
+ * that is not a day.
+ */
+export declare function offerDay(date: string, locale?: string): string | null;
+/** Whether `pathname` is under one of the business's hidden path prefixes (`/checkout` hides `/checkout/paid`, not `/checkouts`). */
+export declare function isHiddenPath(pathname: string, prefixes: readonly string[] | undefined): boolean;
+/** The key the reply email's button carries in the address's hash. */
+export declare const LINK_PARAM = "doany_inbox";
+/** The emailed link's token, read with `URLSearchParams` from the hash. */
+export declare function linkTokenIn(hash: string): string | null;
+/** The hash without that one key; everything else in it stays as written. */
+export declare function hashWithoutLinkToken(hash: string): string;
+/** The platform's email check, run before anything is sent (doany-app-backend `forms/validation.py` `_EMAIL`). */
+export declare const EMAIL_PATTERN: RegExp;
+export declare const EMAIL_MAX = 254;
+export declare const NAME_MAX = 80;
+export declare const MESSAGE_MAX = 1000;

package/dist/format.js

@@ -0,0 +1,136 @@
+/** Where a chat's text may link: `http(s)` addresses only, and only to the site's own live hosts. */
+const URL_PATTERN = /https?:\/\/[^\s<>"'`]+/gi;
+const TRAILING = /[.,;:!?)\]}'"]+$/;
+/**
+ * A message's text in parts: plain text, and links where an address points at
+ * one of `hosts` (the site's live hostnames, compared without case). Anything
+ * else, another site included, stays text.
+ */
+export function textParts(text, hosts) {
+    const allowed = new Set(hosts.map((host) => host.toLowerCase()));
+    const parts = [];
+    let last = 0;
+    for (const match of text.matchAll(URL_PATTERN)) {
+        const start = match.index ?? 0;
+        const raw = match[0].replace(TRAILING, "");
+        let href = null;
+        try {
+            const url = new URL(raw);
+            if (allowed.has(url.hostname.toLowerCase()) && !url.username && !url.password)
+                href = url.href;
+        }
+        catch {
+            href = null;
+        }
+        if (!href)
+            continue;
+        if (start > last)
+            parts.push({ text: text.slice(last, start) });
+        parts.push({ text: raw, href });
+        last = start + raw.length;
+    }
+    if (last < text.length)
+        parts.push({ text: text.slice(last) });
+    return parts;
+}
+/** The weekday and time of `back_at` as the business's clock reads them (its own offset), in `locale`. */
+export function backAtParts(iso, locale) {
+    const match = iso ? /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/.exec(iso) : null;
+    if (!match)
+        return null;
+    const [, year, month, day, hour, minute] = match.map(Number);
+    const wall = Date.UTC(year, month - 1, day, hour, minute);
+    if (Number.isNaN(wall))
+        return null;
+    try {
+        return {
+            day: new Intl.DateTimeFormat(locale, { weekday: "short", timeZone: "UTC" }).format(wall),
+            time: new Intl.DateTimeFormat(locale, { hour: "numeric", minute: "2-digit", timeZone: "UTC" }).format(wall),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * How long ago a message was written, as people read it in `locale`
+ * ("5 min. ago", "2 hr. ago", "3 days ago"). Null under a minute, which the
+ * chat words itself ("Just now"); empty for a value that is not a time.
+ */
+export function relativeTime(iso, now, locale) {
+    const at = Date.parse(iso);
+    if (Number.isNaN(at))
+        return "";
+    const seconds = Math.max(0, Math.round((now - at) / 1000));
+    if (seconds < 60)
+        return null;
+    const [value, unit] = seconds < 3600 ? [Math.floor(seconds / 60), "minute"] : seconds < 86400 ? [Math.floor(seconds / 3600), "hour"] : [Math.floor(seconds / 86400), "day"];
+    try {
+        return new Intl.RelativeTimeFormat(locale, { numeric: "always", style: "short" }).format(-value, unit);
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * An offer's day (`YYYY-MM-DD`, a day on the business's calendar) as people
+ * read it in `locale`: `Sat, Nov 14`. Read from the date's own fields, never as
+ * an instant, so it is the same day wherever the visitor is. Null for a value
+ * that is not a day.
+ */
+export function offerDay(date, locale) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date);
+    if (!match)
+        return null;
+    const [, year, month, day] = match.map(Number);
+    const wall = Date.UTC(year, month - 1, day);
+    if (new Date(wall).getUTCDate() !== day)
+        return null;
+    try {
+        return new Intl.DateTimeFormat(locale, { weekday: "short", month: "short", day: "numeric", timeZone: "UTC" }).format(wall);
+    }
+    catch {
+        return null;
+    }
+}
+/** Whether `pathname` is under one of the business's hidden path prefixes (`/checkout` hides `/checkout/paid`, not `/checkouts`). */
+export function isHiddenPath(pathname, prefixes) {
+    return (prefixes ?? []).some((prefix) => {
+        const base = prefix.length > 1 ? prefix.replace(/\/+$/, "") : prefix;
+        if (!base)
+            return false;
+        if (base === "/")
+            return true;
+        return pathname === base || pathname.startsWith(`${base}/`);
+    });
+}
+/** The key the reply email's button carries in the address's hash. */
+export const LINK_PARAM = "doany_inbox";
+/** The emailed link's token, read with `URLSearchParams` from the hash. */
+export function linkTokenIn(hash) {
+    if (!hash || hash.length < 2)
+        return null;
+    return new URLSearchParams(hash.slice(1)).get(LINK_PARAM) || null;
+}
+/** The hash without that one key; everything else in it stays as written. */
+export function hashWithoutLinkToken(hash) {
+    const rest = hash
+        .slice(1)
+        .split("&")
+        .filter((part) => part && decodeURIComponentSafe(part.split("=")[0]) !== LINK_PARAM)
+        .join("&");
+    return rest ? `#${rest}` : "";
+}
+function decodeURIComponentSafe(value) {
+    try {
+        return decodeURIComponent(value.replace(/\+/g, " "));
+    }
+    catch {
+        return value;
+    }
+}
+/** The platform's email check, run before anything is sent (doany-app-backend `forms/validation.py` `_EMAIL`). */
+export const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+export const EMAIL_MAX = 254;
+export const NAME_MAX = 80;
+export const MESSAGE_MAX = 1000;

package/dist/hooks.d.ts

@@ -0,0 +1,69 @@
+import { type InboxStartInput, type InboxState } from "./session.js";
+import { type InboxStorage } from "./storage.js";
+import type { InboxBooked, InboxConfig } from "./types.js";
+/** The query keys this package reads under, for invalidating from elsewhere. */
+export declare const inboxKeys: {
+    all: readonly ["doany", "inbox"];
+    config: () => readonly ["doany", "inbox", "config"];
+};
+/** The button's settings are read again at most this often alongside polling. */
+export declare const CONFIG_TTL_MS = 60000;
+export interface UseInboxOptions {
+    /** The panel is open: replies are read every 5 seconds and marked seen. Default false. */
+    open?: boolean;
+    /** The page is visible. Default true. Replies are marked seen only while it is. */
+    visible?: boolean;
+    /** Where the visitor is (`/pricing`), kept with the first message. */
+    pagePath?: string;
+    /** The visitor's language (`en-US`), kept with the first message. */
+    language?: string;
+    /** What this page can show beyond text: `["offer_booking"]` when it can open a booking flow from an offer card. */
+    capabilities?: string[];
+    /**
+     * Who is using the site: `guest`, or `user:<id>`. Left out, read from
+     * `<AuthProvider>` (a guest without one). The SDK keeps a chat per account,
+     * so a change reads the chat again.
+     */
+    actor?: string;
+    /** Where the package keeps which reply was last shown. Left out, the browser's localStorage. */
+    storage?: InboxStorage;
+    /** `false`: read nothing (the config included). Default true. */
+    enabled?: boolean;
+}
+export interface UseInboxResult extends InboxState {
+    /** The button's settings, once read. */
+    config: InboxConfig | undefined;
+    configLoading: boolean;
+    /** The site offers the chat now. */
+    available: boolean;
+    /** A site account is signed in: the first message may go without details. */
+    signedIn: boolean;
+    /** The first message of a chat. Resolves true once the platform has it. */
+    start(input: InboxStartInput): Promise<boolean>;
+    /** Sends a first message that was not confirmed again, unchanged. */
+    retryPending(): Promise<boolean>;
+    /** A later message. On false, keep the words: nothing was stored. */
+    send(text: string): Promise<boolean>;
+    /** Hands the chat to a person, with optional words. */
+    askForPerson(text?: string): Promise<boolean>;
+    /** Opens the token from a reply's emailed link (`#doany_inbox=`). */
+    resume(linkToken: string): Promise<boolean>;
+    /** A booking made from an offer in this chat (the booking flow's `onBooked`): the chat then shows it. */
+    reportBooking(result: InboxBooked): Promise<boolean>;
+    /** Forgets this browser's chat, with no call. */
+    newChat(): void;
+    /** The tab came back: polling restarts if it had stopped. */
+    wake(): void;
+    /** Clears the unread mark. */
+    markRead(): void;
+    /** Reads the button's settings again. */
+    refreshConfig(): void;
+}
+/**
+ * The chat on a site, with no DOM: the business's button settings, this
+ * browser's chat and its messages, and the calls that write.
+ * `<InboxWidget />` draws it; a site can draw its own.
+ *
+ * Mount it once per page: each instance keeps its own chat state and polls.
+ */
+export declare function useInbox(options?: UseInboxOptions): UseInboxResult;

package/dist/hooks.js

@@ -0,0 +1,112 @@
+import { useDoany } from "@doany-ai/app-core";
+import { useAuth } from "@doany-ai/app-core/auth";
+import { useQuery } from "@tanstack/react-query";
+import { useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { isHiddenPath } from "./format.js";
+import { InboxSession } from "./session.js";
+import { defaultStorage } from "./storage.js";
+/** The query keys this package reads under, for invalidating from elsewhere. */
+export const inboxKeys = {
+    all: ["doany", "inbox"],
+    config: () => [...inboxKeys.all, "config"],
+};
+/** The button's settings are read again at most this often alongside polling. */
+export const CONFIG_TTL_MS = 60000;
+/** `useAuth()` where there is an `<AuthProvider>`; null where there is none (the page passes `actor`). */
+function useOptionalAuth() {
+    try {
+        return useAuth();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The chat on a site, with no DOM: the business's button settings, this
+ * browser's chat and its messages, and the calls that write.
+ * `<InboxWidget />` draws it; a site can draw its own.
+ *
+ * Mount it once per page: each instance keeps its own chat state and polls.
+ */
+export function useInbox(options = {}) {
+    const client = useDoany();
+    const auth = useOptionalAuth();
+    const enabled = options.enabled !== false;
+    const [session] = useState(() => new InboxSession(client, options.storage ?? defaultStorage()));
+    const state = useSyncExternalStore(session.subscribe, session.getState, session.getState);
+    const config = useQuery({
+        queryKey: inboxKeys.config(),
+        queryFn: () => client.inbox.config(),
+        enabled,
+        staleTime: CONFIG_TTL_MS,
+    });
+    // Who the chat belongs to is known once the sign-in is.
+    const actor = options.actor ?? (auth ? (auth.user ? `user:${auth.user.id}` : auth.authChecked || !auth.isLoadingAuth ? "guest" : null) : "guest");
+    useEffect(() => {
+        if (!enabled)
+            return;
+        session.attach();
+        return () => session.detach();
+    }, [session, enabled]);
+    useEffect(() => {
+        if (enabled && actor)
+            session.setActor(actor);
+    }, [session, enabled, actor]);
+    const open = options.open ?? false;
+    const visible = options.visible ?? true;
+    const capabilities = options.capabilities?.join(",") ?? "";
+    // The chat is read where it is offered (the business has the button on and
+    // this page is not one it hides), or while the panel is open.
+    const offered = config.data?.enabled === true && !(options.pagePath !== undefined && isHiddenPath(options.pagePath, config.data.hidden_paths));
+    const active = open || offered;
+    useEffect(() => {
+        session.setOptions({
+            active,
+            open,
+            visible,
+            pagePath: options.pagePath,
+            language: options.language,
+            capabilities: capabilities ? capabilities.split(",") : undefined,
+        });
+    }, [session, active, open, visible, options.pagePath, options.language, capabilities]);
+    // Read the settings again when the panel opens, and at most once a minute alongside the poll.
+    const refetch = config.refetch;
+    const updatedAt = useRef(0);
+    updatedAt.current = config.dataUpdatedAt;
+    useEffect(() => {
+        if (open && enabled)
+            void refetch();
+    }, [open, enabled, refetch]);
+    // A write said the button is off: the settings say what to show now.
+    const offNow = state.off || state.problem === "off";
+    useEffect(() => {
+        if (offNow && enabled)
+            void refetch();
+    }, [offNow, enabled, refetch]);
+    useEffect(() => {
+        session.onPoll = () => {
+            if (Date.now() - updatedAt.current >= CONFIG_TTL_MS)
+                void refetch();
+        };
+        return () => {
+            session.onPoll = null;
+        };
+    }, [session, refetch]);
+    return {
+        ...state,
+        config: config.data,
+        configLoading: config.isPending,
+        available: config.data?.enabled === true,
+        signedIn: Boolean(auth?.user) || (options.actor !== undefined && options.actor !== "guest"),
+        start: session.start,
+        retryPending: session.retryPending,
+        send: session.send,
+        askForPerson: session.askForPerson,
+        resume: session.resume,
+        reportBooking: session.reportBooking,
+        newChat: session.newChat,
+        wake: () => session.wake(),
+        markRead: session.markRead,
+        refreshConfig: () => void refetch(),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./core.js";
+export { InboxWidget, type InboxWidgetProps } from "./components/inbox-widget.js";
+export type { RenderBooking } from "./components/parts.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+// @doany-ai/inbox: the chat button on a Doany site.
+//
+// useInbox() holds the chat with no DOM, through the SDK client given to
+// app-core's <DoanyProvider> (`client.inbox`). <InboxWidget /> is the site's
+// button and panel: restyled through the theme variables, adjusted through
+// props (its words through `labels`), or replaced while keeping the hook. The
+// package ships no CSS: the site's Tailwind build scans it (see
+// @doany-ai/app-core/tailwind-preset).
+export * from "./core.js";
+export { InboxWidget } from "./components/inbox-widget.js";