tunjid · tunjid · Jun 28, 2025 · May 21, 2025 · May 21, 2025 · May 24, 2025
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -1,28 +1,29 @@
 [versions]
 androidGradlePlugin = "8.9.2"
 androidxActivity = "1.9.2"
-activity-compose = "1.11.0-rc01"
+activity-compose = "1.12.0-alpha02"
 androidxAppCompat = "1.7.0"
 androidxBenchmark = "1.3.4"
 androidxCore = "1.16.0"
 androidxCollection = "1.5.0"
 androidxCompose = "1.7.0"
+androidxNavigationEvent = "1.0.0-alpha02"
 androidxPaging = "3.3.2"
 androidxSavedState = "1.3.0-alpha07"
 androidxTestCore = "1.6.1"
 androidxTestExt = "1.2.1"
 androidxTestRunner = "1.6.2"
 androidxTestRules = "1.6.1"
 dokka = "1.8.20"
-jetbrainsCompose = "1.8.0"
-jetbrainsLifecycle = "2.9.0-beta01"
+jetbrainsCompose = "1.8.2"
+jetbrainsLifecycle = "2.9.1"
 jetbrainsMaterial3Adaptive = "1.0.1"
 junit4 = "4.13.2"
 kotlin = "2.1.20"
 kotlinxCoroutines = "1.10.2"
 kotlinxDatetime = "0.6.2"
 tunjidStateHolder = "1.1.0"
-tunjidComposables = "0.0.16"
+tunjidComposables = "0.0.19"
 junit = "4.13.2"
 runner = "1.0.2"
 espressoCore = "3.0.2"
@@ -37,8 +38,10 @@ android-gradlePlugin = { group = "com.android.tools.build", name = "gradle", ver
 compose-compiler-plugin = { group = "org.jetbrains.kotlin", name = "compose-compiler-gradle-plugin", version.ref = "kotlin" }
 androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "androidxAppCompat" }
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "androidxCore" }
+androidx-activity = { group = "androidx.activity", name = "activity", version.ref = "activity-compose" }
 androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activity-compose" }
 androidx-collection = { group = "androidx.collection", name = "collection", version.ref = "androidxCollection" }
+androidx-navigation-event = { group = "androidx.navigationevent", name = "navigationevent", version.ref = "androidxNavigationEvent" }
 
 jetbrains-compose-animation = { group = "org.jetbrains.compose.animation", name = "animation", version.ref = "jetbrainsCompose" }
 jetbrains-compose-foundation = { group = "org.jetbrains.compose.foundation", name = "foundation", version.ref = "jetbrainsCompose" }

diff --git a/...compose-threepane/src/commonMain/kotlin/com/tunjid/treenav/compose/threepane/ThreePane.kt b/...compose-threepane/src/commonMain/kotlin/com/tunjid/treenav/compose/threepane/ThreePane.kt
@@ -16,16 +16,16 @@
 
 package com.tunjid.treenav.compose.threepane
 
+import androidx.compose.animation.EnterExitState
 import androidx.compose.animation.EnterTransition
 import androidx.compose.animation.ExitTransition
 import androidx.compose.animation.core.FiniteAnimationSpec
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
-import androidx.compose.foundation.layout.Box
 import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
 import com.tunjid.treenav.Node
+import com.tunjid.treenav.compose.Adaptation
 import com.tunjid.treenav.compose.Adaptation.Swap
 import com.tunjid.treenav.compose.MultiPaneDisplay
 import com.tunjid.treenav.compose.PaneEntry
