@devaloop/devalang 0.0.1-beta.3 → 0.1.1

package/rust/core/audio/engine/sample/padding.rs

@@ -1,170 +0,0 @@
-use devalang_types::Value;
-use std::collections::HashMap;
-
-pub fn pad_samples_impl(
-    engine: &mut crate::core::audio::engine::driver::AudioEngine,
-    samples: &[i16],
-    time_secs: f32,
-    effects_map: Option<HashMap<String, Value>>,
-) {
-    let sample_rate = engine.sample_rate as f32;
-    let channels = engine.channels as usize;
-
-    let offset = (time_secs * (sample_rate) * (channels as f32)) as usize;
-    let total_samples = samples.len();
-
-    let mut gain = 1.0;
-    let mut pan = 0.0;
-    let mut fade_in = 0.0;
-    let mut fade_out = 0.0;
-    let mut pitch = 1.0;
-    let mut drive = 0.0;
-    let mut reverb = 0.0;
-    let mut delay = 0.0; // delay time in seconds
-    let delay_feedback = 0.35; // default feedback
-
-    if let Some(map) = &effects_map {
-        for (key, val) in map {
-            match (key.as_str(), val) {
-                ("gain", Value::Number(v)) => {
-                    gain = *v;
-                }
-                ("pan", Value::Number(v)) => {
-                    pan = *v;
-                }
-                ("fadeIn", Value::Number(v)) => {
-                    fade_in = *v;
-                }
-                ("fadeOut", Value::Number(v)) => {
-                    fade_out = *v;
-                }
-                ("pitch", Value::Number(v)) => {
-                    pitch = *v;
-                }
-                ("drive", Value::Number(v)) => {
-                    drive = *v;
-                }
-                ("reverb", Value::Number(v)) => {
-                    reverb = *v;
-                }
-                ("delay", Value::Number(v)) => {
-                    delay = *v;
-                }
-                _ => eprintln!("⚠️ Unknown or invalid effect '{}'", key),
-            }
-        }
-    }
-
-    let fade_in_samples = (fade_in * (sample_rate)) as usize;
-    let fade_out_samples = (fade_out * (sample_rate)) as usize;
-
-    // If no fade specified, apply a tiny default fade (2 ms) when sample boundaries are non-zero
-    let default_boundary_fade_ms = 1.0_f32; // 1 ms
-    let default_fade_samples = (default_boundary_fade_ms * (sample_rate)) as usize;
-    let mut effective_fade_in = fade_in_samples;
-    let mut effective_fade_out = fade_out_samples;
-    if effective_fade_in == 0 {
-        if let Some(&first) = samples.first() {
-            if first.abs() > 64 {
-                // increased threshold to detect only strong abrupt starts
-                effective_fade_in = default_fade_samples.max(1);
-            }
-        }
-    }
-    if effective_fade_out == 0 {
-        if let Some(&last) = samples.last() {
-            if last.abs() > 64 {
-                // increased threshold to detect only strong abrupt ends
-                effective_fade_out = default_fade_samples.max(1);
-            }
-        }
-    }
-
-    // Ensure fades do not exceed half the sample length to avoid silencing short samples
-    if total_samples > 0 {
-        let cap = total_samples / 2;
-        if effective_fade_in > cap {
-            effective_fade_in = cap.max(1);
-        }
-        if effective_fade_out > cap {
-            effective_fade_out = cap.max(1);
-        }
-    }
-
-    let delay_samples = if delay > 0.0 {
-        (delay * (sample_rate)) as usize
-    } else {
-        0
-    };
-    let mut delay_buffer: Vec<f32> = vec![0.0; total_samples + delay_samples];
-
-    for i in 0..total_samples {
-        let pitch_index = if pitch != 1.0 {
-            ((i as f32) / pitch) as usize
-        } else {
-            i
-        };
-
-        let mut adjusted = if pitch_index < total_samples {
-            samples[pitch_index] as f32
-        } else {
-            0.0
-        };
-
-        adjusted *= gain;
-
-        if effective_fade_in > 0 && i < effective_fade_in {
-            if effective_fade_in == 1 {
-                adjusted *= 0.0;
-            } else {
-                adjusted *= (i as f32) / (effective_fade_in as f32);
-            }
-        }
-        if effective_fade_out > 0 && i >= total_samples.saturating_sub(effective_fade_out) {
-            if effective_fade_out == 1 {
-                adjusted *= 0.0;
-            } else {
-                adjusted *= ((total_samples - 1 - i) as f32) / ((effective_fade_out - 1) as f32);
-            }
-        }
-
-        if drive > 0.0 {
-            let normalized = adjusted / (i16::MAX as f32);
-            let pre_gain = (10f32).powf(drive / 20.0);
-            let driven = (normalized * pre_gain).tanh();
-            adjusted = driven * (i16::MAX as f32);
-        }
-
-        if delay_samples > 0 && i >= delay_samples {
-            let echo = delay_buffer[i - delay_samples] * delay_feedback;
-            adjusted += echo;
-        }
-        if delay_samples > 0 {
-            delay_buffer[i] = adjusted;
-        }
-
-        if reverb > 0.0 {
-            let reverb_delay = (0.03 * (sample_rate)) as usize;
-            if i >= reverb_delay {
-                adjusted += (engine.buffer[offset + i - reverb_delay] as f32) * reverb;
-            }
-        }
-
-        let adjusted_sample = adjusted.round().clamp(i16::MIN as f32, i16::MAX as f32) as i16;
-
-        let (left_gain, right_gain) = crate::core::audio::engine::helpers::pan_gains(pan);
-
-        let left = ((adjusted_sample as f32) * left_gain) as i16;
-        let right = ((adjusted_sample as f32) * right_gain) as i16;
-
-        // For interleaved buffer with `channels` channels, each frame has `channels` samples.
-        // left channel at frame i is at offset + i * channels, right at +1.
-        let left_pos = offset + i * channels;
-        let right_pos = left_pos + 1;
-
-        if right_pos < engine.buffer.len() {
-            engine.buffer[left_pos] = engine.buffer[left_pos].saturating_add(left);
-            engine.buffer[right_pos] = engine.buffer[right_pos].saturating_add(right);
-        }
-    }
-}

