@lorikeetai/react-native-sdk 2.0.0-alpha.2 → 2.0.0-alpha.3

package/dist/index.d.ts

@@ -4,50 +4,118 @@ import { WebView, WebViewMessageEvent, WebViewProps } from "react-native-webview
 type ConversationMetadata = Record<string, unknown>;
 //#endregion
 //#region src/customisations.d.ts
+/**
+ * What the chat page accepts as `customisations`, as the SDK's own types.
+ *
+ * A copy of the web SDK's shape rather than an import of it. The web SDK is a
+ * browser bundle an app has no reason to install, and importing a type from it
+ * left the published `dist/index.d.ts` referencing a module consumers do not
+ * have: `Customisations` then degraded to `any` and typed nothing.
+ * `ConversationMetadata` is duplicated here for the same reason.
+ *
+ * `src/customisations.web-sdk-parity.ts` fails the build if the two drift.
+ *
+ * Fields that only mean something on a web page, the viewport sizes and the
+ * launcher button, are kept so the page's behaviour is unchanged and so a host
+ * sharing one configuration object with its web widget still type-checks.
+ */
+/** Sizing for one viewport. Desktop only: the page is full-screen on mobile. */
 interface ViewportCustomisations {
+  /** Clamped to a 2rem maximum. */
   borderRadius?: string;
   default_open?: boolean;
+  /** Clamped to the viewport minus `topClearance`, and to a 20rem minimum. */
   height?: string;
+  /** Reserved space above the widget. Desktop default 6.5rem. */
   topClearance?: string;
   width?: string;
 }
 interface Customisations {
+  /** Falls back to the logo image. */
   avatarUrl?: string;
   botName?: string;
   desktop?: ViewportCustomisations;
+  /**
+   * Which header the customer gets, not whether there is one. `true` hides the
+   * page's own; `false` keeps it, and it carries Close and End chat.
+   *
+   * What replaces a hidden one is the host's business, so there is no one
+   * default to quote. `LorikeetWidgetView` substitutes its own header, a title
+   * and new chat, and does so when this is omitted. `LorikeetClient` only
+   * serialises the flag and renders nothing, so a composed host keeps the page's
+   * header unless it asks for it to go, and must render `LorikeetWidgetHeader`
+   * itself when it does.
+   */
   hideHeader?: boolean;
+  /** @default '_blank' */
   linkTarget?: '_blank' | '_parent';
   logoUrl?: string;
   messages?: {
+    /** Shown when the widget is in an unexpectedly failed state. */
     failOver?: string;
+    /** Shown when live chat has been switched off deliberately. */
     unavailable?: string;
+    /**
+     * Replaces the line under "Someone is taking a look", for a conversation
+     * handed to a person. Say where the reply will come from when the default
+     * should not promise it.
+     */
     escalated?: string;
   };
   mobile?: ViewportCustomisations;
   mode?: 'controlled' | 'uncontrolled';
+  /**
+   * Styling for the launcher button the web widget renders. The React Native
+   * SDK renders no launcher, so this reaches the page and does nothing.
+   *
+   * @danger Experimental and may change.
+   */
   rootElement?: {
     border?: string;
     borderRadius?: string;
     zIndex?: number;
     bottom?: string;
     right?: string;
+    /** Any CSS size value. Defaults to 3rem. */
     size?: string;
   };
+  /** Show dates as well as times, on every message. */
   showVerboseTimestamps?: boolean;
   theme?: CustomisationTheme;
   title?: string;
+  /** @default false */
   useSubtleBranding?: boolean;
 }
 interface CustomisationTheme {
+  /**
+   * Colour or gradient for the main area. Any colour value, and any gradient
+   * function including multiple layers. Image-based backgrounds are not
+   * supported. Takes precedence over `backgroundColor`.
+   */
   background?: string;
   backgroundColor?: string;
+  /** Accent fill, currently the header. Resolves to a neutral when unset. */
   brandAccentColor?: string;
   brandColor?: string;
+  /** @default 'light' */
   colorMode?: 'light' | 'dark';
   fontFamily?: string;
+  /**
+   * Google Fonts CSS URL declaring the `@font-face` rules for `fontFamily`.
+   * The page ships Inter only, so a brand font the device lacks falls back
+   * unless its files are loaded. Host must be `fonts.googleapis.com`, path
+   * `/css` or `/css2`, and only `family` and `display` params; anything else is
+   * ignored.
+   */
   fontUrl?: string;
+  /**
+   * Colour or gradient for the header, on the same terms as `background`.
+   * Takes precedence over `brandAccentColor`.
+   */
   headerBackground?: string;
+  /** For text on a dark background. */
   inverseTextColor?: string;
+  /** Falls back to the brand colour. */
   linkColor?: string;
   linkHoverColor?: string;
   secondaryBrandColor?: string;
@@ -56,84 +124,346 @@ interface CustomisationTheme {
 }
 //#endregion
 //#region src/events.d.ts
-type LorikeetWidgetEvent = {
+/**
+ * What the page reports, as events rather than as raw bridge messages.
+ *
+ * Names follow the web SDK's (`LorikeetEvent` in `@lorikeetai/web-sdk/types`)
+ * wherever it has one, because a host that integrates both should not have to
+ * learn two vocabularies. The rest cover what the page tells a host that owns
+ * its own layout and storage, which on web the SDK handles internally and never
+ * surfaces: the close handshake, the persistence messages, the logout
+ * confirmation, and error codes. `logout_failed` is the one the SDK reports
+ * itself, for a page that said nothing when it had to.
+ *
+ * `token_expiry` is deliberately absent. The credential model it belongs to is
+ * being rewritten, and an event is the hardest thing to take back. Nothing
+ * carrying a credential is translated at all, for the same reason.
+ */
+type LorikeetWidgetEvent =
+/** The page is up and the conversation is usable. */
+{
   type: 'ready';
-} | {
+} |
+/**
+ * A ticket that did not exist before this page loaded. Once per ticket, and
+ * never for a resume, matching the web SDK.
+ */
+{
   type: 'ticket_created';
   ticketId: string;
-} | {
+} |
+/** The customer sent something. */
+{
   type: 'customer_message';
-} | {
+} |
+/**
+ * The agent sent something. `markUnread` is the page asking for an unread
+ * indicator, which it only does where its live chat experience is on; the web
+ * SDK's launcher dot is driven by it, and it badges only while the widget is
+ * out of sight.
+ *
+ * Absent from a page older than the release that added it, which is not the
+ * same as `false`.
+ */
+{
   type: 'agent_message';
   markUnread?: boolean;
-} | {
+} |
+/**
+ * The page closed itself, and why. `ended_by_customer` is followed by a
+ * `new_chat`, seconds later, so a host that tears down here never sees the
+ * rest of the handshake. `minimised` has nothing behind it: the conversation
+ * is intact and hiding it is enough.
+ *
+ * `reason` is absent from a page older than the release that added it.
+ */
+{
   type: 'close';
   reason?: 'ended_by_customer' | 'minimised';
-} | {
+} |
+/**
+ * The conversation ended without the customer ending it: an agent closed it,
+ * or it timed out. Nothing follows, and nothing is asking the host to hide
+ * anything. Left unhandled, this is the customer stranded on a conversation
+ * that can no longer be used.
+ */
+{
   type: 'conversation_ended';
-} | {
+} |
+/**
+ * The page asking for a replacement conversation. It cannot navigate itself,
+ * so acting on this is the host's half of End chat.
+ */
+{
   type: 'new_chat';
-} | {
+} |
+/**
+ * Store this against the customer, alongside the session. A resume needs both:
+ * the ticket alone fails with `CUSTOMER_ID_MISSING`.
+ */
+{
   type: 'persist_ticket_id';
   ticketId: string;
-} | {
+} |
+/** The other half of the stored pair. Arrives separately and in no order. */
+{
   type: 'persist_session';
   session: string;
-} | {
+} |
+/**
+ * `/logout` cleared the frame: the chat's cookies for this key, server-side,
+ * and the storage the page kept. Reached by navigating the WebView to
+ * `LorikeetClient.getLogoutUrl()`, and the only confirmation that the
+ * clearing happened. The page's load event is not: an error page fires that
+ * too.
+ *
+ * `persistAnonymousSessionToken` is deliberately not translated. It carries a
+ * 365-day identity credential, this SDK offers no way to use one, and the web
+ * SDK keeps the same message inside the frame rather than handing it to its
+ * host. A typed event would be a published commitment to storing it, days
+ * before the hand-off protocol is meant to stop putting it in a URL at all.
+ */
+{
   type: 'logged_out';
-} | {
+} |
+/**
+ * The SDK's own report, not the page's: `/logout` did not confirm inside
+ * `LOGOUT_CONFIRMATION_TIMEOUT_MS`, so the previous customer may still be
+ * signed in on this device.
+ *
+ * The widget stays unavailable rather than starting the next customer's chat,
+ * because the alternative is handing them a device the last one's credentials
+ * still open. Call `logout()` again to retry.
+ */
+{
   type: 'logout_failed';
-} | {
+} |
+/** A page-level failure. `LORIKEET_ERROR_CODES` lists the codes. */
+{
   type: 'error';
   error: string;
-} | {
+} |
+/**
+ * The preload page finished warming, and what the server said about it.
+ *
+ * Unreachable from React Native, and published in error. The preload page
+ * posts straight to `window.parent` behind a `window.parent !== window`
+ * guard, which is false in a WebView, so it never takes the native bridge the
+ * page's other messages go through. Kept because removing a published union
+ * member is a breaking change; retire it when 2.x leaves alpha, or when the
+ * page learns to post it natively.
+ */
+{
   type: 'preload_complete';
   clientStart: boolean;
   lazyTicketCreationEnabled: boolean;
 };
+/** The names, spelled out rather than derived, so callers import a real type. */
 type LorikeetWidgetEventType = 'agent_message' | 'close' | 'conversation_ended' | 'customer_message' | 'error' | 'logged_out' | 'logout_failed' | 'new_chat' | 'persist_session' | 'persist_ticket_id' | 'preload_complete' | 'ready' | 'ticket_created';
 //#endregion
 //#region src/types.d.ts
 interface LorikeetInitOptions {
+  /**
+   * The base URL of the Lorikeet API for the widget to interact with.
+   */
   api_base?: string;
+  /**
+   * The options available to customise the widget.
+   */
   customisations?: Customisations;
+  /**
+   * Arbitrary context to attach to the conversation. Sent as JSON, not base64,
+   * which is what both the widget route and the resume route expect.
+   */
   metadata?: ConversationMetadata;
+  /**
+   * The public key to use.
+   */
   public_key: string;
 }
 type LorikeetWidgetWebViewProps = {
+  /**
+   * The URI of the widget.
+   */
   uri: string;
+  /**
+   * The base URL of the Lorikeet API for the widget to interact with.
+   */
   baseUrl?: string;
+  /**
+   * The props for the react-native-webview component
+   */
   webviewProps?: WebViewProps;
+  /**
+   * What the page reported, as typed events rather than raw bridge messages.
+   *
+   * This component reports; it does not act. A host composing it owns its own
+   * URL, layout and storage, so hiding on a close, rebuilding a resume URL or
+   * recovering from process loss are all theirs to do. `LorikeetWidgetView`
+   * consumes this same path and acts on top of it, because it owns the URL.
+   */
   onEvent?: (event: LorikeetWidgetEvent) => void;
 };
 type LorikeetWidgetHeaderProps = {
+  /**
+   * The title of the widget.
+   */
   title: string;
+  /**
+   * The style of the header text.
+   */
   style?: StyleProp<TextStyle>;
+  /**
+   * The icon to display in the header.
+   */
   icon?: React.ReactNode;
+  /**
+   * The function to call when the icon is pressed.
+   */
   onIconPress?: () => void;
 };
+/**
+ * What a host can ask `LorikeetWidgetView` to do, through a ref. Imperative
+ * because logging out and reopening are events on the host's side rather than
+ * states the widget can read off its props.
+ */
 type LorikeetWidgetHandle = {
+  /**
+   * The conversation the widget would resume right now, or `null` when it has
+   * none to resume.
+   *
+   * The pull half of `persist_ticket_id` and `persist_session`. Those report a
+   * conversation as the page names it; this answers what the widget is on after
+   * it has acted, which is not always the same thing. A resume the server
+   * refuses is replaced, and a new chat replaces whatever came before it, so a
+   * host holding what it passed at mount can be holding a conversation that no
+   * longer exists.
+   *
+   * `null` means exactly that the widget has nothing to resume: no conversation
+   * reported yet, only half of one, the credentials have moved on, or the
+   * customer has been logged out. It does not mean the conversation is over. A
+   * conversation the customer ended is still reported, because that is still
+   * what the widget is on and what its own recovery would resume; `close` and
+   * its `reason` are how you hear that it ended.
+   *
+   * Reports what is on screen, so inside an `onEvent` handler it is still what
+   * was on screen before that event: read `reason` on the `close` rather than
+   * calling this from the handler. Read it again after a change rather than
+   * caching what it said.
+   */
   getConversation: () => {
     minimised: boolean;
     session?: string;
     ticketId?: string;
   } | null;
+  /**
+   * Clear this customer's chat from the device, for the credentials currently in
+   * props. Navigates the WebView to the page's own `/logout`, which drops the
+   * chat's cookies and the storage the page keeps; neither is reachable from
+   * native code, so clearing your stored `ticketId` and `session` alone leaves
+   * the conversation reopenable by the next person on the device.
+   *
+   * The widget renders nothing but that page until it confirms, and changing
+   * `publicKey`, `baseUrl` or `authToken` does not cut it short: signing the
+   * next customer in mid-clear would leave the previous one's cookies on the
+   * device. Wait for `logged_out` on `onEvent`, then pass the next credentials.
+   *
+   * A page that does not confirm within ten seconds reports `logout_failed` and
+   * leaves the widget unavailable rather than opening a chat on a device the
+   * previous customer's credentials still unlock. Call this again to retry; a
+   * retry while one is pending retries that customer, not whoever is in props
+   * by then.
+   *
+   * `logout_failed` outlives this component, and the obligation with it. The
+   * SDK stores nothing, so a widget unmounted before the clear confirmed, by a
+   * screen change or an app restart, comes back with no memory of it and will
+   * open a chat normally. Record the failure where you record the conversation,
+   * and call `logout()` again before you mount a chat for anyone else.
+   *
+   * Clear your own stored `ticketId` and `session` as well.
+   */
   logout: () => void;
+  /**
+   * Show a minimised conversation again, exactly as the customer left it.
+   * Nothing reloads and nothing is reported, so the conversation keeps its
+   * place, its draft and its stream.
+   *
+   * For a host with its own launcher. The widget already offers a control of
+   * its own while minimised, and it does the same thing.
+   *
+   * A no-op unless the widget is minimised. A conversation the customer ended
+   * is left alone, because it only reopens read-only, and so is one the
+   * credentials have moved on from.
+   */
   reopen: () => void;
 };
 type LorikeetWidgetViewProps = {
+  /**
+   * The public key to use.
+   */
   publicKey: string;
+  /**
+   * The base URL of the Lorikeet API for the widget to interact with.
+   */
   baseUrl?: string;
+  /**
+   * The auth token to use when retrieving the widget URL.
+   */
   authToken: string;
+  /**
+   * The function to call when a message is received from the webview.
+   *
+   * @deprecated Prefer `onEvent`, which reports the page's messages as typed
+   * events rather than raw JSON a host has to match on by string. Still called,
+   * and still additive with `webviewProps.onMessage`.
+   *
+   * `onEvent` is not a superset. Messages the SDK deliberately leaves
+   * untranslated, `persistAnonymousSessionToken` among them, arrive on the raw
+   * bridge only. Read those through `webviewProps.onMessage`, which carries the
+   * same stream and is not deprecated, rather than taking this prop for them.
+   */
   onWebViewMessage?: (event: WebViewMessageEvent) => void;
+  /**
+   * What the page reported, as typed events. The same stream
+   * `LorikeetWidgetWebView` emits, after the widget has acted on it.
+   */
   onEvent?: (event: LorikeetWidgetEvent) => void;
+  /**
+   * The options available to customise the widget.
+   */
   customisations?: Customisations;
+  /**
+   * The style of the components - limited to header text
+   */
   styles?: {
     header?: StyleProp<TextStyle>;
   };
+  /**
+   * Resume this conversation instead of starting a new one. Without it the
+   * widget boots `/widget`, which mints a fresh ticket on every mount.
+   *
+   * Take it from the `persistLorikeetTicketId` message and store it yourself;
+   * the SDK has no storage of its own.
+   */
   ticketId?: string;
+  /**
+   * The session token last reported by `persistLorikeetSession`, stored
+   * alongside `ticketId`. The ticket route needs it to authorise a WebView that
+   * has no cookie yet, so a resume without it fails with CUSTOMER_ID_MISSING.
+   */
   session?: string;
+  /**
+   * Arbitrary context to attach to the conversation, for routing or for the
+   * agent to read. Survives a resume: the ticket route forwards it into the
+   * re-init URL.
+   */
   metadata?: ConversationMetadata;
+  /**
+   * Props forwarded to the underlying react-native-webview. The SDK supplies
+   * defaults for media playback, scaling and the loading state, and any of them
+   * can be overridden here. `onMessage` is additive rather than an override:
+   * the SDK reads the bridge first and then calls yours.
+   */
   webviewProps?: WebViewProps;
 };
 //#endregion
@@ -156,14 +486,44 @@ declare class LorikeetClient {
     ticket_id?: string;
     token: string;
   }) => string;
+  /**
+   * The page that clears this key's credentials from the WebView: its cookies,
+   * server-side, and the storage the frame keeps. Navigating a WebView here is
+   * the only way to reach either, so a host that only drops its own copy of
+   * `ticketId` and `session` leaves the next person on the device able to
+   * reopen the conversation.
+   *
+   * The page confirms with a `loggedOut` message, which the SDK reports as
+   * `logged_out`. The load event does not: an error page fires that too.
+   */
   getLogoutUrl: () => string;
 }
 //#endregion
 //#region src/errors.d.ts
