react-native-screens 5.0.0-alpha.2 → 5.0.0-alpha.4

package/android/src/main/java/com/swmansion/rnscreens/stack/header/config/StackHeaderConfig.kt

@@ -2,45 +2,33 @@ package com.swmansion.rnscreens.stack.header.config
 
 import android.annotation.SuppressLint
 import android.graphics.drawable.Drawable
-import android.util.LayoutDirection
-import com.facebook.react.bridge.UIManager
-import com.facebook.react.bridge.UIManagerListener
-import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import android.view.Gravity
 import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.views.view.ReactViewGroup
 import com.swmansion.rnscreens.common.ShadowStateProxy
+import com.swmansion.rnscreens.common.text.ReactTextAppearance
 import com.swmansion.rnscreens.helpers.IconResolution
 import com.swmansion.rnscreens.helpers.PropIconResolver
-import com.swmansion.rnscreens.helpers.getFabricUIManagerNotNull
 import com.swmansion.rnscreens.helpers.resolveImage
 import com.swmansion.rnscreens.stack.header.subview.OnStackHeaderSubviewChangeListener
 import com.swmansion.rnscreens.stack.header.subview.StackHeaderSubview
 import com.swmansion.rnscreens.stack.header.subview.StackHeaderSubviewType
+import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarMenuController
+import com.swmansion.rnscreens.stack.header.toolbar.StackHeaderToolbarMenuDelegate
 import com.swmansion.rnscreens.stack.header.toolbar.model.StackHeaderToolbarMenuConfig
-import com.swmansion.rnscreens.stack.header.toolbar.model.StackHeaderToolbarMenuItemIconSource
-import com.swmansion.rnscreens.stack.header.toolbar.update.StackHeaderToolbarFieldUpdate
 import com.swmansion.rnscreens.stack.header.toolbar.update.StackHeaderToolbarMenuElementRawUpdate
 import com.swmansion.rnscreens.stack.header.toolbar.update.StackHeaderToolbarMenuIconResolver
-import com.swmansion.rnscreens.stack.header.toolbar.update.StackHeaderToolbarMenuUpdateQueue
 import java.lang.ref.WeakReference
 import kotlin.properties.Delegates
 
-@OptIn(UnstableReactNativeAPI::class)
 @SuppressLint("ViewConstructor")
 internal class StackHeaderConfig(
     val reactContext: ThemedReactContext,
 ) : ReactViewGroup(reactContext),
     StackHeaderConfigurationProviding,
     StackHeaderDelegate,
-    OnStackHeaderSubviewChangeListener,
-    UIManagerListener {
-    init {
-        UIManagerHelper
-            .getFabricUIManagerNotNull(reactContext)
-            .addUIManagerEventListener(this)
-    }
-
+    StackHeaderToolbarMenuDelegate,
+    OnStackHeaderSubviewChangeListener {
     // region Handling configuration changes
 
     private var configObserver: StackHeaderConfigurationObserver? = null
@@ -49,116 +37,128 @@ internal class StackHeaderConfig(
         configObserver = observer
     }
 
-    override var invalidationFlags = StackHeaderInvalidationFlags.ALL
-
-    override fun clearInvalidationFlags(flags: StackHeaderInvalidationFlags) {
-        invalidationFlags = invalidationFlags.clearing(flags)
-    }
-
     private fun invalidate(flags: StackHeaderInvalidationFlags) {
-        invalidationFlags = invalidationFlags or flags
-    }
-
-    private fun flushUpdates() {
-        if (configObserver == null || invalidationFlags.isEmpty) {
-            return
-        }
-
-        configObserver?.onConfigChanged(this)
+        configObserver?.onInvalidated(flags)
     }
 
     // endregion
 
     // region Properties
 
-    override var type: StackHeaderType by Delegates.observable(StackHeaderType.SMALL) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.STRUCTURE)
-    }
+    override var type: StackHeaderType by invalidatingProperty(StackHeaderType.SMALL, StackHeaderInvalidationFlags.STRUCTURE)
         internal set
 
-    override var title: String by Delegates.observable("") { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.TITLE)
-    }
+    override var title: String by invalidatingProperty("", StackHeaderInvalidationFlags.TITLE)
         internal set
 
-    override var hidden: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.STRUCTURE)
-    }
+    override var subtitle: String by invalidatingProperty("", StackHeaderInvalidationFlags.TITLE)
         internal set
 
-    override var transparent: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.STRUCTURE)
-    }
+    // Requires header rebuild due to bug in Material implementation
+    override var maxLines: Int by invalidatingProperty(1, StackHeaderInvalidationFlags.STRUCTURE)
         internal set
 
