Fix tab content view recreation

Example/Example/ContentView.swift

@@ -25,32 +25,31 @@ import SwiftUI
 import TabBar
 
 struct ContentView: View {
-
     private enum Item: Int, Tabbable {
         case first = 0
         case second
         case third
-        
+
         var icon: String {
             switch self {
-                case .first: return "house"
-                case .second: return "magnifyingglass"
-                case .third: return "person"
+            case .first: "house"
+            case .second: "magnifyingglass"
+            case .third: "person"
             }
         }
-        
+
         var title: String {
             switch self {
-                case .first: return "First"
-                case .second: return "Second"
-                case .third: return "Third"
+            case .first: "First"
+            case .second: "Second"
+            case .third: "Third"
             }
         }
     }
-    
+
     @State private var selection: Item = .first
     @State private var visibility: TabBarVisibility = .visible
-    
+
     var body: some View {
         TabBar(selection: $selection, visibility: $visibility) {
             Button {
@@ -61,15 +60,32 @@ struct ContentView: View {
                 Text("Hide/Show TabBar")
             }
             .tabItem(for: Item.first)
-            
-            Text("Second")
+
+            TextWrapper()
                 .tabItem(for: Item.second)
-            
-            Text("Third")
+
+            TextWrapper()
                 .tabItem(for: Item.third)
         }
         .tabBar(style: CustomTabBarStyle())
         .tabItem(style: CustomTabItemStyle())
+        .onChange(of: selection) { newValue in
+            print("selection changed:", newValue)
+        }
+    }
+}
+
+struct TextWrapper: View {
+    @State var string: String = UUID().uuidString
+
+    var body: some View {
+        Text(string)
+            .onTapGesture {
+                string = UUID().uuidString
+            }
+            .onAppear(perform: {
+                print("onAppear:", string)
+            })
     }
 }
 

Package.swift

@@ -1,19 +1,19 @@
-// swift-tools-version:5.2
+// swift-tools-version:5.3
 
 import PackageDescription
 
 let package = Package(
     name: "TabBar",
     platforms: [
-        .iOS(.v13)
+        .iOS(.v14),
     ],
     products: [
         .library(
             name: "TabBar",
             targets: ["TabBar"]
-        )
+        ),
     ],
     targets: [
-        .target(name: "TabBar")
+        .target(name: "TabBar"),
     ]
 )

Sources/TabBar/Common/Preferences/TabBarSelection.swift

@@ -21,12 +21,35 @@
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //  SOFTWARE.
 
+import Combine
 import SwiftUI
 
 class TabBarSelection<TabItem: Tabbable>: ObservableObject {
-    @Binding var selection: TabItem
-
+    private var cancelSet = Set<AnyCancellable>()
+
+    @Published var selection: TabItem {
+        didSet {
+            loadedItems.insert(selection)
+        }
+    }
+
+    @Published var items: [TabItem] = [] {
+        didSet {
+            loadedItems = [selection]
+        }
+    }
+
+    @Published var loadedItems = Set<TabItem>()
+
     init(selection: Binding<TabItem>) {
-        self._selection = selection
+        self.selection = selection.wrappedValue
+        loadedItems.insert(selection.wrappedValue)
+
+        $selection.sink { item in
+            DispatchQueue.main.async {
+                selection.wrappedValue = item
+            }
+        }
+        .store(in: &cancelSet)
     }
 }

Sources/TabBar/Common/Preferences/TabBarViewModifier.swift

