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) False(node Node) *ConditionalBuilder

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 {
	// Dynamic returns true if this node contains dynamic content that must be re-evaluated on each render.
	Dynamic() bool
}

Dynamic represents nodes that contain dynamic content requiring re-evaluation on each render. This interface is used by the JIT compiler to identify nodes that cannot be pre-rendered.

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 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) Nodes() []Node

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

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

type FunctionsComponent ¶

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

FunctionsComponent 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:

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

func FuncNodes(fn func() []Node) *FunctionsComponent

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

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

func (f *FunctionsComponent) 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 direct children of this node.
	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.