LeaveSpaceEvents -> LeaveSpaceEvent

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/leave/LeaveSpaceEvent.kt

@@ -10,11 +10,11 @@ package io.element.android.features.space.impl.leave
 
 import io.element.android.libraries.matrix.api.core.RoomId
 
-sealed interface LeaveSpaceEvents {
-    data object Retry : LeaveSpaceEvents
-    data object SelectAllRooms : LeaveSpaceEvents
-    data object DeselectAllRooms : LeaveSpaceEvents
-    data class ToggleRoomSelection(val roomId: RoomId) : LeaveSpaceEvents
-    data object LeaveSpace : LeaveSpaceEvents
-    data object CloseError : LeaveSpaceEvents
+sealed interface LeaveSpaceEvent {
+    data object Retry : LeaveSpaceEvent
+    data object SelectAllRooms : LeaveSpaceEvent
+    data object DeselectAllRooms : LeaveSpaceEvent
+    data class ToggleRoomSelection(val roomId: RoomId) : LeaveSpaceEvent
+    data object LeaveSpace : LeaveSpaceEvent
+    data object CloseError : LeaveSpaceEvent
 }

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/leave/LeaveSpacePresenter.kt

@@ -99,33 +99,33 @@ class LeaveSpacePresenter(
             }
         }
 
