README
U
AsyncState
U
Attr
U
ComponentRef
U
Context
U
EffectRunner
U
EventHandler
U
MatchCase
U
Node
U
Owner
U
Resource
U
Signal
U
Trigger
U
TriggerType
U
VAsync
U
VElement
U
VErrorBoundary
U
VInternalRef
U
VIsland
U
VSwitch
U
VWcIsland
V
action
V
all
V
any
V
async_
V
attr_dynamic
V
attr_dynamic_style
V
attr_handler
V
attr_static
V
attr_style
V
batch
V
batch_end
V
batch_start
V
combine2
V
combine3
V
combine4
V
component
V
component_ref
V
computed
V
create_context
V
create_root
V
create_root_with_dispose
V
deferred
V
effect
V
effect_once
V
effect_when
V
error_boundary
V
event_handler
V
flatten
V
for_each
V
fragment
V
get_owner
V
h
V
handler
V
handler_from_callback
V
has_dynamic_content
V
has_owner
V
internal_ref
V
island
V
match_case
V
memo
V
on
V
on_cleanup
V
on_immediate
V
on_mount
V
previous
V
previous_with_initial
V
provide
V
register_disposer
V
register_owner_cleanup
V
resource
V
resource_rejected
V
resource_resolved
V
run_with_owner
V
select
V
show
V
signal
V
switch_
V
text
V
text_dyn
V
text_of
V
untracked
V
use_context
V
watch
V
watch_immediate
V
wc_component_ref
V
wc_island

#Luna Core

Core functionality of the Luna UI library. Platform-independent.

#Module Structure

Submodule	Responsibility
signal/	Reactive primitives (Signal, Effect, Computed)
render/	VNode → HTML string rendering
routes/	Type-safe routing
serialize/	State serialization/deserialization
vnode.mbt	VNode type definitions

#VNode

Virtual DOM node. Type parameter E represents the event type.

pub enum Node[E] {
  Element(VElement[E])      // HTML element
  Text(String)              // Static text
  DynamicText(() -> String) // Dynamic text
  Fragment(Array[Node[E]])  // Fragment
  Show(...)                 // Conditional rendering
  For(...)                  // List rendering
  Island(VIsland[E])        // Hydration boundary
  WcIsland(VWcIsland[E])    // Web Components Island
  Async(VAsync[E])          // Async node
  // ...
}

#Signal

Reactive value container.

let count = @signal.signal(0)
count.get()        // 0
count.set(1)       // Set value
count.update(fn(n) { n + 1 })  // Update function

// Derived value
let doubled = @signal.computed(fn() { count.get() * 2 })

// Side effects
@signal.effect(fn() {
  println(count.get())
})

#Attr

Attribute values. Supports static/dynamic/event handlers.

pub enum Attr[E] {
  VStatic(String)           // Static value
  VDynamic(() -> String)    // Signal-linked
  VHandler(EventHandler[E]) // Event handler
  VAction(String)           // Declarative action
}

#TriggerType

Hydration triggers.

pub enum TriggerType {
  Load      // On page load
  Idle      // On requestIdleCallback
  Visible   // On IntersectionObserver detection
  Media(String)  // On media query match
  None      // Manual trigger
}

#References

Signal Implementation - Reactive system details
Routes Implementation - Routing details

Attr

source

pub enum Attr[E] {
  VStatic(String)
  VDynamic(() -> String)
  VHandler(EventHandler[E])
  VAction(String)
}

Attribute value that can be static or dynamic (signal-based)

ComponentRef

source

pub(all) struct ComponentRef[T] {
  url : String
  props : T
  wc : Bool
  trigger : TriggerType
}

Component reference for type-safe Island embedding Represents a client-side component that can be embedded in server-rendered HTML

url: Path to the client JavaScript (e.g., "/static/counter.js")
props: Component props (must be ToJson serializable)
wc: Whether this is a Web Components based Island
trigger: When to hydrate the component

EventHandler

source

pub struct EventHandler[E] {
  callback : (E) -> Unit
}

Event handler type - newtype wrapper for callback function

EventHandler::get_callback

source

fn[E] EventHandler::get_callback(self : EventHandler[E]) -> ((E) -> Unit)

Get the callback function

MatchCase

source

pub struct MatchCase[E] {
  when : () -> Bool
  render : () -> Node[E]
}

Match case for Switch - pairs a condition with content

Node

source

pub enum Node[E] {
  Element(VElement[E])
  Text(String)
  DynamicText(() -> String)
  Fragment(Array[Node[E]])
  Show(() -> Bool, () -> Node[E])
  For(() -> Array[Node[E]])
  Component(() -> Node[E])
  Island(VIsland[E])
  WcIsland(VWcIsland[E])
  Async(VAsync[E])
  ErrorBoundary(VErrorBoundary[E])
  Switch(VSwitch[E])
  InternalRef(VInternalRef[E])
  RawHtml(String)
}

