@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.2

package/rust/core/audio/interpreter/{sleep.rs → statements/sleep.rs}

@@ -1,28 +1,28 @@
-use crate::core::parser::statement::Statement;
-use devalang_types::Value;
-
-pub fn interprete_sleep_statement(
-    stmt: &Statement,
-    cursor_time: f32,
-    max_end_time: f32,
-) -> (f32, f32) {
-    let duration_secs = match &stmt.value {
-        Value::Number(ms) => *ms / 1000.0,
-        Value::String(s) if s.ends_with("ms") => s
-            .trim_end_matches("ms")
-            .parse::<f32>()
-            .map(|ms| ms / 1000.0)
-            .unwrap_or_else(|_| {
-                eprintln!("❌ Invalid sleep value (ms): {}", s);
-                0.0
-            }),
-        other => {
-            eprintln!("❌ Invalid sleep value: {:?}", other);
-            0.0
-        }
-    };
-
-    let new_cursor = cursor_time + duration_secs;
-    let new_max = max_end_time.max(new_cursor);
-    (new_cursor, new_max)
-}
+use crate::core::parser::statement::Statement;
+use devalang_types::Value;
+
+pub fn interprete_sleep_statement(
+    stmt: &Statement,
+    cursor_time: f32,
+    max_end_time: f32,
+) -> (f32, f32) {
+    let duration_secs = match &stmt.value {
+        Value::Number(ms) => *ms / 1000.0,
+        Value::String(s) if s.ends_with("ms") => s
+            .trim_end_matches("ms")
+            .parse::<f32>()
+            .map(|ms| ms / 1000.0)
+            .unwrap_or_else(|_| {
+                eprintln!("❌ Invalid sleep value (ms): {}", s);
+                0.0
+            }),
+        other => {
+            eprintln!("❌ Invalid sleep value: {:?}", other);
+            0.0
+        }
+    };
+
+    let new_cursor = cursor_time + duration_secs;
+    let new_max = max_end_time.max(new_cursor);
+    (new_cursor, new_max)
+}

package/rust/core/audio/interpreter/{spawn.rs → statements/spawn.rs}

@@ -3,8 +3,9 @@ use devalang_types::{Duration, Value};
 use crate::core::{
     audio::{engine::AudioEngine, interpreter::driver::execute_audio_block},
     parser::statement::{Statement, StatementKind},
-    store::{function::FunctionTable, global::GlobalStore, variable::VariableTable},
+    store::global::GlobalStore,
 };
