CompactButtonDefaults

val ContentPadding: PaddingValues

val Height: Dp

val HorizontalPadding: Dp

val TapTargetPadding: PaddingValues

val VerticalPadding: Dp

val minimumListVerticalContentPadding: Dp

import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.wear.compose.foundation.lazy.TransformingLazyColumn
import androidx.wear.compose.foundation.lazy.itemsIndexed
import androidx.wear.compose.foundation.lazy.rememberTransformingLazyColumnState
import androidx.wear.compose.material3.AppScaffold
import androidx.wear.compose.material3.Button
import androidx.wear.compose.material3.ButtonDefaults
import androidx.wear.compose.material3.Card
import androidx.wear.compose.material3.CardDefaults
import androidx.wear.compose.material3.CompactButton
import androidx.wear.compose.material3.CompactButtonDefaults
import androidx.wear.compose.material3.EdgeButton
import androidx.wear.compose.material3.ListHeader
import androidx.wear.compose.material3.ListHeaderDefaults
import androidx.wear.compose.material3.ScreenScaffold
import androidx.wear.compose.material3.SurfaceTransformation
import androidx.wear.compose.material3.Text
import androidx.wear.compose.material3.lazy.rememberTransformationSpec
import androidx.wear.compose.material3.lazy.transformedHeight

val transformationSpec = rememberTransformationSpec()
val state = rememberTransformingLazyColumnState()
var elements by remember { mutableStateOf(listOf(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)) }
var nextElement by remember { mutableIntStateOf(10) }

fun addElementAfter(index: Int) {
    elements =
        elements.subList(0, index + 1) +
            listOf(nextElement++) +
            elements.subList(index + 1, elements.count())
}

fun removeElementAt(index: Int) {
    elements = elements.subList(0, index) + elements.subList(index + 1, elements.count())
}

AppScaffold {
    ScreenScaffold(
        state,
        edgeButton = {
            EdgeButton(onClick = { elements = elements.shuffled() }) { Text("Shuffle") }
        },
    ) { contentPadding ->
        TransformingLazyColumn(state = state, contentPadding = contentPadding) {
            itemsIndexed(elements, key = { _, key -> key }) { index, key ->
                if (key % 3 == 0) {
                    CompactButton(
                        onClick = { removeElementAt(index) },
                        modifier =
                            Modifier.minimumVerticalContentPadding(
                                    CompactButtonDefaults.minimumListVerticalContentPadding
                                )
                                .transformedHeight(this, transformationSpec)
                                .animateItem(),
                        transformation = SurfaceTransformation(transformationSpec),
                    ) {
                        Text("CompactButton $key")
                    }
                } else if (key % 4 == 0) {
                    ListHeader(
                        modifier =
                            Modifier.minimumVerticalContentPadding(
                                ListHeaderDefaults.minimumListTopContentPadding,
                                ListHeaderDefaults.minimumListBottomContentPadding,
                            )
                    ) {
                        Text("ListHeader heading")
                    }
                } else {
                    Card(
                        onClick = {},
                        modifier =
                            Modifier.fillMaxWidth()
                                .minimumVerticalContentPadding(
                                    CardDefaults.minimumListVerticalContentPadding
                                )
                                .transformedHeight(this, transformationSpec)
                                .animateItem(),
                        transformation = SurfaceTransformation(transformationSpec),
                    ) {
                        Text("Card $key")
                        Row {
                            Spacer(modifier = Modifier.weight(1f))
                            CompactButton(
                                onClick = { removeElementAt(index) },
                                enabled = elements.count() > 1,
                            ) {
                                Text("-")
                            }
                            CompactButton(onClick = { addElementAfter(index) }) { Text("+") }
                        }
                    }
                }
            }
        }
    }
}

val shape: RoundedCornerShape