openuispec 0.2.10 → 0.2.12

package/examples/todo-orbit/generated/ios/Todo Orbit/Sources/TodoOrbit/Components/TrendChartView.swift

@@ -1,70 +0,0 @@
-import Charts
-import SwiftUI
-
-struct TrendChartView: View {
-    let title: String
-    let subtitle: String
-    let emptyMessage: String
-    let legendCompleted: String
-    let legendCreated: String
-    let points: [TrendPoint]
-
-    var body: some View {
-        VStack(alignment: .leading, spacing: 14) {
-            Text(subtitle)
-                .font(.caption.weight(.bold))
-                .foregroundStyle(.secondary)
-                .textCase(.uppercase)
-            Text(title)
-                .font(.title3.weight(.semibold))
-
-            if points.isEmpty {
-                Text(emptyMessage)
-                    .font(.body)
-                    .foregroundStyle(.secondary)
-                    .frame(maxWidth: .infinity, alignment: .leading)
-                    .padding(.vertical, 40)
-            } else {
-                Chart(points) { point in
-                    LineMark(
-                        x: .value("Label", point.label),
-                        y: .value(legendCreated, point.created)
-                    )
-                    .foregroundStyle(.orange)
-                    .interpolationMethod(.catmullRom)
-
-                    LineMark(
-                        x: .value("Label", point.label),
-                        y: .value(legendCompleted, point.completed)
-                    )
-                    .foregroundStyle(.teal)
-                    .interpolationMethod(.catmullRom)
-
-                    AreaMark(
-                        x: .value("Label", point.label),
-                        y: .value(legendCompleted, point.completed)
-                    )
-                    .foregroundStyle(.teal.opacity(0.08))
-                }
-                .frame(height: 280)
-
-                HStack(spacing: 18) {
-                    legend(.teal, title: legendCompleted)
-                    legend(.orange, title: legendCreated)
-                }
-                .font(.footnote)
-                .foregroundStyle(.secondary)
-            }
-        }
-        .orbitCard(fill: Color(uiColor: .systemBackground), stroke: Color.teal.opacity(0.18))
-    }
-
-    private func legend(_ color: Color, title: String) -> some View {
-        HStack(spacing: 8) {
-            Circle()
-                .fill(color)
-                .frame(width: 10, height: 10)
-            Text(title)
-        }
-    }
-}

package/examples/todo-orbit/generated/ios/Todo Orbit/Sources/TodoOrbit/Flows/RecurringRuleSheet.swift

