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

package/rust/cli/play.rs

@@ -1,193 +0,0 @@
-use crate::{
-    config::Config,
-    core::{
-        builder::Builder,
-        debugger::{ lexer::write_lexer_log_file, preprocessor::write_preprocessor_log_file },
-        preprocessor::loader::ModuleLoader,
-        store::global::GlobalStore,
-        utils::path::{ find_entry_file, normalize_path },
-    },
-    utils::{ logger::{ LogLevel, Logger }, spinner::with_spinner, watcher::watch_directory },
-};
-
-use std::{ path::Path, sync::mpsc::channel, thread, time::Duration };
-use std::fs;
-use std::collections::HashMap;
-
-#[cfg(feature = "cli")]
-pub fn handle_play_command(
-    config: Option<Config>,
-    entry: Option<String>,
-    output: Option<String>,
-    watch: bool,
-    repeat: bool
-) {
-    use crate::core::audio::player::AudioPlayer;
-
-    let logger = Logger::new();
-
-    let entry_path = entry
-        .or_else(|| config.as_ref().and_then(|c| c.defaults.entry.clone()))
-        .unwrap_or_else(|| "".to_string());
-
-    let output_path = output
-        .or_else(|| config.as_ref().and_then(|c| c.defaults.output.clone()))
-        .unwrap_or_else(|| "".to_string());
-
-    let fetched_repeat = if repeat {
-        true
-    } else {
-        config
-            .as_ref()
-            .and_then(|c| c.defaults.repeat)
-            .unwrap_or(false)
-    };
-
-    if entry_path.is_empty() || output_path.is_empty() {
-        logger.log_message(LogLevel::Error, "Entry or output path not specified.");
-        std::process::exit(1);
-    }
-
-    let entry_file = find_entry_file(&entry_path).unwrap_or_else(|| {
-        logger.log_message(LogLevel::Error, "index.deva not found");
-        std::process::exit(1);
-    });
-
-    let audio_file = format!("{}/audio/index.wav", normalize_path(&output_path));
-    let mut audio_player = AudioPlayer::new();
-
-    if watch && fetched_repeat {
-        logger.log_message(
-            LogLevel::Error,
-            "Watch and repeat cannot be used together. Use repeat instead."
-        );
-        std::process::exit(1);
-    }
-
-    if watch {
-        let (tx, rx) = channel::<()>();
-
-        // Thread 1 : Watcher sending changes
-        let entry_clone = entry_path.clone();
-        thread::spawn(move || {
-            let _ = watch_directory(entry_clone, move || {
-                let _ = tx.send(()); // signal a change
-            });
-        });
-
-        // Main thread: build + play in a loop
-        begin_play(&config, &entry_file, &output_path);
-        audio_player.play_file_once(&audio_file);
-
-        logger.log_message(LogLevel::Watcher, "Watching for changes... Press Ctrl+C to exit.");
-
-        while let Ok(_) = rx.recv() {
-            logger.log_message(LogLevel::Watcher, "Change detected, rebuilding...");
-
-            begin_play(&config, &entry_file, &output_path);
-
-            logger.log_message(LogLevel::Info, "🎵 Playback started (once mode)...");
-
-            audio_player.play_file_once(&audio_file);
-        }
-    } else if fetched_repeat {
-        // Initial build to start from a clean slate
-        begin_play(&config, &entry_file, &output_path);
-
-        logger.log_message(LogLevel::Info, "🎵 Playback started (repeat mode)...");
-
-        let mut last_snapshot = snapshot_files(&entry_path);
-        let mut audio_player = AudioPlayer::new();
-        audio_player.play_file_once(&audio_file);
-
-        loop {
-            let current_snapshot = snapshot_files(&entry_path);
-            let has_changed = files_changed(&last_snapshot, &current_snapshot);
-
-            if has_changed {
-                logger.log_message(LogLevel::Info, "Change detected, rebuilding in background...");
-                let entry_file = entry_file.clone();
-                let output_path = output_path.clone();
-                let config_clone = config.clone();
-
-                // Rebuild in a separate thread
-                std::thread::spawn(move || {
-                    begin_play(&config_clone, &entry_file, &output_path);
-                });
-
-                last_snapshot = current_snapshot;
-            }
-
-            // Wait for the audio to finish without blocking the current playback
-            audio_player.wait_until_end();
-
-            // Then replay the audio (rebuilt or not)
-            audio_player.play_file_once(&audio_file);
-        }
-    } else {
-        // Single execution
-        begin_play(&config, &entry_file, &output_path);
-        
-        logger.log_message(LogLevel::Info, "🎵 Playback started (once mode)...");
-
-        audio_player.play_file_once(&audio_file);
-        audio_player.wait_until_end();
-    }
-}
-
-fn begin_play(config: &Option<Config>, entry_file: &str, output: &str) {
-    let spinner = with_spinner("Building...", || {
-        thread::sleep(Duration::from_millis(800));
-    });
-
-    let normalized_entry = normalize_path(entry_file);
-    let normalized_output_dir = normalize_path(&output);
-
-    let duration = std::time::Instant::now();
-    let mut global_store = GlobalStore::new();
-    let loader = ModuleLoader::new(&normalized_entry, &normalized_output_dir);
-    let (modules_tokens, modules_statements) = loader.load_all_modules(&mut global_store);
-
-    // SECTION Write logs
-    write_lexer_log_file(&normalized_output_dir, "lexer_tokens.log", modules_tokens.clone());
-    write_preprocessor_log_file(
-        &normalized_output_dir,
-        "resolved_statements.log",
-        modules_statements.clone()
-    );
-
-    // SECTION Building AST and Audio
-    let builder = Builder::new();
-    builder.build_ast(&modules_statements, &output);
-    builder.build_audio(&modules_statements, &output, &mut global_store);
-
-    // SECTION Logging
-    let logger = Logger::new();
-    let success_message = format!(
-        "Build completed successfully in {:.2?}. Output files written to: '{}'",
-        duration.elapsed(),
-        normalized_output_dir
-    );
-
-    logger.log_message(LogLevel::Success, &success_message);
-}
-
-fn snapshot_files<P: AsRef<Path>>(dir: P) -> HashMap<String, u64> {
-    let mut map = HashMap::new();
-    if let Ok(entries) = fs::read_dir(dir) {
-        for entry in entries.flatten() {
-            if let Ok(meta) = entry.metadata() {
-                if let Ok(mtime) = meta.modified() {
-                    if let Ok(duration) = mtime.duration_since(std::time::UNIX_EPOCH) {
-                        map.insert(entry.path().display().to_string(), duration.as_secs());
-                    }
-                }
-            }
-        }
-    }
-    map
-}
-
-fn files_changed(old: &HashMap<String, u64>, new: &HashMap<String, u64>) -> bool {
-    old != new
-}

