go get github.com/hypen-lang/hypen-golang

package main

import (
    "github.com/hypen-lang/hypen-golang/core"
    "github.com/hypen-lang/hypen-golang/remote"
)

func main() {
    // Create a counter module
    counter := core.NewAppBuilder(map[string]any{"count": 0}, nil).
        OnAction("increment", func(ctx core.ActionHandlerContext) {
            count := ctx.State.Get("count").(int)
            ctx.State.Set("count", count+1)
        }).
        OnAction("decrement", func(ctx core.ActionHandlerContext) {
            count := ctx.State.Get("count").(int)
            ctx.State.Set("count", count-1)
        }).
        Build()

    // Start Remote UI server
    server := remote.NewServer(counter)
    server.Listen(":3000")
}

// Create observable state
state := core.NewObservableState(map[string]any{
    "user": map[string]any{
        "name": "Alice",
        "email": "alice@example.com",
    },
    "items": []string{},
}, &core.StateObserverOptions{
    OnChange: func(change core.StateChange) {
        fmt.Printf("Changed paths: %v\n", change.Paths)
    },
})

// Get values
name := state.Get("user.name").(string)

// Set values (triggers OnChange)
state.Set("user.name", "Bob")

// Batch multiple updates
state.BatchUpdate(func() {
    state.Set("user.name", "Charlie")
    state.Set("user.email", "charlie@example.com")
})

counter := core.NewAppBuilder(initialState, nil).
    OnAction("submit", func(ctx core.ActionHandlerContext) {
        // Access action details
        payload := ctx.Action.Payload.(map[string]any)

        // Modify state
        ctx.State.Set("submitted", true)

        // Navigate
        ctx.Next.Router.Push("/success")

        // Access other modules
        auth := ctx.Context.GetModule("auth")
        if auth != nil {
            // ...
        }
    }).
    Build()

router := core.NewHypenRouter("/")

// Navigate
router.Push("/users/123")
router.Replace("/login")
router.Back()
router.Forward()

// Get current route
route := router.CurrentRoute()
fmt.Println(route.Path)   // "/users/123"
fmt.Println(route.Params) // map[string]string{}

// Pattern matching
match, params := router.MatchPath("/users/:id")
// match = true, params = {"id": "123"}

// Listen for route changes
router.OnRouteChange(func(route core.Route) {
    fmt.Printf("Navigated to: %s\n", route.Path)
})

emitter := core.CreateEventEmitter()

// Subscribe to events
unsubscribe := emitter.On("userLoggedIn", func(payload any) {
    user := payload.(map[string]any)
    fmt.Printf("User logged in: %s\n", user["name"])
})

// Emit events
emitter.Emit("userLoggedIn", map[string]any{"name": "Alice"})

// Unsubscribe
unsubscribe()

// One-time listener
emitter.Once("ready", func(payload any) {
    fmt.Println("Ready!")
})

import "github.com/hypen-lang/hypen-golang/remote"

// Create server with your module
server := remote.NewServer(myModule)

// Configure options
server.SetOptions(remote.ServerOptions{
    HeartbeatInterval: 30 * time.Second,
    MaxConnections:    1000,
})

// Custom HTTP handler integration
http.HandleFunc("/ws", server.HandleWebSocket)
http.ListenAndServe(":3000", nil)

func TestCounter(t *testing.T) {
    // Create mock engine
    engine := core.NewMockEngine()

    // Build module with mock
    counter := core.NewAppBuilder(map[string]any{"count": 0}, engine).
        OnAction("increment", func(ctx core.ActionHandlerContext) {
            count := ctx.State.Get("count").(int)
            ctx.State.Set("count", count+1)
        }).
        Build()

    // Trigger action
    engine.TriggerAction("increment", nil)

    // Verify state
    count := counter.State().Get("count").(int)
    if count != 1 {
        t.Errorf("Expected count=1, got %d", count)
    }
}

// Load all components from a directory
loader := core.NewComponentLoader("./components")
components, err := loader.LoadAll()

// Load specific component
component, err := loader.Load("Counter")