openuispec 0.2.10 → 0.2.12

package/examples/todo-orbit/generated/ios/Todo Orbit/Sources/TodoOrbit/Screens/TasksHomeView.swift

@@ -1,364 +0,0 @@
-import SwiftUI
-
-struct TasksHomeView: View {
-    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
-    @ObservedObject var model: AppModel
-    @State private var searchQuery = ""
-    @State private var filter: TaskFilter = .all
-    @State private var taskSheetMode: TaskSheetMode?
-    @State private var showDeleteDialog = false
-    @State private var showMetaSheet = false
-
-    var body: some View {
-        Group {
-            if horizontalSizeClass == .compact {
-                compactLayout
-            } else {
-                splitLayout
-            }
-        }
-        .sheet(item: $taskSheetMode) { mode in
-            switch mode {
-            case .create:
-                TaskEditorSheet(model: model, editingTaskID: nil)
-            case .edit(let id):
-                TaskEditorSheet(model: model, editingTaskID: id)
-            }
-        }
-        .sheet(isPresented: $showMetaSheet) {
-            if let taskID = model.selectedTaskID {
-                TaskMetaSheet(model: model, taskID: taskID)
-            }
-        }
-        .confirmationDialog(
-            model.string("task_detail.delete_title"),
-            isPresented: $showDeleteDialog,
-            titleVisibility: .visible
-        ) {
-            Button(model.string("common.delete"), role: .destructive) {
-                if let taskID = model.selectedTaskID {
-                    model.deleteTask(taskID)
-                }
-            }
-            Button(model.string("common.cancel"), role: .cancel) {}
-        } message: {
-            Text(model.string("task_detail.delete_message"))
-        }
-    }
-
-    private var splitLayout: some View {
-        NavigationSplitView {
-            tasksCanvas(selectionMode: .split)
-                .navigationTitle(model.string("nav.tasks"))
-        } detail: {
-            if let task = model.task(id: model.selectedTaskID) {
-                TaskDetailPanel(
-                    model: model,
-                    task: task,
-                    onEdit: { taskSheetMode = .edit(task.id) },
-                    onMeta: { showMetaSheet = true },
-                    onDelete: { showDeleteDialog = true }
-                )
-            } else {
-                ContentUnavailableView(model.string("home.empty_title"), systemImage: "checkmark.circle")
-            }
-        }
-    }
-
-    private var compactLayout: some View {
-        tasksCanvas(selectionMode: .compact)
-            .navigationTitle(model.string("nav.tasks"))
-    }
-
-    private enum SelectionMode {
-        case compact
-        case split
-    }
-
-    private func tasksCanvas(selectionMode: SelectionMode) -> some View {
-        ScrollView {
-            VStack(alignment: .leading, spacing: 18) {
-                taskHeader
-                searchField
-                filterChips
-                taskListContent(selectionMode: selectionMode)
-            }
-            .padding(.horizontal, horizontalSizeClass == .compact ? 16 : 20)
-            .padding(.top, 12)
-            .padding(.bottom, 104)
-        }
-        .background(Color(uiColor: .systemGroupedBackground).ignoresSafeArea())
-        .overlay(alignment: .bottomTrailing) {
-            createButton
-                .padding(.trailing, horizontalSizeClass == .compact ? 18 : 24)
-                .padding(.bottom, horizontalSizeClass == .compact ? 20 : 24)
-        }
-    }
-
-    private var taskHeader: some View {
-        VStack(alignment: .leading, spacing: 6) {
-            Text(model.string("home.title"))
-                .font(.largeTitle.weight(.bold))
-            Text(model.homeSummary())
-                .foregroundStyle(.secondary)
-        }
-    }
-
-    private var searchField: some View {
-        HStack(spacing: 12) {
-            Image(systemName: "magnifyingglass")
-                .foregroundStyle(.secondary)
-
-            TextField(model.string("home.search_placeholder"), text: $searchQuery)
-                .textFieldStyle(.plain)
-
-            if !searchQuery.isEmpty {
-                Button {
-                    searchQuery = ""
-                } label: {
-                    Image(systemName: "xmark.circle.fill")
-                        .foregroundStyle(.secondary)
-                }
-                .buttonStyle(.plain)
-            }
-        }
-        .orbitInputShell(
-            fill: Color(uiColor: .systemBackground),
-            stroke: Color.teal.opacity(0.3),
-            lineWidth: 1.5
-        )
-    }
-
-    private var filterChips: some View {
-        ScrollView(.horizontal, showsIndicators: false) {
-            HStack(spacing: 10) {
-                ForEach(TaskFilter.allCases) { item in
-                    Button {
-                        filter = item
-                    } label: {
-                        Text("\(model.string("home.filter_\(item.rawValue)")) (\(model.taskCount(for: item)))")
-                    }
-                    .buttonStyle(OrbitChipButtonStyle(selected: filter == item))
-                }
-            }
-        }
-    }
-
-    @ViewBuilder
-    private func taskListContent(selectionMode: SelectionMode) -> some View {
-        let filtered = model.filteredTasks(filter: filter, search: searchQuery)
-
-        if filtered.isEmpty {
-            ContentUnavailableView(
-                model.string("home.empty_title"),
-                systemImage: "checkmark.circle"
-            )
-            .frame(maxWidth: .infinity, minHeight: 220)
-        } else {
-            LazyVStack(spacing: 12) {
-                ForEach(filtered) { task in
-                    taskRowCard(task, selectionMode: selectionMode)
-                }
-            }
-        }
-    }
-
-    @ViewBuilder
-    private func taskRowCard(_ task: Task, selectionMode: SelectionMode) -> some View {
-        let selected = selectionMode == .split && model.selectedTaskID == task.id
-        let card = taskRow(task, selected: selected)
-
-        switch selectionMode {
-        case .compact:
-            NavigationLink {
-                TaskDetailPanel(
-                    model: model,
-                    task: task,
-                    onEdit: { taskSheetMode = .edit(task.id) },
-                    onMeta: {
-                        model.selectedTaskID = task.id
-                        showMetaSheet = true
-                    },
-                    onDelete: {
-                        model.selectedTaskID = task.id
-                        showDeleteDialog = true
-                    }
-                )
-            } label: {
-                card
-            }
-            .buttonStyle(.plain)
-        case .split:
-            Button {
-                model.selectedTaskID = task.id
-            } label: {
-                card
-            }
-            .buttonStyle(.plain)
-        }
-    }
-
-    private func taskRow(_ task: Task, selected: Bool) -> some View {
-        HStack(spacing: 12) {
-            Button {
-                model.toggleTaskStatus(task.id)
-            } label: {
-                Image(systemName: task.status == .done ? "checkmark.circle.fill" : "circle")
-                    .font(.title3)
-                    .foregroundStyle(task.status == .done ? Color.green : Color.secondary)
-            }
-            .buttonStyle(.plain)
-
-            VStack(alignment: .leading, spacing: 4) {
-                Text(task.title)
-                    .font(.headline)
-                    .foregroundStyle(.primary)
-                    .multilineTextAlignment(.leading)
-                Text(model.formatRelativeDueDate(task.dueDate))
-                    .font(.subheadline)
-                    .foregroundStyle(.secondary)
-            }
-
-            Spacer(minLength: 12)
-            PriorityDot(priority: task.priority)
-
-            if horizontalSizeClass == .compact {
-                Image(systemName: "chevron.right")
-                    .font(.footnote.weight(.bold))
-                    .foregroundStyle(.tertiary)
-            }
-        }
-        .frame(maxWidth: .infinity, alignment: .leading)
-        .orbitSurface(
-            cut: 14,
-            fill: selected ? Color.teal.opacity(0.12) : Color(uiColor: .systemBackground),
-            stroke: selected ? Color.teal.opacity(0.34) : Color(uiColor: .separator).opacity(0.28),
-            lineWidth: selected ? 1.5 : 1,
-            contentPadding: 16
-        )
-    }
-
-    private var createButton: some View {
-        Button {
-            taskSheetMode = .create
-        } label: {
-            Label(model.string("home.new_task"), systemImage: "plus")
-        }
-        .buttonStyle(OrbitFloatingActionButtonStyle())
-    }
-}
-
-private enum TaskSheetMode: Identifiable {
-    case create
-    case edit(UUID)
-
-    var id: String {
-        switch self {
-        case .create: "create"
-        case .edit(let id): "edit-\(id.uuidString)"
-        }
-    }
-}
-
-private struct TaskDetailPanel: View {
-    @ObservedObject var model: AppModel
-    let task: Task
-    let onEdit: () -> Void
-    let onMeta: () -> Void
-    let onDelete: () -> Void
-
-    var body: some View {
-        ScrollView {
-            VStack(alignment: .leading, spacing: 18) {
-                VStack(alignment: .leading, spacing: 8) {
-                    Text(task.title)
-                        .font(.largeTitle.weight(.bold))
-                    Text(model.formatDate(task.dueDate))
-                        .foregroundStyle(.secondary)
-                    Label(model.label(for: task.status), systemImage: task.status == .done ? "checkmark.circle.fill" : "circle")
-                        .foregroundStyle(task.status == .done ? .green : .blue)
-                }
-                .orbitCard(fill: Color(uiColor: .systemBackground), stroke: task.priority.tint.opacity(0.25))
-
-                LazyVGrid(columns: [.init(.flexible()), .init(.flexible())], spacing: 12) {
-                    stat(model.string("task_detail.status"), value: model.label(for: task.status))
-                    stat(model.string("task_detail.priority"), value: model.label(for: task.priority))
-                    stat(model.string("task_detail.created"), value: model.formatDate(task.createdAt))
-                    stat(model.string("task_detail.updated"), value: model.formatDate(task.updatedAt))
-                }
-
-                if !task.notes.isEmpty {
-                    VStack(alignment: .leading, spacing: 10) {
-                        Text(model.string("task_detail.notes"))
-                            .font(.headline)
-                        Text(task.notes)
-                            .foregroundStyle(.secondary)
-                    }
-                    .orbitCard()
-                }
-
-                VStack(spacing: 12) {
-                    Button(model.string("task_detail.edit"), action: onEdit)
-                        .buttonStyle(OrbitPrimaryButtonStyle())
-                    Button(model.string("task_detail.toggle_status")) {
-                        model.toggleTaskStatus(task.id)
-                    }
-                    .buttonStyle(OrbitGhostButtonStyle())
-                    Button(model.string("task_detail.more_info"), action: onMeta)
-                        .buttonStyle(OrbitGhostButtonStyle())
-                    Button(model.string("task_detail.delete"), role: .destructive, action: onDelete)
-                        .buttonStyle(OrbitGhostButtonStyle())
-                }
-            }
-            .padding()
-        }
-        .navigationTitle(model.string("task_detail.title"))
-    }
-
-    private func stat(_ title: String, value: String) -> some View {
-        VStack(alignment: .leading, spacing: 10) {
-            Text(title)
-                .font(.caption.weight(.semibold))
-                .foregroundStyle(.secondary)
-            Text(value)
-                .font(.title3.weight(.bold))
-        }
-        .frame(maxWidth: .infinity, alignment: .leading)
-        .orbitCard()
-    }
-}
-
-private struct TaskMetaSheet: View {
-    @Environment(\.dismiss) private var dismiss
-    @ObservedObject var model: AppModel
-    let taskID: UUID
-
-    var body: some View {
-        NavigationStack {
-            if let task = model.task(id: taskID) {
-                List {
-                    row(model.string("task_detail.status"), model.label(for: task.status))
-                    row(model.string("task_detail.priority"), model.label(for: task.priority))
-                    row(model.string("task_detail.created"), model.formatDate(task.createdAt))
-                    row(model.string("task_detail.updated"), model.formatDate(task.updatedAt))
-                }
-                .navigationTitle(model.string("task_detail.more_info"))
-                .toolbar {
-                    ToolbarItem(placement: .topBarTrailing) {
-                        Button(model.string("common.cancel")) { dismiss() }
-                    }
-                }
-            }
-        }
-        .presentationDetents([.medium])
-    }
-
-    private func row(_ title: String, _ value: String) -> some View {
-        HStack {
-            Text(title)
-            Spacer()
-            Text(value)
-                .foregroundStyle(.secondary)
-        }
-    }
-}