@@ -42,13 +42,6 @@ enum class ThreePane {
      */
     Primary,
 
-    /**
-     * A optional pane for placing content from the [Primary] pane, if a preview of the previous
-     * navigation destinations is occurring. The primary content is rendered here, while
-     * the previous primary content is rendered in the [Primary] pane.
-     */
-    TransientPrimary,
-
     /**
      * An optional pane for displaying a navigation destination alongside the [Primary] pane.
      * This is useful for list-detail, or supporting panels flows.
@@ -66,77 +59,33 @@ enum class ThreePane {
      * An optional pane for showing dialogs, or context sheets over existing panes.
      */
     Overlay;
-
-    companion object {
-        val PrimaryToSecondary = Swap(
-            from = Primary,
-            to = Secondary
-        )
-
-        val SecondaryToPrimary = Swap(
-            from = Secondary,
-            to = Primary
-        )
-
-        val PrimaryToTransient = Swap(
-            from = Primary,
-            to = TransientPrimary
-        )
-    }
 }
 
 /**
- * A [PaneEntry] for selectively running animations in [ThreePane] [MultiPaneDisplay]. When:
- * - A navigation destination moves between the [ThreePane.Primary] and [ThreePane.Secondary]
- *     panes, the pane animations are not run to provide a seamless movement experience.
- * - A navigation destination moves between the [ThreePane.Primary] and
- *     [ThreePane.TransientPrimary] panes, the pane animations are not run.
+ * Provides a default [PaneEntry] for selectively running animations in
+ * [ThreePane] [MultiPaneDisplay].
  *
- * @param enterTransition the transition to run for the entering pane when permitted.
- * @param exitTransition the transition to run for the exiting pane when permitted.
- * @param paneMapping the mapping of panes to navigation destinations.
+ * @param enterTransition the [EnterTransition] used when this [PaneEntry] adapts in the display.
+ * @param exitTransition the [ExitTransition] used when this [PaneEntry] adapts in the display.
+ * @param paneMapping the [Destination]s that are shown alongside the [Destination] provided and
+ * which of the [ThreePane]s they should show up in.
  * @param render the Composable for rendering the current destination.
  */
