moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-lang-swift/modules/swift6-features.md

@@ -0,0 +1,265 @@
+# Swift 6.0 Features
+
+Comprehensive guide to Swift 6.0 language features including typed throws, complete concurrency, and data-race safety.
+
+## Typed Throws
+
+Swift 6 introduces typed throws allowing precise error type specification in function signatures.
+
+### Basic Typed Throws
+
+Error Type Specification:
+```swift
+enum NetworkError: Error {
+    case invalidURL
+    case requestFailed(statusCode: Int)
+    case decodingFailed
+}
+
+// Function declares specific error type
+func fetchData(from urlString: String) throws(NetworkError) -> Data {
+    guard let url = URL(string: urlString) else {
+        throw .invalidURL
+    }
+    // Implementation
+}
+
+// Caller has exhaustive error handling
+do {
+    let data = try fetchData(from: "https://api.example.com")
+} catch .invalidURL {
+    print("Invalid URL")
+} catch .requestFailed(let code) {
+    print("Request failed: \(code)")
+} catch .decodingFailed {
+    print("Decoding failed")
+}
+```
+
+### Domain-Specific Error Types
+
+Authentication Errors:
+```swift
+enum AuthError: Error, LocalizedError {
+    case invalidCredentials
+    case sessionExpired
+    case networkError(underlying: Error)
+    
+    var errorDescription: String? {
+        switch self {
+        case .invalidCredentials: return "Invalid email or password"
+        case .sessionExpired: return "Session expired. Please login again."
+        case .networkError(let error): return "Network error: \(error.localizedDescription)"
+        }
+    }
+}
+
+protocol AuthServiceProtocol: Sendable {
+    func login(email: String, password: String) async throws(AuthError) -> AuthTokens
+    func refreshToken(_ token: String) async throws(AuthError) -> AuthTokens
+}
+```
+
+## Complete Concurrency Checking
+
+Swift 6 enforces complete data-race safety by default at compile time.
+
+### Sendable Requirements
+
+Value Types (Automatic Sendable):
+```swift
+// Structs with only Sendable properties are automatically Sendable
+struct User: Codable, Identifiable, Sendable {
+    let id: String
+    let name: String
+    let email: String
+}
+```
+
+Reference Types (Explicit Sendable):
+```swift
+// Classes must explicitly conform and be final
+final class ImmutableConfig: Sendable {
+    let apiKey: String
+    let baseURL: URL
+    
+    init(apiKey: String, baseURL: URL) {
+        self.apiKey = apiKey
+        self.baseURL = baseURL
+    }
+}
+
+// Use @unchecked Sendable for thread-safe classes
+final class ThreadSafeCache<Key: Hashable, Value>: @unchecked Sendable {
+    private var cache: [Key: Value] = [:]
+    private let lock = NSLock()
+    
+    func get(_ key: Key) -> Value? {
+        lock.lock()
+        defer { lock.unlock() }
+        return cache[key]
+    }
+    
+    func set(_ key: Key, value: Value) {
+        lock.lock()
+        defer { lock.unlock() }
+        cache[key] = value
+    }
+}
+```
+
+### Actor Isolation
+
+Protecting Mutable State:
+```swift
+actor UserCache {
+    private var cache: [String: User] = [:]
+    
+    func get(_ id: String) -> User? { cache[id] }
+    func set(_ id: String, user: User) { cache[id] = user }
+    func clear() { cache.removeAll() }
+    
+    var isEmpty: Bool { cache.isEmpty }
+}
+```
+
+### MainActor for UI Code
+
+ViewModel with MainActor:
+```swift
+@MainActor
+@Observable
+final class ProfileViewModel {
+    private(set) var user: User?
+    private(set) var isLoading = false
+    
+    private let api: UserAPIProtocol
+    
+    func loadProfile(_ userId: String) async {
+        isLoading = true
+        defer { isLoading = false }
+        user = try? await api.fetchUser(userId)
+    }
+}
+```
+
+### Nonisolated Functions
+
+Escaping Actor Isolation:
+```swift
+actor NetworkMonitor {
+    private var isConnected = true
+    
+    func updateStatus(connected: Bool) {
+        isConnected = connected
+    }
+    
+    // Nonisolated - can be called synchronously
+    nonisolated func describeConnection() -> String {
+        "Network monitor for connectivity tracking"
+    }
+    
+    // Nonisolated with async for cross-actor reads
+    nonisolated func getStatus() async -> Bool {
+        await isConnected
+    }
+}
+```
+
+## Data-Race Safety Patterns
+
+### Safe Alternatives
+
+Using Actor:
+```swift
+actor SafeCounter {
+    private var count = 0
+    
+    func increment() -> Int {
+        count += 1
+        return count
+    }
+}
+```
+
+Using AsyncStream for Events:
+```swift
+actor EventEmitter<Event: Sendable> {
+    private var continuations: [UUID: AsyncStream<Event>.Continuation] = [:]
+    
+    func subscribe() -> AsyncStream<Event> {
+        let id = UUID()
+        return AsyncStream { continuation in
+            continuations[id] = continuation
+            continuation.onTermination = { [weak self] _ in
+                Task { await self?.removeContinuation(id) }
+            }
+        }
+    }
+    
+    private func removeContinuation(_ id: UUID) {
+        continuations.removeValue(forKey: id)
+    }
+    
+    func emit(_ event: Event) {
+        for continuation in continuations.values {
+            continuation.yield(event)
+        }
+    }
+}
+```
+
+### Global Actor Pattern
+
+Custom Global Actor:
+```swift
+@globalActor
+actor DatabaseActor: GlobalActor {
+    static let shared = DatabaseActor()
+}
+
+@DatabaseActor
+final class DatabaseManager {
+    private var connection: DatabaseConnection?
+    
+    func connect() async throws {
+        connection = try await DatabaseConnection.open()
+    }
+}
+```
+
+## Migration Guidelines
+
+### Enabling Strict Concurrency
+
+Package.swift Settings:
+```swift
+targets: [
+    .target(
+        name: "MyApp",
+        swiftSettings: [
+            .enableExperimentalFeature("StrictConcurrency")
+        ]
+    )
+]
+```
+
+### Common Migration Patterns
+
+Callback to Async:
+```swift
+// Before: Callback-based
+func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void)
+
+// After: Async/await
+func fetchUser(id: String) async throws -> User {
+    let (data, _) = try await URLSession.shared.data(from: url)
+    return try JSONDecoder().decode(User.self, from: data)
+}
+```
+
+---
+
+Version: 2.0.0
+Last Updated: 2026-01-06
+Context7: /apple/swift, /apple/swift-evolution

