Tree-Style Tabs & Split Views

ora/Common/Utils/SettingsStore.swift

@@ -150,6 +150,7 @@ class SettingsStore: ObservableObject {
     private let tabRemovalTimeoutKey = "settings.tabRemovalTimeout"
     private let maxRecentTabsKey = "settings.maxRecentTabs"
     private let autoPiPEnabledKey = "settings.autoPiPEnabled"
+    private let treeTabsEnabledKey = "settings.treeTabsEnabled"
 
     // MARK: - Per-Container
 
@@ -217,6 +218,10 @@ class SettingsStore: ObservableObject {
         didSet { defaults.set(autoPiPEnabled, forKey: autoPiPEnabledKey) }
     }
 
+    @Published var treeTabsEnabled: Bool {
+        didSet { defaults.set(treeTabsEnabled, forKey: treeTabsEnabledKey) }
+    }
+
     init() {
         autoUpdateEnabled = defaults.bool(forKey: autoUpdateKey)
         blockThirdPartyTrackers = defaults.bool(forKey: trackingThirdPartyKey)
@@ -271,6 +276,8 @@ class SettingsStore: ObservableObject {
         maxRecentTabs = maxRecentTabsValue == 0 ? 5 : maxRecentTabsValue
 
         autoPiPEnabled = defaults.object(forKey: autoPiPEnabledKey) as? Bool ?? true
+
+        treeTabsEnabled = defaults.object(forKey: treeTabsEnabledKey) as? Bool ?? false
     }
 
     // MARK: - Per-container helpers

ora/Models/Tab.swift

@@ -30,7 +30,7 @@ class Tab: ObservableObject, Identifiable {
     var createdAt: Date
     var lastAccessedAt: Date?
 
-    var type: TabType
+    private(set) var type: TabType
     var order: Int
     var faviconLocalFile: URL?
     var backgroundColorHex: String = "#000000"
@@ -56,6 +56,9 @@ class Tab: ObservableObject, Identifiable {
     @Transient var isPrivate: Bool = false
 
     @Relationship(inverse: \TabContainer.tabs) var container: TabContainer
+    @Relationship(deleteRule: .cascade) var children: [Tab]
+    @Relationship(inverse: \Tab.children) var parent: Tab?
+    @Relationship(inverse: \TabTileset.tabs) var tileset: TabTileset?
 
     /// Whether this tab is considered alive (recently accessed)
     var isAlive: Bool {
@@ -66,6 +69,7 @@ class Tab: ObservableObject, Identifiable {
 
     init(
         id: UUID = UUID(),
+        parent: Tab? = nil,
         url: URL,
         title: String,
         favicon: URL? = nil,
@@ -92,6 +96,10 @@ class Tab: ObservableObject, Identifiable {
         self.container = container
         // Initialize webView with provided configuration or default
 
+        // Tab hierarchy setup
+        self.children = []
+        self.parent = parent
+
         let config = TabScriptHandler()
 
         self.webView = WKWebView(
@@ -177,6 +185,16 @@ class Tab: ObservableObject, Identifiable {
         }
     }
 
+    func switchSections(to sec: TabType) {
+        type = sec
+        savedURL = switch sec {
+        case .pinned, .fav:
+            url
+        case .normal:
+            nil
+        }
+    }
+
     func updateHeaderColor() {
         DispatchQueue.main.asyncAfter(deadline: .now() + 1) { [weak self] in
             if let wv = self?.webView {
@@ -407,6 +425,29 @@ class Tab: ObservableObject, Identifiable {
             webView.load(request)
         }
     }
+
+    func dissociateFromRelatives() {
+        if let parent = self.parent {
+            parent.children.removeAll(where: { $0.id == id })
+            for child in parent.children {
+                if child.order > self.order {
+                    child.order -= 1
+                }
+            }
+        } else {
+            for sibling in container.tabs where sibling.type == type {
+                if sibling.order > self.order {
+                    sibling.order -= 1
+                }
+            }
+        }
+    }
+
+    func abandonChildren() {
+        for child in children {
+            child.parent = parent
+        }
+    }
 }
 
 extension FileManager {

ora/Models/TabContainer.swift

@@ -3,6 +3,10 @@ import SwiftData
 
 // MARK: - TabContainer
 
+enum ReparentingBehavior {
+    case sibling, child
+}
+
 @Model
 class TabContainer: ObservableObject, Identifiable {
     var id: UUID
@@ -11,7 +15,8 @@ class TabContainer: ObservableObject, Identifiable {
     var createdAt: Date
     var lastAccessedAt: Date
 
-    @Relationship(deleteRule: .cascade) var tabs: [Tab] = []
+    @Relationship(deleteRule: .cascade) var tilesets: [TabTileset] = []
+    @Relationship(deleteRule: .cascade) private(set) var tabs: [Tab] = []
     @Relationship(deleteRule: .cascade) var folders: [Folder] = []
     @Relationship() var history: [History] = []
 
@@ -29,27 +34,142 @@ class TabContainer: ObservableObject, Identifiable {
         self.lastAccessedAt = nowDate
     }
 
-    func reorderTabs(from: Tab, to: Tab) {
-        let dir = from.order - to.order > 0 ? -1 : 1
+    private func pushTabs(
+        in tab: Tab?,
+        ofType type: TabType, startingAfter idx: Int,
+        _ amount: Int = 1
+    ) {
+        for tab in tab?.children ?? tabs where tab.type == type {
+            if tab.order > idx {
+                tab.order += amount
+            }
+        }
+    }
+
+    func addTab(_ tab: Tab) {
+        var orderBase: Int
+        if SettingsStore.shared.treeTabsEnabled {
+            orderBase = (tab.parent?.children ?? tabs).map(\.order).max() ?? -1
+        } else if let parent = tab.parent {
+            orderBase = parent.order
+            pushTabs(
+                in: nil,
+                ofType: tab.type,
+                startingAfter: parent.order
+            )
+        } else {
+            orderBase = tabs.map(\.order).max() ?? -1
+        }
 
-        let tabOrder = self.tabs.sorted { dir == -1 ? $0.order > $1.order : $0.order < $1.order }
+        if !SettingsStore.shared.treeTabsEnabled {
+            tab.parent = nil
+        }
 
-        var started = false
-        for (index, tab) in tabOrder.enumerated() {
-            if tab.id == from.id {
-                started = true
-            }
-            if tab.id == to.id {
+        tab.order = orderBase + 1
+        tabs.append(tab)
+    }
+
+    func removeTabFromTileset(tab: Tab) {
+        guard tab.tileset != nil else { return }
+        for (i, tileset) in tilesets.enumerated() {
+            if let tabIndex = tileset.tabs.firstIndex(of: tab) {
+                tileset.tabs.remove(at: tabIndex)
+                if tileset.tabs.count <= 1 {
+                    tilesets.remove(at: i)
+                }
                 break
             }
-            if started {
-                let currentTab = tab
-                let nextTab = tabOrder[index + 1]
+        }
+        tab.tileset = nil
+    }
+
+    // TODO: Handle combining two tilesets
+    func combineToTileset(withSourceTab src: Tab, andDestinationTab dst: Tab) {
+        // Remove from tabset if exists
+        removeTabFromTileset(tab: src)
 
-                let tempOrder = currentTab.order
-                currentTab.order = nextTab.order
-                nextTab.order = tempOrder
+        if let tabset = tilesets.first(where: { $0.tabs.contains(dst) }) {
+            reorderTabs(from: src, to: tabset.tabs.last!, withReparentingBehavior: .sibling)
+            tabset.tabs.append(src)
+        } else {
+            reorderTabs(from: src, to: dst, withReparentingBehavior: .sibling)
+            let ts = TabTileset(tabs: [])
+            tilesets.append(ts)
+            ts.tabs = [src, dst]
+        }
+    }
+
+    func moveTab(_ tab: Tab, toSection section: TabType) {
+        let tabset = tilesets.first(where: { $0.tabs.contains(tab) })?.tabs ?? [tab]
+        for tab in tabset {
+            tab.switchSections(to: section)
+            if [.pinned, .fav].contains(section) {
+                tab.abandonChildren()
             }
         }
     }
+
+    func reorderTabs(
+        from: Tab,
+        to: Tab,
+        withReparentingBehavior reparentingBehavior: ReparentingBehavior = .sibling
+    ) {
+        let containingTilesetTabs = tilesets.first(where: { $0.tabs.contains(from) })?.tabs ?? [from]
+        let numRelevantTabs = containingTilesetTabs.count
+        reorderTabs(from: from, to: to.type)
+
+        switch reparentingBehavior {
+        case .sibling:
+            if let parent = to.parent {
+                parent.children.insert(from, at: 0)
+                from.parent = parent
+            } else {
+                from.parent = nil
+            }
+            // Find the highest tab in the tileset to push after
+            let maxToTilesetOrder = tilesets.first(where: { $0.tabs.contains(to) })?.tabs.map(\.order).max() ?? to.order
+
+            pushTabs(
+                in: to.parent,
+                ofType: to.type,
+                startingAfter: maxToTilesetOrder,
+                numRelevantTabs
+            )
+            for (i, tab) in containingTilesetTabs.enumerated() {
+                tab.order = maxToTilesetOrder + 1 + i
+            }
+        case .child:
+            to.children.insert(from, at: 0)
+            for (i, tab) in containingTilesetTabs.enumerated() {
+                tab.order = -containingTilesetTabs.count + i
+            }
+            for child in to.children {
+                child.order += numRelevantTabs
+            }
+        }
+    }
+
+    func reorderTabs(from: Tab, to: TabType, offsetTargetTypeOrder: Bool = false) {
+        let containingTilesetTabs = tilesets.first(where: { $0.tabs.contains(from) })?.tabs ?? [from]
+
+        containingTilesetTabs.forEach { $0.dissociateFromRelatives() }
+
+        if from.type != to {
+            moveTab(from, toSection: to)
+        }
+        if offsetTargetTypeOrder {
+            for tab in tabs where tab.type == to {
+                tab.order += containingTilesetTabs.count
+            }
+        }
+        for (i, tab) in containingTilesetTabs.enumerated() {
+            tab.order = i
+        }
+    }
+
+    func flattenTabs() {
+        for tab in tabs {
+            tab.parent = nil
+        }
+    }
 }

ora/Models/TabTileset.swift

@@ -0,0 +1,27 @@
+//
+//  TabTileset.swift
+//  ora
+//
+//  Created by Jack Hogan on 28/10/25.
+//
+
+import Foundation
+import SwiftData
+
+@Model
+class TabTileset: ObservableObject, Identifiable {
+    var id: UUID
+
+    var tabs: [Tab]
+
+    init(id: UUID = UUID(), tabs: [Tab]) {
+        self.id = id
+        self.tabs = tabs
+    }
+
+    func deparentTabs() {
+        for tab in tabs {
+            tab.dissociateFromRelatives()
+        }
+    }
+}

ora/Modules/Browser/BrowserSplitView.swift

@@ -83,15 +83,27 @@ struct BrowserSplitView: View {
                 HomeView()
             }
         }
+        let activeId = tabManager.activeTab?.id
         ZStack {
-            let activeId = tabManager.activeTab?.id
-            ForEach(tabManager.tabsToRender) { tab in
+            ForEach(tabManager.tabsToRender.filter { !($0.id == activeId || tabManager.isInSplit(tab: $0)) }) { tab in
                 if tab.isWebViewReady {
                     BrowserContentContainer {
                         BrowserWebContentView(tab: tab)
                     }
-                    .opacity(tab.id == activeId ? 1 : 0)
-                    .allowsHitTesting(tab.id == activeId)
+                    .opacity(0)
+                    .allowsHitTesting(
+                        false
+                    )
+                }
+            }
+        }
+        HStack {
+            let tabs = tabManager.tabsToRender.filter { $0.id == activeId || tabManager.isInSplit(tab: $0) }
+            if tabs.allSatisfy(\.isWebViewReady) {
+                ForEach(tabs) { tab in
+                    BrowserContentContainer {
+                        BrowserWebContentView(tab: tab)
+                    }
                 }
             }
         }