mooncakes.io

README
U
AsyncState
U
Attr
U
ComponentRef
U
Context
U
EventHandler
U
MatchCase
U
Node
U
Owner
U
Resource
U
Signal
U
Trigger
U
TriggerType
U
TrustedHtml
U
VAsync
U
VElement
U
VErrorBoundary
U
VInternalRef
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
match_case
V
memo
V
on
V
on_cleanup
V
on_immediate
V
on_mount
V
previous
V
previous_with_initial
V
provide
V
raw_html
V
raw_trusted_html
V
register_disposer
V
register_owner_cleanup
V
render_effect
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
unsafe_trusted_html
V
untracked
V
use_context
V
watch
V
watch_immediate
V
wc_component_ref
V
wc_island

mizchi/luna/js/resource does not have a README file

Context

using @mizchi/signals { type Context }

Context type with typed getter The current_getter is managed per-context and tracks the current value chain

Lens

source

using @mizchi/signals { type Lens }

A lens focuses on a specific part of a larger structure

LensStore

source

using @mizchi/signals { type LensStore }

A store with lens-based field access Each focused lens creates a derived signal that only updates when that field changes

Owner

source

using @mizchi/signals { type Owner }

Owner - manages lifecycle of reactive computations (Solid.js style)

Signal

source

using @mizchi/signals { type Signal }

Signal type - holds a value and notifies subscribers on change. A reactive primitive that stores a value and automatically tracks dependencies.

Snapshot

source

using @mizchi/signals { trait Snapshot }

Trait for signal records that can produce a snapshot

SplitStore2

source

using @mizchi/signals { type SplitStore2 }

A record where each field is an independent Signal This is the most performant approach - updates only affect specific fields

SplitStore3

source

using @mizchi/signals { type SplitStore3 }

3-field version

Resource

source

pub struct Resource[T] {
  state : @mizchi/signals.Signal
Signal[@mizchi/signals/ui.AsyncState
AsyncState[T]]
  // private fields
}

Resource - Async value container with Signal integration Environment-agnostic: uses callbacks instead of Promise/async directly

Resource::error

source

fn[T] Resource::error(self : Resource[T]) -> String?

Get error if failure

Resource::get

source

fn[T] Resource::get(self : Resource[T]) -> @mizchi/signals/ui.AsyncState
AsyncState[T]

Get current async state (reactive)

Resource::is_failure

source

fn[T] Resource::is_failure(self : Resource[T]) -> Bool

Check if failed

Resource::is_pending

source

fn[T] Resource::is_pending(self : Resource[T]) -> Bool

Check if currently pending

Resource::is_success

source

fn[T] Resource::is_success(self : Resource[T]) -> Bool

Check if successfully loaded

Resource::peek

source

fn[T] Resource::peek(self : Resource[T]) -> @mizchi/signals/ui.AsyncState
AsyncState[T]

Peek current state without tracking

Resource::pending

source

fn[T] Resource::pending(self : Resource[T]) -> (() -> Bool)

Returns a reactive getter that tracks whether this resource is pending. Unlike is_pending() which uses peek(), this uses get() for dependency tracking.

Resource::refetch

source

fn[T] Resource::refetch(self : Resource[T]) -> Unit

Trigger refetch

Resource::value

source

fn[T] Resource::value(self : Resource[T]) -> T?

Get value if success

all

source

fn all(signals : Array[@mizchi/signals.Signal
Signal[Bool]]) -> (() -> Bool)

Create a signal that is true when all input signals are true.

any

source

fn any(signals : Array[@mizchi/signals.Signal
Signal[Bool]]) -> (() -> Bool)

Create a signal that is true when any input signal is true.

batch

source

fn[T] batch(f : () -> T) -> T

Run a function in a batch - all signal updates are batched. Effects only run once after all updates complete.

batch_end

source

fn batch_end() -> Unit

End a batch update - run all pending effects

batch_start

source

fn batch_start() -> Unit

Start a batch update - effects won't run until batch ends

combine2

source

fn[A, B, R] combine2(a : @mizchi/signals.Signal
Signal[A], b : @mizchi/signals.Signal
Signal[B], f : (A, B) -> R) -> (() -> R)

Combine two signals into one. The getter recomputes when either signal changes.

