openuispec 0.1.18 → 0.1.20

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/ui/screens/TasksScreen.kt

@@ -0,0 +1,342 @@
+package uz.rsteam.todoorbit
+
+import androidx.compose.animation.animateContentSize
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Add
+import androidx.compose.material.icons.outlined.CheckCircle
+import androidx.compose.material.icons.outlined.Delete
+import androidx.compose.material.icons.outlined.Edit
+import androidx.compose.material.icons.outlined.Info
+import androidx.compose.material.icons.outlined.Sort
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.AssistChip
+import androidx.compose.material3.Button
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedCard
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import java.time.LocalDate
+import java.time.temporal.ChronoUnit
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun TasksScreen(
+    tasks: List<TaskModel>,
+    allTasks: List<TaskModel>,
+    filter: TaskFilter,
+    searchQuery: String,
+    selectedTask: TaskModel?,
+    locale: UiLocale,
+    useSplitView: Boolean,
+    onSearchChange: (String) -> Unit,
+    onFilterChange: (TaskFilter) -> Unit,
+    onSelectTask: (TaskModel) -> Unit,
+    onToggleTask: (TaskModel) -> Unit,
+    onCreateTask: () -> Unit,
+    onEditTask: (TaskModel) -> Unit,
+    onDeleteTask: (TaskModel) -> Unit,
+    onMoreInfo: (TaskModel) -> Unit
+) {
+    val counts = remember(allTasks) {
+        mapOf(
+            TaskFilter.All to allTasks.size,
+            TaskFilter.Open to allTasks.count { it.status == TaskStatus.Open },
+            TaskFilter.Done to allTasks.count { it.status == TaskStatus.Done }
+        )
+    }
+    val detailPanePadding = 20.dp
+
+    BoxWithConstraints(modifier = Modifier.fillMaxSize()) {
+        val listPaneWidth = if (useSplitView) maxWidth * 0.42f else maxWidth
+        val detailPaneWidth = (maxWidth - listPaneWidth - detailPanePadding * 2).coerceAtLeast(0.dp)
+
+        Row(modifier = Modifier.fillMaxSize()) {
+            LazyColumn(
+                modifier = Modifier.width(listPaneWidth).fillMaxHeight(),
+                verticalArrangement = Arrangement.spacedBy(16.dp),
+                contentPadding = PaddingValues(20.dp)
+            ) {
+                item {
+                    HeroCard(
+                        title = stringResource(R.string.home_title),
+                        subtitle = homeSummaryText(counts[TaskFilter.Open] ?: 0, counts[TaskFilter.All] ?: 0)
+                    )
+                }
+                item {
+                    OutlinedTextField(
+                        value = searchQuery,
+                        onValueChange = onSearchChange,
+                        modifier = Modifier.fillMaxWidth(),
+                        leadingIcon = { Icon(Icons.Outlined.Sort, contentDescription = null) },
+                        label = { Text(stringResource(R.string.home_search_label)) },
+                        placeholder = { Text(stringResource(R.string.home_search_placeholder)) },
+                        shape = MaterialTheme.shapes.medium
+                    )
+                }
+                item {
+                    androidx.compose.foundation.layout.FlowRow(
+                        horizontalArrangement = Arrangement.spacedBy(8.dp),
+                        verticalArrangement = Arrangement.spacedBy(8.dp)
+                    ) {
+                        TaskFilter.entries.forEach { current ->
+                            FilterChip(
+                                selected = current == filter,
+                                onClick = { onFilterChange(current) },
+                                label = {
+                                    val label = when (current) {
+                                        TaskFilter.All -> stringResource(R.string.home_filter_all)
+                                        TaskFilter.Open -> stringResource(R.string.home_filter_open)
+                                        TaskFilter.Done -> stringResource(R.string.home_filter_done)
+                                    }
+                                    Text("$label (${counts[current] ?: 0})")
+                                }
+                            )
+                        }
+                    }
+                }
+                if (tasks.isEmpty()) {
+                    item {
+                        EmptyCard(
+                            stringResource(R.string.home_empty_title),
+                            stringResource(R.string.home_empty_body)
+                        )
+                    }
+                } else {
+                    items(tasks, key = { it.id }) { task ->
+                        TaskRow(
+                            task = task,
+                            selected = selectedTask?.id == task.id,
+                            onSelect = { onSelectTask(task) },
+                            onToggle = { onToggleTask(task) }
+                        )
+                    }
+                }
+                item { Spacer(Modifier.height(80.dp)) }
+            }
+
+            if (useSplitView && selectedTask != null) {
+                TaskDetailPane(
+                    modifier = Modifier.width(detailPaneWidth).fillMaxHeight().padding(detailPanePadding),
+                    locale = locale,
+                    task = selectedTask,
+                    onEdit = { onEditTask(selectedTask) },
+                    onToggle = { onToggleTask(selectedTask) },
+                    onDelete = { onDeleteTask(selectedTask) },
+                    onMoreInfo = { onMoreInfo(selectedTask) }
+                )
+            }
+        }
+    }
+
+    Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.BottomEnd) {
+        Button(onClick = onCreateTask, modifier = Modifier.padding(24.dp), shape = MaterialTheme.shapes.medium) {
+            Icon(Icons.Outlined.Add, contentDescription = null)
+            Spacer(Modifier.width(8.dp))
+            Text(stringResource(R.string.home_new_task))
+        }
+    }
+}
+
+@Composable
+fun TaskRow(
+    task: TaskModel,
+    selected: Boolean,
+    onSelect: () -> Unit,
+    onToggle: () -> Unit
+) {
+    val containerColor =
+        if (selected) MaterialTheme.colorScheme.primary.copy(alpha = 0.12f) else MaterialTheme.colorScheme.surface
+
+    OutlinedCard(
+        modifier = Modifier.animateContentSize(),
+        shape = MaterialTheme.shapes.medium,
+        colors = CardDefaults.outlinedCardColors(containerColor = containerColor),
+        onClick = onSelect
+    ) {
+        Row(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 14.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(12.dp)
+        ) {
+            Checkbox(checked = task.status == TaskStatus.Done, onCheckedChange = { onToggle() })
+            Column(modifier = Modifier.fillMaxWidth(0.85f)) {
+                Text(task.title, fontWeight = FontWeight.SemiBold, maxLines = 1, overflow = TextOverflow.Ellipsis)
+                Text(
+                    text = task.dueDate?.let { relativeDateText(it) } ?: stringResource(R.string.task_detail_no_due_date),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant
+                )
+            }
+            Box(modifier = Modifier.size(12.dp).background(task.priority.color, CircleShape))
+        }
+    }
+}
+
+@OptIn(ExperimentalFoundationApi::class, ExperimentalLayoutApi::class)
+@Composable
+fun TaskDetailPane(
+    modifier: Modifier = Modifier,
+    locale: UiLocale,
+    task: TaskModel,
+    onEdit: () -> Unit,
+    onToggle: () -> Unit,
+    onDelete: () -> Unit,
+    onMoreInfo: () -> Unit
+) {
+    var confirmDelete by remember { mutableStateOf(false) }
+
+    ElevatedCard(modifier = modifier, shape = MaterialTheme.shapes.large) {
+        LazyColumn(
+            modifier = Modifier.fillMaxSize(),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+            contentPadding = PaddingValues(20.dp)
+        ) {
+            item {
+                Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
+                    Column(modifier = Modifier.fillMaxWidth(0.72f)) {
+                        Text(task.title, style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold)
+                        Text(
+                            task.dueDate?.let { formatAbsolute(it, locale) } ?: stringResource(R.string.task_detail_no_due_date),
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                    AssistChip(
+                        onClick = {},
+                        label = { Text(stringResource(task.status.labelRes)) },
+                        leadingIcon = { Icon(Icons.Outlined.CheckCircle, contentDescription = null) }
+                    )
+                }
+            }
+            item {
+                LazyVerticalGrid(
+                    columns = GridCells.Fixed(2),
+                    modifier = Modifier.height(220.dp),
+                    verticalArrangement = Arrangement.spacedBy(12.dp),
+                    horizontalArrangement = Arrangement.spacedBy(12.dp),
+                    userScrollEnabled = false
+                ) {
+                    item { StatCard(stringResource(R.string.task_detail_status), stringResource(task.status.labelRes)) }
+                    item { StatCard(stringResource(R.string.task_detail_priority), stringResource(task.priority.labelRes)) }
+                    item { StatCard(stringResource(R.string.task_detail_created), formatAbsolute(task.createdAt.toLocalDate(), locale)) }
+                    item { StatCard(stringResource(R.string.task_detail_updated), formatAbsolute(task.updatedAt.toLocalDate(), locale)) }
+                }
+            }
+            if (task.notes.isNotBlank()) {
+                item {
+                    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                        Text(stringResource(R.string.task_detail_notes), style = MaterialTheme.typography.titleMedium)
+                        Text(task.notes)
+                    }
+                }
+            }
+            item {
+                androidx.compose.foundation.layout.FlowRow(
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
+                    verticalArrangement = Arrangement.spacedBy(8.dp)
+                ) {
+                    Button(onClick = onEdit, shape = MaterialTheme.shapes.medium) {
+                        Icon(Icons.Outlined.Edit, contentDescription = null)
+                        Spacer(Modifier.width(8.dp))
+                        Text(stringResource(R.string.task_detail_edit))
+                    }
+                    OutlinedButton(onClick = onToggle, shape = MaterialTheme.shapes.medium) {
+                        Text(stringResource(R.string.task_detail_toggle_status))
+                    }
+                    OutlinedButton(onClick = onMoreInfo, shape = MaterialTheme.shapes.medium) {
+                        Icon(Icons.Outlined.Info, contentDescription = null)
+                        Spacer(Modifier.width(8.dp))
+                        Text(stringResource(R.string.task_detail_more_info))
+                    }
+                    OutlinedButton(onClick = { confirmDelete = true }, shape = MaterialTheme.shapes.medium) {
+                        Icon(Icons.Outlined.Delete, contentDescription = null)
+                        Spacer(Modifier.width(8.dp))
+                        Text(stringResource(R.string.task_detail_delete))
+                    }
+                }
+            }
+        }
+    }
+
+    if (confirmDelete) {
+        AlertDialog(
+            onDismissRequest = { confirmDelete = false },
+            title = { Text(stringResource(R.string.task_detail_delete_title)) },
+            text = { Text(stringResource(R.string.task_detail_delete_message)) },
+            dismissButton = {
+                TextButton(onClick = { confirmDelete = false }) {
+                    Text(stringResource(R.string.common_cancel))
+                }
+            },
+            confirmButton = {
+                TextButton(
+                    onClick = {
+                        confirmDelete = false
+                        onDelete()
+                    }
+                ) {
+                    Text(stringResource(R.string.common_delete))
+                }
+            }
+        )
+    }
+}
+
+@Composable
+private fun homeSummaryText(open: Int, total: Int): String {
+    return if (open == 0) {
+        stringResource(R.string.home_summary_done)
+    } else {
+        pluralStringResource(R.plurals.home_summary_open, open, open, total)
+    }
+}
+
+@Composable
+private fun relativeDateText(date: LocalDate): String {
+    val days = ChronoUnit.DAYS.between(LocalDate.now(), date)
+    return when {
+        days == 0L -> stringResource(R.string.common_today)
+        days > 0L -> pluralStringResource(R.plurals.common_in_days, days.toInt(), days.toInt())
+        else -> pluralStringResource(R.plurals.common_days_ago, (-days).toInt(), (-days).toInt())
+    }
+}

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/ui/sheets/EditorSheets.kt