moai_adk/templates/.claude/skills/moai-lang-swift/modules/swiftui-patterns.md

@@ -0,0 +1,314 @@
+# SwiftUI 6 Patterns
+
+Modern SwiftUI development with @Observable, NavigationStack, state management, and view lifecycle.
+
+## @Observable Macro
+
+The @Observable macro (iOS 17+) replaces @ObservableObject with simpler, more performant observation.
+
+### Basic Usage
+
+Simple ViewModel:
+```swift
+import Observation
+
+@Observable
+class CounterViewModel {
+    var count = 0
+    
+    func increment() { count += 1 }
+    func decrement() { count -= 1 }
+}
+
+struct CounterView: View {
+    @State private var viewModel = CounterViewModel()
+    
+    var body: some View {
+        VStack {
+            Text("Count: \(viewModel.count)")
+            HStack {
+                Button("−") { viewModel.decrement() }
+                Button("+") { viewModel.increment() }
+            }
+        }
+    }
+}
+```
+
+### Complex State Management
+
+Full-Featured ViewModel:
+```swift
+@Observable
+@MainActor
+final class ProductListViewModel {
+    private(set) var products: [Product] = []
+    private(set) var isLoading = false
+    var searchQuery = ""
+    var selectedCategory: Category?
+    
+    var filteredProducts: [Product] {
+        var result = products
+        if !searchQuery.isEmpty {
+            result = result.filter { $0.name.localizedCaseInsensitiveContains(searchQuery) }
+        }
+        if let category = selectedCategory {
+            result = result.filter { $0.category == category }
+        }
+        return result
+    }
+    
+    private let api: ProductAPIProtocol
+    
+    init(api: ProductAPIProtocol) { self.api = api }
+    
+    func loadProducts() async {
+        isLoading = true
+        defer { isLoading = false }
+        products = (try? await api.fetchProducts()) ?? []
+    }
+}
+```
+
+### Environment Integration
+
+Dependency Injection:
+```swift
+@Observable
+class AuthService {
+    var currentUser: User?
+    var isAuthenticated: Bool { currentUser != nil }
+}
+
+@main
+struct MyApp: App {
+    @State private var authService = AuthService()
+    
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+                .environment(authService)
+        }
+    }
+}
+
+struct ProfileView: View {
+    @Environment(AuthService.self) private var authService
+    
+    var body: some View {
+        if let user = authService.currentUser {
+            UserProfileContent(user: user)
+        }
+    }
+}
+```
+
+## NavigationStack
+
+### Programmatic Navigation
+
+Navigation Router Pattern:
+```swift
+@Observable
+class NavigationRouter {
+    var path = NavigationPath()
+    
+    func push<D: Hashable>(_ destination: D) { path.append(destination) }
+    func pop() { guard !path.isEmpty else { return }; path.removeLast() }
+    func popToRoot() { path.removeLast(path.count) }
+}
+
+enum AppDestination: Hashable {
+    case productDetail(Product)
+    case settings
+    case userProfile(User)
+}
+
+struct RootView: View {
+    @State private var router = NavigationRouter()
+    
+    var body: some View {
+        NavigationStack(path: $router.path) {
+            HomeView()
+                .navigationDestination(for: AppDestination.self) { destination in
+                    switch destination {
+                    case .productDetail(let product): ProductDetailView(product: product)
+                    case .settings: SettingsView()
+                    case .userProfile(let user): UserProfileView(user: user)
+                    }
+                }
+        }
+        .environment(router)
+    }
+}
+
+struct HomeView: View {
+    @Environment(NavigationRouter.self) private var router
+    
+    var body: some View {
+        Button("View Settings") { router.push(AppDestination.settings) }
+    }
+}
+```
+
+## State Management
+
+### @State vs @Binding
+
+Local State:
+```swift
+struct ToggleCard: View {
+    @State private var isExpanded = false
+    
+    var body: some View {
+        VStack {
+            Button { withAnimation { isExpanded.toggle() } } label: {
+                HStack {
+                    Text("Details")
+                    Image(systemName: isExpanded ? "chevron.up" : "chevron.down")
+                }
+            }
+            if isExpanded { Text("Expanded content") }
+        }
+    }
+}
+```
+
+Binding for Two-Way Communication:
+```swift
+struct FilterSheet: View {
+    @Binding var selectedCategory: Category?
+    
+    var body: some View {
+        Picker("Category", selection: $selectedCategory) {
+            Text("All").tag(nil as Category?)
+            ForEach(Category.allCases) { category in
+                Text(category.name).tag(category as Category?)
+            }
+        }
+    }
+}
+```
+
+### @Bindable for Observable
+
+Using @Bindable:
+```swift
+@Observable
+class FormViewModel {
+    var name = ""
+    var email = ""
+    var isValid: Bool { !name.isEmpty && email.contains("@") }
+}
+
+struct RegistrationForm: View {
+    @Bindable var viewModel: FormViewModel
+    
+    var body: some View {
+        Form {
+            TextField("Name", text: $viewModel.name)
+            TextField("Email", text: $viewModel.email)
+            Button("Submit") { }.disabled(!viewModel.isValid)
+        }
+    }
+}
+```
+
+## View Lifecycle
+
+### Task Modifier
+
+Async Operations:
+```swift
+struct UserProfileView: View {
+    let userId: String
+    @State private var user: User?
+    
+    var body: some View {
+        Group {
+            if let user { UserContent(user: user) }
+            else { ProgressView() }
+        }
+        .task { user = try? await api.fetchUser(userId) }
+    }
+}
+```
+
+Task with ID for Refresh:
+```swift
+struct SearchResultsView: View {
+    let query: String
+    @State private var results: [SearchResult] = []
+    
+    var body: some View {
+        List(results) { SearchResultRow(result: $0) }
+            .task(id: query) {
+                results = try? await searchService.search(query) ?? []
+            }
+    }
+}
+```
+
+### onChange Modifier
+
+Responding to State Changes:
+```swift
+struct SearchView: View {
+    @State private var searchText = ""
+    @State private var debouncedText = ""
+    
+    var body: some View {
+        TextField("Search", text: $searchText)
+            .onChange(of: searchText) { _, newValue in
+                Task {
+                    try? await Task.sleep(for: .milliseconds(300))
+                    if searchText == newValue { debouncedText = newValue }
+                }
+            }
+    }
+}
+```
+
+## Advanced Patterns
+
+### Preference Key
+
+Size Preference:
+```swift
+struct SizePreferenceKey: PreferenceKey {
+    static var defaultValue: CGSize = .zero
+    static func reduce(value: inout CGSize, nextValue: () -> CGSize) { value = nextValue() }
+}
+
+extension View {
+    func readSize(_ onChange: @escaping (CGSize) -> Void) -> some View {
+        background(GeometryReader { Color.clear.preference(key: SizePreferenceKey.self, value: $0.size) })
+            .onPreferenceChange(SizePreferenceKey.self, perform: onChange)
+    }
+}
+```
+
+### Custom View Modifiers
+
+Reusable Card Style:
+```swift
+struct CardModifier: ViewModifier {
+    func body(content: Content) -> some View {
+        content
+            .padding()
+            .background(Color(.systemBackground))
+            .cornerRadius(12)
+            .shadow(radius: 4)
+    }
+}
+
+extension View {
+    func cardStyle() -> some View { modifier(CardModifier()) }
+}
+```
+
+---
+
+Version: 2.0.0
+Last Updated: 2026-01-06
+Context7: /apple/swift, /SwiftUIX/SwiftUIX