Rork Max — to SwiftUI × Vision Pro Native App Development

import SwiftUI
 
// Single codebase supporting both platforms
struct ContentView: View {
    @Environment(\.horizontalSizeClass) var sizeClass
    @State private var selectedItem: Item?
 
    var body: some View {
        #if os(visionOS)
        // Vision Pro: 3D spatial layout
        VStack {
            WindowGroup {
                MainWindow()
            }
            .windowStyle(.plain)
 
            if let item = selectedItem {
                detailVolume(for: item)
            }
        }
        #else
        // iOS: Traditional navigation
        NavigationStack {
            ListView()
                .navigationDestination(item: $selectedItem) { item in
                    DetailView(item: item)
                }
        }
        #endif
    }
}

import SwiftUI
import RealityKit
 
struct ModelViewerApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
 
        ImmersiveSpace(id: "viewer") {
            ModelViewerSpace()
        }
        .immersionStyle(selection: .constant(.mixed), in: .mixed)
    }
}
 
struct ModelViewerSpace: View {
    @State private var selectedModel: String = "default"
    @State private var rotationX: Float = 0
    @State private var rotationY: Float = 0
 
    var body: some View {
        ZStack {
            // Background passthrough
            Model3D(
                named: selectedModel,
                bundle: .main
            )
            .frame(depth: 200)
            .gesture(
                DragGesture()
                    .onChanged { value in
                        rotationY = Float(value.translation.width) * 0.01
                        rotationX = Float(value.translation.height) * 0.01
                    }
            )
            .rotation3D(
                .degrees(Double(rotationX)),
                axis: (1, 0, 0)
            )
            .rotation3D(
                .degrees(Double(rotationY)),
                axis: (0, 1, 0)
            )
 
            // Control panel (left side)
            VStack(spacing: 16) {
                Text("Model Viewer")
                    .font(.system(size: 28, weight: .bold))
 
                Picker("Model", selection: $selectedModel) {
                    ForEach(["model1", "model2", "model3"], id: \.self) { name in
                        Text(name).tag(name)
                    }
                }
                .pickerStyle(.segmented)
 
                Spacer()
            }
            .padding(24)
            .frame(maxWidth: 250, alignment: .leading)
            .background(Material.thickMaterial)
            .offset(x: -300, z: 50)
        }
    }
}

import RealityKit
 
struct ARViewContainer: UIViewRepresentable {
    @ObservedRealmObject var arModel: ARModel
 
    func makeUIView(context: Context) -> ARView {
        let arView = ARView(frame: .zero)
        loadModel(into: arView)
        return arView
    }
 
    func updateUIView(_ uiView: ARView, context: Context) {
        if arModel.needsUpdate {
            loadModel(into: uiView)
        }
    }
 
    private func loadModel(into arView: ARView) {
        Task {
            guard let modelAnchor = try? await Experience.loadModel() else { return }
            arView.scene.addAnchor(modelAnchor)
        }
    }
}

// Auto-generated from Figma
struct BrandColors {
    static let primary = Color(red: 0.2, green: 0.5, blue: 1.0)
    static let secondary = Color(red: 1.0, green: 0.6, blue: 0.2)
    static let background = Color(red: 0.95, green: 0.95, blue: 0.97)
}
 
struct WorkoutButton: View {
    let title: String
    let action: () -> Void
    @Environment(\.isEnabled) var isEnabled
 
    var body: some View {
        Button(action: action) {
            Text(title)
                .font(.system(size: 18, weight: .semibold))
                .foregroundColor(.white)
                .frame(maxWidth: .infinity)
                .frame(height: 56)
                .background(
                    RoundedRectangle(cornerRadius: 12)
                        .fill(BrandColors.primary)
                )
        }
        .disabled(!isEnabled)
    }
}

struct FitnessAPIClient {
    private let baseURL = URL(string: "https://api.example.com")!
 
    func fetchWorkoutData(
        userId: String,
        startDate: Date,
        endDate: Date
    ) async throws -> [WorkoutRecord] {
        let encoder = JSONEncoder()
        encoder.dateEncodingStrategy = .iso8601
 
        var request = URLRequest(
            url: baseURL.appendingPathComponent("/workouts")
        )
        request.httpMethod = "GET"
        request.addValue(
            "Bearer YOUR_API_TOKEN",
            forHTTPHeaderField: "Authorization"
        )
 
        let (data, response) = try await URLSession.shared.data(for: request)
 
        guard let httpResponse = response as? HTTPURLResponse,
              httpResponse.statusCode == 200 else {
            throw APIError.invalidResponse
        }
 
        let decoder = JSONDecoder()
        decoder.dateDecodingStrategy = .iso8601
        return try decoder.decode([WorkoutRecord].self, from: data)
    }
}

