Migrate chat tab to a more maintainable structure

Author: intitni

Core/Sources/ChatGPTChatTab/ChatGPTChatTab.swift

@@ -1,6 +1,7 @@
 import ChatService
 import ChatTab
 import Combine
+import ComposableArchitecture
 import Foundation
 import OpenAIService
 import Preferences
@@ -24,8 +25,8 @@ public class ChatGPTChatTab: ChatTab {
         var buildable: Bool { true }
         var customCommand: CustomCommand?
 
-        func build() -> any ChatTab {
-            let tab = ChatGPTChatTab()
+        func build(store: StoreOf<ChatTabItem>) -> any ChatTab {
+            let tab = ChatGPTChatTab(store: store)
             Task {
                 if let customCommand {
                     try await tab.service.handleCustomCommand(customCommand)
@@ -53,10 +54,11 @@ public class ChatGPTChatTab: ChatTab {
 
     public static func restore(
         from data: Data,
+        store: StoreOf<ChatTabItem>,
         externalDependency: Void
     ) async throws -> any ChatTab {
         let state = try JSONDecoder().decode(RestorableState.self, from: data)
-        let tab = ChatGPTChatTab()
+        let tab = ChatGPTChatTab(store: store)
         tab.service.configuration.overriding = state.configuration
         await tab.service.memory.mutateHistory { history in
             history = state.history
@@ -77,14 +79,19 @@ public class ChatGPTChatTab: ChatTab {
         return [Builder(title: "New Chat", customCommand: nil)] + customCommands
     }
 
-    public init(service: ChatService = .init()) {
+    public init(service: ChatService = .init(), store: StoreOf<ChatTabItem>) {
         self.service = service
         provider = .init(service: service)
-        super.init(id: "Chat-" + provider.id.uuidString, title: "Chat")
-
+        super.init(store: store)
+    }
+    
+    public func start() {
+        chatTabViewStore.send(.updateTitle("Chat"))
         provider.$history.sink { [weak self] _ in
-            if let title = self?.provider.title {
-                self?.title = title
+            Task { @MainActor [weak self] in
+                if let title = self?.provider.title {
+                    self?.chatTabViewStore.send(.updateTitle(title))
+                }
             }
         }.store(in: &cancellable)
     }

Core/Sources/Service/GUI/ChatTabFactory.swift

@@ -11,9 +11,7 @@ import XcodeInspector
 import ProChatTabs
 
 enum ChatTabFactory {
-    static func chatTabBuilderCollection(
-        openTab: @escaping (any ChatTab) -> Void
-    ) -> [ChatTabBuilderCollection] {
+    static func chatTabBuilderCollection() -> [ChatTabBuilderCollection] {
         func folderIfNeeded(
             _ builders: [any ChatTabBuilder],
             title: String
@@ -88,8 +86,7 @@ enum ChatTabFactory {
                         try await service.modifyCode(prompt: instruction ?? "Modify content.")
                         return service.code
                     }
-                },
-                handleNewTab: openTab
+                }
             )), title: BrowserChatTab.name),
         ].compactMap { $0 }
 
@@ -100,9 +97,7 @@ enum ChatTabFactory {
 #else
 
 enum ChatTabFactory {
-    static func chatTabBuilderCollection(
-        openTab: @escaping (any ChatTab) -> Void
-    ) -> [ChatTabBuilderCollection] {
+    static func chatTabBuilderCollection() -> [ChatTabBuilderCollection] {
         func folderIfNeeded(
             _ builders: [any ChatTabBuilder],
             title: String

Core/Sources/Service/GUI/GraphicalUserInterfaceController.swift

@@ -25,6 +25,8 @@ struct GUI: ReducerProtocol {
         case suggestionWidget(WidgetFeature.Action)
     }
 
+    @Dependency(\.chatTabPool) var chatTabPool: ChatTabPool
+
     var body: some ReducerProtocol<State, Action> {
         Scope(state: \.suggestionWidgetState, action: /Action.suggestionWidget) {
             WidgetFeature()
@@ -37,16 +39,24 @@ struct GUI: ReducerProtocol {
             Reduce { _, action in
                 switch action {
                 case let .createNewTapButtonClicked(kind):
-                    guard let builder = kind?.builder else {
-                        let chatTap = ChatGPTChatTab()
-                        return .run { send in
-                            await send(.appendAndSelectTab(chatTap))
+                    return .run { send in
+                        if let (_, chatTabInfo) = await chatTabPool.createTab(for: kind) {
+                            await send(.appendAndSelectTab(chatTabInfo))
                         }
                     }
-                    guard builder.buildable else { return .none }
-                    let chatTap = builder.build()
+
+                case let .closeTabButtonClicked(id):
+                    return .run { _ in
+                        chatTabPool.removeTab(of: id)
+                    }
+
+                case let .chatTab(_, .openNewTab(builder)):
                     return .run { send in
-                        await send(.appendAndSelectTab(chatTap))
+                        if let (_, chatTabInfo) = await chatTabPool
+                            .createTab(from: builder.chatTabBuilder)
+                        {
+                            await send(.appendAndSelectTab(chatTabInfo))
+                        }
                     }
 
                 default:
@@ -65,12 +75,16 @@ struct GUI: ReducerProtocol {
                 }
 
             case .createChatGPTChatTabIfNeeded:
-                if state.chatTabGroup.tabs.contains(where: { $0 is ChatGPTChatTab }) {
+                if state.chatTabGroup.tabInfo.contains(where: {
+                    chatTabPool.getTab(of: $0.id) is ChatGPTChatTab
+                }) {
                     return .none
                 }
-                let chatTab = ChatGPTChatTab()
-                state.chatTabGroup.tabs.append(chatTab)
-                return .none
+                return .run { send in
+                    if let (_, chatTabInfo) = await chatTabPool.createTab(for: nil) {
+                        await send(.suggestionWidget(.chatPanel(.appendAndSelectTab(chatTabInfo))))
+                    }
+                }
 
             case let .sendCustomCommandToActiveChat(command):
                 @Sendable func stopAndHandleCommand(_ tab: ChatGPTChatTab) async {
@@ -80,28 +94,36 @@ struct GUI: ReducerProtocol {
                     try? await tab.service.handleCustomCommand(command)
                 }
 
-                if let activeTab = state.chatTabGroup.activeChatTab as? ChatGPTChatTab {
+                if let info = state.chatTabGroup.selectedTabInfo,
+                   let activeTab = chatTabPool.getTab(of: info.id) as? ChatGPTChatTab
+                {
                     return .run { send in
                         await send(.openChatPanel(forceDetach: false))
                         await stopAndHandleCommand(activeTab)
                     }
                 }
 
-                if let chatTab = state.chatTabGroup.tabs.first(where: {
-                    guard $0 is ChatGPTChatTab else { return false }
-                    return true
-                }) as? ChatGPTChatTab {
+                if let info = state.chatTabGroup.tabInfo.first(where: {
+                    chatTabPool.getTab(of: $0.id) is ChatGPTChatTab
+                }),
+                    let chatTab = chatTabPool.getTab(of: info.id) as? ChatGPTChatTab
+                {
                     state.chatTabGroup.selectedTabId = chatTab.id
                     return .run { send in
                         await send(.openChatPanel(forceDetach: false))
                         await stopAndHandleCommand(chatTab)
                     }
                 }
-                let chatTab = ChatGPTChatTab()
-                state.chatTabGroup.tabs.append(chatTab)
+
                 return .run { send in
+                    guard let (chatTab, chatTabInfo) = await chatTabPool.createTab(for: nil) else {
+                        return
+                    }
+                    await send(.suggestionWidget(.chatPanel(.appendAndSelectTab(chatTabInfo))))
                     await send(.openChatPanel(forceDetach: false))
-                    await stopAndHandleCommand(chatTab)
+                    if let chatTab = chatTab as? ChatGPTChatTab {
+                        await stopAndHandleCommand(chatTab)
+                    }
                 }
 
             case .suggestionWidget:
@@ -118,31 +140,28 @@ public final class GraphicalUserInterfaceController {
     let widgetController: SuggestionWidgetController
     let widgetDataSource: WidgetDataSource
     let viewStore: ViewStoreOf<GUI>
+    let chatTabPool: ChatTabPool
 
     class WeakStoreHolder {
         weak var store: StoreOf<GUI>?
     }
 
     private init() {
-        let weakStoreHolder = WeakStoreHolder()
+        let chatTabPool = ChatTabPool()
         let suggestionDependency = SuggestionWidgetControllerDependency()
         let setupDependency: (inout DependencyValues) -> Void = { dependencies in
             dependencies.suggestionWidgetControllerDependency = suggestionDependency
             dependencies.suggestionWidgetUserDefaultsObservers = .init()
-            dependencies.chatTabBuilderCollection = {
-                ChatTabFactory.chatTabBuilderCollection { tab in
-                    weakStoreHolder.store?
-                        .send(.suggestionWidget(.chatPanel(.appendAndSelectTab(tab))))
-                }
-            }
+            dependencies.chatTabPool = chatTabPool
+            dependencies.chatTabBuilderCollection = ChatTabFactory.chatTabBuilderCollection
         }
         let store = StoreOf<GUI>(
             initialState: .init(),
             reducer: GUI(),
             prepareDependencies: setupDependency
         )
-        weakStoreHolder.store = store
         self.store = store
+        self.chatTabPool = chatTabPool
         viewStore = ViewStore(store)
         widgetDataSource = .init()
 
@@ -151,9 +170,22 @@ public final class GraphicalUserInterfaceController {
                 state: \.suggestionWidgetState,
                 action: GUI.Action.suggestionWidget
             ),
+            chatTabPool: chatTabPool,
             dependency: suggestionDependency
         )
 
+        chatTabPool.createStore = { id in
+            store.scope(
+                state: { state in
+                    state.chatTabGroup.tabInfo[id: id]
+                        ?? .init(id: id, title: "")
+                },
+                action: { childAction in
+                    .suggestionWidget(.chatPanel(.chatTab(id: id, action: childAction)))
+                }
+            )
+        }
+
         suggestionDependency.suggestionWidgetDataSource = widgetDataSource
         suggestionDependency.onOpenChatClicked = { [weak self] in
             Task { [weak self] in
@@ -177,3 +209,34 @@ public final class GraphicalUserInterfaceController {
     }
 }
 
+extension ChatTabPool {
+    @MainActor
+    func createTab(
+        from builder: ChatTabBuilder
+    ) -> (any ChatTab, ChatTabInfo)? {
+        let id = UUID().uuidString
+        let info = ChatTabInfo(id: id, title: "")
+        guard builder.buildable else { return nil }
+        let chatTap = builder.build(store: createStore(id))
+        setTab(chatTap)
+        return (chatTap, info)
+    }
+
+    @MainActor
+    func createTab(
+        for kind: ChatTabKind?
+    ) -> (any ChatTab, ChatTabInfo)? {
+        let id = UUID().uuidString
+        let info = ChatTabInfo(id: id, title: "")
+        guard let builder = kind?.builder else {
+            let chatTap = ChatGPTChatTab(store: createStore(id))
+            setTab(chatTap)
+            return (chatTap, info)
+        }
+        guard builder.buildable else { return nil }
+        let chatTap = builder.build(store: createStore(id))
+        setTab(chatTap)
+        return (chatTap, info)
+    }
+}
+