package/rust/core/audio/evaluator/condition.rs

@@ -1,61 +0,0 @@
-use crate::core::audio::special::resolve_env_atom;
-use devalang_types::Value;
-use devalang_types::VariableTable;
-
-pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
-    let tokens: Vec<&str> = expr.split_whitespace().collect();
-    if tokens.len() != 3 {
-        return false;
-    }
-
-    let left = tokens[0];
-    let op = tokens[1];
-    let right = tokens[2];
-
-    // Resolve left and right to numeric values where possible. Accept numbers, variables or env atoms.
-    fn resolve_for_cond(s: &str, vars: &VariableTable) -> Option<f32> {
-        if let Ok(n) = s.parse::<f32>() {
-            return Some(n);
-        }
-        if let Some(Value::Number(n)) = vars.get(s) {
-            return Some(*n);
-        }
-        if let Some(v) = resolve_env_atom(s, 120.0, 1.0) {
-            return Some(v);
-        }
-        None
-    }
-
-    let left_val = match resolve_for_cond(left, vars) {
-        Some(v) => v,
-        None => {
-            return false;
-        }
-    };
-
-    let right_val = match resolve_for_cond(right, vars) {
-        Some(v) => v,
-        None => {
-            return false;
-        }
-    };
-
-    match op {
-        ">" => left_val > right_val,
-        "<" => left_val < right_val,
-        ">=" => left_val >= right_val,
-        "<=" => left_val <= right_val,
-        "==" => {
-            // relative epsilon for floating comparisons
-            let diff = (left_val - right_val).abs();
-            let largest = left_val.abs().max(right_val.abs()).max(1.0);
-            diff <= f32::EPSILON * largest
-        }
-        "!=" => {
-            let diff = (left_val - right_val).abs();
-            let largest = left_val.abs().max(right_val.abs()).max(1.0);
-            diff > f32::EPSILON * largest
-        }
-        _ => false,
-    }
-}

package/rust/core/audio/evaluator/mod.rs

@@ -1,9 +0,0 @@
-pub mod condition;
-pub mod numeric;
-pub mod rhs;
-pub mod string_expr;
-
-pub use condition::evaluate_condition_string;
-pub use numeric::evaluate_numeric_expression;
-pub use rhs::evaluate_rhs_into_value;
-pub use string_expr::evaluate_string_expression;

