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) SetAttribute(_ string, _ string)

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

	// RenderOpen writes the opening tag and attributes to the buffer.
	// For example, for a div with class="container", this writes: <div class="container">
	RenderOpen(buf *bytes.Buffer)

	// RenderClose writes the closing tag to the buffer.
	// For example, for a div, this writes: </div>
	// For self-closing elements, this is a no-op.
	RenderClose(buf *bytes.Buffer)
}

Element extends Node with methods for rendering opening and closing tags separately. This interface enables JIT compilation to pre-render static wrapper tags while preserving dynamic content rendering.

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)

func (f *FunctionComponent) SetAttribute(_ string, _ string)

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)

func (f *FunctionsComponent) SetAttribute(_ string, _ string)

type Node ¶

type Node interface {
	// Render generates the complete HTML representation of the node.
	// If a writer is provided, the output is written to it and nil is returned.
	// If no writer is provided, the output is returned as a byte slice.
	Render(w ...io.Writer) []byte

	// RenderBuilder writes the HTML representation directly to a buffer.
	// This method is used for building complex node trees efficiently
	// by allowing nodes to render into a shared buffer.
	RenderBuilder(*bytes.Buffer)

	// Nodes returns a slice of child nodes.
	// For nodes that do not have children, it returns an empty slice.
	Nodes() []Node

	// SetAttribute sets an attribute on the node.
	// This is the primary method for extensions to add attributes safely.
	SetAttribute(key string, value string)
}

Node represents any element in an HTML document tree. All nodes implement both direct output rendering and efficient buffer rendering for optimal performance in different scenarios.