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

package/ios/vendor/swift/ZellioChatCore/Theme.swift

@@ -0,0 +1,238 @@
+import Foundation
+
+/// A #RRGGBB color. Parsing never fails the caller: use the failable init and fall back.
+public struct HexColor: Equatable, Sendable {
+    public let r: Int
+    public let g: Int
+    public let b: Int
+
+    public init(r: Int, g: Int, b: Int) {
+        self.r = min(255, max(0, r))
+        self.g = min(255, max(0, g))
+        self.b = min(255, max(0, b))
+    }
+
+    public init?(_ text: String) {
+        var value = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        if value.hasPrefix("#") { value.removeFirst() }
+        guard value.count == 6, let number = Int(value, radix: 16) else { return nil }
+        self.init(r: (number >> 16) & 255, g: (number >> 8) & 255, b: number & 255)
+    }
+
+    public var hex: String {
+        func two(_ v: Int) -> String {
+            let s = String(v, radix: 16, uppercase: true)
+            return s.count == 1 ? "0" + s : s
+        }
+        return "#" + two(r) + two(g) + two(b)
+    }
+
+    public static let black = HexColor(r: 0, g: 0, b: 0)
+    public static let white = HexColor(r: 255, g: 255, b: 255)
+}
+
+/// Ports packages/zeechat-ui/src/color-contrast.ts.
+public enum Contrast {
+    /// WCAG relative luminance.
+    public static func luminance(_ color: HexColor) -> Double {
+        func channel(_ value: Int) -> Double {
+            let c = Double(value) / 255.0
+            return c <= 0.04045 ? c / 12.92 : pow((c + 0.055) / 1.055, 2.4)
+        }
+        return channel(color.r) * 0.2126 + channel(color.g) * 0.7152 + channel(color.b) * 0.0722
+    }
+
+    public static func ratio(_ a: HexColor, _ b: HexColor) -> Double {
+        let x = luminance(a)
+        let y = luminance(b)
+        return (max(x, y) + 0.05) / (min(x, y) + 0.05)
+    }
+
+    /// Black or white, whichever has the higher contrast on the background.
+    public static func readable(on background: HexColor) -> (foreground: HexColor, ratio: Double) {
+        let black = ratio(background, .black)
+        let white = ratio(background, .white)
+        return black >= white ? (.black, black) : (.white, white)
+    }
+
+    private static let lightBrand = 0.4
+
+    /// A brand color for surfaces that carry text. Mid-tone brands get darker until white text passes 4.5:1.
+    public static func brandSurface(_ color: HexColor) -> (background: HexColor, foreground: HexColor) {
+        if ratio(color, .white) >= 4.5 { return (color, .white) }
+        if luminance(color) > lightBrand { return (color, .black) }
+        let (h, s, l) = toHSL(color)
+        var next = l
+        while next >= 0 {
+            let shade = fromHSL(h, s, next)
+            if ratio(shade, .white) >= 4.5 { return (shade, .white) }
+            next -= 0.01
+        }
+        return (.black, .white)
+    }
+
+    public static func toHSL(_ color: HexColor) -> (Double, Double, Double) {
+        let r = Double(color.r) / 255, g = Double(color.g) / 255, b = Double(color.b) / 255
+        let maxV = max(r, g, b), minV = min(r, g, b)
+        let light = (maxV + minV) / 2
+        if maxV == minV { return (0, 0, light) }
+        let delta = maxV - minV
+        let saturation = light > 0.5 ? delta / (2 - maxV - minV) : delta / (maxV + minV)
+        let hue: Double
+        if maxV == r { hue = (g - b) / delta + (g < b ? 6 : 0) } else if maxV == g { hue = (b - r) / delta + 2 } else { hue = (r - g) / delta + 4 }
+        return (hue / 6, saturation, light)
+    }
+
+    public static func fromHSL(_ h: Double, _ s: Double, _ l: Double) -> HexColor {
+        let q = l < 0.5 ? l * (1 + s) : l + s - l * s
+        let p = 2 * l - q
+        func channel(_ t0: Double) -> Int {
+            var t = t0
+            if t < 0 { t += 1 }
+            if t > 1 { t -= 1 }
+            let value: Double
+            if t < 1.0 / 6 { value = p + (q - p) * 6 * t } else if t < 0.5 { value = q } else if t < 2.0 / 3 { value = p + (q - p) * (2.0 / 3 - t) * 6 } else { value = p }
+            return Int((value * 255).rounded())
+        }
+        return HexColor(r: channel(h + 1.0 / 3), g: channel(h), b: channel(h - 1.0 / 3))
+    }
+
+    /// Lightness scaled down by a percent. Used for the header gradient end (18 percent).
+    public static func darken(_ color: HexColor, percent: Double) -> HexColor {
+        let (h, s, l) = toHSL(color)
+        return fromHSL(h, s, max(0, l * (1 - percent / 100)))
+    }
+
+    /// `top` over `bottom` at an alpha from 0 to 1.
+    public static func blend(_ top: HexColor, over bottom: HexColor, alpha: Double) -> HexColor {
+        func mix(_ a: Int, _ b: Int) -> Int { Int((Double(a) * alpha + Double(b) * (1 - alpha)).rounded()) }
+        return HexColor(r: mix(top.r, bottom.r), g: mix(top.g, bottom.g), b: mix(top.b, bottom.b))
+    }
+}
+
+/// All colors for one screen, resolved from the snapshot and the dark flag. Hex strings.
+public struct ChatPalette: Equatable, Sendable {
+    public var isDark: Bool
+    public var primary: HexColor
+    public var onPrimary: HexColor
+    public var headerEnd: HexColor
+    public var customer: HexColor
+    public var onCustomer: HexColor
+    public var bg: HexColor
+    public var bgAlt: HexColor
+    public var ink: HexColor
+    public var ink2: HexColor
+    public var line: HexColor
+    public var agentBubble: HexColor
+    public var ok: HexColor
+    public var bad: HexColor
+    public var link: HexColor
+    public var avatarTone: HexColor
+    public var avatarInk: HexColor
+    public var disabledSend: HexColor
+
+    /// Resolves the palette. `systemDark` is the device setting; the snapshot theme and `override` can force it.
+    public static func resolve(appearance: Appearance, systemDark: Bool, override: ThemeMode? = nil) -> ChatPalette {
+        let mode = override ?? appearance.theme
+        let dark = mode == .dark || (mode == .auto && systemDark)
+        let primary = HexColor(appearance.primaryColor) ?? HexColor(r: 125, g: 59, b: 237)
+        let customer = HexColor(appearance.customerMessageColor) ?? primary
+        let surface = HexColor(appearance.surfaceColor) ?? .white
+
+        let bg: HexColor = dark ? HexColor("#0F1525") ?? .black : surface
+        // A dark surface in light mode needs light ink: pick by contrast.
+        let ink: HexColor
+        let ink2: HexColor
+        if dark {
+            ink = HexColor("#F4F6FC") ?? .white
+            ink2 = HexColor("#AEB6CC") ?? .white
+        } else if Contrast.readable(on: bg).foreground == .white {
+            ink = HexColor("#F4F6FC") ?? .white
+            ink2 = HexColor("#AEB6CC") ?? .white
+        } else {
+            ink = HexColor("#111426") ?? .black
+            ink2 = HexColor("#50556B") ?? .black
+        }
+        let inkIsLight = Contrast.luminance(ink) > 0.5
+        let bgAlt: HexColor = dark ? HexColor("#161D30") ?? bg : Contrast.blend(ink, over: bg, alpha: 0.04)
+        let agent: HexColor = dark ? HexColor("#1E2740") ?? bg : (inkIsLight ? Contrast.blend(.white, over: bg, alpha: 0.12) : HexColor("#F1F1F6") ?? bg)
+        let line: HexColor = dark ? HexColor("#222B42") ?? ink2 : (inkIsLight ? Contrast.blend(.white, over: bg, alpha: 0.16) : HexColor("#E7E7EF") ?? ink2)
+
+        // Link: primary if it has 4.5:1 on bg, else ink.
+        let link = Contrast.ratio(primary, bg) >= 4.5 ? primary : ink
+
+        return ChatPalette(
+            isDark: dark,
+            primary: primary,
+            onPrimary: Contrast.readable(on: primary).foreground,
+            headerEnd: Contrast.darken(primary, percent: 18),
+            customer: customer,
+            onCustomer: Contrast.readable(on: customer).foreground,
+            bg: bg,
+            bgAlt: bgAlt,
+            ink: ink,
+            ink2: ink2,
+            line: line,
+            agentBubble: agent,
+            ok: HexColor(dark ? "#34D399" : "#16A34A") ?? .black,
+            bad: HexColor(dark ? "#F87171" : "#D92D32") ?? .black,
+            link: link,
+            avatarTone: HexColor(dark ? "#2B3556" : "#D9D3F5") ?? .white,
+            avatarInk: HexColor(dark ? "#E7E9F6" : "#3B2A86") ?? .black,
+            disabledSend: HexColor(dark ? "#2B3556" : "#E3E3EB") ?? .white
+        )
+    }
+}
+
+/// Sizes from the spec and the approved canvas. Points.
+public enum Metrics {
+    public static let bubbleRadius: Double = 20
+    public static let tailRadius: Double = 6
+    public static let squareBubbleRadius: Double = 8
+    public static let squareTailRadius: Double = 4
+    public static let cardRadius: Double = 16
+    public static let controlRadius: Double = 12
+    public static let imageRadius: Double = 14
+    public static let maxBubbleFraction: Double = 0.78
+    public static let maxBubbleWidthPad: Double = 520
+    public static let maxImageWidth: Double = 240
+    public static let minTouch: Double = 44
+    public static let composerSend: Double = 36
+    public static let groupGap: Double = 2
+    public static let groupGapCompact: Double = 2
+    public static let newSenderGap: Double = 12
+    public static let newSenderGapCompact: Double = 8
+    public static let groupWindowSeconds: Double = 300
+    public static let homeOverlap: Double = 20
+
+    public static func bubbleRadius(_ corners: Corners) -> Double { corners == .square ? squareBubbleRadius : bubbleRadius }
+    public static func tailRadius(_ corners: Corners) -> Double { corners == .square ? squareTailRadius : tailRadius }
+    public static func senderGap(_ density: Density) -> Double { density == .compact ? newSenderGapCompact : newSenderGap }
+
+    /// 1.45 for Arabic, 1.35 for English.
+    public static func lineHeightMultiple(_ locale: ChatLocale) -> Double { locale == .ar ? 1.45 : 1.35 }
+}
+
+/// Type roles: size and weight. Weight uses the CSS numbers (400, 600, 700).
+public enum TypeRole: Sendable {
+    case homeHeading, screenTitle, message, sectionTitle, secondary, caption
+
+    public var size: Double {
+        switch self {
+        case .homeHeading: return 28
+        case .screenTitle: return 17
+        case .message: return 16
+        case .sectionTitle: return 15
+        case .secondary: return 13
+        case .caption: return 12
+        }
+    }
+
+    public var weight: Int {
+        switch self {
+        case .homeHeading: return 700
+        case .screenTitle, .sectionTitle: return 600
+        case .message, .secondary, .caption: return 400
+        }
+    }
+}

