htmgo/framework/h/attribute.go

package h

import (
	"fmt"
	"github.com/maddalax/htmgo/framework/datastructure/orderedmap"
	"github.com/maddalax/htmgo/framework/hx"
	"github.com/maddalax/htmgo/framework/internal/util"
	"strings"
)

type AttributeMap = map[string]any

type AttributeMapOrdered struct {
	data *orderedmap.Map[string, string]
}

func (m *AttributeMapOrdered) Set(key string, value any) {
	switch v := value.(type) {
	case string:
		m.data.Set(key, v)
	case *AttributeMap:
		for k, v2 := range *v {
			m.Set(k, v2)
		}
	case *AttributeMapOrdered:
		v.Each(func(k string, v2 string) {
			m.Set(k, v2)
		})
	case *AttributeR:
		m.data.Set(v.Name, v.Value)
	default:
		m.data.Set(key, fmt.Sprintf("%v", value))
	}
}

func (m *AttributeMapOrdered) Each(cb func(key string, value string)) {
	m.data.Each(func(key string, value string) {
		cb(key, value)
	})
}

func (m *AttributeMapOrdered) Entries() []orderedmap.Entry[string, string] {
	return m.data.Entries()
}

func NewAttributeMap(pairs ...string) *AttributeMapOrdered {
	m := orderedmap.New[string, string]()
	if len(pairs)%2 == 0 {
		for i := 0; i < len(pairs); i++ {
			m.Set(pairs[i], pairs[i+1])
			i++
		}
	}
	return &AttributeMapOrdered{data: m}
}

func NoSwap() *AttributeR {
	return Attribute("hx-swap", "none")
}

func Attribute(key string, value string) *AttributeR {
	return &AttributeR{
		Name:  key,
		Value: value,
	}
}

func AttributeList(children ...*AttributeR) *AttributeMapOrdered {
	m := NewAttributeMap()
	for _, c := range children {
		m.Set(c.Name, c.Value)
	}
	return m
}

func Attributes(attributes *AttributeMap) *AttributeMapOrdered {
	m := NewAttributeMap()
	for k, v := range *attributes {
		m.Set(k, v)
	}
	return m
}

func AttributePairs(pairs ...string) *AttributeMapOrdered {
	return NewAttributeMap(pairs...)
}

func Checked() Ren {
	return Attribute("checked", "")
}

func Id(value string) Ren {
	value = strings.TrimPrefix(value, "#")
	return Attribute("id", value)
}

func Disabled() *AttributeR {
	return Attribute("disabled", "")
}

func HxTarget(target string) Ren {
	return Attribute(hx.TargetAttr, target)
}

func Name(name string) Ren {
	return Attribute("name", name)
}

func HxConfirm(message string) Ren {
	return Attribute(hx.ConfirmAttr, message)
}

// HxInclude https://htmx.org/attributes/hx-include/
func HxInclude(selector string) Ren {
	return Attribute(hx.IncludeAttr, selector)
}

func HxIndicator(tag string) *AttributeR {
	return Attribute(hx.IndicatorAttr, tag)
}

// TriggerChildren Adds the hx-extension="trigger-children" to an element
// See https://htmgo.dev/docs#htmx-extensions-trigger-children
func TriggerChildren() *AttributeR {
	return HxExtension("trigger-children")
}

// HxTriggerString Adds a hx-trigger to an element based on a string of triggers
func HxTriggerString(triggers ...string) *AttributeR {
	trigger := hx.NewStringTrigger(strings.Join(triggers, ", "))
	return Attribute(hx.TriggerAttr, trigger.ToString())
}

// HxTrigger Adds a hx-trigger to an element
func HxTrigger(opts ...hx.TriggerEvent) *AttributeR {
	return Attribute(hx.TriggerAttr, hx.NewTrigger(opts...).ToString())
}

// HxTriggerClick Adds a hx-trigger="click" to an element
func HxTriggerClick(opts ...hx.Modifier) *AttributeR {
	return HxTrigger(hx.OnClick(opts...))
}

// HxExtension Adds a hx-ext to an element
func HxExtension(value string) *AttributeR {
	return Attribute(hx.ExtAttr, value)
}

// HxExtensions Adds multiple hx-ext to an element, separated by commas
func HxExtensions(value ...string) Ren {
	return Attribute(hx.ExtAttr, strings.Join(value, ","))
}

func JoinExtensions(attrs ...*AttributeR) Ren {
	return JoinAttributes(", ", attrs...)
}

// JoinAttributes joins multiple attributes into a single attribute string based on a separator
// Example: JoinAttributes(", ", Attribute("hx-extension", "one"), Attribute("hx-extension", "two")) = hx-extension="one,two"
func JoinAttributes(sep string, attrs ...*AttributeR) *AttributeR {
	values := make([]string, 0, len(attrs))
	for _, a := range attrs {
		values = append(values, a.Value)
	}
	return Attribute(attrs[0].Name, strings.Join(values, sep))
}