package/rust/core/audio/evaluator/numeric.rs

@@ -1,152 +0,0 @@
-use crate::core::audio::special::{
-    find_and_eval_first_easing_call, find_and_eval_first_math_call, find_and_eval_first_mod_call,
-    resolve_env_atom,
-};
-use devalang_types::Value;
-use devalang_types::VariableTable;
-
-// Very small expression evaluator for `$env.*`, `$math.*` and variables.
-// Supports: +, -, *, / and simple parentheses, left-to-right (no precedence), and $math.(sin|cos)(expr)
-pub fn evaluate_numeric_expression(
-    expr: &str,
-    vars: &VariableTable,
-    env_bpm: f32,
-    env_beat: f32,
-) -> Option<f32> {
-    let expr = expr.replace(" ", "");
-
-    // Helper to resolve an atom to a number
-    fn resolve_atom(atom: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
-        if let Some(v) = resolve_env_atom(atom, bpm, beat) {
-            return Some(v);
-        }
-        if let Ok(n) = atom.parse::<f32>() {
-            return Some(n);
-        }
-        if let Some(Value::Number(n)) = vars.get(atom) {
-            return Some(*n);
-        }
-        None
-    }
-
-    // Shunting-like, simplified: first evaluate any $math.func(...) calls anywhere in the expression,
-    // then fold remaining parentheses and evaluate left-to-right.
-    fn eval(expr: &str, vars: &VariableTable, bpm: f32, beat: f32) -> Option<f32> {
-        // 1) Replace $math/$easing/$mod calls progressively with a max iteration guard
-        let mut s = expr.to_string();
-        let mut iterations = 0u32;
-        const MAX_ITER: u32 = 64;
-
-        // Evaluate modulators first (they may feed easing/math)
-        while iterations < MAX_ITER {
-            if let Some(next) =
-                find_and_eval_first_mod_call(&s, evaluate_numeric_expression, vars, bpm, beat)
-            {
-                s = next;
-                iterations += 1;
-                continue;
-            }
-            break;
-        }
-
-        iterations = 0;
-        while iterations < MAX_ITER {
-            if let Some(next) =
-                find_and_eval_first_easing_call(&s, evaluate_numeric_expression, vars, bpm, beat)
-            {
-                s = next;
-                iterations += 1;
-                continue;
-            }
-            break;
-        }
-
-        iterations = 0;
-        while iterations < MAX_ITER {
-            if let Some(next) =
-                find_and_eval_first_math_call(&s, evaluate_numeric_expression, vars, bpm, beat)
-            {
-                s = next;
-                iterations += 1;
-                continue;
-            }
-            break;
-        }
-
-        // 2) Evaluate remaining (pure) parentheses starting from innermost
-        if let Some(open) = s.rfind('(') {
-            if let Some(close_rel) = s[open..].find(')') {
-                // index relatif
-                let close = open + close_rel;
-                let inner = &s[open + 1..close];
-                let val = eval(inner, vars, bpm, beat)?;
-                let mut replaced = String::new();
-                replaced.push_str(&s[..open]);
-                replaced.push_str(&val.to_string());
-                replaced.push_str(&s[close + 1..]);
-                return eval(&replaced, vars, bpm, beat);
-            }
-        }
-
-        // Tokenize by operators left-to-right
-        let mut parts: Vec<String> = Vec::new();
-        let mut cur = String::new();
-        for ch in s.chars() {
-            if "+-*/".contains(ch) {
-                if !cur.is_empty() {
-                    parts.push(cur.clone());
-                    cur.clear();
-                }
-                parts.push(ch.to_string());
-            } else {
-                cur.push(ch);
-            }
-        }
-        if !cur.is_empty() {
-            parts.push(cur);
-        }
-        if parts.is_empty() {
-            return None;
-        }
-
-        // Resolve atoms and compute
-        let mut acc: Option<f32> = None;
-        let mut op: Option<char> = None;
-        for part in parts {
-            if part.len() == 1 && "+-*/".contains(part.chars().next().unwrap()) {
-                op = part.chars().next();
-                continue;
-            }
-            let val = if let Some(v) = resolve_atom(&part, vars, bpm, beat) {
-                v
-            } else if part.starts_with("$env.") {
-                // $env atom not handled by resolve_atom (when composed), try recursive eval
-                eval(&part, vars, bpm, beat)?
-            } else {
-                return None;
-            };
-
-            acc = Some(match (acc, op) {
-                (None, _) => val,
-                (Some(a), Some('+')) => a + val,
-                (Some(a), Some('-')) => a - val,
-                (Some(a), Some('*')) => a * val,
-                (Some(a), Some('/')) => {
-                    if val != 0.0 {
-                        a / val
-                    } else {
-                        return Some(f32::INFINITY);
-                    }
-                }
-                (Some(_), None) => val,
-                _ => {
-                    return None;
-                }
-            });
-        }
-
-        acc
-    }
-
-    eval(&expr, vars, env_bpm, env_beat)
-}