package/ios/vendor/swift/ZellioChatCore/ThreadController.swift

@@ -0,0 +1,319 @@
+import Foundation
+
+public struct ThreadSnapshot: Equatable, Sendable {
+    public var conversationId: String?
+    public var messages: [ChatMessage] = []
+    public var hasOlder = false
+    public var isLoadingOlder = false
+    public var isLoading = true
+    public var typing = false
+    public var typingName: String?
+    public var error: ChatError?
+    public var canAttach = true
+    /// Counts agent messages that arrived live. The view uses it for the "New message" pill, the tick and the announcement.
+    public var incomingCount = 0
+    /// True when a visible message changed in place or was added at the end by this controller.
+    public var revision = 0
+
+    public init(conversationId: String? = nil) { self.conversationId = conversationId }
+}
+
+/// The logic of one thread: load, page, send, retry, merge live messages. The view only draws snapshots.
+public actor ThreadController {
+    public typealias Observer = @Sendable (ThreadSnapshot) -> Void
+
+    private let engine: ChatEngine
+    private var timeline = Timeline()
+    private var snapshot: ThreadSnapshot
+    private var observer: Observer?
+    private var listenerToken: Int?
+    private var typingTask: Task<Void, Never>?
+    private var reloadedForExpiredAttachment = false
+    private var started = false
+
+    public init(engine: ChatEngine, conversationId: String?) {
+        self.engine = engine
+        self.snapshot = ThreadSnapshot(conversationId: conversationId)
+    }
+
+    public func setObserver(_ observer: Observer?) {
+        self.observer = observer
+        observer?(snapshot)
+    }
+
+    public var conversationId: String? { snapshot.conversationId }
+
+    private func publish() {
+        snapshot.messages = timeline.messages
+        snapshot.hasOlder = timeline.hasOlder
+        snapshot.revision += 1
+        observer?(snapshot)
+    }
+
+    // MARK: Start and stop
+
+    /// Draws what is saved at once, then reads the newest page.
+    public func start() async {
+        guard !started else { return }
+        started = true
+        if let id = snapshot.conversationId, let saved = engine.storage.load(Timeline.self, StorageName.messages(id)) {
+            timeline = saved
+        }
+        snapshot.canAttach = engine.cachedConfig?.snapshot.behavior.allowAttachments ?? true
+        mergeQueue()
+        snapshot.isLoading = timeline.messages.isEmpty && snapshot.conversationId != nil
+        publish()
+
+        let engineRef = engine
+        let token = engineRef.addListener { [weak self] event in
+            guard let self = self else { return }
+            Task { await self.handle(event) }
+        }
+        listenerToken = token
+
+        await loadLatest()
+        await engine.outbox.kick()
+    }
+
+    public func stop() {
+        if let token = listenerToken { engine.removeListener(token) }
+        listenerToken = nil
+        typingTask?.cancel()
+        observer = nil
+        persist()
+    }
+
+    private func persist() {
+        guard let id = snapshot.conversationId else { return }
+        engine.storage.save(timeline.persisted(), StorageName.messages(id))
+    }
+
+    // MARK: Loading
+
+    private func loadLatest() async {
+        guard let id = snapshot.conversationId else {
+            snapshot.isLoading = false
+            publish()
+            return
+        }
+        do {
+            let page = try await engine.session.perform { token in try await self.engine.api.messages(conversationId: id, token: token) }
+            timeline.apply(page: page, older: false, initial: true)
+            timeline.trim()
+            snapshot.error = nil
+            snapshot.isLoading = false
+            mergeQueue()
+            persist()
+            publish()
+            await markReadIfNeeded()
+        } catch {
+            fail(error)
+        }
+    }
+
+    private func fail(_ error: Error) {
+        let mapped = ErrorPolicy.map(error)
+        snapshot.isLoading = false
+        // A thread that has messages keeps them. The view shows a banner, not an empty error screen.
+        snapshot.error = mapped
+        publish()
+        if mapped == .conversationNotFound { Task { _ = try? await engine.loadConversations() } }
+    }
+
+    public func retryLoad() async {
+        snapshot.isLoading = timeline.messages.isEmpty
+        snapshot.error = nil
+        publish()
+        await loadLatest()
+    }
+
+    /// Older messages, when the customer scrolls to the top.
+    public func loadOlder() async {
+        guard let id = snapshot.conversationId, let cursor = timeline.nextBefore, !snapshot.isLoadingOlder else { return }
+        snapshot.isLoadingOlder = true
+        publish()
+        do {
+            let page = try await engine.session.perform { token in try await self.engine.api.messages(conversationId: id, before: cursor, token: token) }
+            timeline.apply(page: page, older: true)
+            snapshot.isLoadingOlder = false
+            persist()
+            publish()
+        } catch {
+            snapshot.isLoadingOlder = false
+            publish()
+        }
+    }
+
+    /// Reads messages newer than the last one we have. Used after a gap: reconnect, foreground, push.
+    public func catchUp() async {
+        if snapshot.conversationId == nil { await adoptConversationFromList() }
+        guard let id = snapshot.conversationId else { return }
+        guard let cursor = timeline.latest else { await loadLatest(); return }
+        do {
+            let page = try await engine.session.perform { token in try await self.engine.api.messages(conversationId: id, after: cursor, token: token) }
+            let before = timeline.messages.count
+            timeline.apply(page: page, older: false)
+            timeline.trim()
+            countIncoming(timeline.messages.count - before, in: page.messages)
+            snapshot.error = nil
+            persist()
+            publish()
+            await markReadIfNeeded()
+        } catch {
+            if ErrorPolicy.map(error) == .conversationNotFound { fail(error) }
+        }
+    }
+
+    /// An attachment URL expired (403): read the page again, once.
+    public func reloadAfterExpiredAttachment() async {
+        guard !reloadedForExpiredAttachment else { return }
+        reloadedForExpiredAttachment = true
+        await loadLatest()
+    }
+
+    private func adoptConversationFromList() async {
+        guard let page = try? await engine.loadConversations(), let newest = page.conversations.first else { return }
+        guard timeline.messages.contains(where: { $0.from == .visitor }) else { return }
+        snapshot.conversationId = newest.id
+    }
+
+    private func countIncoming(_ added: Int, in messages: [ChatMessage]) {
+        guard added > 0 else { return }
+        snapshot.incomingCount += messages.filter { $0.from == .agent }.count
+    }
+
+    private func markReadIfNeeded() async {
+        guard let id = snapshot.conversationId,
+              let last = timeline.messages.last(where: { $0.from == .agent && $0.serverId != nil }),
+              let serverId = last.serverId else { return }
+        await engine.markRead(conversationId: id, upTo: serverId)
+    }
+
+    // MARK: Live events
+
+    private func handle(_ event: HubEvent) async {
+        switch event {
+        case .localDataWiped:
+            break
+        case .reconnected:
+            await catchUp()
+        case .outbox(let update):
+            handleOutbox(update)
+        case .realtime(let realtime):
+            switch realtime {
+            case .ready(let id):
+                if snapshot.conversationId == nil, let id = id, timeline.messages.contains(where: { $0.from == .visitor }) {
+                    snapshot.conversationId = id
+                    publish()
+                }
+            case .message(let message, let conversationId):
+                guard accepts(streamConversation: conversationId ?? engine.streamConversationId) else { return }
+                if snapshot.conversationId == nil, let conversationId = conversationId { snapshot.conversationId = conversationId }
+                let isNew = !timeline.messages.contains { ($0.serverId != nil && $0.serverId == message.serverId) || ($0.clientMessageId != nil && $0.clientMessageId == message.clientMessageId) }
+                timeline.upsert(message)
+                timeline.trim()
+                if isNew && message.from == .agent {
+                    snapshot.incomingCount += 1
+                    snapshot.typing = false
+                }
+                persist()
+                publish()
+                if message.from == .agent { await markReadIfNeeded() }
+            case .typing(let active, let name):
+                setTyping(active, name: name)
+            case .agentJoined:
+                break
+            case .unread:
+                break
+            }
+        }
+    }
+
+    private func accepts(streamConversation: String?) -> Bool {
+        guard let mine = snapshot.conversationId else { return true }
+        return streamConversation == nil || streamConversation == mine
+    }
+
+    private func setTyping(_ active: Bool, name: String?) {
+        typingTask?.cancel()
+        snapshot.typing = active
+        snapshot.typingName = active ? name : nil
+        publish()
+        if active {
+            // Safety: if the "stopped" event is lost, the dots go away after 12 seconds.
+            typingTask = Task { [weak self] in
+                try? await Task.sleep(nanoseconds: 12_000_000_000)
+                if Task.isCancelled { return }
+                await self?.clearTyping()
+            }
+        }
+    }
+
+    private func clearTyping() {
+        snapshot.typing = false
+        publish()
+    }
+
+    // MARK: Sending
+
+    /// Saves the message to the queue first, shows it at once, then sends. Returns the client id.
+    @discardableResult
+    public func send(text: String, attachments: [Attachment] = []) -> String? {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        if trimmed.isEmpty && attachments.isEmpty { return nil }
+        let item = engine.queue.enqueue(text: trimmed.clipped(toUTF16: 4000), attachments: attachments, context: engine.context, conversationId: snapshot.conversationId)
+        timeline.upsert(item.asMessage(delivery: .sending))
+        engine.drafts.set("", conversationId: snapshot.conversationId)
+        publish()
+        let engineRef = engine
+        Task { await engineRef.outbox.kick() }
+        return item.clientMessageId
+    }
+
+    /// "Try again" on a failed message.
+    public func retry(clientMessageId: String) {
+        engine.queue.retry(clientMessageId)
+        timeline.setDelivery(clientMessageId: clientMessageId, .sending)
+        publish()
+        let engineRef = engine
+        Task { await engineRef.outbox.kick() }
+    }
+
+    private func handleOutbox(_ update: Outbox.Update) {
+        switch update {
+        case .changed:
+            for item in engine.queue.pending where item.attempts > 0 {
+                timeline.setDelivery(clientMessageId: item.clientMessageId, .waiting)
+            }
+            publish()
+        case .sent(let cid, let receipt):
+            timeline.setDelivery(clientMessageId: cid, .sent)
+            if snapshot.conversationId == nil, let id = receipt.conversationId { snapshot.conversationId = id }
+            publish()
+            // The server copy arrives by the stream. If it does not, this read finds it.
+            Task { [weak self] in
+                try? await Task.sleep(nanoseconds: 1_500_000_000)
+                await self?.catchUp()
+            }
+        case .failed(let cid, let reason):
+            timeline.setDelivery(clientMessageId: cid, .failed, reason: reason)
+            publish()
+        }
+    }
+
+    /// Puts queue items that are not in the list yet into it. Used at start, after a restart.
+    private func mergeQueue() {
+        for item in engine.queue.all where item.conversationId == nil || item.conversationId == snapshot.conversationId {
+            let delivery: DeliveryState = item.status == .failed ? .failed : (item.attempts > 0 ? .waiting : .sending)
+            if timeline.messages.contains(where: { $0.clientMessageId == item.clientMessageId && $0.serverId != nil }) { continue }
+            var message = item.asMessage(delivery: delivery)
+            message.failureReason = item.failureReason
+            timeline.upsert(message)
+        }
+    }
+
+    // MARK: Draft
+
+    public func draft() -> String { engine.drafts.get(snapshot.conversationId) }
+    public func saveDraft(_ text: String) { engine.drafts.set(text, conversationId: snapshot.conversationId) }
+}