@devaloop/devalang 0.0.1-alpha.3 → 0.0.1-alpha.5

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

@@ -0,0 +1,151 @@
+pub mod trigger;
+pub mod loop_;
+pub mod bank;
+pub mod tempo;
+
+use std::collections::HashMap;
+use crate::{
+    core::{
+        parser::statement::{ self, Statement, StatementKind },
+        preprocessor::{
+            loader::ModuleLoader,
+            resolver::{
+                bank::resolve_bank,
+                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());
+                }
+
+                _ => {
+                    resolved.push(stmt);
+                }
+            }
+        }
+
+        resolved_map.insert(path.clone(), resolved);
+    }
+
+    resolved_map
+}

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

@@ -0,0 +1,49 @@
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::module::Module,
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_tempo(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    _global_store: &GlobalStore
+) -> Statement {
+    let mut new_stmt = stmt.clone();
+    let logger = Logger::new();
+
+    match &stmt.value {
+        Value::Identifier(ident) => {
+            if let Some(val) = module.variable_table.get(ident) {
+                new_stmt.value = val.clone();
+            } else {
+                let message = format!("Tempo identifier '{ident}' not found in variable table");
+                logger.log_error_with_stacktrace(&message, &module.path);
+                new_stmt.kind = StatementKind::Error {
+                    message,
+                };
+                new_stmt.value = Value::Null;
+            }
+        }
+
+        Value::Number(_) => {
+            // Already resolved, no modification needed
+        }
+
+        other => {
+            let message = format!("Expected a number or identifier for tempo, found {:?}", other);
+            logger.log_error_with_stacktrace(&message, &module.path);
+            new_stmt.kind = StatementKind::Error {
+                message: "Expected a number or identifier for tempo".to_string(),
+            };
+            new_stmt.value = Value::Null;
+        }
+    }
+
+    new_stmt
+}

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

@@ -0,0 +1,114 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::module::Module,
+        shared::{ duration::Duration, value::Value },
+        store::global::GlobalStore,
+        utils::validation::is_valid_entity,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_trigger(
+    stmt: &Statement,
+    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();
+
+    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,
+        };
+    }
+
+    // ✅ Résolution de duration si c'est un identifiant
+    if let Duration::Identifier(ident) = duration {
+        if let Some(val) = module.variable_table.get(ident) {
+            match val {
+                Value::Number(num) => {
+                    final_duration = Duration::Number(*num);
+                }
+                Value::String(s) => {
+                    final_duration = Duration::Identifier(s.clone());
+                }
+                Value::Identifier(id) if id == "auto" => {
+                    final_duration = Duration::Auto;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // ✅ Résolution de value (params, effets)
+    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
+                }
+            }
+        }
+        Value::Map(map) => {
+            let mut resolved_map = HashMap::new();
+            for (k, v) in map.iter() {
+                let resolved_v = match v {
+                    Value::Identifier(id) => {
+                        module.variable_table.get(id).cloned().unwrap_or(Value::Null)
+                    }
+                    other => other.clone(),
+                };
+                resolved_map.insert(k.clone(), resolved_v);
+            }
+            Value::Map(resolved_map)
+        }
+        other => other.clone(),
+    };
+
+    // ✅ On reconstruit le Statement avec Trigger résolu
+    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 {
+        kind: StatementKind::Trigger {
+            entity: entity.to_string(),
+            duration: final_duration,
+        },
+        value: final_value,
+        line: stmt.line,
+        column: stmt.column,
+        indent: stmt.indent,
+    };
+}

package/rust/lib.rs

