@applicaster/quick-brick-native-apple 6.15.2 → 6.16.0

package/apple/QuickBrickApple.podspec.json

@@ -1,6 +1,6 @@
 {
   "name": "QuickBrickApple",
-  "version": "6.15.2",
+  "version": "6.16.0",
   "platforms": {
     "ios": "16.0",
     "tvos": "16.0"
@@ -16,7 +16,7 @@
   "authors": "Applicaster LTD.",
   "source": {
     "git": "https://github.com/applicaster/Zapp-Frameworks.git",
-    "tag": "@@applicaster/quick-brick-native-apple/6.15.2"
+    "tag": "@@applicaster/quick-brick-native-apple/6.16.0"
   },
   "requires_arc": true,
   "source_files": "universal/**/*.{m,swift}",

package/apple/tvos/Helpers/FocusableGroupManager/FocusableManagerModule.swift

@@ -44,8 +44,8 @@ class FocusableManagerModule: NSObject, RCTBridgeModule {
         let delay = DispatchTime.now() + DispatchTimeInterval.milliseconds(delayTimer)
 
         DispatchQueue.main.asyncAfter(deadline: delay) {
-            FocusableGroupManager.shared.updateFocus(groupId: groupId,
-                                                     itemId: itemId)
+            GroupProxyManager.shared.updateFocus(groupId: groupId,
+                                                 itemId: itemId)
         }
     }
 
@@ -60,13 +60,13 @@ class FocusableManagerModule: NSObject, RCTBridgeModule {
         let delay = DispatchTime.now() + DispatchTimeInterval.milliseconds(delayTimer)
 
         DispatchQueue.main.asyncAfter(deadline: delay) {
-            FocusableGroupManager.shared.updateFocus(groupId: groupId,
-                                                     itemId: itemId,
-                                                     needsForceUpdate: true,
-                                                     completion: { succeed in
-                                                         callback?([succeed])
+            GroupProxyManager.shared.updateFocus(groupId: groupId,
+                                                 itemId: itemId,
+                                                 needsForceUpdate: true,
+                                                 completion: { succeed in
+                                                     callback?([succeed])
 
-                                                     })
+                                                 })
         }
     }
 }

package/apple/tvos/Helpers/FocusableGroupManager/GroupProxy.swift

@@ -0,0 +1,128 @@
+//
+//  GroupProxy.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 12/19/24.
+//
+
+import Foundation
+import XrayLogger
+
+class GroupProxy {
+    let groupId: String
+    private weak var group: FocusableGroupView?
+    private var children: [WeakBox<FocusableView>] = []
+    private let lock = NSLock()
+
+    var delayedPreferredFocus: FocusableView?
+
+    private lazy var logger = Logger.getLogger(for: "QuickBrickApple/FocusableGroupManager/GroupProxy")
+
+    init(groupId: String) {
+        self.groupId = groupId
+    }
+
+    // MARK: - Child Management
+
+    func addChild(_ view: FocusableView) {
+        lock.lock()
+        children.append(WeakBox(view))
+        lock.unlock()
+    }
+
+    func removeChild(_ view: FocusableView) {
+        lock.lock()
+        defer { lock.unlock() }
+
+        children.removeAll { $0.value === view }
+
+        if children.isEmpty, group == nil {
+            GroupProxyManager.shared.removeProxy(forGroupId: groupId)
+        }
+
+        if delayedPreferredFocus === view {
+            delayedPreferredFocus = nil
+        }
+    }
+
+    // MARK: - Group Binding
+
+    @MainActor func bindGroup(_ group: FocusableGroupView) {
+        // Check for duplicate group binding
+        if let existingGroup = self.group {
+            logger?.warningLog(message: """
+            ⚠️ Duplicate group binding detected for groupId: '\(groupId)'
+               Previous group: \(existingGroup.debugDescription)
+               New group: \(group.debugDescription)
+               Overwriting previous binding.
+            """)
+
+            #if DEBUG
+                // assertionFailure("Duplicate group binding for groupId '\(groupId)'. Check React Native component IDs.")
+            #endif
+        }
+
+        self.group = group
+
+        if let preferredFocusView = delayedPreferredFocus {
+            applyPreferredFocus(group,
+                                view: preferredFocusView)
+            delayedPreferredFocus = nil
+        }
+    }
+
+    func unbindGroup() {
+        lock.lock()
+        defer { lock.unlock() }
+
+        if children.isEmpty {
+            GroupProxyManager.shared.removeProxy(forGroupId: groupId)
+        }
+
+        group = nil
+    }
+
+    // MARK: - Preferred Focus
+
+    @MainActor private func applyPreferredFocus(_ currentGroup: FocusableGroupView, view: FocusableView) {
+        if view.preferredFocus {
+            currentGroup.setUserPreferredFocusEnvironments([view])
+        } else if let currentPreferred = currentGroup.getUserPreferredFocusEnvironments()?.first as? FocusableView,
+                  currentPreferred === view {
+            currentGroup.setUserPreferredFocusEnvironments(nil)
+        }
+    }
+
+    @MainActor func updatePreferredFocus(_ view: FocusableView) {
+        lock.lock()
+        let currentGroup = group
+        lock.unlock()
+
+        if let currentGroup {
+            applyPreferredFocus(currentGroup,
+                                view: view)
+        } else {
+            if view.preferredFocus {
+                delayedPreferredFocus = view
+            }
+        }
+    }
+
+    /// Get the bound group (if any)
+    func getGroup() -> FocusableGroupView? {
+        lock.lock()
+        defer { lock.unlock() }
+
+        return group
+    }
+}
+
+// MARK: - WeakBox Helper
+
+private class WeakBox<T: AnyObject> {
+    weak var value: T?
+
+    init(_ value: T) {
+        self.value = value
+    }
+}

package/apple/tvos/Helpers/FocusableGroupManager/GroupProxyManager.swift

@@ -0,0 +1,101 @@
+//
+//  GroupProxyManager.swift
+//  Pods
+//
+//  Created by Anton Kononenko on 12/19/24.
+//
+
+import Foundation
+import React
+
+class GroupProxyManager {
+    static let shared = GroupProxyManager()
+
+    private let lock = NSLock()
+    private var proxies: [GroupProxy] = []
+
+    private init() {}
+
+    // MARK: - Proxy Access
+
+    func getOrCreateProxy(forGroupId groupId: String) -> GroupProxy {
+        lock.lock()
+        defer { lock.unlock() }
+
+        if let existing = proxies.first(where: { $0.groupId == groupId }) {
+            return existing
+        }
+
+        let proxy = GroupProxy(groupId: groupId)
+        proxies.append(proxy)
+        return proxy
+    }
+
+    // MARK: - Cleanup
+
+    func removeProxy(forGroupId groupId: String) {
+        lock.lock()
+        defer { lock.unlock() }
+
+        proxies.removeAll { $0.groupId == groupId }
+    }
+
+    // MARK: - Focus Update
+
+    func updateFocus(groupId: String?,
+                     itemId: String?,
+                     needsForceUpdate: Bool = false,
+                     completion: ((Bool) -> Void)? = nil) {
+        guard let groupId,
+              let itemId else {
+            completion?(false)
+            return
+        }
+
+        lock.lock()
+        let proxy = proxies.first(where: { $0.groupId == groupId })
+        lock.unlock()
+
+        guard let proxy,
+              let groupView = proxy.getGroup() else {
+            completion?(false)
+            return
+        }
+
+        DispatchQueue.main.async {
+            var rootView: UIView? = groupView
+
+            while let unwrapedRootView = rootView,
+                  !unwrapedRootView.isReactRootView() {
+                rootView = rootView?.superview
+            }
+
+            guard let rootViewUnwrapped = rootView,
+                  let superView = rootViewUnwrapped.superview as? RCTRootView else {
+                completion?(false)
+                return
+            }
+
+            if needsForceUpdate {
+                superView.setNeedsFocusUpdate()
+                superView.updateFocusIfNeeded()
+
+                let timeout: TimeInterval = 2.0
+
+                groupView.didFocusCallBack = (completion: {
+                    completion?(true)
+                    groupView.didFocusCallBack = nil
+                }, focusableItemId: itemId)
+
+                DispatchQueue.main.asyncAfter(deadline: .now() + timeout) {
+                    if groupView.didFocusCallBack != nil {
+                        completion?(false)
+                        groupView.didFocusCallBack = nil
+                    }
+                }
+            } else {
+                completion?(true)
+            }
+        }
+    }
+}

package/apple/tvos/Views/FocusableGroupView/FocusableGroupView.swift

@@ -6,13 +6,10 @@
 //  Copyright © 2019 Kononenko. All rights reserved.
 //
 
-import Combine
 import Foundation
 import React
 import UIKit
 
-/// Focusable  Group View that implements UIFocusGuide instance that catches focus event
-///
 public class FocusableGroupView: RCTTVView {
     override public var debugDescription: String {
         let groupIdDesc = groupId ?? "NO_GROUP"
@@ -35,9 +32,6 @@ public class FocusableGroupView: RCTTVView {
         """
     }
 
-    private var cancellables = Set<AnyCancellable>()
-
-    /// Completion that will be used when focus manager forcing to update focusable group
     public var didFocusCallBack: (completion: () -> Void, focusableItemId: String)?
 
     private lazy var activeStateNotifier: FocusableGroupStateNotifier = FocusableGroupStateNotifierDefault(action: notifyReactNativeFocusUpdate)
@@ -45,40 +39,38 @@ public class FocusableGroupView: RCTTVView {
     @objc public var onGroupFocus: RCTDirectEventBlock?
     @objc public var onGroupBlur: RCTDirectEventBlock?
 
-    /// Define if focus enabled for current view
     @objc public var isFocusDisabled: Bool = false
 
-    /// Current group will try to find initial index id in groups
     @objc public var dependantGroupIds: [String]?
 
-    /// Check if preferred focus environment disabled
     @objc public var isWithMemory: Bool = true
     var isPreferredFocusDisabled: Bool {
         isWithMemory == false
     }
 
-    /// ID of the Connected GroupView provided by React-Native env
     @objc public var itemId: String? {
         didSet {
             if itemId != oldValue {
-                Task(priority: .userInitiated) {
-                    await manager.registerGroup(self)
+                if oldValue != nil {
+                    proxy?.unbindGroup()
+                    proxy = nil
+                }
+
+                if let newId = itemId {
+                    proxy = GroupProxyManager.shared.getOrCreateProxy(forGroupId: newId)
+                    proxy?.bindGroup(self)
                 }
             }
         }
     }
 
-    /// ID of the parent group, if relevant
     @objc public var groupId: String?
 
     @MainActor private var userPreferredFocusEnvironments: [UIFocusEnvironment]?
     @MainActor private var customPreferredFocusEnvironment: [UIFocusEnvironment]?
 
-    private var manager: FocusableGroupManager {
-        FocusableGroupManager.shared
-    }
+    private var proxy: GroupProxy?
 
-    /// Manager that connects View instance to FocusableGroupViewModule
     private weak var module: FocusableGroupViewModule?
     public func setModule(_ module: FocusableGroupViewModule) {
         self.module = module
@@ -90,17 +82,20 @@ public class FocusableGroupView: RCTTVView {
 
     override public func removeFromSuperview() {
         super.removeFromSuperview()
+        cleanup()
+    }
+
+    deinit {
+        cleanup()
+    }
+
+    private func cleanup() {
         guard let itemId else {
             return
         }
 
-        Task {
-            // Removing when react native releases the view
-            await manager.unregisterGroup(withId: itemId)
-
-            cancellables.forEach { $0.cancel() }
-            cancellables.removeAll()
-        }
+        proxy?.unbindGroup()
+        proxy = nil
     }
 
     public required init?(coder aDecoder: NSCoder) {
@@ -120,6 +115,14 @@ public class FocusableGroupView: RCTTVView {
         customPreferredFocusEnvironment = [view]
     }
 
+    @MainActor func setUserPreferredFocusEnvironments(_ environments: [UIFocusEnvironment]?) {
+        userPreferredFocusEnvironments = environments
+    }
+
+    @MainActor func getUserPreferredFocusEnvironments() -> [UIFocusEnvironment]? {
+        userPreferredFocusEnvironments
+    }
+
     let groupFocusGuide = UIFocusGuide()
 
     private func setupFocus() {
@@ -129,21 +132,6 @@ public class FocusableGroupView: RCTTVView {
         groupFocusGuide.topAnchor.constraint(equalTo: topAnchor).isActive = true
         groupFocusGuide.bottomAnchor.constraint(equalTo: bottomAnchor).isActive = true
         groupFocusGuide.rightAnchor.constraint(equalTo: rightAnchor).isActive = true
-
-        manager.focusableItemDidUpdatePreferredFocus
-            .filter { self.groupId != nil && $0.groupId == self.itemId }
-            .sink { [weak self] focusableView in
-                guard let self else { return }
-                guard focusableView.preferredFocus == false else {
-                    userPreferredFocusEnvironments = [focusableView]
-                    return
-                }
-
-                if let currentPreferred = userPreferredFocusEnvironments?.first as? FocusableView,
-                   currentPreferred == focusableView {
-                    userPreferredFocusEnvironments = nil
-                }
-            }.store(in: &cancellables)
     }
 
     private func createFocusEventParams(context: UIFocusUpdateContext, isActive: Bool) -> [String: Any] {

package/apple/tvos/Views/FocusableView/FocusableView.swift

@@ -6,7 +6,6 @@
 //  Copyright © 2019 Anton Kononenko. All rights reserved.
 //
 
-import Combine
 import Foundation
 import React
 import UIKit
@@ -36,8 +35,6 @@ public class FocusableView: ParallaxView {
         """
     }
 
-    private var cancellables = Set<AnyCancellable>()
-
     private weak var module: FocusableViewModule?
     func setModule(_ module: FocusableViewModule) {
         self.module = module
@@ -58,28 +55,21 @@ public class FocusableView: ParallaxView {
         }
     }
 
-    /// Define if view can become focused
     @objc open var focusable = true
 
-    private var manager: FocusableGroupManager {
-        FocusableGroupManager.shared
-    }
-
-    @MainActor private weak var focusableGroup: FocusableGroupProtocol? {
-        didSet {
-            manager.notifyFocusableItemDidUpdatePreferredFocus(focusableView: self)
-        }
-    }
+    private var proxy: GroupProxy?
 
     @MainActor @objc public var preferredFocus: Bool = false {
         didSet {
-            manager.notifyFocusableItemDidUpdatePreferredFocus(focusableView: self)
+            if oldValue == preferredFocus {
+                return
+            }
+
+            proxy?.updatePreferredFocus(self)
         }
     }
 
     private var isFocusLayoutConfigured = false
-
-    /// Define if view was registered
     private var isViewRegistered: Bool = false
 
     override public init(frame: CGRect) {
@@ -92,31 +82,34 @@ public class FocusableView: ParallaxView {
         initialize()
     }
 
-    /// Initialize component
     private func initialize() {
         delegate = self
-
-        manager.focusableGroupRegistrationUpdates
-            .filter { $0.itemId == self.groupId }
-            .sink { [weak self] focusableGroup in
-                guard let self else { return }
-                DispatchQueue.main.async {
-                    self.focusableGroup = focusableGroup
-                }
-            }.store(in: &cancellables)
     }
 
-    /// ID of the View provided by React-Native env
     @objc private(set) var itemId: String? {
         didSet {
-            registerView()
+            if itemId != oldValue {
+                if oldValue != nil {
+                    proxy?.removeChild(self)
+                    isViewRegistered = false
+                }
+
+                registerView()
+            }
         }
     }
 
-    /// ID of the View provided by React-Native env
     @objc private(set) var groupId: String? {
         didSet {
-            registerView()
+            if groupId != oldValue {
+                if oldValue != nil {
+                    proxy?.removeChild(self)
+                    proxy = nil
+                    isViewRegistered = false
+                }
+
+                registerView()
+            }
         }
     }
 
@@ -129,35 +122,31 @@ public class FocusableView: ParallaxView {
         }
     }
 
-    /// Register View in FocusableGroupManager
     private func registerView() {
-        Task(priority: .userInitiated) {
-            guard itemId != nil,
-                  groupId != nil,
-                  isViewRegistered == false,
-                  await FocusableGroupManager.shared.registerItem(self)
-            else {
-                return
-            }
-
-            await MainActor.run {
-                isViewRegistered = true
-            }
+        guard let groupId,
+              itemId != nil,
+              isViewRegistered == false
+        else {
+            return
         }
+
+        proxy = GroupProxyManager.shared.getOrCreateProxy(forGroupId: groupId)
+        proxy?.addChild(self)
+        isViewRegistered = true
     }
 
     override public func removeFromSuperview() {
         super.removeFromSuperview()
-        guard let itemId, let groupId else {
-            return
-        }
+        cleanup()
+    }
 
-        Task {
-            await FocusableGroupManager.shared.unregisterItem(withId: itemId, inGroup: groupId)
-        }
+    deinit {
+        cleanup()
+    }
 
-        cancellables.forEach { $0.cancel() }
-        cancellables.removeAll()
+    private func cleanup() {
+        proxy?.removeChild(self)
+        proxy = nil
     }
 
     private func addFocusGuideIfNeeded(tag: NSNumber?,
@@ -226,32 +215,18 @@ public class FocusableView: ParallaxView {
             }
 
             DispatchQueue.main.async { [weak self] in
-                FocusableGroupManager.shared.updateFocus(groupId: self?.groupId,
-                                                         itemId: self?.itemId,
-                                                         needsForceUpdate: true)
+                GroupProxyManager.shared.updateFocus(groupId: self?.groupId,
+                                                     itemId: self?.itemId,
+                                                     needsForceUpdate: true)
             }
         }
     }
 
     override public var canBecomeFocused: Bool {
-        guard let focusableGroup else {
+        guard let focusableGroup = proxy?.getGroup() else {
             return focusable
         }
 
         return focusableGroup.canBecomeFocusable && focusable
     }
 }
-
-//    TODO: Example of solution for future with groupId and focuse id
-//    func hintLeftFocusId() {
-//        if let onFocusLeft = dictFromReactNative,
-//           let groupId = onFocusLeft["groupId"],
-//           let id = onFocusLeft["id"],
-//           let view = FocusableGroupManager.item(byGroupId: groupId,
-//                                                 andItemId: id) {
-//            _ = addFocusGuide(from: self,
-//                              to: view,
-//                              direction: .left,
-//                              debugMode: true)
-//        }
-//    }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/quick-brick-native-apple",
-  "version": "6.15.2",
+  "version": "6.16.0",
   "description": "iOS and tvOS native code for QuickBrick applications. This package is used to provide native logic for QuickBrick",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/apple/tvos/Helpers/FocusableGroupManager/FocusableGroupManager+MovementDidFailNotification.swift

@@ -1,181 +0,0 @@
-//
-//  FocusableGroupManager+MovementDidFailNotification.swift
-//  Pods
-//
-//  Created by Anton Kononenko on 9/12/25.
-//
-
-import React
-import UIKit
-
-extension FocusableGroupManager {
-    public func registerForMovementDidFailNotification() {
-        NotificationCenter.default.addObserver(
-            forName: UIFocusSystem.movementDidFailNotification,
-            object: nil,
-            queue: .main
-        ) { n in
-            guard let rootViewController = UIApplication.shared.rootViewController(),
-                  let rootView = rootViewController.view as? RCTRootView,
-                  let userInfo = n.userInfo,
-                  let ctx = userInfo[UIFocusSystem.focusUpdateContextUserInfoKey] as? UIFocusUpdateContext else { return }
-            let prev = ctx.previouslyFocusedItem as? UIView
-            let next = ctx.nextFocusedItem as? UIView
-
-            Task { @MainActor
-                [weak self] in
-                guard let self else { return }
-
-                logFocusError(userInfo: userInfo,
-                              ctx: ctx,
-                              prev: prev,
-                              next: next)
-                simulateFocusUpdateRequest(prev: prev, next: next)
-
-                // TODO: Imlamentation not need now, uncommit in futer if needed
-//                await tryToRestoreCorruptedFocusState(rootView: rootView, next: next)
-            }
-        }
-    }
-
-    @MainActor
-    private func tryToRestoreCorruptedFocusState(rootView: RCTRootView, next: UIView?) async {
-        guard let next else { return }
-
-        rootView.reactPreferredFocusEnvironments = [next]
-
-        rootView.setNeedsFocusUpdate()
-        rootView.updateFocusIfNeeded()
-
-        DispatchQueue.main.async {
-            rootView.reactPreferredFocusEnvironments = []
-            rootView.reactPreferredFocusedView = nil
-        }
-    }
-
-    private func simulateFocusUpdateRequest(prev: UIView?, next: UIView?) {
-        guard let prev,
-              let next else { return }
-        let container = lowestCommonAncestor(prev, next)
-            ?? next.window?.rootViewController?.view
-            ?? prev
-
-        let guide = UIFocusGuide()
-
-        container.addLayoutGuide(guide)
-        NSLayoutConstraint.activate([
-            guide.topAnchor.constraint(equalTo: container.topAnchor),
-            guide.bottomAnchor.constraint(equalTo: container.bottomAnchor),
-            guide.leadingAnchor.constraint(equalTo: container.leadingAnchor),
-            guide.trailingAnchor.constraint(equalTo: container.trailingAnchor),
-        ])
-        guide.preferredFocusEnvironments = [next]
-
-        let sim = UIFocusDebugger.simulateFocusUpdateRequest(from: container)
-        print("⚠️ Simulation result:\n\(sim)")
-
-        print("⚠️ Focus groups (next):\n\(UIFocusDebugger.focusGroups(for: next))")
-        print("⚠️ Preferred chain (next):\n\(UIFocusDebugger.preferredFocusEnvironments(for: next))")
-
-        container.removeLayoutGuide(guide)
-    }
-
-    private func logFocusError(userInfo _: [AnyHashable: Any],
-                               ctx: UIFocusUpdateContext,
-                               prev: UIView?,
-                               next: UIView?) {
-        print("⚠️ Focus movement FAILED. heading=\(ctx.focusHeading.rawValue)")
-        print("  prev=\(String(describing: prev))")
-        print("  next=\(String(describing: next))")
-
-        if let next {
-            print("  ▶︎ UIFocusDebugger.checkFocusability(next):")
-            print(UIFocusDebugger.checkFocusability(for: next))
-
-            let g = rectOnScreen(next)
-            print("  ▶︎ Geometry next: inWindow=\(String(describing: g.inWindow)) window=\(String(describing: g.windowBounds)) onScreen=\(g.onScreen)")
-
-            print("  ▶︎ Focus chain (next): \(focusPath(next))")
-        }
-        if let prev {
-            let g = rectOnScreen(prev)
-            print("  ▶︎ Geometry prev: inWindow=\(String(describing: g.inWindow)) onScreen=\(g.onScreen)")
-            print("  ▶︎ Focus chain (prev): \(focusPath(prev))")
-        }
-    }
-
-    // MARK: - Geometry
-
-    /// Returns the view's rect in window coords, the window bounds, and whether it's (even partially) on-screen.
-    func rectOnScreen(_ view: UIView) -> (inWindow: CGRect?, windowBounds: CGRect?, onScreen: Bool) {
-        guard let win = view.window else {
-            return (nil, nil, false)
-        }
-        let inWin = view.convert(view.bounds, to: win)
-        let on = inWin.intersects(win.bounds) && !inWin.isEmpty
-        return (inWin, win.bounds, on)
-    }
-
-    // MARK: - Focus path
-
-    func focusPath(_ env: UIFocusEnvironment) -> String {
-        var names: [String] = []
-        var cursor: UIFocusEnvironment? = env
-
-        func name(_ obj: AnyObject) -> String {
-            let cls = String(describing: type(of: obj))
-            if obj is UIView {
-                return "\(cls)"
-            } else if obj is UIViewController {
-                return "\(cls)"
-            } else {
-                return cls
-            }
-        }
-
-        while let e = cursor as AnyObject? {
-            names.append(name(e))
-            if let v = e as? UIView {
-                cursor = v.superview ?? v.next as? UIFocusEnvironment ?? v.parentFocusEnvironment
-            } else if let vc = e as? UIViewController {
-                cursor = vc.parent ?? vc.view?.superview ?? vc.parentFocusEnvironment
-            } else {
-                cursor = (e as? UIFocusEnvironment)?.parentFocusEnvironment
-            }
-
-            if e is UIApplication { break }
-            if String(describing: type(of: e)) == "AppDelegate" { break }
-        }
-
-        return names.joined(separator: " → ")
-    }
-
-    func lowestCommonAncestor(_ a: UIView, _ b: UIView) -> UIView? {
-        var seen = Set<ObjectIdentifier>()
-        var x: UIView? = a
-        while let v = x {
-            seen.insert(ObjectIdentifier(v)); x = v.superview
-        }
-        var y: UIView? = b
-        while let v = y {
-            if seen.contains(ObjectIdentifier(v)) { return v }
-            y = v.superview
-        }
-        return nil
-    }
-
-    @inline(__always)
-    func currentFocusedItem(relativeTo view: UIView?) -> UIFocusItem? {
-        if #available(tvOS 15.0, *) {
-            if let fs = view?.window?.windowScene?.focusSystem { return fs.focusedItem }
-            // Fallback if you don't have a view handy:
-            for scene in UIApplication.shared.connectedScenes {
-                if let ws = scene as? UIWindowScene { return ws.focusSystem?.focusedItem }
-            }
-            return nil
-        } else {
-            // tvOS < 15
-            return UIScreen.main.focusedItem
-        }
-    }
-}

package/apple/tvos/Helpers/FocusableGroupManager/FocusableGroupManager.swift

@@ -1,166 +0,0 @@
-//
-//  FocusableGroupManager.swift
-//  QuickBrickApple
-//
-//  Created by Anton Kononenko on 4/17/19.
-//  Copyright © 2019 Anton Kononenko. All rights reserved.
-//
-
-import Combine
-import Foundation
-import React
-
-protocol FocusableGroupManagerUpdater {
-    var focusableGroupRegistrationUpdates: PassthroughSubject<FocusableGroupView, Never> { get }
-    var focusableItemDidUpdatePreferredFocus: PassthroughSubject<FocusableView, Never> { get }
-}
-
-/// Class control focusable group view with focusable items
-class FocusableGroupManager {
-    static let shared = FocusableGroupManager()
-
-    private let groupStorage: FocusableGroupStorage
-    private let itemStorage: FocusableItemStorage
-    private let updateService: UpdateService
-
-    private init(groupStorage: FocusableGroupStorage = InMemoryFocusableGroupStorage(),
-                 itemStorage: FocusableItemStorage = InMemoryFocusableItemStorage(),
-                 updateService: UpdateService = UpdateService()) {
-        self.groupStorage = groupStorage
-        self.itemStorage = itemStorage
-        self.updateService = updateService
-
-        // TODO: Unocomment for debugging or catch focus
-        // registerForMovementDidFailNotification()
-    }
-
-    // MARK: - Group Managment
-
-    func registerGroup(_ group: FocusableGroupView) async -> Bool {
-        let wasRegistered = await groupStorage.registerGroup(group)
-        guard wasRegistered else {
-            return false
-        }
-
-        updateService.sendFocusableGroupRegisteredUpdate(group)
-        return true
-    }
-
-    func unregisterGroup(withId groupId: String) async {
-        await groupStorage.unregisterGroup(withId: groupId)
-        let items = await itemStorage.items(forGroup: groupId)
-        for itemId in items.keys {
-            await itemStorage.unregisterItem(withId: itemId, inGroup: groupId)
-        }
-    }
-
-    func getGroup(by groupID: String) async -> FocusableGroupView? {
-        await groupStorage.group(by: groupID)
-    }
-
-    // MARK: - Item Management
-
-    func registerItem(_ item: FocusableView) async -> Bool {
-        let success = await itemStorage.registerItem(item)
-        if success,
-           let groupId = await item.groupId {
-            if let itemGroup = await getGroup(by: groupId) {
-                // Handler in case group was registerd later then items
-                // TODO: Check this it gives a lot of calls, need to be optimized
-                updateService.sendFocusableGroupRegisteredUpdate(itemGroup)
-            }
-        }
-        return success
-    }
-
-    func unregisterItem(withId itemId: String, inGroup groupId: String) async {
-        await itemStorage.unregisterItem(withId: itemId, inGroup: groupId)
-    }
-
-    func getItems(forGroup groupId: String) async -> [String: FocusableView] {
-        await itemStorage.items(forGroup: groupId)
-    }
-
-    func getItem(withId itemId: String, inGroup groupId: String) async -> FocusableView? {
-        await itemStorage.item(withId: itemId, inGroup: groupId)
-    }
-
-    func notifyFocusableItemDidUpdatePreferredFocus(focusableView: FocusableView) {
-        updateService.sendFocusableItemDidUpdatePreferredFocus(focusableView)
-    }
-
-    /// Make focus item focusable if exists and registered
-    ///
-    /// - Parameters:
-    ///   - groupId: Id of the group
-    ///   - itemId: Id of the focusable item
-    ///   - needsForceUpdate: if value is true after make item as preferred item focus, It will also request Focus Engine to focus immidiately
-    ///   - completion: completion block in case need, that will be called when focusable item did focus
-    func updateFocus(groupId: String?,
-                     itemId: String?,
-                     needsForceUpdate: Bool = false,
-                     completion: ((Bool) -> Void)? = nil) {
-        Task { @MainActor in
-            guard
-                let groupId,
-                let itemId,
-                let groupView = await groupStorage.group(by: groupId),
-                let viewToFocus = await itemStorage.item(withId: itemId, inGroup: groupId)
-            else {
-                completion?(false)
-                return
-            }
-
-            groupView.updatePreferredFocusEnv(with: viewToFocus)
-
-            var rootView: UIView? = groupView
-
-            while let unwrapedRootView = rootView,
-                  !unwrapedRootView.isReactRootView() {
-                rootView = rootView?.superview
-            }
-
-            guard let rootViewUnwrapped = rootView,
-                  let superView = rootViewUnwrapped.superview as? RCTRootView else {
-                completion?(false)
-                return
-            }
-
-            superView.reactPreferredFocusedView = viewToFocus
-
-            if needsForceUpdate {
-                superView.setNeedsFocusUpdate()
-                superView.updateFocusIfNeeded()
-
-                let timeout: TimeInterval = 2.0
-
-                groupView.didFocusCallBack = (completion: {
-                    completion?(true)
-                    groupView.didFocusCallBack = nil
-
-                }, focusableItemId: itemId)
-
-                // Timeout handling
-                Task {
-                    try? await Task.sleep(nanoseconds: UInt64(timeout * 1_000_000_000))
-                    if groupView.didFocusCallBack != nil {
-                        completion?(false)
-                        groupView.didFocusCallBack = nil
-                    }
-                }
-            } else {
-                completion?(true)
-            }
-        }
-    }
-}
-
-extension FocusableGroupManager: FocusableGroupManagerUpdater {
-    var focusableItemDidUpdatePreferredFocus: PassthroughSubject<FocusableView, Never> {
-        updateService.focusableItemDidUpdatePreferredFocus
-    }
-
-    var focusableGroupRegistrationUpdates: PassthroughSubject<FocusableGroupView, Never> {
-        updateService.focusableGroupRegistrationUpdates
-    }
-}

package/apple/tvos/Helpers/FocusableGroupManager/InMemoryFocusableItemStorage.swift

@@ -1,37 +0,0 @@
-//
-//  InMemoryFocusableItemStorage.swift
-//  Pods
-//
-//  Created by Anton Kononenko on 10/28/24.
-//
-
-actor InMemoryFocusableItemStorage: FocusableItemStorage {
-    private var itemsGroups: [String: [String: FocusableView]] = [:]
-
-    func registerItem(_ item: FocusableView) async -> Bool {
-        guard let groupId = await item.groupId,
-              let itemId = await item.itemId else { return false }
-
-        if itemsGroups[groupId] == nil {
-            itemsGroups[groupId] = [:]
-        }
-
-        itemsGroups[groupId]?[itemId] = item
-
-        return true
-    }
-
-    func unregisterItem(withId itemId: String, inGroup groupId: String) {
-        guard var groupItems = itemsGroups[groupId] else { return }
-        groupItems[itemId] = nil
-        itemsGroups[groupId] = groupItems.isEmpty ? nil : groupItems
-    }
-
-    func items(forGroup groupId: String) -> [String: FocusableView] {
-        itemsGroups[groupId] ?? [:]
-    }
-
-    func item(withId itemId: String, inGroup groupId: String) -> FocusableView? {
-        itemsGroups[groupId]?[itemId]
-    }
-}

package/apple/tvos/Helpers/FocusableGroupManager/InMemoryGroupStorage.swift

@@ -1,24 +0,0 @@
-//
-//  InMemoryGroupStorage.swift
-//  Pods
-//
-//  Created by Anton Kononenko on 10/28/24.
-//
-
-actor InMemoryFocusableGroupStorage: FocusableGroupStorage {
-    private var focusableGroups: [String: FocusableGroupView] = [:]
-
-    func registerGroup(_ group: FocusableGroupView) async -> Bool {
-        guard let id = await group.itemId else { return false }
-        focusableGroups[id] = group
-        return true
-    }
-
-    func unregisterGroup(withId groupId: String) async {
-        focusableGroups.removeValue(forKey: groupId)
-    }
-
-    func group(by groupID: String) async -> FocusableGroupView? {
-        focusableGroups[groupID]
-    }
-}

package/apple/tvos/Helpers/FocusableGroupManager/Protocols/FocusableGroupManagerStorages.swift

@@ -1,19 +0,0 @@
-//
-//  FocusableGroupManagerStorages.swift
-//  Pods
-//
-//  Created by Anton Kononenko on 10/28/24.
-//
-
-protocol FocusableGroupStorage {
-    func registerGroup(_ group: FocusableGroupView) async -> Bool
-    func unregisterGroup(withId groupId: String) async
-    func group(by groupID: String) async -> FocusableGroupView?
-}
-
-protocol FocusableItemStorage {
-    func registerItem(_ item: FocusableView) async -> Bool
-    func unregisterItem(withId itemId: String, inGroup groupId: String) async
-    func items(forGroup groupId: String) async -> [String: FocusableView]
-    func item(withId itemId: String, inGroup groupId: String) async -> FocusableView?
-}

package/apple/tvos/Helpers/FocusableGroupManager/Protocols/UpdateService.swift

@@ -1,26 +0,0 @@
-//
-//  UpdateService.swift
-//  Pods
-//
-//  Created by Anton Kononenko on 10/28/24.
-//
-
-import Combine
-
-struct FocusableGroupUpdateEvent {
-    let groupId: String
-    let focusableItems: [String: FocusableView]
-}
-
-class UpdateService {
-    let focusableGroupRegistrationUpdates = PassthroughSubject<FocusableGroupView, Never>()
-    let focusableItemDidUpdatePreferredFocus = PassthroughSubject<FocusableView, Never>()
-
-    func sendFocusableGroupRegisteredUpdate(_ focusableGroupView: FocusableGroupView) {
-        focusableGroupRegistrationUpdates.send(focusableGroupView)
-    }
-
-    func sendFocusableItemDidUpdatePreferredFocus(_ focusableView: FocusableView) {
-        focusableItemDidUpdatePreferredFocus.send(focusableView)
-    }
-}