-        fun handleEvent(event: LeaveSpaceEvents) {
+        fun handleEvent(event: LeaveSpaceEvent) {
             when (event) {
-                LeaveSpaceEvents.Retry -> {
+                LeaveSpaceEvent.Retry -> {
                     leaveSpaceRooms = AsyncData.Loading()
                     retryCount += 1
                 }
-                LeaveSpaceEvents.DeselectAllRooms -> {
+                LeaveSpaceEvent.DeselectAllRooms -> {
                     selectedRoomIds = persistentSetOf()
                 }
-                LeaveSpaceEvents.SelectAllRooms -> {
+                LeaveSpaceEvent.SelectAllRooms -> {
                     selectedRoomIds = selectableSpaceRooms.dataOrNull()
                         .orEmpty()
                         .filter { it.isLastOwner.not() }
                         .map { it.spaceRoom.roomId }
                 }
-                is LeaveSpaceEvents.ToggleRoomSelection -> {
+                is LeaveSpaceEvent.ToggleRoomSelection -> {
                     selectedRoomIds = if (selectedRoomIds.contains(event.roomId)) {
                         selectedRoomIds - event.roomId
                     } else {
                         selectedRoomIds + event.roomId
                     }
                 }
-                LeaveSpaceEvents.LeaveSpace -> coroutineScope.leaveSpace(
+                LeaveSpaceEvent.LeaveSpace -> coroutineScope.leaveSpace(
                     leaveSpaceAction = leaveSpaceAction,
                     selectedRoomIds = selectedRoomIds,
                 )
-                LeaveSpaceEvents.CloseError -> {
+                LeaveSpaceEvent.CloseError -> {
                     leaveSpaceAction.value = AsyncAction.Uninitialized
                 }
             }

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/leave/LeaveSpaceState.kt

@@ -19,7 +19,7 @@ data class LeaveSpaceState(
     val areCreatorsPrivileged: Boolean,
     val selectableSpaceRooms: AsyncData<ImmutableList<SelectableSpaceRoom>>,
     val leaveSpaceAction: AsyncAction<Unit>,
-    val eventSink: (LeaveSpaceEvents) -> Unit,
+    val eventSink: (LeaveSpaceEvent) -> Unit,
 ) {
     private val rooms = selectableSpaceRooms.dataOrNull().orEmpty().toImmutableList()
     private val lastAdminRooms: ImmutableList<SelectableSpaceRoom>

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/leave/LeaveSpaceView.kt

@@ -92,7 +92,7 @@ fun LeaveSpaceView(
                 showLeaveButton = state.showLeaveButton,
                 selectedRoomsCount = state.selectedRoomsCount,
                 onLeaveSpace = {
-                    state.eventSink(LeaveSpaceEvents.LeaveSpace)
+                    state.eventSink(LeaveSpaceEvent.LeaveSpace)
                 },
                 onCancel = onCancel,
                 showRolesAndPermissionsButton = state.needsOwnerChange && !state.areCreatorsPrivileged,
@@ -115,7 +115,7 @@ fun LeaveSpaceView(
                                         selectableSpaceRoom = selectableSpaceRoom,
                                         showCheckBox = state.hasOnlyLastAdminRoom.not(),
                                         onClick = {
-                                            state.eventSink(LeaveSpaceEvents.ToggleRoomSelection(selectableSpaceRoom.spaceRoom.roomId))
+                                            state.eventSink(LeaveSpaceEvent.ToggleRoomSelection(selectableSpaceRoom.spaceRoom.roomId))
                                         }
                                     )
                                 }
@@ -125,7 +125,7 @@ fun LeaveSpaceView(
                             AsyncFailure(
                                 throwable = state.selectableSpaceRooms.error,
                                 onRetry = {
-                                    state.eventSink(LeaveSpaceEvents.Retry)
+                                    state.eventSink(LeaveSpaceEvent.Retry)
                                 },
                             )
                         }
@@ -143,7 +143,7 @@ fun LeaveSpaceView(
         async = state.leaveSpaceAction,
         onSuccess = { /* Nothing to do, the screen will be dismissed automatically */ },
         errorMessage = { stringResource(CommonStrings.error_unknown) },
-        onErrorDismiss = { state.eventSink(LeaveSpaceEvents.CloseError) },
+        onErrorDismiss = { state.eventSink(LeaveSpaceEvent.CloseError) },
     )
 }
 
@@ -184,11 +184,11 @@ private fun LeaveSpaceHeader(
         if (state.showQuickAction) {
             if (state.areAllSelected) {
                 QuickActionButton(CommonStrings.action_deselect_all) {
-                    state.eventSink(LeaveSpaceEvents.DeselectAllRooms)
+                    state.eventSink(LeaveSpaceEvent.DeselectAllRooms)
                 }
             } else {
                 QuickActionButton(resId = CommonStrings.action_select_all) {
-                    state.eventSink(LeaveSpaceEvents.SelectAllRooms)
+                    state.eventSink(LeaveSpaceEvent.SelectAllRooms)
                 }
             }
         }

features/space/impl/src/test/kotlin/io/element/android/features/space/impl/leave/LeaveSpacePresenterTest.kt

@@ -61,7 +61,7 @@ class LeaveSpacePresenterTest {
             val stateError = awaitItem()
             assertThat(stateError.selectableSpaceRooms.isFailure()).isTrue()
             // Retry
-            stateError.eventSink(LeaveSpaceEvents.Retry)
+            stateError.eventSink(LeaveSpaceEvent.Retry)
             skipItems(1)
             val stateLoadingAgain = awaitItem()
             assertThat(stateLoadingAgain.selectableSpaceRooms.isLoading()).isTrue()
@@ -121,7 +121,7 @@ class LeaveSpacePresenterTest {
             assertThat(finalState.selectableSpaceRooms.dataOrNull()!!.map { it.spaceRoom.roomId }).containsExactly(A_ROOM_ID, A_ROOM_ID_3)
             assertThat(finalState.selectedRoomsCount).isEqualTo(2)
             // Leaving the space will not include the DM
-            finalState.eventSink(LeaveSpaceEvents.LeaveSpace)
+            finalState.eventSink(LeaveSpaceEvent.LeaveSpace)
             val stateLeaving = awaitItem()
             assertThat(stateLeaving.leaveSpaceAction).isEqualTo(AsyncAction.Loading)
             val stateLeft = awaitItem()
@@ -165,32 +165,32 @@ class LeaveSpacePresenterTest {
             assertThat(room2.isSelected).isFalse()
             assertThat(room2.isLastOwner).isTrue()
             // Deselect all
-            state.eventSink(LeaveSpaceEvents.DeselectAllRooms)
+            state.eventSink(LeaveSpaceEvent.DeselectAllRooms)
             skipItems(1)
             val stateAllDeselected = awaitItem()
             val dataAllDeselected = stateAllDeselected.selectableSpaceRooms.dataOrNull()!!
             assertThat(dataAllDeselected.any { it.isSelected }).isFalse()
             // Select all
-            stateAllDeselected.eventSink(LeaveSpaceEvents.SelectAllRooms)
+            stateAllDeselected.eventSink(LeaveSpaceEvent.SelectAllRooms)
             skipItems(1)
             val stateAllSelected = awaitItem()
             val dataAllSelected = stateAllSelected.selectableSpaceRooms.dataOrNull()!!
             // The last admin room should not be selected
             assertThat(dataAllSelected.count { it.isSelected }).isEqualTo(1)
             // Toggle selection of the first room
-            stateAllSelected.eventSink(LeaveSpaceEvents.ToggleRoomSelection(A_ROOM_ID))
+            stateAllSelected.eventSink(LeaveSpaceEvent.ToggleRoomSelection(A_ROOM_ID))
             skipItems(1)
             val stateOneDeselected = awaitItem()
             val dataOneDeselected = stateOneDeselected.selectableSpaceRooms.dataOrNull()!!
             assertThat(dataOneDeselected[0].isSelected).isFalse()
             // Toggle selection of the first room
-            stateOneDeselected.eventSink(LeaveSpaceEvents.ToggleRoomSelection(A_ROOM_ID))
+            stateOneDeselected.eventSink(LeaveSpaceEvent.ToggleRoomSelection(A_ROOM_ID))
             skipItems(1)
             val stateOneSelected = awaitItem()
             val dataOneSelected = stateOneSelected.selectableSpaceRooms.dataOrNull()!!
             assertThat(dataOneSelected[0].isSelected).isTrue()
             // Leave space
-            stateOneSelected.eventSink(LeaveSpaceEvents.LeaveSpace)
+            stateOneSelected.eventSink(LeaveSpaceEvent.LeaveSpace)
             val stateLeaving = awaitItem()
             assertThat(stateLeaving.leaveSpaceAction).isEqualTo(AsyncAction.Loading)
             val stateLeft = awaitItem()
@@ -215,13 +215,13 @@ class LeaveSpacePresenterTest {
         presenter.test {
             skipItems(3)
             val state = awaitItem()
-            state.eventSink(LeaveSpaceEvents.LeaveSpace)
+            state.eventSink(LeaveSpaceEvent.LeaveSpace)
             val stateLeaving = awaitItem()
             assertThat(stateLeaving.leaveSpaceAction).isEqualTo(AsyncAction.Loading)
             val stateError = awaitItem()
             assertThat(stateError.leaveSpaceAction.isFailure()).isTrue()
             // Close error
-            stateError.eventSink(LeaveSpaceEvents.CloseError)
+            stateError.eventSink(LeaveSpaceEvent.CloseError)
             val stateErrorClosed = awaitItem()
             assertThat(stateErrorClosed.leaveSpaceAction).isEqualTo(AsyncAction.Uninitialized)
         }