@tishlang/tish-format 1.0.12 → 1.0.13

package/crates/tish_builtins/src/globals.rs

@@ -0,0 +1,213 @@
+//! Global builtin functions with signature (args: &[Value]) -> Value.
+//!
+//! Used by both tishlang_vm (bytecode) and tishlang_runtime (compiled). Keeps tishlang_vm
+//! independent of tishlang_runtime.
+
+use std::sync::Arc;
+use tishlang_core::VmRef;
+use tishlang_core::{percent_decode, percent_encode, ObjectMap, Value};
+
+/// Boolean(value) - coerce to bool
+pub fn boolean(args: &[Value]) -> Value {
+    let v = args.first().unwrap_or(&Value::Null);
+    Value::Bool(v.is_truthy())
+}
+
+/// decodeURI(str)
+pub fn decode_uri(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    Value::String(percent_decode(&s).unwrap_or(s).into())
+}
+
+/// encodeURI(str)
+pub fn encode_uri(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    Value::String(percent_encode(&s).into())
+}
+
+/// isFinite(value)
+pub fn is_finite(args: &[Value]) -> Value {
+    Value::Bool(
+        args.first()
+            .is_some_and(|v| matches!(v, Value::Number(n) if n.is_finite())),
+    )
+}
+
+/// isNaN(value)
+pub fn is_nan(args: &[Value]) -> Value {
+    Value::Bool(args.first().is_none_or(|v| {
+        matches!(v, Value::Number(n) if n.is_nan()) || !matches!(v, Value::Number(_))
+    }))
+}
+
+/// Array.isArray(value)
+pub fn array_is_array(args: &[Value]) -> Value {
+    Value::Bool(matches!(args.first(), Some(Value::Array(_))))
+}
+
+/// String(value) — convert value to string (JS String constructor as function).
+pub fn string_convert(args: &[Value]) -> Value {
+    let v = args.first().unwrap_or(&Value::Null);
+    Value::String(v.to_display_string().into())
+}
+
+/// String.fromCharCode(...codes)
+pub fn string_from_char_code(args: &[Value]) -> Value {
+    let s: String = args
+        .iter()
+        .filter_map(|v| match v {
+            Value::Number(n) => char::from_u32(*n as u32),
+            _ => None,
+        })
+        .collect();
+    Value::String(s.into())
+}
+
+/// Object.keys(obj)
+pub fn object_keys(args: &[Value]) -> Value {
+    if let Some(Value::Object(obj)) = args.first() {
+        let obj_borrow = obj.borrow();
+        let keys: Vec<Value> = obj_borrow
+            .strings
+            .keys()
+            .map(|k| Value::String(Arc::clone(k)))
+            .collect();
+        Value::Array(VmRef::new(keys))
+    } else {
+        Value::Array(VmRef::new(Vec::new()))
+    }
+}
+
+/// Object.values(obj)
+pub fn object_values(args: &[Value]) -> Value {
+    if let Some(Value::Object(obj)) = args.first() {
+        let obj_borrow = obj.borrow();
+        let values: Vec<Value> = obj_borrow.strings.values().cloned().collect();
+        Value::Array(VmRef::new(values))
+    } else {
+        Value::Array(VmRef::new(Vec::new()))
+    }
+}
+
+/// Object.entries(obj)
+pub fn object_entries(args: &[Value]) -> Value {
+    if let Some(Value::Object(obj)) = args.first() {
+        let obj_borrow = obj.borrow();
+        let entries: Vec<Value> = obj_borrow
+            .strings
+            .iter()
+            .map(|(k, v)| Value::Array(VmRef::new(vec![Value::String(Arc::clone(k)), v.clone()])))
+            .collect();
+        Value::Array(VmRef::new(entries))
+    } else {
+        Value::Array(VmRef::new(Vec::new()))
+    }
+}
+
+/// Object.assign(target, ...sources)
+pub fn object_assign(args: &[Value]) -> Value {
+    let target = match args.first() {
+        Some(Value::Object(obj)) => obj,
+        _ => return Value::Null,
+    };
+
+    let additional_capacity: usize = args
+        .iter()
+        .skip(1)
+        .map(|source| {
+            if let Value::Object(src) = source {
+                src.borrow().len_entries()
+            } else {
+                0
+            }
+        })
+        .sum();
+
+    let mut target_mut = target.borrow_mut();
+    target_mut.strings.reserve(additional_capacity);
+
+    for source in args.iter().skip(1) {
+        if let Value::Object(src) = source {
+            let src_borrow = src.borrow();
+            for (k, v) in src_borrow.strings.iter() {
+                target_mut.strings.insert(Arc::clone(k), v.clone());
+            }
+            if let Some(ss) = &src_borrow.symbols {
+                if target_mut.symbols.is_none() {
+                    target_mut.symbols = Some(Default::default());
+                }
+                let dst = target_mut.symbols.as_mut().unwrap();
+                dst.extend(ss.iter().map(|(id, v)| (*id, v.clone())));
+            }
+        }
+    }
+    drop(target_mut);
+    Value::Object(target.clone())
+}
+
+/// parseInt(string, radix?)
+pub fn parse_int(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    let s = s.trim();
+    let radix = args
+        .get(1)
+        .and_then(|v| match v {
+            Value::Number(n) => Some(*n as i32),
+            _ => None,
+        })
+        .unwrap_or(10);
+
+    if (2..=36).contains(&radix) {
+        let prefix: String = s
+            .chars()
+            .take_while(|c| *c == '-' || *c == '+' || c.is_digit(radix as u32))
+            .collect();
+        if let Ok(n) = i64::from_str_radix(&prefix, radix as u32) {
+            return Value::Number(n as f64);
+        }
+    }
+    Value::Number(f64::NAN)
+}
+
+/// parseFloat(string)
+pub fn parse_float(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    Value::Number(s.trim().parse().unwrap_or(f64::NAN))
+}
+
+/// Object.fromEntries(entries)
+pub fn object_from_entries(args: &[Value]) -> Value {
+    if let Some(Value::Array(entries)) = args.first() {
+        let entries_borrow = entries.borrow();
+        let mut obj: ObjectMap = ObjectMap::with_capacity(entries_borrow.len());
+
+        for entry in entries_borrow.iter() {
+            if let Value::Array(pair) = entry {
+                let pair_borrow = pair.borrow();
+                if pair_borrow.len() >= 2 {
+                    let key: Arc<str> = match &pair_borrow[0] {
+                        Value::String(s) => Arc::clone(s),
+                        v => v.to_display_string().into(),
+                    };
+                    obj.insert(key, pair_borrow[1].clone());
+                }
+            }
+        }
+
+        Value::object(obj)
+    } else {
+        Value::empty_object()
+    }
+}

