@devaloop/devalang 0.0.1-alpha.7 → 0.0.1-alpha.9

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

@@ -1,158 +1,14 @@
+pub mod driver;
+
+pub mod value;
+
 pub mod trigger;
 pub mod loop_;
 pub mod bank;
 pub mod tempo;
 pub mod group;
-
-use std::collections::HashMap;
-use crate::{
-    core::{
-        parser::statement::{ self, Statement, StatementKind },
-        preprocessor::{
-            loader::ModuleLoader,
-            resolver::{
-                bank::resolve_bank,
-                group::resolve_group,
-                loop_::resolve_loop,
-                tempo::resolve_tempo,
-                trigger::resolve_trigger,
-            },
-        },
-        shared::{ duration::Duration, value::Value },
-        store::global::GlobalStore,
-        utils::validation::{ is_valid_entity, is_valid_identifier },
-    },
-    utils::logger::Logger,
-};
-
-pub fn resolve_all_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
-    for module in global_store.clone().modules.values_mut() {
-        resolve_imports(module_loader, global_store);
-    }
-}
-
-pub fn resolve_imports(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
-    for (module_path, module) in global_store.clone().modules.iter_mut() {
-        for (name, source_path) in &module.import_table.imports {
-            match source_path {
-                Value::String(source_path) => {
-                    if let Some(source_module) = global_store.modules.get(source_path) {
-                        if let Some(value) = source_module.export_table.get_export(name) {
-                            module.variable_table.set(name.clone(), value.clone());
-                        } else {
-                            println!(
-                                "[warn] '{module_path}': '{name}' not found in exports of '{source_path}'"
-                            );
-                        }
-                    } else {
-                        println!(
-                            "[warn] '{module_path}': cannot find source module '{source_path}'"
-                        );
-                    }
-                }
-                _ => {
-                    println!(
-                        "[warn] '{module_path}': expected string for import source, found {:?}",
-                        source_path
-                    );
-                }
-            }
-        }
-    }
-}
-
-pub fn resolve_and_flatten_all_modules(
-    global_store: &mut GlobalStore
-) -> HashMap<String, Vec<Statement>> {
-    let logger = Logger::new();
-    let snapshot = global_store.clone();
-
-    // 1. Imports resolution
-    for (module_path, module) in global_store.modules.iter_mut() {
-        for (name, source_path) in &module.import_table.imports {
-            if let Value::String(source_path_str) = source_path {
-                match snapshot.modules.get(source_path_str) {
-                    Some(source_module) => {
-                        if let Some(value) = source_module.export_table.get_export(name) {
-                            module.variable_table.set(name.clone(), value.clone());
-                        } else {
-                            logger.log_error_with_stacktrace(
-                                &format!("'{name}' not found in exports of '{source_path_str}'"),
-                                module_path
-                            );
-                        }
-                    }
-                    None => {
-                        logger.log_error_with_stacktrace(
-                            &format!("Cannot find source module '{source_path_str}'"),
-                            module_path
-                        );
-                    }
-                }
-            } else {
-                logger.log_error_with_stacktrace(
-                    &format!("Expected string for import source, found {:?}", source_path),
-                    module_path
-                );
-            }
-        }
-    }
-
-    // 2. Statements resolution
-    let mut resolved_map: HashMap<String, Vec<Statement>> = HashMap::new();
-    let store_snapshot = global_store.clone();
-
-    for (path, module) in &store_snapshot.modules {
-        let mut resolved = Vec::new();
-
-        for stmt in &module.statements {
-            let mut stmt = stmt.clone();
-
-            match &stmt.kind {
-                StatementKind::Trigger { entity, duration } => {
-                    let resolved_stmt = resolve_trigger(
-                        &stmt,
-                        entity.as_str(),
-                        &mut duration.clone(),
-                        &module,
-                        &path,
-                        &store_snapshot
-                    );
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Loop => {
-                    let resolved_stmt = resolve_loop(&stmt, &module, &path, &store_snapshot);
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Bank => {
-                    let resolved_stmt = resolve_bank(&stmt, &module, &path, &store_snapshot);
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Tempo => {
-                    let resolved_stmt = resolve_tempo(&stmt, &module, &path, &store_snapshot);
-                    resolved.push(resolved_stmt);
-                }
-
-                StatementKind::Import { .. } | StatementKind::Export { .. } => {
-                    resolved.push(stmt.clone());
-                }
-
-                StatementKind::Group => {
-                    let resolved_stmt = resolve_group(&stmt, &module, &path, &store_snapshot);
-                    resolved.push(resolved_stmt);
-                }
-
-                _ => {
-                    resolved.push(stmt);
-                }
-            }
-        }
-
-        resolved_map.insert(path.clone(), resolved);
-    }
-
-    resolved_map
-}
+pub mod condition;
+pub mod spawn;
+pub mod call;
+pub mod synth;
+pub mod let_;

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

@@ -0,0 +1,58 @@
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{
+            module::Module,
+            resolver::driver::resolve_statement,
+            resolver::value::resolve_value,
+        },
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::{ Logger, LogLevel },
+};
+
+pub fn resolve_spawn(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    let resolved_value = resolve_value(&stmt.value, module, global_store);
+
+    match resolved_value {
+        Value::Map(mut map) => {
+            if let Some(Value::Block(stmts)) = map.get("body") {
+                let resolved_block = stmts
+                    .iter()
+                    .map(|s| resolve_statement(s, module, path, global_store))
+                    .collect();
+                map.insert("body".to_string(), Value::Block(resolved_block));
+            }
+
+            Statement {
+                kind: StatementKind::Spawn,
+                value: Value::Map(map),
+                ..stmt.clone()
+            }
+        }
+
+        _ => {
+            let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+            logger.log_message(
+                LogLevel::Error,
+                &format!("Expected a map in spawn statement\n  → at {stacktrace}")
+            );
+
+            Statement {
+                kind: StatementKind::Error {
+                    message: "Invalid spawn value".to_string(),
+                },
+                value: Value::Null,
+                ..stmt.clone()
+            }
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::driver::resolve_statement },
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::{ LogLevel, Logger },
+};
+
+pub fn resolve_synth(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    let Value::Map(synth_map) = &stmt.value else {
+        return type_error(&logger, module, stmt, "Expected a map in synth statement".to_string());
+    };
+
+    let mut resolved_map = synth_map.clone();
+
+    if let Some(Value::Block(body)) = synth_map.get("body") {
+        let resolved_body = body.iter()
+            .map(|s| resolve_statement(s, module, path, global_store))
+            .collect::<Vec<_>>();
+        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
+    } else {
+        logger.log_message(LogLevel::Warning, "synth without a body");
+    }
+
+    Statement {
+        kind: StatementKind::Synth,
+        value: Value::Map(resolved_map),
+        ..stmt.clone()
+    }
+}
+
+fn type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) -> Statement {
+    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+    logger.log_error_with_stacktrace(&message, &stacktrace);
+
+    Statement {
+        kind: StatementKind::Error { message },
+        value: Value::Null,
+        ..stmt.clone()
+    }
+}

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

@@ -6,7 +6,6 @@ use crate::{
         preprocessor::module::Module,
         shared::{ duration::Duration, value::Value },
         store::global::GlobalStore,
-        utils::validation::is_valid_entity,
     },
     utils::logger::Logger,
 };
@@ -24,30 +23,17 @@ pub fn resolve_trigger(
     let mut final_duration = duration.clone();
     let mut final_value = stmt.value.clone();
 
-    if !is_valid_entity(entity, module, global_store) {
-        let message = format!("Invalid entity '{}', expected a valid identifier", entity);
-        let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-        logger.log_error_with_stacktrace(&message, &stacktrace);
-
-        return Statement {
-            kind: stmt.kind.clone(),
-            value: Value::Null,
-            line: stmt.line,
-            column: stmt.column,
-            indent: stmt.indent,
-        };
-    }
-
+    // Duration resolution
     if let Duration::Identifier(ident) = duration {
-        if let Some(val) = module.variable_table.get(ident) {
+        if let Some(val) = resolve_identifier(ident, module, global_store) {
             match val {
-                Value::Number(num) => {
-                    final_duration = Duration::Number(*num);
+                Value::Number(n) => {
+                    final_duration = Duration::Number(n);
                 }
                 Value::String(s) => {
-                    final_duration = Duration::Identifier(s.clone());
+                    final_duration = Duration::Identifier(s);
                 }
-                Value::Identifier(id) if id == "auto" => {
+                Value::Identifier(s) if s == "auto" => {
                     final_duration = Duration::Auto;
                 }
                 _ => {}
@@ -55,50 +41,34 @@ pub fn resolve_trigger(
         }
     }
 
+    // Params value resolution
     final_value = match &stmt.value {
         Value::Identifier(ident) => {
-            match module.variable_table.get(ident) {
-                Some(val) => val.clone(),
-                None => {
-                    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-                    let message = format!(
-                        "'{path}': value identifier '{ident}' not found in variable table"
-                    );
-                    logger.log_error_with_stacktrace(&message, &stacktrace);
-                    Value::Null
-                }
-            }
+            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
+            })
         }
         Value::Map(map) => {
             let mut resolved_map = HashMap::new();
-            for (k, v) in map.iter() {
-                let resolved_v = match v {
+            for (k, v) in map {
+                let resolved = match v {
                     Value::Identifier(id) => {
-                        module.variable_table.get(id).cloned().unwrap_or(Value::Null)
+                        resolve_identifier(id, module, global_store).unwrap_or(Value::Null)
                     }
                     other => other.clone(),
                 };
-                resolved_map.insert(k.clone(), resolved_v);
+                resolved_map.insert(k.clone(), resolved);
             }
             Value::Map(resolved_map)
         }
         other => other.clone(),
     };
 
-    if let StatementKind::Trigger { entity, .. } = &stmt.kind {
-        return Statement {
-            kind: StatementKind::Trigger {
-                entity: entity.to_string(),
-                duration: final_duration,
-            },
-            value: final_value,
-            line: stmt.line,
-            column: stmt.column,
-            indent: stmt.indent,
-        };
-    }
-
-    return Statement {
+    Statement {
         kind: StatementKind::Trigger {
             entity: entity.to_string(),
             duration: final_duration,
@@ -107,5 +77,36 @@ pub fn resolve_trigger(
         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));
+    }
+
+    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
+}
+
+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/utils/path.rs

@@ -1,46 +1,31 @@
-use std::path::{ Component, Path };
+use std::path::{ Component, Path, PathBuf };
 
-pub fn find_entry_file(path: &str) -> Option<String> {
-    let path = Path::new(path);
+pub fn find_entry_file(entry: &str) -> Option<String> {
+    let path = Path::new(entry);
 
-    // Check if the path is a file
     if path.is_file() {
-        return Some(path.to_string_lossy().to_string());
+        return Some(normalize_path(entry));
     }
 
-    // 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());
+        let candidate = path.join("index.deva");
+        if candidate.exists() {
+            return Some(normalize_path(&candidate));
         }
     }
 
     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("/");
+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('\\', "/")
+}
 
-    format!("./{}", normalized)
+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

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

@@ -1,23 +1,18 @@
 import fs from "fs";
-import path from "path";
 import { execSync } from "child_process";
 
 export const fetchVersion = async (projectVersionPath: string) => {
-    // Lire le fichier
     const data = JSON.parse(fs.readFileSync(projectVersionPath, "utf-8"));
 
-    // Incrémenter le numéro de build
     data.build = (data.build || 0) + 1;
 
-    // Récupérer le dernier hash git
     try {
         const commit = execSync("git rev-parse HEAD").toString().trim();
         data.lastCommit = commit;
     } catch (err) {
-        console.warn("⚠️ Impossible de récupérer le hash git.");
+        console.warn("⚠️ Unable to fetch git commit hash. Ensure you are in a git repository.");
     }
 
-    // Écrire la mise à jour
     fs.writeFileSync(projectVersionPath, JSON.stringify(data, null, 2));
 }