#mizchi/js/builtins/weak

    Weak references (WeakRef, FinalizationRegistry).

    #Installation

    Add to your moon.pkg.json:

    { "import": [ "mizchi/js", "mizchi/js/builtins/weak" ] }

    #Overview

    Provides bindings for JavaScript's weak reference APIs:
    • WeakRef - Weak reference to an object that doesn't prevent garbage collection
    • FinalizationRegistry - Callback when objects are garbage collected

    #Usage Example

    fn main {
    let obj = @core.Object::new()

    // Create a weak reference
    let weak_ref = @weak.WeakRef::new(obj)

    // Dereference (might return None if collected)
    let deref = weak_ref.deref()

    // FinalizationRegistry for cleanup callbacks
    let registry = @weak.FinalizationRegistry::new()
    }

    #Use Cases

    • Cache implementations
    • Memory-sensitive data structures
    • Resource cleanup tracking

    #Reference

    FinalizationRegistry

    #external
    pub type FinalizationRegistry[T]

    FinalizationRegistry::new

    fn[T] FinalizationRegistry::new(cleanup_callback : (T) -> Unit) -> FinalizationRegistry[T]

    FinalizationRegistry::register

    fn[T, U] FinalizationRegistry::register(self : FinalizationRegistry[T], target : U, held_value : T, unregister_token? :
    Any
    ) -> Unit

    FinalizationRegistry::unregister

    fn[T] FinalizationRegistry::unregister(self : FinalizationRegistry[T], unregister_token :
    Any
    ) -> Bool

    WeakMap

    #external
    pub type WeakMap[K, V]

    WeakMap::delete

    fn[K, V] WeakMap::delete(self : WeakMap[K, V], key : K) -> Bool

    WeakMap::get

    fn[K, V] WeakMap::get(self : WeakMap[K, V], key : K) -> V?

    WeakMap::has

    fn[K, V] WeakMap::has(self : WeakMap[K, V], key : K) -> Bool

    WeakMap::new

    fn[K, V] WeakMap::new() -> WeakMap[K, V]

    WeakMap::set

    fn[K, V] WeakMap::set(self : WeakMap[K, V], key : K, value : V) -> WeakMap[K, V]

    WeakRef

    #external
    pub type WeakRef[T]

    JavaScript WeakRef

    WeakRef::deref

    fn[T] WeakRef::deref(self : WeakRef[T]) -> T?

    WeakRef::new

    fn[T] WeakRef::new(target : T) -> WeakRef[T]

    WeakSet

    #external
    pub type WeakSet[T]

    WeakSet::add

    fn[T] WeakSet::add(self : WeakSet[T], value : T) -> WeakSet[T]

    WeakSet::delete

    fn[T] WeakSet::delete(self : WeakSet[T], value : T) -> Bool

    WeakSet::has

    fn[T] WeakSet::has(self : WeakSet[T], value : T) -> Bool

    WeakSet::new

    fn[T] WeakSet::new() -> WeakSet[T]

    Source Files