@@ -1,126 +0,0 @@
-import SwiftUI
-
-struct RecurringRuleSheet: View {
-    @Environment(\.dismiss) private var dismiss
-    @ObservedObject var model: AppModel
-
-    @State private var draft = RecurringRuleDraft()
-    @State private var errors: [String: String] = [:]
-
-    var body: some View {
-        NavigationStack {
-            ScrollView {
-                VStack(alignment: .leading, spacing: 18) {
-                    if !errors.isEmpty {
-                        Text(model.string("validation.fix_errors"))
-                            .font(.footnote.weight(.medium))
-                            .foregroundStyle(.orange)
-                            .padding(14)
-                            .frame(maxWidth: .infinity, alignment: .leading)
-                            .background(Color.orange.opacity(0.1), in: CutCornerShape(cut: 12))
-                    }
-
-                    VStack(spacing: 14) {
-                        TextField(model.string("recurring_rule.field_name"), text: $draft.name)
-                        errorText("name")
-
-                        TextField(model.string("recurring_rule.field_confirm_name"), text: $draft.confirmName)
-                        errorText("confirmName")
-
-                        Picker(model.string("recurring_rule.field_cadence"), selection: $draft.cadence) {
-                            Text("—").tag(RecurrenceCadence?.none)
-                            ForEach(RecurrenceCadence.allCases) { cadence in
-                                Text(model.string("recurring_rule.cadence_\(cadence.rawValue)"))
-                                    .tag(RecurrenceCadence?.some(cadence))
-                            }
-                        }
-                        .pickerStyle(.segmented)
-                        errorText("cadence")
-
-                        TextField(model.string("recurring_rule.field_interval"), text: $draft.interval)
-                            .keyboardType(.numberPad)
-                        errorText("interval")
-
-                        if draft.cadence == .weekly {
-                            Picker(model.string("recurring_rule.field_weekday"), selection: $draft.weekday) {
-                                Text("—").tag(Weekday?.none)
-                                ForEach(Weekday.allCases) { weekday in
-                                    Text(model.label(for: weekday)).tag(Weekday?.some(weekday))
-                                }
-                            }
-                            .pickerStyle(.menu)
-                            errorText("weekday")
-                        }
-
-                        if draft.cadence == .monthly {
-                            TextField(model.string("recurring_rule.field_month_day"), text: $draft.monthDay)
-                                .keyboardType(.numberPad)
-                            errorText("monthDay")
-                        }
-
-                        DatePicker(model.string("recurring_rule.field_start_date"), selection: $draft.startDate, displayedComponents: .date)
-
-                        Toggle(model.string("recurring_rule.field_has_end_date"), isOn: $draft.hasEndDate)
-                        if draft.hasEndDate {
-                            DatePicker(model.string("recurring_rule.field_end_date"), selection: $draft.endDate, displayedComponents: .date)
-                            errorText("endDate")
-                        }
-
-                        if model.preferences.remindersEnabled {
-                            TextField(model.string("recurring_rule.field_remind_at"), text: $draft.remindAt)
-                                .textInputAutocapitalization(.never)
-                            errorText("remindAt")
-                        }
-
-                        Toggle(model.string("recurring_rule.field_enable_summary"), isOn: $draft.enableSummary)
-                        if draft.enableSummary {
-                            Picker(model.string("recurring_rule.field_summary_channel"), selection: $draft.summaryChannel) {
-                                Text("—").tag(SummaryChannel?.none)
-                                ForEach(SummaryChannel.allCases) { channel in
-                                    Text(model.string("recurring_rule.summary_\(channel.rawValue)"))
-                                        .tag(SummaryChannel?.some(channel))
-                                }
-                            }
-                            .pickerStyle(.segmented)
-                            errorText("summaryChannel")
-                        }
-                    }
-                    .textFieldStyle(.roundedBorder)
-                    .orbitCard(fill: Color(uiColor: .secondarySystemGroupedBackground), stroke: Color.teal.opacity(0.18))
-
-                    SchedulePreviewView(
-                        model: model,
-                        title: model.string("recurring_preview.title"),
-                        result: SchedulePreviewView.compute(from: draft)
-                    )
-                }
-                .padding()
-            }
-            .navigationTitle(model.string("recurring_rule.title"))
-            .toolbar {
-                ToolbarItem(placement: .topBarLeading) {
-                    Button(model.string("common.cancel")) { dismiss() }
-                }
-                ToolbarItem(placement: .topBarTrailing) {
-                    Button(model.string("recurring_rule.save")) {
-                        errors = model.addRecurringRule(from: draft)
-                        if errors.isEmpty {
-                            dismiss()
-                        }
-                    }
-                }
-            }
-        }
-        .presentationDetents([.large])
-    }
-
-    @ViewBuilder
-    private func errorText(_ key: String) -> some View {
-        if let message = errors[key] {
-            Text(message)
-                .font(.footnote)
-                .foregroundStyle(.red)
-                .frame(maxWidth: .infinity, alignment: .leading)
-        }
-    }
-}

package/examples/todo-orbit/generated/ios/Todo Orbit/Sources/TodoOrbit/Flows/TaskEditorSheet.swift

