@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.11

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

@@ -1,176 +1,112 @@
 use std::collections::HashMap;
 
-use crate::core::{
-    parser::parse_with_resolving_with_module,
-    types::{
-        module::Module,
-        statement::{ Statement, StatementKind, StatementResolved, StatementResolvedValue },
-        token::{ TokenDuration, TokenParamValue },
-        variable::VariableValue,
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::module::Module,
+        shared::{ duration::Duration, value::Value },
+        store::global::GlobalStore,
     },
+    utils::logger::Logger,
 };
 
-pub fn resolve_trigger_statement(
+pub fn resolve_trigger(
     stmt: &Statement,
-    entity: String,
-    duration: TokenDuration,
-    module: &Module
-) -> StatementResolved {
-    let mut entity_value = VariableValue::Unknown;
-
-    if let Some(value) = module.variable_table.variables.get(&entity) {
-        entity_value = value.clone();
-    } else {
-        entity_value = VariableValue::Text(entity.clone());
-    }
-
-    let duration_raw_value = match duration {
-        TokenDuration::Auto => "auto",
-        TokenDuration::Infinite => "infinite",
-        TokenDuration::Number(n) => &n.to_string(),
-        TokenDuration::Identifier(ref id) => id.as_str(),
-        _ => "unknown",
-    };
-
-    let duration_variable_value = module.variable_table.variables.get(duration_raw_value);
-    let mut parsed_duration_value = TokenDuration::Unknown;
-
-    if duration_variable_value.is_some() {
-        parsed_duration_value = duration_variable_value
-            .as_ref()
-            .map_or(TokenDuration::Unknown, |value| {
-                match value {
-                    VariableValue::Text(text) => TokenDuration::Identifier(text.clone()),
-                    VariableValue::Number(num) => TokenDuration::Number(*num),
-                    VariableValue::Boolean(_) => TokenDuration::Unknown,
-                    _ => {
-                        eprintln!("⚠️ Invalid duration type for Trigger: {:?}", value);
-                        TokenDuration::Unknown
-                    }
+    entity: &str,
+    duration: &mut Duration,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    let mut final_duration = duration.clone();
+    let mut final_value = stmt.value.clone();
+
+    // Duration resolution
+    if let Duration::Identifier(ident) = duration {
+        if let Some(val) = resolve_identifier(ident, module, global_store) {
+            match val {
+                Value::Number(n) => {
+                    final_duration = Duration::Number(n);
                 }
-            });
-    } else if let Ok(num) = duration_raw_value.parse::<f32>() {
-        parsed_duration_value = TokenDuration::Number(num);
-    } else if duration_raw_value == "auto" {
-        parsed_duration_value = TokenDuration::Auto;
-    } else if duration_raw_value == "infinite" {
-        parsed_duration_value = TokenDuration::Infinite;
-    } else {
-        eprintln!("⚠️ Invalid duration format: {}", duration_raw_value);
-    }
-
-    match &stmt.value {
-        VariableValue::Text(text) => {
-            if let Some(value) = module.variable_table.variables.get(text) {
-                let parsed_entity_value: StatementResolvedValue = match value {
-                    VariableValue::Array(arr) => {
-                        StatementResolvedValue::Array(
-                            parse_with_resolving_with_module(arr.clone(), module)
-                        )
-                    }
-                    VariableValue::Map(map) => {
-                        let mut resolved_map = HashMap::new();
-
-                        for (key, value) in map {
-                            let resolved_value = match value {
-                                TokenParamValue::String(text) =>
-                                    StatementResolvedValue::String(text.clone()),
-                                TokenParamValue::Number(num) =>
-                                    StatementResolvedValue::Number(*num),
-                                TokenParamValue::Boolean(b) => StatementResolvedValue::Boolean(*b),
-                                _ => {
-                                    eprintln!(
-                                        "⚠️ Unsupported variable type for Trigger map: {:?}",
-                                        value
-                                    );
-                                    StatementResolvedValue::Unknown
-                                }
-                            };
-                            resolved_map.insert(key.clone(), resolved_value);
-                        }
-
-                        StatementResolvedValue::Map(resolved_map)
-                    }
-
-                    | VariableValue::Text(_)
-                    | VariableValue::Number(_)
-                    | VariableValue::Boolean(_) => {
-                        StatementResolvedValue::String(text.clone())
-                    }
-                    _ => {
-                        eprintln!("⚠️ Unsupported variable type for Trigger entity: {:?}", value);
-                        StatementResolvedValue::Unknown
-                    }
-                };
-
-                StatementResolved {
-                    kind: StatementKind::Trigger {
-                        entity: entity.clone(),
-                        duration: parsed_duration_value,
-                    },
-                    value: parsed_entity_value,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
+                Value::String(s) => {
+                    final_duration = Duration::Identifier(s);
                 }
-            } else {
-                eprintln!("⚠️ Trigger variable '{}' not found", text);
-                StatementResolved {
-                    kind: StatementKind::Trigger {
-                        entity: entity.clone(),
-                        duration: parsed_duration_value,
-                    },
-                    value: StatementResolvedValue::Unknown,
-                    indent: stmt.indent,
-                    line: stmt.line,
-                    column: stmt.column,
+                Value::Identifier(s) if s == "auto" => {
+                    final_duration = Duration::Auto;
                 }
+                _ => {}
             }
         }
-        VariableValue::Map(map) => {
-            let mut resolved_map = HashMap::new();
-
-            // TODO Handle nested maps and arrays
+    }
 
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Map(resolved_map),
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
-            }
+    // Params value resolution
+    final_value = match &stmt.value {
+        Value::Identifier(ident) => {
+            resolve_identifier(ident, module, global_store).unwrap_or_else(|| {
+                logger.log_error_with_stacktrace(
+                    &format!("'{path}': value identifier '{ident}' not found"),
+                    &format!("{}:{}:{}", module.path, stmt.line, stmt.column)
+                );
+                Value::Null
+            })
         }
-        VariableValue::Null => {
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Map(HashMap::new()),
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
+        Value::Map(map) => {
+            let mut resolved_map = HashMap::new();
+            for (k, v) in map {
+                let resolved = match v {
+                    Value::Identifier(id) => {
+                        resolve_identifier(id, module, global_store).unwrap_or(Value::Null)
+                    }
+                    other => other.clone(),
+                };
+                resolved_map.insert(k.clone(), resolved);
             }
+            Value::Map(resolved_map)
         }
+        other => other.clone(),
+    };
 
-        // TODO Parse other parameters
+    Statement {
+        kind: StatementKind::Trigger {
+            entity: entity.to_string(),
+            duration: final_duration,
+        },
+        value: final_value,
+        line: stmt.line,
+        column: stmt.column,
+        indent: stmt.indent,
+    }
+}
+
+fn resolve_identifier(ident: &str, module: &Module, global_store: &GlobalStore) -> Option<Value> {
+    if let Some(val) = module.variable_table.get(ident) {
+        return Some(resolve_value(val, module, global_store));
+    }
 
-        _ => {
-            eprintln!("⚠️ Invalid value type for Trigger statement: {:?}", stmt.value);
+    for (_, other_mod) in &global_store.modules {
+        if let Some(val) = other_mod.export_table.get_export(ident) {
+            return Some(resolve_value(val, other_mod, global_store));
+        }
+    }
+
+    None
+}
 
-            StatementResolved {
-                kind: StatementKind::Trigger {
-                    entity: entity.clone(),
-                    duration: parsed_duration_value,
-                },
-                value: StatementResolvedValue::Unknown,
-                indent: stmt.indent,
-                line: stmt.line,
-                column: stmt.column,
+fn resolve_value(val: &Value, module: &Module, global_store: &GlobalStore) -> Value {
+    match val {
+        Value::Identifier(inner) =>
+            resolve_identifier(inner, module, global_store).unwrap_or(
+                Value::Identifier(inner.clone())
+            ),
+        Value::Map(map) => {
+            let mut resolved = HashMap::new();
+            for (k, v) in map {
+                resolved.insert(k.clone(), resolve_value(v, module, global_store));
             }
+            Value::Map(resolved)
         }
+        other => other.clone(),
     }
 }

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

@@ -0,0 +1,78 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::driver::resolve_statement },
+        shared::value::Value,
+        store::{ global::GlobalStore, variable::VariableTable },
+    },
+    utils::logger::{ LogLevel, Logger },
+};
+
+fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
+    for (_path, module) in &global_store.modules {
+        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::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);
+            }
+
+            eprintln!("⚠️ Unresolved identifier '{}'", name);
+            Value::Null
+        }
+
+        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()));
+
+                        let mut result = HashMap::new();
+                        result.insert("waveform".to_string(), resolved_waveform);
+                        result.insert("parameters".to_string(), resolved_params);
+
+                        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/shared/bank.rs

@@ -0,0 +1,21 @@
+use serde::{ Deserialize, Serialize };
+
+#[derive(Debug, Deserialize)]
+pub struct BankInfo {
+    pub name: String,
+    pub version: String,
+    pub description: String,
+    pub author: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BankFile {
+    pub bank: BankInfo,
+    pub triggers: Option<Vec<BankTrigger>>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct BankTrigger {
+    pub name: String,
+    pub path: String,
+}

package/rust/core/shared/duration.rs

@@ -0,0 +1,9 @@
+use serde::{ Deserialize, Serialize };
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum Duration {
+    Number(f32),
+    Identifier(String),
+    Beat(String),
+    Auto,
+}

package/rust/core/shared/mod.rs

@@ -0,0 +1,3 @@
+pub mod value;
+pub mod duration;
+pub mod bank;

package/rust/core/shared/value.rs

@@ -0,0 +1,29 @@
+use std::collections::HashMap;
+use serde::{ Deserialize, Serialize };
+
+use crate::core::parser::statement::Statement;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum Value {
+    Boolean(bool),
+    Number(f32),
+    Identifier(String),
+    String(String),
+    Array(Vec<Value>),
+    Map(HashMap<String, Value>),
+    Block(Vec<Statement>),
+    Sample(String),
+    Beat(String),
+    Unknown,
+    Null,
+}
+
+impl Value {
+    pub fn get(&self, key: &str) -> Option<&Value> {
+        if let Value::Map(map) = self {
+            map.get(key)
+        } else {
+            None
+        }
+    }
+}

package/rust/core/store/export.rs

@@ -0,0 +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)
+    }
+}

package/rust/core/store/global.rs

@@ -0,0 +1,39 @@
+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)
+    }
+}