Virtual DOM node types

TriggerType

source

#alias(Trigger)
pub(all) enum TriggerType {
  Load
  Idle
  Visible
  Media(String)
  None
}

Hydration trigger types - when to hydrate a component

TriggerType::parse

source

fn TriggerType::parse(s : String) -> TriggerType

Parse TriggerType from string.

test {
  // Round-trip test: parse then to_string
  inspect(@luna.TriggerType::parse("load").to_string(), content="load")
  inspect(@luna.TriggerType::parse("idle").to_string(), content="idle")
  inspect(@luna.TriggerType::parse("visible").to_string(), content="visible")
  inspect(@luna.TriggerType::parse("none").to_string(), content="none")
  inspect(
    @luna.TriggerType::parse("media:(min-width: 1024px)").to_string(),
    content="media:(min-width: 1024px)",
  )
}

TriggerType::to_string

source

fn TriggerType::to_string(self : TriggerType) -> String

Convert TriggerType to attribute value.

test {
  inspect(@luna.Load.to_string(), content="load")
  inspect(@luna.Idle.to_string(), content="idle")
  inspect(@luna.Visible.to_string(), content="visible")
  inspect(
    @luna.Media("(max-width: 768px)").to_string(),
    content="media:(max-width: 768px)",
  )
  inspect(@luna.None.to_string(), content="none")
}

VAsync

source

pub struct VAsync[E] {
  render : async () -> Node[E]
  fallback : () -> Node[E]
  on_error : (Error) -> Node[E]?
}

Virtual Async node for async rendering with error handling Note: async functions implicitly raise Error, no need for raise? annotation

VElement

source

pub struct VElement[E] {
  tag : String
  attrs : Array[(String, Attr[E])]
  children : Array[Node[E]]
}

Virtual element node

VErrorBoundary

source

pub struct VErrorBoundary[E] {
  children : () -> Node[E] raise
  fallback : (Error, () -> Unit) -> Node[E] raise
}

Virtual ErrorBoundary node for catching rendering errors Similar to Solid.js ErrorBoundary - catches errors during:

Child component rendering
Effects and memos within children Does NOT catch:
Event handler errors
Async errors outside render cycle

VInternalRef

source

pub struct VInternalRef[E] {
  url : String
  state : String
  trigger : TriggerType
  wc : Bool
  styles : String
  children : Array[Node[E]]
}

Virtual Internal Reference node for type-safe Island embedding

VIsland

source

pub struct VIsland[E] {
  id : String
  url : String
  state : String
  trigger : TriggerType
  children : Array[Node[E]]
}

Virtual Island node - serializable hydration unit

VSwitch

source

pub struct VSwitch[E] {
  cases : Array[MatchCase[E]]
  fallback : () -> Node[E]?
}

Virtual Switch node - renders first matching case Similar to Solid.js /

cases: array of condition-content pairs, evaluated in order
fallback: optional content when no case matches

VWcIsland

source

pub struct VWcIsland[E] {
  name : String
  url : String
  styles : String
  state : String
  trigger : TriggerType
  children : Array[Node[E]]
}

Virtual Web Components Island node - Web Components based hydration unit Uses Declarative Shadow DOM for SSR and DOM Parts for partial updates

action

source

fn[E, A : Show] action(a : A) -> Attr[E]

Create an action attribute value - dispatches named action on event Used for declarative event handling with enum types: ("onclick", action(Increment)) // requires derive(Show)

Example:

pub enum MyAction { Increment; Decrement } derive(Show)
@luna.h("button", [("onclick", action(Increment))], [...])

async_

source

fn[E] async_(render~ : async () -> Node[E], fallback~ : () -> Node[E], on_error? : (Error) -> Node[E]?) -> Node[E]

Create an async VNode with fallback

render: async function that produces the content (may raise errors)
fallback: shown while loading or on error (if no on_error handler)
on_error: optional custom error UI handler

attr_dynamic

source

fn[E] attr_dynamic(getter : () -> String) -> Attr[E]

Create a dynamic attribute value. The value is computed lazily on each render.

test {
  let count = @signal.signal(0)
  let attr : @luna.Attr[Unit] = @luna.attr_dynamic(fn() {
    "count-" + count.get().to_string()
  })
  guard attr is @luna.VDynamic(getter) else { fail("expected VDynamic") }
  inspect(getter(), content="count-0")
  count.set(5)
  inspect(getter(), content="count-5")
}