func Href(path string) Ren {
	return Attribute("href", path)
}

func Target(target string) Ren {
	return Attribute("target", target)
}

func D(value string) Ren {
	return Attribute("d", value)
}

func Alt(value string) Ren {
	return Attribute("alt", value)
}

func For(value string) Ren {
	return Attribute("for", value)
}

func Type(name string) Ren {
	return Attribute("type", name)
}

func Placeholder(placeholder string) Ren {
	return Attribute("placeholder", placeholder)
}

func Hidden() Ren {
	return Attribute("style", "display:none")
}

func Controls() Ren {
	return Attribute("controls", "")
}

func Class(value ...string) *AttributeR {
	return Attribute("class", MergeClasses(value...))
}

// ClassF is a helper function to create a class attribute with the given format string and arguments
func ClassF(format string, args ...interface{}) *AttributeR {
	atr := fmt.Sprintf(format, args...)
	return Attribute("class", atr)
}

// ClassX conditionally renders a class based on a map of class names and boolean values
// value is any non-conditional class name you'd like to add
// m is a map of class names and boolean values
func ClassX(value string, m ClassMap) Ren {
	builder := strings.Builder{}
	builder.WriteString(value)
	builder.WriteString(" ")
	for k, v := range m {
		if v {
			builder.WriteString(k)
			builder.WriteString(" ")
		}
	}
	return Class(builder.String())
}

// MergeClasses merges multiple classes into a single class string
func MergeClasses(classes ...string) string {
	if len(classes) == 1 {
		return classes[0]
	}
	builder := strings.Builder{}
	for _, s := range classes {
		builder.WriteString(s)
		builder.WriteString(" ")
	}
	return builder.String()
}

func Boost() Ren {
	return Attribute(hx.BoostAttr, "true")
}

func IfQueryParam(key string, node *Element) Ren {
	return Fragment(Attribute("hx-if-qp:"+key, "true"), node)
}

func ReadOnly() *AttributeR {
	return Attribute("readonly", "")
}

func Required() *AttributeR {
	return Attribute("required", "")
}

func Multiple() *AttributeR {
	return Attribute("multiple", "")
}

func Selected() *AttributeR {
	return Attribute("selected", "")
}

func MaxLength(value int) *AttributeR {
	return Attribute("maxlength", fmt.Sprintf("%d", value))
}

func MinLength(value int) *AttributeR {
	return Attribute("minlength", fmt.Sprintf("%d", value))
}

func Size(value int) *AttributeR {
	return Attribute("size", fmt.Sprintf("%d", value))
}

func Width(value int) *AttributeR {
	return Attribute("width", fmt.Sprintf("%d", value))
}

func Height(value int) *AttributeR {
	return Attribute("height", fmt.Sprintf("%d", value))
}

func Download(value bool) *AttributeR {
	return Attribute("download", fmt.Sprintf("%t", value))
}

func Rel(value string) *AttributeR {
	return Attribute("rel", value)
}

func Pattern(value string) *AttributeR {
	return Attribute("pattern", value)
}

func Action(value string) *AttributeR {
	return Attribute("action", value)
}

func Method(value string) *AttributeR {
	return Attribute("method", value)
}

func Enctype(value string) *AttributeR {
	return Attribute("enctype", value)
}

func AutoComplete(value string) *AttributeR {
	return Attribute("autocomplete", value)
}

func AutoFocus() *AttributeR {
	return Attribute("autofocus", "")
}

func NoValidate() *AttributeR {
	return Attribute("novalidate", "")
}

func Step(value string) *AttributeR {
	return Attribute("step", value)
}

func Max(value string) *AttributeR {
	return Attribute("max", value)
}

func Min(value string) *AttributeR {
	return Attribute("min", value)
}

func Cols(value int) *AttributeR {
	return Attribute("cols", fmt.Sprintf("%d", value))
}

func Rows(value int) *AttributeR {
	return Attribute("rows", fmt.Sprintf("%d", value))
}

func Wrap(value string) *AttributeR {
	return Attribute("wrap", value)
}

func Role(value string) *AttributeR {
	return Attribute("role", value)
}

func AriaLabel(value string) *AttributeR {
	return Attribute("aria-label", value)
}

func AriaHidden(value bool) *AttributeR {
	return Attribute("aria-hidden", fmt.Sprintf("%t", value))
}

func TabIndex(value int) *AttributeR {
	return Attribute("tabindex", fmt.Sprintf("%d", value))
}

func GenId(len int) string {
	return util.RandSeq(len)
}