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

TriggerType::to_string

source

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

Convert TriggerType to attribute value

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

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

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

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

fragment

source

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

Create a fragment VNode

h

source

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

Create a VNode element

handler

source

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

Create an event handler from a callback

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

show

source

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

Create a conditional VNode

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

text_dyn

source

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

Create a dynamic text VNode

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

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

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