@zellio/chat-react-native 0.0.0-stage → 1.0.0

package/ios/vendor/swift/ZellioChat/Model/ChatModel.swift

@@ -0,0 +1,261 @@
+#if canImport(SwiftUI) && canImport(UIKit)
+import Combine
+import Foundation
+import SwiftUI
+
+enum ChatRoute: Equatable {
+    case loading
+    case consent
+    case home
+    case list
+    case thread(String?)
+    case unavailable
+    case loginNeeded
+    case loadFailed
+}
+
+enum ChatBanner: Equatable {
+    case reconnecting
+    case outsideHours(String)
+}
+
+/// What the screen asked for when it was presented.
+enum ChatEntry: Equatable {
+    case `default`
+    case conversation(String?)
+}
+
+/// The state behind the SwiftUI screens. Thin: all rules live in ZellioChatCore.
+final class ChatModel: ObservableObject {
+    @Published private(set) var route: ChatRoute = .loading
+    @Published private(set) var config: ChatConfig?
+    @Published private(set) var conversations: [ConversationSummary] = []
+    @Published private(set) var locale: ChatLocale = .en
+    @Published private(set) var banner: ChatBanner?
+    @Published private(set) var isIdentified = false
+    @Published var themeOverrides: ZellioChatTheme
+
+    let engine: ChatEngine
+    private let entry: ChatEntry
+    private var history: [ChatRoute] = []
+    private var offlineTimer: Task<Void, Never>?
+    private var isOffline = false
+    private var started = false
+    private(set) var activeThread: ThreadController?
+
+    var onClose: () -> Void = {}
+    var emit: (ZellioChatEvent) -> Void = { _ in }
+
+    init(engine: ChatEngine, entry: ChatEntry, theme: ZellioChatTheme) {
+        self.engine = engine
+        self.entry = entry
+        self.themeOverrides = theme
+        self.locale = engine.locale()
+        self.config = engine.cachedConfig
+        if let saved = engine.cachedConversations() { self.conversations = saved.conversations }
+        self.route = ChatModel.initialRoute(config: engine.cachedConfig, entry: entry)
+        if case .thread(let id) = route { activeThread = engine.makeThread(conversationId: id) }
+    }
+
+    /// A model for SwiftUI previews and tests. It never touches the network.
+    static func preview(config: ChatConfig?, conversations: [ConversationSummary] = [], route: ChatRoute, locale: ChatLocale, banner: ChatBanner? = nil) -> ChatModel {
+        let transport = PreviewTransport()
+        let engine = ChatEngine(options: EngineOptions(baseURL: URL(string: "https://preview.invalid") ?? URL(fileURLWithPath: "/"), appKey: "preview", localeOption: locale),
+                                transport: transport, secrets: MemorySecretStore(), storage: MemoryStorage())
+        let model = ChatModel(engine: engine, entry: .default, theme: ZellioChatTheme())
+        model.config = config
+        model.conversations = conversations
+        model.route = route
+        model.locale = locale
+        model.banner = banner
+        model.started = true
+        return model
+    }
+
+    private static func initialRoute(config: ChatConfig?, entry: ChatEntry) -> ChatRoute {
+        guard let config = config else { return .loading }
+        if case .conversation(let id) = entry { return .thread(id) }
+        return config.snapshot.layout == .chatOnly ? .thread(nil) : .home
+    }
+
+    var theme: ChatTheme {
+        ChatTheme.make(config: config, locale: locale, systemDark: false, overrides: themeOverrides)
+    }
+
+    func theme(systemDark: Bool) -> ChatTheme {
+        ChatTheme.make(config: config, locale: locale, systemDark: systemDark, overrides: themeOverrides)
+    }
+
+    var isChatOnly: Bool { config?.snapshot.layout == .chatOnly }
+    var canGoBack: Bool { !history.isEmpty }
+    var allowsAttachments: Bool { config?.snapshot.behavior.allowAttachments ?? true }
+
+    // MARK: Loading
+
+    @MainActor
+    func start() async {
+        guard !started else { return }
+        started = true
+        await loadConfigAndContinue()
+    }
+
+    @MainActor
+    func retry() async {
+        route = config == nil ? .loading : route
+        await loadConfigAndContinue()
+    }
+
+    @MainActor
+    private func loadConfigAndContinue() async {
+        do {
+            let fresh = try await engine.refreshConfig()
+            config = fresh
+            locale = engine.locale()
+        } catch let error as ChatError {
+            if error == .unavailable { route = .unavailable; emit(.error(code: error.eventCode)); return }
+            if config == nil { route = .loadFailed; emit(.error(code: error.eventCode)); return }
+        } catch {
+            if config == nil { route = .loadFailed; return }
+        }
+        guard let config = config else { route = .loadFailed; return }
+        if ConsentGate.state(config: config, store: engine.consentStore) == .required {
+            route = .consent
+            return
+        }
+        await proceedAfterConsent()
+    }
+
+    @MainActor
+    func acceptConsent() async {
+        engine.acceptConsent()
+        await proceedAfterConsent()
+    }
+
+    @MainActor
+    private func proceedAfterConsent() async {
+        guard let config = config else { return }
+        locale = engine.locale()
+        let target = ChatModel.initialRoute(config: config, entry: entry)
+        if case .thread(let id) = target {
+            if activeThread == nil { activeThread = engine.makeThread(conversationId: id) }
+            route = target
+            await engine.startRealtime()
+            await refreshIdentity()
+            updateBanner()
+            return
+        }
+        route = target
+        await reloadConversations()
+        await engine.startRealtime()
+        await refreshIdentity()
+        updateBanner()
+    }
+
+    @MainActor
+    private func refreshIdentity() async {
+        let identified = await engine.session.isIdentified
+        if identified != isIdentified { isIdentified = identified }
+    }
+
+    @MainActor
+    func reloadConversations() async {
+        do {
+            let page = try await engine.loadConversations()
+            conversations = page.conversations
+            await refreshIdentity()
+        } catch let error as ChatError {
+            handle(error)
+        } catch {
+            // Keep the saved list.
+        }
+    }
+
+    @MainActor
+    private func handle(_ error: ChatError) {
+        switch error {
+        case .unavailable:
+            route = .unavailable
+        case .loginNeeded:
+            route = .loginNeeded
+        default:
+            break
+        }
+        emit(.error(code: error.eventCode))
+    }
+
+    // MARK: Navigation
+
+    @MainActor
+    func open(_ next: ChatRoute) {
+        if next == route { return }
+        history.append(route)
+        if case .thread(let id) = next {
+            activeThread = engine.makeThread(conversationId: id)
+        }
+        route = next
+    }
+
+    @MainActor
+    func goBack() {
+        guard let previous = history.popLast() else { return }
+        // The thread that was on screen may be another one now (a push tap opened it). Make the earlier one again.
+        if case .thread(let id) = previous { activeThread = engine.makeThread(conversationId: id) }
+        route = previous
+        Task { await reloadConversations() }
+    }
+
+    @MainActor
+    func openNewConversation() {
+        // The server decides which conversation a message goes to. A new thread starts empty.
+        open(.thread(nil))
+    }
+
+    // MARK: Network banner
+
+    func networkChanged(online: Bool) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            self.isOffline = !online
+            self.offlineTimer?.cancel()
+            if online {
+                self.updateBanner()
+            } else {
+                // "Reconnecting" shows after 3 seconds offline.
+                self.offlineTimer = Task { [weak self] in
+                    try? await Task.sleep(nanoseconds: 3_000_000_000)
+                    if Task.isCancelled { return }
+                    await MainActor.run { self?.updateBanner() }
+                }
+            }
+        }
+    }
+
+    @MainActor
+    private func updateBanner() {
+        if isOffline {
+            banner = .reconnecting
+        } else if let config = config, !config.online {
+            banner = .outsideHours(config.snapshot.screens.offline.resolve(locale) ?? ChatStrings(locale: locale).string("banner.offline"))
+        } else {
+            banner = nil
+        }
+    }
+
+    @MainActor
+    func refreshBanner() { updateBanner() }
+
+    func stop() {
+        offlineTimer?.cancel()
+        if let thread = activeThread { Task { await thread.stop() } }
+    }
+}
+
+/// Never reaches a network. For previews.
+final class PreviewTransport: HTTPTransport, @unchecked Sendable {
+    func send(_ request: HTTPRequest) async throws -> HTTPResponse { throw ChatAPIError.network }
+    func upload(_ request: HTTPRequest, progress: @escaping @Sendable (Double) -> Void) async throws -> HTTPResponse { throw ChatAPIError.network }
+    func stream(_ request: HTTPRequest) -> AsyncThrowingStream<StreamChunk, Error> {
+        AsyncThrowingStream { $0.finish(throwing: ChatAPIError.network) }
+    }
+}
+#endif

