Compare commits
1 Commits
main
...
issue-8-da
| Author | SHA1 | Date | |
|---|---|---|---|
79f994e6e8
|
@@ -1,418 +0,0 @@
|
||||
//go:build js && wasm
|
||||
|
||||
// Package main demonstrates OIDC authentication with Iris.
|
||||
//
|
||||
// This example shows:
|
||||
// - OIDC client setup
|
||||
// - Login/logout flow
|
||||
// - Protected routes with auth guard
|
||||
// - Displaying user info
|
||||
// - Token handling
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"strings"
|
||||
"syscall/js"
|
||||
|
||||
"git.flowmade.one/flowmade-one/iris/auth"
|
||||
"git.flowmade.one/flowmade-one/iris/navigation"
|
||||
"git.flowmade.one/flowmade-one/iris/reactive"
|
||||
"git.flowmade.one/flowmade-one/iris/ui"
|
||||
)
|
||||
|
||||
// Configuration - in production, these would come from environment/config
|
||||
const (
|
||||
// OIDC provider configuration
|
||||
// Update these values for your OIDC provider (e.g., Dex, Keycloak, Auth0)
|
||||
OIDCIssuer = "https://dex.example.com"
|
||||
ClientID = "iris-example-app"
|
||||
RedirectURI = "http://localhost:8080/callback"
|
||||
)
|
||||
|
||||
var (
|
||||
// Global OIDC client
|
||||
oidcClient *auth.OIDCClient
|
||||
|
||||
// Reactive state for authentication
|
||||
isAuthenticated = reactive.NewSignal(false)
|
||||
currentUser = reactive.NewSignal[*UserDisplay](nil)
|
||||
authError = reactive.NewSignal("")
|
||||
isLoading = reactive.NewSignal(false)
|
||||
|
||||
// Font presets
|
||||
fontTitle = ui.NewFont().Size("32px").Weight("700")
|
||||
fontHeading = ui.NewFont().Size("20px").Weight("600")
|
||||
)
|
||||
|
||||
// UserDisplay holds user information for display
|
||||
type UserDisplay struct {
|
||||
Email string
|
||||
Name string
|
||||
Sub string
|
||||
}
|
||||
|
||||
func main() {
|
||||
// Initialize OIDC client
|
||||
oidcClient = auth.NewOIDCClient(OIDCIssuer, ClientID, RedirectURI)
|
||||
|
||||
// Check for existing tokens on startup
|
||||
checkExistingSession()
|
||||
|
||||
// Check if this is an OAuth callback
|
||||
if isCallbackPath() {
|
||||
handleOAuthCallback()
|
||||
return
|
||||
}
|
||||
router := navigation.NewRouter(getRoutes())
|
||||
router.SetNotFoundHandler(notFoundView)
|
||||
navigation.SetGlobalRouter(router)
|
||||
|
||||
// Create the main app with router
|
||||
ui.NewAppWithRouter(router)
|
||||
|
||||
// Keep the application running
|
||||
select {}
|
||||
}
|
||||
|
||||
// getRoutes returns the route configuration for the application
|
||||
func getRoutes() []navigation.Route {
|
||||
return []navigation.Route{
|
||||
{
|
||||
Path: "/",
|
||||
Handler: homeView,
|
||||
},
|
||||
{
|
||||
Path: "/callback",
|
||||
Handler: callbackView,
|
||||
},
|
||||
{
|
||||
Path: "/profile",
|
||||
Handler: profileView,
|
||||
Guards: []navigation.RouteGuard{authGuard()},
|
||||
},
|
||||
{
|
||||
Path: "/protected",
|
||||
Handler: protectedView,
|
||||
Guards: []navigation.RouteGuard{authGuard()},
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// checkExistingSession checks for existing valid tokens
|
||||
func checkExistingSession() {
|
||||
if oidcClient.IsAuthenticated() {
|
||||
isAuthenticated.Set(true)
|
||||
loadUserFromToken()
|
||||
}
|
||||
}
|
||||
|
||||
// isCallbackPath checks if current path is the OAuth callback
|
||||
func isCallbackPath() bool {
|
||||
pathname := js.Global().Get("window").Get("location").Get("pathname").String()
|
||||
search := js.Global().Get("window").Get("location").Get("search").String()
|
||||
return pathname == "/callback" && strings.Contains(search, "code=")
|
||||
}
|
||||
|
||||
// handleOAuthCallback processes the OAuth callback
|
||||
func handleOAuthCallback() {
|
||||
isLoading.Set(true)
|
||||
|
||||
// Discover OIDC configuration and handle callback
|
||||
oidcClient.DiscoverConfigAsync(OIDCIssuer, func(err error) {
|
||||
if err != nil {
|
||||
authError.Set("Failed to load OIDC configuration: " + err.Error())
|
||||
isLoading.Set(false)
|
||||
renderApp()
|
||||
return
|
||||
}
|
||||
|
||||
// Exchange code for tokens
|
||||
tokens, err := oidcClient.HandleCallback(OIDCIssuer)
|
||||
if err != nil {
|
||||
authError.Set("Authentication failed: " + err.Error())
|
||||
isLoading.Set(false)
|
||||
renderApp()
|
||||
return
|
||||
}
|
||||
|
||||
// Store tokens
|
||||
oidcClient.StoreTokens(tokens)
|
||||
isAuthenticated.Set(true)
|
||||
loadUserFromToken()
|
||||
isLoading.Set(false)
|
||||
|
||||
// Clear URL parameters and redirect to home
|
||||
js.Global().Get("window").Get("history").Call("replaceState", nil, "", "/")
|
||||
renderApp()
|
||||
})
|
||||
}
|
||||
|
||||
// renderApp initializes and renders the app after callback processing
|
||||
func renderApp() {
|
||||
router := navigation.NewRouter(getRoutes())
|
||||
router.SetNotFoundHandler(notFoundView)
|
||||
navigation.SetGlobalRouter(router)
|
||||
|
||||
ui.NewAppWithRouter(router)
|
||||
|
||||
select {}
|
||||
}
|
||||
|
||||
// loadUserFromToken extracts user info from the ID token
|
||||
func loadUserFromToken() {
|
||||
tokens := oidcClient.GetStoredTokens()
|
||||
if tokens == nil || tokens.IDToken == "" {
|
||||
return
|
||||
}
|
||||
|
||||
// Parse the ID token to get user info (JWT payload is the second part)
|
||||
parts := strings.Split(tokens.IDToken, ".")
|
||||
if len(parts) != 3 {
|
||||
return
|
||||
}
|
||||
|
||||
// Decode the payload
|
||||
payload, err := base64.RawURLEncoding.DecodeString(parts[1])
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
var claims struct {
|
||||
Sub string `json:"sub"`
|
||||
Email string `json:"email"`
|
||||
Name string `json:"name"`
|
||||
}
|
||||
if err := json.Unmarshal(payload, &claims); err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
currentUser.Set(&UserDisplay{
|
||||
Email: claims.Email,
|
||||
Name: claims.Name,
|
||||
Sub: claims.Sub,
|
||||
})
|
||||
}
|
||||
|
||||
// authGuard creates a route guard that checks authentication
|
||||
func authGuard() navigation.RouteGuard {
|
||||
return navigation.AuthGuard(func() bool {
|
||||
return isAuthenticated.Get()
|
||||
})
|
||||
}
|
||||
|
||||
// login initiates the OIDC login flow
|
||||
func login() {
|
||||
isLoading.Set(true)
|
||||
authError.Set("")
|
||||
|
||||
oidcClient.DiscoverConfigAsync(OIDCIssuer, func(err error) {
|
||||
if err != nil {
|
||||
authError.Set("Failed to connect to authentication provider: " + err.Error())
|
||||
isLoading.Set(false)
|
||||
return
|
||||
}
|
||||
|
||||
if err := oidcClient.StartAuthFlow(); err != nil {
|
||||
authError.Set("Failed to start login: " + err.Error())
|
||||
isLoading.Set(false)
|
||||
}
|
||||
// Note: If successful, the browser will redirect to the OIDC provider
|
||||
})
|
||||
}
|
||||
|
||||
// logout clears authentication state
|
||||
func logout() {
|
||||
oidcClient.Logout()
|
||||
isAuthenticated.Set(false)
|
||||
currentUser.Set(nil)
|
||||
navigation.Navigate("/")
|
||||
}
|
||||
|
||||
// View functions
|
||||
|
||||
func homeView(params map[string]string) ui.View {
|
||||
return ui.VerticalGroup(
|
||||
header(),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("Iris Auth Example").
|
||||
Font(fontTitle).
|
||||
Margin("20px 0"),
|
||||
ui.TextFromString("This example demonstrates OIDC authentication with protected routes.").
|
||||
Color("#666"),
|
||||
ui.TextFromFunction(func() string {
|
||||
if authError.Get() != "" {
|
||||
return "Error: " + authError.Get()
|
||||
}
|
||||
return ""
|
||||
}).Color("#ff4444"),
|
||||
authSection(),
|
||||
).Padding("20px").MaxWidth("800px"),
|
||||
).Gap("0")
|
||||
}
|
||||
|
||||
func header() ui.View {
|
||||
return ui.HorizontalGroup(
|
||||
ui.TextFromString("Auth Example").Font(fontHeading),
|
||||
navigation.Link("/", ui.TextFromString("Home")),
|
||||
navigation.Link("/profile", ui.TextFromString("Profile")),
|
||||
navigation.Link("/protected", ui.TextFromString("Protected")),
|
||||
ui.Spacer(),
|
||||
authButton(),
|
||||
).Padding("16px 24px").Background("#f5f5f5").BorderBottom("1px solid #ddd")
|
||||
}
|
||||
|
||||
func authSection() ui.View {
|
||||
return ui.VerticalGroup(
|
||||
ui.TextFromFunction(func() string {
|
||||
if isLoading.Get() {
|
||||
return "Loading..."
|
||||
}
|
||||
if isAuthenticated.Get() {
|
||||
user := currentUser.Get()
|
||||
if user != nil {
|
||||
return "Welcome, " + user.Name + "!"
|
||||
}
|
||||
return "You are logged in."
|
||||
}
|
||||
return "You are not logged in."
|
||||
}).Margin("20px 0"),
|
||||
|
||||
ui.TextFromFunction(func() string {
|
||||
if isAuthenticated.Get() {
|
||||
return "Navigate to Profile or Protected pages to see authenticated content."
|
||||
}
|
||||
return "Click Login to authenticate with your OIDC provider."
|
||||
}).Color("#666"),
|
||||
).Padding("20px").Background("#fafafa").BorderRadius("8px").Margin("20px 0")
|
||||
}
|
||||
|
||||
func authButton() ui.View {
|
||||
return ui.Button(func() {
|
||||
if isAuthenticated.Get() {
|
||||
logout()
|
||||
} else {
|
||||
login()
|
||||
}
|
||||
}, ui.TextFromFunction(func() string {
|
||||
if isLoading.Get() {
|
||||
return "Loading..."
|
||||
}
|
||||
if isAuthenticated.Get() {
|
||||
return "Logout"
|
||||
}
|
||||
return "Login"
|
||||
})).Padding("8px 16px").Background("#007bff").Foreground("#fff").
|
||||
Border("none").BorderRadius("4px").Cursor("pointer")
|
||||
}
|
||||
|
||||
func callbackView(params map[string]string) ui.View {
|
||||
return ui.VerticalGroup(
|
||||
header(),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("Processing login...").Font(fontHeading),
|
||||
ui.TextFromString("Please wait while we complete authentication.").Color("#666"),
|
||||
).Padding("40px"),
|
||||
).Gap("0")
|
||||
}
|
||||
|
||||
func profileView(params map[string]string) ui.View {
|
||||
return ui.VerticalGroup(
|
||||
header(),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("User Profile").Font(fontTitle).Margin("20px 0"),
|
||||
userInfoCard(),
|
||||
tokenInfoCard(),
|
||||
).Padding("20px").MaxWidth("800px"),
|
||||
).Gap("0")
|
||||
}
|
||||
|
||||
func userInfoCard() ui.View {
|
||||
return ui.VerticalGroup(
|
||||
ui.TextFromString("User Information").Font(fontHeading),
|
||||
ui.TextFromFunction(func() string {
|
||||
user := currentUser.Get()
|
||||
if user == nil {
|
||||
return "No user information available"
|
||||
}
|
||||
return "Name: " + user.Name
|
||||
}),
|
||||
ui.TextFromFunction(func() string {
|
||||
user := currentUser.Get()
|
||||
if user == nil {
|
||||
return ""
|
||||
}
|
||||
return "Email: " + user.Email
|
||||
}),
|
||||
ui.TextFromFunction(func() string {
|
||||
user := currentUser.Get()
|
||||
if user == nil {
|
||||
return ""
|
||||
}
|
||||
return "Subject: " + user.Sub
|
||||
}).Color("#888"),
|
||||
).Padding("20px").Background("#fafafa").BorderRadius("8px").Margin("10px 0").Gap("8px")
|
||||
}
|
||||
|
||||
func tokenInfoCard() ui.View {
|
||||
return ui.VerticalGroup(
|
||||
ui.TextFromString("Token Information").Font(fontHeading),
|
||||
ui.TextFromFunction(func() string {
|
||||
tokens := oidcClient.GetStoredTokens()
|
||||
if tokens == nil {
|
||||
return "No tokens available"
|
||||
}
|
||||
return "Access Token: " + truncateToken(tokens.AccessToken)
|
||||
}),
|
||||
ui.TextFromFunction(func() string {
|
||||
tokens := oidcClient.GetStoredTokens()
|
||||
if tokens == nil {
|
||||
return ""
|
||||
}
|
||||
return "ID Token: " + truncateToken(tokens.IDToken)
|
||||
}),
|
||||
ui.TextFromFunction(func() string {
|
||||
authHeader := oidcClient.GetAuthHeader()
|
||||
if authHeader == "" {
|
||||
return ""
|
||||
}
|
||||
return "Auth Header: " + truncateToken(authHeader)
|
||||
}).Color("#888"),
|
||||
).Padding("20px").Background("#fafafa").BorderRadius("8px").Margin("10px 0").Gap("8px")
|
||||
}
|
||||
|
||||
func protectedView(params map[string]string) ui.View {
|
||||
return ui.VerticalGroup(
|
||||
header(),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("Protected Content").Font(fontTitle).Margin("20px 0"),
|
||||
ui.TextFromString("This page is only visible to authenticated users.").Color("#666"),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("Access Granted").Font(fontHeading).Color("#28a745"),
|
||||
ui.TextFromString("You have successfully accessed a protected route."),
|
||||
ui.TextFromString("The auth guard verified your authentication status before allowing access.").Color("#888"),
|
||||
).Padding("20px").Background("#e8f5e9").BorderRadius("8px").Margin("20px 0"),
|
||||
).Padding("20px").MaxWidth("800px"),
|
||||
).Gap("0")
|
||||
}
|
||||
|
||||
func notFoundView() ui.View {
|
||||
return ui.VerticalGroup(
|
||||
header(),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("404 - Page Not Found").Font(fontTitle).Color("#ff4444"),
|
||||
ui.TextFromString("The requested page could not be found.").Color("#666"),
|
||||
navigation.Link("/", ui.TextFromString("Go to Home").Color("#007bff")),
|
||||
).Padding("40px"),
|
||||
).Gap("0")
|
||||
}
|
||||
|
||||
// Helper functions
|
||||
|
||||
func truncateToken(token string) string {
|
||||
if len(token) <= 20 {
|
||||
return token
|
||||
}
|
||||
return token[:10] + "..." + token[len(token)-10:]
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
//go:build js && wasm
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"git.flowmade.one/flowmade-one/iris/reactive"
|
||||
"git.flowmade.one/flowmade-one/iris/ui"
|
||||
)
|
||||
|
||||
func main() {
|
||||
// Create a signal with initial value 0
|
||||
count := reactive.NewSignal(0)
|
||||
|
||||
view := ui.NewView()
|
||||
|
||||
// Reactive text that updates when count changes
|
||||
view.Child(ui.TextFromFunction(func() string {
|
||||
return fmt.Sprintf("Count: %d", count.Get())
|
||||
}))
|
||||
|
||||
// Button that increments the count on click
|
||||
view.Child(ui.Button(func() {
|
||||
count.Set(count.Get() + 1)
|
||||
}, ui.TextFromString("Increment")))
|
||||
|
||||
// Button that decrements the count on click
|
||||
view.Child(ui.Button(func() {
|
||||
count.Set(count.Get() - 1)
|
||||
}, ui.TextFromString("Decrement")))
|
||||
|
||||
ui.NewApp(view)
|
||||
|
||||
select {}
|
||||
}
|
||||
@@ -1,265 +0,0 @@
|
||||
//go:build js && wasm
|
||||
|
||||
// Package main demonstrates Iris client-side routing capabilities.
|
||||
//
|
||||
// This example shows:
|
||||
// - Router setup with multiple routes
|
||||
// - Route parameters (/users/:id)
|
||||
// - Navigation between pages using Link and Navigate
|
||||
// - Route guards for protected routes
|
||||
// - History management (back/forward)
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"git.flowmade.one/flowmade-one/iris/navigation"
|
||||
"git.flowmade.one/flowmade-one/iris/reactive"
|
||||
"git.flowmade.one/flowmade-one/iris/ui"
|
||||
)
|
||||
|
||||
// Global auth state to demonstrate route guards
|
||||
var isAuthenticated = reactive.NewSignal(false)
|
||||
|
||||
func main() {
|
||||
// Define routes with their handlers and guards
|
||||
routes := []navigation.Route{
|
||||
{Path: "/", Handler: homePage},
|
||||
{Path: "/about", Handler: aboutPage},
|
||||
{Path: "/users", Handler: usersPage},
|
||||
{Path: "/users/:id", Handler: userDetailPage, Guards: []navigation.RouteGuard{
|
||||
navigation.NumericIdGuard(),
|
||||
}},
|
||||
{Path: "/admin", Handler: adminPage, Guards: []navigation.RouteGuard{
|
||||
navigation.AuthGuard(func() bool { return isAuthenticated.Get() }),
|
||||
}},
|
||||
}
|
||||
|
||||
// Create router and set up navigation
|
||||
router := navigation.NewRouter(routes)
|
||||
router.SetNotFoundHandler(notFoundPage)
|
||||
navigation.SetGlobalRouter(router)
|
||||
|
||||
// Mount the app with router support
|
||||
ui.NewAppWithRouter(router)
|
||||
|
||||
// Keep the application running
|
||||
select {}
|
||||
}
|
||||
|
||||
// homePage renders the landing page with navigation links
|
||||
func homePage(params map[string]string) ui.View {
|
||||
return pageLayout("Home",
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("Welcome to the Iris Multi-Page Demo").
|
||||
Color("#333").
|
||||
Padding("16px"),
|
||||
ui.TextFromString("This example demonstrates client-side routing with:").
|
||||
Color("#666").
|
||||
Padding("8px"),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("- Multiple routes and page navigation").Color("#888"),
|
||||
ui.TextFromString("- Route parameters (see /users/:id)").Color("#888"),
|
||||
ui.TextFromString("- Route guards for protected pages").Color("#888"),
|
||||
ui.TextFromString("- Browser history integration").Color("#888"),
|
||||
).Padding("8px 24px"),
|
||||
ui.TextFromString("Use the navigation bar above to explore.").
|
||||
Color("#666").
|
||||
Padding("16px"),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
// aboutPage renders information about the demo
|
||||
func aboutPage(params map[string]string) ui.View {
|
||||
return pageLayout("About",
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("About Iris Navigation").
|
||||
Color("#333").
|
||||
Padding("16px"),
|
||||
ui.TextFromString("The navigation package provides:").
|
||||
Color("#666").
|
||||
Padding("8px"),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("Router - Define routes with path patterns and handlers").Color("#888"),
|
||||
ui.TextFromString("RouteGuard - Protect routes with custom logic").Color("#888"),
|
||||
ui.TextFromString("HistoryManager - Integrate with browser history").Color("#888"),
|
||||
ui.TextFromString("Link - Create navigational elements").Color("#888"),
|
||||
ui.TextFromString("Navigate/Back/Forward - Programmatic navigation").Color("#888"),
|
||||
).Padding("8px 24px"),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
// usersPage renders a list of users with links to their detail pages
|
||||
func usersPage(params map[string]string) ui.View {
|
||||
users := []struct {
|
||||
ID string
|
||||
Name string
|
||||
}{
|
||||
{"1", "Alice"},
|
||||
{"2", "Bob"},
|
||||
{"3", "Charlie"},
|
||||
{"4", "Diana"},
|
||||
}
|
||||
|
||||
var userLinks []ui.View
|
||||
for _, user := range users {
|
||||
// Capture user in closure
|
||||
u := user
|
||||
userLinks = append(userLinks,
|
||||
navigation.Link(fmt.Sprintf("/users/%s", u.ID),
|
||||
ui.TextFromString(fmt.Sprintf("View %s (ID: %s)", u.Name, u.ID)).
|
||||
Color("#0066cc"),
|
||||
).Padding("8px").Cursor("pointer"),
|
||||
)
|
||||
}
|
||||
|
||||
return pageLayout("Users",
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("User Directory").
|
||||
Color("#333").
|
||||
Padding("16px"),
|
||||
ui.TextFromString("Click a user to see their details:").
|
||||
Color("#666").
|
||||
Padding("8px"),
|
||||
ui.VerticalGroup(userLinks...).Padding("8px"),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
// userDetailPage shows details for a specific user using the :id parameter
|
||||
func userDetailPage(params map[string]string) ui.View {
|
||||
userID := params["id"]
|
||||
|
||||
// Simulated user data
|
||||
userData := map[string]struct {
|
||||
Name string
|
||||
Email string
|
||||
Role string
|
||||
}{
|
||||
"1": {"Alice", "alice@example.com", "Admin"},
|
||||
"2": {"Bob", "bob@example.com", "User"},
|
||||
"3": {"Charlie", "charlie@example.com", "User"},
|
||||
"4": {"Diana", "diana@example.com", "Moderator"},
|
||||
}
|
||||
|
||||
user, exists := userData[userID]
|
||||
if !exists {
|
||||
return pageLayout("User Not Found",
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString(fmt.Sprintf("User with ID %s not found", userID)).
|
||||
Color("#ff4444").
|
||||
Padding("16px"),
|
||||
ui.Button(func() {
|
||||
navigation.Navigate("/users")
|
||||
}, ui.TextFromString("Back to Users")).
|
||||
Padding("8px"),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
return pageLayout(fmt.Sprintf("User: %s", user.Name),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString(fmt.Sprintf("User Details (ID: %s)", userID)).
|
||||
Color("#333").
|
||||
Padding("16px"),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString(fmt.Sprintf("Name: %s", user.Name)).Color("#666"),
|
||||
ui.TextFromString(fmt.Sprintf("Email: %s", user.Email)).Color("#666"),
|
||||
ui.TextFromString(fmt.Sprintf("Role: %s", user.Role)).Color("#666"),
|
||||
).Padding("8px 24px"),
|
||||
ui.HorizontalGroup(
|
||||
ui.Button(func() {
|
||||
navigation.Back()
|
||||
}, ui.TextFromString("Go Back")).Padding("8px"),
|
||||
ui.Button(func() {
|
||||
navigation.Navigate("/users")
|
||||
}, ui.TextFromString("All Users")).Padding("8px"),
|
||||
).Padding("16px"),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
// adminPage is a protected route that requires authentication
|
||||
func adminPage(params map[string]string) ui.View {
|
||||
return pageLayout("Admin",
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("Admin Dashboard").
|
||||
Color("#333").
|
||||
Padding("16px"),
|
||||
ui.TextFromString("Welcome to the protected admin area!").
|
||||
Color("#28a745").
|
||||
Padding("8px"),
|
||||
ui.TextFromString("This page is protected by an AuthGuard.").
|
||||
Color("#666").
|
||||
Padding("8px"),
|
||||
ui.Button(func() {
|
||||
isAuthenticated.Set(false)
|
||||
navigation.Navigate("/")
|
||||
}, ui.TextFromString("Logout")).
|
||||
Padding("8px").
|
||||
Background("#dc3545").
|
||||
Foreground("#fff"),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
// notFoundPage renders when no route matches
|
||||
func notFoundPage() ui.View {
|
||||
return pageLayout("404",
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString("404 - Page Not Found").
|
||||
Color("#ff4444").
|
||||
Padding("16px"),
|
||||
ui.TextFromString("The page you are looking for does not exist.").
|
||||
Color("#666").
|
||||
Padding("8px"),
|
||||
ui.Button(func() {
|
||||
navigation.Navigate("/")
|
||||
}, ui.TextFromString("Go Home")).Padding("8px"),
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
// pageLayout provides consistent page structure with navigation
|
||||
func pageLayout(title string, content ui.View) ui.View {
|
||||
return ui.VerticalGroup(
|
||||
navBar(),
|
||||
ui.VerticalGroup(
|
||||
ui.TextFromString(title).
|
||||
Color("#333").
|
||||
Padding("8px").
|
||||
Background("#f0f0f0").
|
||||
Width("100%"),
|
||||
content,
|
||||
).Padding("16px"),
|
||||
).MinHeight("100vh")
|
||||
}
|
||||
|
||||
// navBar creates the navigation header with links
|
||||
func navBar() ui.View {
|
||||
return ui.HorizontalGroup(
|
||||
navigation.Link("/", ui.TextFromString("Home").Color("#fff")),
|
||||
navigation.Link("/about", ui.TextFromString("About").Color("#fff")),
|
||||
navigation.Link("/users", ui.TextFromString("Users").Color("#fff")),
|
||||
authButton(),
|
||||
).Background("#333").Padding("8px 16px").AlignItems("center")
|
||||
}
|
||||
|
||||
// authButton shows login/admin based on auth state
|
||||
func authButton() ui.View {
|
||||
return ui.Button(func() {
|
||||
if isAuthenticated.Get() {
|
||||
navigation.Navigate("/admin")
|
||||
} else {
|
||||
isAuthenticated.Set(true)
|
||||
navigation.Navigate("/admin")
|
||||
}
|
||||
}, ui.TextFromFunction(func() string {
|
||||
if isAuthenticated.Get() {
|
||||
return "Admin"
|
||||
}
|
||||
return "Login"
|
||||
}).Color("#fff")).Background("transparent").Border("1px solid #fff").Padding("4px 12px").Cursor("pointer")
|
||||
}
|
||||
@@ -1,195 +0,0 @@
|
||||
//go:build js && wasm
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"syscall/js"
|
||||
|
||||
"git.flowmade.one/flowmade-one/iris/reactive"
|
||||
"git.flowmade.one/flowmade-one/iris/ui"
|
||||
)
|
||||
|
||||
// Todo represents a single todo item
|
||||
type Todo struct {
|
||||
ID int
|
||||
Text string
|
||||
Completed bool
|
||||
}
|
||||
|
||||
func main() {
|
||||
// Signal holding the list of todos
|
||||
todos := reactive.NewSignal([]Todo{})
|
||||
|
||||
// Signal for the input field
|
||||
inputText := reactive.NewSignal("")
|
||||
|
||||
// Counter for generating unique IDs
|
||||
nextID := reactive.NewSignal(1)
|
||||
|
||||
// Create the main app view
|
||||
view := ui.VerticalGroup(
|
||||
// Title
|
||||
ui.TextFromString("Todo List").Padding("16px 0"),
|
||||
|
||||
// Input row: text input + add button
|
||||
inputRow(&inputText, func() {
|
||||
text := inputText.Get()
|
||||
if text == "" {
|
||||
return
|
||||
}
|
||||
|
||||
// Add new todo
|
||||
id := nextID.Get()
|
||||
nextID.Set(id + 1)
|
||||
|
||||
currentTodos := todos.Get()
|
||||
newTodos := append(currentTodos, Todo{
|
||||
ID: id,
|
||||
Text: text,
|
||||
Completed: false,
|
||||
})
|
||||
todos.Set(newTodos)
|
||||
|
||||
// Clear input
|
||||
inputText.Set("")
|
||||
}),
|
||||
|
||||
// Todo list
|
||||
todoList(&todos),
|
||||
|
||||
// Summary text showing completed count
|
||||
ui.TextFromFunction(func() string {
|
||||
allTodos := todos.Get()
|
||||
if len(allTodos) == 0 {
|
||||
return "No todos yet"
|
||||
}
|
||||
|
||||
completed := 0
|
||||
for _, t := range allTodos {
|
||||
if t.Completed {
|
||||
completed++
|
||||
}
|
||||
}
|
||||
return fmt.Sprintf("%d of %d completed", completed, len(allTodos))
|
||||
}).Padding("16px 0"),
|
||||
).MaxWidth("400px").Padding("24px")
|
||||
|
||||
ui.NewApp(view)
|
||||
|
||||
select {}
|
||||
}
|
||||
|
||||
// inputRow creates the input field and add button
|
||||
func inputRow(inputText *reactive.Signal[string], onAdd func()) ui.View {
|
||||
row := ui.NewView()
|
||||
row.Display("flex").Gap("8px").Width("100%")
|
||||
|
||||
// Text input
|
||||
input := ui.TextInput(inputText, "What needs to be done?")
|
||||
input.Width("100%")
|
||||
|
||||
// Handle Enter key to add todo
|
||||
input.Element().OnWithEvent("keypress", func(event js.Value) {
|
||||
if event.Get("key").String() == "Enter" {
|
||||
onAdd()
|
||||
}
|
||||
})
|
||||
|
||||
// Add button
|
||||
addBtn := ui.Button(onAdd, ui.TextFromString("Add"))
|
||||
addBtn.Padding("8px 16px")
|
||||
|
||||
row.Child(input)
|
||||
row.Child(addBtn)
|
||||
|
||||
return row
|
||||
}
|
||||
|
||||
// todoList renders the list of todos reactively
|
||||
func todoList(todos *reactive.Signal[[]Todo]) ui.View {
|
||||
container := ui.NewView()
|
||||
container.Width("100%")
|
||||
|
||||
// Effect that re-renders the list when todos change
|
||||
reactive.NewEffect(func() {
|
||||
allTodos := todos.Get()
|
||||
|
||||
// Clear existing children
|
||||
container.Element().ClearChildren()
|
||||
|
||||
// Render each todo item
|
||||
for _, todo := range allTodos {
|
||||
item := todoItem(todo, todos)
|
||||
container.Child(item)
|
||||
}
|
||||
|
||||
// Show empty state if no todos
|
||||
if len(allTodos) == 0 {
|
||||
emptyText := ui.TextFromString("Add your first todo above")
|
||||
emptyText.Color("#666").Padding("16px 0").TextAlign("center")
|
||||
container.Child(emptyText)
|
||||
}
|
||||
})
|
||||
|
||||
return container
|
||||
}
|
||||
|
||||
// todoItem renders a single todo item with toggle and delete
|
||||
func todoItem(todo Todo, todos *reactive.Signal[[]Todo]) ui.View {
|
||||
row := ui.NewView()
|
||||
row.Display("flex").Gap("12px").Padding("8px 0").Width("100%").AlignItems("center")
|
||||
row.BorderBottom("1px solid #eee")
|
||||
|
||||
// Completed checkbox using public ui.RawCheckbox
|
||||
checkbox := ui.RawCheckbox(todo.Completed, func(isChecked bool) {
|
||||
toggleTodo(todos, todo.ID, isChecked)
|
||||
})
|
||||
|
||||
// Todo text with strikethrough if completed
|
||||
textView := ui.NewView()
|
||||
textView.Display("flex").Width("100%")
|
||||
text := ui.Span(todo.Text)
|
||||
if todo.Completed {
|
||||
text.TextDecoration("line-through").Color("#999")
|
||||
}
|
||||
textView.Child(text)
|
||||
|
||||
// Delete button
|
||||
deleteBtn := ui.Button(func() {
|
||||
deleteTodo(todos, todo.ID)
|
||||
}, ui.TextFromString("X"))
|
||||
deleteBtn.Padding("4px 8px")
|
||||
|
||||
row.Child(checkbox)
|
||||
row.Child(textView)
|
||||
row.Child(deleteBtn)
|
||||
|
||||
return row
|
||||
}
|
||||
|
||||
// toggleTodo updates the completed status of a todo
|
||||
func toggleTodo(todos *reactive.Signal[[]Todo], id int, completed bool) {
|
||||
currentTodos := todos.Get()
|
||||
newTodos := make([]Todo, len(currentTodos))
|
||||
for i, t := range currentTodos {
|
||||
if t.ID == id {
|
||||
newTodos[i] = Todo{ID: t.ID, Text: t.Text, Completed: completed}
|
||||
} else {
|
||||
newTodos[i] = t
|
||||
}
|
||||
}
|
||||
todos.Set(newTodos)
|
||||
}
|
||||
|
||||
// deleteTodo removes a todo from the list
|
||||
func deleteTodo(todos *reactive.Signal[[]Todo], id int) {
|
||||
currentTodos := todos.Get()
|
||||
newTodos := make([]Todo, 0, len(currentTodos))
|
||||
for _, t := range currentTodos {
|
||||
if t.ID != id {
|
||||
newTodos = append(newTodos, t)
|
||||
}
|
||||
}
|
||||
todos.Set(newTodos)
|
||||
}
|
||||
111
host/README.md
111
host/README.md
@@ -36,9 +36,9 @@ myapp/
|
||||
|
||||
The server serves files from the specified public directory. Any request path maps directly to files:
|
||||
|
||||
- `/` -> `public/index.html`
|
||||
- `/app.wasm` -> `public/app.wasm`
|
||||
- `/styles.css` -> `public/styles.css`
|
||||
- `/` → `public/index.html`
|
||||
- `/app.wasm` → `public/app.wasm`
|
||||
- `/styles.css` → `public/styles.css`
|
||||
|
||||
**SPA Fallback**: Unknown paths and directories fall back to `index.html`, enabling client-side routing.
|
||||
|
||||
@@ -68,109 +68,28 @@ Gzip compression is automatically applied to compressible content types when the
|
||||
|
||||
Binary assets (PNG, JPEG, etc.) are served uncompressed since they're already compressed.
|
||||
|
||||
## Hot Reload (Development)
|
||||
## Development vs Production
|
||||
|
||||
The `DevServer` provides automatic rebuild and browser reload during development:
|
||||
|
||||
```go
|
||||
package main
|
||||
|
||||
import (
|
||||
"git.flowmade.one/flowmade-one/iris/host"
|
||||
)
|
||||
|
||||
func main() {
|
||||
// Create dev server with hot reload
|
||||
dev := host.NewDevServer(
|
||||
"public", // Static files directory
|
||||
"index.html", // Index file
|
||||
".", // Source directory to watch
|
||||
"public/app.wasm", // WASM output path
|
||||
)
|
||||
|
||||
// Start watching and serving
|
||||
dev.ListenAndServe(":8080")
|
||||
}
|
||||
```
|
||||
|
||||
### How It Works
|
||||
|
||||
1. **File Watcher**: Monitors `.go` files in the source directory for changes
|
||||
2. **Auto Build**: Runs `GOOS=js GOARCH=wasm go build` when changes are detected
|
||||
3. **Browser Reload**: Injects a WebSocket client into HTML pages that triggers reload on build success
|
||||
|
||||
### Directory Structure for Development
|
||||
|
||||
```
|
||||
myapp/
|
||||
├── main.go # WASM application entry point
|
||||
├── server/
|
||||
│ └── main.go # Dev server (code above)
|
||||
└── public/
|
||||
├── index.html
|
||||
├── app.wasm # Generated by dev server
|
||||
└── wasm_exec.js
|
||||
```
|
||||
|
||||
### Workflow
|
||||
|
||||
1. Start the dev server: `go run ./server`
|
||||
2. Open `http://localhost:8080` in your browser
|
||||
3. Edit your Go source files
|
||||
4. Save - the browser automatically reloads with your changes
|
||||
|
||||
### Custom Watch Configuration
|
||||
|
||||
```go
|
||||
// Watch additional file types
|
||||
watcher := host.NewWatcher(
|
||||
".",
|
||||
onChangeCallback,
|
||||
host.WithExtensions(".go", ".html", ".css"),
|
||||
host.WithInterval(100*time.Millisecond),
|
||||
)
|
||||
```
|
||||
|
||||
### Manual Components
|
||||
|
||||
For advanced use cases, you can use the individual components:
|
||||
|
||||
```go
|
||||
// File watcher
|
||||
watcher := host.NewWatcher(".", func() {
|
||||
log.Println("Files changed")
|
||||
})
|
||||
watcher.Start()
|
||||
defer watcher.Stop()
|
||||
|
||||
// WASM builder
|
||||
builder := host.NewBuilder(".", "public/app.wasm")
|
||||
result := builder.Build()
|
||||
if result.Success {
|
||||
log.Println("Build succeeded")
|
||||
}
|
||||
|
||||
// Live reload (WebSocket notifications)
|
||||
lr := host.NewLiveReload()
|
||||
http.Handle("/__livereload", lr)
|
||||
lr.NotifyReload() // Triggers reload in all connected browsers
|
||||
```
|
||||
|
||||
## Production
|
||||
|
||||
For production, use the standard `Server` instead of `DevServer`:
|
||||
### Development
|
||||
|
||||
```go
|
||||
func main() {
|
||||
server := host.New("public", "index.html")
|
||||
log.Fatal(http.ListenAndServe(":8080", server))
|
||||
http.ListenAndServe(":8080", server)
|
||||
}
|
||||
```
|
||||
|
||||
Compile and deploy:
|
||||
Run with:
|
||||
```bash
|
||||
go run server.go
|
||||
```
|
||||
|
||||
### Production
|
||||
|
||||
For production, compile the server and run as a binary:
|
||||
|
||||
```bash
|
||||
go build -o server ./server
|
||||
go build -o server ./server.go
|
||||
./server
|
||||
```
|
||||
|
||||
|
||||
@@ -1,85 +0,0 @@
|
||||
package host
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"os/exec"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// Builder compiles Go source to WASM.
|
||||
type Builder struct {
|
||||
sourceDir string
|
||||
outputPath string
|
||||
|
||||
mu sync.Mutex
|
||||
building bool
|
||||
}
|
||||
|
||||
// BuildResult contains the result of a build operation.
|
||||
type BuildResult struct {
|
||||
Success bool
|
||||
Output string
|
||||
Error error
|
||||
}
|
||||
|
||||
// NewBuilder creates a new WASM builder.
|
||||
// sourceDir is the directory containing Go source files.
|
||||
// outputPath is the target WASM file path.
|
||||
func NewBuilder(sourceDir, outputPath string) *Builder {
|
||||
return &Builder{
|
||||
sourceDir: sourceDir,
|
||||
outputPath: outputPath,
|
||||
}
|
||||
}
|
||||
|
||||
// Build compiles the Go source to WASM.
|
||||
func (b *Builder) Build() BuildResult {
|
||||
b.mu.Lock()
|
||||
if b.building {
|
||||
b.mu.Unlock()
|
||||
return BuildResult{
|
||||
Success: false,
|
||||
Output: "Build already in progress",
|
||||
Error: fmt.Errorf("build already in progress"),
|
||||
}
|
||||
}
|
||||
b.building = true
|
||||
b.mu.Unlock()
|
||||
|
||||
defer func() {
|
||||
b.mu.Lock()
|
||||
b.building = false
|
||||
b.mu.Unlock()
|
||||
}()
|
||||
|
||||
cmd := exec.Command("go", "build", "-o", b.outputPath, b.sourceDir)
|
||||
cmd.Env = append(cmd.Environ(), "GOOS=js", "GOARCH=wasm")
|
||||
|
||||
var stdout, stderr bytes.Buffer
|
||||
cmd.Stdout = &stdout
|
||||
cmd.Stderr = &stderr
|
||||
|
||||
err := cmd.Run()
|
||||
output := stdout.String() + stderr.String()
|
||||
|
||||
if err != nil {
|
||||
return BuildResult{
|
||||
Success: false,
|
||||
Output: output,
|
||||
Error: err,
|
||||
}
|
||||
}
|
||||
|
||||
return BuildResult{
|
||||
Success: true,
|
||||
Output: output,
|
||||
}
|
||||
}
|
||||
|
||||
// IsBuilding returns true if a build is currently in progress.
|
||||
func (b *Builder) IsBuilding() bool {
|
||||
b.mu.Lock()
|
||||
defer b.mu.Unlock()
|
||||
return b.building
|
||||
}
|
||||
@@ -1,222 +0,0 @@
|
||||
package host
|
||||
|
||||
import (
|
||||
"compress/gzip"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// DevServer provides a development server with hot reload support.
|
||||
// It watches source files, rebuilds WASM on changes, and notifies
|
||||
// connected browsers to reload.
|
||||
type DevServer struct {
|
||||
publicDir string
|
||||
indexFile string
|
||||
sourceDir string
|
||||
outputPath string
|
||||
|
||||
watcher *Watcher
|
||||
builder *Builder
|
||||
liveReload *LiveReload
|
||||
logger *log.Logger
|
||||
}
|
||||
|
||||
// DevServerOption configures a DevServer.
|
||||
type DevServerOption func(*DevServer)
|
||||
|
||||
// WithLogger sets a custom logger for the dev server.
|
||||
func WithLogger(logger *log.Logger) DevServerOption {
|
||||
return func(d *DevServer) {
|
||||
d.logger = logger
|
||||
}
|
||||
}
|
||||
|
||||
// NewDevServer creates a new development server with hot reload.
|
||||
//
|
||||
// Parameters:
|
||||
// - publicDir: Directory containing static files (e.g., "public")
|
||||
// - indexFile: The fallback HTML file (e.g., "index.html")
|
||||
// - sourceDir: Directory containing Go source files to watch (e.g., ".")
|
||||
// - outputPath: Target path for compiled WASM file (e.g., "public/app.wasm")
|
||||
func NewDevServer(publicDir, indexFile, sourceDir, outputPath string, opts ...DevServerOption) *DevServer {
|
||||
d := &DevServer{
|
||||
publicDir: publicDir,
|
||||
indexFile: indexFile,
|
||||
sourceDir: sourceDir,
|
||||
outputPath: outputPath,
|
||||
logger: log.New(os.Stdout, "[iris] ", log.LstdFlags),
|
||||
}
|
||||
|
||||
for _, opt := range opts {
|
||||
opt(d)
|
||||
}
|
||||
|
||||
d.liveReload = NewLiveReload()
|
||||
d.builder = NewBuilder(sourceDir, outputPath)
|
||||
|
||||
d.watcher = NewWatcher(sourceDir, d.onFileChange,
|
||||
WithExtensions(".go"),
|
||||
WithInterval(500*time.Millisecond),
|
||||
)
|
||||
|
||||
return d
|
||||
}
|
||||
|
||||
// Start begins watching for file changes.
|
||||
func (d *DevServer) Start() error {
|
||||
// Initial build
|
||||
d.logger.Println("Performing initial build...")
|
||||
result := d.builder.Build()
|
||||
if !result.Success {
|
||||
d.logger.Printf("Initial build failed: %v\n%s", result.Error, result.Output)
|
||||
} else {
|
||||
d.logger.Println("Initial build succeeded")
|
||||
}
|
||||
|
||||
// Start watcher
|
||||
d.logger.Printf("Watching %s for changes...", d.sourceDir)
|
||||
return d.watcher.Start()
|
||||
}
|
||||
|
||||
// Stop stops the file watcher.
|
||||
func (d *DevServer) Stop() {
|
||||
d.watcher.Stop()
|
||||
}
|
||||
|
||||
// ServeHTTP implements http.Handler interface.
|
||||
func (d *DevServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
// Handle live reload WebSocket endpoint
|
||||
if r.URL.Path == "/__livereload" {
|
||||
d.liveReload.ServeHTTP(w, r)
|
||||
return
|
||||
}
|
||||
|
||||
p := filepath.Join(d.publicDir, filepath.Clean(r.URL.Path))
|
||||
|
||||
if info, err := os.Stat(p); err != nil {
|
||||
d.serveHTMLWithInjection(w, r, filepath.Join(d.publicDir, d.indexFile))
|
||||
return
|
||||
} else if info.IsDir() {
|
||||
d.serveHTMLWithInjection(w, r, filepath.Join(d.publicDir, d.indexFile))
|
||||
return
|
||||
}
|
||||
|
||||
// Check if this is an HTML file
|
||||
if strings.HasSuffix(p, ".html") {
|
||||
d.serveHTMLWithInjection(w, r, p)
|
||||
return
|
||||
}
|
||||
|
||||
// Serve other files with compression
|
||||
d.serveFileWithCompression(w, r, p)
|
||||
}
|
||||
|
||||
func (d *DevServer) onFileChange() {
|
||||
d.logger.Println("File change detected, rebuilding...")
|
||||
|
||||
result := d.builder.Build()
|
||||
if !result.Success {
|
||||
d.logger.Printf("Build failed: %v\n%s", result.Error, result.Output)
|
||||
return
|
||||
}
|
||||
|
||||
d.logger.Println("Build succeeded, reloading browsers...")
|
||||
d.liveReload.NotifyReload()
|
||||
}
|
||||
|
||||
func (d *DevServer) serveHTMLWithInjection(w http.ResponseWriter, r *http.Request, filePath string) {
|
||||
// Read HTML file
|
||||
content, err := os.ReadFile(filePath)
|
||||
if err != nil {
|
||||
http.Error(w, "File not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
|
||||
// Inject reload script
|
||||
content = InjectReloadScript(content)
|
||||
|
||||
// Set headers
|
||||
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
||||
w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
|
||||
|
||||
// Check if client accepts gzip
|
||||
if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
|
||||
w.Header().Set("Content-Encoding", "gzip")
|
||||
w.Header().Set("Vary", "Accept-Encoding")
|
||||
|
||||
gz := gzip.NewWriter(w)
|
||||
defer gz.Close()
|
||||
|
||||
gz.Write(content)
|
||||
} else {
|
||||
w.Write(content)
|
||||
}
|
||||
}
|
||||
|
||||
func (d *DevServer) serveFileWithCompression(w http.ResponseWriter, r *http.Request, filePath string) {
|
||||
// Check if client accepts gzip
|
||||
if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
|
||||
http.ServeFile(w, r, filePath)
|
||||
return
|
||||
}
|
||||
|
||||
// Open and read file
|
||||
file, err := os.Open(filePath)
|
||||
if err != nil {
|
||||
http.Error(w, "File not found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
defer file.Close()
|
||||
|
||||
// Get file info for headers
|
||||
fileInfo, err := file.Stat()
|
||||
if err != nil {
|
||||
http.Error(w, "Error reading file", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
// Set content type based on file extension
|
||||
contentType := getContentType(filepath.Ext(filePath))
|
||||
w.Header().Set("Content-Type", contentType)
|
||||
|
||||
// Disable caching in dev mode for WASM files
|
||||
if strings.HasSuffix(filePath, ".wasm") {
|
||||
w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
|
||||
}
|
||||
|
||||
// Check if we should compress this file type
|
||||
if shouldCompress(contentType) {
|
||||
// Set gzip headers
|
||||
w.Header().Set("Content-Encoding", "gzip")
|
||||
w.Header().Set("Vary", "Accept-Encoding")
|
||||
|
||||
// Create gzip writer
|
||||
gz := gzip.NewWriter(w)
|
||||
defer gz.Close()
|
||||
|
||||
// Copy file content through gzip
|
||||
_, err = io.Copy(gz, file)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
} else {
|
||||
// Serve without compression
|
||||
http.ServeContent(w, r, fileInfo.Name(), fileInfo.ModTime(), file)
|
||||
}
|
||||
}
|
||||
|
||||
// ListenAndServe starts the development server on the specified address.
|
||||
func (d *DevServer) ListenAndServe(addr string) error {
|
||||
if err := d.Start(); err != nil {
|
||||
return fmt.Errorf("failed to start watcher: %w", err)
|
||||
}
|
||||
|
||||
d.logger.Printf("Development server running on http://%s", addr)
|
||||
return http.ListenAndServe(addr, d)
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
package host
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// ReloadScript is the JavaScript code injected into HTML pages for hot reload.
|
||||
const ReloadScript = `<script>
|
||||
(function() {
|
||||
var wsUrl = 'ws://' + window.location.host + '/__livereload';
|
||||
var ws;
|
||||
var reconnectAttempts = 0;
|
||||
var maxReconnectDelay = 5000;
|
||||
|
||||
function connect() {
|
||||
ws = new WebSocket(wsUrl);
|
||||
|
||||
ws.onopen = function() {
|
||||
console.log('[iris] Hot reload connected');
|
||||
reconnectAttempts = 0;
|
||||
};
|
||||
|
||||
ws.onmessage = function(event) {
|
||||
if (event.data === 'reload') {
|
||||
console.log('[iris] Reloading...');
|
||||
window.location.reload();
|
||||
}
|
||||
};
|
||||
|
||||
ws.onclose = function() {
|
||||
var delay = Math.min(1000 * Math.pow(2, reconnectAttempts), maxReconnectDelay);
|
||||
reconnectAttempts++;
|
||||
console.log('[iris] Connection lost. Reconnecting in ' + delay + 'ms...');
|
||||
setTimeout(connect, delay);
|
||||
};
|
||||
|
||||
ws.onerror = function() {
|
||||
ws.close();
|
||||
};
|
||||
}
|
||||
|
||||
connect();
|
||||
})();
|
||||
</script>`
|
||||
|
||||
// InjectReloadScript injects the live reload script into HTML content.
|
||||
// The script is inserted just before the closing </body> tag.
|
||||
func InjectReloadScript(html []byte) []byte {
|
||||
// Try to inject before </body>
|
||||
bodyEnd := bytes.LastIndex(html, []byte("</body>"))
|
||||
if bodyEnd != -1 {
|
||||
result := make([]byte, 0, len(html)+len(ReloadScript))
|
||||
result = append(result, html[:bodyEnd]...)
|
||||
result = append(result, []byte(ReloadScript)...)
|
||||
result = append(result, html[bodyEnd:]...)
|
||||
return result
|
||||
}
|
||||
|
||||
// Try to inject before </html>
|
||||
htmlEnd := bytes.LastIndex(html, []byte("</html>"))
|
||||
if htmlEnd != -1 {
|
||||
result := make([]byte, 0, len(html)+len(ReloadScript))
|
||||
result = append(result, html[:htmlEnd]...)
|
||||
result = append(result, []byte(ReloadScript)...)
|
||||
result = append(result, html[htmlEnd:]...)
|
||||
return result
|
||||
}
|
||||
|
||||
// Append at the end as fallback
|
||||
result := make([]byte, 0, len(html)+len(ReloadScript))
|
||||
result = append(result, html...)
|
||||
result = append(result, []byte(ReloadScript)...)
|
||||
return result
|
||||
}
|
||||
|
||||
// IsHTMLContent checks if the content type indicates HTML.
|
||||
func IsHTMLContent(contentType string) bool {
|
||||
return strings.Contains(contentType, "text/html")
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
package host
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestInjectReloadScript_BeforeBody(t *testing.T) {
|
||||
html := []byte(`<!DOCTYPE html>
|
||||
<html>
|
||||
<head><title>Test</title></head>
|
||||
<body>
|
||||
<h1>Hello</h1>
|
||||
</body>
|
||||
</html>`)
|
||||
|
||||
result := InjectReloadScript(html)
|
||||
|
||||
// Should contain the script
|
||||
if !strings.Contains(string(result), "livereload") {
|
||||
t.Error("Expected result to contain livereload script")
|
||||
}
|
||||
|
||||
// Script should be before </body>
|
||||
bodyIndex := strings.Index(string(result), "</body>")
|
||||
scriptIndex := strings.Index(string(result), "<script>")
|
||||
|
||||
if scriptIndex > bodyIndex {
|
||||
t.Error("Expected script to be injected before </body>")
|
||||
}
|
||||
}
|
||||
|
||||
func TestInjectReloadScript_BeforeHTML(t *testing.T) {
|
||||
// HTML without body tag
|
||||
html := []byte(`<!DOCTYPE html>
|
||||
<html>
|
||||
<head><title>Test</title></head>
|
||||
<div>Hello</div>
|
||||
</html>`)
|
||||
|
||||
result := InjectReloadScript(html)
|
||||
|
||||
// Should contain the script
|
||||
if !strings.Contains(string(result), "livereload") {
|
||||
t.Error("Expected result to contain livereload script")
|
||||
}
|
||||
|
||||
// Script should be before </html>
|
||||
htmlIndex := strings.Index(string(result), "</html>")
|
||||
scriptIndex := strings.Index(string(result), "<script>")
|
||||
|
||||
if scriptIndex > htmlIndex {
|
||||
t.Error("Expected script to be injected before </html>")
|
||||
}
|
||||
}
|
||||
|
||||
func TestInjectReloadScript_Fallback(t *testing.T) {
|
||||
// Minimal HTML without body or html closing tags
|
||||
html := []byte(`<div>Hello</div>`)
|
||||
|
||||
result := InjectReloadScript(html)
|
||||
|
||||
// Should contain the script
|
||||
if !strings.Contains(string(result), "livereload") {
|
||||
t.Error("Expected result to contain livereload script")
|
||||
}
|
||||
|
||||
// Should be appended at the end
|
||||
if !strings.HasSuffix(string(result), "</script>") {
|
||||
t.Error("Expected script to be appended at the end")
|
||||
}
|
||||
}
|
||||
|
||||
func TestInjectReloadScript_ContainsReconnect(t *testing.T) {
|
||||
html := []byte(`<html><body></body></html>`)
|
||||
result := InjectReloadScript(html)
|
||||
|
||||
// Should contain reconnection logic
|
||||
if !strings.Contains(string(result), "reconnect") {
|
||||
t.Error("Expected script to contain reconnection logic")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIsHTMLContent(t *testing.T) {
|
||||
tests := []struct {
|
||||
contentType string
|
||||
expected bool
|
||||
}{
|
||||
{"text/html", true},
|
||||
{"text/html; charset=utf-8", true},
|
||||
{"application/json", false},
|
||||
{"text/css", false},
|
||||
{"application/javascript", false},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
result := IsHTMLContent(tt.contentType)
|
||||
if result != tt.expected {
|
||||
t.Errorf("IsHTMLContent(%q) = %v, want %v", tt.contentType, result, tt.expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,184 +0,0 @@
|
||||
package host
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"crypto/sha1"
|
||||
"encoding/base64"
|
||||
"encoding/binary"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// LiveReload manages WebSocket connections for browser reload notifications.
|
||||
type LiveReload struct {
|
||||
mu sync.RWMutex
|
||||
clients map[*wsConn]bool
|
||||
}
|
||||
|
||||
// NewLiveReload creates a new LiveReload manager.
|
||||
func NewLiveReload() *LiveReload {
|
||||
return &LiveReload{
|
||||
clients: make(map[*wsConn]bool),
|
||||
}
|
||||
}
|
||||
|
||||
// ServeHTTP handles WebSocket upgrade requests.
|
||||
func (lr *LiveReload) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
conn, err := lr.upgrade(w, r)
|
||||
if err != nil {
|
||||
http.Error(w, "WebSocket upgrade failed", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
lr.addClient(conn)
|
||||
defer lr.removeClient(conn)
|
||||
|
||||
// Keep connection alive and handle pings
|
||||
conn.readLoop()
|
||||
}
|
||||
|
||||
// NotifyReload sends a reload message to all connected clients.
|
||||
func (lr *LiveReload) NotifyReload() {
|
||||
lr.mu.RLock()
|
||||
defer lr.mu.RUnlock()
|
||||
|
||||
for conn := range lr.clients {
|
||||
conn.send([]byte("reload"))
|
||||
}
|
||||
}
|
||||
|
||||
// ClientCount returns the number of connected clients.
|
||||
func (lr *LiveReload) ClientCount() int {
|
||||
lr.mu.RLock()
|
||||
defer lr.mu.RUnlock()
|
||||
return len(lr.clients)
|
||||
}
|
||||
|
||||
func (lr *LiveReload) addClient(conn *wsConn) {
|
||||
lr.mu.Lock()
|
||||
defer lr.mu.Unlock()
|
||||
lr.clients[conn] = true
|
||||
}
|
||||
|
||||
func (lr *LiveReload) removeClient(conn *wsConn) {
|
||||
lr.mu.Lock()
|
||||
defer lr.mu.Unlock()
|
||||
delete(lr.clients, conn)
|
||||
conn.close()
|
||||
}
|
||||
|
||||
func (lr *LiveReload) upgrade(w http.ResponseWriter, r *http.Request) (*wsConn, error) {
|
||||
if r.Header.Get("Upgrade") != "websocket" {
|
||||
return nil, io.ErrUnexpectedEOF
|
||||
}
|
||||
|
||||
key := r.Header.Get("Sec-WebSocket-Key")
|
||||
if key == "" {
|
||||
return nil, io.ErrUnexpectedEOF
|
||||
}
|
||||
|
||||
// Compute accept key
|
||||
h := sha1.New()
|
||||
h.Write([]byte(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"))
|
||||
acceptKey := base64.StdEncoding.EncodeToString(h.Sum(nil))
|
||||
|
||||
// Hijack the connection
|
||||
hijacker, ok := w.(http.Hijacker)
|
||||
if !ok {
|
||||
return nil, io.ErrUnexpectedEOF
|
||||
}
|
||||
|
||||
conn, bufrw, err := hijacker.Hijack()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
// Send upgrade response
|
||||
bufrw.WriteString("HTTP/1.1 101 Switching Protocols\r\n")
|
||||
bufrw.WriteString("Upgrade: websocket\r\n")
|
||||
bufrw.WriteString("Connection: Upgrade\r\n")
|
||||
bufrw.WriteString("Sec-WebSocket-Accept: " + acceptKey + "\r\n")
|
||||
bufrw.WriteString("\r\n")
|
||||
bufrw.Flush()
|
||||
|
||||
return &wsConn{
|
||||
conn: conn,
|
||||
rw: bufrw,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// wsConn is a minimal WebSocket connection.
|
||||
type wsConn struct {
|
||||
conn net.Conn
|
||||
rw *bufio.ReadWriter
|
||||
mu sync.Mutex
|
||||
closed bool
|
||||
}
|
||||
|
||||
func (c *wsConn) send(data []byte) error {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
|
||||
if c.closed {
|
||||
return io.ErrClosedPipe
|
||||
}
|
||||
|
||||
// Write text frame
|
||||
frame := makeFrame(1, data) // 1 = text frame
|
||||
_, err := c.conn.Write(frame)
|
||||
return err
|
||||
}
|
||||
|
||||
func (c *wsConn) close() {
|
||||
c.mu.Lock()
|
||||
defer c.mu.Unlock()
|
||||
|
||||
if c.closed {
|
||||
return
|
||||
}
|
||||
c.closed = true
|
||||
|
||||
// Send close frame
|
||||
frame := makeFrame(8, nil) // 8 = close frame
|
||||
c.conn.Write(frame)
|
||||
c.conn.Close()
|
||||
}
|
||||
|
||||
func (c *wsConn) readLoop() {
|
||||
buf := make([]byte, 1024)
|
||||
for {
|
||||
_, err := c.rw.Read(buf)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
// We don't process incoming messages, just keep connection alive
|
||||
}
|
||||
}
|
||||
|
||||
func makeFrame(opcode byte, data []byte) []byte {
|
||||
length := len(data)
|
||||
|
||||
var frame []byte
|
||||
if length < 126 {
|
||||
frame = make([]byte, 2+length)
|
||||
frame[0] = 0x80 | opcode // FIN + opcode
|
||||
frame[1] = byte(length)
|
||||
copy(frame[2:], data)
|
||||
} else if length < 65536 {
|
||||
frame = make([]byte, 4+length)
|
||||
frame[0] = 0x80 | opcode
|
||||
frame[1] = 126
|
||||
binary.BigEndian.PutUint16(frame[2:], uint16(length))
|
||||
copy(frame[4:], data)
|
||||
} else {
|
||||
frame = make([]byte, 10+length)
|
||||
frame[0] = 0x80 | opcode
|
||||
frame[1] = 127
|
||||
binary.BigEndian.PutUint64(frame[2:], uint64(length))
|
||||
copy(frame[10:], data)
|
||||
}
|
||||
|
||||
return frame
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
package host
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestLiveReload_ClientCount(t *testing.T) {
|
||||
lr := NewLiveReload()
|
||||
|
||||
if count := lr.ClientCount(); count != 0 {
|
||||
t.Errorf("Expected 0 clients, got %d", count)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMakeFrame_SmallPayload(t *testing.T) {
|
||||
data := []byte("reload")
|
||||
frame := makeFrame(1, data)
|
||||
|
||||
// First byte: FIN + opcode
|
||||
if frame[0] != 0x81 {
|
||||
t.Errorf("Expected first byte 0x81, got 0x%02x", frame[0])
|
||||
}
|
||||
|
||||
// Second byte: length (no mask, small payload)
|
||||
if frame[1] != byte(len(data)) {
|
||||
t.Errorf("Expected length %d, got %d", len(data), frame[1])
|
||||
}
|
||||
|
||||
// Payload
|
||||
payload := frame[2:]
|
||||
if string(payload) != string(data) {
|
||||
t.Errorf("Expected payload %q, got %q", data, payload)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMakeFrame_MediumPayload(t *testing.T) {
|
||||
// Create payload between 126 and 65535 bytes
|
||||
data := make([]byte, 200)
|
||||
for i := range data {
|
||||
data[i] = byte(i % 256)
|
||||
}
|
||||
|
||||
frame := makeFrame(1, data)
|
||||
|
||||
// First byte: FIN + opcode
|
||||
if frame[0] != 0x81 {
|
||||
t.Errorf("Expected first byte 0x81, got 0x%02x", frame[0])
|
||||
}
|
||||
|
||||
// Second byte: 126 indicates extended length
|
||||
if frame[1] != 126 {
|
||||
t.Errorf("Expected length indicator 126, got %d", frame[1])
|
||||
}
|
||||
|
||||
// Extended length (2 bytes, big endian)
|
||||
extLen := int(frame[2])<<8 | int(frame[3])
|
||||
if extLen != len(data) {
|
||||
t.Errorf("Expected extended length %d, got %d", len(data), extLen)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMakeFrame_CloseFrame(t *testing.T) {
|
||||
frame := makeFrame(8, nil)
|
||||
|
||||
// First byte: FIN + close opcode
|
||||
if frame[0] != 0x88 {
|
||||
t.Errorf("Expected first byte 0x88, got 0x%02x", frame[0])
|
||||
}
|
||||
|
||||
// Second byte: 0 length
|
||||
if frame[1] != 0 {
|
||||
t.Errorf("Expected length 0, got %d", frame[1])
|
||||
}
|
||||
}
|
||||
169
host/watcher.go
169
host/watcher.go
@@ -1,169 +0,0 @@
|
||||
package host
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Watcher monitors files for changes and triggers callbacks.
|
||||
type Watcher struct {
|
||||
dir string
|
||||
extensions []string
|
||||
onChange func()
|
||||
interval time.Duration
|
||||
|
||||
mu sync.Mutex
|
||||
modTimes map[string]time.Time
|
||||
stop chan struct{}
|
||||
wg sync.WaitGroup
|
||||
}
|
||||
|
||||
// WatcherOption configures a Watcher.
|
||||
type WatcherOption func(*Watcher)
|
||||
|
||||
// WithExtensions sets file extensions to watch (e.g., ".go", ".html").
|
||||
func WithExtensions(exts ...string) WatcherOption {
|
||||
return func(w *Watcher) {
|
||||
w.extensions = exts
|
||||
}
|
||||
}
|
||||
|
||||
// WithInterval sets the polling interval for file changes.
|
||||
func WithInterval(d time.Duration) WatcherOption {
|
||||
return func(w *Watcher) {
|
||||
w.interval = d
|
||||
}
|
||||
}
|
||||
|
||||
// NewWatcher creates a new file watcher that monitors the specified directory.
|
||||
func NewWatcher(dir string, onChange func(), opts ...WatcherOption) *Watcher {
|
||||
w := &Watcher{
|
||||
dir: dir,
|
||||
extensions: []string{".go"},
|
||||
onChange: onChange,
|
||||
interval: 500 * time.Millisecond,
|
||||
modTimes: make(map[string]time.Time),
|
||||
stop: make(chan struct{}),
|
||||
}
|
||||
|
||||
for _, opt := range opts {
|
||||
opt(w)
|
||||
}
|
||||
|
||||
return w
|
||||
}
|
||||
|
||||
// Start begins watching for file changes.
|
||||
func (w *Watcher) Start() error {
|
||||
// Initial scan to populate mod times
|
||||
if err := w.scan(false); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
w.wg.Add(1)
|
||||
go w.watch()
|
||||
return nil
|
||||
}
|
||||
|
||||
// Stop stops the watcher.
|
||||
func (w *Watcher) Stop() {
|
||||
close(w.stop)
|
||||
w.wg.Wait()
|
||||
}
|
||||
|
||||
func (w *Watcher) watch() {
|
||||
defer w.wg.Done()
|
||||
|
||||
ticker := time.NewTicker(w.interval)
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-w.stop:
|
||||
return
|
||||
case <-ticker.C:
|
||||
if err := w.scan(true); err != nil {
|
||||
// Log error but continue watching
|
||||
continue
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (w *Watcher) scan(notify bool) error {
|
||||
w.mu.Lock()
|
||||
defer w.mu.Unlock()
|
||||
|
||||
changed := false
|
||||
seen := make(map[string]bool)
|
||||
|
||||
err := filepath.Walk(w.dir, func(path string, info os.FileInfo, err error) error {
|
||||
if err != nil {
|
||||
return nil // Skip files we can't access
|
||||
}
|
||||
|
||||
if info.IsDir() {
|
||||
// Skip hidden directories and vendor
|
||||
name := info.Name()
|
||||
if len(name) > 0 && name[0] == '.' {
|
||||
return filepath.SkipDir
|
||||
}
|
||||
if name == "vendor" || name == "node_modules" {
|
||||
return filepath.SkipDir
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Check if extension matches
|
||||
ext := filepath.Ext(path)
|
||||
if !w.matchesExtension(ext) {
|
||||
return nil
|
||||
}
|
||||
|
||||
seen[path] = true
|
||||
modTime := info.ModTime()
|
||||
|
||||
if prev, exists := w.modTimes[path]; !exists {
|
||||
// New file
|
||||
w.modTimes[path] = modTime
|
||||
if notify {
|
||||
changed = true
|
||||
}
|
||||
} else if !modTime.Equal(prev) {
|
||||
// Modified file
|
||||
w.modTimes[path] = modTime
|
||||
changed = true
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Check for deleted files
|
||||
for path := range w.modTimes {
|
||||
if !seen[path] {
|
||||
delete(w.modTimes, path)
|
||||
changed = true
|
||||
}
|
||||
}
|
||||
|
||||
if changed && notify && w.onChange != nil {
|
||||
w.onChange()
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (w *Watcher) matchesExtension(ext string) bool {
|
||||
for _, e := range w.extensions {
|
||||
if e == ext {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -1,216 +0,0 @@
|
||||
package host
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sync/atomic"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestWatcher_DetectsNewFiles(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
// Create initial file
|
||||
initialFile := filepath.Join(dir, "initial.go")
|
||||
if err := os.WriteFile(initialFile, []byte("package main"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var changeCount int32
|
||||
w := NewWatcher(dir, func() {
|
||||
atomic.AddInt32(&changeCount, 1)
|
||||
}, WithInterval(50*time.Millisecond))
|
||||
|
||||
if err := w.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer w.Stop()
|
||||
|
||||
// Create new file
|
||||
newFile := filepath.Join(dir, "new.go")
|
||||
if err := os.WriteFile(newFile, []byte("package main"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Wait for detection
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
|
||||
if count := atomic.LoadInt32(&changeCount); count == 0 {
|
||||
t.Error("Expected change to be detected for new file")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWatcher_DetectsModifiedFiles(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
// Create initial file
|
||||
file := filepath.Join(dir, "test.go")
|
||||
if err := os.WriteFile(file, []byte("package main"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var changeCount int32
|
||||
w := NewWatcher(dir, func() {
|
||||
atomic.AddInt32(&changeCount, 1)
|
||||
}, WithInterval(50*time.Millisecond))
|
||||
|
||||
if err := w.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer w.Stop()
|
||||
|
||||
// Ensure mod time will be different
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
|
||||
// Modify file
|
||||
if err := os.WriteFile(file, []byte("package main\n// updated"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Wait for detection
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
|
||||
if count := atomic.LoadInt32(&changeCount); count == 0 {
|
||||
t.Error("Expected change to be detected for modified file")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWatcher_DetectsDeletedFiles(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
// Create initial file
|
||||
file := filepath.Join(dir, "test.go")
|
||||
if err := os.WriteFile(file, []byte("package main"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var changeCount int32
|
||||
w := NewWatcher(dir, func() {
|
||||
atomic.AddInt32(&changeCount, 1)
|
||||
}, WithInterval(50*time.Millisecond))
|
||||
|
||||
if err := w.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer w.Stop()
|
||||
|
||||
// Delete file
|
||||
if err := os.Remove(file); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Wait for detection
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
|
||||
if count := atomic.LoadInt32(&changeCount); count == 0 {
|
||||
t.Error("Expected change to be detected for deleted file")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWatcher_IgnoresNonMatchingExtensions(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
// Create initial go file
|
||||
goFile := filepath.Join(dir, "main.go")
|
||||
if err := os.WriteFile(goFile, []byte("package main"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var changeCount int32
|
||||
w := NewWatcher(dir, func() {
|
||||
atomic.AddInt32(&changeCount, 1)
|
||||
}, WithInterval(50*time.Millisecond), WithExtensions(".go"))
|
||||
|
||||
if err := w.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer w.Stop()
|
||||
|
||||
// Create non-matching file
|
||||
txtFile := filepath.Join(dir, "readme.txt")
|
||||
if err := os.WriteFile(txtFile, []byte("readme"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Wait
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
|
||||
if count := atomic.LoadInt32(&changeCount); count != 0 {
|
||||
t.Error("Expected no change detected for non-matching extension")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWatcher_CustomExtensions(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
// Create initial file
|
||||
file := filepath.Join(dir, "style.css")
|
||||
if err := os.WriteFile(file, []byte("body {}"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var changeCount int32
|
||||
w := NewWatcher(dir, func() {
|
||||
atomic.AddInt32(&changeCount, 1)
|
||||
}, WithInterval(50*time.Millisecond), WithExtensions(".css", ".html"))
|
||||
|
||||
if err := w.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer w.Stop()
|
||||
|
||||
// Ensure mod time will be different
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
|
||||
// Modify css file
|
||||
if err := os.WriteFile(file, []byte("body { color: red; }"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Wait for detection
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
|
||||
if count := atomic.LoadInt32(&changeCount); count == 0 {
|
||||
t.Error("Expected change to be detected for custom extension")
|
||||
}
|
||||
}
|
||||
|
||||
func TestWatcher_SkipsHiddenDirs(t *testing.T) {
|
||||
dir := t.TempDir()
|
||||
|
||||
// Create hidden directory with go file
|
||||
hiddenDir := filepath.Join(dir, ".hidden")
|
||||
if err := os.MkdirAll(hiddenDir, 0755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Create a visible go file first
|
||||
visibleFile := filepath.Join(dir, "visible.go")
|
||||
if err := os.WriteFile(visibleFile, []byte("package main"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
var changeCount int32
|
||||
w := NewWatcher(dir, func() {
|
||||
atomic.AddInt32(&changeCount, 1)
|
||||
}, WithInterval(50*time.Millisecond))
|
||||
|
||||
if err := w.Start(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer w.Stop()
|
||||
|
||||
// Create file in hidden directory
|
||||
hiddenFile := filepath.Join(hiddenDir, "hidden.go")
|
||||
if err := os.WriteFile(hiddenFile, []byte("package main"), 0644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Wait
|
||||
time.Sleep(200 * time.Millisecond)
|
||||
|
||||
if count := atomic.LoadInt32(&changeCount); count != 0 {
|
||||
t.Error("Expected no change detected for hidden directory")
|
||||
}
|
||||
}
|
||||
21
ui/input.go
21
ui/input.go
@@ -205,23 +205,4 @@ func NumberInput(value *reactive.Signal[float64], placeholder string) View {
|
||||
})
|
||||
|
||||
return View{input}
|
||||
}
|
||||
// RawCheckbox creates a plain checkbox input without a label wrapper.
|
||||
// The onChange callback is called with the new checked state when the user clicks.
|
||||
func RawCheckbox(checked bool, onChange func(bool)) View {
|
||||
checkbox := element.NewElement("input")
|
||||
checkbox.Attr("type", "checkbox")
|
||||
|
||||
// Set initial state
|
||||
if checked {
|
||||
checkbox.Set("checked", true)
|
||||
}
|
||||
|
||||
// Call onChange when user clicks
|
||||
checkbox.On("change", func() {
|
||||
newValue := checkbox.Get("checked").Bool()
|
||||
onChange(newValue)
|
||||
})
|
||||
|
||||
return View{checkbox}
|
||||
}
|
||||
}
|
||||
@@ -170,8 +170,3 @@ func (v View) PointerEvents(value string) View {
|
||||
v.e.PointerEvents(value)
|
||||
return v
|
||||
}
|
||||
|
||||
func (v View) TextDecoration(value string) View {
|
||||
v.e.Get("style").Call("setProperty", "text-decoration", value)
|
||||
return v
|
||||
}
|
||||
|
||||
@@ -21,10 +21,3 @@ func TextFromFunction(fn func() string) View {
|
||||
|
||||
return View{textNode}
|
||||
}
|
||||
|
||||
// Span creates a span element with the given text content.
|
||||
func Span(text string) View {
|
||||
v := View{element.NewElement("span")}
|
||||
v.e.Set("textContent", text)
|
||||
return v
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user