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: lento::mrc::Mrc<#struct_name>,
21 }
22
23 impl std::ops::Deref for #ref_name {
24 type Target = lento::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: lento::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<lento::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, lento::mrc::UpgradeError> {
81 let inner = if let Some(inner) = &self.inner {
82 inner.upgrade()?
83 } else {
84 return Err(lento::mrc::UpgradeError{});
85 };
86 Ok(
87 #ref_name {
88 inner
89 }
90 )
91 }
92
93 pub fn upgrade_mut(&self) -> Result<#mut_name, lento::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 = lento::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 #[lento_macros::mrc_object]
129 #visibility struct #struct_name #struct_fields
130
131 impl lento::js::FromJsValue for #struct_name {
132 fn from_js_value(value: lento::js::JsValue) -> Result<Self, lento::js::ValueError> {
133 let element = lento::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! {lento::element::ElementWeak})
144}
145
146#[proc_macro_attribute]
147pub fn frame_event(_attr: TokenStream, struct_def: TokenStream) -> TokenStream {
148 create_event(_attr, struct_def, quote! {lento::frame::FrameWeak})
149}
150
151#[proc_macro_attribute]
152pub fn worker_event(_attr: TokenStream, struct_def: TokenStream) -> TokenStream {
153 create_event(_attr, struct_def, quote! {lento::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! {lento::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 lento::base::EventContext<#target_type>)>);
176
177 impl #listener_name {
178 pub fn new<F: FnMut(&mut #event_name, &mut lento::base::EventContext<#target_type>) + 'static>(f: F) -> Self {
179 Self(Box::new(f))
180 }
181 }
182
183 impl lento::base::EventListener<#event_name, #target_type> for #listener_name {
184 fn handle_event(&mut self, event: &mut #event_name, ctx: &mut lento::base::EventContext<#target_type>) {
185 (self.0)(event, ctx)
186 }
187 }
188
189 impl lento::js::FromJsValue for #listener_name {
190 fn from_js_value(value: lento::js::JsValue) -> Result<Self, lento::js::ValueError> {
191 let listener = Self::new(move |e, ctx| {
192 let target = ctx.target.clone();
193 use lento::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) = lento::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 lento::js_serialize!(#event_name);
224
225 impl lento::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 lento::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 lento::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 lento::mrc::Mrc<lento::js::JsContext>, args: Vec<lento::js::JsValue>) -> Result<lento::js::JsValue, lento::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 lento::js::FromJsValue>::from_js_value(args.get(#idx).unwrap().clone())?;
358 });
359 param_list.push(p_name);
360 idx += 1;
361 }
362
363 let call_stmt = if asyncness.is_none() {
366 if receiver.is_some() {
367 quote! {
368 let mut inst = <#struct_name as lento::js::FromJsValue>::from_js_value(args.get(0).unwrap().clone())?;
369 let r = inst.#func_name( #(#param_list, )* );
370 }
371 } else {
372 quote! {
373 let r = #struct_name::#func_name( #(#param_list, )* );
374 }
375 }
376 } else {
377 if receiver.is_some() {
378 quote! {
379 let mut inst = <#struct_name as lento::js::FromJsValue>::from_js_value(args.get(0).unwrap().clone())?;
380 let r = js_context.create_async_task2(async move {
381 inst.#func_name( #(#param_list, )* ).await
382 });
383 }
384 } else {
385 quote! {
386 let r = js_context.create_async_task2(async move {
387 #struct_name::#func_name( #(#param_list, )* ).await
388 });
389 }
390 }
391 };
392 let result = quote! {
393 use lento::js::FromJsValue;
394 use lento::js::ToJsValue;
395 use lento::js::ToJsCallResult;
396 #(#param_expand_stmts)*
397 #call_stmt
398 r.to_js_call_result()
399 };
400 result
401}
402
403#[proc_macro_attribute]
404pub fn js_func(_attr: TokenStream, func: TokenStream) -> TokenStream {
405 let func = parse_macro_input!(func as ItemFn);
406 let vis = func.vis;
407 let func_name = &func.sig.ident;
408 let asyncness = func.sig.asyncness;
409 let func_inputs = func.sig.inputs;
410 let func_block = func.block;
411
412 let args_count = func_inputs.len();
413 let args = func_inputs.iter().map(|it| it.clone()).collect::<Vec<_>>();
414 let bridge_body = build_bridge_body(
415 args,
416 asyncness,
417 format_ident!("Self"),
418 func_name.clone()
419 );
420
421 let return_type = func.sig.output;
422
423 let bridge = build_bridge_struct(vis, func_name.clone(), args_count, bridge_body);
424
425 let expanded = quote! {
426
427 #bridge
428
429 impl #func_name {
430
431 #asyncness fn #func_name(#func_inputs) #return_type #func_block
432
433 }
434
435 };
436 expanded.into()
437}