package/ios/vendor/swift/ZellioChat/Platform/Platform.swift

@@ -0,0 +1,124 @@
+#if canImport(SwiftUI) && canImport(UIKit)
+import Foundation
+import Network
+import Security
+import UIKit
+import AudioToolbox
+
+/// Session token store in the Keychain. Accessible after first unlock, never synced or restored to another device.
+final class KeychainSecretStore: SecretStore, @unchecked Sendable {
+    private let service: String
+
+    init(service: String = "ai.zellio.chat") { self.service = service }
+
+    private func baseQuery(_ key: String) -> [String: Any] {
+        [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: key,
+        ]
+    }
+
+    func read(_ key: String) -> String? {
+        var query = baseQuery(key)
+        query[kSecReturnData as String] = true
+        query[kSecMatchLimit as String] = kSecMatchLimitOne
+        var result: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &result)
+        guard status == errSecSuccess, let data = result as? Data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    func write(_ key: String, value: String) {
+        let data = Data(value.utf8)
+        let update: [String: Any] = [kSecValueData as String: data]
+        let status = SecItemUpdate(baseQuery(key) as CFDictionary, update as CFDictionary)
+        if status == errSecItemNotFound {
+            var add = baseQuery(key)
+            add[kSecValueData as String] = data
+            add[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+            _ = SecItemAdd(add as CFDictionary, nil)
+        }
+    }
+
+    func delete(_ key: String) {
+        _ = SecItemDelete(baseQuery(key) as CFDictionary)
+    }
+}
+
+enum AppleStorage {
+    /// Application Support/ZellioChat/<appKey hash>. Excluded from backups.
+    static func make(appKey: String) -> FileStorage {
+        let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask).first
+            ?? URL(fileURLWithPath: NSTemporaryDirectory())
+        let safeKey = String(appKey.map { $0.isLetter || $0.isNumber ? $0 : "_" }.prefix(48))
+        var directory = base.appendingPathComponent("ZellioChat", isDirectory: true).appendingPathComponent(safeKey, isDirectory: true)
+        try? FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        var values = URLResourceValues()
+        values.isExcludedFromBackup = true
+        try? directory.setResourceValues(values)
+        // The parent folder too, so no other file of ours is backed up.
+        var parent = directory.deletingLastPathComponent()
+        try? parent.setResourceValues(values)
+        return FileStorage(directory: directory)
+    }
+}
+
+/// Reports whether the network is reachable.
+final class NetworkMonitor: @unchecked Sendable {
+    private let monitor = NWPathMonitor()
+    private let queue = DispatchQueue(label: "ai.zellio.chat.network")
+    private let lock = NSLock()
+    private var online = true
+    var onChange: (@Sendable (Bool) -> Void)?
+
+    var isOnline: Bool { lock.lock(); defer { lock.unlock() }; return online }
+
+    func start() {
+        monitor.pathUpdateHandler = { [weak self] path in
+            guard let self = self else { return }
+            let now = path.status == .satisfied
+            self.lock.lock()
+            let changed = self.online != now
+            self.online = now
+            self.lock.unlock()
+            if changed { self.onChange?(now) }
+        }
+        monitor.start(queue: queue)
+    }
+
+    func stop() { monitor.cancel() }
+}
+
+enum Haptics {
+    /// A light tap on send.
+    static func sendTap() {
+        DispatchQueue.main.async { UIImpactFeedbackGenerator(style: .light).impactOccurred() }
+    }
+
+    /// A soft tick on a new message while chat is open.
+    static func incomingTick() {
+        DispatchQueue.main.async { UIImpactFeedbackGenerator(style: .soft).impactOccurred() }
+    }
+
+    /// A notice on a failed send.
+    static func failure() {
+        DispatchQueue.main.async { UINotificationFeedbackGenerator().notificationOccurred(.error) }
+    }
+
+    /// Only when the brand turned sound on. System sounds follow the ring switch.
+    static func incomingSound() {
+        AudioServicesPlaySystemSound(1007)
+    }
+}
+
+enum SDKLog {
+    static var level: ZellioChatLogLevel = .error
+
+    /// Never pass message text, tokens or identities here.
+    static func log(_ level: ZellioChatLogLevel, _ message: @autoclosure () -> String) {
+        guard level.rawValue <= SDKLog.level.rawValue, level != .none else { return }
+        NSLog("[ZellioChat] %@", message())
+    }
+}
+#endif