@@ -25,29 +25,31 @@ import SwiftUI
 
 struct TabBarViewModifier<TabItem: Tabbable>: ViewModifier {
     @EnvironmentObject private var selectionObject: TabBarSelection<TabItem>
-    
+
     let item: TabItem
-    
+
     func body(content: Content) -> some View {
         Group {
-            if self.item == self.selectionObject.selection {
+            if selectionObject.loadedItems.contains(item) {
                 content
+                    .opacity(item == selectionObject.selection ? 1 : 0)
             } else {
                 Color.clear
             }
         }
-        .preference(key: TabBarPreferenceKey.self, value: [self.item])
+        .environmentObject(selectionObject)
+        .preference(key: TabBarPreferenceKey.self, value: [item])
     }
 }
 
-extension View {
+public extension View {
     /**
      A function that is used to associated view with the passed item.
-     
+
      Use this function to associate view with the specific item
      of the `TabBar`.
      */
-    public func tabItem<TabItem: Tabbable>(for item: TabItem) -> some View {
-        return self.modifier(TabBarViewModifier(item: item))
+    func tabItem(for item: some Tabbable) -> some View {
+        modifier(TabBarViewModifier(item: item))
     }
 }

Sources/TabBar/View/TabBar.swift

@@ -25,135 +25,130 @@ import SwiftUI
 
 /**
  `TabBar` – highly customizable tab bar for your SwiftUI application.
- 
+
  By using this component you will be able to add a view that
  switches between multiple child views using interactive user
  interface elements.
- 
+
  `TabBar` can be easily customized. You have to conform
  to `TabBarStyle` and `TabItemStyle` to customize bar
  and item respectively. To apply customization you have to inject
  them to tab bar using `tabBar(style:)` for bar
  and `tabItem(style:)` for item.
- 
+
  Usage:
- 
+
  ```
  TabBar(selection: $selection) { }
     .tabBar(style: CustomTabBarStyle())
     .tabItem(style: CustomTabItemStyle())
  ```
  */
 public struct TabBar<TabItem: Tabbable, Content: View>: View {
-
-    private let selectedItem: TabBarSelection<TabItem>
-    private let content: Content
-
-    private var tabItemStyle : AnyTabItemStyle
-    private var tabBarStyle  : AnyTabBarStyle
-
-    @State private var items: [TabItem]
-
+    @StateObject private var selectedItem: TabBarSelection<TabItem>
+    private let content: () -> Content
+
+    private var tabItemStyle: AnyTabItemStyle
+    private var tabBarStyle: AnyTabBarStyle
+
     @Binding private var visibility: TabBarVisibility
-    
+
     /**
      Creates a tab bar components with given
      bindings to selection and visibility.
-     
+
      Provided views in the `content` closure
      will be recognized as a tab bar item only
      if they have `tabItem(for:)` applied on them.
      */
     public init(
         selection: Binding<TabItem>,
         visibility: Binding<TabBarVisibility> = .constant(.visible),
-        @ViewBuilder content: () -> Content
+        @ViewBuilder content: @escaping () -> Content
     ) {
-        self.tabItemStyle = .init(itemStyle: DefaultTabItemStyle())
-        self.tabBarStyle = .init(barStyle: DefaultTabBarStyle())
-
-        self.selectedItem = .init(selection: selection)
-        self.content = content()
-
-        self._items = .init(initialValue: .init())
-        self._visibility = visibility
+        tabItemStyle = .init(itemStyle: DefaultTabItemStyle())
+        tabBarStyle = .init(barStyle: DefaultTabBarStyle())
+
+        _selectedItem = .init(wrappedValue: .init(selection: selection))
+        self.content = content
+        _visibility = visibility
     }
-    
+
     private var tabItems: some View {
         HStack {
-            ForEach(self.items, id: \.self) { item in
-                self.tabItemStyle.tabItem(
+            ForEach(selectedItem.items, id: \.self) { item in
+                tabItemStyle.tabItem(
                     icon: item.icon,
                     selectedIcon: item.selectedIcon,
                     title: item.title,
-                    isSelected: self.selectedItem.selection == item
+                    isSelected: selectedItem.selection == item
                 )
                 .onTapGesture {
-                    self.selectedItem.selection = item
-                    self.selectedItem.objectWillChange.send()
+                    selectedItem.selection = item
                 }
             }
             .frame(maxWidth: .infinity)
         }
     }
-    
+
     public var body: some View {
         ZStack {
-            self.content
+            content()
                 .frame(maxWidth: .infinity, maxHeight: .infinity)
-                .environmentObject(self.selectedItem)
-            
+                .environmentObject(selectedItem)
+
             GeometryReader { geometry in
                 VStack {
                     Spacer()
-                    
-                    self.tabBarStyle.tabBar(with: geometry) {
-                        .init(self.tabItems)
+
+                    tabBarStyle.tabBar(with: geometry) {
+                        .init(tabItems)
                     }
                 }
                 .edgesIgnoringSafeArea(.bottom)
-                .visibility(self.visibility)
+                .visibility(visibility)
             }
         }
         .onPreferenceChange(TabBarPreferenceKey.self) { value in
-            self.items = value
+            if value != selectedItem.items {
+                selectedItem.items = value
+            }
         }
     }
-
 }
 
-extension TabBar {
+public extension TabBar {
     /**
      A function that is used to apply tab item's style on `TabBar`.
-     
+
      By passing the instance of object that conforms to `TabItemStyle`
      protocol `TabBar` will use this style for its items.
-     
+
      - Parameters:
         - style: Item style that should be applied to `TabBar`.
-     
+
      - Returns:
         `TabBar` with applied item style.
      */
-    public func tabItem<ItemStyle: TabItemStyle>(style: ItemStyle) -> Self {
+    func tabItem(style: some TabItemStyle) -> Self {
         var _self = self
         _self.tabItemStyle = .init(itemStyle: style)
         return _self
     }
-    
+
     /**
      A function that is used to apply tab bar's style on `TabBar`.
-     
+
      By passing the instance of object that conforms to `TabBarStyle`
      protocol `TabBar` will apply this style to its bar.
-     
+
      - Parameters:
         - style: Bar style that should be applied to `TabBar`.
-     
+
      - Returns:
         `TabBar` with applied bar style.
      */
-    public func tabBar<BarStyle: TabBarStyle>(style: BarStyle) -> Self {
+    func tabBar(style: some TabBarStyle) -> Self {
         var _self = self
         _self.tabBarStyle = .init(barStyle: style)
         return _self