1use std::cell::RefCell;
5use std::collections::HashSet;
6use std::ffi::c_void;
7
8use redjs::ffi::{redjs_promise_create, redjs_protect, redjs_unprotect};
9use redjs::glue;
10use redjs::webapi::domexception;
11use redjs::webapi::util::*;
12
13pub unsafe fn global(g: *mut c_void) -> u64 {
14 glue::rjs_global(g)
15}
16
17pub unsafe fn error(g: *mut c_void, name: &str, msg: &str) -> u64 {
19 if matches!(name, "TypeError" | "RangeError" | "Error") {
20 let ctor = get(g, global(g), name);
21 return call(g, ctor, UNDEF, &[js_string(g, msg)]).unwrap_or(UNDEF);
22 }
23 domexception::create(g, name, msg)
24}
25
26pub unsafe fn throw(g: *mut c_void, name: &str, msg: &str) -> u64 {
28 glue::rjs_throw(g, error(g, name, msg));
29 UNDEF
30}
31
32pub struct Settler {
34 resolve: u64,
35 reject: u64,
36}
37
38impl Settler {
39 pub unsafe fn resolve(self, g: *mut c_void, v: u64) {
40 let _ = call(g, self.resolve, UNDEF, &[v]);
41 self.release(g);
42 }
43
44 pub unsafe fn reject(self, g: *mut c_void, e: u64) {
45 let _ = call(g, self.reject, UNDEF, &[e]);
46 self.release(g);
47 }
48
49 pub unsafe fn settle(self, g: *mut c_void, outcome: Result<u64, u64>) {
50 match outcome {
51 Ok(v) => self.resolve(g, v),
52 Err(e) => self.reject(g, e),
53 }
54 }
55
56 pub unsafe fn abandon(self, g: *mut c_void) {
58 self.release(g);
59 }
60
61 unsafe fn release(self, g: *mut c_void) {
62 redjs_unprotect(g, self.resolve);
63 redjs_unprotect(g, self.reject);
64 }
65}
66
67pub unsafe fn deferred(g: *mut c_void) -> (u64, Settler) {
69 let (mut resolve, mut reject, mut promise) = (UNDEF, UNDEF, UNDEF);
70 redjs_promise_create(g, &mut resolve, &mut reject, &mut promise);
71 redjs_protect(g, resolve);
72 redjs_protect(g, reject);
73 (promise, Settler { resolve, reject })
74}
75
76pub unsafe fn rejected_with(g: *mut c_void, reason: u64) -> u64 {
77 let (p, s) = deferred(g);
78 s.reject(g, reason);
79 p
80}
81
82pub unsafe fn rejected(g: *mut c_void, name: &str, msg: &str) -> u64 {
83 rejected_with(g, error(g, name, msg))
84}
85
86pub unsafe fn resolved(g: *mut c_void, v: u64) -> u64 {
87 resolved_promise(g, v)
88}
89
90pub unsafe fn to_js(g: *mut c_void, v: &serde_json::Value) -> u64 {
91 use serde_json::Value as J;
92 match v {
93 J::Null => NULL,
94 J::Bool(b) => enc_bool(*b),
95 J::Number(n) => enc_f64(n.as_f64().unwrap_or(0.0)),
96 J::String(s) => js_string(g, s),
97 J::Array(a) => {
98 let arr = new_array(g);
99 for (i, x) in a.iter().enumerate() {
100 set_i(g, arr, i as u32, to_js(g, x));
101 }
102 arr
103 }
104 J::Object(m) => {
105 let obj = new_object(g, UNDEF);
106 for (k, x) in m {
107 define(g, obj, k, to_js(g, x), 0);
108 }
109 obj
110 }
111 }
112}
113
114pub unsafe fn stringify(g: *mut c_void, v: u64) -> Option<String> {
116 let json = get(g, global(g), "JSON");
117 let s = call(g, get(g, json, "stringify"), json, &[v]).ok()?;
118 if s == UNDEF {
119 return None;
120 }
121 read_string(g, s)
122}
123
124pub unsafe fn frozen_strings(g: *mut c_void, items: &[impl AsRef<str>]) -> u64 {
126 let arr = new_array(g);
127 for (i, s) in items.iter().enumerate() {
128 set_i(g, arr, i as u32, js_string(g, s.as_ref()));
129 }
130 let object = get(g, global(g), "Object");
131 call(g, get(g, object, "freeze"), object, &[arr]).unwrap_or(arr)
132}
133
134pub unsafe fn is_string(g: *mut c_void, v: u64) -> bool {
135 const KIND_STRING: u32 = 5;
136 glue::rjs_kind(g, v) == KIND_STRING
137}
138
139pub unsafe fn truthy(g: *mut c_void, v: u64) -> bool {
140 call(g, get(g, global(g), "Boolean"), UNDEF, &[v]) == Ok(TRUE)
141}
142
143pub unsafe fn string_arg(g: *mut c_void, v: u64) -> Option<String> {
144 if v == UNDEF {
145 return None;
146 }
147 to_js_string(g, v).ok().and_then(|s| read_string(g, s))
148}
149
150pub unsafe fn method(g: *mut c_void, obj: u64, name: &str, arity: u32, f: HostFn) {
151 define(g, obj, name, make_fn(g, name, arity, f), 2);
152}
153
154pub unsafe fn getter(g: *mut c_void, obj: u64, name: &str, f: HostFn) {
155 let a = atom(g, name);
156 glue::rjs_define_accessor(
157 g,
158 obj,
159 a,
160 make_fn(g, &format!("get {name}"), 0, f),
161 UNDEF,
162 0,
163 );
164 glue::rjs_atom_free(g, a);
165}
166
167pub unsafe fn install_object(g: *mut c_void, name: &str, proto: u64) -> u64 {
169 let obj = new_object(g, proto);
170 redjs_protect(g, obj);
171 define(g, global(g), name, obj, 2);
172 obj
173}
174
175thread_local! {
176 static WARNED: RefCell<HashSet<String>> = RefCell::new(HashSet::new());
177}
178
179pub unsafe fn warn_compat(g: *mut c_void, key: &str, msg: &str) -> bool {
181 warn_once(g, key.to_string(), &format!("[skathi compat] {msg}"))
182}
183
184unsafe fn warn_once(g: *mut c_void, key: String, line: &str) -> bool {
185 if !WARNED.with(|w| w.borrow_mut().insert(key)) {
186 return false;
187 }
188 let console = get(g, global(g), "console");
189 if is_cell(console) {
190 let _ = call(g, get(g, console, "warn"), console, &[js_string(g, line)]);
191 }
192 true
193}
194
195pub fn has_warned(key: &str) -> bool {
196 WARNED.with(|w| w.borrow().contains(key))
197}
198
199crate::host_fn!(fn js_advise(g, args) {
200 let key = unsafe { string_arg(g, args.arg(0).0) }.unwrap_or_default();
201 let msg = unsafe { string_arg(g, args.arg(1).0) }.unwrap_or_default();
202 enc_bool(unsafe { warn_compat(g, &key, &msg) })
203});
204
205crate::host_fn!(fn js_advised(g, args) {
206 let key = unsafe { string_arg(g, args.arg(0).0) }.unwrap_or_default();
207 enc_bool(has_warned(&key))
208});
209
210crate::host_fn!(fn js_perf_advise(g, args) {
211 let code = match unsafe { string_arg(g, args.arg(0).0) }.as_deref() {
212 Some("wasted-render") => "wasted-render",
213 Some("long-list") => "long-list",
214 Some("host-writes") => "host-writes",
215 _ => return UNDEF,
216 };
217 let key = unsafe { string_arg(g, args.arg(1).0) }.unwrap_or_default();
218 let msg = unsafe { string_arg(g, args.arg(2).0) }.unwrap_or_default();
219 redjs::profiling::hint(code, &msg);
220 enc_bool(unsafe { warn_once(g, format!("perf:{code}:{key}"), &format!("[skathi perf] {msg}")) })
221});
222
223pub(crate) unsafe fn install(g: *mut c_void) {
227 define(
228 g,
229 global(g),
230 "__sk_perf_advise",
231 make_fn(g, "__sk_perf_advise", 3, js_perf_advise),
232 2,
233 );
234 define(
235 g,
236 global(g),
237 "__sk_advise",
238 make_fn(g, "__sk_advise", 2, js_advise),
239 2,
240 );
241 define(
242 g,
243 global(g),
244 "__sk_advised",
245 make_fn(g, "__sk_advised", 1, js_advised),
246 2,
247 );
248}
249
250#[cfg(test)]
251mod tests {
252 use crate::JsRuntime;
253
254 #[test]
255 fn the_runtime_and_the_host_share_one_advisory_set() {
256 crate::testing::on_js_thread(|| {
257 JsRuntime::with(|rt| {
258 let read = |src: &str| {
259 rt.ctx()
260 .to_rust_string(rt.ctx().eval(src).unwrap())
261 .unwrap()
262 };
263 assert!(unsafe { super::warn_compat(rt.raw(), "host-first", "said by the host") });
264 assert_eq!(
265 read("[__sk_advised('host-first'), __sk_advise('host-first', 'x'), __sk_advise('js-first', 'y'), __sk_advise('js-first', 'y')].join()"),
266 "true,false,true,false"
267 );
268 assert!(super::has_warned("js-first"));
269 });
270 });
271 }
272}