openuispec 0.1.18 → 0.1.20

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

@@ -0,0 +1,94 @@
+import SwiftUI
+
+struct AnalyticsView: View {
+    @ObservedObject var model: AppModel
+    @State private var period: AnalyticsPeriod = .week
+
+    private let grid = [
+        GridItem(.flexible(), spacing: 12),
+        GridItem(.flexible(), spacing: 12)
+    ]
+
+    var body: some View {
+        let snapshot = model.analyticsSnapshot()
+        let points = model.trendSeries(period: period)
+        let overdue = model.overdueTasks()
+
+        ScrollView {
+            VStack(alignment: .leading, spacing: 18) {
+                VStack(alignment: .leading, spacing: 6) {
+                    Text(model.string("analytics.title"))
+                        .font(.largeTitle.weight(.bold))
+                    Text(model.string("analytics.subtitle"))
+                        .foregroundStyle(.secondary)
+                }
+
+                Picker("Period", selection: $period) {
+                    ForEach(AnalyticsPeriod.allCases) { period in
+                        Text(model.string("analytics.period_\(period.rawValue)")).tag(period)
+                    }
+                }
+                .pickerStyle(.segmented)
+
+                LazyVGrid(columns: grid, spacing: 12) {
+                    statCard(model.string("analytics.completed_today"), value: "\(snapshot.completedToday)")
+                    statCard(model.string("analytics.open_tasks"), value: "\(snapshot.openTasks)")
+                    statCard(model.string("analytics.overdue_tasks"), value: "\(snapshot.overdueTasks)")
+                    statCard(model.string("analytics.completion_rate"), value: "\(snapshot.completionRate)%")
+                }
+
+                TrendChartView(
+                    title: model.string("analytics.title"),
+                    subtitle: model.string("analytics.trend_subtitle"),
+                    emptyMessage: model.string("analytics.empty_trend"),
+                    legendCompleted: model.string("analytics.legend_completed"),
+                    legendCreated: model.string("analytics.legend_created"),
+                    points: points
+                )
+
+                VStack(alignment: .leading, spacing: 14) {
+                    Text(model.string("analytics.overdue_section"))
+                        .font(.title3.weight(.semibold))
+                    Text(model.string("analytics.overdue_subtitle"))
+                        .foregroundStyle(.secondary)
+
+                    if overdue.isEmpty {
+                        Text(model.string("analytics.empty_overdue_body"))
+                            .foregroundStyle(.secondary)
+                    } else {
+                        ForEach(overdue) { task in
+                            HStack {
+                                VStack(alignment: .leading, spacing: 4) {
+                                    Text(task.title)
+                                        .font(.headline)
+                                    Text(model.label(for: task.priority))
+                                        .foregroundStyle(.secondary)
+                                }
+                                Spacer()
+                                Text(model.formatDate(task.dueDate))
+                                    .font(.subheadline.weight(.semibold))
+                            }
+                            .padding(.vertical, 10)
+                            Divider()
+                        }
+                    }
+                }
+                .orbitCard()
+            }
+            .padding()
+        }
+        .navigationTitle(model.string("nav.analytics"))
+    }
+
+    private func statCard(_ title: String, value: String) -> some View {
+        VStack(alignment: .leading, spacing: 10) {
+            Text(title)
+                .font(.caption.weight(.semibold))
+                .foregroundStyle(.secondary)
+            Text(value)
+                .font(.title.weight(.bold))
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .orbitCard()
+    }
+}

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

@@ -0,0 +1,74 @@
+import SwiftUI
+
+struct SettingsView: View {
+    @ObservedObject var model: AppModel
+    @State private var draft = Preferences(locale: .en, theme: .light, remindersEnabled: true, dailySummaryEnabled: false)
+    @State private var showRecurringSheet = false
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 18) {
+                VStack(alignment: .leading, spacing: 6) {
+                    Text(model.string("settings.title"))
+                        .font(.largeTitle.weight(.bold))
+                    Text(model.string("settings.subtitle"))
+                        .foregroundStyle(.secondary)
+                }
+
+                VStack(spacing: 14) {
+                    Picker(model.string("settings.language"), selection: $draft.locale) {
+                        Text(model.string("settings.language_en")).tag(AppLocale.en)
+                        Text(model.string("settings.language_ru")).tag(AppLocale.ru)
+                    }
+
+                    Picker(model.string("settings.theme"), selection: $draft.theme) {
+                        Text(model.string("settings.theme_light")).tag(ThemePreference.light)
+                        Text(model.string("settings.theme_dark")).tag(ThemePreference.dark)
+                    }
+
+                    Toggle(model.string("settings.reminders"), isOn: $draft.remindersEnabled)
+                    Toggle(model.string("settings.daily_summary"), isOn: $draft.dailySummaryEnabled)
+
+                    Button(model.string("settings.save")) {
+                        model.savePreferences(draft)
+                    }
+                    .buttonStyle(OrbitPrimaryButtonStyle())
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                }
+                .orbitCard()
+
+                VStack(alignment: .leading, spacing: 14) {
+                    Text(model.string("settings.automation_title"))
+                        .font(.title3.weight(.semibold))
+                    Text(model.string("settings.automation_subtitle"))
+                        .foregroundStyle(.secondary)
+
+                    Button(model.string("settings.automation_create_rule")) {
+                        showRecurringSheet = true
+                    }
+                    .buttonStyle(OrbitPrimaryButtonStyle())
+
+                    if !model.rules.isEmpty {
+                        ForEach(model.rules) { rule in
+                            VStack(alignment: .leading, spacing: 6) {
+                                Text(rule.name)
+                                    .font(.headline)
+                                Text(model.describe(rule: rule))
+                                    .foregroundStyle(.secondary)
+                            }
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                            .padding(.vertical, 8)
+                        }
+                    }
+                }
+                .orbitCard()
+            }
+            .padding()
+        }
+        .navigationTitle(model.string("nav.settings"))
+        .onAppear { draft = model.preferences }
+        .sheet(isPresented: $showRecurringSheet) {
+            RecurringRuleSheet(model: model)
+        }
+    }
+}

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

@@ -0,0 +1,363 @@
+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()
+        }
+    }
+
+    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)
+        }
+    }
+}