openuispec 0.1.17 → 0.1.19

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

@@ -0,0 +1,126 @@
+import SwiftUI
+
+struct SchedulePreviewResult {
+    enum State {
+        case invalid
+        case empty
+        case ready
+    }
+
+    let state: State
+    let dates: [Date]
+}
+
+struct SchedulePreviewView: View {
+    let model: AppModel
+    let title: String
+    let result: SchedulePreviewResult
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 14) {
+            Text("x_schedule_preview.detail")
+                .font(.caption.weight(.bold))
+                .foregroundStyle(.secondary)
+                .textCase(.uppercase)
+            Text(title)
+                .font(.title3.weight(.semibold))
+
+            switch result.state {
+            case .invalid:
+                Text(model.string("recurring_preview.invalid"))
+                    .font(.footnote.weight(.medium))
+                    .foregroundStyle(.red)
+                    .padding(14)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                    .background(Color.red.opacity(0.08), in: CutCornerShape(cut: 12))
+            case .empty:
+                Text(model.string("recurring_preview.empty"))
+                    .foregroundStyle(.secondary)
+            case .ready:
+                VStack(spacing: 10) {
+                    ForEach(Array(result.dates.enumerated()), id: \.offset) { index, date in
+                        HStack {
+                            Text(index == 0 ? "Next" : "+\(index)")
+                                .font(.caption.weight(.bold))
+                                .foregroundStyle(index == 0 ? .teal : .secondary)
+                            Spacer()
+                            Text(model.formatDate(date))
+                                .font(.subheadline.weight(.semibold))
+                        }
+                        .padding(14)
+                        .background(
+                            CutCornerShape(cut: 12)
+                                .fill(index == 0 ? Color.teal.opacity(0.08) : Color(uiColor: .secondarySystemBackground))
+                        )
+                    }
+                }
+            }
+        }
+        .orbitCard(fill: Color(uiColor: .systemBackground), stroke: Color.orange.opacity(0.22))
+    }
+
+    static func compute(from draft: RecurringRuleDraft) -> SchedulePreviewResult {
+        guard let cadence = draft.cadence, let interval = Int(draft.interval), interval >= 1 else {
+            return .init(state: .invalid, dates: [])
+        }
+
+        if draft.hasEndDate, draft.endDate < draft.startDate {
+            return .init(state: .invalid, dates: [])
+        }
+
+        if cadence == .weekly, draft.weekday == nil {
+            return .init(state: .invalid, dates: [])
+        }
+
+        if cadence == .monthly {
+            guard let day = Int(draft.monthDay), (1...28).contains(day) else {
+                return .init(state: .invalid, dates: [])
+            }
+        }
+
+        let calendar = Calendar.current
+        var dates: [Date] = []
+        var cursor = draft.startDate
+        let endDate = draft.hasEndDate ? draft.endDate : nil
+
+        for _ in 0..<4 {
+            let next: Date?
+            switch cadence {
+            case .daily:
+                next = cursor
+                cursor = calendar.date(byAdding: .day, value: interval, to: cursor) ?? cursor
+            case .weekly:
+                next = nextWeeklyDate(startingAt: cursor, weekday: draft.weekday!, interval: interval)
+                cursor = calendar.date(byAdding: .day, value: interval * 7, to: next ?? cursor) ?? cursor
+            case .monthly:
+                next = nextMonthlyDate(startingAt: cursor, day: Int(draft.monthDay)!, interval: interval)
+                cursor = calendar.date(byAdding: .month, value: interval, to: next ?? cursor) ?? cursor
+            }
+
+            guard let next else { break }
+            if let endDate, next > endDate { break }
+            dates.append(next)
+        }
+
+        return dates.isEmpty ? .init(state: .empty, dates: []) : .init(state: .ready, dates: dates)
+    }
+
+    private static func nextWeeklyDate(startingAt start: Date, weekday: Weekday, interval: Int) -> Date? {
+        let calendar = Calendar.current
+        var next = start
+        while calendar.component(.weekday, from: next) != weekday.calendarIndex {
+            guard let candidate = calendar.date(byAdding: .day, value: 1, to: next) else { return nil }
+            next = candidate
+        }
+        return next
+    }
+
+    private static func nextMonthlyDate(startingAt start: Date, day: Int, interval: Int) -> Date? {
+        let calendar = Calendar.current
+        var components = calendar.dateComponents([.year, .month], from: start)
+        components.day = day
+        guard let initial = calendar.date(from: components) else { return nil }
+        if initial >= start { return initial }
+        return calendar.date(byAdding: .month, value: interval, to: initial)
+    }
+}

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

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

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

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

@@ -0,0 +1,238 @@
+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)!
+            )
+        ]
+    }
+}