-    override var backButtonHidden: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.BACK_BUTTON)
-    }
+    override var hidden: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.STRUCTURE)
         internal set
 
-    override var backButtonTintColorNormal: Int? by Delegates.observable(null) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.BACK_BUTTON)
-    }
+    override var transparent: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.STRUCTURE)
         internal set
 
-    override var backButtonTintColorPressed: Int? by Delegates.observable(null) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.BACK_BUTTON)
-    }
+    override var backButtonHidden: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.BACK_BUTTON)
         internal set
 
-    override var backButtonTintColorFocused: Int? by Delegates.observable(null) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.BACK_BUTTON)
-    }
+    override var backButtonTintColorNormal: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACK_BUTTON)
         internal set
 
-    override var backButtonIcon: Drawable? by Delegates.observable(null) { _, old, new ->
-        if (old !== new) invalidate(StackHeaderInvalidationFlags.BACK_BUTTON)
-    }
+    override var backButtonTintColorPressed: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACK_BUTTON)
         internal set
 
-    override var scrollFlagScroll: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.SCROLL_FLAGS)
-    }
+    override var backButtonTintColorFocused: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACK_BUTTON)
         internal set
 
-    override var scrollFlagEnterAlways: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.SCROLL_FLAGS)
-    }
+    override var backButtonIcon: Drawable? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACK_BUTTON)
         internal set
 
-    override var scrollFlagEnterAlwaysCollapsed: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.SCROLL_FLAGS)
-    }
+    override var overflowIconTintColorNormal: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.OVERFLOW_ICON)
         internal set
 
-    override var scrollFlagExitUntilCollapsed: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.SCROLL_FLAGS)
-    }
+    override var overflowIconTintColorPressed: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.OVERFLOW_ICON)
         internal set
 
-    override var scrollFlagSnap: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.SCROLL_FLAGS)
-    }
+    override var overflowIconTintColorFocused: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.OVERFLOW_ICON)
         internal set
 
-    override var liftOnScroll: Boolean by Delegates.observable(true) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.LIFT_ON_SCROLL)
-    }
+    override var overflowIcon: Drawable? by invalidatingProperty(null, StackHeaderInvalidationFlags.OVERFLOW_ICON)
         internal set
 
-    override var toolbarMenu: StackHeaderToolbarMenuConfig
-        by Delegates.observable(StackHeaderToolbarMenuConfig(emptyList(), emptyList())) { _, old, new ->
-            if (old != new) invalidate(StackHeaderInvalidationFlags.TOOLBAR_MENU)
-        }
+    override var scrollFlagScroll: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.SCROLL_FLAGS)
         internal set
 
-    override var toolbarMenuGroupDividerEnabled: Boolean by Delegates.observable(false) { _, old, new ->
-        if (old != new) invalidate(StackHeaderInvalidationFlags.TOOLBAR_MENU)
-    }
+    override var scrollFlagEnterAlways: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.SCROLL_FLAGS)
+        internal set
+
+    override var scrollFlagEnterAlwaysCollapsed: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.SCROLL_FLAGS)
+        internal set
+
+    override var scrollFlagExitUntilCollapsed: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.SCROLL_FLAGS)
+        internal set
+
+    override var scrollFlagSnap: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.SCROLL_FLAGS)
+        internal set
+
+    override var liftOnScroll: Boolean by invalidatingProperty(true, StackHeaderInvalidationFlags.LIFT_ON_SCROLL)
+        internal set
+
+    override var backgroundColor: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACKGROUND_COLORS)
+        internal set
+
+    override var scrolledBackgroundColor: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACKGROUND_COLORS)
+        internal set
+
+    override var statusBarScrimColor: Int? by invalidatingProperty(null, StackHeaderInvalidationFlags.BACKGROUND_COLORS)
+        internal set
+
+    override var titleCentered: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.TITLE_POSITIONING)
+        internal set
+
+    override var subtitleCentered: Boolean by invalidatingProperty(false, StackHeaderInvalidationFlags.TITLE_POSITIONING)
+        internal set
+
+    override var expandedTitleHorizontalGravity: Int by invalidatingProperty(Gravity.START, StackHeaderInvalidationFlags.TITLE_POSITIONING)
         internal set
 