@@ -1,61 +0,0 @@
-import SwiftUI
-
-struct TaskEditorSheet: View {
-    @Environment(\.dismiss) private var dismiss
-    @ObservedObject var model: AppModel
-    let editingTaskID: UUID?
-
-    @State private var draft = TaskEditorDraft(title: "", notes: "", priority: .medium, dueDate: nil)
-    @State private var validationError: String?
-
-    var body: some View {
-        NavigationStack {
-            Form {
-                if let validationError {
-                    Section {
-                        Text(validationError)
-                            .font(.footnote.weight(.medium))
-                            .foregroundStyle(.red)
-                    }
-                }
-
-                Section {
-                    TextField(model.string(editingTaskID == nil ? "create_task.field_title" : "edit_task.field_title"), text: $draft.title)
-                    TextField(model.string(editingTaskID == nil ? "create_task.field_notes" : "edit_task.field_notes"), text: $draft.notes, axis: .vertical)
-                    Picker(model.string(editingTaskID == nil ? "create_task.field_priority" : "edit_task.field_priority"), selection: $draft.priority) {
-                        ForEach(TaskPriority.allCases) { priority in
-                            Text(model.label(for: priority)).tag(priority)
-                        }
-                    }
-                    .pickerStyle(.segmented)
-                    DatePicker(
-                        model.string(editingTaskID == nil ? "create_task.field_due_date" : "edit_task.field_due_date"),
-                        selection: Binding(
-                            get: { draft.dueDate ?? .now },
-                            set: { draft.dueDate = $0 }
-                        ),
-                        displayedComponents: .date
-                    )
-                }
-            }
-            .navigationTitle(model.string(editingTaskID == nil ? "create_task.title" : "edit_task.title"))
-            .toolbar {
-                ToolbarItem(placement: .topBarLeading) {
-                    Button(model.string("common.cancel")) { dismiss() }
-                }
-                ToolbarItem(placement: .topBarTrailing) {
-                    Button(model.string(editingTaskID == nil ? "create_task.save" : "edit_task.save")) {
-                        validationError = model.submitTask(draft, editing: editingTaskID)
-                        if validationError == nil {
-                            dismiss()
-                        }
-                    }
-                }
-            }
-        }
-        .onAppear {
-            draft = model.makeTaskDraft(for: model.task(id: editingTaskID))
-        }
-        .presentationDetents([.medium, .large])
-    }
-}

package/examples/todo-orbit/generated/ios/Todo Orbit/Sources/TodoOrbit/Models/DomainModels.swift