-fun <R : Node> threePaneEntry(
-    enterTransition: PaneScope<ThreePane, R>.() -> EnterTransition = { DefaultFadeIn },
-    exitTransition: PaneScope<ThreePane, R>.() -> ExitTransition = { DefaultFadeOut },
-    paneMapping: @Composable (R) -> Map<ThreePane, R?> = {
-        mapOf(ThreePane.Primary to it)
+fun <Destination : Node> threePaneEntry(
+    enterTransition: PaneScope<ThreePane, Destination>.() -> EnterTransition = {
+        if (canAnimate()) DefaultFadeIn else EnterTransition.None
     },
-    render: @Composable PaneScope<ThreePane, R>.(R) -> Unit,
-) = PaneEntry(
-    paneTransform = paneMapping,
-    renderTransform = { destination, original ->
-        val state = paneState
-        val shouldAnimate = when (state.pane) {
-            ThreePane.Primary,
-            ThreePane.Secondary,
-                -> when {
-                ThreePane.PrimaryToSecondary in state.adaptations -> false
-                ThreePane.SecondaryToPrimary in state.adaptations -> false
-                else -> true
-            }
-
-            ThreePane.TransientPrimary -> when {
-                ThreePane.PrimaryToTransient in state.adaptations -> false
-                else -> true
-            }
-
-            else -> true
-        }
-        Box(
-            modifier =
-                if (shouldAnimate) Modifier.animateEnterExit(
-                    enter = enterTransition(),
-                    exit = exitTransition()
-                )
-                else Modifier,
-            content = {
-                original(destination)
-            }
-        )
-
+    exitTransition: PaneScope<ThreePane, Destination>.() -> ExitTransition = {
+        if (canAnimate()) DefaultFadeOut else ExitTransition.None
+    },
+    paneMapping: @Composable (Destination) -> Map<ThreePane, Destination?> = { destination ->
+        mapOf(ThreePane.Primary to destination)
     },
+    render: @Composable (PaneScope<ThreePane, Destination>.(Destination) -> Unit),
+) = PaneEntry(
+    enterTransition = enterTransition,
+    exitTransition = exitTransition,
+    paneMapping = paneMapping,
     content = render
 )
 
@@ -151,3 +100,29 @@ private val DefaultFadeIn = fadeIn(
 private val DefaultFadeOut = fadeOut(
     animationSpec = RouteTransitionAnimationSpec,
 )
+
+private fun PaneScope<ThreePane, *>.canAnimate() =
+    when {
+        transition.targetState == EnterExitState.PostExit -> true
+        inPredictiveBack && isActive -> true
+        paneState.adaptations.any { adaptation ->
+            adaptation is Adaptation.Same
+        } -> false
+
+        paneState.adaptations.any { adaptation ->
+            adaptation is Adaptation.Pop || adaptation is Adaptation.Change
+        } && paneState.adaptations.none {
+            it is Swap<*>
+        } -> true
+
+        else -> when (val pane = paneState.pane) {
+            ThreePane.Primary,
+            ThreePane.Secondary,
+            ThreePane.Tertiary -> paneState.adaptations.any { adaptation ->
+                adaptation is Swap<*> && adaptation.from == pane
+            }
+
+            ThreePane.Overlay,
+            null -> true
+        }
+    }
diff --git a/.../commonMain/kotlin/com/tunjid/treenav/compose/threepane/ThreePaneSharedTransitionScope.kt b/.../commonMain/kotlin/com/tunjid/treenav/compose/threepane/ThreePaneSharedTransitionScope.kt
@@ -65,64 +65,32 @@ private class ThreePaneSharedTransitionScope<Destination : Node> @OptIn(
 
     @OptIn(ExperimentalSharedTransitionApi::class)
     override fun Modifier.paneSharedElement(
-        key: Any,
+        sharedContentState: SharedTransitionScope.SharedContentState,
         boundsTransform: BoundsTransform,
         placeHolderSize: PlaceHolderSize,
         renderInOverlayDuringTransition: Boolean,
         visible: Boolean?,
         zIndexInOverlay: Float,
         clipInOverlayDuringTransition: OverlayClip,
-    ): Modifier = composed {
-
-        when (paneScope.paneState.pane) {
-            null -> throw IllegalArgumentException(
-                "Shared elements may only be used in non null panes"
-            )
-            // Allow shared elements in the primary or transient primary content only
-            ThreePane.Primary -> when {
-                paneScope.isPreviewingBack -> sharedElementWithCallerManagedVisibility(
-                    sharedContentState = rememberSharedContentState(key),
-                    visible = false,
-                    boundsTransform = boundsTransform,
-                    placeHolderSize = placeHolderSize,
-                    renderInOverlayDuringTransition = renderInOverlayDuringTransition,
-                    zIndexInOverlay = zIndexInOverlay,
-                    clipInOverlayDuringTransition = clipInOverlayDuringTransition,
-                )
-                // Share the element
-                else -> sharedElementWithCallerManagedVisibility(
-                    sharedContentState = rememberSharedContentState(key),
-                    visible = when (visible) {
-                        null -> paneScope.isActive
-                        else -> paneScope.isActive && visible
-                    },
-                    boundsTransform = boundsTransform,
-                    placeHolderSize = placeHolderSize,
-                    renderInOverlayDuringTransition = renderInOverlayDuringTransition,
-                    zIndexInOverlay = zIndexInOverlay,
-                    clipInOverlayDuringTransition = clipInOverlayDuringTransition,
-                )
-            }
-            // Share the element when in the transient pane
-            ThreePane.TransientPrimary -> sharedElementWithCallerManagedVisibility(
-                sharedContentState = rememberSharedContentState(key),
-                visible = paneScope.isActive,
-                boundsTransform = boundsTransform,
-                placeHolderSize = placeHolderSize,
-                renderInOverlayDuringTransition = renderInOverlayDuringTransition,
-                zIndexInOverlay = zIndexInOverlay,
-                clipInOverlayDuringTransition = clipInOverlayDuringTransition,
-            )
+    ): Modifier = when (paneScope.paneState.pane) {
+        null -> throw IllegalArgumentException(
+            "Shared elements may only be used in non null panes"
+        )
+        // Allow shared elements in the primary or transient primary content only
+        ThreePane.Primary -> sharedElement(
+            sharedContentState = sharedContentState,
+            animatedVisibilityScope = paneScope,
+            boundsTransform = boundsTransform,
+            placeHolderSize = placeHolderSize,
+            renderInOverlayDuringTransition = renderInOverlayDuringTransition,
+            zIndexInOverlay = zIndexInOverlay,
+            clipInOverlayDuringTransition = clipInOverlayDuringTransition,
+        )
 
-            // In the other panes use the element as is
-            ThreePane.Secondary,
-            ThreePane.Tertiary,
-            ThreePane.Overlay,
-                -> this
-        }
+        // In the other panes use the element as is
+        ThreePane.Secondary,
+        ThreePane.Tertiary,
+        ThreePane.Overlay,
+            -> this
     }
-}
-
-private val PaneScope<ThreePane, *>.isPreviewingBack: Boolean
-    get() = paneState.pane == ThreePane.Primary
-            && paneState.adaptations.contains(ThreePane.PrimaryToTransient)
+}
diff --git a/...commonMain/kotlin/com/tunjid/treenav/compose/threepane/transforms/BackPreviewTransform.kt b/...commonMain/kotlin/com/tunjid/treenav/compose/threepane/transforms/BackPreviewTransform.kt