attr_dynamic_style

source

fn[E] attr_dynamic_style(getter : () -> String) -> Attr[E]

Create a dynamic style attribute value

attr_handler

source

fn[E] attr_handler(handler : EventHandler[E]) -> Attr[E]

Create a handler attribute value

attr_static

source

fn[E] attr_static(value : String) -> Attr[E]

Create a static attribute value.

test {
  let attr : @luna.Attr[Unit] = @luna.attr_static("my-class")
  guard attr is @luna.VStatic(v) else { fail("expected VStatic") }
  inspect(v, content="my-class")
}

attr_style

source

fn[E] attr_style(style : String) -> Attr[E]

Create a style attribute value (string form, e.g. "color: red; margin: 10px")

component

source

fn[E] component(render : () -> Node[E]) -> Node[E]

Create a component VNode. Wraps a render function as a component boundary.

test {
  let node : @luna.Node[Unit] = @luna.component(fn() {
    @luna.h("div", [], [@luna.text("Component")])
  })
  guard node is @luna.Component(render~) else { fail("expected Component") }
  guard render() is @luna.Element(el) else { fail("expected Element") }
  inspect(el.tag, content="div")
}

component_ref

source

fn[T] component_ref(url : String, props : T, trigger? : TriggerType) -> ComponentRef[T]

Create a ComponentRef for a regular Island component

error_boundary

source

fn[E] error_boundary(children~ : () -> Node[E] raise, fallback~ : (Error, () -> Unit) -> Node[E] raise) -> Node[E]

Create an error boundary VNode Catches errors during child rendering and displays fallback UI

children: lazy function that produces child content (may throw)
fallback: function receiving (error, reset) that produces fallback UI
- error: the caught Error
- reset: function to retry rendering children

Example:

error_boundary(
  children=fn() { risky_component() },
  fallback=fn(err, reset) {
    h("div", [], [
      text("Error: " + err.to_string()),
      h("button", [("onclick", handler(fn(_) { reset() }))], [text("Retry")])
    ])
  }
)

event_handler

source

fn event_handler() -> EventHandler[Unit]

Create a placeholder event handler for SSR (noop)

for_each

source

fn[E] for_each(items : () -> Array[Node[E]]) -> Node[E]

Create a list VNode. Renders a dynamic list of nodes.

test {
  let items = @signal.signal(["a", "b", "c"])
  let node : @luna.Node[Unit] = @luna.for_each(fn() {
    items.get().map(fn(s) { @luna.text(s) })
  })
  guard node is @luna.For(render~) else { fail("expected For") }
  inspect(render().length(), content="3")
}

fragment

source

fn[E] fragment(children : Array[Node[E]]) -> Node[E]

Create a fragment VNode. Groups multiple nodes without a wrapper element.

test {
  let node : @luna.Node[Unit] = @luna.fragment([
    @luna.text("Hello"),
    @luna.text(" "),
    @luna.text("World"),
  ])
  guard node is @luna.Fragment(children) else { fail("expected Fragment") }
  inspect(children.length(), content="3")
}

h

source

fn[E] h(tag : String, attrs : Array[(String, Attr[E])], children : Array[Node[E]]) -> Node[E]

Create a VNode element. The main building block for creating virtual DOM elements.

test {
  let node : @luna.Node[Unit] = @luna.h(
    "div",
    [("class", @luna.attr_static("container"))],
    [@luna.text("Hello")],
  )
  guard node is @luna.Element(el) else { fail("expected Element") }
  inspect(el.tag, content="div")
}

handler

source

fn[E] handler(f : (E) -> Unit) -> EventHandler[E]

Create an event handler from a callback.

test {
  let h : @luna.EventHandler[Int] = @luna.handler(fn(x) {
    let _ = x * 2

  })
  inspect(h.get_callback()(5), content="()")
}

handler_from_callback

source

fn handler_from_callback(f : () -> Unit) -> EventHandler[Unit]

Create an event handler from a simple callback (ignores event, for SSR compatibility)

has_dynamic_content

source

fn[E] has_dynamic_content(attrs : Array[(String, Attr[E])]) -> Bool

Check if element has dynamic content that needs hydration

internal_ref

source

fn[E] internal_ref(url : String, state : String, trigger? : TriggerType, wc? : Bool, styles? : String, children? : Array[Node[E]]) -> Node[E]

Create an internal reference VNode (for server_dom.island())

island

source

fn[E] island(id : String, url : String, state : String, children : Array[Node[E]], trigger? : TriggerType) -> Node[E]

Create an island VNode for partial hydration

match_case

source

fn[E] match_case(when~ : () -> Bool, render~ : () -> Node[E]) -> MatchCase[E]