class WorkoutViewModel: ObservableObject {
    @Published var workouts: [Workout] = []
    private var timer: Timer?
 
    func startUpdates() {
        timer = Timer.scheduledTimer(
            withTimeInterval: 5.0,
            repeats: true
        ) { [weak self] _ in
            self?.updateWorkoutData()
        }
    }
 
    func stopUpdates() {
        timer?.invalidate()
        timer = nil
    }
 
    deinit {
        stopUpdates()
    }
}

import StoreKit
 
@MainActor
class SubscriptionManager: ObservableObject {
    @Published var availableSubscriptions: [Product] = []
    @Published var purchasedSubscriptionId: String?
    @Published var isSubscriptionActive: Bool = false
 
    init() {
        Task {
            await loadSubscriptions()
            await checkSubscriptionStatus()
        }
    }
 
    func loadSubscriptions() async {
        do {
            let productIds = ["com.example.fitpro.monthly",
                              "com.example.fitpro.yearly"]
            availableSubscriptions = try await Product.products(for: productIds)
        } catch {
            print("Failed to load subscriptions: \(error)")
        }
    }
 
    func purchaseSubscription(_ product: Product) async {
        do {
            let result = try await product.purchase()
            switch result {
            case .success(let verification):
                let transaction = try checkVerified(verification)
                await updateSubscriptionStatus(transaction)
                await transaction.finish()
 
            case .userCancelled:
                print("User cancelled subscription")
 
            case .pending:
                print("Subscription pending")
            @unknown default:
                break
            }
        } catch {
            print("Purchase failed: \(error)")
        }
    }
 
    func checkSubscriptionStatus() async {
        for await result in Transaction.currentEntitlements {
            let transaction = try checkVerified(result)
            if transaction.revocationDate == nil {
                isSubscriptionActive = true
                purchasedSubscriptionId = transaction.productID
            }
        }
    }
 
    private func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
        switch result {
        case .unverified:
            throw NSError(domain: "Unverified", code: -1)
        case .verified(let safe):
            return safe
        }
    }
}

struct PremiumFeaturesView: View {
    @StateObject private var subscriptionManager = SubscriptionManager()
 
    var body: some View {
        VStack(spacing: 16) {
            if subscriptionManager.isSubscriptionActive {
                Text("Premium Member")
                    .font(.title2)
                    .foregroundColor(.green)
 
                VStack(alignment: .leading, spacing: 8) {
                    Label("Unlimited workouts", systemImage: "checkmark.circle.fill")
                    Label("Advanced analytics", systemImage: "checkmark.circle.fill")
                    Label("AI coaching", systemImage: "checkmark.circle.fill")
                }
                .padding()
                .background(Color.green.opacity(0.1))
                .cornerRadius(12)
 
            } else {
                VStack(spacing: 12) {
                    ForEach(subscriptionManager.availableSubscriptions, id: \.id) { product in
                        Button(action: {
                            Task {
                                await subscriptionManager.purchaseSubscription(product)
                            }
                        }) {
                            Text("\(product.displayName) - \(product.displayPrice)")
                                .frame(maxWidth: .infinity)
                        }
                        .buttonStyle(.borderedProminent)
                    }
                }
            }
        }
        .padding()
    }
}

#if targetEnvironment(simulator)
let isSimulator = true
#else
let isSimulator = false
#endif
 
struct DebugView: View {
    @Environment(\.horizontalSizeClass) var sizeClass
 
    var body: some View {
        if isSimulator {
            Text("Running in Simulator")
                .padding()
                .background(Color.yellow.opacity(0.3))
        }
    }
}

import Testing
import SwiftUI
 
@Suite("WorkoutViewModel Tests")
struct WorkoutViewModelTests {
    @Test func testFetchWorkoutData() async throws {
        let viewModel = WorkoutViewModel()
        try await viewModel.loadWorkouts()
 
        #expect(viewModel.workouts.count > 0)
        #expect(viewModel.isLoading == false)
    }
 
    @Test func testSubscriptionCheck() async throws {
        let manager = SubscriptionManager()
        await manager.checkSubscriptionStatus()
 
        #expect(manager.isSubscriptionActive || !manager.isSubscriptionActive)
    }
}