package/rust/core/audio/evaluator/rhs.rs

@@ -1,16 +0,0 @@
-use crate::core::audio::evaluator::numeric::evaluate_numeric_expression;
-use devalang_types::Value;
-use devalang_types::VariableTable;
-
-pub fn evaluate_rhs_into_value(
-    raw: &str,
-    vars: &VariableTable,
-    env_bpm: f32,
-    env_beat: f32,
-) -> Value {
-    if let Some(num) = evaluate_numeric_expression(raw, vars, env_bpm, env_beat) {
-        Value::Number(num)
-    } else {
-        Value::String(raw.to_string())
-    }
-}

package/rust/core/audio/evaluator/string_expr.rs

@@ -1,94 +0,0 @@
-use crate::core::audio::evaluator::numeric::evaluate_numeric_expression;
-use devalang_types::Value;
-use devalang_types::VariableTable;
-
-// Evaluate a simple string concatenation expression like: "hello " + name + "!" + $env.beat
-// - Splits on + outside quotes
-// - Terms can be string literals (double quotes), variables (Number/String/Boolean), or numeric env/math expressions
-// Returns None if parsing fails (fallback to raw print)
-pub fn evaluate_string_expression(
-    expr: &str,
-    vars: &VariableTable,
-    env_bpm: f32,
-    env_beat: f32,
-) -> Option<String> {
-    // Quick reject if no '+' present
-    if !expr.contains('+') {
-        return None;
-    }
-
-    // Split by '+' outside of quotes
-    let mut parts: Vec<String> = Vec::new();
-    let mut cur = String::new();
-    let mut in_quotes = false;
-    let mut escape = false;
-    for ch in expr.chars() {
-        if escape {
-            cur.push(ch);
-            escape = false;
-            continue;
-        }
-        if ch == '\\' {
-            // escape next char
-            escape = true;
-            continue;
-        }
-        if ch == '"' {
-            in_quotes = !in_quotes;
-            cur.push(ch);
-            continue;
-        }
-        if ch == '+' && !in_quotes {
-            parts.push(cur.to_string());
-            cur.clear();
-            continue;
-        }
-        cur.push(ch);
-    }
-    if !cur.is_empty() {
-        parts.push(cur.to_string());
-    }
-    if parts.is_empty() {
-        return None;
-    }
-
-    // Resolve each part into a string
-    fn strip_quotes(s: &str) -> Option<String> {
-        let st = s.trim();
-        if st.len() >= 2 && st.starts_with('"') && st.ends_with('"') {
-            Some(st[1..st.len() - 1].to_string())
-        } else {
-            None
-        }
-    }
-
-    let mut out = String::new();
-    for p in parts {
-        if p.is_empty() {
-            continue;
-        }
-        if let Some(lit) = strip_quotes(&p) {
-            out.push_str(&lit);
-            continue;
-        }
-        // Try variables first
-        if let Some(val) = vars.get(&p) {
-            match val {
-                Value::String(s) => out.push_str(s),
-                Value::Number(n) => out.push_str(&format!("{}", n)),
-                Value::Boolean(b) => out.push_str(&format!("{}", b)),
-                other => out.push_str(&format!("{:?}", other)),
-            }
-            continue;
-        }
-        // Try env/math/numeric expression for this term
-        if let Some(n) = evaluate_numeric_expression(&p, vars, env_bpm, env_beat) {
-            out.push_str(&format!("{}", n));
-            continue;
-        }
-        // Bareword not resolved: include as-is (safe fallback)
-        out.push_str(&p);
-    }
-
-    Some(out)
-}