package/crates/tish_builtins/src/helpers.rs

@@ -0,0 +1,35 @@
+//! Common helper functions used across builtin implementations.
+
+use std::sync::Arc;
+use tishlang_core::{ObjectMap, Value};
+
+/// Normalize an array index, handling negative indices.
+/// Returns a valid index within bounds or the default value.
+pub fn normalize_index(idx: &Value, len: i64, default: usize) -> usize {
+    match idx {
+        Value::Number(n) => {
+            let n = *n as i64;
+            if n < 0 {
+                (len + n).max(0) as usize
+            } else {
+                n.min(len) as usize
+            }
+        }
+        _ => default,
+    }
+}
+
+/// Create an error object with a single "error" field.
+pub fn make_error_value(e: impl std::fmt::Display) -> Value {
+    let mut obj = ObjectMap::with_capacity(1);
+    obj.insert(Arc::from("error"), Value::String(e.to_string().into()));
+    Value::object(obj)
+}
+
+/// Extract a number from a Value, returning None for non-numbers.
+pub fn extract_num(v: Option<&Value>) -> Option<f64> {
+    v.and_then(|val| match val {
+        Value::Number(n) => Some(*n),
+        _ => None,
+    })
+}

package/crates/tish_builtins/src/lib.rs

@@ -0,0 +1,16 @@
+//! Shared builtin implementations for Tish.
+//!
+//! Used by the compiled runtime (tishlang_runtime) and bytecode VM (tishlang_vm). The
+//! interpreter (tishlang_eval) implements builtins inline due to different Value
+//! and native signatures.
+
+pub mod array;
+pub mod construct;
+pub mod globals;
+pub mod helpers;
+pub mod math;
+pub mod object;
+pub mod string;
+pub mod symbol;
+
+pub use tishlang_core::Value;

package/crates/tish_builtins/src/math.rs

