node

type Attribute ¶

type Attribute struct {
	Key   string
	Value string
}

Attribute represents an HTML attribute with a key-value pair

type ConditionalBuilder ¶

type ConditionalBuilder struct {
	// contains filtered or unexported fields
}

ConditionalBuilder provides a fluent API for conditional rendering. It allows you to specify different content based on a boolean condition.

Nil nodes are safely ignored - if a nil node is provided to True() or False(), it will not be stored and nothing will be rendered for that path.

Usage:

Condition(user.IsLoggedIn).
    True(p.Text("Welcome back!")).
    False(p.Text("Please log in"))

func Condition(condition bool) *ConditionalBuilder

func Unless(condition bool, node Node) *ConditionalBuilder

Unless(user.IsLoggedIn, a.New().Href("/login").Text("Sign in"))

func When(condition bool, node Node) *ConditionalBuilder

When(user.IsAdmin, span.Static("Admin"))

func (c *ConditionalBuilder) DynamicKey() string

func (c *ConditionalBuilder) False(node Node) *ConditionalBuilder

func (c *ConditionalBuilder) IsDynamic() bool

func (c *ConditionalBuilder) Nodes() []Node

func (c *ConditionalBuilder) Render(w ...io.Writer) []byte

func (c *ConditionalBuilder) RenderBuilder(buf *bytes.Buffer)

func (c *ConditionalBuilder) True(node Node) *ConditionalBuilder

type Dynamic ¶

type Dynamic interface {
	IsDynamic() bool
	DynamicKey() string
}

Dynamic represents nodes that contain dynamic content requiring re-evaluation on each render. IsDynamic reports whether the node produces different output across renders. DynamicKey returns the developer-assigned key used by the diff engine to track changes across renders. Nodes without a key return an empty string.

type Element ¶

type Element interface {
	Node

	SetAttribute(key string, value string)

	// RenderOpen and RenderClose split the element's rendering so that JIT can
	// cache the opening tag separately from the children.
	// For example: RenderOpen writes <div class="container">, RenderClose writes </div>.
	RenderOpen(buf *bytes.Buffer)
	RenderClose(buf *bytes.Buffer)
}

Element extends Node for HTML elements that have attributes and an open/close tag structure. Not all nodes are elements — text nodes, function components, and conditionals are not. This separation allows extensions (htmx, turbo, shoelace) to accept only types that genuinely support attributes, and allows JIT compilation to pre-render static wrapper tags independently of dynamic content.

type FuncsComponent ¶ added in v0.2.0

type FuncsComponent struct {
	// contains filtered or unexported fields
}

FuncsComponent enables dynamic content generation of multiple nodes. The function is called during rendering to generate the actual node content. This is useful for generating lists of items, e.g. from a loop.

Nil nodes are safely ignored - any nil nodes in the returned slice will be skipped.

Usage:

Funcs(func() []Node {
    nodes := []Node{}
    for _, item := range items {
        nodes = append(nodes, li.Text(item.Name))
    }
    return nodes
})

func Funcs(fn func() []Node) *FuncsComponent

func (f *FuncsComponent) DynamicKey() string

func (f *FuncsComponent) IsDynamic() bool

func (f *FuncsComponent) Nodes() []Node

func (f *FuncsComponent) Render(w ...io.Writer) []byte

func (f *FuncsComponent) RenderBuilder(buf *bytes.Buffer)

type FunctionComponent ¶

type FunctionComponent struct {
	// contains filtered or unexported fields
}

FunctionComponent enables dynamic content generation through function calls. The function is called during rendering to generate the actual node content. This is useful for complex conditional logic, loops, and data transformations.

Nil nodes are safely ignored - if the function returns nil, nothing will be rendered.

Usage:

Func(func() Node {
    if user.IsLoggedIn {
        return div.Text("Welcome back!")
    }
    return div.Text("Please log in")
})

func Func(fn func() Node) *FunctionComponent

func (f *FunctionComponent) DynamicKey() string

func (f *FunctionComponent) IsDynamic() bool

func (f *FunctionComponent) Nodes() []Node

func (f *FunctionComponent) Render(w ...io.Writer) []byte

func (f *FunctionComponent) RenderBuilder(buf *bytes.Buffer)

type Node ¶

type Node interface {
	// Render returns the HTML as a byte slice, or writes it to the provided writer.
	// Use this for top-level rendering where you need the final output.
	Render(w ...io.Writer) []byte

	// RenderBuilder writes HTML into a shared buffer to avoid allocations
	// when composing a tree of nodes. Parent nodes call this on their children.
	RenderBuilder(*bytes.Buffer)

	// Nodes returns the children that will be rendered. For conditionals
	// this is the active branch only; for function components this is the
	// evaluated output. Tree walkers rely on this matching Render output.
	Nodes() []Node
}

Node represents any renderable item in an HTML document tree. This is the base contract that all renderable types satisfy — text, elements, function components, and conditionals alike.