combine3

source

fn[A, B, C, R] combine3(a : @mizchi/signals.Signal
Signal[A], b : @mizchi/signals.Signal
Signal[B], c : @mizchi/signals.Signal
Signal[C], f : (A, B, C) -> R) -> (() -> R)

Combine three signals into one

combine4

source

fn[A, B, C, D, R] combine4(a : @mizchi/signals.Signal
Signal[A], b : @mizchi/signals.Signal
Signal[B], c : @mizchi/signals.Signal
Signal[C], d : @mizchi/signals.Signal
Signal[D], f : (A, B, C, D) -> R) -> (() -> R)

Combine four signals into one

computed

source

fn[T] computed(compute : () -> T) -> (() -> T)

Create a computed signal (alias for memo with Signal-like API). Same as memo, but named to be more familiar for those coming from other reactive frameworks.

create_context

source

fn[T] create_context(default_value : T) -> @mizchi/signals.Context
Context[T]

Create a new context with a default value Similar to Solid.js createContext

create_root

source

fn[T] create_root(f : (() -> Unit) -> T) -> T

Create a new reactive root scope. The function receives a dispose callback that cleans up all effects. Returns the result of the function.

create_root_with_dispose

source

fn[T] create_root_with_dispose(f : () -> T) -> (T, () -> Unit)

Create a reactive root and return both result and dispose function

deferred

source

fn[T] deferred() -> (Resource[T], (T) -> Unit, (String) -> Unit)

Create a deferred Resource (starts pending, resolve/reject manually)

effect

source

fn effect(fn_ : () -> Unit) -> (() -> Unit)

Create an effect that is deferred until after rendering completes. (Solid.js style createEffect - deferred execution via microtask) Returns a dispose function to stop the effect. Unlike render_effect, this runs asynchronously via microtask queue.

effect_once

source

fn effect_once(fn_ : () -> Unit) -> Unit

Create a one-time effect that disposes itself after first run. Useful for initialization logic that should only run once.

effect_when

source

fn effect_when(condition : () -> Bool, fn_ : () -> Unit) -> (() -> Unit)

Create an effect that only runs when condition is true. Uses render_effect for synchronous execution.

flatten

source

fn[T] flatten(outer : @mizchi/signals.Signal
Signal[@mizchi/signals.Signal
Signal[T]]) -> (() -> T)

Flatten a signal of signals. Unwraps nested Signal[Signal[T]] to a getter for T.

get_owner

source

fn get_owner() -> @mizchi/signals.Owner
Owner?

Get the current owner (if any)

has_owner

source

fn has_owner() -> Bool

Check if currently inside an owner scope

is_batching

source

fn is_batching() -> Bool

Check if we're currently inside a batch

memo

source

fn[T] memo(compute : () -> T) -> (() -> T)

Create a memoized computation. Returns a getter function that caches the result and recomputes only when dependencies change.

memo_eq

source

fn[T : Eq] memo_eq(compute : () -> T) -> (() -> T)

A memo whose cutoff compares values with Eq rather than object identity.

Reach for this when compute returns a freshly allocated value that is often equal to the previous one — a formatted String, a small struct, a bucketed number. memo republishes each of those because every result is a new object; memo_eq republishes only when the value actually moved.

test "memo_eq stops an effect that memo would wake" {
  let n = @resource.signal(0)
  // A fresh String every time, but the same text until `n` reaches 100.
  let label = @resource.memo_eq(() => "page \{n.get() / 100}")
  let runs = Ref(0)
  let _ = @resource.render_effect(() => {
    let _ = label()
    runs.val  1
  })
  for i in 1...=5 {
    n.set(i)
  }
  // Five source changes, one effect run: the label never moved.
  inspect(runs.val, content="1")
  inspect(label(), content="page 0")
}

Two differences from memo worth knowing:

It is eager. memo is lazy — compute first runs on the first read. memo_eq runs it once at construction and again on every source change, whether or not anything reads the result. Per source change the two cost the same single compute call.
It is owned. It installs an effect, registered with the current owner, so it stops recomputing once that owner is disposed; a disposed memo_eq keeps returning the last value it published. Created outside any owner it lives as long as the program, like a bare render_effect.

