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 impl deft::base::JsEvent<#target_type> for #event_name {
232 fn create_listener_factory() -> deft::base::BoxJsEventListenerFactory<#target_type> {
233 use deft::base::EventListener;
234 use deft::js::js_binding::FromJsValue;
235 Box::new(move |listener| {
236 let mut listener = <#listener_name>::from_js_value(listener).ok()?;
237 Some((
238 std::any::TypeId::of::<#event_name>(),
239 Box::new(move |e, ctx| {
240 if let Some(e) = e.downcast_mut::<#event_name>() {
241 listener.handle_event(e, ctx);
242 }
243 }),
244 ))
245 })
246 }
247 }
248
249 impl #event_name {
250 pub fn cast(event: &deft::event::Event) -> Option<&Self> {
251 event.downcast_ref::<Self>()
252 }
253
254 pub fn is(event: &deft::event::Event) -> bool {
255 Self::cast(event).is_some()
256 }
257
258 }
259
260 };
261 expanded.into()
262}
263
264#[proc_macro_attribute]
265pub fn js_methods(_attr: TokenStream, impl_item: TokenStream) -> TokenStream {
266 let item = parse_macro_input!(impl_item as ItemImpl);
267 let ItemImpl {
269 attrs,
270 impl_token,
271 generics,
272 self_ty,
273 mut items,
274 ..
275 } = item;
276
277 let mut api_bridges = Vec::new();
278 let mut api_create_expr_list = Vec::new();
279 let type_name_str = self_ty.clone().into_token_stream().to_string();
280 let type_name_ident = format_ident!("{}", type_name_str);
281
282
283 for item in &mut items {
284 match item {
285 ImplItem::Fn(item) => {
286 item.attrs.retain(|it| {
287 if !it.path().is_ident("js_func") {
288 return true;
289 }
290
291 let vis = item.vis.clone();
292
293 let api_name_ident = format_ident!("{}_{}", type_name_str, item.sig.ident);
294
295 let args_count = item.sig.inputs.len();
296 let args = item.sig.inputs.iter().map(|it| it.clone()).collect::<Vec<_>>();
297
298 let bridge_body = build_bridge_body(
299 args,
300 item.sig.asyncness,
301 type_name_ident.clone(),
302 item.sig.ident.clone()
303 );
304
305 let bridge = build_bridge_struct(
306 vis,
307 api_name_ident.clone(),
308 args_count,
309 bridge_body,
310 );
311
312 api_bridges.push(bridge);
313 api_create_expr_list.push(quote! {
314 #api_name_ident::new()
315 });
316 false
317 });
318 }
319 _ => {}
320 }
321 }
322 let q = quote! {
323 #(#attrs)*
324 #impl_token #generics #self_ty {
325 #(#items)*
326
327 pub fn create_js_apis() -> Vec<Box<dyn deft::js::JsFunc + std::panic::RefUnwindSafe + 'static>> {
328 vec![#(Box::new(#api_create_expr_list), )*]
329 }
330
331 }
332
333 #(#api_bridges)*
334 };
335
336 q.into()
337}
338
339fn build_bridge_struct(vis: Visibility, func_name: Ident, args_count: usize, bridge_body: TokenStream2) -> TokenStream2 {
340 let func_name_str = func_name.to_string();
341 quote! {
342 #[doc(hidden)]
343 #[allow(nonstandard_style)]
344 #vis struct #func_name {}
345
346 impl #func_name {
347 pub fn new() -> Self {
348 Self {}
349 }
350 }
351
352 impl deft::js::JsFunc for #func_name {
353
354 fn name(&self) -> &str {
355 #func_name_str
356 }
357
358 fn args_count(&self) -> usize {
359 #args_count
360 }
361
362 fn call(&self, js_context: &mut deft::mrc::Mrc<deft::js::JsContext>, args: Vec<deft::js::JsValue>) -> Result<deft::js::JsValue, deft::js::JsCallError> {
363 #bridge_body
364 }
365 }
366 }
367}
368
369fn build_bridge_body(func_inputs: Vec<FnArg>, asyncness: Option<Async>, struct_name: Ident, func_name: Ident) -> TokenStream2 {
370 let mut receiver = None;
371 let mut params = Vec::new();
372 func_inputs.iter().for_each(|i| {
373 match i {
374 FnArg::Receiver(r) => receiver = Some(r.ty.clone()),
375 FnArg::Typed(ref val) => {
376 params.push(val.ty.clone())
377 }
378 }
379 });
380 let mut param_expand_stmts = Vec::new();
381 let mut param_list = Vec::new();
382 let mut idx = if receiver.is_some() { 1usize } else { 0usize };
383 for p in params {
384 let p_name = format_ident!("_p{}", idx);
385 param_expand_stmts.push(quote! {
386 let #p_name = <#p as deft::js::FromJsValue>::from_js_value(args.get(#idx).unwrap().clone())
387 .map_err(
388 |e| deft::js::ValueError::Internal(
389 format!("Failed to cast js argument {} (zero-based) to rust type, {}", #idx, e)
390 )
391 )?;
392 });
393 param_list.push(p_name);
394 idx += 1;
395 }
396
397 let call_stmt = if asyncness.is_none() {
400 if receiver.is_some() {
401 quote! {
402 let mut inst = <#struct_name as deft::js::FromJsValue>::from_js_value(args.get(0).unwrap().clone())?;
403 let r = inst.#func_name( #(#param_list, )* );
404 }
405 } else {
406 quote! {
407 let r = #struct_name::#func_name( #(#param_list, )* );
408 }
409 }
410 } else {
411 if receiver.is_some() {
412 quote! {
413 let mut inst = <#struct_name as deft::js::FromJsValue>::from_js_value(args.get(0).unwrap().clone())?;
414 let r = js_context.create_async_task2(async move {
415 inst.#func_name( #(#param_list, )* ).await
416 });
417 }
418 } else {
419 quote! {
420 let r = js_context.create_async_task2(async move {
421 #struct_name::#func_name( #(#param_list, )* ).await
422 });
423 }
424 }
425 };
426 let result = quote! {
427 use deft::js::FromJsValue;
428 use deft::js::ToJsValue;
429 use deft::js::ToJsCallResult;
430 #(#param_expand_stmts)*
431 #call_stmt
432 r.to_js_call_result()
433 };
434 result
435}
436
437#[proc_macro_attribute]
438pub fn js_func(_attr: TokenStream, func: TokenStream) -> TokenStream {
439 let func = parse_macro_input!(func as ItemFn);
440 let vis = func.vis;
441 let func_name = &func.sig.ident;
442 let asyncness = func.sig.asyncness;
443 let func_inputs = func.sig.inputs;
444 let func_block = func.block;
445
446 let args_count = func_inputs.len();
447 let args = func_inputs.iter().map(|it| it.clone()).collect::<Vec<_>>();
448 let bridge_body = build_bridge_body(
449 args,
450 asyncness,
451 format_ident!("Self"),
452 func_name.clone()
453 );
454
455 let return_type = func.sig.output;
456
457 let bridge = build_bridge_struct(vis, func_name.clone(), args_count, bridge_body);
458
459 let expanded = quote! {
460
461 #bridge
462
463 impl #func_name {
464
465 #asyncness fn #func_name(#func_inputs) #return_type #func_block
466
467 }
468
469 };
470 expanded.into()
471}