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

package/rust/core/parser/statement.rs

@@ -51,12 +51,16 @@ pub enum StatementKind {
     // Loop statements
     Loop,
 
+    // Group statements
+    Group,
+
+    // Special statements
+    Call,
+    Spawn,
+    Sleep,
+
     // Conditional statements
-    // If {
-    //     // condition: ConditionParts,
-    //     condition_state: bool,
-    //     body: Vec<Statement>,
-    // },
+    // If
 
     // Keyword statements
     Tempo,

package/rust/core/preprocessor/loader.rs

@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-
 use crate::{
     core::{
         error::ErrorHandler,
@@ -11,8 +10,9 @@ use crate::{
             resolver::{ resolve_all_modules, resolve_and_flatten_all_modules },
         },
         store::global::GlobalStore,
+        utils::path::normalize_path,
     },
-    utils::logger::{ Logger },
+    utils::logger::Logger,
 };
 
 pub struct ModuleLoader {
@@ -28,7 +28,67 @@ impl ModuleLoader {
         }
     }
 
-    pub fn load_all(
+    pub fn from_raw_source(
+        entry_path: &str,
+        output_path: &str,
+        content: &str,
+        global_store: &mut GlobalStore
+    ) -> Self {
+        let normalized_entry_path = normalize_path(entry_path);
+
+        let mut module = Module::new(&entry_path);
+        module.content = content.to_string();
+
+        println!("Loading module from raw source: {}", normalized_entry_path);
+
+        global_store.insert_module(normalized_entry_path.to_string(), module);
+
+        Self {
+            entry: normalized_entry_path.to_string(),
+            output: output_path.to_string(),
+        }
+    }
+
+    pub fn extract_statements_map(
+        &self,
+        global_store: &GlobalStore
+    ) -> HashMap<String, Vec<Statement>> {
+        global_store.modules
+            .iter()
+            .map(|(path, module)| (path.clone(), module.statements.clone()))
+            .collect()
+    }
+
+    pub fn load_single_module(&self, global_store: &mut GlobalStore) -> Result<Module, String> {
+        let mut module = global_store.modules
+            .remove(&self.entry)
+            .ok_or_else(|| format!("Module not found in store for path: {}", self.entry))?;
+
+        // SECTION Lexing the module content
+        let lexer = Lexer::new();
+        let tokens = lexer
+            .lex_from_source(&module.content)
+            .map_err(|e| format!("Lexer failed: {}", e))?;
+
+        module.tokens = tokens.clone();
+
+        // SECTION Parsing tokens into statements
+        let mut parser = Parser::new();
+        parser.set_current_module(self.entry.clone());
+        let statements = parser.parse_tokens(tokens, global_store);
+        module.statements = statements;
+
+        // SECTION Error handling
+        let mut error_handler = ErrorHandler::new();
+        error_handler.detect_from_statements(&mut parser, &module.statements);
+
+        global_store.modules.insert(self.entry.clone(), module.clone());
+
+        Ok(module)
+    }
+
+    #[cfg(feature = "cli")]
+    pub fn load_all_modules(
         &self,
         global_store: &mut GlobalStore
     ) -> (HashMap<String, Vec<Token>>, HashMap<String, Vec<Statement>>) {
@@ -44,6 +104,7 @@ impl ModuleLoader {
         (tokens_by_module, statemnts_by_module)
     }
 
+    #[cfg(feature = "cli")]
     fn load_module_recursively(
         &self,
         path: &str,
@@ -95,6 +156,7 @@ impl ModuleLoader {
         tokens_by_module
     }
 
+    #[cfg(feature = "cli")]
     fn load_module_imports(&self, path: &String, global_store: &mut GlobalStore) {
         let imports = global_store.modules
             .get(path)

package/rust/core/preprocessor/module.rs

@@ -18,6 +18,7 @@ pub struct Module {
     pub variable_table: VariableTable,
     pub export_table: ExportTable,
     pub import_table: ImportTable,
+    pub content: String,
 }
 
 impl Module {
@@ -30,6 +31,7 @@ impl Module {
             export_table: ExportTable::new(),
             import_table: ImportTable::new(),
             resolved: false,
+            content: String::new(),
         }
     }
 

package/rust/core/preprocessor/processor.rs

@@ -1,6 +1,8 @@
+use std::collections::HashMap;
+
 use crate::core::{
     parser::{ statement::StatementKind, Parser },
-    preprocessor::loader::ModuleLoader,
+    preprocessor::{ loader::ModuleLoader, resolver::group },
     shared::value::Value,
     store::global::GlobalStore,
 };
@@ -33,7 +35,31 @@ pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalSt
                         module.import_table.add_import(name.clone(), Value::String(source.clone()));
                     }
                 }
-                
+
+                StatementKind::Group => {
+                    if let Value::Map(map) = &stmt.value {
+                        if
+                            let (Some(Value::String(name)), Some(Value::Block(body))) = (
+                                map.get("identifier"),
+                                map.get("body"),
+                            )
+                        {
+                            let mut stored_map = HashMap::new();
+
+                            stored_map.insert(
+                                "identifier".to_string(),
+                                Value::String(name.clone())
+                            );
+
+                            stored_map.insert("body".to_string(), Value::Block(body.clone()));
+
+                            module.variable_table.set(name.to_string(), Value::Map(stored_map));
+                        } else {
+                            eprintln!("❌ Invalid group definition: {:?}", stmt.value);
+                        }
+                    }
+                }
+
                 _ => {}
             }
         }

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

@@ -1,9 +1,12 @@
-use crate::{core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::module::Module,
-    shared::value::Value,
-    store::global::GlobalStore,
-}, utils::logger::Logger};
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::module::Module,
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
 
 pub fn resolve_bank(
     stmt: &Statement,
@@ -28,9 +31,7 @@ pub fn resolve_bank(
             }
         }
 