+/**
+ * Codes the chat page posts to the host as `{ type: 'error', error: CODE }`.
+ * Mirrored here because the page publishes them nowhere else, so a host would
+ * otherwise be matching on strings it discovered by observation.
+ */
 declare const LORIKEET_ERROR_CODES: readonly ["MISSING_TOKEN", "CORRUPT_TOKEN_DATA", "DECRYPT_FAILED", "EXPIRED_TOKEN", "MALFORMED_TOKEN", "MISSING_PUBLIC_KEY", "UNKNOWN_PUBLIC_KEY", "CUSTOMER_ID_CONFLICT", "CUSTOMER_ID_MISSING", "FATAL_ERROR", "INVALID_SESSION", "DOMAIN_NOT_ALLOWED", "TICKET_NOT_FOUND"];
 type LorikeetErrorCode = (typeof LORIKEET_ERROR_CODES)[number];
+/** Whether an error code means the stored conversation cannot be reopened. */
 declare function isUnusableConversationCode(code: string): boolean;
 declare function isUnusableConversation(message: unknown): boolean;
 //#endregion
-export { type CustomisationTheme, type Customisations, LORIKEET_ERROR_CODES, LorikeetClient, type LorikeetErrorCode, type LorikeetInitOptions, type LorikeetWidgetEvent, type LorikeetWidgetEventType, type LorikeetWidgetHandle, LorikeetWidgetHeader, type LorikeetWidgetHeaderProps, LorikeetWidgetView, type LorikeetWidgetViewProps, LorikeetWidgetWebView, type LorikeetWidgetWebViewProps, isUnusableConversation, isUnusableConversationCode };
+//#region src/lifecycle.d.ts
+/**
+ * How long `/logout` gets to confirm it cleared the frame before the host is
+ * told it did not. Matches the web SDK's own budget, and like it, a logout that
+ * misses the deadline leaves the widget unavailable rather than letting the next
+ * customer start a chat on a device the previous one's credentials still open.
+ *
+ * `LorikeetWidgetView` applies this to its own `logout()`. Exported because a
+ * composed host has to run the timer itself and nothing else will report
+ * `logout_failed` for it, and two hosts choosing their own budgets is how one
+ * app calls a clear failed that the other never does.
+ */
+declare const LOGOUT_CONFIRMATION_TIMEOUT_MS = 10000;
+//#endregion
+export { type CustomisationTheme, type Customisations, LOGOUT_CONFIRMATION_TIMEOUT_MS, LORIKEET_ERROR_CODES, LorikeetClient, type LorikeetErrorCode, type LorikeetInitOptions, type LorikeetWidgetEvent, type LorikeetWidgetEventType, type LorikeetWidgetHandle, LorikeetWidgetHeader, type LorikeetWidgetHeaderProps, LorikeetWidgetView, type LorikeetWidgetViewProps, LorikeetWidgetWebView, type LorikeetWidgetWebViewProps, isUnusableConversation, isUnusableConversationCode };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/conversation-metadata.ts","../src/customisations.ts","../src/events.ts","../src/types.ts","../src/widget.tsx","../src/client.ts","../src/errors.ts"],"mappings":";;;KAEY,uBAAuB;;;UCezB;EAER;EACA;EAEA;EAEA;EACA;;UAGe;EAEf;EACA;EACA,UAAU;EAEV;EAEA;EACA;EACA;IAEE;IAEA;IAMA;;EAEF,SAAS;EACT;EAOA;IACE;IACA;IACA;IACA;IACA;IAEA;;EAGF;EACA,QAAQ;EACR;EAEA;;UAGe;EAMf;EACA;EAEA;EACA;EAEA;EACA;EAQA;EAKA;EAEA;EAEA;EACA;EACA;EACA;EACA;;;;KC9FU;EAEN;;EAKA;EAAwB;;EAExB;;EAUA;EAAuB;;EASvB;EAAe;;EAOf;;EAKA;;EAKA;EAA2B;;EAE3B;EAAyB;;EAczB;;EAUA;;EAEA;EAAe;;EAYf;EACA;EACA;;KAIM;;;UCnGK;EAIf;EAIA,iBAAiB;EAKjB,WAAW;EAIX;;KAGU;EAIV;EAIA;EAIA,eAAe;EASf,WAAW,OAAO;;KAGR;EAIV;EAIA,QAAQ,UAAU;EAIlB,OAAO,MAAM;EAIb;;KAQU;EAwBV;IACE;IACA;IACA;;EA4BF;EAaA;;KAGU;EAIV;EAIA;EAIA;EAQA,oBAAoB,OAAO;EAK3B,WAAW,OAAO;EAIlB,iBAAiB;EAIjB;IACE,SAAS,UAAU;;EASrB;EAMA;EAMA,WAAW;EAOX,eAAe;;;;cCtHJ,uCAAqB,0BAAA,6CAAA,cAAA;cA2HrB,yBAAwB,OAAA,OAAA,MAAA,eAKlC,8CAAyB,IAAA;cAYf,oCAAkB,0BAAA,0CAAA,cAAA;;;cCjOlB;EACX;EACA,gBAAgB;EAChB,UAAU;EACV;EAEY,cACV,gBACA,UACA,UACA,cACC;EAeH,kBAAiB,gBAAA,eAAA,OAAA,WAAA;IAOf;IACA;IACA;IACA;IACA;;EAmDF;;;;cCxFW;KAgBD,4BAA4B;iBAexB,2BAA2B;iBAK3B,uBAAuB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/conversation-metadata.ts","../src/customisations.ts","../src/events.ts","../src/types.ts","../src/widget.tsx","../src/client.ts","../src/errors.ts","../src/lifecycle.ts"],"mappings":";;;KAEY,uBAAuB;;;;;;;;;;;;;;;;;;;UCezB;;EAER;EACA;;EAEA;;EAEA;EACA;;UAGe;;EAEf;EACA;EACA,UAAU;;;;;;;;;;;;EAYV;;EAEA;EACA;EACA;;IAEE;;IAEA;;;;;;IAMA;;EAEF,SAAS;EACT;;;;;;;EAOA;IACE;IACA;IACA;IACA;IACA;;IAEA;;;EAGF;EACA,QAAQ;EACR;;EAEA;;UAGe;;;;;;EAMf;EACA;;EAEA;EACA;;EAEA;EACA;;;;;;;;EAQA;;;;;EAKA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;KCxGU;;;EAEN;;;;;;;EAKA;EAAwB;;;;EAExB;;;;;;;;;;;;EAUA;EAAuB;;;;;;;;;;;EASvB;EAAe;;;;;;;;;EAOf;;;;;;;EAKA;;;;;;;EAKA;EAA2B;;;;EAE3B;EAAyB;;;;;;;;;;;;;;;;EAczB;;;;;;;;;;;;EAUA;;;;EAEA;EAAe;;;;;;;;;;;;;EAYf;EACA;EACA;;;KAIM;;;UCnGK;;;;EAIf;;;;EAIA,iBAAiB;;;;;EAKjB,WAAW;;;;EAIX;;KAGU;;;;EAIV;;;;EAIA;;;;EAIA,eAAe;;;;;;;;;EASf,WAAW,OAAO;;KAGR;;;;EAIV;;;;EAIA,QAAQ,UAAU;;;;EAIlB,OAAO,MAAM;;;;EAIb;;;;;;;KAQU;;;;;;;;;;;;;;;;;;;;;;;;EAwBV;IACE;IACA;IACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BF;;;;;;;;;;;;;EAaA;;KAGU;;;;EAIV;;;;EAIA;;;;EAIA;;;;;;;;;;;;;EAaA,oBAAoB,OAAO;;;;;EAK3B,WAAW,OAAO;;;;EAIlB,iBAAiB;;;;EAIjB;IACE,SAAS,UAAU;;;;;;;;;EASrB;;;;;;EAMA;;;;;;EAMA,WAAW;;;;;;;EAOX,eAAe;;;;cC3HJ,uCAAqB,0BAAA,6CAAA,cAAA;cA2HrB,yBAAwB,OAAA,OAAA,MAAA,eAKlC,8CAAyB,IAAA;cAYf,oCAAkB,0BAAA,0CAAA,cAAA;;;cCjOlB;EACX;EACA,gBAAgB;EAChB,UAAU;EACV;EAEY,cACV,gBACA,UACA,UACA,cACC;EAeH,kBAAiB,gBAAA,eAAA,OAAA,WAAA;IAOf;IACA;IACA;IACA;IACA;;;;;;;;;;;;EAmDF;;;;;;;;;cCxFW;KAgBD,4BAA4B;;iBAexB,2BAA2B;iBAK3B,uBAAuB;;;;;;;;;;;;;;cCjB1B"}

