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

package/dist/index.js

@@ -1,224 +1,855 @@
-import { forwardRef, useState, useRef, useEffect } from 'react';
-import { StyleSheet, Linking, View, Text, TouchableOpacity } from 'react-native';
-import { SafeAreaView } from 'react-native-safe-area-context';
-import { WebView } from 'react-native-webview';
-import Svg, { Path, Line } from 'react-native-svg';
-import { jsx, jsxs } from 'react/jsx-runtime';
+import { forwardRef, useCallback, useEffect, useImperativeHandle, useRef, useState } from "react";
+import { AppState, Linking, StyleSheet, Text, TouchableOpacity, View } from "react-native";
+import { SafeAreaView } from "react-native-safe-area-context";
+import { WebView } from "react-native-webview";
+import Svg, { Line, Path } from "react-native-svg";
+import { jsx, jsxs } from "react/jsx-runtime";
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+//#region src/bridge.ts
+/**
+* The public key, base URL and token are one unit, and a conversation belongs to
+* the credentials that created it. Stamping an observation with them is what
+* stops a remount resuming one environment's ticket against another's key.
+*/
+const conversationIdentity = ({ authToken, baseUrl, publicKey }) => `${publicKey} ${baseUrl !== null && baseUrl !== void 0 ? baseUrl : ""} ${authToken}`;
+/**
+* A remount has to resume the conversation it was in, or the recovery abandons
+* the ticket it was meant to rescue. Only usable when the credentials still
+* match the ones that produced it.
+*/
+const resumableConversation = (observed, identity, intendedTicketId) => {
+	if (observed === null || observed.identity !== identity || observed.intendedTicketId !== intendedTicketId || observed.ticketId === void 0) return null;
+	return {
+		session: observed.session,
+		ticketId: observed.ticketId
+	};
+};
+
+//#endregion
+//#region src/encode.ts
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/**
+* Base64 of a string's UTF-8 bytes.
+*
+* The chat page decodes this as UTF-8 (`Buffer.from(value, 'base64')`), so
+* UTF-8 is the contract. The global `btoa` cannot meet it: it accepts Latin-1
+* only, so a typographic apostrophe or an emoji in a title throws
+* "Found invalid character when converting to base64" and takes the render with
+* it. Hermes also had no `btoa` at all before React Native 0.74, which is
+* inside this package's supported peer range.
+*/
+function base64EncodeUtf8(value) {
+	const bytes = encodeURIComponent(value).replace(/%([0-9A-F]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+	let encoded = "";
+	for (let index = 0; index < bytes.length; index += 3) {
+		const first = bytes.charCodeAt(index);
+		const second = index + 1 < bytes.length ? bytes.charCodeAt(index + 1) : void 0;
+		const third = index + 2 < bytes.length ? bytes.charCodeAt(index + 2) : void 0;
+		encoded += BASE64_ALPHABET[first >> 2];
+		encoded += BASE64_ALPHABET[(first & 3) << 4 | (second !== null && second !== void 0 ? second : 0) >> 4];
+		encoded += second === void 0 ? "=" : BASE64_ALPHABET[(second & 15) << 2 | (third !== null && third !== void 0 ? third : 0) >> 6];
+		encoded += third === void 0 ? "=" : BASE64_ALPHABET[third & 63];
+	}
+	return encoded;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.147.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.147.0/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
 
-// src/client.ts
+//#endregion
+//#region \0@oxc-project+runtime@0.147.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.147.0/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/client.ts
 var LorikeetClient = class {
-  constructor({ customisations, api_base, public_key }) {
-    __publicField(this, "baseUrl", "https://chat.lorikeetcx.ai");
-    // Fallback URL
-    __publicField(this, "customisations", null);
-    __publicField(this, "publicKey");
-    __publicField(this, "getWebviewUrl", ({
-      customer_email,
-      customer_name,
-      token,
-      ticket_id
-    }) => {
-      const url = new URL(this.baseUrl);
-      url.pathname = ticket_id ? `/tickets/${this.publicKey}/${ticket_id}` : "/widget";
-      url.searchParams.append("public_key", this.publicKey);
-      if (customer_email) {
-        url.searchParams.append("customer_email", customer_email);
-      }
-      if (customer_name) {
-        url.searchParams.append("customer_name", customer_name);
-      }
-      url.searchParams.append("token", token);
-      if (this.customisations) {
-        url.searchParams.append(
-          "customisations",
-          btoa(JSON.stringify(this.customisations))
-        );
-      }
-      return url.toString();
-    });
-    if (api_base) {
-      this.baseUrl = api_base;
-    }
-    this.publicKey = public_key;
-    if (customisations) {
-      this.customisations = customisations;
-    }
-  }
+	constructor({ customisations, api_base, metadata, public_key }) {
+		_defineProperty(this, "baseUrl", "https://chat.lorikeetcx.ai");
+		_defineProperty(this, "customisations", null);
+		_defineProperty(this, "metadata", null);
+		_defineProperty(this, "publicKey", void 0);
+		_defineProperty(this, "getWebviewUrl", ({ customer_email, customer_name, token, ticket_id, session }) => {
+			const url = new URL(this.baseUrl);
+			url.pathname = ticket_id ? `/tickets/${this.publicKey}/${ticket_id}` : "/widget";
+			url.searchParams.append("public_key", this.publicKey);
+			if (customer_email) url.searchParams.append("customer_email", customer_email);
+			if (customer_name) url.searchParams.append("customer_name", customer_name);
+			url.searchParams.append("token", token);
+			if (ticket_id && session) url.searchParams.append("session", session);
+			if (this.customisations) url.searchParams.append("customisations", base64EncodeUtf8(JSON.stringify(this.customisations)));
+			if (this.metadata) url.searchParams.append("metadata", JSON.stringify(this.metadata));
+			return url.toString();
+		});
+		_defineProperty(
+			this,
+			/**
+			* 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",
+			() => {
+				const url = new URL(this.baseUrl);
+				url.pathname = "/logout";
+				url.searchParams.append("public_key", this.publicKey);
+				return url.toString();
+			}
+		);
+		if (api_base) this.baseUrl = api_base;
+		this.publicKey = public_key;
+		if (customisations) this.customisations = customisations;
+		if (metadata) this.metadata = metadata;
+	}
 };
-var MessageCirclePlusIcon = ({
-  size = 24,
-  color = "currentColor",
-  strokeWidth = 2
-}) => {
-  return /* @__PURE__ */ jsxs(Svg, { fill: "none", height: size, viewBox: "0 0 24 24", width: size, children: [
-    /* @__PURE__ */ jsx(
-      Path,
-      {
-        d: "M7.9 20A9 9 0 1 0 4 16.1L2 22Z",
-        stroke: color,
-        strokeLinecap: "round",
-        strokeLinejoin: "round",
-        strokeWidth
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      Line,
-      {
-        stroke: color,
-        strokeLinecap: "round",
-        strokeWidth,
-        x1: "12",
-        x2: "12",
-        y1: "8",
-        y2: "16"
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      Line,
-      {
-        stroke: color,
-        strokeLinecap: "round",
-        strokeWidth,
-        x1: "8",
-        x2: "16",
-        y1: "12",
-        y2: "12"
-      }
-    )
-  ] });
+
+//#endregion
+//#region src/errors.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.
+*/
+const LORIKEET_ERROR_CODES = [
+	"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"
+];
+/**
+* The codes that mean the stored conversation cannot be reopened, as opposed to
+* the trusted token being bad or the integration being misconfigured. Only
+* these are worth abandoning a resume for: a token error fails again with the
+* same token, and a configuration error fails again regardless.
+*/
+const UNUSABLE_CONVERSATION_CODES = [
+	"CUSTOMER_ID_MISSING",
+	"INVALID_SESSION",
+	"TICKET_NOT_FOUND"
+];
+/** Whether an error code means the stored conversation cannot be reopened. */
+function isUnusableConversationCode(code) {
+	return UNUSABLE_CONVERSATION_CODES.includes(code);
+}
+function isUnusableConversation(message) {
+	if (typeof message !== "object" || message === null) return false;
+	const { type, error } = message;
+	return type === "error" && typeof error === "string" ? isUnusableConversationCode(error) : false;
+}
+
+//#endregion
+//#region src/events.ts
+const asRecord = (message) => typeof message === "object" && message !== null && !Array.isArray(message) ? message : null;
+const asNonEmptyString = (value) => typeof value === "string" && value !== "" ? value : null;
+/**
+* The event a bridge message carries, or `null` for one that carries none.
+*
+* `ticket_created` is not derived here: telling a fresh ticket from a resumed
+* one needs the URL the page was loaded with, which only the component holds.
+*/
+const eventFromMessage = (message) => {
+	const record = asRecord(message);
+	if (record === null || typeof record.type !== "string") return null;
+	switch (record.type) {
+		case "ready": return { type: "ready" };
+		case "customerMessage": return { type: "customer_message" };
+		case "agentMessage": return typeof record.markUnread === "boolean" ? {
+			type: "agent_message",
+			markUnread: record.markUnread
+		} : { type: "agent_message" };
+		case "closeChat": {
+			const reason = asNonEmptyString(record.reason);
+			return reason === "ended_by_customer" || reason === "minimised" ? {
+				type: "close",
+				reason
+			} : { type: "close" };
+		}
+		case "conversationEnded": return { type: "conversation_ended" };
+		case "startNewChat": return { type: "new_chat" };
+		case "persistLorikeetTicketId": {
+			const ticketId = asNonEmptyString(record.ticketId);
+			return ticketId === null ? null : {
+				type: "persist_ticket_id",
+				ticketId
+			};
+		}
+		case "persistLorikeetSession": {
+			const session = asNonEmptyString(record.session);
+			return session === null ? null : {
+				type: "persist_session",
+				session
+			};
+		}
+		case "loggedOut": return { type: "logged_out" };
+		case "error": {
+			const error = asNonEmptyString(record.error);
+			return error === null ? null : {
+				type: "error",
+				error
+			};
+		}
+		case "preloadComplete": return {
+			type: "preload_complete",
+			clientStart: record.clientStart === true,
+			lazyTicketCreationEnabled: record.lazyTicketCreationEnabled === true
+		};
+		default: return null;
+	}
+};
+/**
+* The ticket a URL is trying to resume, or `null` for one that creates its own.
+*
+* Read from the URL rather than from any state, so it holds for a host that
+* built the URL itself. An unreadable URL reports nothing, which at worst
+* announces a resumed ticket as created once.
+*/
+const resumedTicketIdFromUri = (uri) => {
+	var _segments$;
+	let pathname;
+	try {
+		pathname = new URL(uri).pathname;
+	} catch {
+		return null;
+	}
+	const segments = pathname.split("/").filter((part) => part !== "");
+	if (segments.length < 3 || segments[0] !== "tickets") return null;
+	return (_segments$ = segments[2]) !== null && _segments$ !== void 0 ? _segments$ : null;
+};
+
+//#endregion
+//#region src/lifecycle.ts
+/**
+* The page gives its message stream ten attempts with exponential backoff
+* capped at 30s (`message-stream-utils.tsx`), so the budget runs out roughly
+* 151s after the stream drops, or ~196s once jitter is counted. It then sits at
+* `failed` with nothing to reset it, so a customer who comes back to a
+* backgrounded app is looking at a stream that will never reconnect.
+*
+* Three minutes sits inside that band. Shorter would remount while the page's
+* own retries could still win, which costs the customer their draft message for
+* nothing; much longer leaves a dead stream on screen.
+*/
+const BACKGROUND_RELOAD_THRESHOLD_MS = 18e4;
+/**
+* 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.
+*/
+const LOGOUT_CONFIRMATION_TIMEOUT_MS = 1e4;
+/**
+* Elapsed time is the only signal available: the bridge reports `ready`,
+* `error` and the persistence messages, but never stream health, so the SDK
+* cannot ask whether the connection actually survived.
+*/
+const shouldReloadAfterBackground = (backgroundedAt, now, thresholdMs = BACKGROUND_RELOAD_THRESHOLD_MS) => {
+	if (backgroundedAt === null) return false;
+	const elapsed = now - backgroundedAt;
+	if (elapsed < 0) return false;
+	return elapsed >= thresholdMs;
+};
+
+//#endregion
+//#region src/links.ts
+/**
+* Schemes the WebView resolves for itself. None of them is a page the customer
+* asked to leave the app for, and the OS cannot open them anyway.
+*/
+const WEBVIEW_OWNED_SCHEMES = /* @__PURE__ */ new Set([
+	"about:",
+	"blob:",
+	"data:",
+	"javascript:"
+]);
+const parseUrl = (value) => {
+	try {
+		return new URL(value);
+	} catch {
+		return null;
+	}
+};
+/**
+* Whether the OS could be asked to open this at all. `window.open()` with no
+* argument gives `about:blank`, and a scheme the WebView resolves for itself is
+* not something the OS can place.
+*/
+const canOpenOutsideApp = (url) => {
+	const target = parseUrl(url);
+	return target !== null && !WEBVIEW_OWNED_SCHEMES.has(target.protocol);
 };
-var stylesheet = StyleSheet.create({
-  root: { flex: 1, backgroundColor: "#fff" },
-  container: {
-    flex: 1,
-    borderRadius: 8,
-    overflow: "hidden",
-    shadowColor: "#000",
-    shadowOffset: { width: 0, height: 2 },
-    shadowOpacity: 0.1,
-    shadowRadius: 4,
-    elevation: 3
-  },
-  header: {
-    padding: 16,
-    display: "flex",
-    flexDirection: "row",
-    justifyContent: "space-between"
-  },
-  headerIcon: {
-    width: 24
-  },
-  headerText: {
-    textAlign: "center",
-    fontSize: 16
-  },
-  webView: {
-    flex: 1
-  }
+/**
+* Whether a navigation belongs inside the widget.
+*
+* An origin comparison rather than the substring match this replaces. `baseUrl`
+* appearing anywhere in a URL counted as internal, so
+* `https://evil.example/?next=https://chat.lorikeetcx.ai` loaded in place of the
+* conversation instead of opening in the browser. Comparing origins rather than
+* matching a prefix also means a port, a trailing slash and a different path all
+* still resolve to the same widget.
+*/
+const isInternalNavigation = (url, baseUrl) => {
+	const base = parseUrl(baseUrl);
+	const target = parseUrl(url);
+	if (base === null || target === null) return true;
+	if (WEBVIEW_OWNED_SCHEMES.has(target.protocol)) return true;
+	return target.origin === base.origin;
+};
+
+//#endregion
+//#region src/message-circle-plus-icon.tsx
+const MessageCirclePlusIcon = ({ size = 24, color = "currentColor", strokeWidth = 2 }) => {
+	return /* @__PURE__ */ jsxs(Svg, {
+		fill: "none",
+		height: size,
+		viewBox: "0 0 24 24",
+		width: size,
+		children: [
+			/* @__PURE__ */ jsx(Path, {
+				d: "M7.9 20A9 9 0 1 0 4 16.1L2 22Z",
+				stroke: color,
+				strokeLinecap: "round",
+				strokeLinejoin: "round",
+				strokeWidth
+			}),
+			/* @__PURE__ */ jsx(Line, {
+				stroke: color,
+				strokeLinecap: "round",
+				strokeWidth,
+				x1: "12",
+				x2: "12",
+				y1: "8",
+				y2: "16"
+			}),
+			/* @__PURE__ */ jsx(Line, {
+				stroke: color,
+				strokeLinecap: "round",
+				strokeWidth,
+				x1: "8",
+				x2: "16",
+				y1: "12",
+				y2: "12"
+			})
+		]
+	});
+};
+
+//#endregion
+//#region src/widget.tsx
+const stylesheet = StyleSheet.create({
+	root: {
+		flex: 1,
+		backgroundColor: "#fff"
+	},
+	container: {
+		flex: 1,
+		borderRadius: 8,
+		overflow: "hidden",
+		shadowColor: "#000",
+		shadowOffset: {
+			width: 0,
+			height: 2
+		},
+		shadowOpacity: .1,
+		shadowRadius: 4,
+		elevation: 3
+	},
+	header: {
+		padding: 16,
+		display: "flex",
+		flexDirection: "row",
+		justifyContent: "space-between"
+	},
+	headerIcon: { width: 24 },
+	headerText: {
+		textAlign: "center",
+		fontSize: 16
+	},
+	closedControl: { padding: 16 },
+	webView: { flex: 1 },
+	closed: {
+		flex: 1,
+		opacity: 0
+	}
 });
-var LorikeetWidgetWebView = forwardRef(({ uri, baseUrl = "https://chat.lorikeetcx.ai", webviewProps = {} }, ref) => {
-  return /* @__PURE__ */ jsx(
-    WebView,
-    {
-      ...webviewProps,
-      onNavigationStateChange: (navState) => {
-        if (navState.url.includes(baseUrl)) {
-          return false;
-        } else {
-          void Linking.openURL(navState.url);
-          return false;
-        }
-      },
-      ref,
-      source: {
-        uri
-      },
-      style: stylesheet.webView
-    }
-  );
+const LorikeetWidgetWebView = forwardRef(({ uri, baseUrl = "https://chat.lorikeetcx.ai", webviewProps = {}, onEvent }, ref) => {
+	const isInternal = (url) => isInternalNavigation(url, baseUrl);
+	const accounted = useRef(/* @__PURE__ */ new Set());
+	const seenUri = useRef(null);
+	if (seenUri.current !== uri) {
+		seenUri.current = uri;
+		const resumed = resumedTicketIdFromUri(uri);
+		if (resumed !== null) accounted.current.add(resumed);
+	}
+	const emit = (event) => {
+		onEvent === null || onEvent === void 0 || onEvent(event);
+		if (event.type !== "persist_ticket_id") return;
+		if (accounted.current.has(event.ticketId)) return;
+		accounted.current.add(event.ticketId);
+		onEvent === null || onEvent === void 0 || onEvent({
+			ticketId: event.ticketId,
+			type: "ticket_created"
+		});
+	};
+	return /* @__PURE__ */ jsx(WebView, {
+		style: stylesheet.webView,
+		...webviewProps,
+		onMessage: (event) => {
+			var _webviewProps$onMessa;
+			let message;
+			try {
+				message = JSON.parse(event.nativeEvent.data);
+			} catch {}
+			const widgetEvent = eventFromMessage(message);
+			if (widgetEvent !== null) emit(widgetEvent);
+			(_webviewProps$onMessa = webviewProps.onMessage) === null || _webviewProps$onMessa === void 0 || _webviewProps$onMessa.call(webviewProps, event);
+		},
+		onNavigationStateChange: (navState) => {
+			var _webviewProps$onNavig;
+			if (!isInternal(navState.url)) Linking.openURL(navState.url);
+			(_webviewProps$onNavig = webviewProps.onNavigationStateChange) === null || _webviewProps$onNavig === void 0 || _webviewProps$onNavig.call(webviewProps, navState);
+		},
+		onOpenWindow: (event) => {
+			var _webviewProps$onOpenW;
+			const { targetUrl } = event.nativeEvent;
+			if (canOpenOutsideApp(targetUrl)) Linking.openURL(targetUrl);
+			(_webviewProps$onOpenW = webviewProps.onOpenWindow) === null || _webviewProps$onOpenW === void 0 || _webviewProps$onOpenW.call(webviewProps, event);
+		},
+		onShouldStartLoadWithRequest: (request) => {
+			var _webviewProps$onShoul;
+			if (((_webviewProps$onShoul = webviewProps.onShouldStartLoadWithRequest) === null || _webviewProps$onShoul === void 0 ? void 0 : _webviewProps$onShoul.call(webviewProps, request)) === false) return false;
+			if (request.isTopFrame === false || isInternal(request.url)) return true;
+			Linking.openURL(request.url);
+			return false;
+		},
+		ref,
+		source: { uri }
+	});
 });
 LorikeetWidgetWebView.displayName = "LorikeetWidgetWebView";
-var LorikeetWidgetHeader = ({
-  title,
-  style,
-  icon = /* @__PURE__ */ jsx(MessageCirclePlusIcon, { size: 16 }),
-  onIconPress
-}) => {
-  return /* @__PURE__ */ jsxs(View, { style: stylesheet.header, children: [
-    /* @__PURE__ */ jsx(View, { style: stylesheet.headerIcon }),
-    /* @__PURE__ */ jsx(Text, { style: [stylesheet.headerText, style], children: title }),
-    /* @__PURE__ */ jsx(TouchableOpacity, { onPress: onIconPress, style: stylesheet.headerIcon, children: icon })
-  ] });
+const LorikeetWidgetHeader = ({ title, style, icon = /* @__PURE__ */ jsx(MessageCirclePlusIcon, { size: 16 }), onIconPress }) => {
+	return /* @__PURE__ */ jsxs(View, {
+		style: stylesheet.header,
+		children: [
+			/* @__PURE__ */ jsx(View, { style: stylesheet.headerIcon }),
+			/* @__PURE__ */ jsx(Text, {
+				style: [stylesheet.headerText, style],
+				children: title
+			}),
+			/* @__PURE__ */ jsx(TouchableOpacity, {
+				onPress: onIconPress,
+				style: stylesheet.headerIcon,
+				children: icon
+			})
+		]
+	});
 };
-function LorikeetWidgetView({
-  publicKey,
-  baseUrl,
-  authToken,
-  customisations,
-  styles,
-  onWebViewMessage
-}) {
-  var _a;
-  const [lorikeetClient, setLorikeetClient] = useState(
-    null
-  );
-  const [uri, setUri] = useState(null);
-  const [timestamp, setTimestamp] = useState(Date.now());
-  const webViewRef = useRef(null);
-  useEffect(() => {
-    const lorikeetClient2 = new LorikeetClient({
-      public_key: publicKey,
-      api_base: baseUrl,
-      customisations: {
-        ...customisations,
-        hideHeader: (customisations == null ? void 0 : customisations.hideHeader) === void 0 ? true : customisations.hideHeader
-      }
-    });
-    setLorikeetClient(lorikeetClient2);
-    setUri(
-      lorikeetClient2.getWebviewUrl({
-        token: authToken
-      })
-    );
-  }, [publicKey, baseUrl]);
-  if (!lorikeetClient || !uri) {
-    return null;
-  }
-  return /* @__PURE__ */ jsx(SafeAreaView, { edges: ["top", "left", "right"], style: stylesheet.root, children: /* @__PURE__ */ jsxs(View, { style: stylesheet.container, children: [
-    /* @__PURE__ */ jsx(
-      LorikeetWidgetHeader,
-      {
-        onIconPress: () => {
-          setTimestamp(Date.now());
-        },
-        style: styles == null ? void 0 : styles.header,
-        title: (_a = customisations == null ? void 0 : customisations.title) != null ? _a : "Lorikeet AI Agent"
-      }
-    ),
-    /* @__PURE__ */ jsx(
-      LorikeetWidgetWebView,
-      {
-        baseUrl: lorikeetClient.baseUrl,
-        ref: webViewRef,
-        uri,
-        webviewProps: {
-          onMessage: onWebViewMessage,
-          allowsInlineMediaPlayback: true,
-          mediaPlaybackRequiresUserAction: false,
-          scalesPageToFit: true,
-          startInLoadingState: true,
-          style: stylesheet.webView
-        }
-      },
-      timestamp
-    )
-  ] }) });
-}
+const LorikeetWidgetView = forwardRef(function LorikeetWidgetView({ publicKey, baseUrl, authToken, customisations, styles, onEvent, onWebViewMessage, ticketId, session, metadata, webviewProps }, ref) {
+	var _customisations$hideH, _customisations$title;
+	const [lorikeetClient, setLorikeetClient] = useState(null);
+	const [loaded, setLoaded] = useState(null);
+	const [generation, setGeneration] = useState(0);
+	const generationRef = useRef(generation);
+	generationRef.current = generation;
+	const remount = useCallback(() => {
+		setGeneration((previous) => previous + 1);
+	}, []);
+	const webViewRef = useRef(null);
+	const [refusedTicketId, setRefusedTicketId] = useState(null);
+	const observedRef = useRef(null);
+	const backgroundedAtRef = useRef(null);
+	const uriRef = useRef(null);
+	const loadedForRef = useRef({
+		identity: "",
+		intendedTicketId: void 0
+	});
+	const identity = conversationIdentity({
+		authToken,
+		baseUrl,
+		publicKey
+	});
+	const resumingTicketId = ticketId !== void 0 && ticketId !== refusedTicketId ? ticketId : void 0;
+	const [attemptedTicketId, setAttemptedTicketId] = useState(void 0);
+	const [closed, setClosed] = useState(null);
+	const [clearing, setClearing] = useState(null);
+	const [loggedOutIdentity, setLoggedOutIdentity] = useState(null);
+	const onEventRef = useRef(onEvent);
+	onEventRef.current = onEvent;
+	const hideHeader = (_customisations$hideH = customisations === null || customisations === void 0 ? void 0 : customisations.hideHeader) !== null && _customisations$hideH !== void 0 ? _customisations$hideH : true;
+	const load = useCallback((client, forIdentity, intendedTicketId, resume, force = false) => {
+		const next = client.getWebviewUrl({
+			token: authToken,
+			ticket_id: resume === null || resume === void 0 ? void 0 : resume.ticketId,
+			session: resume === null || resume === void 0 ? void 0 : resume.session
+		});
+		const unchanged = uriRef.current === next;
+		if (loadedForRef.current.identity !== forIdentity || loadedForRef.current.intendedTicketId !== intendedTicketId) setClosed(null);
+		uriRef.current = next;
+		loadedForRef.current = {
+			identity: forIdentity,
+			intendedTicketId
+		};
+		if (unchanged && !force) {
+			setLoaded((previous) => previous === null || previous.identity !== forIdentity || previous.intendedTicketId !== intendedTicketId ? {
+				identity: forIdentity,
+				intendedTicketId,
+				uri: next
+			} : previous);
+			return;
+		}
+		setLoaded({
+			identity: forIdentity,
+			intendedTicketId,
+			uri: next
+		});
+		setAttemptedTicketId(resume === null || resume === void 0 ? void 0 : resume.ticketId);
+		remount();
+	}, [authToken, remount]);
+	useEffect(() => {
+		const lorikeetClient = new LorikeetClient({
+			public_key: publicKey,
+			api_base: baseUrl,
+			metadata,
+			customisations: {
+				...customisations,
+				hideHeader
+			}
+		});
+		setLorikeetClient(lorikeetClient);
+		if (clearing !== null || loggedOutIdentity === identity) return;
+		if (loggedOutIdentity !== null) setLoggedOutIdentity(null);
+		const resume = resumingTicketId !== void 0 ? {
+			session,
+			ticketId: resumingTicketId
+		} : resumableConversation(observedRef.current, identity, void 0);
+		load(lorikeetClient, identity, resumingTicketId, resume);
+	}, [
+		publicKey,
+		baseUrl,
+		authToken,
+		clearing,
+		customisations,
+		hideHeader,
+		loggedOutIdentity,
+		metadata,
+		session,
+		resumingTicketId,
+		identity,
+		load
+	]);
+	/**
+	* Clear this customer's chat from the device. Loads the page's own `/logout`,
+	* the only thing that can drop the chat's cookies and the storage the page
+	* keeps; a host clearing its stored `ticketId` and `session` leaves both
+	* behind.
+	*
+	* Nothing else loads until the page confirms with `logged_out`, and nothing
+	* loads for these credentials after it, so pass the next customer's in to
+	* start their chat. Clear your own stored `ticketId` and `session` too.
+	*/
+	const logout = useCallback(() => {
+		observedRef.current = null;
+		setClosed(null);
+		setClearing((previous) => {
+			if (previous !== null) return {
+				...previous,
+				attempt: previous.attempt + 1
+			};
+			setLoggedOutIdentity(identity);
+			return {
+				attempt: 1,
+				baseUrl,
+				identity,
+				uri: new LorikeetClient({
+					api_base: baseUrl,
+					public_key: publicKey
+				}).getLogoutUrl(),
+				webviewProps: {
+					...webviewProps,
+					injectedJavaScript: void 0,
+					injectedJavaScriptBeforeContentLoaded: void 0,
+					onMessage: void 0,
+					onShouldStartLoadWithRequest: void 0
+				}
+			};
+		});
+	}, [
+		baseUrl,
+		identity,
+		publicKey,
+		webviewProps
+	]);
+	/**
+	* Show a minimised conversation again, exactly as the customer left it.
+	*
+	* A no-op unless something is minimised, so a host with its own launcher can
+	* call it without first asking.
+	*/
+	const reopen = useCallback(() => {
+		setClosed((previous) => previous === "minimised" ? null : previous);
+	}, []);
+	/**
+	* What the widget is actually on, for a host that has to store it or draw its
+	* own launcher around it.
+	*/
+	const getConversation = useCallback(() => {
+		const resumable = resumableConversation(observedRef.current, identity, resumingTicketId);
+		if (resumable === null) return null;
+		return {
+			minimised: closed === "minimised",
+			session: resumable.session,
+			ticketId: resumable.ticketId
+		};
+	}, [
+		closed,
+		identity,
+		resumingTicketId
+	]);
+	useImperativeHandle(ref, () => ({
+		getConversation,
+		logout,
+		reopen
+	}), [
+		getConversation,
+		logout,
+		reopen
+	]);
+	const clearingAttempt = clearing === null || clearing === void 0 ? void 0 : clearing.attempt;
+	useEffect(() => {
+		if (clearingAttempt === void 0) return;
+		const timer = setTimeout(() => {
+			var _onEventRef$current;
+			(_onEventRef$current = onEventRef.current) === null || _onEventRef$current === void 0 || _onEventRef$current.call(onEventRef, { type: "logout_failed" });
+		}, LOGOUT_CONFIRMATION_TIMEOUT_MS);
+		return () => {
+			clearTimeout(timer);
+		};
+	}, [clearingAttempt]);
+	const handleClearingEvent = useCallback((event) => {
+		if (event.type === "logged_out") setClearing((previous) => (previous === null || previous === void 0 ? void 0 : previous.attempt) === clearingAttempt ? null : previous);
+		onEvent === null || onEvent === void 0 || onEvent(event);
+	}, [clearingAttempt, onEvent]);
+	const reload = useCallback(() => {
+		const resume = resumableConversation(observedRef.current, identity, resumingTicketId);
+		if (lorikeetClient !== null && resume !== null) {
+			load(lorikeetClient, identity, resumingTicketId, resume, true);
+			return;
+		}
+		remount();
+	}, [
+		identity,
+		load,
+		lorikeetClient,
+		remount,
+		resumingTicketId
+	]);
+	useEffect(() => {
+		const subscription = AppState.addEventListener("change", (next) => {
+			if (next === "active") {
+				if (shouldReloadAfterBackground(backgroundedAtRef.current, Date.now())) reload();
+				backgroundedAtRef.current = null;
+				return;
+			}
+			if (next === "background") {
+				var _backgroundedAtRef$cu;
+				(_backgroundedAtRef$cu = backgroundedAtRef.current) !== null && _backgroundedAtRef$cu !== void 0 || (backgroundedAtRef.current = Date.now());
+			}
+		});
+		return () => {
+			subscription.remove();
+		};
+	}, [reload]);
+	const startNewChat = useCallback(() => {
+		setClosed(null);
+		if (lorikeetClient !== null && resumingTicketId === void 0) {
+			observedRef.current = null;
+			load(lorikeetClient, identity, void 0, null, true);
+			return;
+		}
+		remount();
+	}, [
+		identity,
+		load,
+		lorikeetClient,
+		remount,
+		resumingTicketId
+	]);
+	const handleEvent = useCallback((event) => {
+		if (generation === generationRef.current && loadedForRef.current.identity === identity && loadedForRef.current.intendedTicketId === resumingTicketId) {
+			if (event.type === "persist_ticket_id" || event.type === "persist_session") {
+				var _observedRef$current;
+				const current = ((_observedRef$current = observedRef.current) === null || _observedRef$current === void 0 ? void 0 : _observedRef$current.identity) === identity && observedRef.current.intendedTicketId === resumingTicketId ? observedRef.current : null;
+				observedRef.current = {
+					...current,
+					...event.type === "persist_ticket_id" ? { ticketId: event.ticketId } : { session: event.session },
+					identity,
+					intendedTicketId: resumingTicketId
+				};
+			}
+			if (event.type === "close") setClosed(event.reason === "minimised" ? "minimised" : "ended");
+			if (event.type === "new_chat") startNewChat();
+			if (event.type === "error" && attemptedTicketId !== void 0 && isUnusableConversationCode(event.error)) {
+				observedRef.current = null;
+				setRefusedTicketId(attemptedTicketId);
+				if (lorikeetClient !== null) load(lorikeetClient, identity, void 0, null, true);
+			}
+		}
+		onEvent === null || onEvent === void 0 || onEvent(event);
+	}, [
+		attemptedTicketId,
+		generation,
+		identity,
+		load,
+		lorikeetClient,
+		onEvent,
+		resumingTicketId,
+		startNewChat
+	]);
+	const handleMessage = useCallback((event) => {
+		var _webviewProps$onMessa2;
+		onWebViewMessage === null || onWebViewMessage === void 0 || onWebViewMessage(event);
+		webviewProps === null || webviewProps === void 0 || (_webviewProps$onMessa2 = webviewProps.onMessage) === null || _webviewProps$onMessa2 === void 0 || _webviewProps$onMessa2.call(webviewProps, event);
+	}, [onWebViewMessage, webviewProps]);
+	if (clearing !== null) return /* @__PURE__ */ jsx(SafeAreaView, {
+		edges: [
+			"top",
+			"left",
+			"right"
+		],
+		style: stylesheet.root,
+		children: /* @__PURE__ */ jsx(View, {
+			accessibilityElementsHidden: true,
+			importantForAccessibility: "no-hide-descendants",
+			pointerEvents: "none",
+			style: stylesheet.closed,
+			children: /* @__PURE__ */ jsx(LorikeetWidgetWebView, {
+				baseUrl: clearing.baseUrl,
+				onEvent: handleClearingEvent,
+				uri: clearing.uri,
+				webviewProps: {
+					...clearing.webviewProps,
+					style: stylesheet.webView
+				}
+			}, `logout|${clearing.attempt}`)
+		})
+	});
+	if (lorikeetClient === null || loaded === null || loaded.identity !== identity || loaded.intendedTicketId !== resumingTicketId || loggedOutIdentity === identity) return null;
+	const isClosed = closed !== null;
+	return /* @__PURE__ */ jsx(SafeAreaView, {
+		edges: [
+			"top",
+			"left",
+			"right"
+		],
+		style: stylesheet.root,
+		children: /* @__PURE__ */ jsxs(View, {
+			style: stylesheet.container,
+			children: [
+				hideHeader && closed !== "minimised" ? /* @__PURE__ */ jsx(LorikeetWidgetHeader, {
+					onIconPress: startNewChat,
+					style: styles === null || styles === void 0 ? void 0 : styles.header,
+					title: (_customisations$title = customisations === null || customisations === void 0 ? void 0 : customisations.title) !== null && _customisations$title !== void 0 ? _customisations$title : "Lorikeet AI Agent"
+				}) : null,
+				closed === "minimised" ? /* @__PURE__ */ jsx(TouchableOpacity, {
+					onPress: reopen,
+					style: stylesheet.closedControl,
+					children: /* @__PURE__ */ jsx(Text, {
+						style: stylesheet.headerText,
+						children: "Reopen chat"
+					})
+				}) : null,
+				!hideHeader && closed === "ended" ? /* @__PURE__ */ jsx(TouchableOpacity, {
+					onPress: startNewChat,
+					style: stylesheet.closedControl,
+					children: /* @__PURE__ */ jsx(Text, {
+						style: stylesheet.headerText,
+						children: "Start new chat"
+					})
+				}) : null,
+				/* @__PURE__ */ jsx(View, {
+					accessibilityElementsHidden: isClosed,
+					importantForAccessibility: isClosed ? "no-hide-descendants" : "auto",
+					pointerEvents: isClosed ? "none" : "auto",
+					style: isClosed ? stylesheet.closed : stylesheet.webView,
+					children: /* @__PURE__ */ jsx(LorikeetWidgetWebView, {
+						baseUrl: lorikeetClient.baseUrl,
+						onEvent: handleEvent,
+						ref: webViewRef,
+						uri: loaded.uri,
+						webviewProps: {
+							allowsInlineMediaPlayback: true,
+							mediaPlaybackRequiresUserAction: false,
+							scalesPageToFit: true,
+							startInLoadingState: true,
+							style: stylesheet.webView,
+							...webviewProps,
+							onMessage: handleMessage,
+							onRenderProcessGone: (event) => {
+								var _webviewProps$onRende;
+								if (generation === generationRef.current) reload();
+								webviewProps === null || webviewProps === void 0 || (_webviewProps$onRende = webviewProps.onRenderProcessGone) === null || _webviewProps$onRende === void 0 || _webviewProps$onRende.call(webviewProps, event);
+							},
+							onContentProcessDidTerminate: (event) => {
+								var _webviewProps$onConte;
+								if (generation === generationRef.current) reload();
+								webviewProps === null || webviewProps === void 0 || (_webviewProps$onConte = webviewProps.onContentProcessDidTerminate) === null || _webviewProps$onConte === void 0 || _webviewProps$onConte.call(webviewProps, event);
+							}
+						}
+					}, `${identity}|${resumingTicketId !== null && resumingTicketId !== void 0 ? resumingTicketId : ""}|${generation}`)
+				})
+			]
+		})
+	});
+});
+LorikeetWidgetView.displayName = "LorikeetWidgetView";
 
-export { LorikeetClient, LorikeetWidgetHeader, LorikeetWidgetView, LorikeetWidgetWebView };
-//# sourceMappingURL=index.js.map
+//#endregion
+export { LORIKEET_ERROR_CODES, LorikeetClient, LorikeetWidgetHeader, LorikeetWidgetView, LorikeetWidgetWebView, isUnusableConversation, isUnusableConversationCode };
 //# sourceMappingURL=index.js.map