+use devalang_types::store::{FunctionTable, VariableTable};
 
 pub fn interprete_spawn_statement(
     stmt: &Statement,
@@ -79,7 +80,7 @@ pub fn interprete_spawn_statement(
                 }
 
                 let final_variable_table = if let Some(parent) = &variable_table.parent {
-                    crate::core::store::variable::VariableTable {
+                    devalang_types::VariableTable {
                         variables: parent.variables.clone(),
                         parent: None,
                     }

package/rust/core/audio/interpreter/{tempo.rs → statements/tempo.rs}

@@ -1,40 +1,40 @@
-use crate::core::parser::statement::{Statement, StatementKind};
-use devalang_types::Value;
-use devalang_utils::logger::{LogLevel, Logger};
-
-pub fn interprete_tempo_statement(stmt: &Statement) -> Option<(f32, f32)> {
-    if let StatementKind::Tempo = &stmt.kind {
-        match &stmt.value {
-            Value::Number(bpm) => {
-                let bpm = { *bpm };
-                let duration = 60.0 / bpm;
-
-                return Some((bpm, duration));
-            }
-
-            Value::String(bpm_str) => {
-                if let Ok(bpm) = bpm_str.parse::<f32>() {
-                    let duration = 60.0 / bpm;
-                    return Some((bpm, duration));
-                }
-            }
-
-            Value::Identifier(bpm_ident) => {
-                if let Ok(bpm) = bpm_ident.parse::<f32>() {
-                    let duration = 60.0 / bpm;
-                    return Some((bpm, duration));
-                }
-            }
-
-            _ => {
-                let logger = Logger::new();
-                logger.log_message(
-                    LogLevel::Warning,
-                    format!("Invalid tempo value: {:?}", stmt.value).as_str(),
-                );
-            }
-        }
-    }
-
-    None
-}
+use crate::core::parser::statement::{Statement, StatementKind};
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
+
+pub fn interprete_tempo_statement(stmt: &Statement) -> Option<(f32, f32)> {
+    if let StatementKind::Tempo = &stmt.kind {
+        match &stmt.value {
+            Value::Number(bpm) => {
+                let bpm = { *bpm };
+                let duration = 60.0 / bpm;
+
+                return Some((bpm, duration));
+            }
+
+            Value::String(bpm_str) => {
+                if let Ok(bpm) = bpm_str.parse::<f32>() {
+                    let duration = 60.0 / bpm;
+                    return Some((bpm, duration));
+                }
+            }
+
+            Value::Identifier(bpm_ident) => {
+                if let Ok(bpm) = bpm_ident.parse::<f32>() {
+                    let duration = 60.0 / bpm;
+                    return Some((bpm, duration));
+                }
+            }
+
+            _ => {
+                let logger = Logger::new();
+                logger.log_message(
+                    LogLevel::Warning,
+                    format!("Invalid tempo value: {:?}", stmt.value).as_str(),
+                );
+            }
+        }
+    }
+
+    None
+}

package/rust/core/audio/interpreter/{trigger.rs → statements/trigger.rs}

@@ -3,8 +3,8 @@ use std::collections::HashMap;
 use crate::core::{
     audio::{engine::AudioEngine, loader::trigger::load_trigger},
     parser::statement::{Statement, StatementKind},
-    store::variable::VariableTable,
 };
+use devalang_types::store::VariableTable;
 use devalang_types::{Duration, Value};
 use devalang_utils::logger::Logger;
 

package/rust/core/audio/loader/trigger.rs

@@ -1,4 +1,5 @@
-use crate::core::{parser::statement::StatementKind, store::variable::VariableTable};
+use crate::core::parser::statement::StatementKind;
+use devalang_types::store::VariableTable;
 use devalang_types::{Duration, Value};
 
 pub fn load_trigger(

package/rust/core/audio/mod.rs

@@ -1,7 +1,6 @@
-pub mod engine;
-pub mod evaluator;
-pub mod interpreter;
-pub mod loader;
-pub mod player;
-pub mod renderer;
-pub mod special;
+pub mod engine;
+pub mod evaluator;
+pub mod interpreter;
+pub mod loader;
+pub mod player;
+pub mod special;

package/rust/core/audio/player.rs

@@ -1,70 +1,70 @@
-use rodio::{Decoder, OutputStream, OutputStreamHandle, Sink, Source};
-use std::{fs::File, io::BufReader};
-
-pub struct AudioPlayer {
-    _stream: OutputStream,
-    handle: OutputStreamHandle,
-    sink: Sink,
-    last_path: Option<String>,
-}
-
-impl Default for AudioPlayer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl AudioPlayer {
-    pub fn new() -> Self {
-        let (stream, handle) = OutputStream::try_default().unwrap();
-        let sink = Sink::try_new(&handle).unwrap();
-
-        Self {
-            _stream: stream,
-            handle,
-            sink,
-            last_path: None,
-        }
-    }
-
-    fn load_source(&self, path: &str) -> Option<impl Source<Item = f32> + Send + 'static> {
-        if let Ok(file) = File::open(path) {
-            let reader = BufReader::new(file);
-            match Decoder::new(reader) {
-                Ok(decoder) => Some(decoder.convert_samples()),
-                Err(e) => {
-                    eprintln!("❌ Failed to decode audio file '{}': {}", path, e);
-                    None
-                }
-            }
-        } else {
-            eprintln!("❌ Could not open audio file: {}", path);
-            None
-        }
-    }
-
-    pub fn play_file_once(&mut self, path: &str) {
-        self.sink.stop();
-        self.sink = Sink::try_new(&self.handle).unwrap();
-        self.sink.set_volume(1.0);
-
-        if let Some(source) = self.load_source(path) {
-            self.sink.append(source);
-            self.last_path = Some(path.to_string());
-        } else {
-            eprintln!("⚠️ Skipping playback: failed to load '{}'", path);
-        }
-    }
-
-    pub fn replay_last(&mut self) {
-        if let Some(path) = self.last_path.clone() {
-            self.play_file_once(&path);
-        } else {
-            eprintln!("⚠️ No previous audio to replay.");
-        }
-    }
-
-    pub fn wait_until_end(&self) {
-        self.sink.sleep_until_end();
-    }
-}
+use rodio::{Decoder, OutputStream, OutputStreamHandle, Sink, Source};
+use std::{fs::File, io::BufReader};
+
+pub struct AudioPlayer {
+    _stream: OutputStream,
+    handle: OutputStreamHandle,
+    sink: Sink,
+    last_path: Option<String>,
+}
+
+impl Default for AudioPlayer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AudioPlayer {
+    pub fn new() -> Self {
+        let (stream, handle) = OutputStream::try_default().unwrap();
+        let sink = Sink::try_new(&handle).unwrap();
+
+        Self {
+            _stream: stream,
+            handle,
+            sink,
+            last_path: None,
+        }
+    }
+
+    fn load_source(&self, path: &str) -> Option<impl Source<Item = f32> + Send + 'static> {
+        if let Ok(file) = File::open(path) {
+            let reader = BufReader::new(file);
+            match Decoder::new(reader) {
+                Ok(decoder) => Some(decoder.convert_samples()),
+                Err(e) => {
+                    eprintln!("❌ Failed to decode audio file '{}': {}", path, e);
+                    None
+                }
+            }
+        } else {
+            eprintln!("❌ Could not open audio file: {}", path);
+            None
+        }
+    }
+
+    pub fn play_file_once(&mut self, path: &str) {
+        self.sink.stop();
+        self.sink = Sink::try_new(&self.handle).unwrap();
+        self.sink.set_volume(1.0);
+
+        if let Some(source) = self.load_source(path) {
+            self.sink.append(source);
+            self.last_path = Some(path.to_string());
+        } else {
+            eprintln!("⚠️ Skipping playback: failed to load '{}'", path);
+        }
+    }
+
+    pub fn replay_last(&mut self) {
+        if let Some(path) = self.last_path.clone() {
+            self.play_file_once(&path);
+        } else {
+            eprintln!("⚠️ No previous audio to replay.");
+        }
+    }
+
+    pub fn wait_until_end(&self) {
+        self.sink.sleep_until_end();
+    }
+}