package/dist/index.js

@@ -283,6 +283,11 @@ const BACKGROUND_RELOAD_THRESHOLD_MS = 18e4;
 * told it did not. Matches the web SDK's own budget, and like it, a logout that
 * misses the deadline leaves the widget unavailable rather than letting the next
 * customer start a chat on a device the previous one's credentials still open.
+*
+* `LorikeetWidgetView` applies this to its own `logout()`. Exported because a
+* composed host has to run the timer itself and nothing else will report
+* `logout_failed` for it, and two hosts choosing their own budgets is how one
+* app calls a clear failed that the other never does.
 */
 const LOGOUT_CONFIRMATION_TIMEOUT_MS = 1e4;
 /**
@@ -851,5 +856,5 @@ const LorikeetWidgetView = forwardRef(function LorikeetWidgetView({ publicKey, b
 LorikeetWidgetView.displayName = "LorikeetWidgetView";
 
 //#endregion
-export { LORIKEET_ERROR_CODES, LorikeetClient, LorikeetWidgetHeader, LorikeetWidgetView, LorikeetWidgetWebView, isUnusableConversation, isUnusableConversationCode };
+export { LOGOUT_CONFIRMATION_TIMEOUT_MS, LORIKEET_ERROR_CODES, LorikeetClient, LorikeetWidgetHeader, LorikeetWidgetView, LorikeetWidgetWebView, isUnusableConversation, isUnusableConversationCode };
 //# sourceMappingURL=index.js.map