package/ios/vendor/swift/ZellioChat/Platform/URLSessionTransport.swift

@@ -0,0 +1,175 @@
+#if canImport(SwiftUI) && canImport(UIKit)
+import Foundation
+
+/// The real network layer. URLSession only. No third-party code.
+///
+/// Timeouts: connect and idle reads use the request timeout (30 s). Uploads use 120 s.
+/// The SSE stream has no read timeout here; `RealtimeClient` treats 45 s without bytes as dead.
+final class URLSessionTransport: HTTPTransport, @unchecked Sendable {
+    private let session: URLSession
+
+    init() {
+        let configuration = URLSessionConfiguration.default
+        configuration.waitsForConnectivity = false
+        configuration.httpCookieStorage = nil
+        configuration.urlCache = nil
+        configuration.requestCachePolicy = .reloadIgnoringLocalCacheData
+        session = URLSession(configuration: configuration)
+    }
+
+    private static func urlRequest(_ request: HTTPRequest) -> URLRequest {
+        var result = URLRequest(url: request.url)
+        result.httpMethod = request.method
+        result.timeoutInterval = request.timeout > 0 ? request.timeout : 60 * 60 * 24
+        for (key, value) in request.headers { result.setValue(value, forHTTPHeaderField: key) }
+        result.httpBody = request.body
+        return result
+    }
+
+    static func headers(_ response: HTTPURLResponse) -> [String: String] {
+        var result: [String: String] = [:]
+        for (key, value) in response.allHeaderFields {
+            if let key = key as? String, let value = value as? String { result[key] = value }
+        }
+        return result
+    }
+
+    static func map(_ error: Error) -> Error {
+        if let urlError = error as? URLError {
+            switch urlError.code {
+            case .cancelled: return CancellationError()
+            case .timedOut: return ChatAPIError.timeout
+            default: return ChatAPIError.network
+            }
+        }
+        if error is CancellationError { return error }
+        return ChatAPIError.network
+    }
+
+    func send(_ request: HTTPRequest) async throws -> HTTPResponse {
+        do {
+            let (data, response) = try await session.data(for: URLSessionTransport.urlRequest(request))
+            guard let http = response as? HTTPURLResponse else { throw ChatAPIError.network }
+            return HTTPResponse(status: http.statusCode, headers: URLSessionTransport.headers(http), body: data)
+        } catch {
+            throw URLSessionTransport.map(error)
+        }
+    }
+
+    func upload(_ request: HTTPRequest, progress: @escaping @Sendable (Double) -> Void) async throws -> HTTPResponse {
+        let box = UploadBox(progress: progress)
+        let uploadSession = URLSession(configuration: session.configuration, delegate: box, delegateQueue: nil)
+        defer { uploadSession.finishTasksAndInvalidate() }
+        var urlRequest = URLSessionTransport.urlRequest(request)
+        let body = urlRequest.httpBody ?? Data()
+        urlRequest.httpBody = nil
+        return try await withTaskCancellationHandler {
+            try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<HTTPResponse, Error>) in
+                let task = uploadSession.uploadTask(with: urlRequest, from: body) { data, response, error in
+                    if let error = error {
+                        continuation.resume(throwing: URLSessionTransport.map(error))
+                    } else if let http = response as? HTTPURLResponse {
+                        continuation.resume(returning: HTTPResponse(status: http.statusCode, headers: URLSessionTransport.headers(http), body: data ?? Data()))
+                    } else {
+                        continuation.resume(throwing: ChatAPIError.network)
+                    }
+                }
+                box.task = task
+                task.resume()
+            }
+        } onCancel: {
+            box.cancel()
+        }
+    }
+
+    func stream(_ request: HTTPRequest) -> AsyncThrowingStream<StreamChunk, Error> {
+        AsyncThrowingStream { continuation in
+            let delegate = StreamDelegate(continuation: continuation)
+            let configuration = self.session.configuration
+            configuration.timeoutIntervalForRequest = 60 * 60 * 24
+            configuration.timeoutIntervalForResource = 60 * 60 * 24
+            let streamSession = URLSession(configuration: configuration, delegate: delegate, delegateQueue: nil)
+            let task = streamSession.dataTask(with: URLSessionTransport.urlRequest(request))
+            continuation.onTermination = { _ in
+                task.cancel()
+                streamSession.invalidateAndCancel()
+            }
+            task.resume()
+        }
+    }
+}
+
+private final class UploadBox: NSObject, URLSessionTaskDelegate, @unchecked Sendable {
+    private let progress: @Sendable (Double) -> Void
+    private let lock = NSLock()
+    private var current: URLSessionTask?
+    private var cancelled = false
+
+    init(progress: @escaping @Sendable (Double) -> Void) { self.progress = progress }
+
+    var task: URLSessionTask? {
+        get { lock.lock(); defer { lock.unlock() }; return current }
+        set {
+            lock.lock()
+            current = newValue
+            let shouldCancel = cancelled
+            lock.unlock()
+            if shouldCancel { newValue?.cancel() }
+        }
+    }
+
+    func cancel() {
+        lock.lock()
+        cancelled = true
+        let running = current
+        lock.unlock()
+        running?.cancel()
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didSendBodyData bytesSent: Int64, totalBytesSent: Int64, totalBytesExpectedToSend: Int64) {
+        guard totalBytesExpectedToSend > 0 else { return }
+        progress(min(1, Double(totalBytesSent) / Double(totalBytesExpectedToSend)))
+    }
+}
+
+private final class StreamDelegate: NSObject, URLSessionDataDelegate, @unchecked Sendable {
+    private let continuation: AsyncThrowingStream<StreamChunk, Error>.Continuation
+    private var status = 0
+    private var headers: [String: String] = [:]
+    private var errorBody = Data()
+
+    init(continuation: AsyncThrowingStream<StreamChunk, Error>.Continuation) { self.continuation = continuation }
+
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse, completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
+        if let http = response as? HTTPURLResponse {
+            status = http.statusCode
+            headers = URLSessionTransport.headers(http)
+        }
+        if (200..<300).contains(status) { continuation.yield(.opened) }
+        completionHandler(.allow)
+    }
+
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        if (200..<300).contains(status) {
+            continuation.yield(.data(data))
+        } else if errorBody.count < 16_384 {
+            errorBody.append(data)
+        }
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+        if !(200..<300).contains(status), status != 0 {
+            let retry = headers.first { $0.key.lowercased() == "retry-after" }.flatMap { TimeInterval($0.value) }
+            continuation.finish(throwing: ChatAPIError.http(status: status, code: ErrorPolicy.parseCode(from: errorBody), retryAfter: retry))
+        } else if let error = error {
+            if let urlError = error as? URLError, urlError.code == .cancelled {
+                continuation.finish()
+            } else {
+                continuation.finish(throwing: ChatAPIError.network)
+            }
+        } else {
+            continuation.finish()
+        }
+    }
+}
+#endif

