feat: some stuff

packages/node-registry/src/lib/registry.ts

@@ -35,10 +35,9 @@ export async function getNode(id: `${string}/${string}/${string}`) {
 
   const wrapper = await getNodeWasm(id);
 
-  const node_id = wrapper.get_id();
   const outputs = wrapper.get_outputs();
   const inputTypes = JSON.parse(wrapper.get_input_types());
 
-  return { id: node_id, outputs, inputs: inputTypes }
+  return { id, outputs, inputs: inputTypes }
 
 }

packages/plantarium/Cargo.toml

@@ -5,3 +5,5 @@ edition = "2021"
 
 [dependencies]
 wasm-bindgen = "0.2.92"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0", default-features = false, features = ["alloc"] }

packages/plantarium/src/helpers.rs

@@ -1,10 +1,13 @@
+use std::cell::RefCell;
+
+use serde_json::Value;
 use wasm_bindgen::prelude::*;
 
-pub fn unwrap_int(val: JsValue) -> u8 {
+pub fn unwrap_int(val: JsValue) -> i32 {
     if val.is_undefined() || val.is_null() {
         panic!("Value is undefined");
     }
-    return val.as_f64().unwrap() as u8;
+    return val.as_f64().unwrap() as i32;
 }
 
 pub fn unwrap_float(val: JsValue) -> f64 {
@@ -21,6 +24,55 @@ pub fn unwrap_string(val: JsValue) -> String {
     return val.as_string().unwrap();
 }
 
-pub fn evaluate_parameter(_val: String) -> i32 {
-    return 2;
+pub fn evaluate_parameters(val: JsValue) -> f64 {
+    let str = unwrap_string(val);
+    let v: Value = serde_json::from_str(&str).unwrap();
+    let index = RefCell::new(0.0);
+    return walk_json(&v, &index);
+}
+
+fn walk_json(value: &Value, depth: &RefCell<f64>) -> f64 {
+    *depth.borrow_mut() += 1.0;
+    match value {
+        // If it's an object, recursively walk through its fields
+        Value::Object(obj) => {
+            let obj_type = obj.get("__type").unwrap();
+            if obj_type == "random" {
+                let min = walk_json(obj.get("min").unwrap(), depth);
+                let max = walk_json(obj.get("max").unwrap(), depth);
+                let seed = (obj.get("seed").unwrap().as_f64().unwrap() + *depth.borrow() * 2000.0)
+                    / 1000000.0;
+                let range = max - min;
+                let seed = seed % range;
+                return seed - min;
+            } else if obj_type == "math" {
+                let a = walk_json(obj.get("a").unwrap(), depth);
+                let b = walk_json(obj.get("b").unwrap(), depth);
+                let op_type = obj.get("op_type").unwrap();
+                if op_type == 0 {
+                    return a + b;
+                } else if op_type == 1 {
+                    return a - b;
+                } else if op_type == 2 {
+                    return a * b;
+                } else if op_type == 3 {
+                    return a / b;
+                }
+            }
+            return 0.0;
+        }
+        Value::Array(arr) => {
+            for val in arr {
+                walk_json(val, depth);
+            }
+            return 0.0;
+        }
+        Value::Number(num) => {
+            return num.as_f64().unwrap();
+        }
+        // If it's a primitive value, print it
+        _ => {
+            return 0.0;
+        }
+    }
 }

packages/types/inputs.ts

@@ -24,13 +24,17 @@ type NodeInputSelect = {
   value?: number;
 }
 
+type NodeInputSeed = {
+  type: "seed"
+}
+
 type DefaultOptions = {
   internal?: boolean;
   external?: boolean;
-  title?: string;
+  label?: string;
 }
 
-export type NodeInput = (NodeInputBoolean | NodeInputFloat | NodeInputInteger | NodeInputSelect) & DefaultOptions;
+export type NodeInput = (NodeInputSeed | NodeInputBoolean | NodeInputFloat | NodeInputInteger | NodeInputSelect) & DefaultOptions;
 
 
 export type NodeInputType<T extends Record<string, NodeInput>> = {