mooncakes.io

_bench
→
core
→
dom
→
examples
→
js
→
tests
→
x
→
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

README

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.

#
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.

#
previous

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

#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

#
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