simplify vdom pkg, remove more public methods and types (hooks implemented in comp)

Author: sawka

tsunami/comp/comp.go

@@ -22,7 +22,7 @@ type ComponentImpl struct {
 	Mounted bool
 
 	// hooks
-	Hooks []*vdom.Hook
+	Hooks []*Hook
 
 	// #text component
 	Text string

tsunami/comp/hooks.go

@@ -0,0 +1,191 @@
+// Copyright 2025, Command Line Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+package comp
+
+import (
+	"context"
+	"log"
+	"strconv"
+
+	"github.com/wavetermdev/waveterm/tsunami/vdom"
+	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
+)
+
+// generic hook structure
+type Hook struct {
+	Init      bool          // is initialized
+	Idx       int           // index in the hook array
+	Fn        func() func() // for useEffect
+	UnmountFn func()        // for useEffect
+	Val       any           // for useState, useMemo, useRef
+	Deps      []any
+}
+
+type VDomContextImpl struct {
+	Root       *RootElem
+	Comp       *ComponentImpl
+	HookIdx    int
+	RenderOpts *RenderOpts
+}
+
+// Compile-time check to ensure VDomContextImpl implements vdomctx.VDomContext
+var _ vdomctx.VDomContext = (*VDomContextImpl)(nil)
+
+// Implement vdomctx.VDomContext interface methods on VDomContextImpl
+
+func MakeContextVal(root *RootElem, comp *ComponentImpl, opts *RenderOpts) *VDomContextImpl {
+	return &VDomContextImpl{Root: root, Comp: comp, HookIdx: 0, RenderOpts: opts}
+}
+
+func (vc *VDomContextImpl) getCompWaveId() string {
+	if vc.Comp == nil {
+		return ""
+	}
+	return vc.Comp.WaveId
+}
+
+func (vc *VDomContextImpl) getOrderedHook() *Hook {
+	if vc.Comp == nil {
+		panic("tsunami hooks must be called within a component (vc.Comp is nil)")
+	}
+	for len(vc.Comp.Hooks) <= vc.HookIdx {
+		vc.Comp.Hooks = append(vc.Comp.Hooks, &Hook{Idx: len(vc.Comp.Hooks)})
+	}
+	hookVal := vc.Comp.Hooks[vc.HookIdx]
+	vc.HookIdx++
+	return hookVal
+}
+
+func (vc *VDomContextImpl) getCompName() string {
+	if vc.Comp == nil || vc.Comp.Elem == nil {
+		return ""
+	}
+	return vc.Comp.Elem.Tag
+}
+
+func (vc *VDomContextImpl) UseRenderTs(ctx context.Context) int64 {
+	return vc.Root.RenderTs
+}
+
+func (vc *VDomContextImpl) UseId(ctx context.Context) string {
+	return vc.getCompWaveId()
+}
+
+func (vc *VDomContextImpl) UseState(ctx context.Context, initialVal any) (any, func(any), func(func(any) any)) {
+	hookVal := vc.getOrderedHook()
+	if !hookVal.Init {
+		hookVal.Init = true
+		hookVal.Val = initialVal
+	}
+
+	setVal := func(newVal any) {
+		hookVal.Val = newVal
+		vc.Root.AddRenderWork(vc.getCompWaveId())
+	}
+
+	setFuncVal := func(updateFunc func(any) any) {
+		hookVal.Val = updateFunc(hookVal.Val)
+		vc.Root.AddRenderWork(vc.getCompWaveId())
+	}
+
+	return hookVal.Val, setVal, setFuncVal
+}
+
+func (vc *VDomContextImpl) UseAtom(ctx context.Context, atomName string) (any, func(any), func(func(any) any)) {
+	hookVal := vc.getOrderedHook()
+	if !hookVal.Init {
+		hookVal.Init = true
+		closedWaveId := vc.getCompWaveId()
+		hookVal.UnmountFn = func() {
+			vc.Root.AtomSetUsedBy(atomName, closedWaveId, false)
+		}
+	}
+	vc.Root.AtomSetUsedBy(atomName, vc.getCompWaveId(), true)
+	atomVal := vc.Root.GetAtomVal(atomName)
+
+	setVal := func(newVal any) {
+		vc.Root.SetAtomVal(atomName, newVal, true)
+		vc.Root.AtomAddRenderWork(atomName)
+	}
+
+	setFuncVal := func(updateFunc func(any) any) {
+		currentVal := vc.Root.GetAtomVal(atomName)
+		vc.Root.SetAtomVal(atomName, updateFunc(currentVal), true)
+		vc.Root.AtomAddRenderWork(atomName)
+	}
+
+	return atomVal, setVal, setFuncVal
+}
+
+func (vc *VDomContextImpl) UseVDomRef(ctx context.Context) any {
+	hookVal := vc.getOrderedHook()
+	if !hookVal.Init {
+		hookVal.Init = true
+		refId := vc.getCompWaveId() + ":" + strconv.Itoa(hookVal.Idx)
+		hookVal.Val = &vdom.VDomRef{Type: vdom.ObjectType_Ref, RefId: refId}
+	}
+	refVal, ok := hookVal.Val.(*vdom.VDomRef)
+	if !ok {
+		panic("UseVDomRef hook value is not a ref (possible out of order or conditional hooks)")
+	}
+	return refVal
+}
+
+func (vc *VDomContextImpl) UseRef(ctx context.Context, hookInitialVal any) any {
+	hookVal := vc.getOrderedHook()
+	if !hookVal.Init {
+		hookVal.Init = true
+		hookVal.Val = hookInitialVal
+	}
+	return hookVal.Val
+}
+
+func depsEqual(deps1 []any, deps2 []any) bool {
+	if len(deps1) != len(deps2) {
+		return false
+	}
+	for i := range deps1 {
+		if deps1[i] != deps2[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func (vc *VDomContextImpl) UseEffect(ctx context.Context, fn func() func(), deps []any) {
+	hookVal := vc.getOrderedHook()
+	if !hookVal.Init {
+		hookVal.Init = true
+		hookVal.Fn = fn
+		hookVal.Deps = deps
+		vc.Root.AddEffectWork(vc.getCompWaveId(), hookVal.Idx)
+		return
+	}
+	if depsEqual(hookVal.Deps, deps) {
+		return
+	}
+	hookVal.Fn = fn
+	hookVal.Deps = deps
+	vc.Root.AddEffectWork(vc.getCompWaveId(), hookVal.Idx)
+}
+
+func (vc *VDomContextImpl) UseResync(ctx context.Context) bool {
+	if vc.RenderOpts == nil {
+		return false
+	}
+	return vc.RenderOpts.Resync
+}
+
+func (vc *VDomContextImpl) UseSetAppTitle(ctx context.Context, title string) {
+	if vc.getCompName() != "App" {
+		log.Printf("UseSetAppTitle can only be called from the App component")
+		return
+	}
+	vc.Root.AppTitle = title
+}
+
+func (vc *VDomContextImpl) QueueRefOp(ctx context.Context, op any) {
+	typedOp := op.(vdom.VDomRefOperation)
+	vc.Root.QueueRefOp(typedOp)
+}

tsunami/comp/rootelem.go

@@ -11,29 +11,44 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"unicode"
 
 	"github.com/google/uuid"
 	"github.com/wavetermdev/waveterm/tsunami/rpctypes"
 	"github.com/wavetermdev/waveterm/tsunami/util"
 	"github.com/wavetermdev/waveterm/tsunami/vdom"
+	"github.com/wavetermdev/waveterm/tsunami/vdomctx"
 )
 
+const ChildrenPropKey = "children"
+
 type RenderOpts struct {
 	Resync bool
 }
 
+type Atom struct {
+	Val    any
+	Dirty  bool
+	UsedBy map[string]bool // component waveid -> true
+}
+
+type EffectWorkElem struct {
+	Id          string
+	EffectIndex int
+}
+
 type RootElem struct {
 	OuterCtx        context.Context
 	Root            *ComponentImpl
 	RenderTs        int64
 	AppTitle        string
 	CFuncs          map[string]any
 	CompMap         map[string]*ComponentImpl // component waveid -> component
-	EffectWorkQueue []*vdom.EffectWorkElem
+	EffectWorkQueue []*EffectWorkElem
 	NeedsRenderMap  map[string]bool
-	Atoms           map[string]*vdom.Atom
+	Atoms           map[string]*Atom
 	atomLock        sync.Mutex
-	RefOperations   []rpctypes.VDomRefOperation
+	RefOperations   []vdom.VDomRefOperation
 }
 
 func (r *RootElem) AddRenderWork(id string) {
@@ -44,7 +59,7 @@ func (r *RootElem) AddRenderWork(id string) {
 }
 
 func (r *RootElem) AddEffectWork(id string, effectIndex int) {
-	r.EffectWorkQueue = append(r.EffectWorkQueue, &vdom.EffectWorkElem{Id: id, EffectIndex: effectIndex})
+	r.EffectWorkQueue = append(r.EffectWorkQueue, &EffectWorkElem{Id: id, EffectIndex: effectIndex})
 }
 
 func (r *RootElem) GetDataMap() map[string]any {
@@ -64,7 +79,7 @@ func (r *RootElem) GetDataMap() map[string]any {
 func (r *RootElem) GetConfigMap() map[string]any {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
-	
+
 	result := make(map[string]any)
 	for atomName, atom := range r.Atoms {
 		if strings.HasPrefix(atomName, "$config.") {
@@ -80,24 +95,23 @@ func MakeRoot() *RootElem {
 		Root:    nil,
 		CFuncs:  make(map[string]any),
 		CompMap: make(map[string]*ComponentImpl),
-		Atoms:   make(map[string]*vdom.Atom),
+		Atoms:   make(map[string]*Atom),
 	}
 }
 
-func (r *RootElem) ensureAtomNoLock(name string) *vdom.Atom {
+func (r *RootElem) ensureAtomNoLock(name string) *Atom {
 	atom, ok := r.Atoms[name]
 	if !ok {
-		atom = &vdom.Atom{UsedBy: make(map[string]bool)}
+		atom = &Atom{UsedBy: make(map[string]bool)}
 		r.Atoms[name] = atom
 	}
 	return atom
 }
 
-
 func (r *RootElem) AtomSetUsedBy(atomName string, waveId string, used bool) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
-	
+
 	atom := r.ensureAtomNoLock(atomName)
 	if used {
 		atom.UsedBy[waveId] = true
@@ -109,7 +123,7 @@ func (r *RootElem) AtomSetUsedBy(atomName string, waveId string, used bool) {
 func (r *RootElem) AtomAddRenderWork(atomName string) {
 	r.atomLock.Lock()
 	defer r.atomLock.Unlock()
-	
+
 	atom, ok := r.Atoms[atomName]
 	if !ok {
 		return
@@ -297,7 +311,7 @@ func (r *RootElem) render(elem *vdom.VDomElem, comp **ComponentImpl, opts *Rende
 		r.renderText(elem.Text, comp)
 		return
 	}
-	if vdom.IsBaseTag(elem.Tag) {
+	if isBaseTag(elem.Tag) {
 		// simple vdom, fragment, wave element
 		r.renderSimple(elem, comp, opts)
 		return
@@ -421,9 +435,9 @@ func (r *RootElem) renderComponent(cfunc any, elem *vdom.VDomElem, comp **Compon
 	for k, v := range elem.Props {
 		props[k] = v
 	}
-	props[vdom.ChildrenPropKey] = elem.Children
+	props[ChildrenPropKey] = elem.Children
 	vc := MakeContextVal(r, *comp, opts)
-	ctx := vdom.WithRenderContext(r.OuterCtx, vc)
+	ctx := vdomctx.WithRenderContext(r.OuterCtx, vc)
 	renderedElem := callCFunc(cfunc, ctx, props)
 	rtnElemArr := vdom.PartToElems(renderedElem)
 	if len(rtnElemArr) == 0 {
@@ -472,11 +486,11 @@ func (r *RootElem) UpdateRef(updateRef rpctypes.VDomRefUpdate) {
 	r.AddRenderWork(waveId)
 }
 
-func (r *RootElem) QueueRefOp(op rpctypes.VDomRefOperation) {
+func (r *RootElem) QueueRefOp(op vdom.VDomRefOperation) {
 	r.RefOperations = append(r.RefOperations, op)
 }
 
-func (r *RootElem) GetRefOperations() []rpctypes.VDomRefOperation {
+func (r *RootElem) GetRefOperations() []vdom.VDomRefOperation {
 	ops := r.RefOperations
 	r.RefOperations = nil
 	return ops
@@ -573,17 +587,16 @@ func VDomFuncCallFn(vdf *vdom.VDomFunc, event vdom.VDomEvent) {
 	}
 }
 
-func QueueRefOp(ctx context.Context, ref *vdom.VDomRef, op rpctypes.VDomRefOperation) {
-	if ref == nil || !ref.HasCurrent {
-		return
+func isBaseTag(tag string) bool {
+	if tag == "" {
+		return false
 	}
-	vcIf := vdom.GetRenderContext(ctx)
-	if vcIf == nil {
-		panic("QueueRefOp must be called within a component (no context)")
+	if tag == vdom.TextTag || tag == vdom.WaveTextTag || tag == vdom.WaveNullTag || tag == vdom.FragmentTag {
+		return true
 	}
-	vc := vcIf.(*VDomContextVal)
-	if op.RefId == "" {
-		op.RefId = ref.RefId
+	if tag[0] == '#' {
+		return true
 	}
-	vc.Root.QueueRefOp(op)
+	firstChar := rune(tag[0])
+	return unicode.IsLower(firstChar)
 }