update app API for 3 different atom types

Author: sawka

tsunami/app/defaultclient.go

@@ -8,6 +8,7 @@ import (
 	"io/fs"
 	"net/http"
 
+	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
 )
 
@@ -41,16 +42,31 @@ func SendAsyncInitiation() error {
 	return defaultClient.SendAsyncInitiation()
 }
 
-func SetAtomVals(m map[string]any) {
-	defaultClient.SetAtomVals(m)
+func GetSharedAtom[T any](name string) T {
+	rawVal := defaultClient.GetAtomVal("$shared." + name)
+	return util.GetTypedAtomValue[T](rawVal, "$shared."+name)
 }
 
-func SetAtomVal(name string, val any) {
-	defaultClient.SetAtomVal(name, val)
+func SetSharedAtom[T any](name string, val T) {
+	defaultClient.SetAtomVal("$shared."+name, val)
 }
 
-func GetAtomVal(name string) any {
-	return defaultClient.GetAtomVal(name)
+func GetConfig[T any](name string) T {
+	rawVal := defaultClient.GetAtomVal("$config." + name)
+	return util.GetTypedAtomValue[T](rawVal, "$config."+name)
+}
+
+func SetConfig[T any](name string, val T) {
+	defaultClient.SetAtomVal("$config."+name, val)
+}
+
+func GetData[T any](name string) T {
+	rawVal := defaultClient.GetAtomVal("$data." + name)
+	return util.GetTypedAtomValue[T](rawVal, "$data."+name)
+}
+
+func SetData[T any](name string, val T) {
+	defaultClient.SetAtomVal("$data."+name, val)
 }
 
 // HandleDynFunc registers a dynamic HTTP handler function with the internal http.ServeMux.

tsunami/prompts/global-keyboard-handling.md

@@ -0,0 +1,72 @@
+# Global Keyboard Handling
+
+The Tsunami framework provides two approaches for handling keyboard events:
+
+1. Standard DOM event handling on elements:
+
+```go
+vdom.H("div", map[string]any{
+    "onKeyDown": func(e vdom.VDomEvent) {
+        // Handle key event
+    },
+})
+```
+
+2. Global keyboard event handling:
+
+```go
+// Global keyboard events are automatically enabled when you set a global event handler
+func init() {
+    app.SetGlobalEventHandler(func(event vdom.VDomEvent) {
+    if event.EventType != "onKeyDown" || event.KeyData == nil {
+        return
+    }
+
+    switch event.KeyData.Key {
+    case "ArrowUp":
+        // Handle up arrow
+    case "ArrowDown":
+        // Handle down arrow
+    }
+})
+```
+
+The global handler approach is particularly useful when:
+
+- You need to handle keyboard events regardless of focus state
+- Building terminal-like applications that need consistent keyboard control
+- Implementing application-wide keyboard shortcuts
+- Managing navigation in full-screen applications
+
+Key differences:
+
+- Standard DOM events require the element to have focus
+- Global events work regardless of focus state
+- Global events can be used alongside regular DOM event handlers
+- Global handler receives all keyboard events for the application
+
+The event handler receives a VDomEvent with KeyData for keyboard events:
+
+```go
+type VDomEvent struct {
+    EventType       string             // e.g., "onKeyDown"
+    KeyData         *WaveKeyboardEvent `json:"keydata,omitempty"`
+    // ... other fields
+}
+
+type WaveKeyboardEvent struct {
+    Type     string // "keydown", "keyup", "keypress"
+    Key      string // The key value (e.g., "ArrowUp")
+    Code     string // Physical key code
+    Shift    bool   // Modifier states
+    Control  bool
+    Alt      bool
+    Meta     bool
+    Cmd      bool   // Meta on Mac, Alt on Windows/Linux
+    Option   bool   // Alt on Mac, Meta on Windows/Linux
+}
+```
+
+When using global keyboard events:
+
+Global keyboard events are automatically enabled when you set a global event handler. Set up the handler in a place where you have access to necessary state updates.

tsunami/prompts/system.md

@@ -69,7 +69,7 @@ var App = app.DefineComponent("App",
 
 Key Points:
 
-- Must use package main.
+- Must use `package main`.
 - The `App` component is required. It serves as the entry point to your application.
 - Do NOT add a `main()` function, that is provided by the framework when building.
 - Uses Tailwind v4 for styling - you can use any Tailwind classes in your components.
@@ -98,7 +98,7 @@ vdom.H("div", map[string]any{
 vdom.H("div", map[string]any{
     "style": map[string]any{
         "marginTop": 10,      // Numbers automatically convert to px (like React)
-        "zIndex": 1000,
+        "zIndex": 1000,       // use React style names
         "transform": "rotate(45deg)",
     },
 })
@@ -671,76 +671,7 @@ Key points for state management:
 
 ## Global Keyboard Handling
 
-The Tsunami framework provides two approaches for handling keyboard events:
-
-1. Standard DOM event handling on elements:
-
-```go
-vdom.H("div", map[string]any{
-    "onKeyDown": func(e vdom.VDomEvent) {
-        // Handle key event
-    },
-})
-```
-
-2. Global keyboard event handling:
-
-```go
-// Global keyboard events are automatically enabled when you set a global event handler
-func init() {
-    app.SetGlobalEventHandler(func(event vdom.VDomEvent) {
-    if event.EventType != "onKeyDown" || event.KeyData == nil {
-        return
-    }
-
-    switch event.KeyData.Key {
-    case "ArrowUp":
-        // Handle up arrow
-    case "ArrowDown":
-        // Handle down arrow
-    }
-})
-```
-
-The global handler approach is particularly useful when:
-
-- You need to handle keyboard events regardless of focus state
-- Building terminal-like applications that need consistent keyboard control
-- Implementing application-wide keyboard shortcuts
-- Managing navigation in full-screen applications
-
-Key differences:
-
-- Standard DOM events require the element to have focus
-- Global events work regardless of focus state
-- Global events can be used alongside regular DOM event handlers
-- Global handler receives all keyboard events for the application
-
-The event handler receives a VDomEvent with KeyData for keyboard events:
-
-```go
-type VDomEvent struct {
-    EventType       string             // e.g., "onKeyDown"
-    KeyData         *WaveKeyboardEvent `json:"keydata,omitempty"`
-    // ... other fields
-}
-
-type WaveKeyboardEvent struct {
-    Type     string // "keydown", "keyup", "keypress"
-    Key      string // The key value (e.g., "ArrowUp")
-    Code     string // Physical key code
-    Shift    bool   // Modifier states
-    Control  bool
-    Alt      bool
-    Meta     bool
-    Cmd      bool   // Meta on Mac, Alt on Windows/Linux
-    Option   bool   // Alt on Mac, Meta on Windows/Linux
-}
-```
-
-When using global keyboard events:
-
-Global keyboard events are automatically enabled when you set a global event handler. Set up the handler in a place where you have access to necessary state updates.
+For some applications, getting access to each key press regardless of focus state is essential. To enable global keyboard handling that captures all keyboard events across your application, see the global-keyboard-handling.md document.
 
 ## File Handling
 

tsunami/util/util.go

@@ -90,3 +90,23 @@ func OpenBrowser(url string, delay time.Duration) {
 
 	exec.Command(cmd, args...).Start()
 }
+
+func GetTypedAtomValue[T any](rawVal any, atomName string) T {
+	var result T
+	if rawVal == nil {
+		return *new(T)
+	}
+
+	var ok bool
+	result, ok = rawVal.(T)
+	if !ok {
+		// Try converting from float64 if rawVal is float64
+		if f64Val, isFloat64 := rawVal.(float64); isFloat64 {
+			if converted, convOk := FromFloat64[T](f64Val); convOk {
+				return converted
+			}
+		}
+		panic(fmt.Sprintf("GetTypedAtomValue %q value type mismatch (expected %T, got %T)", atomName, *new(T), rawVal))
+	}
+	return result
+}

tsunami/vdom/vdom.go

@@ -182,25 +182,6 @@ func UseState[T any](ctx context.Context, initialVal T) (T, func(T), func(func(T
 	return rtnVal, typedSetVal, typedSetFuncVal
 }
 
-func getTypedAtomValue[T any](rawVal any, atomName string) T {
-	var result T
-	if rawVal == nil {
-		return *new(T)
-	}
-
-	var ok bool
-	result, ok = rawVal.(T)
-	if !ok {
-		// Try converting from float64 if rawVal is float64
-		if f64Val, isFloat64 := rawVal.(float64); isFloat64 {
-			if converted, convOk := util.FromFloat64[T](f64Val); convOk {
-				return converted
-			}
-		}
-		panic(fmt.Sprintf("UseAtom %q value type mismatch (expected %T, got %T)", atomName, *new(T), rawVal))
-	}
-	return result
-}
 
 func useAtom[T any](ctx context.Context, hookName string, atomName string) (T, func(T), func(func(T) T)) {
 	rc := vdomctx.GetRenderContext(ctx)
@@ -210,15 +191,15 @@ func useAtom[T any](ctx context.Context, hookName string, atomName string) (T, f
 	val, setVal, setFn := rc.UseAtom(ctx, atomName)
 
 	// Adapt the "any" values to type "T"
-	atomVal := getTypedAtomValue[T](val, atomName)
+	atomVal := util.GetTypedAtomValue[T](val, atomName)
 
 	typedSetVal := func(newVal T) {
 		setVal(newVal)
 	}
 
 	typedSetFuncVal := func(updateFunc func(T) T) {
 		setFn(func(oldVal any) any {
-			typedOldVal := getTypedAtomValue[T](oldVal, atomName)
+			typedOldVal := util.GetTypedAtomValue[T](oldVal, atomName)
 			return updateFunc(typedOldVal)
 		})
 	}