1use proc_macro::TokenStream;
2use quote::{format_ident, quote, ToTokens};
3use syn::{parse_macro_input, Fields, FnArg, Ident, ImplItem, ItemFn, ItemImpl, ItemStruct, Visibility};
4use syn::__private::TokenStream2;
5use syn::token::{Async};
6
7#[proc_macro_attribute]
8pub fn mrc_object(_attr: TokenStream, struct_def: TokenStream) -> TokenStream {
9 let struct_def = parse_macro_input!(struct_def as ItemStruct);
10 let weak_name = format_ident!("{}Weak", struct_def.ident);
11 let struct_name = format_ident!("{}Data", struct_def.ident);
12 let mut_name = format_ident!("{}RefMut", struct_def.ident);
13 let ref_name = struct_def.ident;
14 let fields = struct_def.fields;
15
16 let expanded = quote! {
17
18 #[derive(Clone, PartialEq)]
19 pub struct #ref_name {
20 inner: deft::mrc::Mrc<#struct_name>,
21 }
22
23 impl std::ops::Deref for #ref_name {
24 type Target = deft::mrc::Mrc<#struct_name>;
25
26 fn deref(&self) -> &Self::Target {
27 &self.inner
28 }
29 }
30
31 impl std::ops::DerefMut for #ref_name {
32 fn deref_mut(&mut self) -> &mut Self::Target {
33 &mut self.inner
34 }
35 }
36
37 impl #ref_name {
38
39 pub fn from_inner(inner: deft::mrc::Mrc<#struct_name>) -> Self {
40 Self { inner }
41 }
42
43 pub fn as_weak(&self) -> #weak_name {
44 #weak_name {
45 inner: Some(self.inner.as_weak()),
46 }
47 }
48 }
49
50 pub struct #mut_name<'a> {
51 weak: &'a #weak_name,
52 data: #ref_name,
53 }
54
55 impl<'a> std::ops::Deref for #mut_name<'a> {
56 type Target = #ref_name;
57
58 fn deref(&self) -> &Self::Target {
59 &self.data
60 }
61 }
62
63 impl<'a> std::ops::DerefMut for #mut_name<'a> {
64 fn deref_mut(&mut self) -> &mut Self::Target {
65 &mut self.data
66 }
67 }
68
69 #[derive(Clone, PartialEq)]
70 pub struct #weak_name {
71 inner: Option<deft::mrc::MrcWeak<#struct_name>>,
72 }
73
74 impl #weak_name {
75
76 pub fn invalid() -> Self {
77 Self {inner: None}
78 }
79
80 pub fn upgrade(&self) -> Result<#ref_name, deft::mrc::UpgradeError> {
81 let inner = if let Some(inner) = &self.inner {
82 inner.upgrade()?
83 } else {
84 return Err(deft::mrc::UpgradeError{});
85 };
86 Ok(
87 #ref_name {
88 inner
89 }
90 )
91 }
92
93 pub fn upgrade_mut(&self) -> Result<#mut_name, deft::mrc::UpgradeError> {
94 let data = self.upgrade()?;
95 Ok(
96 #mut_name {
97 weak: self,
98 data,
99 }
100 )
101 }
102
103 }
104
105 pub struct #struct_name
106 #fields
107
108
109 impl #struct_name {
110 pub fn to_ref(self) -> #ref_name {
111 let inner = deft::mrc::Mrc::new(self);
112 #ref_name::from_inner(inner)
113 }
114 }
115
116 };
117 expanded.into()
118}
119
120#[proc_macro_attribute]
121pub fn element_backend(_attr: TokenStream, struct_def: TokenStream) -> TokenStream {
122 let struct_def = parse_macro_input!(struct_def as ItemStruct);
123 let struct_name = struct_def.ident.clone();
124 let visibility = struct_def.vis.clone();
125 let struct_fields = struct_def.fields;
126 let q = quote! {
127
128 #[deft_macros::mrc_object]
129 #visibility struct #struct_name #struct_fields
130
131 impl deft::js::FromJsValue for #struct_name {
132 fn from_js_value(value: deft::js::JsValue) -> Result<Self, deft::js::ValueError> {
133 let element = deft::element::Element::from_js_value(value)?;
134 Ok(element.get_backend_as::<#struct_name>().clone())
135 }
136 }
137 };
138 q.into()
139}
140
141#[proc_macro_attribute]
142pub fn event(_attr: TokenStream, struct_def: TokenStream) -> TokenStream {
143 create_event(_attr, struct_def, quote! {deft::element::ElementWeak})
144}
145
146#[proc_macro_attribute]
147pub fn window_event(_attr: TokenStream, struct_def: TokenStream) -> TokenStream {
148 create_event(_attr, struct_def, quote! {deft::window::WindowWeak})
149}
150
151#[proc_macro_attribute]
152pub fn worker_event(_attr: TokenStream, struct_def: TokenStream) -> TokenStream {
153 create_event(_attr, struct_def, quote! {deft::ext::ext_worker::WorkerWeak})
154}
155
156#[proc_macro_attribute]
157pub fn worker_context_event(_attr: TokenStream, struct_def: TokenStream) -> TokenStream {
158 create_event(_attr, struct_def, quote! {deft::ext::ext_worker::WorkerContextWeak})
159}
160
161fn create_event(_attr: TokenStream, struct_def: TokenStream, target_type: TokenStream2) -> TokenStream {
162 let struct_def = parse_macro_input!(struct_def as ItemStruct);
163 let listener_name = format_ident!("{}Listener", struct_def.ident);
164 let event_name = struct_def.ident;
165 let fields = struct_def.fields;
166
167 let fields_ts = match fields {
168 Fields::Named(nf) => { quote! {#nf} }
169 Fields::Unnamed(uf) => { quote! {#uf;} }
170 Fields::Unit => {quote! {#fields;} }
171 };
172
173 let expanded = quote! {
174
175 pub struct #listener_name(Box<dyn FnMut(&mut #event_name, &mut deft::base::EventContext<#target_type>)>);
176
177 impl #listener_name {
178 pub fn new<F: FnMut(&mut #event_name, &mut deft::base::EventContext<#target_type>) + 'static>(f: F) -> Self {
179 Self(Box::new(f))
180 }
181 }
182
183 impl deft::base::EventListener<#event_name, #target_type> for #listener_name {
184 fn handle_event(&mut self, event: &mut #event_name, ctx: &mut deft::base::EventContext<#target_type>) {
185 (self.0)(event, ctx)
186 }
187 }
188
189 impl deft::js::FromJsValue for #listener_name {
190 fn from_js_value(value: deft::js::JsValue) -> Result<Self, deft::js::ValueError> {
191 let listener = Self::new(move |e, ctx| {
192 let target = ctx.target.clone();
193 use deft::js::ToJsValue;
194 if let Ok(d) = target.to_js_value() {
195 if let Ok(e) = e.clone().to_js_value() {
196 let callback_result = value.call_as_function(vec![e, d]);
197 if let Ok(cb_result) = callback_result {
198 if let Ok(res) = deft::js::js_value_util::EventResult::from_js_value(cb_result) {
199 if res.propagation_cancelled {
200 ctx.propagation_cancelled = true;
201 }
202 if res.prevent_default {
203 ctx.prevent_default = true;
204 }
205 }
206 }
207 } else {
208 println!("invalid event");
209 }
210 } else {
211 println!("invalid event");
212 }
213 });
214 Ok(listener)
215 }
216 }
217
218 #[derive(serde::Serialize, Clone)]
219 #[serde(rename_all = "camelCase")]
220 pub struct #event_name
221 #fields_ts
222
223 deft::js_serialize!(#event_name);
224
225 impl deft::element::ViewEvent for #event_name {
226 fn allow_bubbles(&self) -> bool {
227 true
228 }
229 }
230
231 };
232 expanded.into()
233}
234
235#[proc_macro_attribute]
236pub fn js_methods(_attr: TokenStream, impl_item: TokenStream) -> TokenStream {
237 let item = parse_macro_input!(impl_item as ItemImpl);
238 let ItemImpl {
240 attrs,
241 impl_token,
242 generics,
243 self_ty,
244 mut items,
245 ..
246 } = item;
247
248 let mut api_bridges = Vec::new();
249 let mut api_create_expr_list = Vec::new();
250 let type_name_str = self_ty.clone().into_token_stream().to_string();
251 let type_name_ident = format_ident!("{}", type_name_str);
252
253
254 for item in &mut items {
255 match item {
256 ImplItem::Fn(item) => {
257 item.attrs.retain(|it| {
258 if !it.path().is_ident("js_func") {
259 return true;
260 }
261
262 let vis = item.vis.clone();
263
264 let api_name_ident = format_ident!("{}_{}", type_name_str, item.sig.ident);
265
266 let args_count = item.sig.inputs.len();
267 let args = item.sig.inputs.iter().map(|it| it.clone()).collect::<Vec<_>>();
268
269 let bridge_body = build_bridge_body(
270 args,
271 item.sig.asyncness,
272 type_name_ident.clone(),
273 item.sig.ident.clone()
274 );
275
276 let bridge = build_bridge_struct(
277 vis,
278 api_name_ident.clone(),
279 args_count,
280 bridge_body,
281 );
282
283 api_bridges.push(bridge);
284 api_create_expr_list.push(quote! {
285 #api_name_ident::new()
286 });
287 false
288 });
289 }
290 _ => {}
291 }
292 }
293 let q = quote! {
294 #(#attrs)*
295 #impl_token #generics #self_ty {
296 #(#items)*
297
298 pub fn create_js_apis() -> Vec<Box<dyn deft::js::JsFunc + std::panic::RefUnwindSafe + 'static>> {
299 vec![#(Box::new(#api_create_expr_list), )*]
300 }
301
302 }
303
304 #(#api_bridges)*
305 };
306
307 q.into()
308}
309
310fn build_bridge_struct(vis: Visibility, func_name: Ident, args_count: usize, bridge_body: TokenStream2) -> TokenStream2 {
311 let func_name_str = func_name.to_string();
312 quote! {
313 #[doc(hidden)]
314 #[allow(nonstandard_style)]
315 #vis struct #func_name {}
316
317 impl #func_name {
318 pub fn new() -> Self {
319 Self {}
320 }
321 }
322
323 impl deft::js::JsFunc for #func_name {
324
325 fn name(&self) -> &str {
326 #func_name_str
327 }
328
329 fn args_count(&self) -> usize {
330 #args_count
331 }
332
333 fn call(&self, js_context: &mut deft::mrc::Mrc<deft::js::JsContext>, args: Vec<deft::js::JsValue>) -> Result<deft::js::JsValue, deft::js::JsCallError> {
334 #bridge_body
335 }
336 }
337 }
338}
339
340fn build_bridge_body(func_inputs: Vec<FnArg>, asyncness: Option<Async>, struct_name: Ident, func_name: Ident) -> TokenStream2 {
341 let mut receiver = None;
342 let mut params = Vec::new();
343 func_inputs.iter().for_each(|i| {
344 match i {
345 FnArg::Receiver(r) => receiver = Some(r.ty.clone()),
346 FnArg::Typed(ref val) => {
347 params.push(val.ty.clone())
348 }
349 }
350 });
351 let mut param_expand_stmts = Vec::new();
352 let mut param_list = Vec::new();
353 let mut idx = if receiver.is_some() { 1usize } else { 0usize };
354 for p in params {
355 let p_name = format_ident!("_p{}", idx);
356 param_expand_stmts.push(quote! {
357 let #p_name = <#p as deft::js::FromJsValue>::from_js_value(args.get(#idx).unwrap().clone())
358 .map_err(
359 |e| deft::js::ValueError::Internal(
360 format!("Failed to cast js argument {} (zero-based) to rust type, {}", #idx, e)
361 )
362 )?;
363 });
364 param_list.push(p_name);
365 idx += 1;
366 }
367
368 let call_stmt = if asyncness.is_none() {
371 if receiver.is_some() {
372 quote! {
373 let mut inst = <#struct_name as deft::js::FromJsValue>::from_js_value(args.get(0).unwrap().clone())?;
374 let r = inst.#func_name( #(#param_list, )* );
375 }
376 } else {
377 quote! {
378 let r = #struct_name::#func_name( #(#param_list, )* );
379 }
380 }
381 } else {
382 if receiver.is_some() {
383 quote! {
384 let mut inst = <#struct_name as deft::js::FromJsValue>::from_js_value(args.get(0).unwrap().clone())?;
385 let r = js_context.create_async_task2(async move {
386 inst.#func_name( #(#param_list, )* ).await
387 });
388 }
389 } else {
390 quote! {
391 let r = js_context.create_async_task2(async move {
392 #struct_name::#func_name( #(#param_list, )* ).await
393 });
394 }
395 }
396 };
397 let result = quote! {
398 use deft::js::FromJsValue;
399 use deft::js::ToJsValue;
400 use deft::js::ToJsCallResult;
401 #(#param_expand_stmts)*
402 #call_stmt
403 r.to_js_call_result()
404 };
405 result
406}
407
408#[proc_macro_attribute]
409pub fn js_func(_attr: TokenStream, func: TokenStream) -> TokenStream {
410 let func = parse_macro_input!(func as ItemFn);
411 let vis = func.vis;
412 let func_name = &func.sig.ident;
413 let asyncness = func.sig.asyncness;
414 let func_inputs = func.sig.inputs;
415 let func_block = func.block;
416
417 let args_count = func_inputs.len();
418 let args = func_inputs.iter().map(|it| it.clone()).collect::<Vec<_>>();
419 let bridge_body = build_bridge_body(
420 args,
421 asyncness,
422 format_ident!("Self"),
423 func_name.clone()
424 );
425
426 let return_type = func.sig.output;
427
428 let bridge = build_bridge_struct(vis, func_name.clone(), args_count, bridge_body);
429
430 let expanded = quote! {
431
432 #bridge
433
434 impl #func_name {
435
436 #asyncness fn #func_name(#func_inputs) #return_type #func_block
437
438 }
439
440 };
441 expanded.into()
442}