@@ -0,0 +1,344 @@
+package uz.rsteam.todoorbit
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.Button
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.OutlinedCard
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.delay
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun TaskEditorSheet(
+    draft: TaskDraft,
+    title: String,
+    saveLabel: String,
+    onDismiss: () -> Unit,
+    onSubmit: (TaskDraft) -> Unit
+) {
+    val minLengthError = stringResource(R.string.validation_min_length, 2)
+    val priorityOptions = Priority.entries.map { it.name to stringResource(it.labelRes) }
+    var localDraft by remember(draft) { mutableStateOf(draft) }
+    var titleError by remember { mutableStateOf<String?>(null) }
+
+    ModalBottomSheet(onDismissRequest = onDismiss) {
+        Column(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 20.dp, vertical = 8.dp).padding(bottom = 24.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp)
+        ) {
+            Text(title, style = MaterialTheme.typography.headlineSmall)
+            OutlinedTextField(
+                value = localDraft.title,
+                onValueChange = {
+                    localDraft = localDraft.copy(title = it)
+                    titleError = if (it.trim().length < 2) {
+                        minLengthError
+                    } else {
+                        null
+                    }
+                },
+                modifier = Modifier.fillMaxWidth(),
+                label = { Text(stringResource(R.string.create_task_field_title)) },
+                placeholder = { Text(stringResource(R.string.create_task_field_title_placeholder)) },
+                shape = MaterialTheme.shapes.medium,
+                isError = titleError != null
+            )
+            AnimatedVisibility(visible = titleError != null) {
+                Text(titleError.orEmpty(), color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+            }
+            OutlinedTextField(
+                value = localDraft.notes,
+                onValueChange = { localDraft = localDraft.copy(notes = it) },
+                modifier = Modifier.fillMaxWidth(),
+                label = { Text(stringResource(R.string.create_task_field_notes)) },
+                placeholder = { Text(stringResource(R.string.create_task_field_notes_placeholder)) },
+                shape = MaterialTheme.shapes.medium,
+                minLines = 4
+            )
+            EnumSelector(
+                title = stringResource(R.string.create_task_field_priority),
+                current = localDraft.priority.name,
+                options = priorityOptions,
+                onSelected = { selected ->
+                    localDraft = localDraft.copy(priority = Priority.entries.first { it.name == selected })
+                }
+            )
+            OutlinedTextField(
+                value = localDraft.dueDate?.toString().orEmpty(),
+                onValueChange = { entered ->
+                    localDraft = localDraft.copy(dueDate = parseLocalDateOrNull(entered))
+                },
+                modifier = Modifier.fillMaxWidth(),
+                label = { Text(stringResource(R.string.create_task_field_due_date)) },
+                placeholder = { Text(stringResource(R.string.create_task_field_due_date_placeholder)) },
+                shape = MaterialTheme.shapes.medium
+            )
+            Button(
+                onClick = {
+                    if (localDraft.title.trim().length >= 2) {
+                        onSubmit(localDraft)
+                    } else {
+                        titleError = minLengthError
+                    }
+                },
+                modifier = Modifier.fillMaxWidth(),
+                shape = MaterialTheme.shapes.medium
+            ) {
+                Text(saveLabel)
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun RecurringRuleSheet(
+    preferences: PreferencesState,
+    rules: List<RecurringRuleModel>,
+    locale: UiLocale,
+    onDismiss: () -> Unit,
+    onSubmit: (RecurringRuleModel) -> Unit
+) {
+    val dailyCadenceLabel = stringResource(R.string.recurring_rule_cadence_daily)
+    val weeklyCadenceLabel = stringResource(R.string.recurring_rule_cadence_weekly)
+    val monthlyCadenceLabel = stringResource(R.string.recurring_rule_cadence_monthly)
+    val weekdayOptions = listOf(
+        "" to "—",
+        Weekday.Mon.name to stringResource(R.string.weekday_mon),
+        Weekday.Tue.name to stringResource(R.string.weekday_tue),
+        Weekday.Wed.name to stringResource(R.string.weekday_wed),
+        Weekday.Thu.name to stringResource(R.string.weekday_thu),
+        Weekday.Fri.name to stringResource(R.string.weekday_fri),
+        Weekday.Sat.name to stringResource(R.string.weekday_sat),
+        Weekday.Sun.name to stringResource(R.string.weekday_sun)
+    )
+    val summaryChannelOptions = listOf(
+        "" to "—",
+        SummaryChannel.Push.name to stringResource(R.string.recurring_rule_summary_push),
+        SummaryChannel.Email.name to stringResource(R.string.recurring_rule_summary_email)
+    )
+    var draft by remember { mutableStateOf(RuleDraft()) }
+    var errors by remember { mutableStateOf<Map<String, UiText>>(emptyMap()) }
+    var checkingName by remember { mutableStateOf(false) }
+    val preview = remember(draft) { schedulePreview(draft) }
+
+    LaunchedEffect(draft.name, rules) {
+        val trimmed = draft.name.trim()
+        if (trimmed.length < 4 || trimmed == "Default") {
+            checkingName = false
+            return@LaunchedEffect
+        }
+        checkingName = true
+        delay(450)
+        checkingName = false
+        if (rules.any { it.name.equals(trimmed, ignoreCase = true) }) {
+            errors = errors + ("name" to UiText.Resource(R.string.validation_rule_name_taken))
+        }
+    }
+
+    ModalBottomSheet(onDismissRequest = onDismiss) {
+        Column(
+            modifier = Modifier.fillMaxWidth().padding(horizontal = 20.dp, vertical = 8.dp).padding(bottom = 24.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp)
+        ) {
+            Text(stringResource(R.string.recurring_rule_title), style = MaterialTheme.typography.headlineSmall)
+            Text(stringResource(R.string.recurring_rule_subtitle), color = MaterialTheme.colorScheme.onSurfaceVariant)
+
+            RuleTextField(
+                label = stringResource(R.string.recurring_rule_field_name),
+                value = draft.name,
+                placeholder = stringResource(R.string.recurring_rule_field_name_placeholder),
+                error = errors["name"]?.resolve(),
+                helper = if (checkingName) stringResource(R.string.recurring_rule_checking_name) else null,
+                onValueChange = { draft = draft.copy(name = it) }
+            )
+            RuleTextField(
+                label = stringResource(R.string.recurring_rule_field_confirm_name),
+                value = draft.confirmName,
+                placeholder = stringResource(R.string.recurring_rule_field_confirm_name_placeholder),
+                error = errors["confirmName"]?.resolve(),
+                onValueChange = { draft = draft.copy(confirmName = it) }
+            )
+
+            EnumSelector(
+                title = stringResource(R.string.recurring_rule_field_cadence),
+                current = draft.cadence?.name.orEmpty(),
+                options = listOf(
+                    "" to "—",
+                    Cadence.Daily.name to dailyCadenceLabel,
+                    Cadence.Weekly.name to weeklyCadenceLabel,
+                    Cadence.Monthly.name to monthlyCadenceLabel
+                ),
+                onSelected = {
+                    draft = draft.copy(
+                        cadence = Cadence.entries.firstOrNull { entry -> entry.name == it },
+                        weekday = if (it == Cadence.Weekly.name) draft.weekday else null,
+                        monthDay = if (it == Cadence.Monthly.name) draft.monthDay else ""
+                    )
+                }
+            )
+            RuleTextField(
+                label = stringResource(R.string.recurring_rule_field_interval),
+                value = draft.interval,
+                helper = stringResource(R.string.recurring_rule_field_interval_helper),
+                error = errors["interval"]?.resolve(),
+                onValueChange = { draft = draft.copy(interval = it) }
+            )
+
+            AnimatedVisibility(visible = draft.cadence == Cadence.Weekly) {
+                EnumSelector(
+                    title = stringResource(R.string.recurring_rule_field_weekday),
+                    current = draft.weekday?.name.orEmpty(),
+                    options = weekdayOptions,
+                    onSelected = { draft = draft.copy(weekday = Weekday.entries.firstOrNull { day -> day.name == it }) }
+                )
+            }
+            AnimatedVisibility(visible = draft.cadence == Cadence.Monthly) {
+                RuleTextField(
+                    label = stringResource(R.string.recurring_rule_field_month_day),
+                    value = draft.monthDay,
+                    helper = stringResource(R.string.recurring_rule_field_month_day_helper),
+                    error = errors["monthDay"]?.resolve(),
+                    onValueChange = { draft = draft.copy(monthDay = it) }
+                )
+            }
+
+            RuleTextField(
+                label = stringResource(R.string.recurring_rule_field_start_date),
+                value = draft.startDate.toString(),
+                error = errors["startDate"]?.resolve(),
+                onValueChange = { text ->
+                    parseLocalDateOrNull(text)?.also { draft = draft.copy(startDate = it) }
+                }
+            )
+            SettingsToggle(
+                title = stringResource(R.string.recurring_rule_field_has_end_date),
+                subtitle = stringResource(R.string.recurring_rule_field_has_end_date_helper),
+                checked = draft.hasEndDate,
+                onCheckedChange = { draft = draft.copy(hasEndDate = it) }
+            )
+            AnimatedVisibility(visible = draft.hasEndDate) {
+                RuleTextField(
+                    label = stringResource(R.string.recurring_rule_field_end_date),
+                    value = draft.endDate?.toString().orEmpty(),
+                    error = errors["endDate"]?.resolve(),
+                    onValueChange = { text -> draft = draft.copy(endDate = parseLocalDateOrNull(text)) }
+                )
+            }
+            if (preferences.remindersEnabled) {
+                RuleTextField(
+                    label = stringResource(R.string.recurring_rule_field_remind_at),
+                    value = draft.remindAt,
+                    placeholder = stringResource(R.string.recurring_rule_field_remind_at_placeholder),
+                    helper = stringResource(R.string.recurring_rule_field_remind_at_helper),
+                    error = errors["remindAt"]?.resolve(),
+                    onValueChange = { draft = draft.copy(remindAt = it) }
+                )
+            }
+            SettingsToggle(
+                title = stringResource(R.string.recurring_rule_field_enable_summary),
+                subtitle = stringResource(R.string.recurring_rule_field_enable_summary_helper),
+                checked = draft.enableSummary,
+                onCheckedChange = { draft = draft.copy(enableSummary = it) }
+            )
+            AnimatedVisibility(visible = draft.enableSummary) {
+                EnumSelector(
+                    title = stringResource(R.string.recurring_rule_field_summary_channel),
+                    current = draft.summaryChannel?.name.orEmpty(),
+                    options = summaryChannelOptions,
+                    onSelected = {
+                        draft = draft.copy(summaryChannel = SummaryChannel.entries.firstOrNull { item -> item.name == it })
+                    }
+                )
+            }
+
+            SchedulePreviewCard(previewState = preview, locale = locale)
+
+            Button(
+                onClick = {
+                    val validation = validateRuleDraft(draft, preferences, rules)
+                    errors = validation
+                    if (validation.isEmpty()) {
+                        onSubmit(
+                            RecurringRuleModel(
+                                id = "rule-${System.currentTimeMillis()}",
+                                name = draft.name.trim(),
+                                cadence = draft.cadence!!,
+                                interval = draft.interval.toInt(),
+                                weekday = draft.weekday,
+                                monthDay = draft.monthDay.toIntOrNull(),
+                                startDate = draft.startDate,
+                                endDate = if (draft.hasEndDate) draft.endDate else null,
+                                remindAt = draft.remindAt.takeIf { it.isNotBlank() },
+                                summaryChannel = if (draft.enableSummary) draft.summaryChannel else null
+                            )
+                        )
+                    }
+                },
+                modifier = Modifier.fillMaxWidth(),
+                shape = MaterialTheme.shapes.medium
+            ) {
+                Text(stringResource(R.string.recurring_rule_save))
+            }
+        }
+    }
+}
+
+@Composable
+fun SchedulePreviewCard(
+    previewState: SchedulePreviewState,
+    locale: UiLocale
+) {
+    ElevatedCard(shape = MaterialTheme.shapes.large) {
+        Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+            Text(stringResource(R.string.recurring_preview_title), style = MaterialTheme.typography.titleMedium)
+            when (previewState.mode) {
+                PreviewMode.Invalid -> {
+                    Text(stringResource(R.string.recurring_preview_invalid), color = MaterialTheme.colorScheme.error)
+                }
+
+                PreviewMode.Empty -> {
+                    Text(stringResource(R.string.recurring_preview_empty), color = MaterialTheme.colorScheme.onSurfaceVariant)
+                }
+
+                PreviewMode.Ready -> {
+                    previewState.occurrences.forEachIndexed { index, date ->
+                        OutlinedCard(shape = MaterialTheme.shapes.medium) {
+                            Row(
+                                modifier = Modifier.fillMaxWidth().padding(horizontal = 14.dp, vertical = 12.dp),
+                                horizontalArrangement = Arrangement.SpaceBetween
+                            ) {
+                                Text(
+                                    if (index == 0) stringResource(R.string.recurring_preview_next) else "+$index",
+                                    fontWeight = FontWeight.SemiBold
+                                )
+                                Text(formatAbsolute(date, locale))
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}