package/rust/config/loader.rs

@@ -1,13 +0,0 @@
-use std::{ fs, path::Path };
-use crate::config::Config;
-
-pub fn load_config(path: Option<&Path>) -> Option<Config> {
-    let config_path = path.unwrap_or_else(|| Path::new(".devalang"));
-
-    if config_path.exists() {
-        let content = fs::read_to_string(config_path).ok()?;
-        toml::from_str(&content).ok()
-    } else {
-        None
-    }
-}

package/rust/core/audio/engine.rs

@@ -1,203 +0,0 @@
-use std::{ collections::HashMap, fs::File, io::BufReader };
-use hound::{ SampleFormat, WavSpec, WavWriter };
-use rodio::{ Decoder, Source };
-
-use crate::core::{
-    store::variable::VariableTable,
-    utils::path::{ normalize_path, resolve_relative_path },
-};
-
-const SAMPLE_RATE: u32 = 44100;
-const CHANNELS: u16 = 2;
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct AudioEngine {
-    pub volume: f32,
-    pub variables: VariableTable,
-    pub buffer: Vec<i16>,
-    pub module_name: String,
-}
-
-impl AudioEngine {
-    pub fn new(module_name: String) -> Self {
-        AudioEngine {
-            volume: 1.0,
-            buffer: vec![],
-            variables: VariableTable::new(),
-            module_name,
-        }
-    }
-
-    pub fn mix(&mut self, other: &AudioEngine) {
-        let max_len = self.buffer.len().max(other.buffer.len());
-        self.buffer.resize(max_len, 0);
-
-        for (i, &sample) in other.buffer.iter().enumerate() {
-            self.buffer[i] = self.buffer[i].saturating_add(sample);
-        }
-    }
-
-    pub fn merge_with(&mut self, other: AudioEngine) {
-        if other.buffer.iter().all(|&s| s == 0) {
-            eprintln!("⚠️ Skipping merge: other buffer is silent");
-            return;
-        }
-
-        if self.buffer.iter().all(|&s| s == 0) {
-            self.buffer = other.buffer;
-            self.variables.variables.extend(other.variables.variables);
-            return;
-        }
-
-        self.mix(&other);
-        self.variables.variables.extend(other.variables.variables);
-    }
-
-    pub fn set_duration(&mut self, duration_secs: f32) {
-        let total_samples = (duration_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
-
-        if self.buffer.len() < total_samples {
-            self.buffer.resize(total_samples, 0);
-        }
-    }
-
-    pub fn set_variables(&mut self, variables: VariableTable) {
-        self.variables = variables;
-    }
-
-    pub fn generate_wav_file(&mut self, output_dir: &String) -> Result<(), String> {
-        if self.buffer.len() % (CHANNELS as usize) != 0 {
-            self.buffer.push(0);
-            println!("Completed buffer to respect stereo format.");
-        }
-
-        let spec = WavSpec {
-            channels: CHANNELS,
-            sample_rate: SAMPLE_RATE,
-            bits_per_sample: 16,
-            sample_format: SampleFormat::Int,
-        };
-
-        let mut writer = WavWriter::create(output_dir, spec).map_err(|e|
-            format!("Error creating WAV file: {}", e)
-        )?;
-
-        for sample in &self.buffer {
-            writer.write_sample(*sample).map_err(|e| format!("Error writing sample: {:?}", e))?;
-        }
-
-        writer.finalize().map_err(|e| format!("Error finalizing WAV: {:?}", e))?;
-
-        Ok(())
-    }
-
-    pub fn insert_note(
-        &mut self,
-        waveform: String,
-        freq: f32,
-        amp: f32,
-        start_time_ms: f32,
-        duration_ms: f32
-    ) {
-        let sample_rate = SAMPLE_RATE as f32;
-        let channels = CHANNELS as usize;
-
-        let total_samples = ((duration_ms / 1000.0) * sample_rate) as usize;
-        let start_sample = ((start_time_ms / 1000.0) * sample_rate) as usize;
-        let amplitude = (i16::MAX as f32) * amp.clamp(0.0, 1.0);
-
-        let mut samples = Vec::with_capacity(total_samples);
-        let fade_len = (sample_rate * 0.01) as usize; // 10 ms fade
-
-        for i in 0..total_samples {
-            let t = ((start_sample + i) as f32) / sample_rate;
-            let phase = 2.0 * std::f32::consts::PI * freq * t;
-
-            let mut value = match waveform.as_str() {
-                "sine" => phase.sin(),
-                "square" => if phase.sin() >= 0.0 { 1.0 } else { -1.0 }
-                "saw" => 2.0 * (freq * t - (freq * t + 0.5).floor()),
-                "triangle" => (2.0 * (2.0 * (freq * t).fract() - 1.0)).abs() * 2.0 - 1.0,
-                _ => 0.0,
-            };
-
-            // Fade in/out
-            if i < fade_len {
-                value *= (i as f32) / (fade_len as f32);
-            } else if i >= total_samples - fade_len {
-                value *= ((total_samples - i) as f32) / (fade_len as f32);
-            }
-
-            samples.push((value * amplitude) as i16);
-        }
-
-        // Convert to stereo
-        let stereo_samples: Vec<i16> = samples
-            .iter()
-            .flat_map(|s| vec![*s, *s])
-            .collect();
-
-        let offset = start_sample * channels;
-        let required_len = offset + stereo_samples.len();
-
-        if self.buffer.len() < required_len {
-            self.buffer.resize(required_len, 0);
-        }
-
-        for (i, sample) in stereo_samples.iter().enumerate() {
-            if *sample != 0 {
-            }
-            self.buffer[offset + i] = self.buffer[offset + i].saturating_add(*sample);
-        }
-    }
-
-    pub fn insert_sample(
-        &mut self,
-        filepath: &str,
-        time_secs: f32,
-        dur_sec: f32,
-        effects: Option<HashMap<String, f32>>
-    ) {
-        let resolved = resolve_relative_path(&self.module_name.clone(), filepath);
-
-        let file = BufReader::new(File::open(resolved).expect("Failed to open audio file"));
-        let decoder = Decoder::new(file).expect("Failed to decode audio file");
-
-        // Mono or stereo reading possible here, we will duplicate in L/R
-        let max_mono_samples = (dur_sec * (SAMPLE_RATE as f32)) as usize;
-        let samples: Vec<i16> = decoder.convert_samples().take(max_mono_samples).collect();
-
-        if samples.is_empty() {
-            eprintln!("No samples found in the audio file: {}", filepath);
-            return;
-        }
-
-        // TODO Apply effects here if needed
-        let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
-        let required_len = offset + samples.len() * (CHANNELS as usize);
-        let padded_required_len = if required_len % 2 == 1 {
-            required_len + 1
-        } else {
-            required_len
-        };
-
-        self.buffer.resize(padded_required_len, 0);
-        self.pad_samples(&samples, time_secs);
-    }
-
-    fn pad_samples(&mut self, samples: &[i16], time_secs: f32) {
-        let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
-
-        for (i, &sample) in samples.iter().enumerate() {
-            let adjusted_sample = ((sample as f32) * self.volume).round() as i16;
-
-            let left_pos = offset + i * 2;
-            let right_pos = left_pos + 1;
-
-            if right_pos < self.buffer.len() {
-                self.buffer[left_pos] = self.buffer[left_pos].saturating_add(adjusted_sample); // gauche
-                self.buffer[right_pos] = self.buffer[right_pos].saturating_add(adjusted_sample); // droite
-            }
-        }
-    }
-}

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/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);