openuispec 0.2.9 → 0.2.11

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

@@ -1,345 +0,0 @@
-package uz.rsteam.todoorbit
-
-import androidx.appcompat.app.AppCompatDelegate
-import androidx.compose.animation.Crossfade
-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.BoxWithConstraints
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.automirrored.outlined.TrendingUp
-import androidx.compose.material.icons.outlined.Checklist
-import androidx.compose.material.icons.outlined.Settings
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.NavigationBar
-import androidx.compose.material3.NavigationBarItem
-import androidx.compose.material3.NavigationRail
-import androidx.compose.material3.NavigationRailItem
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.SnackbarHost
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.material3.Surface
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.material3.TopAppBar
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.saveable.rememberSaveable
-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 androidx.core.os.LocaleListCompat
-import kotlinx.coroutines.launch
-import uz.rsteam.todoorbit.ui.theme.TodoOrbitTheme
-import java.time.LocalDate
-import java.time.LocalDateTime
-
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class, ExperimentalLayoutApi::class)
-@Composable
-fun TodoOrbitGeneratedApp() {
-    var tab by rememberSaveable { mutableStateOf(ScreenTab.Tasks) }
-    var filter by rememberSaveable { mutableStateOf(TaskFilter.All) }
-    var searchQuery by rememberSaveable { mutableStateOf("") }
-    var analyticsPeriod by rememberSaveable { mutableStateOf(AnalyticsPeriod.Week) }
-    var preferences by rememberSaveable(stateSaver = PreferencesStateSaver) { mutableStateOf(PreferencesState()) }
-    var selectedTaskId by rememberSaveable { mutableStateOf(sampleTasks().first().id) }
-    var overlay by remember { mutableStateOf<OverlayState?>(null) }
-    val snackbarHostState = remember { SnackbarHostState() }
-    val scope = rememberCoroutineScope()
-    val tasks = remember { mutableStateListOf(*sampleTasks().toTypedArray()) }
-    val recurringRules = remember { mutableStateListOf<RecurringRuleModel>() }
-    val createTaskSuccessMessage = stringResource(R.string.create_task_success)
-    val editTaskSuccessMessage = stringResource(R.string.edit_task_success)
-    val recurringRuleSuccessMessage = stringResource(R.string.recurring_rule_success)
-
-    LaunchedEffect(preferences.locale) {
-        AppCompatDelegate.setApplicationLocales(
-            LocaleListCompat.forLanguageTags(preferences.locale.toLanguageTag())
-        )
-    }
-
-    TodoOrbitTheme(darkTheme = preferences.themeMode == ThemeMode.Dark) {
-        Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
-            BoxWithConstraints {
-                val useRail = maxWidth >= 900.dp
-                val useSplitView = useRail && this@BoxWithConstraints.maxWidth >= 1200.dp
-                val visibleTasks = remember(tasks.toList(), filter, searchQuery) {
-                    tasks.filter { task ->
-                        val matchesFilter = when (filter) {
-                            TaskFilter.All -> true
-                            TaskFilter.Open -> task.status == TaskStatus.Open
-                            TaskFilter.Done -> task.status == TaskStatus.Done
-                        }
-                        val matchesSearch = listOf(task.title, task.notes).joinToString(" ").contains(searchQuery, ignoreCase = true)
-                        matchesFilter && matchesSearch
-                    }
-                }
-                val selectedTask = tasks.firstOrNull { it.id == selectedTaskId } ?: tasks.firstOrNull()
-                val overview = analyticsOverview(tasks)
-                val trendSeries = trendPoints(tasks, analyticsPeriod, preferences.locale)
-                val overdueTasks = tasks.filter { it.status == TaskStatus.Open && it.dueDate?.isBefore(LocalDate.now()) == true }
-
-                Scaffold(
-                    topBar = {
-                        TopAppBar(
-                            title = {
-                                Column {
-                                    Text(stringResource(R.string.app_name), fontWeight = FontWeight.Bold)
-                                    Text(
-                                        text = when (tab) {
-                                            ScreenTab.Tasks -> stringResource(R.string.app_path_home)
-                                            ScreenTab.Analytics -> stringResource(R.string.app_path_analytics)
-                                            ScreenTab.Settings -> stringResource(R.string.app_path_settings)
-                                        },
-                                        style = MaterialTheme.typography.labelSmall,
-                                        color = MaterialTheme.colorScheme.onSurfaceVariant
-                                    )
-                                }
-                            }
-                        )
-                    },
-                    bottomBar = {
-                        if (!useRail) {
-                            NavigationBar {
-                                NavigationBarItem(
-                                    selected = tab == ScreenTab.Tasks,
-                                    onClick = { tab = ScreenTab.Tasks },
-                                    icon = { Icon(Icons.Outlined.Checklist, contentDescription = null) },
-                                    label = { Text(stringResource(R.string.nav_tasks)) }
-                                )
-                                NavigationBarItem(
-                                    selected = tab == ScreenTab.Analytics,
-                                    onClick = { tab = ScreenTab.Analytics },
-                                    icon = { Icon(Icons.AutoMirrored.Outlined.TrendingUp, contentDescription = null) },
-                                    label = { Text(stringResource(R.string.nav_analytics)) }
-                                )
-                                NavigationBarItem(
-                                    selected = tab == ScreenTab.Settings,
-                                    onClick = { tab = ScreenTab.Settings },
-                                    icon = { Icon(Icons.Outlined.Settings, contentDescription = null) },
-                                    label = { Text(stringResource(R.string.nav_settings)) }
-                                )
-                            }
-                        }
-                    },
-                    snackbarHost = { SnackbarHost(snackbarHostState) }
-                ) { innerPadding ->
-                    Row(modifier = Modifier.fillMaxSize().padding(innerPadding)) {
-                        if (useRail) {
-                            NavigationRail(containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.45f)) {
-                                Spacer(Modifier.height(12.dp))
-                                NavigationRailItem(
-                                    selected = tab == ScreenTab.Tasks,
-                                    onClick = { tab = ScreenTab.Tasks },
-                                    icon = { Icon(Icons.Outlined.Checklist, contentDescription = null) },
-                                    label = { Text(stringResource(R.string.nav_tasks)) }
-                                )
-                                NavigationRailItem(
-                                    selected = tab == ScreenTab.Analytics,
-                                    onClick = { tab = ScreenTab.Analytics },
-                                    icon = { Icon(Icons.AutoMirrored.Outlined.TrendingUp, contentDescription = null) },
-                                    label = { Text(stringResource(R.string.nav_analytics)) }
-                                )
-                                NavigationRailItem(
-                                    selected = tab == ScreenTab.Settings,
-                                    onClick = { tab = ScreenTab.Settings },
-                                    icon = { Icon(Icons.Outlined.Settings, contentDescription = null) },
-                                    label = { Text(stringResource(R.string.nav_settings)) }
-                                )
-                            }
-                        }
-
-                        Crossfade(targetState = tab, modifier = Modifier.fillMaxSize(), label = "tab-crossfade") { activeTab ->
-                            when (activeTab) {
-                                ScreenTab.Tasks -> {
-                                    TasksScreen(
-                                        tasks = visibleTasks,
-                                        allTasks = tasks,
-                                        filter = filter,
-                                        searchQuery = searchQuery,
-                                        selectedTask = selectedTask,
-                                        locale = preferences.locale,
-                                        useSplitView = useSplitView,
-                                        onSearchChange = { searchQuery = it },
-                                        onFilterChange = { filter = it },
-                                        onSelectTask = { selectedTaskId = it.id },
-                                        onToggleTask = { task ->
-                                            val index = tasks.indexOfFirst { it.id == task.id }
-                                            if (index >= 0) {
-                                                tasks[index] = task.copy(
-                                                    status = if (task.status == TaskStatus.Done) TaskStatus.Open else TaskStatus.Done,
-                                                    updatedAt = LocalDateTime.now()
-                                                )
-                                            }
-                                        },
-                                        onCreateTask = { overlay = OverlayState.CreateTask },
-                                        onEditTask = { overlay = OverlayState.EditTask(it.id) },
-                                        onDeleteTask = {
-                                            tasks.removeAll { task -> task.id == it.id }
-                                            selectedTaskId = tasks.firstOrNull()?.id.orEmpty()
-                                        },
-                                        onMoreInfo = { overlay = OverlayState.TaskMeta(it.id) }
-                                    )
-                                }
-
-                                ScreenTab.Analytics -> {
-                                    AnalyticsScreen(
-                                        period = analyticsPeriod,
-                                        overview = overview,
-                                        trendSeries = trendSeries,
-                                        overdueTasks = overdueTasks,
-                                        onPeriodChange = { analyticsPeriod = it },
-                                        locale = preferences.locale
-                                    )
-                                }
-
-                                ScreenTab.Settings -> {
-                                    SettingsScreen(
-                                        preferences = preferences,
-                                        recurringRules = recurringRules,
-                                        onPreferencesChange = { preferences = it },
-                                        onOpenRecurringRule = { overlay = OverlayState.RecurringRule },
-                                        locale = preferences.locale
-                                    )
-                                }
-                            }
-                        }
-                    }
-                }
-
-                when (val currentOverlay = overlay) {
-                    OverlayState.CreateTask -> {
-                        TaskEditorSheet(
-                            draft = TaskDraft(),
-                            title = stringResource(R.string.create_task_title),
-                            saveLabel = stringResource(R.string.create_task_save),
-                            onDismiss = { overlay = null },
-                            onSubmit = { draft ->
-                                tasks.add(
-                                    0,
-                                    TaskModel(
-                                        id = "task-${System.currentTimeMillis()}",
-                                        title = draft.title.trim(),
-                                        notes = draft.notes.trim(),
-                                        status = TaskStatus.Open,
-                                        priority = draft.priority,
-                                        dueDate = draft.dueDate,
-                                        createdAt = LocalDateTime.now(),
-                                        updatedAt = LocalDateTime.now()
-                                    )
-                                )
-                                selectedTaskId = tasks.first().id
-                                overlay = null
-                                scope.launch {
-                                    snackbarHostState.showSnackbar(createTaskSuccessMessage)
-                                }
-                            }
-                        )
-                    }
-
-                    is OverlayState.EditTask -> {
-                        val task = tasks.firstOrNull { it.id == currentOverlay.taskId }
-                        if (task != null) {
-                            TaskEditorSheet(
-                                draft = TaskDraft(
-                                    title = task.title,
-                                    notes = task.notes,
-                                    priority = task.priority,
-                                    dueDate = task.dueDate
-                                ),
-                                title = stringResource(R.string.edit_task_title),
-                                saveLabel = stringResource(R.string.edit_task_save),
-                                onDismiss = { overlay = null },
-                                onSubmit = { draft ->
-                                    val index = tasks.indexOfFirst { it.id == task.id }
-                                    if (index >= 0) {
-                                        tasks[index] = task.copy(
-                                            title = draft.title.trim(),
-                                            notes = draft.notes.trim(),
-                                            priority = draft.priority,
-                                            dueDate = draft.dueDate,
-                                            updatedAt = LocalDateTime.now()
-                                        )
-                                    }
-                                    overlay = null
-                                    scope.launch {
-                                        snackbarHostState.showSnackbar(editTaskSuccessMessage)
-                                    }
-                                }
-                            )
-                        }
-                    }
-
-                    OverlayState.RecurringRule -> {
-                        RecurringRuleSheet(
-                            preferences = preferences,
-                            rules = recurringRules,
-                            locale = preferences.locale,
-                            onDismiss = { overlay = null },
-                            onSubmit = { rule ->
-                                recurringRules.add(0, rule)
-                                overlay = null
-                                scope.launch {
-                                    snackbarHostState.showSnackbar(recurringRuleSuccessMessage)
-                                }
-                            }
-                        )
-                    }
-
-                    is OverlayState.TaskMeta -> {
-                        val task = tasks.firstOrNull { it.id == currentOverlay.taskId }
-                        if (task != null) {
-                            AlertDialog(
-                                onDismissRequest = { overlay = null },
-                                title = { Text(stringResource(R.string.task_detail_more_info)) },
-                                text = {
-                                    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                                        LabelValue(
-                                            stringResource(R.string.task_detail_status),
-                                            stringResource(task.status.labelRes)
-                                        )
-                                        LabelValue(
-                                            stringResource(R.string.task_detail_priority),
-                                            stringResource(task.priority.labelRes)
-                                        )
-                                        LabelValue(
-                                            stringResource(R.string.task_detail_created),
-                                            formatAbsolute(task.createdAt.toLocalDate(), preferences.locale)
-                                        )
-                                        LabelValue(
-                                            stringResource(R.string.task_detail_updated),
-                                            formatAbsolute(task.updatedAt.toLocalDate(), preferences.locale)
-                                        )
-                                    }
-                                },
-                                confirmButton = {
-                                    TextButton(onClick = { overlay = null }) {
-                                        Text(stringResource(R.string.common_cancel))
-                                    }
-                                }
-                            )
-                        }
-                    }
-
-                    null -> Unit
-                }
-            }
-        }
-    }
-}

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/support/AppLogic.kt