-    override val isRTL: Boolean
-        get() = layoutDirection == LayoutDirection.RTL
+    override var expandedTitleVerticalGravity: Int by invalidatingProperty(Gravity.BOTTOM, StackHeaderInvalidationFlags.TITLE_POSITIONING)
+        internal set
+
+    override var collapsedTitleHorizontalGravity: Int by invalidatingProperty(Gravity.START, StackHeaderInvalidationFlags.TITLE_POSITIONING)
+        internal set
+
+    override var collapsedTitleVerticalGravity: Int by invalidatingProperty(
+        Gravity.CENTER_VERTICAL,
+        StackHeaderInvalidationFlags.TITLE_POSITIONING,
+    )
+        internal set
+
+    override var collapsedTitleGravityMode: StackHeaderCollapsedTitleGravityMode
+        by invalidatingProperty(StackHeaderCollapsedTitleGravityMode.AVAILABLE_SPACE, StackHeaderInvalidationFlags.STRUCTURE)
+        internal set
+
+    override var contentInsetStart: Float?
+        by invalidatingProperty(null, StackHeaderInvalidationFlags.CONTENT_INSETS)
+        internal set
+
+    override var contentInsetEnd: Float?
+        by invalidatingProperty(null, StackHeaderInvalidationFlags.CONTENT_INSETS)
+        internal set
+
+    override val titleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+    override val subtitleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+    override val expandedTitleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+    override val collapsedTitleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+    override val expandedSubtitleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+    override val collapsedSubtitleAppearance = ReactTextAppearance(reactContext.assets, ::invalidateTextAppearance)
+
+    private fun invalidateTextAppearance() = invalidate(StackHeaderInvalidationFlags.TITLE_APPEARANCE)
 
     // endregion
 
