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

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/lib.rs

@@ -1 +1,161 @@
-// TODO WebAssembly support
+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::{
+    audio::{ engine::AudioEngine, interpreter::driver::{ run_audio_program } },
+    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))) }
+    }
+}
+
+#[wasm_bindgen]
+pub fn render_audio(user_code: &str) -> Result<js_sys::Float32Array, JsValue> {
+    let entry_path = normalize_path("playground.deva");
+    let output_path = normalize_path("./temp");
+
+    let mut global_store = GlobalStore::new();
+
+    let loader = ModuleLoader::from_raw_source(
+        &entry_path,
+        &output_path,
+        user_code,
+        &mut global_store
+    );
+
+    loader
+        .load_wasm_module(&mut global_store)
+        .map_err(|e| JsValue::from_str(&format!("Module loading error: {}", e)))?;
+
+    let all_statements_map = loader.extract_statements_map(&global_store);
+
+    let main_statements = all_statements_map
+        .get(&entry_path)
+        .ok_or(JsValue::from_str("❌ No statements found for entry module"))?
+        .clone();
+
+    let audio_engine = AudioEngine::new("wasm_output".to_string());
+
+    let (final_engine, _, _) = run_audio_program(
+        &main_statements,
+        audio_engine,
+        "playground".to_string(),
+        "wasm_output".to_string()
+    );
+
+    let samples = final_engine.get_normalized_buffer();
+
+    if samples.is_empty() {
+        return Err(JsValue::from_str("❌ Audio buffer is empty"));
+    }
+
+    Ok(js_sys::Float32Array::from(samples.as_slice()))
+}
+
+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,48 +1,64 @@
+#![cfg(feature = "cli")]
+
 pub mod core;
 pub mod cli;
-pub mod runner;
-pub mod audio;
 pub mod utils;
+pub mod config;
 
