bind

type Binder[T comparable] interface {
	RWLocker
	Setter[T]
	tag.TagGetter
	jaws.ClickHandler
	jaws.ContextMenuHandler
	jaws.InitialHTMLAttrHandler

	JawsGetLocked(elem *jaws.Element) (value T)
	JawsSetLocked(elem *jaws.Element, value T) (err error)

	// JawsInitialHTMLAttrLocked returns the initial HTML attribute while
	// the Binder lock is held.
	JawsInitialHTMLAttrLocked(elem *jaws.Element) (s template.HTMLAttr)

	// SetLocked returns a Binder[T] that will call fn instead of JawsSetLocked.
	//
	// The lock will be held at this point.
	// Do not lock or unlock the Binder within fn. Do not call JawsSet.
	//
	// The bind argument to the function is the previous Binder in the chain,
	// and you probably want to call it's JawsSetLocked first.
	SetLocked(fn SetHook[T]) (newbind Binder[T])

	// GetLocked returns a Binder[T] that will call fn instead of JawsGetLocked.
	//
	// The lock will be held at this point, preferring RLock over Lock, if available.
	// Do not lock or unlock the Binder within fn. Do not call JawsGet.
	//
	// The bind argument to the function is the previous Binder in the chain,
	// and you probably want to call it's JawsGetLocked first.
	GetLocked(fn GetHook[T]) (newbind Binder[T])

	// Success returns a Binder[T] that will call fn after the value has been set
	// with no errors. No locks are held when the function is called.
	// If the function returns an error, that will be returned from JawsSet.
	//
	// The function must have one of the following signatures:
	//  * func()
	//  * func() error
	//  * func(*Element)
	//  * func(*Element) error
	Success(fn any) (newbind Binder[T])

	// GetHTML returns a Binder[T] that will call fn instead of the default
	// escaped fmt.Sprintf("%v", JawsGetLocked(elem)) HTML rendering.
	//
	// The lock will be held at this point, preferring RLock over Lock, if available.
	// Do not lock or unlock the Binder within fn. Do not call JawsGet.
	GetHTML(fn GetHTMLHook[T]) (newbind Binder[T])

	// Clicked returns a Binder[T] that will call fn when JawsClick is invoked.
	//
	// The Binder locks are not held when the function is called.
	Clicked(fn ClickedHook[T]) (newbind Binder[T])

	// ContextMenu returns a Binder[T] that will call fn when JawsContextMenu
	// is invoked.
	//
	// The Binder locks are not held when the function is called.
	ContextMenu(fn ContextMenuHook[T]) (newbind Binder[T])

	// InitialHTMLAttr returns a Binder[T] that will call fn when
	// JawsInitialHTMLAttr is invoked.
	//
	// The lock will be held at this point, preferring RLock over Lock, if available.
	// Do not lock or unlock the Binder within fn. Do not call JawsGet.
	// To call the previous handler in the chain, call JawsInitialHTMLAttrLocked.
	InitialHTMLAttr(fn InitialHTMLAttrHook[T]) (newbind Binder[T])
}

type ClickedHook[T comparable] func(bind Binder[T], elem *jaws.Element, click jaws.Click) (err error)

type ContextMenuHook[T comparable] func(bind Binder[T], elem *jaws.Element, click jaws.Click) (err error)

type GetHTMLHook[T comparable] func(bind Binder[T], elem *jaws.Element) (s template.HTML)

type GetHook[T comparable] func(bind Binder[T], elem *jaws.Element) (value T)

type Getter[T comparable] interface {
	JawsGet(elem *jaws.Element) (value T)
}

type HTMLGetter interface {
	JawsGetHTML(e *jaws.Element) template.HTML
}

type InitialHTMLAttrHook[T comparable] func(bind Binder[T], elem *jaws.Element) (s template.HTMLAttr)

type RWLocker interface {
	sync.Locker
	RLock()
	RUnlock()
}

type SetHook[T comparable] func(bind Binder[T], elem *jaws.Element, value T) (err error)

type Setter[T comparable] interface {
	Getter[T]
	// JawsSet may return ErrValueUnchanged to indicate value was already set.
	JawsSet(elem *jaws.Element, value T) (err error)
}

type SetterFloat64[T numeric] interface {
	Getter[T]
	// JawsSet may return ErrValueUnchanged to indicate value was already set.
	JawsSet(elem *jaws.Element, value T) (err error)
}

type SuccessHook func(*jaws.Element) (err error)