1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! `Closure<F>` `Box<dyn Fn>` `Box<Fn>` `Box<dyn FnMut>` `Box<dyn FnOnce>`
//! implements [IntoJsRuntime] and [TryBorrowToJsRuntime](crate::TryBorrowToJsRuntime).
//!
//! Only `Rc<Closure<F>>`, `Rc<Fn>` implements [BorrowToJsRuntime].
//!

use crate::PassToJsRuntimeValue;
use std::{any::Any, rc::Rc};
use wasm_bindgen::closure::{Closure, WasmClosure, WasmClosureFnOnce};

// Closure<F>
crate::impl_pass_to_js_runtime! {
    [
        try_borrow: None
        into:   own_closure
    ]
    { F: 'static + ?Sized } Closure<F>
}

// Closure<F>
crate::impl_pass_to_js_runtime! {
    [
        borrow: clone
        into(this) {
            let js_value = this.as_ref().as_ref().clone();
            PassToJsRuntimeValue {
                js_value,
                to_persist: Some(this as Rc<dyn Any>),
            }
        }
    ]
    { F: 'static + ?Sized } Rc<Closure<F>>
}

// dyn FnOnce
crate::impl_pass_to_js_runtime! {
    [
        try_borrow: None
    ]
    { T0, TR } dyn FnOnce(T0) -> TR
    where Self: WasmClosureFnOnce<(T0,), TR>
}

// Box<dyn FnOnce>
crate::impl_pass_to_js_runtime! {
    [
        try_borrow: None
        into: own_fn_once
    ]
    { T0, TR } Box<dyn FnOnce(T0) -> TR>
    where Self: WasmClosureFnOnce<(T0,), TR>
}

// dyn Fn
crate::impl_pass_to_js_runtime! {
    [
        try_borrow: None
    ]
    { T0, TR } dyn Fn(T0) -> TR
    where dyn Fn(T0) -> TR: WasmClosure
}

// Box<dyn Fn>
crate::impl_pass_to_js_runtime! {
    [
        try_borrow: None
        into: own_fn
    ]
    { T0: 'static, TR: 'static } Box<dyn Fn(T0) -> TR>
    where dyn Fn(T0) -> TR: WasmClosure
}

// Rc<Fn>
crate::impl_pass_to_js_runtime! {
    [
        borrow: clone
        into: own_rc_fn
    ]
    { T0: 'static, TR: 'static } Rc<dyn Fn(T0) -> TR>
    where dyn Fn(T0) -> TR: WasmClosure
}

// dyn FnMut
crate::impl_pass_to_js_runtime! {
    [
        try_borrow: None
    ]
    { T0, TR } dyn FnMut(T0) -> TR
    where dyn FnMut(T0) -> TR: WasmClosure
}

// Box<FnMut>
crate::impl_pass_to_js_runtime! {
    [
        try_borrow: None
        into: own_fn
    ]
    { T0: 'static, TR: 'static } Box<dyn FnMut(T0) -> TR>
    where dyn FnMut(T0) -> TR: WasmClosure
}

fn own_fn_once<T: ?Sized, A, R>(v: Box<T>) -> PassToJsRuntimeValue
where
    Box<T>: WasmClosureFnOnce<A, R>,
{
    let c = Closure::once(v);
    own_closure(c)
}

fn own_rc_fn<T0: 'static, TR: 'static>(v: Rc<dyn Fn(T0) -> TR>) -> PassToJsRuntimeValue
where
    dyn Fn(T0) -> TR: WasmClosure,
{
    own_fn(Box::new(move |js| v.as_ref()(js)) as Box<dyn Fn(T0) -> TR>)
}

fn own_fn<T: 'static>(v: Box<T>) -> PassToJsRuntimeValue
where
    T: ?Sized + WasmClosure,
{
    let c = Closure::wrap(v);
    own_closure(c)
}

fn own_closure<F: 'static + ?Sized>(v: Closure<F>) -> PassToJsRuntimeValue {
    let js_value = v.as_ref().clone();
    PassToJsRuntimeValue {
        js_value,
        to_persist: Some(Rc::new(v) as Rc<dyn Any>),
    }
}