-use std::{ io };
+use std::io;
+use cli::{ Cli };
 use clap::Parser;
 use crate::{
-    cli::{ build::handle_build_command, check::handle_check_command },
-    core::types::cli::{ Cli, CliCommands },
+    cli::{
+        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,
+    },
+    config::{ loader::load_config, Config },
 };
 
 fn main() -> io::Result<()> {
-    let cli = Cli::parse();
+    let cli: Cli = Cli::parse();
+    let mut config: Option<Config> = None;
+
+    if !cli.no_config {
+        config = load_config(None);
+    } else {
+        println!("No configuration file loaded. Running with arguments only.");
+    }
 
     match cli.command {
-        // TODO - Implement the new command
-        // CliCommands::New { name, template } => {
-        //     log_message("Command 'new project' is not implemented yet.", "WARNING");
-        // }
-
-        // TODO - Implement the template command
-        // CliCommands::Template { command } =>
-        //     match command {
-        //         CliTemplateCommand::List => {
-        //             log_message("Command 'template list' is not implemented yet.", "WARNING");
-        //         }
-        //         CliTemplateCommand::Info { name } => {
-        //             log_message("Command 'template info' is not implemented yet.", "WARNING");
-        //         }
-        //     }
-
-        CliCommands::Build { entry, output, watch, compilation_mode, debug, compress } => {
-            handle_build_command(entry, output);
+        Commands::Init { name, template } => {
+            handle_init_command(name, template);
+        }
+
+        Commands::Template { command } =>
+            match command {
+                TemplateCommand::List => {
+                    handle_template_list_command();
+                }
+                TemplateCommand::Info { name } => {
+                    handle_template_info_command(name);
+                }
+            }
+
+        Commands::Check { entry, output, watch, compilation_mode, debug } => {
+            handle_check_command(config, entry, output, watch);
+        }
+
+        Commands::Build { entry, output, watch, compilation_mode, debug, compress } => {
+            handle_build_command(config, entry, output, watch);
         }
 
-        CliCommands::Check { entry, output, watch, compilation_mode, debug } => {
-            handle_check_command(entry, output);
+        Commands::Play { entry, output, watch, repeat } => {
+            handle_play_command(config, entry, output, watch, repeat);
         }
 
-        // TODO - Implement the play command
-        // CliCommands::Play {} => {
-        //     log_message("Command 'play' is not implemented yet.", "WARNING");
-        // }
+        _ => {}
     }
 
     Ok(())

package/rust/utils/file.rs

@@ -0,0 +1,35 @@
+use std::{ fs::{ self }, path::Path };
+use include_dir::{ Dir, DirEntry };
+
+pub fn copy_dir_recursive(dir: &Dir, target_root: &Path, base_path: &Path) {
+    for entry in dir.entries() {
+        match entry {
+            DirEntry::Dir(subdir) => {
+                copy_dir_recursive(subdir, target_root, base_path);
+            }
+            DirEntry::File(file) => {
+                let rel_path = file.path().strip_prefix(base_path).unwrap();
+                let dest_path = target_root.join(rel_path);
+
+                if let Some(parent) = dest_path.parent() {
+                    fs::create_dir_all(parent).unwrap();
+                }
+
+                fs::write(&dest_path, file.contents()).expect("Error writing file");
+            }
+        }
+    }
+}
+
+pub fn format_file_size(bytes: u64) -> String {
+    const KB: u64 = 1024;
+    const MB: u64 = 1024 * 1024;
+
+    if bytes >= MB {
+        format!("{:.2} Mb", (bytes as f64) / (MB as f64))
+    } else if bytes >= KB {
+        format!("{:.2} Kb", (bytes as f64) / (KB as f64))
+    } else {
+        format!("{} bytes", bytes)
+    }
+}

package/rust/utils/logger.rs

@@ -1,49 +1,123 @@
+#[cfg(feature = "cli")]
 use crossterm::style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor};
-use std::{ fmt::Write };
+use std::fmt::Write;
 
-pub fn log_message(message: &str, status: &str) {
-    let formatted_status = format_status(status);
-    println!("🦊 {} {} {}", language_signature(), formatted_status, message);
+#[derive(Debug, Clone, PartialEq)]
+pub enum LogLevel {
+    Success,
+    Error,
+    Info,
+    Warning,
+    Watcher,
+    Debug,
 }
 
-fn language_signature() -> String {
-    let mut s = String::new();
+#[derive(Debug, Clone)]
+pub struct Logger;
 
-    write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
-    s.push('[');
+impl Logger {
+    pub fn new() -> Self {
+        Logger
+    }
 
-    write!(&mut s, "{}", SetForegroundColor(Color::Rgb { r: 29, g: 211, b: 176 })).unwrap();
-    write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
-    s.push_str("Devalang");
-    write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+    // --- log_message ---
 
-    write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
-    s.push(']');
+    #[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);
+    }
 
-    write!(&mut s, "{}", ResetColor).unwrap();
+    #[cfg(not(feature = "cli"))]
+    pub fn log_message(&self, _level: LogLevel, _message: &str) {
+        // no-op for WASM
+    }
 
-    s
-}
+    // --- 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();
+
+        write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
+        s.push('[');
+
+        write!(&mut s, "{}", SetForegroundColor(Color::Rgb { r: 29, g: 211, b: 176 })).unwrap();
+        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
+        s.push_str("Devalang");
+        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+
+        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();
 
-fn format_status(status: &str) -> String {
-    let mut s = String::new();
+        let color = match level {
+            LogLevel::Success => Color::Rgb { r: 76, g: 175, b: 80 },
+            LogLevel::Error => Color::Rgb { r: 244, g: 67, b: 54 },
+            LogLevel::Info => Color::Rgb { r: 33, g: 150, b: 243 },
+            LogLevel::Warning => Color::Rgb { r: 255, g: 152, b: 0 },
+            LogLevel::Watcher => Color::Rgb { r: 156, g: 39, b: 176 },
+            LogLevel::Debug => Color::Rgb { r: 103, g: 58, b: 183 },
+        };
 
-    let color = match status {
-        "SUCCESS" => Color::Rgb { r: 76, g: 175, b: 80 },
-        "ERROR" => Color::Rgb { r: 244, g: 67, b: 54 },
-        "INFO" => Color::Rgb { r: 33, g: 150, b: 243 },
-        "WARNING" => Color::Rgb { r: 255, g: 152, b: 0 },
-        _ => Color::Grey,
-    };
+        let status = match level {
+            LogLevel::Success => "SUCCESS",
+            LogLevel::Error => "ERROR",
+            LogLevel::Info => "INFO",
+            LogLevel::Warning => "WARNING",
+            LogLevel::Watcher => "WATCHER",
+            LogLevel::Debug => "DEBUG",
+        };
 
-    s.push('[');
-    write!(&mut s, "{}", SetForegroundColor(color)).unwrap();
-    write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
-    s.push_str(status);
-    write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
-    s.push(']');
+        s.push('[');
+        write!(&mut s, "{}", SetForegroundColor(color)).unwrap();
+        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
+        s.push_str(status);
+        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+        s.push(']');
+        write!(&mut s, "{}", ResetColor).unwrap();
 
-    write!(&mut s, "{}", ResetColor).unwrap();
+        s
+    }
 
-    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/mod.rs

@@ -1,5 +1,6 @@
 pub mod version;
 pub mod signature;
-pub mod path;
-pub mod loader;
+pub mod spinner;
+pub mod watcher;
+pub mod file;
 pub mod logger;

package/rust/utils/{loader.rs → 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

@@ -0,0 +1,33 @@
+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
+{
+    let (tx, rx) = channel();
+
+    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(_) => {
+                let now = Instant::now();
+                if now.duration_since(last_trigger) > Duration::from_millis(200) {
+                    callback();
+                    last_trigger = now;
+                }
+            }
+            Err(e) => {
+                eprintln!("Channel error: {:?}", e);
+                break;
+            }
+        }
+    }
+
+    Ok(())
+}

package/templates/minimal/.devalang

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