respo 0.1.17

a tiny virtual DOM library migrated from ClojureScript
Documentation 
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
132

use std::{cell::RefCell, rc::Rc};
use wasm_bindgen::prelude::Closure;
use wasm_bindgen::JsCast;
use web_sys::Node;

/// this one uses `requestAnimationFrame` for calling
#[allow(dead_code)]
pub fn raf_loop(mut cb: Box<dyn FnMut() -> Result<(), String>>) {
  let f_ = Rc::new(RefCell::new(None));
  let g = f_.to_owned();

  *g.borrow_mut() = Some(Closure::wrap(Box::new(move || {
    if let Err(e) = cb() {
      crate::log!("failed in raq loop: {}", e);
    }

    // Schedule ourself for another requestAnimationFrame callback.
    request_animation_frame(f_.borrow().as_ref().expect("call raq"));
  }) as Box<dyn FnMut()>));

  request_animation_frame(g.borrow().as_ref().expect("call raq"));
}

fn request_animation_frame(f: &Closure<dyn FnMut()>) {
  window()
    .request_animation_frame(f.as_ref().unchecked_ref())
    .expect("should register `requestAnimationFrame` OK");
}

fn window() -> web_sys::Window {
  web_sys::window().expect("no global `window` exists")
}

/// uses `requestAnimationFrame` for calling, but with a interval to reduce cost.
/// prefer `req_loop` if you want to be faster
#[allow(dead_code)]
pub fn raf_loop_slow(interval: i32, mut cb: Box<dyn FnMut() -> Result<(), String>>) {
  let f = Rc::new(RefCell::new(None));
  let g = f.to_owned();

  *g.borrow_mut() = Some(Closure::wrap(Box::new(move || {
    if let Err(e) = cb() {
      crate::warn_log!(
        "Failure in slow loop, program has to stop since inconsistent DOM states. Details: {}",
        e
      );
    }

    let h = Closure::wrap(Box::new({
      let f = f.to_owned();
      move || {
        request_animation_frame(f.borrow().as_ref().expect("call raq"));
      }
    }) as Box<dyn FnMut()>);
    web_sys::Window::set_timeout_with_callback_and_timeout_and_arguments_0(&window(), h.as_ref().unchecked_ref(), interval)
      .expect("call set timeout");
    h.forget(); // It is not good practice, just for simplification!

    // Schedule ourself for another requestAnimationFrame callback.
    // request_animation_frame(f.borrow().as_ref().expect("call raq"));
  }) as Box<dyn FnMut()>));

  request_animation_frame(g.borrow().as_ref().expect("call raq"));
}

// just get first of tuple
pub(crate) fn fst<T, U>(pair: &(T, U)) -> &T {
  &pair.0
}

/// a shorthand for get an Node with given pattern
pub fn query_select_node(pattern: &str) -> Result<Node, String> {
  let window = web_sys::window().expect("no global `window` exists");
  let document = window.document().expect("should have a document on window");
  let target = document.query_selector(pattern).expect("call selector").expect("find .app");

  if let Some(element) = target.dyn_ref::<Node>() {
    Ok(element.to_owned())
  } else {
    Err(format!("failed to find {pattern}"))
  }
}

/// wraps on top of `web_sys::console.log_1`.
///
/// use it like:
/// ```ignore
/// util::log!("a is {}", a);
/// ```
#[macro_export]
macro_rules! log {
  ($($t:tt)*) => {{
    web_sys::console::log_1(&format!($($t)*).into());
  }};
}

/// wraps on top of `web_sys::console.warn_1`.
///
/// use it like:
/// ```ignore
/// util::warn_log!("a is {}", a);
/// ```
#[macro_export]
macro_rules! warn_log {
  ($($t:tt)*) => {{
    web_sys::console::warn_1(&format!($($t)*).into());
  }};
}

/// wraps on top of `web_sys::console.error_1`.
///
/// use it like:
/// ```ignore
/// util::error_log!("a is {}", a);
/// ```
#[macro_export]
macro_rules! error_log {
  ($($t:tt)*) => {{
    web_sys::console::error_1(&format!($($t)*).into());
  }};
}

pub use error_log;
pub use log;
pub use warn_log;

/// display type of a variable, as a debug tool
#[allow(dead_code)]
pub fn print_type_of<T>(_: &T) {
  // println!("{}", std::any::type_name::<T>())
  log!("{}", &std::any::type_name::<T>().to_string());
}