package/examples/todo-orbit/generated/ios/Todo Orbit/Sources/TodoOrbit/Support/AppModel.swift

@@ -1,324 +0,0 @@
-import Foundation
-import SwiftUI
-
-@MainActor
-final class AppModel: ObservableObject {
-    @Published var preferences = Preferences(
-        locale: .en,
-        theme: .light,
-        remindersEnabled: true,
-        dailySummaryEnabled: false
-    )
-    @Published var tasks: [Task] = Task.seed()
-    @Published var rules: [RecurringRule] = []
-    @Published var selectedTaskID: UUID?
-    @Published var toast: ToastMessage?
-
-    init() {
-        selectedTaskID = tasks.first?.id
-    }
-
-    var locale: Locale { Locale(identifier: preferences.locale.rawValue) }
-
-    func string(_ key: String) -> String {
-        let bundle = Bundle.main.path(
-            forResource: preferences.locale.rawValue,
-            ofType: "lproj"
-        ).flatMap { Bundle(path: $0) } ?? .main
-        return bundle.localizedString(forKey: key, value: key, table: nil)
-    }
-
-    func format(_ key: String, _ arguments: CVarArg...) -> String {
-        let format = string(key)
-        return String(format: format, locale: locale, arguments: arguments)
-    }
-
-    func homeSummary() -> String {
-        let open = tasks.filter { $0.status == .open }.count
-        let total = tasks.count
-        if preferences.locale == .ru {
-            if open == 0 { return string("home.summary.done") }
-            return format("home.summary.remaining", open, total)
-        }
-
-        if open == 0 { return string("home.summary.done") }
-        return format("home.summary.remaining", open, total)
-    }
-
-    func taskCount(for filter: TaskFilter) -> Int {
-        switch filter {
-        case .all:
-            return tasks.count
-        case .open:
-            return tasks.filter { $0.status == .open }.count
-        case .done:
-            return tasks.filter { $0.status == .done }.count
-        }
-    }
-
-    func filteredTasks(filter: TaskFilter, search: String) -> [Task] {
-        tasks.filter { task in
-            let matchesFilter: Bool
-            switch filter {
-            case .all: matchesFilter = true
-            case .open: matchesFilter = task.status == .open
-            case .done: matchesFilter = task.status == .done
-            }
-
-            let query = search.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
-            let matchesSearch = query.isEmpty || "\(task.title) \(task.notes)".lowercased().contains(query)
-            return matchesFilter && matchesSearch
-        }
-    }
-
-    func task(id: UUID?) -> Task? {
-        guard let id else { return nil }
-        return tasks.first(where: { $0.id == id })
-    }
-
-    func binding(for taskID: UUID) -> Binding<Task>? {
-        guard let index = tasks.firstIndex(where: { $0.id == taskID }) else { return nil }
-        return Binding(
-            get: { self.tasks[index] },
-            set: { self.tasks[index] = $0 }
-        )
-    }
-
-    func savePreferences(_ draft: Preferences) {
-        preferences = draft
-        showToast(level: .success, text: string("settings.saved"))
-    }
-
-    func makeTaskDraft(for task: Task?) -> TaskEditorDraft {
-        TaskEditorDraft(
-            title: task?.title ?? "",
-            notes: task?.notes ?? "",
-            priority: task?.priority ?? .medium,
-            dueDate: task?.dueDate
-        )
-    }
-
-    func submitTask(_ draft: TaskEditorDraft, editing taskID: UUID?) -> String? {
-        let title = draft.title.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard title.count >= 2 else {
-            return format("validation.min_length", 2)
-        }
-
-        if let taskID, let index = tasks.firstIndex(where: { $0.id == taskID }) {
-            tasks[index].title = title
-            tasks[index].notes = draft.notes.trimmingCharacters(in: .whitespacesAndNewlines)
-            tasks[index].priority = draft.priority
-            tasks[index].dueDate = draft.dueDate
-            tasks[index].updatedAt = .now
-            showToast(level: .success, text: string("edit_task.success"))
-        } else {
-            let next = Task(
-                id: UUID(),
-                title: title,
-                notes: draft.notes.trimmingCharacters(in: .whitespacesAndNewlines),
-                status: .open,
-                priority: draft.priority,
-                dueDate: draft.dueDate,
-                createdAt: .now,
-                updatedAt: .now
-            )
-            tasks.insert(next, at: 0)
-            selectedTaskID = next.id
-            showToast(level: .success, text: string("create_task.success"))
-        }
-
-        return nil
-    }
-
-    func toggleTaskStatus(_ taskID: UUID) {
-        guard let index = tasks.firstIndex(where: { $0.id == taskID }) else { return }
-        tasks[index].status = tasks[index].status == .done ? .open : .done
-        tasks[index].updatedAt = .now
-        showToast(level: .success, text: string("task_detail.updated_feedback"))
-    }
-
-    func deleteTask(_ taskID: UUID) {
-        tasks.removeAll { $0.id == taskID }
-        if selectedTaskID == taskID {
-            selectedTaskID = tasks.first?.id
-        }
-        showToast(level: .success, text: string("task_detail.deleted_feedback"))
-    }
-
-    func addRecurringRule(from draft: RecurringRuleDraft) -> [String: String] {
-        var errors: [String: String] = [:]
-
-        let trimmedName = draft.name.trimmingCharacters(in: .whitespacesAndNewlines)
-        if trimmedName.count < 4 {
-            errors["name"] = format("validation.rule_name_min_length", 4)
-        } else if trimmedName == "Default" {
-            errors["name"] = string("validation.rule_name_reserved")
-        } else if rules.contains(where: { $0.name.caseInsensitiveCompare(trimmedName) == .orderedSame }) {
-            errors["name"] = string("validation.rule_name_taken")
-        }
-
-        if draft.confirmName.trimmingCharacters(in: .whitespacesAndNewlines) != trimmedName {
-            errors["confirmName"] = string("validation.match_field")
-        }
-
-        guard let cadence = draft.cadence else {
-            errors["cadence"] = string("validation.required")
-            return errors
-        }
-
-        guard let interval = Int(draft.interval), interval >= 1 else {
-            errors["interval"] = format("validation.min_value", 1)
-            return errors
-        }
-
-        if interval > 30 {
-            errors["interval"] = format("validation.max_value", 30)
-        }
-
-        if cadence == .weekly, draft.weekday == nil {
-            errors["weekday"] = string("validation.required")
-        }
-
-        var monthDayValue: Int?
-        if cadence == .monthly {
-            guard let day = Int(draft.monthDay), day >= 1 else {
-                errors["monthDay"] = format("validation.min_value", 1)
-                return errors
-            }
-            if day > 28 {
-                errors["monthDay"] = string("validation.month_day_max")
-            } else {
-                monthDayValue = day
-            }
-        }
-
-        if draft.hasEndDate && draft.endDate < draft.startDate {
-            errors["endDate"] = string("validation.end_date_after_start")
-        }
-
-        if preferences.remindersEnabled {
-            let regex = try? NSRegularExpression(pattern: "^([01]\\d|2[0-3]):[0-5]\\d$")
-            let range = NSRange(location: 0, length: draft.remindAt.utf16.count)
-            let matches = regex?.firstMatch(in: draft.remindAt, options: [], range: range) != nil
-            if !matches {
-                errors["remindAt"] = string("validation.time_format")
-            }
-        }
-
-        if draft.enableSummary && draft.summaryChannel == nil {
-            errors["summaryChannel"] = string("validation.required")
-        }
-
-        guard errors.isEmpty else { return errors }
-
-        let rule = RecurringRule(
-            id: UUID(),
-            name: trimmedName,
-            cadence: cadence,
-            interval: interval,
-            weekday: draft.weekday,
-            monthDay: monthDayValue,
-            startDate: draft.startDate,
-            endDate: draft.hasEndDate ? draft.endDate : nil,
-            remindAt: preferences.remindersEnabled ? draft.remindAt : nil,
-            summaryChannel: draft.enableSummary ? draft.summaryChannel : nil
-        )
-        rules.insert(rule, at: 0)
-        showToast(level: .success, text: string("recurring_rule.success"))
-        return [:]
-    }
-
-    func analyticsSnapshot() -> AnalyticsSnapshot {
-        let calendar = Calendar.current
-        let startOfToday = calendar.startOfDay(for: .now)
-        let completedToday = tasks.filter {
-            $0.status == .done && $0.updatedAt >= startOfToday
-        }.count
-        let openTasks = tasks.filter { $0.status == .open }.count
-        let overdueTasks = overdueTasks().count
-        let completionRate = tasks.isEmpty ? 0 : Int(((Double(tasks.count - openTasks) / Double(tasks.count)) * 100).rounded())
-        return AnalyticsSnapshot(
-            completedToday: completedToday,
-            openTasks: openTasks,
-            overdueTasks: overdueTasks,
-            completionRate: completionRate
-        )
-    }
-
-    func trendSeries(period: AnalyticsPeriod) -> [TrendPoint] {
-        let calendar = Calendar.current
-        let formatter = DateFormatter()
-        formatter.locale = locale
-        formatter.dateFormat = period == .week ? "E" : "MMM d"
-        let length: Int = switch period {
-        case .week: 7
-        case .month: 6
-        case .quarter: 8
-        }
-        let strideDays: Int = period == .week ? 1 : 5
-
-        return (0..<length).map { index in
-            let offset = length - index - 1
-            let pointDate = calendar.date(byAdding: .day, value: -(offset * strideDays), to: .now) ?? .now
-            let completed = tasks.filter { $0.status == .done && $0.updatedAt <= pointDate }.count
-            let created = tasks.filter { $0.createdAt <= pointDate }.count
-            return TrendPoint(label: formatter.string(from: pointDate), completed: completed, created: created)
-        }
-    }
-
-    func overdueTasks() -> [Task] {
-        let startOfToday = Calendar.current.startOfDay(for: .now)
-        return tasks.filter { task in
-            task.status == .open && (task.dueDate.map { $0 < startOfToday } ?? false)
-        }
-    }
-
-    func formatDate(_ date: Date?) -> String {
-        guard let date else { return string("task_detail.no_due_date") }
-        let formatter = DateFormatter()
-        formatter.locale = locale
-        formatter.dateStyle = .medium
-        formatter.timeStyle = .none
-        return formatter.string(from: date)
-    }
-
-    func formatRelativeDueDate(_ date: Date?) -> String {
-        guard let date else { return string("task_detail.no_due_date") }
-        let formatter = RelativeDateTimeFormatter()
-        formatter.locale = locale
-        formatter.unitsStyle = .abbreviated
-        return formatter.localizedString(for: date, relativeTo: .now)
-    }
-
-    func label(for priority: TaskPriority) -> String { string("priority.\(priority.rawValue)") }
-    func label(for status: TaskStatus) -> String { string("status.\(status.rawValue)") }
-    func label(for weekday: Weekday) -> String { string("weekday.\(weekday.rawValue)") }
-
-    func describe(rule: RecurringRule) -> String {
-        switch rule.cadence {
-        case .daily:
-            return "\(string("recurring_rule.cadence_daily")) · \(formatDate(rule.startDate))"
-        case .weekly:
-            return "\(string("recurring_rule.cadence_weekly")) · \(label(for: rule.weekday ?? .mon))"
-        case .monthly:
-            return "\(string("recurring_rule.cadence_monthly")) · \(rule.monthDay ?? 1)"
-        }
-    }
-
-    func showToast(level: ToastMessage.Level, text: String) {
-        withAnimation(.spring(duration: 0.32)) {
-            toast = ToastMessage(level: level, text: text)
-        }
-
-        _Concurrency.Task { [weak self] in
-            try? await _Concurrency.Task.sleep(for: .seconds(2.5))
-            guard let self else { return }
-            await MainActor.run {
-                withAnimation(.easeOut(duration: 0.2)) {
-                    self.toast = nil
-                }
-            }
-        }
-    }
-
-}