package/rust/core/store/import.rs

@@ -0,0 +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)
+    }
+}

package/rust/core/store/mod.rs

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

package/rust/core/store/variable.rs

@@ -0,0 +1,28 @@
+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)
+    }
+}

package/rust/core/utils/mod.rs

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

package/rust/core/utils/path.rs

@@ -0,0 +1,31 @@
+use std::path::{ Component, 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("\\", "/")
+}

package/rust/core/utils/validation.rs

@@ -0,0 +1,37 @@
+use crate::core::{ preprocessor::module::Module, shared::value::Value, store::global::GlobalStore };
+
+// NOTE: Deprecated functions, kept for reference
+
+// pub fn is_valid_entity(entity: &str, module: &Module, global_store: &GlobalStore) -> bool {
+//     let built_ins = ["kick", "snare", "hat", "clap"];
+
+//     if built_ins.contains(&entity) {
+//         return true;
+//     }
+
+//     if let Some(val) = module.variable_table.get(entity) {
+//         match val {
+//             Value::Sample(_) => true,
+//             _ => false,
+//         }
+//     } else {
+//         false
+//     }
+// }
+
+// pub fn is_valid_identifier(ident: &str, module: &Module) -> bool {
+//     let built_ins = ["auto"];
+
+//     if built_ins.contains(&ident) {
+//         return true;
+//     }
+
+//     if let Some(val) = module.variable_table.get(ident) {
+//         match val {
+//             Value::Identifier(_) => true,
+//             _ => false,
+//         }
+//     } else {
+//         false
+//     }
+// }

