Add observability event log to demo

Author: MikeChen1109

LiveLocalizationKit/DemoLocalizationEventStore.swift

@@ -0,0 +1,67 @@
+import Foundation
+import LiveLocalizationCore
+
+actor DemoLocalizationEventStore {
+    private let entryLimit = 50
+    private var entries: [String] = []
+    private var continuations: [UUID: AsyncStream<[String]>.Continuation] = [:]
+
+    func record(_ event: LocalizationEvent) {
+        entries.insert(Self.description(for: event), at: 0)
+        if entries.count > entryLimit {
+            entries.removeLast(entries.count - entryLimit)
+        }
+
+        let snapshot = entries
+        for continuation in continuations.values {
+            continuation.yield(snapshot)
+        }
+    }
+
+    func snapshots() -> AsyncStream<[String]> {
+        AsyncStream { continuation in
+            let id = UUID()
+            continuations[id] = continuation
+            continuation.yield(entries)
+
+            continuation.onTermination = { [weak self] _ in
+                Task {
+                    await self?.removeContinuation(withID: id)
+                }
+            }
+        }
+    }
+
+    private func removeContinuation(withID id: UUID) {
+        continuations[id] = nil
+    }
+
+    private static func description(for event: LocalizationEvent) -> String {
+        switch event {
+        case .sharedConfigurationStarted:
+            return "Shared configuration started"
+        case .sharedConfigurationFinished:
+            return "Shared configuration finished"
+        case .cacheWarmupStarted:
+            return "Cache warmup started"
+        case .cacheWarmupFinished:
+            return "Cache warmup finished"
+        case .cacheHit(let key):
+            return "Cache hit: \(key)"
+        case .cacheMiss(let key):
+            return "Cache miss: \(key)"
+        case .cacheStoreWrite(let key):
+            return "Cache write: \(key)"
+        case .cacheInvalidated(let key):
+            return "Cache invalidated: \(key)"
+        case .cacheCleared:
+            return "Cache cleared"
+        case .providerTranslationStarted(let request):
+            return "Provider started: \(request.sourceText)"
+        case .providerTranslationSucceeded(let request, let localizedText):
+            return "Provider succeeded: \(request.sourceText) -> \(localizedText)"
+        case .providerTranslationFailed(let request, let fallbackText):
+            return "Provider fallback: \(request.sourceText) -> \(fallbackText)"
+        }
+    }
+}

LiveLocalizationKit/LiveLocalizationKitApp.swift

@@ -5,6 +5,7 @@ import LiveLocalizationTranslationSupport
 @main
 struct LiveLocalizationKitApp: App {
     private let shouldPresentPreparationGate: Bool
+    private let eventStore = DemoLocalizationEventStore()
     @State private var isConfigured = false
 
     init() {
@@ -15,7 +16,10 @@ struct LiveLocalizationKitApp: App {
         WindowGroup {
             Group {
                 if isConfigured {
-                    RootDemoView(shouldPresentPreparationGate: shouldPresentPreparationGate)
+                    RootDemoView(
+                        shouldPresentPreparationGate: shouldPresentPreparationGate,
+                        eventStore: eventStore
+                    )
                 } else {
                     ProgressView()
                 }
@@ -28,7 +32,10 @@ struct LiveLocalizationKitApp: App {
                     cachePolicy: LocalizationCachePolicy(
                         namespace: "demo",
                         providerIdentifier: "apple-translation"
-                    )
+                    ),
+                    logger: ClosureLocalizationLogger { event in
+                        await eventStore.record(event)
+                    }
                 )
                 isConfigured = true
             }

LiveLocalizationKit/LocalizationEventLogView.swift

@@ -0,0 +1,37 @@
+import SwiftUI
+
+struct LocalizationEventLogView: View {
+    let eventStore: DemoLocalizationEventStore
+
+    @State private var entries: [String] = []
+
+    var body: some View {
+        NavigationStack {
+            Group {
+                if entries.isEmpty {
+                    ContentUnavailableView(
+                        "No Events Yet",
+                        systemImage: "list.bullet.rectangle",
+                        description: Text("Run the SwiftUI or UIKit demos to generate localization events.")
+                    )
+                } else {
+                    List(entries, id: \.self) { entry in
+                        Text(entry)
+                            .font(.footnote.monospaced())
+                            .textSelection(.enabled)
+                    }
+                }
+            }
+            .navigationTitle("Events")
+        }
+        .task {
+            for await snapshot in await eventStore.snapshots() {
+                entries = snapshot
+            }
+        }
+    }
+}
+
+#Preview {
+    LocalizationEventLogView(eventStore: DemoLocalizationEventStore())
+}

LiveLocalizationKit/RootDemoView.swift

@@ -3,6 +3,7 @@ import LiveLocalizationTranslationSupport
 
 struct RootDemoView: View {
     let shouldPresentPreparationGate: Bool
+    let eventStore: DemoLocalizationEventStore
 
     var body: some View {
         TranslationPreparationGate(isEnabled: shouldPresentPreparationGate) {
@@ -21,6 +22,11 @@ struct RootDemoView: View {
                 .tabItem {
                     Label("UIKit", systemImage: "square.stack.3d.up")
                 }
+
+            LocalizationEventLogView(eventStore: eventStore)
+                .tabItem {
+                    Label("Events", systemImage: "list.bullet.rectangle")
+                }
         }
     }
 }