API Reference

Muta.configure(apiKey: String)

// Using SwiftUI Color
func displayPlacement(
    placementId: String,
    backgroundColor: Color = .white,
    presentationType: PresentationType = .slide,
    loadingView: AnyView? = nil,
    injectedScreens: [InjectedScreen] = []
)

// Using hex color string
func displayPlacement(
    placementId: String,
    backgroundHexColor: String,
    presentationType: PresentationType = .slide,
    loadingView: AnyView? = nil,
    injectedScreens: [InjectedScreen] = []
)

// Subscribe to all events
func on(_ handler: @escaping (MutaEvent) -> Void) -> Subscription

// Subscribe to specific event type
func on<T: MutaEvent>(_ type: T.Type, handler: @escaping (T) -> Void) -> Subscription

protocol MutaEvent {
    var timestamp: Int { get }
    var placementId: String { get }
    var flowName: String? { get }
}

struct FlowStartedEvent: MutaEvent {
    let timestamp: Int
    let placementId: String
    let flowName: String?
    let totalScreens: Int
}

struct ScreenViewedEvent: MutaEvent {
    let timestamp: Int
    let placementId: String
    let flowName: String?
    let screenIndex: Int
    let totalScreens: Int
    let screenName: String?
}

struct FlowCompletedEvent: MutaEvent {
    let timestamp: Int
    let placementId: String
    let flowName: String
    let screenIndex: Int
    let totalScreens: Int
    let screenName: String
    let eventData: [String: Any]?  // Contains variables collected during the flow
}

struct FlowAbandonedEvent: MutaEvent {
    let timestamp: Int
    let placementId: String
    let flowName: String?
    let screenIndex: Int
    let totalScreens: Int
    let lastScreenIndex: Int
    let screenName: String?
}

struct CodeScreenDisplayedEvent {
    let screenId: String
    let screenName: String
    let timestamp: Int
}

struct CodeScreenActionEvent {
    let action: String         // "continue" or "back"
    let screenId: String
    let screenName: String
    let timestamp: Int
}

struct CustomEvent: MutaEvent {
    let type: String           // Your custom event name
    let timestamp: Int
    let placementId: String
    let flowName: String?
    let screenIndex: Int?
    let eventData: [String: Any]?  // Custom data from the editor
}

// Listen for custom events configured in the Muta editor
let subscription = Muta.shared.on(CustomEvent.self) { event in
    switch event.type {
    case "signup_started":
        // Handle signup button click
        navigateToSignup()
        
    case "plan_selected":
        // Handle plan selection with custom data
        if let planType = event.eventData?["planType"] as? String {
            selectPlan(planType)
        }
        
    case "survey_completed":
        // Handle survey completion
        if let answers = event.eventData?["answers"] as? [String: Any] {
            saveSurveyData(answers)
        }
        
    default:
        break
    }
}

struct InjectedScreen {
    let screenName: String                               // Must match name in Muta editor
    let view: (CodeScreenContext) -> AnyView             // Factory function for the view
}

struct CodeScreenContext {
    let onContinue: () -> Void                           // Navigate to configured continue destination
    let onBack: () -> Void                               // Navigate to configured back destination
    let variables: [[String: Any]]                       // Current flow variables
    let screenId: String                                 // Unique screen ID
    let screenIndex: Int                                 // Screen position in flow
}

// Inject a login screen into your flow
Muta.shared.displayPlacement(
    placementId: "onboarding",
    backgroundColor: .black,
    injectedScreens: [
        InjectedScreen(
            screenName: "Login Screen",
            view: { context in
                AnyView(LoginScreen(context: context))
            }
        )
    ]
)

enum ErrorEvent {
    case network(message: String, timestamp: Int)
    case placement(message: String, code: String, timestamp: Int, placementId: String)
}

import SwiftUI
import MutaSDK

@main
struct YourApp: App {
    init() {
        Muta.configure(apiKey: "your-api-key")
    }
    
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

struct ContentView: View {
    var body: some View {
        Button("Show Placement") {
            Muta.shared.displayPlacement(
                placementId: "your-placement-id",
                backgroundColor: .white,
                presentationType: .fade,
                loadingView: AnyView(
                    VStack {
                        ProgressView()
                        Text("Loading...")
                    }
                )
            )
        }
    }
}