package/rust/installer/bank.rs

@@ -0,0 +1,55 @@
+use std::path::{ Path, PathBuf };
+use crate::{
+    common::cdn::get_cdn_url,
+    config::loader::{ add_bank_to_config, load_config },
+    utils::installer::{ download_file, extract_archive },
+};
+
+pub async fn install_bank(name: &str, target_dir: &Path) -> Result<(), String> {
+    let cdn_url = get_cdn_url();
+    let url = format!("{}/bank/{}", cdn_url, name);
+
+    let bank_dir = target_dir.join("bank");
+    let archive_path = PathBuf::from(format!("./.deva/tmp/{}.devabank", name));
+    let extract_path = bank_dir.join(name);
+
+    if extract_path.exists() {
+        println!(
+            "Bank '{}' already exists at '{}'. Skipping install.",
+            name,
+            extract_path.display()
+        );
+        return Ok(());
+    }
+
+    download_file(&url, &archive_path).await.map_err(|e| format!("Failed to download: {}", e))?;
+
+    extract_archive(&archive_path, &extract_path).await.map_err(|e|
+        format!("Failed to extract: {}", e)
+    )?;
+
+    // Add the bank to the config
+    let root_dir = target_dir
+        .parent()
+        .ok_or_else(|| "Failed to determine root directory".to_string())?;
+
+    let config_path = root_dir.join(".devalang");
+    if !config_path.exists() {
+        return Err(
+            format!(
+                "Config file not found at '{}'. Please run 'devalang init' before adding an addon",
+                config_path.display()
+            )
+        );
+    }
+
+    let mut config = load_config(Some(&config_path)).ok_or_else(||
+        format!("Failed to load config from '{}'", config_path.display())
+    )?;
+
+    let dependency_path = &format!("devalang://bank/{}", name);
+
+    add_bank_to_config(&mut config, &extract_path, &dependency_path);
+
+    Ok(())
+}

package/rust/installer/mod.rs

@@ -0,0 +1 @@
+pub mod bank;