@@ -1,231 +0,0 @@
-package uz.rsteam.todoorbit
-
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.format.DateTimeFormatter
-import java.time.format.FormatStyle
-import java.util.Locale
-import kotlin.math.roundToInt
-
-data class AnalyticsOverview(
-    val completedToday: Int,
-    val openTasks: Int,
-    val overdueTasks: Int,
-    val completionRate: Int
-)
-
-fun analyticsOverview(tasks: List<TaskModel>): AnalyticsOverview {
-    val today = LocalDate.now()
-    val completedToday = tasks.count { it.status == TaskStatus.Done && it.updatedAt.toLocalDate() == today }
-    val openTasks = tasks.count { it.status == TaskStatus.Open }
-    val overdueTasks = tasks.count { it.status == TaskStatus.Open && it.dueDate?.isBefore(today) == true }
-    val completionRate = if (tasks.isEmpty()) 0 else (((tasks.size - openTasks).toFloat() / tasks.size) * 100f).roundToInt()
-    return AnalyticsOverview(completedToday, openTasks, overdueTasks, completionRate)
-}
-
-fun trendPoints(tasks: List<TaskModel>, period: AnalyticsPeriod, locale: UiLocale): List<TrendPoint> {
-    val length = when (period) {
-        AnalyticsPeriod.Week -> 7
-        AnalyticsPeriod.Month -> 6
-        AnalyticsPeriod.Quarter -> 8
-    }
-    val formatter = when (locale) {
-        UiLocale.En -> DateTimeFormatter.ofPattern(if (period == AnalyticsPeriod.Week) "EEE" else "MMM d", Locale.ENGLISH)
-        UiLocale.Ru -> DateTimeFormatter.ofPattern(if (period == AnalyticsPeriod.Week) "EEE" else "d MMM", Locale("ru"))
-    }
-    val today = LocalDate.now()
-    return (0 until length).map { index ->
-        val cursor = today.minusDays(((length - index - 1) * if (period == AnalyticsPeriod.Week) 1 else 5).toLong())
-        TrendPoint(
-            label = cursor.format(formatter),
-            completed = tasks.count { it.status == TaskStatus.Done && !it.updatedAt.toLocalDate().isAfter(cursor) },
-            created = tasks.count { !it.createdAt.toLocalDate().isAfter(cursor) }
-        )
-    }
-}
-
-fun validateRuleDraft(
-    draft: RuleDraft,
-    preferences: PreferencesState,
-    rules: List<RecurringRuleModel>
-): Map<String, UiText> {
-    val errors = mutableMapOf<String, UiText>()
-    val trimmedName = draft.name.trim()
-    if (trimmedName.length < 4) {
-        errors["name"] = UiText.Resource(R.string.validation_rule_name_min_length, listOf(4))
-    } else if (trimmedName == "Default") {
-        errors["name"] = UiText.Resource(R.string.validation_rule_name_reserved)
-    } else if (rules.any { it.name.equals(trimmedName, ignoreCase = true) }) {
-        errors["name"] = UiText.Resource(R.string.validation_rule_name_taken)
-    }
-
-    if (draft.confirmName.trim() != trimmedName) {
-        errors["confirmName"] = UiText.Resource(R.string.validation_match_field)
-    }
-
-    val interval = draft.interval.toIntOrNull()
-    when {
-        interval == null || interval < 1 -> errors["interval"] = UiText.Resource(R.string.validation_min_value, listOf(1))
-        interval > 30 -> errors["interval"] = UiText.Resource(R.string.validation_max_value, listOf(30))
-    }
-
-    if (draft.cadence == null) {
-        errors["cadence"] = UiText.Resource(R.string.validation_fix_errors)
-    }
-
-    if (draft.cadence == Cadence.Weekly && draft.weekday == null) {
-        errors["weekday"] = UiText.Resource(R.string.validation_fix_errors)
-    }
-
-    if (draft.cadence == Cadence.Monthly) {
-        val monthDay = draft.monthDay.toIntOrNull()
-        when {
-            monthDay == null || monthDay < 1 -> errors["monthDay"] = UiText.Resource(R.string.validation_min_value, listOf(1))
-            monthDay > 28 -> errors["monthDay"] = UiText.Resource(R.string.validation_month_day_max)
-        }
-    }
-
-    if (draft.hasEndDate && draft.endDate != null && draft.endDate.isBefore(draft.startDate)) {
-        errors["endDate"] = UiText.Resource(R.string.validation_end_date_after_start)
-    }
-
-    if (preferences.remindersEnabled && !Regex("^([01]\\d|2[0-3]):[0-5]\\d$").matches(draft.remindAt)) {
-        errors["remindAt"] = UiText.Resource(R.string.validation_time_format)
-    }
-
-    if (draft.enableSummary && draft.summaryChannel == null) {
-        errors["summaryChannel"] = UiText.Resource(R.string.validation_fix_errors)
-    }
-
-    return errors
-}
-
-fun schedulePreview(draft: RuleDraft): SchedulePreviewState {
-    val interval = draft.interval.toIntOrNull() ?: return SchedulePreviewState(PreviewMode.Invalid)
-    val cadence = draft.cadence ?: return SchedulePreviewState(PreviewMode.Invalid)
-    if (interval < 1) return SchedulePreviewState(PreviewMode.Invalid)
-    if (draft.hasEndDate && draft.endDate != null && draft.endDate.isBefore(draft.startDate)) {
-        return SchedulePreviewState(PreviewMode.Invalid)
-    }
-    if (cadence == Cadence.Weekly && draft.weekday == null) return SchedulePreviewState(PreviewMode.Invalid)
-    val monthlyDay = if (cadence == Cadence.Monthly) draft.monthDay.toIntOrNull() ?: return SchedulePreviewState(PreviewMode.Invalid) else null
-
-    val result = mutableListOf<LocalDate>()
-    var cursor = draft.startDate
-    repeat(4) {
-        val next = when (cadence) {
-            Cadence.Daily -> cursor
-            Cadence.Weekly -> nextWeekdayFrom(cursor, draft.weekday!!)
-            Cadence.Monthly -> nextMonthlyFrom(cursor, monthlyDay!!)
-        }
-        if (draft.endDate != null && next.isAfter(draft.endDate)) return@repeat
-        result += next
-        cursor = when (cadence) {
-            Cadence.Daily -> next.plusDays(interval.toLong())
-            Cadence.Weekly -> next.plusWeeks(interval.toLong())
-            Cadence.Monthly -> next.plusMonths(interval.toLong())
-        }
-    }
-
-    return if (result.isEmpty()) SchedulePreviewState(PreviewMode.Empty) else SchedulePreviewState(PreviewMode.Ready, result)
-}
-
-fun formatAbsolute(date: LocalDate, locale: UiLocale): String {
-    val formatter = when (locale) {
-        UiLocale.En -> DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(Locale.ENGLISH)
-        UiLocale.Ru -> DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(Locale("ru"))
-    }
-    return formatter.format(date)
-}
-
-fun parseLocalDateOrNull(value: String): LocalDate? {
-    return runCatching {
-        value.takeIf(String::isNotBlank)?.let(LocalDate::parse)
-    }.getOrNull()
-}
-
-private fun nextWeekdayFrom(date: LocalDate, weekday: Weekday): LocalDate {
-    var cursor = date
-    while (cursor.dayOfWeek.value != weekdayToDayNumber(weekday)) {
-        cursor = cursor.plusDays(1)
-    }
-    return cursor
-}
-
-private fun nextMonthlyFrom(date: LocalDate, day: Int): LocalDate {
-    val base = date.withDayOfMonth(1)
-    val candidate = base.withDayOfMonth(day.coerceAtMost(base.lengthOfMonth()))
-    return if (candidate.isBefore(date)) {
-        base.plusMonths(1).withDayOfMonth(day.coerceAtMost(base.plusMonths(1).lengthOfMonth()))
-    } else {
-        candidate
-    }
-}
-
-private fun weekdayToDayNumber(weekday: Weekday): Int {
-    return when (weekday) {
-        Weekday.Mon -> 1
-        Weekday.Tue -> 2
-        Weekday.Wed -> 3
-        Weekday.Thu -> 4
-        Weekday.Fri -> 5
-        Weekday.Sat -> 6
-        Weekday.Sun -> 7
-    }
-}
-
-fun sampleTasks(): List<TaskModel> {
-    val now = LocalDateTime.now()
-    return listOf(
-        TaskModel(
-            id = "task-1",
-            title = "Prepare bilingual launch notes",
-            notes = "Document the web, iOS, and Android behavior differences before review.",
-            status = TaskStatus.Open,
-            priority = Priority.High,
-            dueDate = LocalDate.now().plusDays(2),
-            createdAt = now.minusDays(6),
-            updatedAt = now.minusDays(1)
-        ),
-        TaskModel(
-            id = "task-2",
-            title = "Review recurring-rule validation",
-            notes = "Confirm async uniqueness checks and cross-field constraints.",
-            status = TaskStatus.Done,
-            priority = Priority.Medium,
-            dueDate = LocalDate.now().minusDays(1),
-            createdAt = now.minusDays(5),
-            updatedAt = now
-        ),
-        TaskModel(
-            id = "task-3",
-            title = "Polish analytics empty states",
-            notes = "Ensure chart and overdue list degrade gracefully on zero-data snapshots.",
-            status = TaskStatus.Open,
-            priority = Priority.Medium,
-            dueDate = LocalDate.now().plusDays(5),
-            createdAt = now.minusDays(4),
-            updatedAt = now.minusDays(2)
-        ),
-        TaskModel(
-            id = "task-4",
-            title = "Regenerate drift snapshots",
-            notes = "Refresh ios, android, and web state after spec edits.",
-            status = TaskStatus.Open,
-            priority = Priority.Low,
-            dueDate = LocalDate.now().minusDays(3),
-            createdAt = now.minusDays(3),
-            updatedAt = now.minusDays(3)
-        ),
-        TaskModel(
-            id = "task-5",
-            title = "Prototype schedule preview contract",
-            notes = "Use derived occurrences to prove custom-contract generation.",
-            status = TaskStatus.Done,
-            priority = Priority.High,
-            dueDate = LocalDate.now().plusDays(1),
-            createdAt = now.minusDays(8),
-            updatedAt = now.minusDays(1)
-        )
-    )
-}