pax_runtime_api/pax_value/
functions.rs

1use crate::{
2    math::{Transform2, Vector2},
3    Color, ColorChannel, Fill, PaxValue, Rotation,
4};
5use once_cell::sync::Lazy;
6use std::{
7    collections::HashMap,
8    sync::{Arc, RwLock},
9};
10
11use super::{CoercionRules, ToPaxValue};
12
13type FunctionType = Arc<dyn Fn(Vec<PaxValue>) -> Result<PaxValue, String> + Send + Sync>;
14
15static FUNCTIONS: Lazy<Arc<RwLock<HashMap<String, HashMap<String, FunctionType>>>>> =
16    Lazy::new(|| Arc::new(RwLock::new(HashMap::new())));
17
18// Dumps registered PAXEL helper functions for diagnostics.
19pub fn print_all_functions() {
20    let functions = FUNCTIONS.read().unwrap();
21    log::warn!("Total scopes: {}", functions.len());
22    for (scope, funcs) in functions.iter() {
23        log::warn!("Scope: {}", scope);
24        for (name, _) in funcs.iter() {
25            log::warn!("  |{}|", name);
26        }
27    }
28}
29
30// Registers one PAXEL helper function under a scope/name pair.
31pub fn register_function(scope: String, name: String, func: FunctionType) {
32    let mut functions = FUNCTIONS.write().unwrap();
33    functions
34        .entry(scope)
35        .or_insert_with(HashMap::new)
36        .insert(name, func);
37}
38
39// Dispatches a registered PAXEL helper function.
40pub fn call_function(scope: String, name: String, args: Vec<PaxValue>) -> Result<PaxValue, String> {
41    let functions = FUNCTIONS.read().unwrap();
42    let scope_funcs = functions
43        .get(&scope)
44        .ok_or_else(|| format!("Scope {} not found", scope))?;
45    let func = scope_funcs
46        .get(&name)
47        .ok_or_else(|| format!("Function {} not found in scope {}", name, scope))?;
48    func(args)
49}
50
51/// Helper function for adding two PaxValues
52fn add(args: Vec<PaxValue>) -> Result<PaxValue, String> {
53    if args.len() != 2 {
54        return Err("Expected 2 arguments for function add".to_string());
55    }
56    let mut itr = args.into_iter();
57    Ok(itr.next().unwrap() + itr.next().unwrap())
58}
59
60/// Helper function for subtracting two PaxValues
61fn sub_or_neg(args: Vec<PaxValue>) -> Result<PaxValue, String> {
62    if args.len() == 1 {
63        Ok(-args.into_iter().next().unwrap())
64    } else if args.len() == 2 {
65        let mut itr = args.into_iter();
66        Ok(itr.next().unwrap() - itr.next().unwrap())
67    } else {
68        Err("Expected 1 or 2 arguments for function sub_or_neg".to_string())
69    }
70}
71
72/// Helper function for multiplying two PaxValues
73fn mul(args: Vec<PaxValue>) -> Result<PaxValue, String> {
74    if args.len() != 2 {
75        return Err("Expected 2 arguments for function mul".to_string());
76    }
77    let mut itr = args.into_iter();
78    Ok(itr.next().unwrap() * itr.next().unwrap())
79}
80
81/// Helper function for dividing two PaxValues
82fn div(args: Vec<PaxValue>) -> Result<PaxValue, String> {
83    if args.len() != 2 {
84        return Err("Expected 2 arguments for function div".to_string());
85    }
86    let mut itr = args.into_iter();
87    Ok(itr.next().unwrap() / itr.next().unwrap())
88}
89
90/// Helper function for exponentiating one PaxValue by another
91fn exp(args: Vec<PaxValue>) -> Result<PaxValue, String> {
92    if args.len() != 2 {
93        return Err("Expected 2 arguments for function exp".to_string());
94    }
95    let mut itr = args.into_iter();
96    Ok(itr.next().unwrap().pow(itr.next().unwrap()))
97}
98
99/// Helper function for taking the modulus of one PaxValue by another
100fn mod_(args: Vec<PaxValue>) -> Result<PaxValue, String> {
101    if args.len() != 2 {
102        return Err("Expected 2 arguments for function mod_".to_string());
103    }
104    let mut itr = args.into_iter();
105    Ok(itr.next().unwrap() % itr.next().unwrap())
106}
107
108/// Helper function for checking if two PaxValues are equal
109fn rel_eq(args: Vec<PaxValue>) -> Result<PaxValue, String> {
110    if args.len() != 2 {
111        return Err("Expected 2 arguments for function rel_eq".to_string());
112    }
113    Ok(PaxValue::Bool(args[0] == args[1]))
114}
115
116/// Helper function for checking if one PaxValue is greater than another
117fn rel_gt(args: Vec<PaxValue>) -> Result<PaxValue, String> {
118    if args.len() != 2 {
119        return Err("Expected 2 arguments for function rel_gt".to_string());
120    }
121    Ok(PaxValue::Bool(args[0] > args[1]))
122}
123
124/// Helper function for checking if one PaxValue is greater than or equal to another
125fn rel_gte(args: Vec<PaxValue>) -> Result<PaxValue, String> {
126    if args.len() != 2 {
127        return Err("Expected 2 arguments for function rel_gte".to_string());
128    }
129    Ok(PaxValue::Bool(args[0] >= args[1]))
130}
131
132/// Helper function for checking if one PaxValue is less than another
133fn rel_lt(args: Vec<PaxValue>) -> Result<PaxValue, String> {
134    if args.len() != 2 {
135        return Err("Expected 2 arguments for function rel_lt".to_string());
136    }
137    Ok(PaxValue::Bool(args[0] < args[1]))
138}
139
140/// Helper function for checking if one PaxValue is less than or equal to another
141fn rel_lte(args: Vec<PaxValue>) -> Result<PaxValue, String> {
142    if args.len() != 2 {
143        return Err("Expected 2 arguments for function rel_lte".to_string());
144    }
145    Ok(PaxValue::Bool(args[0] <= args[1]))
146}
147
148/// Helper function for checking if two PaxValues are not equal
149fn rel_neq(args: Vec<PaxValue>) -> Result<PaxValue, String> {
150    if args.len() != 2 {
151        return Err("Expected 2 arguments for function rel_neq".to_string());
152    }
153    Ok(PaxValue::Bool(args[0] != args[1]))
154}
155
156/// Helper function for performing a boolean AND operation on two PaxValues
157fn bool_and(args: Vec<PaxValue>) -> Result<PaxValue, String> {
158    if args.len() != 2 {
159        return Err("Expected 2 arguments for function bool_and".to_string());
160    }
161    let mut itr = args.into_iter();
162    Ok(itr.next().unwrap().op_and(itr.next().unwrap()))
163}
164
165/// Helper function for performing a boolean OR operation on two PaxValues
166fn bool_or(args: Vec<PaxValue>) -> Result<PaxValue, String> {
167    if args.len() != 2 {
168        return Err("Expected 2 arguments for function bool_or".to_string());
169    }
170    let mut itr = args.into_iter();
171    Ok(itr.next().unwrap().op_or(itr.next().unwrap()))
172}
173
174/// Helper function for performing a boolean NOT operation on a PaxValue
175fn bool_not(args: Vec<PaxValue>) -> Result<PaxValue, String> {
176    if args.len() != 1 {
177        return Err("Expected 1 argument for function bool_not".to_string());
178    }
179    Ok(args.into_iter().next().unwrap().op_not())
180}
181
182/// Helper function for taking the minimum of two PaxValues
183fn min(args: Vec<PaxValue>) -> Result<PaxValue, String> {
184    if args.len() != 2 {
185        return Err("Expected 2 arguments for function min".to_string());
186    }
187    let mut itr = args.into_iter();
188    Ok(itr.next().unwrap().min(itr.next().unwrap()))
189}
190
191/// Helper function for taking the maximum of two PaxValues
192fn max(args: Vec<PaxValue>) -> Result<PaxValue, String> {
193    if args.len() != 2 {
194        return Err("Expected 2 arguments for function max".to_string());
195    }
196    let mut itr = args.into_iter();
197    Ok(itr.next().unwrap().max(itr.next().unwrap()))
198}
199
200/// Helper function for getting the length of a PaxValue vector
201fn len(args: Vec<PaxValue>) -> Result<PaxValue, String> {
202    if args.len() != 1 {
203        return Err("len function takes a single argument".to_string());
204    }
205    match args.into_iter().next().unwrap() {
206        PaxValue::Vec(vec) => Ok(vec.len().to_pax_value()),
207        e => Err(format!("can't get length of {e:?}")),
208    }
209}
210
211/// Helper function for creating an RGB color from three PaxValues representing the red, green, and blue channels
212fn rgb(args: Vec<PaxValue>) -> Result<PaxValue, String> {
213    if args.len() != 3 {
214        return Err("Expected 3 arguments for function rgb".to_string());
215    }
216    let mut itr = args.into_iter();
217    let r = ColorChannel::try_coerce(itr.next().unwrap())?;
218    let g = ColorChannel::try_coerce(itr.next().unwrap())?;
219    let b = ColorChannel::try_coerce(itr.next().unwrap())?;
220    Ok(Color::rgb(r, g, b).to_pax_value())
221}
222
223/// Helper function for creating an RGBA color from four PaxValues representing the red, green, blue, and alpha channels
224fn rgba(args: Vec<PaxValue>) -> Result<PaxValue, String> {
225    if args.len() != 4 {
226        return Err("Expected 4 arguments for function rgba".to_string());
227    }
228    let mut itr = args.into_iter();
229    let r = ColorChannel::try_coerce(itr.next().unwrap())?;
230    let g = ColorChannel::try_coerce(itr.next().unwrap())?;
231    let b = ColorChannel::try_coerce(itr.next().unwrap())?;
232    let a = ColorChannel::try_coerce(itr.next().unwrap())?;
233    Ok(Color::rgba(r, g, b, a).to_pax_value())
234}
235
236/// Helper function for creating an HSL color from three PaxValues representing the hue, saturation, and lightness channels
237fn hsl(args: Vec<PaxValue>) -> Result<PaxValue, String> {
238    if args.len() != 3 {
239        return Err("Expected 3 arguments for function hsl".to_string());
240    }
241    let mut itr = args.into_iter();
242    let h = Rotation::try_coerce(itr.next().unwrap())?;
243    let s = ColorChannel::try_coerce(itr.next().unwrap())?;
244    let l = ColorChannel::try_coerce(itr.next().unwrap())?;
245    Ok(Color::hsl(h, s, l).to_pax_value())
246}
247
248/// Helper function for creating an HSLA color from four PaxValues representing the hue, saturation, lightness, and alpha channels
249fn hsla(args: Vec<PaxValue>) -> Result<PaxValue, String> {
250    if args.len() != 4 {
251        return Err("Expected 4 arguments for function hsla".to_string());
252    }
253    let mut itr = args.into_iter();
254    let h = Rotation::try_coerce(itr.next().unwrap())?;
255    let s = ColorChannel::try_coerce(itr.next().unwrap())?;
256    let l = ColorChannel::try_coerce(itr.next().unwrap())?;
257    let a = ColorChannel::try_coerce(itr.next().unwrap())?;
258    Ok(Color::hsla(h, s, l, a).to_pax_value())
259}
260
261/// Helper function for creating a color from a hexadecimal string representation
262fn hex(args: Vec<PaxValue>) -> Result<PaxValue, String> {
263    if args.len() != 1 {
264        return Err("Expected 1 argument for function hex".to_string());
265    }
266    let hex = String::try_coerce(args.into_iter().next().unwrap())?;
267    Ok(Color::from_hex(&hex).to_pax_value())
268}
269
270/// Registers helper functions made available to PAXEL scopes.
271pub trait HelperFunctions {
272    /// Registers all helper functions for this type.
273    fn register_all_functions() {}
274}
275
276/// Registry bootstrap for built-in PAXEL helper functions.
277pub struct Functions;
278
279impl Functions {
280    /// Registers built-in math, color, and transform helper functions.
281    pub fn register_all_functions() {
282        // Math
283        register_function("Math".to_string(), "+".to_string(), Arc::new(add));
284        register_function("Math".to_string(), "-".to_string(), Arc::new(sub_or_neg));
285        register_function("Math".to_string(), "*".to_string(), Arc::new(mul));
286        register_function("Math".to_string(), "/".to_string(), Arc::new(div));
287        register_function("Math".to_string(), "^".to_string(), Arc::new(exp));
288        register_function("Math".to_string(), "%%".to_string(), Arc::new(mod_));
289        register_function("Math".to_string(), "==".to_string(), Arc::new(rel_eq));
290        register_function("Math".to_string(), ">".to_string(), Arc::new(rel_gt));
291        register_function("Math".to_string(), ">=".to_string(), Arc::new(rel_gte));
292        register_function("Math".to_string(), "<".to_string(), Arc::new(rel_lt));
293        register_function("Math".to_string(), "<=".to_string(), Arc::new(rel_lte));
294        register_function("Math".to_string(), "!=".to_string(), Arc::new(rel_neq));
295        register_function("Math".to_string(), "&&".to_string(), Arc::new(bool_and));
296        register_function("Math".to_string(), "||".to_string(), Arc::new(bool_or));
297        register_function("Math".to_string(), "!".to_string(), Arc::new(bool_not));
298        register_function("Math".to_string(), "min".to_string(), Arc::new(min));
299        register_function("Math".to_string(), "max".to_string(), Arc::new(max));
300        register_function("Math".to_string(), "len".to_string(), Arc::new(len));
301        // Colors
302        register_function("Color".to_string(), "rgb".to_string(), Arc::new(rgb));
303        register_function("Color".to_string(), "rgba".to_string(), Arc::new(rgba));
304        register_function("Color".to_string(), "hsl".to_string(), Arc::new(hsl));
305        register_function("Color".to_string(), "hsla".to_string(), Arc::new(hsla));
306        register_function("Color".to_string(), "#".to_string(), Arc::new(hex));
307        // Transform2D
308        crate::Transform2D::register_all_functions();
309    }
310
311    /// Returns true if a helper function exists in the named scope.
312    pub fn has_function(scope: &str, name: &str) -> bool {
313        let functions = FUNCTIONS.read().unwrap();
314        if let Some(scope_funcs) = functions.get(scope) {
315            scope_funcs.contains_key(name)
316        } else {
317            false
318        }
319    }
320}
321
322impl HelperFunctions for crate::Size {}
323
324impl HelperFunctions for crate::Color {}
325
326impl HelperFunctions for crate::Rotation {}
327
328impl HelperFunctions for crate::Duration {}
329
330impl HelperFunctions for String {}
331
332impl HelperFunctions for crate::Numeric {}
333
334impl HelperFunctions for crate::UnitValue {}
335
336impl HelperFunctions for bool {}
337
338impl HelperFunctions for Fill {}
339
340impl HelperFunctions for crate::PaxValue {}
341
342impl HelperFunctions for crate::ColorChannel {}
343
344impl HelperFunctions for crate::Opacity {}
345
346impl HelperFunctions for crate::Stroke {}
347
348impl HelperFunctions for crate::PathSmoothing {}
349
350impl HelperFunctions for crate::StrokeCap {}
351
352impl HelperFunctions for crate::StrokeJoin {}
353
354impl HelperFunctions for u8 {}
355impl HelperFunctions for u16 {}
356impl HelperFunctions for u32 {}
357impl HelperFunctions for u64 {}
358impl HelperFunctions for u128 {}
359impl HelperFunctions for usize {}
360
361impl HelperFunctions for i8 {}
362impl HelperFunctions for i16 {}
363impl HelperFunctions for i32 {}
364impl HelperFunctions for i64 {}
365impl HelperFunctions for i128 {}
366impl HelperFunctions for isize {}
367
368impl HelperFunctions for f32 {}
369impl HelperFunctions for f64 {}
370impl<T> HelperFunctions for Vec<T> {}
371
372impl<T: HelperFunctions> HelperFunctions for Option<T> {}
373
374impl HelperFunctions for crate::Transform2D {
375    fn register_all_functions() {
376        register_function(
377            "Transform2D".to_string(),
378            "scale".to_string(),
379            Arc::new(|args| {
380                if args.len() != 2 {
381                    return Err("Expected 2 arguments for function scale".to_string());
382                }
383                let mut itr = args.into_iter();
384                let x = crate::Size::try_coerce(itr.next().unwrap())?;
385                let y = crate::Size::try_coerce(itr.next().unwrap())?;
386                Ok(crate::Transform2D::scale(x, y).to_pax_value())
387            }),
388        );
389        register_function(
390            "Transform2D".to_string(),
391            "rotate".to_string(),
392            Arc::new(|args| {
393                if args.len() != 1 {
394                    return Err("Expected 1 argument for function rotate".to_string());
395                }
396                let z = crate::Rotation::try_coerce(args.into_iter().next().unwrap())?;
397                Ok(crate::Transform2D::rotate(z).to_pax_value())
398            }),
399        );
400        register_function(
401            "Transform2D".to_string(),
402            "translate".to_string(),
403            Arc::new(|args| {
404                if args.len() != 2 {
405                    return Err("Expected 2 arguments for function translate".to_string());
406                }
407                let mut itr = args.into_iter();
408                let x = crate::Size::try_coerce(itr.next().unwrap())?;
409                let y = crate::Size::try_coerce(itr.next().unwrap())?;
410                Ok(crate::Transform2D::translate(x, y).to_pax_value())
411            }),
412        );
413        register_function(
414            "Transform2D".to_string(),
415            "anchor".to_string(),
416            Arc::new(|args| {
417                if args.len() != 2 {
418                    return Err("Expected 2 arguments for function anchor".to_string());
419                }
420                let mut itr = args.into_iter();
421                let x = crate::Size::try_coerce(itr.next().unwrap())?;
422                let y = crate::Size::try_coerce(itr.next().unwrap())?;
423                Ok(crate::Transform2D::anchor(x, y).to_pax_value())
424            }),
425        );
426    }
427}
428
429impl HelperFunctions for Transform2 {
430    fn register_all_functions() {
431        register_function(
432            "Transform2".to_string(),
433            "identity".to_string(),
434            Arc::new(|args| {
435                if args.len() != 0 {
436                    return Err("Expected 0 arguments for function identity".to_string());
437                }
438                Ok(Transform2::identity().to_pax_value())
439            }),
440        );
441        register_function(
442            "Transform2".to_string(),
443            "scale".to_string(),
444            Arc::new(|args| {
445                if args.len() != 1 {
446                    return Err("Expected 1 argument for function scale".to_string());
447                }
448                let s = f64::try_coerce(args.into_iter().next().unwrap())?;
449                Ok(Transform2::scale(s).to_pax_value())
450            }),
451        );
452
453        register_function(
454            "Transform2".to_string(),
455            "translate".to_string(),
456            Arc::new(|args| {
457                if args.len() != 1 {
458                    return Err("Expected 1 argument for function scale".to_string());
459                }
460                let s = Vector2::try_coerce(args.into_iter().next().unwrap())?;
461                Ok(Transform2::translate(s).to_pax_value())
462            }),
463        );
464
465        register_function(
466            "Transform2".to_string(),
467            "rotate".to_string(),
468            Arc::new(|args| {
469                if args.len() != 1 {
470                    return Err("Expected 1 argument for function rotate".to_string());
471                }
472                let s = f64::try_coerce(args.into_iter().next().unwrap())?;
473                Ok(Transform2::rotate(s).to_pax_value())
474            }),
475        );
476        register_function(
477            "Transform2".to_string(),
478            "skew".to_string(),
479            Arc::new(|args| {
480                if args.len() != 1 {
481                    return Err("Expected 1 argument for function skew".to_string());
482                }
483                let s = Vector2::try_coerce(args.into_iter().next().unwrap())?;
484                Ok(Transform2::skew(s).to_pax_value())
485            }),
486        );
487    }
488}
pax_runtime_api/pax_value/functions.rs

pax_runtime_api/pax_value/
functions.rs
