agnostic - v1.0.0

agnostic/vdom/vnode

Types

Element

</> 
pub type Element(message) {
  Fragment(
    kind: Int,
    key: String,
    children: List(Element(message)),
    keyed_children: mutable_map.MutableMap(
      String,
      Element(message),
    ),
  )
  Element(
    kind: Int,
    key: String,
    namespace: String,
    tag: String,
    attributes: List(vattr.Attribute(message)),
    children: List(Element(message)),
    keyed_children: mutable_map.MutableMap(
      String,
      Element(message),
    ),
  )
  Text(kind: Int, key: String, content: String)
  RawContainer(
    kind: Int,
    key: String,
    namespace: String,
    tag: String,
    attributes: List(vattr.Attribute(message)),
    content: RawContent,
    compare: option.Option(fn(RawContent, RawContent) -> Bool),
  )
  RawNode(
    kind: Int,
    key: String,
    content: RawContent,
    compare: option.Option(fn(RawContent, RawContent) -> Bool),
  )
  Map(
    kind: Int,
    key: String,
    mapper: fn(dynamic.Dynamic) -> dynamic.Dynamic,
    child: Element(message),
  )
  Memo(
    kind: Int,
    key: String,
    dependencies: List(ref.Ref),
    view: fn() -> Element(message),
  )
}

Constructors

Memos

</> 
pub type Memos(message) =
  mutable_map.MutableMap(
    fn() -> Element(message),
    Element(message),
  )

RawContent

</>

An external type for storing platform-specific raw content. For DOM platforms, this holds HTML strings. For other platforms (like OpenTUI), this can hold raw platform nodes. It’s defined as external to avoid polluting the Element type with another generic

pub type RawContent

RawContentComparator

</>

A comparator function for raw content. Used by the diff algorithm to determine if raw content has changed when reference equality isn’t sufficient.

pub type RawContentComparator =
  fn(RawContent, RawContent) -> Bool

RawContentSerializer

</> 
pub type RawContentSerializer =
  fn(RawContent) -> String

View

</> 
pub type View(message) =
  fn() -> Element(message)

Values

element

</> 
pub fn element(
  key key: String,
  namespace namespace: String,
  tag tag: String,
  attributes attributes: List(vattr.Attribute(message)),
  children children: List(Element(message)),
  keyed_children keyed_children: mutable_map.MutableMap(
    String,
    Element(message),
  ),
) -> Element(message)

element_kind

</> 
pub const element_kind: Int

empty_keyed_children

</> 
pub fn empty_keyed_children() -> mutable_map.MutableMap(
  String,
  Element(message),
)

Create an empty keyed children map. Used internally when constructing elements without keyed children.

fragment

</> 
pub fn fragment(
  key key: String,
  children children: List(Element(message)),
  keyed_children keyed_children: mutable_map.MutableMap(
    String,
    Element(message),
  ),
) -> Element(message)

fragment_kind

</> 
pub const fragment_kind: Int

map

</> 
pub fn map(element: Element(a), mapper: fn(a) -> b) -> Element(b)

map_kind

</> 
pub const map_kind: Int

memo

</> 
pub fn memo(
  key key: String,
  dependencies dependencies: List(ref.Ref),
  view view: fn() -> Element(message),
) -> Element(message)

memo_kind

</> 
pub const memo_kind: Int

raw_container

</> 
pub fn raw_container(
  key key: String,
  namespace namespace: String,
  tag tag: String,
  attributes attributes: List(vattr.Attribute(message)),
  content content: a,
  compare compare: option.Option(fn(a, a) -> Bool),
) -> Element(message)

raw_container_kind

</> 
pub const raw_container_kind: Int

raw_content_to_string

</> 
pub fn raw_content_to_string(content: RawContent) -> String

Convert RawContent back to a String. This should only be used when you know the content is a String (e.g., in server-side HTML rendering).

raw_node

</> 
pub fn raw_node(
  key key: String,
  content content: a,
  compare compare: option.Option(fn(a, a) -> Bool),
) -> Element(message)

raw_node_kind

</> 
pub const raw_node_kind: Int

text

</> 
pub fn text(
  key key: String,
  content content: String,
) -> Element(message)

text_kind

</> 
pub const text_kind: Int

to_json

</> 
pub fn to_json(
  node: Element(message),
  memos: mutable_map.MutableMap(
    fn() -> Element(message),
    Element(message),
  ),
  serialize_raw_content: fn(RawContent) -> String,
) -> json.Json

to_keyed

</> 
pub fn to_keyed(
  key: String,
  node: Element(message),
) -> Element(message)

to_raw_content

</> 
pub fn to_raw_content(value: a) -> RawContent

Convert any value to a RawContent. This is the hack that make this work

✨ Search Document