@@ -172,9 +172,6 @@ internal class StackHeaderConfig(
      */
     internal fun onContentScrollViewChanged() {
         invalidate(StackHeaderInvalidationFlags.LIFT_ON_SCROLL)
-        if (!isInsideMountTransaction) {
-            flushUpdates()
-        }
     }
 
     // endregion
@@ -186,104 +183,93 @@ internal class StackHeaderConfig(
     // Resolution happens in resolveBackButtonIconIfNeeded(), called from onAfterUpdateTransaction.
     internal var backButtonDrawableIconResourceName: String? = null
     internal var backButtonImageIconUri: String? = null
-    private val backButtonIconResolver = PropIconResolver()
+    private val backButtonIconResolver = createPropIconResolver(reactContext)
 
     internal fun resolveBackButtonIconIfNeeded() {
         backButtonIconResolver.resolve(
-            reactContext,
             backButtonDrawableIconResourceName,
             backButtonImageIconUri,
         ) { result ->
             when (result) {
                 IconResolution.Unchanged -> Unit
-                is IconResolution.Resolved -> {
-                    backButtonIcon = result.drawable
-                    if (!isInsideMountTransaction) {
-                        flushUpdates()
-                    }
-                }
+                is IconResolution.Resolved -> backButtonIcon = result.drawable
             }
         }
     }
 
     // endregion
 
-    // region Toolbar menu item icon resolution
+    // region Overflow menu icon resolution
 
-    internal var toolbarMenuItemIconSourceMap = mapOf<String, StackHeaderToolbarMenuItemIconSource>()
+    // Staging fields for overflow menu icon resolution — mirrors the back button icon.
+    // Resolution happens in resolveOverflowIconIfNeeded(), called from onAfterUpdateTransaction.
+    internal var overflowIconDrawableIconResourceName: String? = null
+    internal var overflowIconImageIconUri: String? = null
+    private val overflowIconResolver = createPropIconResolver(reactContext)
 
-    private var toolbarMenuItemIconResolvers = mapOf<String, PropIconResolver>()
+    internal fun resolveOverflowIconIfNeeded() {
+        overflowIconResolver.resolve(
+            overflowIconDrawableIconResourceName,
+            overflowIconImageIconUri,
+        ) { result ->
+            when (result) {
+                IconResolution.Unchanged -> Unit
+                is IconResolution.Resolved -> overflowIcon = result.drawable
+            }
+        }
+    }
 
-    // Last resolved icon per menu item id, from the `toolbarMenu` prop path only
-    // (resolveToolbarMenuItemIconsIfNeeded). Command (`updateToolbarMenuElements`) icons are applied
-    // directly to the live toolbar and are intentionally NOT stored here.
-    private var toolbarMenuItemIcons = mapOf<String, Drawable?>()
+    // endregion
 
-    internal fun resolveToolbarMenuItemIconsIfNeeded() {
-        val nextResolvers = mutableMapOf<String, PropIconResolver>()
+    // region Toolbar menu
 
-        toolbarMenuItemIconSourceMap.forEach { (id, source) ->
-            val resolver = toolbarMenuItemIconResolvers[id] ?: PropIconResolver()
-            nextResolvers[id] = resolver
+    override val toolbarMenuController =
+        StackHeaderToolbarMenuController(createMenuIconResolver(reactContext))
+            .also { it.delegate = WeakReference(this) }
 
-            resolver.resolve(
-                context = reactContext,
-                drawableIconResourceName = source.drawableIconResourceName,
-                imageIconUri = source.imageIconUri,
-            ) { result ->
-                val icon =
-                    when (result) {
-                        IconResolution.Unchanged -> toolbarMenuItemIcons[id]
-                        is IconResolution.Resolved -> {
-                            toolbarMenuItemIcons = toolbarMenuItemIcons + (id to result.drawable)
-                            result.drawable
-                        }
-                    }
+    internal fun setToolbarMenuFromProps(menu: StackHeaderToolbarMenuConfig) {
+        if (toolbarMenuController.setMenu(menu)) {
+            invalidate(StackHeaderInvalidationFlags.TOOLBAR_MENU)
+        }
+    }
 
-                applyToolbarMenuItemIcon(id, icon)
-            }
+    internal fun setToolbarMenuGroupDividerEnabledFromProps(enabled: Boolean) {
+        if (toolbarMenuController.setGroupDividerEnabled(enabled)) {
+            invalidate(StackHeaderInvalidationFlags.TOOLBAR_MENU)
         }
+    }
+
+    internal fun dispatchMenuElementUpdates(updates: List<StackHeaderToolbarMenuElementRawUpdate>) {
+        toolbarMenuController.enqueueElementUpdates(updates)
+    }
 
-        toolbarMenuItemIconResolvers = nextResolvers
-        toolbarMenuItemIcons = toolbarMenuItemIcons.filterKeys { it in toolbarMenuItemIconSourceMap }
+    // StackHeaderToolbarMenuDelegate -> JS events
+
+    override fun onMenuItemClicked(id: String) {
+        eventEmitter.emitOnToolbarMenuItemPress(id)
     }
 
-    private fun applyToolbarMenuItemIcon(
-        id: String,
-        icon: Drawable?,
+    override fun onGroupSelectionChanged(
+        groupId: String,
+        selectedIds: List<String>,
     ) {
-        val currentMenu = toolbarMenu
-        val updated = currentMenu.updateItemIcon(id, icon)
-        if (updated !== currentMenu) {
-            toolbarMenu = updated
-            if (!isInsideMountTransaction) {
-                flushUpdates()
-            }
-        }
+        eventEmitter.emitOnToolbarMenuGroupSelectionChange(groupId, selectedIds)
     }
 
     // endregion
 
     // region Subviews
 
-    override var backgroundSubview: StackHeaderSubview? by Delegates.observable(null) { _, old, new ->
-        if (old !== new) invalidate(StackHeaderInvalidationFlags.SUBVIEWS)
-    }
+    override var backgroundSubview: StackHeaderSubview? by invalidatingProperty(null, StackHeaderInvalidationFlags.SUBVIEWS)
         private set
 
-    override var leadingSubview: StackHeaderSubview? by Delegates.observable(null) { _, old, new ->
-        if (old !== new) invalidate(StackHeaderInvalidationFlags.SUBVIEWS)
-    }
+    override var leadingSubview: StackHeaderSubview? by invalidatingProperty(null, StackHeaderInvalidationFlags.SUBVIEWS)
         private set
 
-    override var centerSubview: StackHeaderSubview? by Delegates.observable(null) { _, old, new ->
-        if (old !== new) invalidate(StackHeaderInvalidationFlags.SUBVIEWS)
-    }
+    override var centerSubview: StackHeaderSubview? by invalidatingProperty(null, StackHeaderInvalidationFlags.SUBVIEWS)
         private set
 
-    override var trailingSubview: StackHeaderSubview? by Delegates.observable(null) { _, old, new ->
-        if (old !== new) invalidate(StackHeaderInvalidationFlags.SUBVIEWS)
-    }
+    override var trailingSubview: StackHeaderSubview? by invalidatingProperty(null, StackHeaderInvalidationFlags.SUBVIEWS)
         private set
 
     override fun onStackHeaderSubviewChanged() {
@@ -349,17 +335,6 @@ internal class StackHeaderConfig(
         )
     }
 
-    override fun onMenuItemClicked(id: String) {
-        eventEmitter.emitOnToolbarMenuItemPress(id)
-    }
-
-    override fun onGroupSelectionChanged(
-        groupId: String,
-        selectedIds: List<String>,
-    ) {
-        eventEmitter.emitOnToolbarMenuGroupSelectionChange(groupId, selectedIds)
-    }
-
     override fun onSubviewOriginChanged(
         type: StackHeaderSubviewType,
         x: Int,
@@ -388,83 +363,42 @@ internal class StackHeaderConfig(
 
     // endregion
 
-    // region Imperative menu item commands
-
-    /**
-     * Resolves a single command's icon. Unlike the `toolbarMenu` prop path,
-     * this does NOT go through the stateful per-id [PropIconResolver] (whose
-     * drop-stale async guard could leave the queue waiting forever - the queue
-     * requires that [StackHeaderToolbarMenuIconResolver.resolve] always calls
-     * [onResolved] even if the image loading results in failure; see
-     * [StackHeaderToolbarMenuIconResolver] and
-     * [StackHeaderToolbarMenuUpdateQueue] for more details) and does NOT touch
-     * the prop icon cache: it resolves the source with an always-completing
-     * [resolveImage] and forwards the result to the queue, which applies it to
-     * the live toolbar. Ordering across commands is guaranteed by the queue, so
-     * no drop-stale is needed here; a failed or empty source resolves to `null`
-     * -> Reset (the icon is cleared) rather than stalling the queue.
-     */
-    private val commandIconResolver =
-        StackHeaderToolbarMenuIconResolver { iconSource, onResolved ->
-            resolveImage(
-                reactContext,
-                iconSource.drawableIconResourceName,
-                iconSource.imageIconUri,
-            ) { drawable ->
-                onResolved(StackHeaderToolbarFieldUpdate.from(drawable))
-            }
-        }
-
-    // Serializes `updateToolbarMenuElements` batches and waits for every icon in a batch to
-    // resolve before applying it, so each batch is applied atomically and in order.
-    private val menuUpdateQueue =
-        StackHeaderToolbarMenuUpdateQueue(
-            iconResolver = commandIconResolver,
-            delegate = { updates -> configObserver?.onMenuElementsUpdated(updates) },
-        )
+    // region Teardown
 
-    /**
-     * Enqueues a batch of toolbar menu element view commands. The batch is processed only
-     * after any earlier batch has been fully applied, and is applied atomically once all of
-     * its icons (if any) have resolved — see [StackHeaderToolbarMenuUpdateQueue].
-     */
-    internal fun dispatchMenuElementUpdates(updates: List<StackHeaderToolbarMenuElementRawUpdate>) {
-        menuUpdateQueue.enqueue(updates)
+    internal fun tearDown() {
+        toolbarMenuController.tearDown()
+        configObserver = null
     }
 
     // endregion
 
-    // region UIManagerListener
-
-    private var isInsideMountTransaction = false
-
-    override fun willMountItems(uiManager: UIManager) {
-        isInsideMountTransaction = true
-    }
+    // region Helpers
 
-    override fun didMountItems(uiManager: UIManager) {
-        isInsideMountTransaction = false
-        flushUpdates()
+    private fun <T> invalidatingProperty(
+        initialValue: T,
+        flag: StackHeaderInvalidationFlags,
+    ) = Delegates.observable(initialValue) { _, old, new ->
+        if (old != new) invalidate(flag)
     }
 
-    override fun willDispatchViewUpdates(uiManager: UIManager) = Unit
-
-    override fun didDispatchMountItems(uiManager: UIManager) = Unit
-
-    override fun didScheduleMountItems(uiManager: UIManager) = Unit
-
     // endregion
 
-    // region Teardown
+    // Built outside the instance scope on purpose: a lambda capturing this view
+    // would be retained by every icon load still in flight.
+    private companion object {
+        fun createPropIconResolver(context: ThemedReactContext) =
+            PropIconResolver { name, uri, onComplete ->
+                resolveImage(context, name, uri, onComplete)
+            }
 
-    internal fun tearDown() {
-        UIManagerHelper
-            .getFabricUIManagerNotNull(reactContext)
-            .removeUIManagerEventListener(this)
-        menuUpdateQueue.tearDown()
-        invalidationFlags = StackHeaderInvalidationFlags.NONE
-        configObserver = null
+        fun createMenuIconResolver(context: ThemedReactContext) =
+            StackHeaderToolbarMenuIconResolver { iconSource, onResolved ->
+                resolveImage(
+                    context,
+                    iconSource.drawableIconResourceName,
+                    iconSource.imageIconUri,
+                    onResolved,
+                )
+            }
     }
-
-    // endregion
 }