@@ -0,0 +1,89 @@
+//! Math builtin functions.
+
+use crate::helpers::extract_num;
+use tishlang_core::Value;
+
+macro_rules! math_unary {
+    ($name:ident, $op:ident) => {
+        pub fn $name(args: &[Value]) -> Value {
+            let n = extract_num(args.first()).unwrap_or(f64::NAN);
+            Value::Number(n.$op())
+        }
+    };
+}
+
+math_unary!(abs, abs);
+math_unary!(sqrt, sqrt);
+math_unary!(floor, floor);
+math_unary!(ceil, ceil);
+math_unary!(round, round);
+math_unary!(sin, sin);
+math_unary!(cos, cos);
+math_unary!(tan, tan);
+math_unary!(asin, asin);
+math_unary!(acos, acos);
+math_unary!(atan, atan);
+math_unary!(log, ln);
+math_unary!(log10, log10);
+math_unary!(log2, log2);
+math_unary!(exp, exp);
+math_unary!(trunc, trunc);
+math_unary!(cbrt, cbrt);
+
+pub fn min(args: &[Value]) -> Value {
+    let n = args
+        .iter()
+        .filter_map(|v| extract_num(Some(v)))
+        .fold(f64::INFINITY, f64::min);
+    Value::Number(if n == f64::INFINITY { f64::NAN } else { n })
+}
+
+pub fn max(args: &[Value]) -> Value {
+    let n = args
+        .iter()
+        .filter_map(|v| extract_num(Some(v)))
+        .fold(f64::NEG_INFINITY, f64::max);
+    Value::Number(if n == f64::NEG_INFINITY { f64::NAN } else { n })
+}
+
+pub fn pow(args: &[Value]) -> Value {
+    let base = extract_num(args.first()).unwrap_or(f64::NAN);
+    let exp = extract_num(args.get(1)).unwrap_or(f64::NAN);
+    Value::Number(base.powf(exp))
+}
+
+pub fn random(_args: &[Value]) -> Value {
+    Value::Number(rand::random::<f64>())
+}
+
+pub fn sign(args: &[Value]) -> Value {
+    let n = extract_num(args.first()).unwrap_or(f64::NAN);
+    Value::Number(if n.is_nan() {
+        f64::NAN
+    } else if n > 0.0 {
+        1.0
+    } else if n < 0.0 {
+        -1.0
+    } else {
+        0.0
+    })
+}
+
+pub fn atan2(args: &[Value]) -> Value {
+    let y = extract_num(args.first()).unwrap_or(f64::NAN);
+    let x = extract_num(args.get(1)).unwrap_or(f64::NAN);
+    Value::Number(y.atan2(x))
+}
+
+pub fn hypot(args: &[Value]) -> Value {
+    let x = extract_num(args.first()).unwrap_or(0.0);
+    let y = extract_num(args.get(1)).unwrap_or(0.0);
+    Value::Number(x.hypot(y))
+}
+
+/// ES6 `Math.imul`: 32-bit integer multiply (used by xmur3 PRNG in juke-cards).
+pub fn imul(args: &[Value]) -> Value {
+    let a = extract_num(args.first()).unwrap_or(0.0) as i32;
+    let b = extract_num(args.get(1)).unwrap_or(0.0) as i32;
+    Value::Number(a.wrapping_mul(b) as f64)
+}

package/crates/tish_builtins/src/object.rs

@@ -0,0 +1,36 @@
+//! Object builtin methods.
+//!
+//! This module will contain shared object method implementations.
+//! Functions will be migrated here from tishlang_runtime and tishlang_eval.
+
+use std::sync::Arc;
+use tishlang_core::{ObjectData, ObjectMap, Value, VmRef};
+
+/// Create a new empty object Value.
+pub fn new() -> Value {
+    Value::empty_object()
+}
+
+/// Create a new object Value with a given capacity.
+pub fn with_capacity(capacity: usize) -> Value {
+    Value::Object(VmRef::new(ObjectData {
+        strings: ObjectMap::with_capacity(capacity),
+        symbols: None,
+    }))
+}
+
+/// Get the keys of an object (string keys only; matches `Object.keys` in JS).
+pub fn keys(obj: &Value) -> Option<Vec<Arc<str>>> {
+    match obj {
+        Value::Object(map) => Some(map.borrow().strings.keys().cloned().collect()),
+        _ => None,
+    }
+}
+
+/// Get the values of an object (string-keyed properties only).
+pub fn values(obj: &Value) -> Option<Vec<Value>> {
+    match obj {
+        Value::Object(map) => Some(map.borrow().strings.values().cloned().collect()),
+        _ => None,
+    }
+}