Reads are always current: a read straight after set, with no flush in between, sees the new value.

new_effect_id

source

fn new_effect_id() -> Int

Generate a new unique effect ID

on

source

fn[T] on(sig : @mizchi/signals.Signal
Signal[T], callback : (T) -> Unit) -> (() -> Unit)

Explicitly subscribe to a signal with a callback. Returns an unsubscribe function. Unlike effect(), this doesn't auto-track and only listens to this one signal. Callback is NOT called on initial subscription, only on subsequent changes.

on_cleanup

source

fn on_cleanup(cleanup : () -> Unit) -> Unit

Effects: cleanup runs before effect re-runs or when effect disposes
Components: cleanup runs when component unmounts (Solid.js style - can be called directly in component body)

on_immediate

source

fn[T] on_immediate(sig : @mizchi/signals.Signal
Signal[T], callback : (T) -> Unit) -> (() -> Unit)

Subscribe and run immediately with current value. Like on, but also invokes the callback with the current value right away.

on_mount

source

fn on_mount(fn_ : () -> Unit) -> Unit

Run a function once after mount (Solid.js style onMount). The function runs without tracking dependencies. Cleanup registered via on_cleanup inside will run when owner is disposed.

source

fn[T] previous(sig : @mizchi/signals.Signal
Signal[T]) -> (() -> T?)

Create a signal that holds the previous value of another signal. Returns a getter function for the previous value (None on first read).

previous_with_initial

source

fn[T] previous_with_initial(sig : @mizchi/signals.Signal
Signal[T], initial : T) -> (() -> T)

Create a signal that holds the previous value with initial value. Unlike previous, this returns a plain T instead of T?.

provide

source

fn[T, R] provide(ctx : @mizchi/signals.Context
Context[T], value : T, f : () -> R) -> R

Provide a context value for the current Owner and its descendants The value is associated with the current Owner and will be available to all effects and components created within this scope.

register_disposer

source

fn register_disposer(disposer : () -> Unit) -> Unit

register_owner_cleanup

source

fn register_owner_cleanup(cleanup : () -> Unit) -> Unit

render_effect

source

fn render_effect(fn_ : () -> Unit) -> (() -> Unit)

Create an effect that runs immediately and re-runs when dependencies change. (Solid.js style createRenderEffect - synchronous execution) Returns a dispose function to stop the effect. Supports on_cleanup() calls inside the effect.

resource

source

fn[T] resource(fetcher : ((T) -> Unit, (String) -> Unit) -> Unit) -> Resource[T]

Create a Resource from a callback-based fetcher The fetcher receives (resolve, reject) callbacks This is environment-agnostic - the actual async execution is handled by the caller

resource_rejected

source

fn[T] resource_rejected(error : String) -> Resource[T]

Create a Resource with initial error (already rejected)

resource_resolved

source

fn[T] resource_resolved(value : T) -> Resource[T]

Create a Resource with initial value (already resolved)

run_with_cleanup_tracking

source

fn[T] run_with_cleanup_tracking(cleanups : Array[() -> Unit], f : () -> T) -> T

Run a function with cleanup tracking enabled

run_with_owner

source

fn[T] run_with_owner(owner : @mizchi/signals.Owner
Owner, f : () -> T) -> T

Run a function with a specific owner as current

select

source

fn[T] select(items : @mizchi/signals.Signal
Signal[Array[T]], index : @mizchi/signals.Signal
Signal[Int]) -> (() -> T?)

Select from an array signal by index signal. Returns None if index is out of bounds.

set_current_cleanups

source

fn set_current_cleanups(cleanups : Array[() -> Unit]?) -> Array[() -> Unit]?

Set the current cleanup array (used internally by effect)

sig_filter

source

fn[T] sig_filter(sig : @mizchi/signals.Signal
Signal[T], predicate : (T) -> Bool) -> @mizchi/signals.Signal
Signal[T?]

Filter signal updates - only updates when predicate is true. Returns a signal that only updates when predicate passes.

sig_filter_map

source

fn[T, U] sig_filter_map(sig : @mizchi/signals.Signal
Signal[T], f : (T) -> U?) -> @mizchi/signals.Signal
Signal[U?]

Filter and map signal updates Uses render_effect for synchronous execution

sig_map

source