Create a match case for Switch

when: condition function, evaluated lazily
render: content to render when condition is true

raw_html

source

fn[E] raw_html(content : String) -> Node[E]

Create a raw HTML VNode (content is not escaped). Use with caution: content should be trusted or sanitized.

test {
  let node : @luna.Node[Unit] = @luna.raw_html("<strong>Bold</strong>")
  guard node is @luna.RawHtml(html) else { fail("expected RawHtml") }
  inspect(html, content="<strong>Bold</strong>")
}

show

source

fn[E] show(when : () -> Bool, child : () -> Node[E]) -> Node[E]

Create a conditional VNode. Only renders the child when the condition is true.

test {
  let visible = @signal.signal(true)
  let node : @luna.Node[Unit] = @luna.show(fn() { visible.get() }, fn() {
    @luna.text("Visible!")
  })
  guard node is @luna.Show(condition~, ..) else { fail("expected Show") }
  inspect(condition(), content="true")
}

switch_

source

fn[E] switch_(cases~ : Array[MatchCase[E]], fallback? : () -> Node[E]?) -> Node[E]

Create a switch VNode - renders first matching case Similar to Solid.js /

Example:

switch_(
  cases=[
    match_case(when=fn() { state.get() == 1 }, render=fn() { text("One") }),
    match_case(when=fn() { state.get() == 2 }, render=fn() { text("Two") }),
  ],
  fallback=Some(fn() { text("Other") })
)

text

source

fn[E] text(content : String) -> Node[E]

Create a text VNode.

test {
  let node : @luna.Node[Unit] = @luna.text("Hello World")
  guard node is @luna.Text(s) else { fail("expected Text") }
  inspect(s, content="Hello World")
}

text_dyn

source

fn[E] text_dyn(content : () -> String) -> Node[E]

Create a dynamic text VNode. The content is computed lazily on each render.

test {
  let count = @signal.signal(5)
  let node : @luna.Node[Unit] = @luna.text_dyn(fn() { count.get().to_string() })
  guard node is @luna.DynamicText(getter) else { fail("expected DynamicText") }
  inspect(getter(), content="5")
  count.set(10)
  inspect(getter(), content="10")
}

text_of

source

fn[E, T : Show] text_of(sig : @mizchi/luna/luna/signal.Signal
Signal[T]) -> Node[E]

Create a text VNode from a signal. Shorthand for text_dyn(fn() { sig.get().to_string() }).

test {
  let name = @signal.signal("Alice")
  let node : @luna.Node[Unit] = @luna.text_of(name)
  guard node is @luna.DynamicText(getter) else { fail("expected DynamicText") }
  inspect(getter(), content="Alice")
  name.set("Bob")
  inspect(getter(), content="Bob")
}

wc_component_ref

source

fn[T] wc_component_ref(url : String, props : T, trigger? : TriggerType) -> ComponentRef[T]

Create a ComponentRef for a Web Components Island

wc_island

source

fn[E] wc_island(name : String, url : String, styles : String, state : String, children : Array[Node[E]], trigger? : TriggerType) -> Node[E]

Create a Web Components island VNode for partial hydration Uses Declarative Shadow DOM for SSR

Source Files

vnode.mbt

Site source Report issue Packages Build queue Skills Statistics

#Luna Core

#Module Structure

#VNode

#Signal

#Attr

#TriggerType

#References

#Attr

#ComponentRef

#EventHandler

#EventHandler::get_callback

#MatchCase

#Node

#TriggerType

#TriggerType::parse

#TriggerType::to_string

#VAsync

#VElement

#VErrorBoundary

#VInternalRef

#VIsland

#VSwitch

#VWcIsland

#action

#async_

#attr_dynamic

#attr_dynamic_style

#attr_handler

#attr_static

#attr_style

#component

#component_ref

#error_boundary

#event_handler

#for_each

#fragment

#h

#handler

#handler_from_callback

#has_dynamic_content

#internal_ref

#island

#match_case

#raw_html

#show

#switch_

#text

#text_dyn

#text_of

#wc_component_ref

#wc_island

Source Files

Attr

ComponentRef

EventHandler

EventHandler::get_callback

MatchCase

Node

TriggerType

TriggerType::parse

TriggerType::to_string

VAsync

VElement

VErrorBoundary

VInternalRef

VIsland

VSwitch

VWcIsland

action

async_

attr_dynamic

attr_dynamic_style

attr_handler

attr_static

attr_style

component

component_ref

error_boundary

event_handler

for_each

fragment

h

handler

handler_from_callback

has_dynamic_content

internal_ref

island

match_case

raw_html

show

switch_

text

text_dyn

text_of

wc_component_ref

wc_island