@@ -0,0 +1,118 @@
+pub mod core;
+pub mod utils;
+pub mod config;
+pub mod audio;
+
+use serde::{ Deserialize, Serialize };
+use wasm_bindgen::prelude::*;
+use serde_wasm_bindgen::to_value;
+
+use crate::core::{
+    parser::statement::{ Statement, StatementKind },
+    preprocessor::loader::ModuleLoader,
+    shared::value::Value,
+    store::global::GlobalStore,
+    utils::path::normalize_path,
+};
+
+#[derive(Serialize, Deserialize)]
+struct ParseResult {
+    ok: bool,
+    ast: String,
+    errors: Vec<ErrorResult>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct ErrorResult {
+    message: String,
+    line: usize,
+    column: usize,
+}
+
+#[wasm_bindgen]
+pub fn parse(entry_path: &str, source: &str) -> Result<JsValue, JsValue> {
+    let statements = parse_internal_from_string(entry_path, source);
+
+    match statements {
+        Ok(value) => {
+            let ast_string = value;
+            to_value(&ast_string).map_err(|e|
+                JsValue::from_str(&format!("Error converting AST to JS value: {}", e))
+            )
+        }
+        Err(e) => { Err(JsValue::from_str(&format!("Error: {}", e))) }
+    }
+}
+
+fn parse_internal_from_string(virtual_path: &str, source: &str) -> Result<ParseResult, String> {
+    let entry_path = normalize_path(virtual_path);
+    let output_path = normalize_path("./temp");
+
+    let mut global_store = GlobalStore::new();
+    let loader = ModuleLoader::from_raw_source(
+        &entry_path,
+        &output_path,
+        source,
+        &mut global_store
+    );
+
+    let module = loader
+        .load_single_module(&mut global_store)
+        .map_err(|e| format!("Error loading module: {}", e))?;
+
+    let raw_ast = ast_to_string(module.statements.clone());
+
+    let found_errors = collect_errors_recursively(&module.statements);
+
+    let result = ParseResult {
+        ok: true,
+        ast: raw_ast,
+        errors: found_errors,
+    };
+
+    Ok(result)
+}
+
+fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
+    let mut errors: Vec<ErrorResult> = Vec::new();
+
+    for stmt in statements {
+        match &stmt.kind {
+            StatementKind::Unknown => {
+                errors.push(ErrorResult {
+                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Error { message } => {
+                errors.push(ErrorResult {
+                    message: message.clone(),
+                    line: stmt.line,
+                    column: stmt.column,
+                });
+            }
+            StatementKind::Loop => {
+                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
+                    errors.extend(collect_errors_recursively(body_statements));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    errors
+}
+
+fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
+    if let Value::Map(map) = value {
+        if let Some(Value::Block(statements)) = map.get("body") {
+            return Some(statements);
+        }
+    }
+    None
+}
+
+fn ast_to_string(statements: Vec<Statement>) -> String {
+    serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
+}

package/rust/main.rs

@@ -1,7 +1,10 @@
+#![cfg(feature = "cli")]
+
 pub mod core;
 pub mod cli;
 pub mod utils;
 pub mod config;
+pub mod audio;
 
 use std::io;
 use cli::{ Cli };
@@ -11,6 +14,7 @@ use crate::{
         build::handle_build_command,
         check::handle_check_command,
         init::handle_init_command,
+        play::handle_play_command,
         template::{ handle_template_info_command, handle_template_list_command },
         Commands,
         TemplateCommand,
@@ -51,6 +55,10 @@ fn main() -> io::Result<()> {
             handle_build_command(config, entry, output, watch);
         }
 
+        Commands::Play { entry, output, watch, repeat } => {
+            handle_play_command(config, entry, output, watch, repeat);
+        }
+
         _ => {}
     }
 

package/rust/utils/logger.rs

@@ -1,5 +1,6 @@
-use crossterm::style::{ Attribute, Color, ResetColor, SetAttribute, SetForegroundColor };
-use std::{ fmt::Write };
+#[cfg(feature = "cli")]
+use crossterm::style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor};
+use std::fmt::Write;
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum LogLevel {
@@ -12,24 +13,43 @@ pub enum LogLevel {
 }
 
 #[derive(Debug, Clone)]
-pub struct Logger {}
+pub struct Logger;
 
 impl Logger {
     pub fn new() -> Self {
-        Logger {}
+        Logger
     }
 
+    // --- log_message ---
+
+    #[cfg(feature = "cli")]
     pub fn log_message(&self, level: LogLevel, message: &str) {
         let formatted_status = self.format_status(level);
         println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
     }
 
+    #[cfg(not(feature = "cli"))]
+    pub fn log_message(&self, _level: LogLevel, _message: &str) {
+        // no-op for WASM
+    }
+
+    // --- log_error_with_stacktrace ---
+
+    #[cfg(feature = "cli")]
     pub fn log_error_with_stacktrace(&self, message: &str, stacktrace: &str) {
         let formatted_status = self.format_status(LogLevel::Error);
         println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
         println!("     ↳ {}", stacktrace);
     }
 
+    #[cfg(not(feature = "cli"))]
+    pub fn log_error_with_stacktrace(&self, _message: &str, _stacktrace: &str) {
+        // no-op for WASM
+    }
+
+    // --- language_signature ---
+
+    #[cfg(feature = "cli")]
     fn language_signature(&self) -> String {
         let mut s = String::new();
 
@@ -43,12 +63,19 @@ impl Logger {
 
         write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
         s.push(']');
-
         write!(&mut s, "{}", ResetColor).unwrap();
 
         s
     }
 
+    #[cfg(not(feature = "cli"))]
+    fn language_signature(&self) -> String {
+        "[Devalang]".to_string()
+    }
+
+    // --- format_status ---
+
+    #[cfg(feature = "cli")]
     fn format_status(&self, level: LogLevel) -> String {
         let mut s = String::new();
 
@@ -76,9 +103,21 @@ impl Logger {
         s.push_str(status);
         write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
         s.push(']');
-
         write!(&mut s, "{}", ResetColor).unwrap();
 
         s
     }
+
+    #[cfg(not(feature = "cli"))]
+    fn format_status(&self, level: LogLevel) -> String {
+        match level {
+            LogLevel::Success => "[SUCCESS]",
+            LogLevel::Error => "[ERROR]",
+            LogLevel::Info => "[INFO]",
+            LogLevel::Warning => "[WARNING]",
+            LogLevel::Watcher => "[WATCHER]",
+            LogLevel::Debug => "[DEBUG]",
+        }
+        .to_string()
+    }
 }

package/rust/utils/spinner.rs

@@ -1,6 +1,8 @@
+#[cfg(feature = "cli")]
 use indicatif::{ ProgressBar, ProgressStyle };
 use std::{ time::Duration };
 
+#[cfg(feature = "cli")]
 pub fn with_spinner<T, F>(start_msg: &str, f: F) -> T where F: FnOnce() -> T {
     let spinner = ProgressBar::new_spinner();
     spinner.set_style(

package/rust/utils/watcher.rs

@@ -1,6 +1,8 @@
 use notify::{ Watcher, RecursiveMode, Config, RecommendedWatcher };
 use std::sync::mpsc::channel;
 
+use std::time::{ Duration, Instant };
+
 pub fn watch_directory<F>(entry: String, callback: F) -> notify::Result<()>
     where F: Fn() + Send + 'static
 {
@@ -9,13 +11,19 @@ pub fn watch_directory<F>(entry: String, callback: F) -> notify::Result<()>
     let mut watcher: RecommendedWatcher = Watcher::new(tx, Config::default())?;
     watcher.watch(&entry.as_ref(), RecursiveMode::Recursive)?;
 
+    let mut last_trigger = Instant::now();
+
     loop {
         match rx.recv() {
             Ok(_) => {
-                callback();
+                let now = Instant::now();
+                if now.duration_since(last_trigger) > Duration::from_millis(200) {
+                    callback();
+                    last_trigger = now;
+                }
             }
             Err(e) => {
-                eprintln!("Channel error : {:?}", e);
+                eprintln!("Channel error: {:?}", e);
                 break;
             }
         }

package/templates/minimal/.devalang

@@ -1,4 +1,5 @@
 [defaults]
 entry = "./src"
 output = "./output"
-watch = false
+watch = false
+repeat = false