package/ios/vendor/swift/ZellioChat/Preview/Previews.swift

@@ -0,0 +1,62 @@
+#if canImport(SwiftUI) && canImport(UIKit) && DEBUG
+import SwiftUI
+
+/// Sample data for the Xcode previews. The text matches the contract fixtures.
+enum PreviewData {
+    static let configJSON = """
+    {"data":{"protocol":"studio-v1","snapshot":{"schemaVersion":1,"siteId":"ws_1~site_1","versionId":"ver_1","layout":"support",
+    "language":{"mode":"both","defaultLocale":"en","startIn":"browser"},
+    "appearance":{"brandName":"Nile Store","logoFileId":"file_1","logoAlt":{"en":"Nile Store","ar":"متجر النيل"},"primaryColor":"#7D3BED","customerMessageColor":"#7D3BED","surfaceColor":"#FFFFFF","theme":"auto","density":"comfortable","corners":"rounded","position":"right","desktopOffset":20,"mobileOffset":16,"launcherSize":56,"launcherLabel":{},"showAgentAvatar":true,"soundEnabled":false,"unreadBadge":true,"showAttribution":true,"launcherIcon":"bubbles","launcherShape":"circle","headerStyle":"gradient","mirrorInRtl":true,"welcomeBubble":{"enabled":false,"text":{},"delaySeconds":5}},
+    "modules":[{"id":"m1","type":"start-conversation","label":{"en":"Talk to our team","ar":"كلّم فريقنا"},"visibility":{},"primary":true},
+    {"id":"m2","type":"announcement","label":{"en":"Eid delivery","ar":"توصيل العيد"},"description":{"en":"Orders placed today arrive on Sunday.","ar":"الطلبات النهاردة توصل يوم الحد."},"visibility":{}},
+    {"id":"m3","type":"external-link","label":{"en":"Track my order","ar":"تتبّع طلبي"},"href":"https://shop.example/track","visibility":{}}],
+    "screens":{"heading":{"en":"How can we help?","ar":"إزاي نقدر نساعدك؟"},"greeting":{"en":"Hi! Tell us what you need help with.","ar":"أهلاً! قولّنا محتاج إيه."},"description":{"en":"We usually reply in a few minutes.","ar":"غالباً بنرد في دقايق."},"offline":{"en":"We are away.","ar":"إحنا مش متاحين دلوقتي."}},
+    "behavior":{"allowAttachments":true,"inheritHours":true,"replyExpectation":{"en":"Usually within minutes","ar":"غالباً في دقايق"},"consentRequired":true,"consentText":{"en":"We store your messages and share them with our support team.","ar":"هنحفظ رسايلك ونشاركها مع فريق الدعم."},"privacyUrl":"https://shop.example/privacy"}},
+    "assets":{"logoUrl":null},"availability":{"online":true},"app":{"allowGuests":true,"minSdkVersion":null}}}
+    """
+
+    static let conversationsJSON = """
+    {"data":{"conversations":[
+    {"id":"conv_2","status":"open","lastMessageAt":"2026-11-03T10:00:00.000Z","lastMessage":{"from":"agent","text":"Your order is on the way.","hasAttachment":false},"agentName":"Mona","agentAvatarUrl":null,"unread":1},
+    {"id":"conv_1","status":"resolved","lastMessageAt":"2026-10-20T08:30:00.000Z","lastMessage":{"from":"visitor","text":"","hasAttachment":true},"agentName":null,"agentAvatarUrl":null,"unread":0}],
+    "nextCursor":null,"unreadTotal":1}}
+    """
+
+    static var config: ChatConfig? { try? ChatConfig.parse(Data(configJSON.utf8)) }
+
+    static var conversations: [ConversationSummary] {
+        guard let root = (try? JSONSerialization.jsonObject(with: Data(conversationsJSON.utf8))) as? [String: Any],
+              let inner = root["data"],
+              let data = try? JSONSerialization.data(withJSONObject: inner),
+              let page = try? JSONDecoder().decode(ConversationsPage.self, from: data) else { return [] }
+        return page.conversations
+    }
+
+    static func model(_ route: ChatRoute, locale: ChatLocale, banner: ChatBanner? = nil) -> ChatModel {
+        ChatModel.preview(config: config, conversations: conversations, route: route, locale: locale, banner: banner)
+    }
+}
+
+private struct ScreenPreview: View {
+    let route: ChatRoute
+    let locale: ChatLocale
+    let dark: Bool
+
+    var body: some View {
+        ChatRootView(model: PreviewData.model(route, locale: locale), onClose: {})
+            .preferredColorScheme(dark ? .dark : .light)
+    }
+}
+
+struct ChatScreens_Previews: PreviewProvider {
+    static var previews: some View {
+        Group {
+            ForEach(Array([ChatRoute.home, .list, .thread(nil), .consent, .loadFailed].enumerated()), id: \.offset) { _, route in
+                ScreenPreview(route: route, locale: .en, dark: false).previewDisplayName("\(String(describing: route)) light")
+                ScreenPreview(route: route, locale: .en, dark: true).previewDisplayName("\(String(describing: route)) dark")
+                ScreenPreview(route: route, locale: .ar, dark: false).previewDisplayName("\(String(describing: route)) arabic")
+            }
+        }
+    }
+}
+#endif