-        Value::String(_) => {
-            // Pas de résolution nécessaire
-        }
+        Value::String(_) => {}
 
         other => {
             let message = format!("Expected a string or identifier for bank, found {:?}", other);

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

@@ -0,0 +1,113 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::trigger::resolve_trigger },
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_group(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    if let Value::Map(value_map) = &stmt.value {
+        let group_name = match value_map.get("identifier") {
+            Some(Value::String(name)) => name.clone(),
+            Some(other) => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    format!("Group name must be a string, found {:?}", other)
+                );
+                return stmt.clone();
+            }
+            None => {
+                log_type_error(&logger, module, stmt, "Group name is required".to_string());
+                return stmt.clone();
+            }
+        };
+
+        let body_value = match value_map.get("body") {
+            Some(Value::Block(block)) => {
+                let mut resolved_block = Vec::new();
+                for ref statement in block.clone() {
+                    match &statement.kind {
+                        StatementKind::Trigger { entity, duration } => {
+                            let resolved = resolve_trigger(
+                                &mut statement.clone(),
+                                &entity,
+                                &mut duration.clone(),
+                                module,
+                                path,
+                                global_store
+                            );
+                            resolved_block.push(resolved);
+                        }
+                        _ => {
+                            println!("Unhandled group body statement: {:?}", statement);
+                        }
+                    }
+                }
+                Value::Block(resolved_block)
+            }
+            Some(other) => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    format!("Unexpected value for group body: {:?}", other)
+                );
+                Value::Null
+            }
+            None => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    "Missing 'body' key in group statement map".to_string()
+                );
+                Value::Null
+            }
+        };
+
+        let mut resolved_map = HashMap::new();
+
+        resolved_map.insert("identifier".to_string(), Value::String(group_name));
+        resolved_map.insert("body".to_string(), body_value);
+
+        return Statement {
+            kind: StatementKind::Group,
+            value: Value::Map(resolved_map),
+            ..stmt.clone()
+        };
+    } else {
+        log_type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Expected Map for group statement, found {:?}", stmt.value)
+        );
+
+        Statement {
+            kind: StatementKind::Error {
+                message: "Expected a map for group statement".to_string(),
+            },
+            value: Value::Null,
+            ..stmt.clone()
+        }
+    }
+}
+
+fn log_type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) {
+    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+    logger.log_error_with_stacktrace(&message, &stacktrace);
+}

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

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
@@ -16,9 +18,7 @@ pub fn resolve_loop(
 ) -> Statement {
     let logger = Logger::new();
 
-    // Vérifie que stmt.value est bien une Map
     if let Value::Map(value_map) = &stmt.value {
-        // Résolution de l'iterator
         let iterator_value = match value_map.get("iterator") {
             Some(Value::Identifier(ident)) => {
                 match module.variable_table.get(ident) {
@@ -33,13 +33,18 @@ pub fn resolve_loop(
                         Value::Null
                     }
                     None => {
-                        log_type_error(
-                            &logger,
-                            module,
-                            stmt,
-                            format!("Loop iterator '{ident}' not found")
-                        );
-                        Value::Null
+                        // Value is not a variable so we assume it's a number
+                        if let Ok(n) = ident.parse::<f32>() {
+                            Value::Number(n)
+                        } else {
+                            log_type_error(
+                                &logger,
+                                module,
+                                stmt,
+                                format!("Loop iterator '{ident}' is not a valid number")
+                            );
+                            Value::Null
+                        }
                     }
                 }
             }
@@ -64,7 +69,6 @@ pub fn resolve_loop(
             }
         };
 
-        // Résolution du body
         let body_value = match value_map.get("body") {
             Some(Value::Block(block)) => {
                 let mut resolved_block = Vec::new();
@@ -108,12 +112,10 @@ pub fn resolve_loop(
             }
         };
 
-        // ✅ Reconstruit proprement la valeur résolue
-        let mut resolved_map = std::collections::HashMap::new();
+        let mut resolved_map = HashMap::new();
         resolved_map.insert("iterator".to_string(), iterator_value);
         resolved_map.insert("body".to_string(), body_value);
 
-        // ✅ Reconstruit le StatementLoop à partir des éléments résolus
         Statement {
             kind: StatementKind::Loop,
             value: Value::Map(resolved_map),

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

@@ -2,6 +2,7 @@ pub mod trigger;
 pub mod loop_;
 pub mod bank;
 pub mod tempo;
+pub mod group;
 
 use std::collections::HashMap;
 use crate::{
@@ -11,6 +12,7 @@ use crate::{
             loader::ModuleLoader,
             resolver::{
                 bank::resolve_bank,
+                group::resolve_group,
                 loop_::resolve_loop,
                 tempo::resolve_tempo,
                 trigger::resolve_trigger,
@@ -63,9 +65,9 @@ pub fn resolve_and_flatten_all_modules(
     global_store: &mut GlobalStore
 ) -> HashMap<String, Vec<Statement>> {
     let logger = Logger::new();
-    let snapshot = global_store.clone(); // pour éviter les emprunts mutables
+    let snapshot = global_store.clone();
 
-    // 1. Résolution des imports
+    // 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 {
@@ -96,8 +98,8 @@ pub fn resolve_and_flatten_all_modules(
         }
     }
 
-    // 2. Résolution des statements
-    let mut resolved_map = HashMap::new();
+    // 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 {
@@ -135,10 +137,14 @@ pub fn resolve_and_flatten_all_modules(
                 }
 
                 StatementKind::Import { .. } | StatementKind::Export { .. } => {
-                    // Rien à faire
                     resolved.push(stmt.clone());
                 }
 
+                StatementKind::Group => {
+                    let resolved_stmt = resolve_group(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
+
                 _ => {
                     resolved.push(stmt);
                 }

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

@@ -38,7 +38,6 @@ pub fn resolve_trigger(
         };
     }
 
-    // ✅ 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 {
@@ -56,7 +55,6 @@ pub fn resolve_trigger(
         }
     }
 
-    // ✅ Résolution de value (params, effets)
     final_value = match &stmt.value {
         Value::Identifier(ident) => {
             match module.variable_table.get(ident) {
@@ -87,7 +85,6 @@ pub fn resolve_trigger(
         other => other.clone(),
     };
 
-    // ✅ On reconstruit le Statement avec Trigger résolu
     if let StatementKind::Trigger { entity, .. } = &stmt.kind {
         return Statement {
             kind: StatementKind::Trigger {

package/rust/lib.rs

@@ -0,0 +1,117 @@
+pub mod core;
+pub mod utils;
+pub mod config;
+
+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,8 +1,9 @@
+#![cfg(feature = "cli")]
+
 pub mod core;
 pub mod cli;
 pub mod utils;
 pub mod config;
-pub mod audio;
 
 use std::io;
 use cli::{ Cli };

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()
+    }
 }