fn[T, U] sig_map(sig : @mizchi/signals.Signal
Signal[T], f : (T) -> U) -> (() -> U)

Map a signal's value through a function. Returns a getter function (like memo) that recomputes when the signal changes.

signal

source

fn[T] signal(initial : T) -> @mizchi/signals.Signal
Signal[T]

Convenience function to create a signal. Shorthand for Signal::new.

switch_

source

fn[T] switch_(condition : @mizchi/signals.Signal
Signal[Bool], on_true : @mizchi/signals.Signal
Signal[T], on_false : @mizchi/signals.Signal
Signal[T]) -> (() -> T)

Switch between signals based on a boolean signal. Returns value from on_true when condition is true, otherwise on_false.

to_getter

source

fn[T] to_getter(sig : @mizchi/signals.Signal
Signal[T]) -> (() -> T)

Create a read-only getter for a signal

untracked

source

fn[T] untracked(f : () -> T) -> T

Run a function without tracking (useful for avoiding circular deps). Signal reads inside this function won't create subscriptions.

use_context

source

fn[T] use_context(ctx : @mizchi/signals.Context
Context[T]) -> T

Use a context value - returns the current provided value or default Walks up the Owner chain to find the nearest provided value. Similar to Solid.js useContext

watch

source

fn[T : Eq] watch(source : () -> T, callback : (T, T) -> Unit) -> (() -> Unit)

Watch a computed expression and run callback when it changes. Returns a dispose function. The callback receives (newValue, oldValue).

watch_immediate

source

fn[T : Eq] watch_immediate(source : () -> T, callback : (T, T?) -> Unit) -> (() -> Unit)

Watch with immediate execution (runs callback on first value too). The callback receives (newValue, oldValue?) where oldValue is None on first run.

with_parent_owner

source

fn[T] with_parent_owner(captured_owner : @mizchi/signals.Owner
Owner?, f : () -> T) -> T

Run a function with a captured parent owner context (if any) This is useful for rendering child components that need to inherit the parent's owner. If captured_owner is Some, runs with that owner as context. If captured_owner is None, runs directly without owner context.

Source Files

Site source Report issue Packages Build queue Skills Statistics

#Context

#Lens

#LensStore

#Owner

#Signal

#Snapshot

#SplitStore2

#SplitStore3

#Resource

#Resource::error

#Resource::get

#Resource::is_failure

#Resource::is_pending

#Resource::is_success

#Resource::peek

#Resource::pending

#Resource::refetch

#Resource::value

#all

#any

#batch

#batch_end

#batch_start

#combine2

#combine3

#combine4

#computed

#create_context

#create_root

#create_root_with_dispose

#deferred

#effect

#effect_once

#effect_when

#flatten

#get_owner

#has_owner

#is_batching

#memo

#memo_eq

#new_effect_id

#on

#on_cleanup

#on_immediate

#on_mount

#previous

#previous_with_initial

#provide

#register_disposer

#register_owner_cleanup

#render_effect

#resource

#resource_rejected

#resource_resolved

#run_with_cleanup_tracking

#run_with_owner

#select

#set_current_cleanups

#sig_filter

#sig_filter_map

#sig_map

#signal

#switch_

#to_getter

#untracked

#use_context

#watch

#watch_immediate

#with_parent_owner

Source Files

Context

Lens

LensStore

Owner

Signal

Snapshot

SplitStore2

SplitStore3

Resource

Resource::error

Resource::get

Resource::is_failure

Resource::is_pending

Resource::is_success

Resource::peek

Resource::pending

Resource::refetch

Resource::value

all

any

batch

batch_end

batch_start

combine2

combine3

combine4

computed

create_context

create_root

create_root_with_dispose

deferred

effect

effect_once

effect_when

flatten

get_owner

has_owner

is_batching

memo

memo_eq

new_effect_id

on

on_cleanup

on_immediate

on_mount

previous

previous_with_initial

provide

register_disposer

register_owner_cleanup

render_effect

resource

resource_rejected

resource_resolved

run_with_cleanup_tracking

run_with_owner

select

set_current_cleanups

sig_filter

sig_filter_map

sig_map

signal

switch_

to_getter

untracked

use_context

watch

watch_immediate

with_parent_owner