@apexnative/navigation 1.0.0-alpha.3 → 1.0.0-alpha.4

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/StackViews.kt

@@ -288,8 +288,8 @@ internal class StackViews(private val stack: StackController) : StackDisplay {
         screen.whenContentMounted(
             waiting = waiting,
             mounted = {
-                // The frame of the mount: the screen shows transparent and lays out; its transition starts on the
-                // pre-draw of that frame.
+                // The frame of the mount: the screen shows transparent and lays out. The pre-draw of that frame hands
+                // the start to the queue, whose transition begins behind the calls JavaScript made before.
                 screen.peekView()?.let {
                     it.alpha = 0f
                     it.visibility = View.VISIBLE

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/fab/FabPresenter.kt

@@ -172,19 +172,20 @@ internal class FabPresenter(
         alignStart = options.alignHorizontally.get("right") == "left"
         val source = source
         fab?.let { fab ->
-            applyButton(fab, options)
+            applyButton(fab, options, mayWait = fab.drawable != null || options.visible.isFalse)
             TestIds.apply(fab, options.testID.takeIf { it.hasValue() }?.get())
             val id = shownId.orEmpty()
             fab.setOnClickListener { press(source, id) }
         }
         menu?.let { menu ->
-            applyButton(menu.main, options)
+            applyButton(menu.main, options, mayWait = menu.main.drawable != null || options.visible.isFalse)
             TestIds.apply(menu.main, options.testID.takeIf { it.hasValue() }?.get())
             menu.scrimColor = options.scrimColor.get(activity, null)
             menu.setActions(options.actions.orEmpty().map { action ->
                 val actionId = action.id.get("")
                 Fab(activity, actionId).also { button ->
-                    applyButton(button, action)
+                    // The actions show only while the menu is open.
+                    applyButton(button, action, mayWait = !menu.isOpen)
                     TestIds.apply(button, action.testID.takeIf { it.hasValue() }?.get())
                     button.setOnClickListener {
                         press(source, actionId)
@@ -205,9 +206,10 @@ internal class FabPresenter(
         place()
     }
 
-    private fun applyButton(button: Fab, options: FabOptions) {
+    // [mayWait]: the button can take its icon when it is ready (it shows one, or it stays hidden), see [Fab.applyIcon].
+    private fun applyButton(button: Fab, options: FabOptions, mayWait: Boolean) {
         val icon = options.icon.takeIf { it.hasValue() }?.get()?.ifEmpty { null }
-        if (icon != null) button.applyIcon(icon, options.iconColor)
+        if (icon != null) button.applyIcon(icon, options.iconColor, mayWait)
         applyColors(button, options)
         button.setMini(options.size.get("regular") == "mini")
     }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/search/StackSearchPresenter.kt

@@ -14,7 +14,6 @@ import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
 import com.facebook.react.ReactApplication
 import dev.apexnative.navigation.options.SearchBarOptions
-import dev.apexnative.navigation.options.params.Text
 import dev.apexnative.navigation.options.params.ThemeColour
 import dev.apexnative.navigation.react.events.EventEmitter
 import dev.apexnative.navigation.utils.dp
@@ -148,10 +147,11 @@ class StackSearchPresenter(
 
     private fun searchOf(screen: ViewController<*>): ScreenSearch =
         searches.getOrPut(screen.view) {
-            // The search of a pair of screens is its primary's: its events name that screen, which keeps the scope.
+            // The search of a pair of screens is its primary's: its events name that screen, which keeps the scope in
+            // its user layer, where a merge that sends the same options again doesn't take it away.
             val owner = (screen as? OptionsScreen)?.optionsScreen ?: screen
             ScreenSearch(this, owner.id, styleContext(), loadIcon) { scope ->
-                owner.changeOptions { it.topBar.searchBar.selectedScope = Text(scope) }
+                owner.changeChoices { it.pickScope(scope) }
             }
         }
 

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/topbar/MenuChecks.kt

@@ -1,16 +1,14 @@
 package dev.apexnative.navigation.viewcontrollers.stack.topbar
 
-import dev.apexnative.navigation.options.ButtonMenuOptions
-import dev.apexnative.navigation.options.ButtonOptions
 import dev.apexnative.navigation.options.Options
-import dev.apexnative.navigation.options.copyMenu
+import dev.apexnative.navigation.options.UserChoices
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 
 /**
- * The check of a single-selection menu the user picked: written through [ViewController.changeOptions] into the
- * screen's own menu, never into a menu other screens share (the stack's, the defaults'). A menu that came from
- * elsewhere is copied into the screen's own options first — for a button, its whole side, as lists of buttons replace
- * whole. The check stays with the screen until new options give the menu. Main thread only.
+ * The check of a single-selection menu the user picked: written into the screen's user layer
+ * ([ViewController.changeChoices]), never into its own options nor into a menu other screens share (the stack's, the
+ * defaults'). It goes over the menu as the screen's options resolve, by the button's id and the item's id, and stays
+ * until the app changes that menu's checks or takes the item away. Main thread only.
  */
 internal object MenuChecks {
     /**
@@ -19,54 +17,13 @@ internal object MenuChecks {
      */
     fun write(screen: ViewController<*>, resolved: Options, buttonId: String?, itemId: String) {
         val topBar = resolved.topBar
-        if (buttonId == null) {
-            val menu = topBar.overflowMenu ?: return
-            if (!checks(menu, itemId)) return
-            screen.changeOptions { own ->
-                val copy = (own.topBar.overflowMenu ?: menu).copyMenu()
-                check(copy, itemId)
-                own.topBar.overflowMenu = copy
-            }
-            return
-        }
-        val left = topBar.buttons.left?.any { it.id.get(null) == buttonId } == true
-        val list = (if (left) topBar.buttons.left else topBar.buttons.right) ?: return
-        val menu = list.firstOrNull { it.id.get(null) == buttonId }?.menu ?: return
-        if (!checks(menu, itemId)) return
-        screen.changeOptions { own ->
-            val ownList = (if (left) own.topBar.buttons.left else own.topBar.buttons.right)
-                ?: list.map(ButtonOptions::copyWithMenu)
-            val button = ownList.firstOrNull { it.id.get(null) == buttonId } ?: return@changeOptions
-            val copy = (button.menu ?: menu).copyMenu()
-            check(copy, itemId)
-            button.menu = copy
-            if (left) own.topBar.buttons.left = ownList else own.topBar.buttons.right = ownList
-        }
-    }
-
-    /** Whether picking [itemId] moves a check: its level has `singleSelection`. */
-    fun checks(menu: ButtonMenuOptions, itemId: String): Boolean = levelOf(menu.items, menu.singleSelection, itemId) == true
-
-    /** Moves the check of [itemId]'s level to it, in [menu] itself. */
-    fun check(menu: ButtonMenuOptions, itemId: String) {
-        mark(menu.items, menu.singleSelection, itemId)
-    }
-
-    // Whether the level holding [itemId] has single selection; null when [itemId] isn't in [elements].
-    private fun levelOf(elements: List<ButtonMenuOptions.Element>, single: Boolean, itemId: String): Boolean? {
-        if (elements.any { it is ButtonMenuOptions.Item && it.id == itemId }) return single
-        for (element in elements) {
-            if (element !is ButtonMenuOptions.Submenu) continue
-            levelOf(element.items, element.singleSelection, itemId)?.let { return it }
-        }
-        return null
-    }
-
-    private fun mark(elements: List<ButtonMenuOptions.Element>, single: Boolean, itemId: String): Boolean {
-        if (elements.any { it is ButtonMenuOptions.Item && it.id == itemId }) {
-            if (single) elements.forEach { if (it is ButtonMenuOptions.Item) it.checked = it.id == itemId }
-            return true
-        }
-        return elements.any { it is ButtonMenuOptions.Submenu && mark(it.items, it.singleSelection, itemId) }
+        val menu = if (buttonId == null) {
+            topBar.overflowMenu
+        } else {
+            (topBar.buttons.left.orEmpty() + topBar.buttons.right.orEmpty()).firstOrNull { it.id.get(null) == buttonId }
+                ?.menu
+        } ?: return
+        if (!UserChoices.checks(menu, itemId)) return
+        screen.changeChoices { it.check(buttonId, menu, itemId) }
     }
 }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/topbar/TopBarPresenter.kt

@@ -1008,8 +1008,16 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         button.priority.get(null),
     ).joinToString("|")
 
-    private fun menuKey(menu: ButtonMenuOptions): String =
-        menu.items.joinToString("|") { "${it.title}:${it.icon}:${it.testID}" } + menu.testID
+    // What the overflow menu shows, its submenus and checks with it: a check the app moves, or one of the user layer
+    // that leaves, fills the menu again.
+    private fun menuKey(menu: ButtonMenuOptions): String = elementsKey(menu.items) + menu.testID
+
+    private fun elementsKey(elements: List<ButtonMenuOptions.Element>): String = elements.joinToString("|") {
+        "${it.title}:${it.icon}:${it.testID}" + when (it) {
+            is ButtonMenuOptions.Item -> ":${it.checked}:${it.disabled}"
+            is ButtonMenuOptions.Submenu -> "[${elementsKey(it.items)}]"
+        }
+    }
 
     private fun fontKey(font: FontOptions): String =
         listOf(font.fontFamily, font.fontStyle, font.fontWeight).joinToString { it.get(null).toString() }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/viewcontroller/ViewController.kt

@@ -6,6 +6,7 @@ import android.view.ViewGroup
 import dev.apexnative.navigation.options.DefaultOptions
 import dev.apexnative.navigation.options.Options
 import dev.apexnative.navigation.options.OptionsCache
+import dev.apexnative.navigation.options.UserChoices
 import dev.apexnative.navigation.options.params.Bool
 import dev.apexnative.navigation.options.params.NullBool
 import dev.apexnative.navigation.react.CommandListener
@@ -30,11 +31,11 @@ abstract class ViewController<V : ViewGroup>(
     var initialOptions: Options,
 ) {
     /**
-     * The node's own options: those it was made with, with every `mergeOptions` and every user's choice over them.
-     * Writing them is one of the two places the options change ([OptionsCache]): the setter takes away the one-shot
-     * options, keeps the object (a stripped copy when it has a one-shot option: the caller's object never changes), and
-     * makes every resolved result stale. Don't change the object in place: [changeOptions] or [mergeOptions] write a
-     * changed copy.
+     * The node's own options: those it was made with, with every `mergeOptions` over them; what the user chose in the
+     * native UI is not here but in [choices]. Writing them is one of the places the options change ([OptionsCache]):
+     * the setter takes away the one-shot options, keeps the object (a stripped copy when it has a one-shot option: the
+     * caller's object never changes), and makes every resolved result stale. Don't change the object in place:
+     * [changeOptions] or [mergeOptions] write a changed copy.
      */
     var options: Options = initialOptions.copy().also(Options::clearOneShotOptions)
         set(value) {
@@ -42,6 +43,10 @@ abstract class ViewController<V : ViewGroup>(
             OptionsCache.optionsChanged()
         }
 
+    // The user layer: what the user chose in the native UI (a menu's check, a search scope), over the node's own
+    // options as they resolve ([changeChoices]).
+    private val choices = UserChoices()
+
     /**
      * The JavaScript the node was made for (`ReloadCoordinator`): the events of the node and its screens reach only
      * that one.
@@ -156,9 +161,9 @@ abstract class ViewController<V : ViewGroup>(
     }
 
     /**
-     * The node's options over those of the layouts around it, without the default options: the parents' resolution,
-     * then the node's own. A new object at each call, which the caller may change. For a layout of nodes this is not
-     * what it shows with: that is [resolveShownOptions].
+     * The node's options over those of the layouts around it, without the default options and without the user layer
+     * ([changeChoices]): the parents' resolution, then the node's own. A new object at each call, which the caller may
+     * change. For a layout of nodes this is not what it shows with: that is [resolveShownOptions].
      */
     open fun resolveCurrentOptions(): Options {
         val resolved = parent?.resolveChildOptions(this) ?: Options()
@@ -166,21 +171,21 @@ abstract class ViewController<V : ViewGroup>(
     }
 
     /**
-     * The node's options over those of the layouts around it and [defaultOptions]: what it shows with. With the app's
-     * default options ([DefaultOptions.current]) the result is kept and given again while no options changed
-     * ([OptionsCache]) and the layouts around the node and its current children are the same: it is read-only, whoever
-     * changes it copies it first. Main thread only.
+     * The node's options over those of the layouts around it and [defaultOptions], with the user layer over them
+     * ([changeChoices]): what it shows with. With the app's default options ([DefaultOptions.current]) the result is
+     * kept and given again while no options changed ([OptionsCache]) and the layouts around the node and its current
+     * children are the same: it is read-only, whoever changes it copies it first. Main thread only.
      *
      * For a layout of nodes (a stack, tabs, a side menu) it is the layout's own options over those around it, without
      * any child's: not what the layout shows with, which [resolveShownOptions] gives.
      */
     open fun resolveCurrentOptions(defaultOptions: Options): Options {
-        if (defaultOptions !== DefaultOptions.current) return resolveCurrentOptions().withDefaultOptions(defaultOptions)
+        if (defaultOptions !== DefaultOptions.current) return withChoices(defaultOptions)
         val generation = OptionsCache.generation
         val along = resolvedAlong()
         val kept = resolved
         if (kept != null && resolvedGeneration == generation && sameNodes(along, resolvedAlong)) return kept
-        val result = resolveCurrentOptions().withDefaultOptions(defaultOptions)
+        val result = withChoices(defaultOptions)
         resolved = result
         resolvedGeneration = generation
         resolvedAlong = along.map(::WeakReference)
@@ -196,6 +201,10 @@ abstract class ViewController<V : ViewGroup>(
      */
     open fun resolveShownOptions(defaultOptions: Options): Options = resolveCurrentOptions(defaultOptions)
 
+    // The resolution in its order: the defaults, the parents, the node's own options, then the user layer over them.
+    private fun withChoices(defaultOptions: Options): Options =
+        choices.applyTo(resolveCurrentOptions().withDefaultOptions(defaultOptions))
+
     // The layouts around this node, nearest first, then its current children down the visible chain.
     private fun resolvedAlong(): List<ViewController<*>> {
         val nodes = ArrayList<ViewController<*>>()
@@ -216,9 +225,9 @@ abstract class ViewController<V : ViewGroup>(
         nodes.size == kept.size && nodes.indices.all { nodes[it] === kept[it].get() }
 
     /**
-     * Changes the node's own options: [change] gets a copy, which is stored ([options]). A presenter or a module that
-     * writes a user's choice into the options (a menu's checkmark, a search scope, tokens, a toggled button) does it
-     * this way; a button menu keeps its own shared `checked` (`ButtonMenuOptions`).
+     * Changes the node's own options: [change] gets a copy, which is stored ([options]). It is for the library's own
+     * bookkeeping of a merge (a side color written into the node's buttons, the back button's visibility); what the
+     * user chose goes through [changeChoices].
      */
     fun changeOptions(change: (Options) -> Unit) {
         val copy = options.copy()
@@ -226,14 +235,40 @@ abstract class ViewController<V : ViewGroup>(
         options = copy
     }
 
+    /**
+     * Changes the node's user layer: what the user chose in the native UI (a single-selection menu's check, a search
+     * scope). It goes over the node's own options as they resolve, by the ids of the buttons, items and scopes, and
+     * stays through an unrelated `mergeOptions`, the same values sent again and `setDefaultOptions`; a merge that
+     * changes the chosen field takes it away ([mergeOwnOptions]). Every resolved result is stale after it
+     * ([OptionsCache]).
+     */
+    internal fun changeChoices(change: (UserChoices) -> Unit) {
+        change(choices)
+        OptionsCache.optionsChanged()
+    }
+
+    /**
+     * [delta] of a `mergeOptions` goes over the node's own options ([options]); a choice of the user layer whose field
+     * the merge changes, or whose button, item or scope it took away, leaves, so the app's value shows
+     * (`UserChoices.yieldTo`). Every `mergeOptions` into a node writes its own options this way.
+     */
+    protected fun mergeOwnOptions(delta: Options) {
+        val own = options
+        val before = if (choices.isEmpty) null else resolveCurrentOptions().withDefaultOptions(DefaultOptions.current)
+        options = own.copy().mergeWith(delta)
+        before ?: return
+        val after = resolveCurrentOptions().withDefaultOptions(DefaultOptions.current)
+        if (choices.yieldTo(delta, own, before, after)) OptionsCache.optionsChanged()
+    }
+
     /**
      * `mergeOptions` with the node's id (`mergeOptions`): [options] go over its own and stay there (one-shot options
-     * not kept); what shows applies them ([applyMergedOptions], when the view shows; otherwise as it appears); the
-     * layouts around it apply their part (`ParentController.mergeChildOptions`, each passes it on). [options] still
-     * carry the one-shot options to them. Containers that hand the merge to a child override it.
+     * not kept, [mergeOwnOptions]); what shows applies them ([applyMergedOptions], when the view shows; otherwise as it
+     * appears); the layouts around it apply their part (`ParentController.mergeChildOptions`, each passes it on).
+     * [options] still carry the one-shot options to them. Containers that hand the merge to a child override it.
      */
     open fun mergeOptions(options: Options) {
-        this.options = this.options.copy().mergeWith(options)
+        mergeOwnOptions(options)
         if (isViewShown) applyMergedOptions(options)
         performOnParentController { it.mergeChildOptions(options, this) }
     }

package/android/src/main/java/dev/apexnative/navigation/views/bottomtabs/BottomTabs.kt

@@ -228,13 +228,15 @@ class BottomTabs(context: Context) : BottomNavigationView(MaterialTheme.context(
         applyLongPressesAgain()
     }
 
-    fun setIcon(index: Int, icon: Drawable) {
+    /** Null: the item has no icon. */
+    fun setIcon(index: Int, icon: Drawable?) {
         val item = items.getOrNull(index) ?: return
         if (item.icon == icon) return
         updateIcon(index, item.copy(icon = icon))
     }
 
-    fun setSelectedIcon(index: Int, icon: Drawable) {
+    /** Null: the item shows its icon when selected too. */
+    fun setSelectedIcon(index: Int, icon: Drawable?) {
         val item = items.getOrNull(index) ?: return
         if (item.selectedIcon == icon) return
         updateIcon(index, item.copy(selectedIcon = icon))

package/android/src/main/java/dev/apexnative/navigation/views/stack/fab/Fab.kt

@@ -4,12 +4,11 @@ import android.content.Context
 import android.content.res.ColorStateList
 import android.content.res.Configuration
 import android.graphics.Color
-import android.graphics.drawable.Drawable
 import com.google.android.material.floatingactionbutton.FloatingActionButton
 import dev.apexnative.navigation.options.params.ThemeColour
-import dev.apexnative.navigation.utils.ImageLoader
-import dev.apexnative.navigation.utils.ImageLoadingListenerAdapter
+import dev.apexnative.navigation.utils.ImageRequests
 import dev.apexnative.navigation.utils.MaterialTheme
+import dev.apexnative.navigation.utils.OptionImages
 import dev.apexnative.navigation.utils.UiUtils
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListener
 import androidx.appcompat.R as AppCompatR
@@ -29,6 +28,7 @@ class Fab(context: Context, val fabId: String) : FloatingActionButton(MaterialTh
     // The icon's color of the options: a container color merged later kept the theme's icon color instead.
     private var iconColor: Int? = null
     private var optionRippleColor: Int? = null
+    private val icons = ImageRequests<Unit>(OptionImages.source(this.context))
 
     init {
         // Material's theme overlay of the button is a copy of the theme, made once: it follows a light/dark switch too.
@@ -36,14 +36,18 @@ class Fab(context: Context, val fabId: String) : FloatingActionButton(MaterialTh
         MaterialTheme.followOverlay(this.context)
     }
 
-    fun applyIcon(icon: String, color: ThemeColour) {
+    /**
+     * The icon of the options, with its color. [mayWait]: the button can show it when it is ready (it shows an icon
+     * already, it is hidden with `visible: false`, or it is an action of a closed menu), so an icon the cache doesn't
+     * have loads off the main thread; the last icon asked for wins. Otherwise it loads at once. An icon that doesn't
+     * load leaves the button without an icon.
+     */
+    fun applyIcon(icon: String, color: ThemeColour, mayWait: Boolean) {
         if (color.hasValue()) iconColor = color.get()
-        ImageLoader().loadIcon(context, icon, object : ImageLoadingListenerAdapter() {
-            override fun onComplete(drawable: Drawable) {
-                setImageDrawable(drawable)
-                iconColor?.let { imageTintList = ColorStateList.valueOf(it) }
-            }
-        })
+        icons.request(Unit, icon, mayWait) { drawable ->
+            setImageDrawable(drawable)
+            iconColor?.let { imageTintList = ColorStateList.valueOf(it) }
+        }
     }
 
     /** iconColor alone, without a new icon: it did nothing in a merge. */

package/cli/doctor/checks/app.js

@@ -11,8 +11,10 @@ const {
   reactNativeVersion,
   usesExpo,
 } = require('../../app');
+const { mainActivity } = require('../../links/native');
 const { findProject } = require('../../project');
 const { codeOf } = require('../../setup/source');
+const { loadsReactNativeItself } = require('../../setup/steps/mainApplication');
 const { planCodegen } = require('../../codegen');
 const { readConfig } = require('../../config');
 const { planProject } = require('../../setup');
@@ -27,6 +29,16 @@ const { splashChecks } = require('./splash');
 const SETUP = { label: 'npx apex-navigation setup', run: /** @type {const} */ ('setup') };
 const GENERATED = ['ApexNavigation.generated.swift', 'ApexNavigationGenerated.kt'];
 const CODEGEN = { label: 'npx apex-navigation codegen', run: /** @type {const} */ ('codegen') };
+// The changes the main activity must handle itself; the template's value has them all.
+const CONFIG_CHANGES = [
+  'orientation',
+  'screenSize',
+  'smallestScreenSize',
+  'screenLayout',
+  'uiMode',
+];
+const TEMPLATE_CONFIG_CHANGES =
+  'keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode';
 
 /**
  * React Native, the navigation, and the files setup sets up.
@@ -122,28 +134,64 @@ function appChecks({ root, run }) {
     });
   }
 
+  const configChanges = configChangesCheck(project.manifest);
+  if (configChanges) checks.push(configChanges);
+
   checks.push(...splashChecks(root, project), ...iconChecks(root, project));
 
-  // A second load of React Native crashes the app on start: the most common slip of a setup by hand.
+  // NavigationApplication leaves the load of React Native to the template's call: without it the app closes on start,
+  // and so it does with a second load of the app's own next to it.
   const application = project.mainApplication && fs.readFileSync(project.mainApplication, 'utf8');
-  if (
-    application &&
-    /:\s*NavigationApplication\(\)/.test(application) &&
-    /\bloadReactNative\s*\(/.test(codeOf(application))
-  ) {
-    checks.push({
-      group: 'app',
-      title: 'React Native loads twice',
-      status: 'error',
-      detail: 'MainApplication.kt calls loadReactNative(this), NavigationApplication loads it too',
-      fix: { label: 'Remove loadReactNative(this) from MainApplication.kt' },
-    });
+  if (application && /:\s*NavigationApplication\(/.test(application)) {
+    const loads = /\bloadReactNative\s*\(/.test(codeOf(application));
+    if (!loads) {
+      checks.push({
+        group: 'app',
+        title: 'React Native not loaded',
+        status: 'error',
+        detail: "MainApplication.kt doesn't call loadReactNative(this) in onCreate",
+        fix: SETUP,
+      });
+    } else if (loadsReactNativeItself(application)) {
+      checks.push({
+        group: 'app',
+        title: 'React Native loads twice',
+        status: 'error',
+        detail:
+          'MainApplication.kt loads React Native itself (SoLoader.init or the New Architecture entry point) next to loadReactNative(this)',
+        fix: SETUP,
+      });
+    }
   }
   const generated = generatedCheck(root, run);
   if (generated) checks.push(generated);
   return checks;
 }
 
+/**
+ * Whether the main activity handles the changes of its window itself, as the React Native template has it. Without
+ * one of them Android recreates the activity on a rotation, a resize, a fold or a light/dark switch: every screen goes
+ * with it and the navigation starts again from its root. Nothing without a manifest or a main activity.
+ * @param {string | undefined} manifest
+ * @returns {Check | undefined}
+ */
+function configChangesCheck(manifest) {
+  if (!manifest || !fs.existsSync(manifest)) return undefined;
+  const activity = mainActivity(fs.readFileSync(manifest, 'utf8'));
+  if (!activity) return undefined;
+  const value = /android:configChanges\s*=\s*(?:"([^"]*)"|'([^']*)')/.exec(activity.text);
+  const declared = (value?.[1] ?? value?.[2] ?? '').split('|').map((change) => change.trim());
+  const missing = CONFIG_CHANGES.filter((change) => !declared.includes(change));
+  if (missing.length === 0) return undefined;
+  return {
+    group: 'app',
+    title: 'Config changes',
+    status: 'warn',
+    detail: `the main activity doesn't handle ${missing.join(', ')}: Android recreates it, and every screen with it`,
+    fix: { label: `Set android:configChanges="${TEMPLATE_CONFIG_CHANGES}" on the main activity` },
+  };
+}
+
 /**
  * One line for a few files: set up, or which need setup or a change by hand.
  * @param {string} title

package/cli/migrate/native.js

@@ -3,6 +3,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { withReactNativeLoaded } = require('../setup/steps/mainApplication');
 
 /** @typedef {import('../changes').FileChange} FileChange */
 /** @typedef {import('./report').ReportItem} ReportItem */
@@ -158,6 +159,23 @@ function planNative(project) {
     const before = fs.readFileSync(file, 'utf8');
     let next = before;
     for (const [pattern, replacement] of rewrite.rules) next = next.replace(pattern, replacement);
+    // react-native-navigation loaded React Native itself; the navigation's application leaves it to the template's
+    // loadReactNative(this), which such an app doesn't have.
+    if (file === project.mainApplication && /:\s*NavigationApplication\(/.test(next)) {
+      const loaded = withReactNativeLoaded(next);
+      if (loaded !== undefined) next = loaded;
+      else {
+        report.push({
+          file: path.relative(root, file),
+          line: 1,
+          step: 'native',
+          before: 'onCreate',
+          after: 'super.onCreate() then loadReactNative(this), and no load of its own',
+          what: 'React Native loads through loadReactNative(this) in onCreate: add it by hand',
+          docs: `${DOCS}#native`,
+        });
+      }
+    }
     if (next !== before) {
       changes.push({
         name: path.basename(file),

package/cli/setup/source.js

@@ -35,7 +35,8 @@ function removeUnusedImports(text, names) {
   for (const name of names) {
     const line = new RegExp(`^import\\s+${escape(name)}[ \\t]*\\r?\\n`, 'm');
     const simple = name.slice(name.lastIndexOf('.') + 1);
-    const code = result.replace(/^import\s.*$/gm, '');
+    // A name in a comment is no use of the import.
+    const code = codeOf(result).replace(/^import\s.*$/gm, '');
     if (line.test(result) && !new RegExp(`\\b${escape(simple)}\\b`).test(code))
       result = result.replace(line, '');
   }