Demo.kt

Column(modifier = Modifier.fillMaxSize()) {
        var state1 by remember { mutableStateOf(_state1) }
        var state2 by remember { mutableStateOf(_state2) }

        LazyColumn(
            modifier = Modifier.wrapContentSize(),
        ) {
            items(
                items = state1.cartRows,
                key = { value ->
                    value.id
                },
                itemContent = { item ->
                    val bulkEdit = state1.selectedCartRows.size > 0
                    val animState by animateIntAsState(
                        targetValue = item.visibility,
                        animationSpec = tween(500),
                        finishedListener = {
                            val updatedCartRows = state1.cartRows.filter { it.id != item.id }
                            state1  =  state1.copy(cartRows = updatedCartRows)
                        }
                    )
                    ItemContent(
                        item = item,
                        selectedItems = state1.selectedCartRows.map { it.id },
                        onSelectItem = { id ->
                            // Clear selected items of the other list
                            val selectedstate2Items = state2.selectedCartRows
                            if (selectedstate2Items.size > 0) {
                                state2 =state2.copy(selectedCartRows = listOf())
                            }
                            state1.cartRows.find { it.id == id }?.let { selectedItem ->
                                if (state1.selectedCartRows.contains(selectedItem)) {
                                    val updatedSelectedCartRows = state1.selectedCartRows.filter { it.id != selectedItem.id }
                                    state1  =  state1.copy(selectedCartRows = updatedSelectedCartRows)
                                } else {
                                    val updatedSelectedCartRows = state1.selectedCartRows + selectedItem
                                    state1  =  state1.copy(selectedCartRows = updatedSelectedCartRows)
                                }
                            }
                        },
                        bulkEdit = bulkEdit,
                        animState = animState,
                    )
                }
            )
            item {
                Button(
                    enabled = state2.selectedCartRows.size > 0,
                    onClick = {
                        // Update visibility of all selected items
                        val currentListItems = state2.selectedCartRows
                            .map {
                                it.copy(visibility = 0)
                            }
                        val updatingItems = mutableListOf<Item>()
                        val filteredItems = state2.cartRows.toMutableList()
                        currentListItems.forEach { updatedItem ->
                            state2.cartRows.find { it.id == updatedItem.id  }?.let { itemToFilter ->
                                updatingItems.add(updatedItem)
                                filteredItems.remove(itemToFilter)
                            }
                        }

                        state1  =  state1.copy(cartRows = state1.cartRows + state2.selectedCartRows)
                        state2 = state2.copy(cartRows = filteredItems + updatingItems, selectedCartRows = listOf())
                    }
                ) {
                    Text("Move")
                }
            }
        }
        Divider(
            modifier = Modifier
                .height(5.dp)
                .background(Color.Gray)
        )
        LazyColumn(
            modifier = Modifier.wrapContentSize()
        ) {
            itemsIndexed(
                items = state2.cartRows,
                key = { _, value ->
                    value.id
                },
                itemContent = { _, item ->
                    val bulkEdit = state2.selectedCartRows.size > 0
                    val animState by animateIntAsState(
                        targetValue = item.visibility,
                        animationSpec = tween(500),
                        finishedListener = {
                            val updatedCartRows = state2.cartRows.filter { it.id != item.id }
                            state2 =state2.copy(cartRows = updatedCartRows)
                        }
                    )
                    ItemContent(
                        item = item,
                        selectedItems = state2.selectedCartRows.map { it.id },
                        onSelectItem = { id ->
                            // Clear selected items of the other list
                            val selectedState1Items = state1.selectedCartRows
                            if (selectedState1Items.size > 0) {
                                state1  =  state1.copy(selectedCartRows = listOf())
                            }
                            state2.cartRows.find { it.id == id }?.let { selectedItem ->
                                if (state2.selectedCartRows.contains(selectedItem)) {
                                    val updatedSelectedCartRows = state2.selectedCartRows.filter { it.id != selectedItem.id }
                                    state2 =state2.copy(selectedCartRows = updatedSelectedCartRows)
                                } else {
                                    val updatedSelectedCartRows = state2.selectedCartRows + selectedItem
                                    state2 =state2.copy(selectedCartRows = updatedSelectedCartRows)
                                }
                            }
                        },
                        bulkEdit = bulkEdit,
                        animState = animState,
                    )
                }
            )
            item {
                Button(
                    enabled = state1.selectedCartRows.size > 0,
                    onClick = {
                        // Update visibility of all selected items
                        val currentListItems = state1.selectedCartRows
                            .map {
                                it.copy(visibility = 0)
                            }
                        val updatingItems = mutableListOf<Item>()
                        val filteredItems = state1.cartRows.toMutableList()
                        currentListItems.forEach { updatedItem ->
                            state1.cartRows.find { it.id == updatedItem.id  }?.let { itemToFilter ->
                                updatingItems.add(updatedItem)
                                filteredItems.remove(itemToFilter)
                            }
                        }

                        state2 =state2.copy(cartRows = state2.cartRows + state1.selectedCartRows)
                        state1 =  state1.copy(cartRows = filteredItems + updatingItems, selectedCartRows = listOf())
                    }
                ) {
                    Text("Move")
                }
            }
        }
    }
}

ItemContent.kt

@Composable
fun ItemContent(
    item: Item,
    selectedItems: List<String>,
    onSelectItem: (String) -> Unit,
    bulkEdit: Boolean,
    animState: Int,
) {
    var launchedVisibility by remember { mutableStateOf(0) }
    val launchedAnimState by animateIntAsState(
        targetValue = launchedVisibility,
        animationSpec = tween(500),
        finishedListener = {
            // no-op
        }
    )

    LaunchedEffect(key1 = item.id) {
        launchedVisibility = 1
    }
    AnimatedVisibility(
        visible = if (launchedVisibility != 1) {
            launchedAnimState == 1
        } else {
            animState == 1
        },
        enter = expandVertically(),
        exit = shrinkVertically()
    ) {
        Row(
            modifier = Modifier
                .fillMaxWidth()
                .clickable {
                    onSelectItem(item.id)
                }
        ) {
            Text(
                modifier = Modifier
                    .padding(16.dp)
                ,
                text = item.title
            )
            Spacer(modifier = Modifier.weight(1f))
            if (bulkEdit) {
                Checkbox(
                    modifier = Modifier,
                    checked = selectedItems.contains(item.id),
                    onCheckedChange = {
                        // no op
                    }
                )
            }
        }
    }
}

state.kt

data class Item(
    val id: String,
    val title: String,
    val visibility: Int,
)

data class State(
    val cartRows: List<Item>,
    val selectedCartRows: List<Item>,
)

var _state1  =  State(
    cartRows = listOf(
        Item(
            id = UUID.randomUUID().toString(),
            title = "one",
            visibility = 1
        ),
        Item(
            id = UUID.randomUUID().toString(),
            title = "two",
            visibility = 1
        ),
        Item(
            id = UUID.randomUUID().toString(),
            title = "three",
            visibility = 1
        ),
        Item(
            id = UUID.randomUUID().toString(),
            title = "four",
            visibility = 1
        ),
    ),
    selectedCartRows = listOf()
)

var _state2 =State(
    cartRows = listOf(
        Item(
            id = UUID.randomUUID().toString(),
            title = "five",
            visibility = 1
        ),
        Item(
            id = UUID.randomUUID().toString(),
            title = "six",
            visibility = 1
        ),
    ),
    selectedCartRows = listOf()
)