@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

package/rust/core/preprocessor/loader.rs

@@ -1,193 +0,0 @@
-use std::{ collections::HashMap, path::Path };
-use crate::{
-    core::{
-        error::ErrorHandler,
-        lexer::{ token::Token, Lexer },
-        parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-        preprocessor::{ module::Module, processor::process_modules },
-        store::global::GlobalStore,
-        utils::path::normalize_path,
-    },
-    utils::logger::Logger,
-};
-use crate::core::preprocessor::resolver::driver::{
-    resolve_all_modules,
-    resolve_and_flatten_all_modules,
-};
-use crate::core::utils::path::resolve_relative_path;
-
-pub struct ModuleLoader {
-    pub entry: String,
-    pub output: String,
-    pub base_dir: String,
-}
-
-impl ModuleLoader {
-    pub fn new(entry: &str, output: &str) -> Self {
-        let base_dir = Path::new(entry)
-            .parent()
-            .unwrap_or(Path::new(""))
-            .to_string_lossy()
-            .replace('\\', "/");
-
-        Self {
-            entry: entry.to_string(),
-            output: output.to_string(),
-            base_dir: base_dir,
-        }
-    }
-
-    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();
-
-        global_store.insert_module(normalized_entry_path.to_string(), module);
-
-        Self {
-            entry: normalized_entry_path.to_string(),
-            output: output_path.to_string(),
-            base_dir: "".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>>) {
-        // SECTION Load the entry module and its dependencies
-
-        let tokens_by_module = self.load_module_recursively(&self.entry, global_store);
-
-        // SECTION Process and resolve modules
-        process_modules(self, global_store);
-        resolve_all_modules(self, global_store);
-
-        let statemnts_by_module = resolve_and_flatten_all_modules(global_store);
-
-        (tokens_by_module, statemnts_by_module)
-    }
-
-    #[cfg(feature = "cli")]
-    fn load_module_recursively(
-        &self,
-        raw_path: &str,
-        global_store: &mut GlobalStore
-    ) -> HashMap<String, Vec<Token>> {
-        let path = normalize_path(raw_path);
-
-        // Check if already loaded
-        if global_store.modules.contains_key(&path) {
-            return HashMap::new();
-        }
-
-        let lexer = Lexer::new();
-        let tokens = lexer.lex_tokens(&path);
-
-        let mut parser = Parser::new();
-        parser.set_current_module(path.clone());
-
-        let statements = parser.parse_tokens(tokens.clone(), global_store);
-
-        // Error handling
-        let mut error_handler = ErrorHandler::new();
-        error_handler.detect_from_statements(&mut parser, &statements);
-
-        if error_handler.has_errors() {
-            let logger = Logger::new();
-            for error in error_handler.get_errors() {
-                let trace = format!("{}:{}:{}", path, error.line, error.column);
-                logger.log_error_with_stacktrace(&error.message, &trace);
-            }
-        }
-
-        // Insert module into store
-        let mut module = Module::new(&path);
-        module.tokens = tokens.clone();
-        module.statements = statements.clone();
-        global_store.insert_module(path.clone(), module);
-
-        // Load dependencies
-        self.load_module_imports(&path, global_store);
-
-        // Return tokens per module
-        global_store.modules
-            .iter()
-            .map(|(p, m)| (p.clone(), m.tokens.clone()))
-            .collect()
-    }
-
-    #[cfg(feature = "cli")]
-    fn load_module_imports(&self, path: &String, global_store: &mut GlobalStore) {
-        let import_paths: Vec<String> = {
-            let current_module = match global_store.modules.get(path) {
-                Some(module) => module,
-                None => {
-                    eprintln!("[warn] Cannot resolve imports: module '{}' not found in store", path);
-                    return;
-                }
-            };
-
-            current_module.statements
-                .iter()
-                .filter_map(|stmt| {
-                    if let StatementKind::Import { source, .. } = &stmt.kind {
-                        Some(source.clone())
-                    } else {
-                        None
-                    }
-                })
-                .collect()
-        };
-
-        for import_path in import_paths {
-            let resolved = resolve_relative_path(path, &import_path);
-            self.load_module_recursively(&resolved, global_store);
-        }
-    }
-}

package/rust/core/preprocessor/processor.rs

@@ -1,76 +0,0 @@
-use std::{ collections::HashMap, path::Path };
-
-use crate::core::{
-    parser::{ driver::Parser, statement::StatementKind },
-    preprocessor::{ loader::ModuleLoader, resolver::group },
-    shared::value::Value,
-    store::global::GlobalStore,
-    utils::path::{normalize_path, resolve_relative_path},
-};
-
-pub fn process_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
-    for module in global_store.modules.values_mut() {
-        for stmt in &module.statements {
-            match &stmt.kind {
-                StatementKind::Let { name } => {
-                    module.variable_table.variables.insert(name.clone(), stmt.value.clone());
-                }
-
-                StatementKind::Load { source, alias } => {
-                    let module_dir = Path::new(&module.path).parent().unwrap_or(Path::new(""));
-
-                    let resolved_path = normalize_path(&module_dir.join(source));
-
-                    module.variable_table.variables.insert(
-                        alias.clone(),
-                        Value::Sample(resolved_path)
-                    );
-                }
-
-                StatementKind::Export { names, source } => {
-                    for name in names {
-                        if let Some(val) = module.variable_table.get(name) {
-                            module.export_table.add_export(name.clone(), val.clone());
-                        }
-                    }
-                }
-
-                StatementKind::Import { names, source } => {
-                    let resolved = resolve_relative_path(&module.path, source);
-                    for name in names {
-                        module.import_table.add_import(
-                            name.clone(),
-                            Value::String(resolved.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/shared/duration.rs

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

package/rust/core/shared/mod.rs

@@ -1,2 +0,0 @@
-pub mod value;
-pub mod duration;

package/rust/core/shared/value.rs

@@ -1,18 +0,0 @@
-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),
-    Unknown,
-    Null,
-}

package/rust/core/store/export.rs

@@ -1,28 +0,0 @@
-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/import.rs

@@ -1,28 +0,0 @@
-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/variable.rs

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

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

package/rust/core/utils/path.rs

@@ -1,31 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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/utils/file.rs

@@ -1,35 +0,0 @@
-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/signature.rs

@@ -1,17 +0,0 @@
-pub fn get_signature(version: &str) -> String {
-    let signature =
-        format!(r#"
-   /|_/|                    
-  / ^ ^(_o                  🦊 Devalang
- /    __.'                  
- /     \                    A programming language for music and sound.
-/  _   \_                   Part of Devaloop project.
-(_) (_) '._                 
-  '.__     '. .-''-'.       https://devaloop.com
-     ( '.   ('.____.''
-     _) )'_, )              v{}
-    (__/ (__/
-"#, version);
-
-    signature
-}

package/rust/utils/version.rs

@@ -1,15 +0,0 @@
-use crate::utils::signature::get_signature;
-
-pub fn get_version() -> &'static str {
-    let version: &str = env!("CARGO_PKG_VERSION");
-    version
-}
-
-pub fn get_version_with_signature() -> &'static str {
-    let version = get_version();
-    let signature = get_signature(version);
-
-    println!("{}", signature);
-
-    "(c) 2025 Devaloop. All rights reserved."
-}

package/typescript/scripts/postbuild.ts

@@ -1,8 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-const source = path.join(__dirname, "..", "..", "target", "release", "devalang.exe");
-const destination = path.join(__dirname, "..", "bin", "devalang.exe");
-
-fs.copyFileSync(source, destination);
-fs.chmodSync(destination, 0o755);