@devaloop/devalang 0.0.1-alpha.8 → 0.0.1-beta.1

package/rust/core/preprocessor/resolver/value.rs

@@ -0,0 +1,176 @@
+use std::collections::HashMap;
+use toml::Value as TomlValue;
+
+use crate::core::{
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
+};
+
+use devalang_types::Value;
+
+fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
+    for module in global_store.modules.values() {
+        if let Some(val) = module.export_table.get_export(name) {
+            return Some(val.clone());
+        }
+    }
+
+    None
+}
+
+pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
+    match value {
+        Value::String(s) => {
+            // Keep raw strings as-is; they may be runtime-evaluated (e.g., expressions)
+            Value::String(s.clone())
+        }
+
+        Value::Identifier(name) => {
+            if let Some(original_val) = module.variable_table.get(name) {
+                return resolve_value(original_val, module, global_store);
+            }
+
+            if let Some(export_val) = find_export_value(name, global_store) {
+                return resolve_value(&export_val, module, global_store);
+            }
+
+            // Leave unresolved identifiers as-is; may be runtime-bound (e.g., foreach variable)
+            Value::Identifier(name.clone())
+        }
+
+        Value::Map(map) => {
+            if let Some(Value::Identifier(entity)) = map.get("entity") {
+                // SECTION Synth
+                if entity == "synth" {
+                    if let Some(Value::Map(synth_data)) = map.get("value") {
+                        let resolved_waveform = synth_data
+                            .get("waveform")
+                            .map(|wf| resolve_value(wf, module, global_store))
+                            .unwrap_or(Value::Null);
+
+                        let resolved_params = synth_data
+                            .get("parameters")
+                            .map(|p| resolve_value(p, module, global_store))
+                            .unwrap_or(Value::Map(HashMap::new()));
+
+                        // If waveform refers to a plugin synth (e.g., alias.synth),
+                        // merge plugin-exported defaults (dynamic) into parameters and
+                        // allow 'waveform' override from parameters map.
+                        let mut final_waveform = resolved_waveform.clone();
+                        let mut params_map = match resolved_params.clone() {
+                            Value::Map(m) => m,
+                            _ => HashMap::new(),
+                        };
+
+                        // Helper: convert TomlValue into runtime Value
+                        fn toml_to_value(tv: &TomlValue) -> Value {
+                            match tv {
+                                TomlValue::String(s) => Value::String(s.clone()),
+                                TomlValue::Integer(i) => Value::Number(*i as f32),
+                                TomlValue::Float(f) => Value::Number(*f as f32),
+                                TomlValue::Boolean(b) => Value::Boolean(*b),
+                                TomlValue::Array(arr) => {
+                                    Value::Array(arr.iter().map(toml_to_value).collect())
+                                }
+                                TomlValue::Table(t) => {
+                                    let mut m = HashMap::new();
+                                    for (k, v) in t.iter() {
+                                        m.insert(k.clone(), toml_to_value(v));
+                                    }
+                                    Value::Map(m)
+                                }
+                                _ => Value::Null,
+                            }
+                        }
+
+                        // Detect plugin alias from waveform string like "alias.synth" OR just "alias"
+                        let (alias_opt, explicit_synth_export) = match &final_waveform {
+                            Value::String(s) | Value::Identifier(s) => {
+                                let parts: Vec<&str> = s.split('.').collect();
+                                if parts.len() >= 2 && parts[1] == "synth" {
+                                    (Some(parts[0].to_string()), true)
+                                } else if parts.len() == 1 {
+                                    (Some(parts[0].to_string()), false)
+                                } else {
+                                    (None, false)
+                                }
+                            }
+                            _ => (None, false),
+                        };
+
+                        if let Some(alias) = alias_opt {
+                            // Resolve alias -> plugin uri -> plugin info
+                            if let Some(Value::String(uri)) = module.variable_table.get(&alias) {
+                                if let Some(id) = uri.strip_prefix("devalang://plugin/") {
+                                    let mut parts = id.split('.');
+                                    let author = parts.next().unwrap_or("");
+                                    let pname = parts.next().unwrap_or("");
+                                    let key = format!("{}:{}", author, pname);
+                                    if let Some((plugin_info, _wasm)) =
+                                        global_store.plugins.get(&key)
+                                    {
+                                        // Merge defaults dynamically from exports
+                                        for exp in &plugin_info.exports {
+                                            // Skip entry named 'synth' which is used as the flag
+                                            if exp.name == "synth" {
+                                                continue;
+                                            }
+                                            if let Some(def) = &exp.default {
+                                                let val = toml_to_value(def);
+                                                // only apply if not overridden by user params
+                                                params_map.entry(exp.name.clone()).or_insert(val);
+                                            }
+                                        }
+
+                                        // If 'waveform' is provided in params (by user or default), use it
+                                        if let Some(wf_val) = params_map.remove("waveform") {
+                                            final_waveform =
+                                                resolve_value(&wf_val, module, global_store);
+                                        } else if let Some(wf_default) = plugin_info
+                                            .exports
+                                            .iter()
+                                            .find(|e| e.name == "waveform")
+                                            .and_then(|e| e.default.as_ref())
+                                        {
+                                            final_waveform = toml_to_value(wf_default);
+                                        } else if explicit_synth_export {
+                                            // keep as alias.synth if no default waveform
+                                        } else {
+                                            // If no explicit .synth in waveform, but alias is a plugin,
+                                            // treat it as alias.synth by default to enable plugin synth usage
+                                            final_waveform =
+                                                Value::String(format!("{}.synth", alias));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        let mut result = HashMap::new();
+                        result.insert("waveform".to_string(), final_waveform);
+                        result.insert("parameters".to_string(), Value::Map(params_map));
+
+                        return Value::Map(result);
+                    }
+                }
+            }
+
+            let mut resolved = HashMap::new();
+            for (k, v) in map {
+                resolved.insert(k.clone(), resolve_value(v, module, global_store));
+            }
+
+            Value::Map(resolved)
+        }
+
+        Value::Block(stmts) => {
+            let resolved_stmts = stmts
+                .iter()
+                .map(|stmt| resolve_statement(stmt, module, &module.path, global_store))
+                .collect();
+            Value::Block(resolved_stmts)
+        }
+
+        other => other.clone(),
+    }
+}

package/rust/core/store/export.rs

@@ -1,28 +1,28 @@
-use std::collections::HashMap;
-
-use crate::core::shared::value::Value;
-
-#[derive(Debug, Default, Clone, PartialEq)]
-pub struct ExportTable {
-    pub exports: HashMap<String, Value>,
-}
-
-impl ExportTable {
-    pub fn new() -> Self {
-        ExportTable {
-            exports: HashMap::new(),
-        }
-    }
-
-    pub fn add_export(&mut self, name: String, value: Value) {
-        self.exports.insert(name, value);
-    }
-
-    pub fn get_export(&self, name: &str) -> Option<&Value> {
-        self.exports.get(name)
-    }
-
-    pub fn remove_export(&mut self, name: &str) -> Option<Value> {
-        self.exports.remove(name)
-    }
-}
+use std::collections::HashMap;
+
+use devalang_types::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ExportTable {
+    pub exports: HashMap<String, Value>,
+}
+
+impl ExportTable {
+    pub fn new() -> Self {
+        ExportTable {
+            exports: HashMap::new(),
+        }
+    }
+
+    pub fn add_export(&mut self, name: String, value: Value) {
+        self.exports.insert(name, value);
+    }
+
+    pub fn get_export(&self, name: &str) -> Option<&Value> {
+        self.exports.get(name)
+    }
+
+    pub fn remove_export(&mut self, name: &str) -> Option<Value> {
+        self.exports.remove(name)
+    }
+}

package/rust/core/store/function.rs

@@ -0,0 +1,40 @@
+use crate::core::parser::statement::Statement;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone)]
+pub struct FunctionDef {
+    pub name: String,
+    pub parameters: Vec<String>,
+    pub body: Vec<Statement>,
+}
+
+#[derive(Debug, Clone)]
+pub struct FunctionTable {
+    pub functions: HashMap<String, FunctionDef>,
+}
+
+impl Default for FunctionTable {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl FunctionTable {
+    pub fn new() -> Self {
+        FunctionTable {
+            functions: HashMap::new(),
+        }
+    }
+
+    pub fn add_function(&mut self, function: FunctionDef) {
+        self.functions.insert(function.name.clone(), function);
+    }
+
+    pub fn get_function(&self, name: &str) -> Option<&FunctionDef> {
+        self.functions.get(name)
+    }
+
+    pub fn remove_function(&mut self, name: &str) -> Option<FunctionDef> {
+        self.functions.remove(name)
+    }
+}

package/rust/core/store/global.rs

@@ -1,39 +1,61 @@
-use std::collections::HashMap;
-use crate::core::preprocessor::module::Module;
-
-#[derive(Debug, Default, Clone)]
-pub struct GlobalStore {
-    pub modules: HashMap<String, Module>,
-}
-
-impl GlobalStore {
-    pub fn new() -> Self {
-        GlobalStore {
-            modules: HashMap::new(),
-        }
-    }
-
-    pub fn resolve_all_imports(&mut self) {
-        for module in self.modules.values_mut() {
-            for (name, source_path) in &module.import_table.imports {
-                println!("Resolving import: {} from {:?}", name, source_path);
-            }
-        }
-    }
-
-    pub fn insert_module(&mut self, path: String, module: Module) {
-        self.modules.insert(path, module);
-    }
-
-    pub fn modules_mut(&mut self) -> &mut HashMap<String, Module> {
-        &mut self.modules
-    }
-
-    pub fn get_module(&self, path: &str) -> Option<&Module> {
-        self.modules.get(path)
-    }
-
-    pub fn remove_module(&mut self, path: &str) -> Option<Module> {
-        self.modules.remove(path)
-    }
-}
+use crate::core::{
+    parser::statement::Statement,
+    preprocessor::module::Module,
+    store::{function::FunctionTable, variable::VariableTable},
+};
+use devalang_types::PluginInfo;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone)]
+pub struct GlobalStore {
+    pub modules: HashMap<String, Module>,
+    pub variables: VariableTable,
+    pub functions: FunctionTable,
+    pub events: HashMap<String, Vec<Statement>>,
+    pub plugins: HashMap<String, (PluginInfo, Vec<u8>)>,
+}
+
+impl Default for GlobalStore {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl GlobalStore {
+    pub fn new() -> Self {
+        GlobalStore {
+            modules: HashMap::new(),
+            functions: FunctionTable::new(),
+            variables: VariableTable::new(),
+            events: HashMap::new(),
+            plugins: HashMap::new(),
+        }
+    }
+
+    pub fn insert_module(&mut self, path: String, module: Module) {
+        self.modules.insert(path, module);
+    }
+
+    pub fn modules_mut(&mut self) -> &mut HashMap<String, Module> {
+        &mut self.modules
+    }
+
+    pub fn get_module(&self, path: &str) -> Option<&Module> {
+        self.modules.get(path)
+    }
+
+    pub fn remove_module(&mut self, path: &str) -> Option<Module> {
+        self.modules.remove(path)
+    }
+
+    pub fn register_event_handler(&mut self, event: &str, handler: Statement) {
+        self.events
+            .entry(event.to_string())
+            .or_default()
+            .push(handler);
+    }
+
+    pub fn get_event_handlers(&self, event: &str) -> Option<&Vec<Statement>> {
+        self.events.get(event)
+    }
+}

package/rust/core/store/import.rs

@@ -1,28 +1,28 @@
-use std::collections::HashMap;
-
-use crate::core::shared::value::Value;
-
-#[derive(Debug, Default, Clone, PartialEq)]
-pub struct ImportTable {
-    pub imports: HashMap<String, Value>,
-}
-
-impl ImportTable {
-    pub fn new() -> Self {
-        ImportTable {
-            imports: HashMap::new(),
-        }
-    }
-
-    pub fn add_import(&mut self, name: String, value: Value) {
-        self.imports.insert(name, value);
-    }
-
-    pub fn get_import(&self, name: &str) -> Option<&Value> {
-        self.imports.get(name)
-    }
-
-    pub fn remove_import(&mut self, name: &str) -> Option<Value> {
-        self.imports.remove(name)
-    }
-}
+use std::collections::HashMap;
+
+use devalang_types::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ImportTable {
+    pub imports: HashMap<String, Value>,
+}
+
+impl ImportTable {
+    pub fn new() -> Self {
+        ImportTable {
+            imports: HashMap::new(),
+        }
+    }
+
+    pub fn add_import(&mut self, name: String, value: Value) {
+        self.imports.insert(name, value);
+    }
+
+    pub fn get_import(&self, name: &str) -> Option<&Value> {
+        self.imports.get(name)
+    }
+
+    pub fn remove_import(&mut self, name: &str) -> Option<Value> {
+        self.imports.remove(name)
+    }
+}

package/rust/core/store/mod.rs

@@ -1,4 +1,5 @@
-pub mod global;
-pub mod export;
-pub mod import;
-pub mod variable;
+pub mod export;
+pub mod function;
+pub mod global;
+pub mod import;
+pub mod variable;

package/rust/core/store/variable.rs

@@ -1,28 +1,51 @@
-use std::collections::HashMap;
-
-use crate::core::shared::value::Value;
-
-#[derive(Debug, Default, Clone, PartialEq)]
-pub struct VariableTable {
-    pub variables: HashMap<String, Value>,
-}
-
-impl VariableTable {
-    pub fn new() -> Self {
-        VariableTable {
-            variables: HashMap::new(),
-        }
-    }
-
-    pub fn set(&mut self, name: String, value: Value) {
-        self.variables.insert(name, value);
-    }
-
-    pub fn get(&self, name: &str) -> Option<&Value> {
-        self.variables.get(name)
-    }
-
-    pub fn remove(&mut self, name: &str) -> Option<Value> {
-        self.variables.remove(name)
-    }
-}
+use std::collections::HashMap;
+
+use devalang_types::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct VariableTable {
+    pub variables: HashMap<String, Value>,
+    pub parent: Option<Box<VariableTable>>,
+}
+
+impl VariableTable {
+    pub fn new() -> Self {
+        VariableTable {
+            variables: HashMap::new(),
+            parent: None,
+        }
+    }
+
+    pub fn set(&mut self, name: String, value: Value) {
+        self.variables.insert(name, value);
+    }
+
+    pub fn with_parent(parent: VariableTable) -> Self {
+        Self {
+            variables: HashMap::new(),
+            parent: Some(Box::new(parent)),
+        }
+    }
+
+    pub fn get(&self, name: &str) -> Option<&Value> {
+        // First try the local table
+        if let Some(v) = self.variables.get(name) {
+            return Some(v);
+        }
+
+        // Then walk parent chain if present
+        let mut current = &self.parent;
+        while let Some(boxed) = current {
+            if let Some(v) = boxed.variables.get(name) {
+                return Some(v);
+            }
+            current = &boxed.parent;
+        }
+
+        None
+    }
+
+    pub fn remove(&mut self, name: &str) -> Option<Value> {
+        self.variables.remove(name)
+    }
+}

package/rust/core/utils/mod.rs

@@ -1,2 +1 @@
-pub mod path;
-pub mod validation;
+pub mod path;

package/rust/core/utils/path.rs

@@ -1,46 +1,37 @@
-use std::path::{ Component, Path };
-
-pub fn find_entry_file(path: &str) -> Option<String> {
-    let path = Path::new(path);
-
-    // Check if the path is a file
-    if path.is_file() {
-        return Some(path.to_string_lossy().to_string());
-    }
-
-    // Check if the path is a directory
-    if path.is_dir() {
-        // Look for an index.deva file in the directory
-        let index_path = path.join("index.deva");
-        if index_path.is_file() {
-            return Some(index_path.to_string_lossy().to_string());
-        }
-    }
-
-    None
-}
-
-pub fn normalize_path(path: &str) -> String {
-    let mut components = Vec::new();
-
-    // Iterate through the components of the path
-    for comp in Path::new(path).components() {
-        match comp {
-            Component::CurDir => {
-                continue;
-            }
-            Component::Normal(c) => components.push(c),
-            Component::RootDir => components.clear(),
-            _ => {}
-        }
-    }
-
-    // Join the components into a normalized path
-    let normalized = components
-        .iter()
-        .map(|c| c.to_string_lossy())
-        .collect::<Vec<_>>()
-        .join("/");
-
-    format!("./{}", normalized)
-}
+use std::path::{Path, PathBuf};
+
+pub fn find_entry_file(entry: &str) -> Option<String> {
+    let path = Path::new(entry);
+
+    if path.is_file() {
+        return Some(normalize_path(entry));
+    }
+
+    if path.is_dir() {
+        let candidate = path.join("index.deva");
+        if candidate.exists() {
+            return Some(normalize_path(&candidate));
+        }
+    }
+
+    None
+}
+
+pub fn normalize_path<P: AsRef<Path>>(path: P) -> String {
+    let path_buf = PathBuf::from(path.as_ref());
+    path_buf
+        .components()
+        .collect::<PathBuf>()
+        .to_string_lossy()
+        .replace('\\', "/")
+}
+
+pub fn resolve_relative_path(base: &str, import: &str) -> String {
+    let base_path = Path::new(base).parent().unwrap_or_else(|| Path::new(""));
+    let full_path = base_path.join(import);
+    full_path
+        .components()
+        .collect::<PathBuf>()
+        .to_string_lossy()
+        .replace("\\", "/")
+}