@@ -1,238 +0,0 @@
-import Foundation
-import SwiftUI
-
-enum AppLocale: String, CaseIterable, Identifiable {
-    case en
-    case ru
-
-    var id: String { rawValue }
-}
-
-enum ThemePreference: String, CaseIterable, Identifiable {
-    case light
-    case dark
-
-    var id: String { rawValue }
-
-    var colorScheme: ColorScheme {
-        switch self {
-        case .light: .light
-        case .dark: .dark
-        }
-    }
-}
-
-enum TaskStatus: String, CaseIterable, Identifiable {
-    case open
-    case done
-
-    var id: String { rawValue }
-}
-
-enum TaskPriority: String, CaseIterable, Identifiable {
-    case low
-    case medium
-    case high
-
-    var id: String { rawValue }
-
-    var tint: Color {
-        switch self {
-        case .low: Color(red: 148 / 255, green: 163 / 255, blue: 184 / 255)
-        case .medium: Color(red: 37 / 255, green: 99 / 255, blue: 235 / 255)
-        case .high: Color(red: 217 / 255, green: 119 / 255, blue: 6 / 255)
-        }
-    }
-}
-
-enum TaskFilter: String, CaseIterable, Identifiable {
-    case all
-    case open
-    case done
-
-    var id: String { rawValue }
-}
-
-enum AnalyticsPeriod: String, CaseIterable, Identifiable {
-    case week
-    case month
-    case quarter
-
-    var id: String { rawValue }
-}
-
-enum RecurrenceCadence: String, CaseIterable, Identifiable {
-    case daily
-    case weekly
-    case monthly
-
-    var id: String { rawValue }
-}
-
-enum Weekday: String, CaseIterable, Identifiable {
-    case mon
-    case tue
-    case wed
-    case thu
-    case fri
-    case sat
-    case sun
-
-    var id: String { rawValue }
-
-    var calendarIndex: Int {
-        switch self {
-        case .sun: 1
-        case .mon: 2
-        case .tue: 3
-        case .wed: 4
-        case .thu: 5
-        case .fri: 6
-        case .sat: 7
-        }
-    }
-}
-
-enum SummaryChannel: String, CaseIterable, Identifiable {
-    case push
-    case email
-
-    var id: String { rawValue }
-}
-
-struct Preferences: Equatable {
-    var locale: AppLocale
-    var theme: ThemePreference
-    var remindersEnabled: Bool
-    var dailySummaryEnabled: Bool
-}
-
-struct Task: Identifiable, Equatable {
-    let id: UUID
-    var title: String
-    var notes: String
-    var status: TaskStatus
-    var priority: TaskPriority
-    var dueDate: Date?
-    let createdAt: Date
-    var updatedAt: Date
-}
-
-struct RecurringRule: Identifiable, Equatable {
-    let id: UUID
-    var name: String
-    var cadence: RecurrenceCadence
-    var interval: Int
-    var weekday: Weekday?
-    var monthDay: Int?
-    var startDate: Date
-    var endDate: Date?
-    var remindAt: String?
-    var summaryChannel: SummaryChannel?
-}
-
-struct TrendPoint: Identifiable, Equatable {
-    let id = UUID()
-    let label: String
-    let completed: Int
-    let created: Int
-}
-
-struct AnalyticsSnapshot: Equatable {
-    let completedToday: Int
-    let openTasks: Int
-    let overdueTasks: Int
-    let completionRate: Int
-}
-
-struct ToastMessage: Identifiable, Equatable {
-    enum Level {
-        case success
-        case warning
-        case error
-    }
-
-    let id = UUID()
-    let level: Level
-    let text: String
-}
-
-struct TaskEditorDraft {
-    var title: String
-    var notes: String
-    var priority: TaskPriority
-    var dueDate: Date?
-}
-
-struct RecurringRuleDraft {
-    var name: String = ""
-    var confirmName: String = ""
-    var cadence: RecurrenceCadence?
-    var interval: String = "1"
-    var weekday: Weekday?
-    var monthDay: String = ""
-    var startDate: Date = .now
-    var hasEndDate: Bool = false
-    var endDate: Date = .now
-    var remindAt: String = ""
-    var enableSummary: Bool = false
-    var summaryChannel: SummaryChannel?
-}
-
-extension Task {
-    static func seed(referenceDate: Date = .now) -> [Task] {
-        let calendar = Calendar.current
-        return [
-            Task(
-                id: UUID(uuidString: "A6AC1D32-DF3E-4A87-9E11-6E9C2A52CF11")!,
-                title: "Prepare bilingual launch notes",
-                notes: "Document the web, iOS, and Android behavior differences before review.",
-                status: .open,
-                priority: .high,
-                dueDate: calendar.date(byAdding: .day, value: 2, to: referenceDate),
-                createdAt: calendar.date(byAdding: .day, value: -6, to: referenceDate)!,
-                updatedAt: calendar.date(byAdding: .day, value: -1, to: referenceDate)!
-            ),
-            Task(
-                id: UUID(uuidString: "A6AC1D32-DF3E-4A87-9E11-6E9C2A52CF12")!,
-                title: "Review recurring-rule validation",
-                notes: "Confirm async uniqueness checks and cross-field constraints.",
-                status: .done,
-                priority: .medium,
-                dueDate: calendar.date(byAdding: .day, value: -1, to: referenceDate),
-                createdAt: calendar.date(byAdding: .day, value: -5, to: referenceDate)!,
-                updatedAt: referenceDate
-            ),
-            Task(
-                id: UUID(uuidString: "A6AC1D32-DF3E-4A87-9E11-6E9C2A52CF13")!,
-                title: "Polish analytics empty states",
-                notes: "Ensure chart and overdue list degrade gracefully on zero-data snapshots.",
-                status: .open,
-                priority: .medium,
-                dueDate: calendar.date(byAdding: .day, value: 5, to: referenceDate),
-                createdAt: calendar.date(byAdding: .day, value: -4, to: referenceDate)!,
-                updatedAt: calendar.date(byAdding: .day, value: -2, to: referenceDate)!
-            ),
-            Task(
-                id: UUID(uuidString: "A6AC1D32-DF3E-4A87-9E11-6E9C2A52CF14")!,
-                title: "Regenerate drift snapshots",
-                notes: "Refresh ios, android, and web state after spec edits.",
-                status: .open,
-                priority: .low,
-                dueDate: calendar.date(byAdding: .day, value: -3, to: referenceDate),
-                createdAt: calendar.date(byAdding: .day, value: -3, to: referenceDate)!,
-                updatedAt: calendar.date(byAdding: .day, value: -3, to: referenceDate)!
-            ),
-            Task(
-                id: UUID(uuidString: "A6AC1D32-DF3E-4A87-9E11-6E9C2A52CF15")!,
-                title: "Prototype schedule preview contract",
-                notes: "Use derived occurrences to prove custom-contract generation.",
-                status: .done,
-                priority: .high,
-                dueDate: calendar.date(byAdding: .day, value: 1, to: referenceDate),
-                createdAt: calendar.date(byAdding: .day, value: -8, to: referenceDate)!,
-                updatedAt: calendar.date(byAdding: .day, value: -1, to: referenceDate)!
-            )
-        ]
-    }
-}

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

@@ -1,94 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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)
-                    }
-                    .pickerStyle(.segmented)
-
-                    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)
-                    }
-                    .pickerStyle(.segmented)
-
-                    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)
-        }
-    }
-}