@tishlang/tish 1.0.7 → 1.0.11

package/crates/tish_runtime/src/native_promise.rs

@@ -0,0 +1,26 @@
+//! Native Promise entrypoints for fetch / fetchAll.
+
+use tish_core::Value;
+
+pub fn fetch_promise(args: Vec<Value>) -> Value {
+    crate::http_fetch::fetch_promise_from_args(args)
+}
+
+pub fn fetch_all_promise(args: Vec<Value>) -> Value {
+    crate::http_fetch::fetch_all_promise_from_args(args)
+}
+
+pub fn fetch_async_promise(args: Vec<Value>) -> Value {
+    fetch_promise(args)
+}
+
+pub fn await_promise(v: Value) -> Value {
+    if let Value::Promise(p) = v {
+        match p.block_until_settled() {
+            Ok(val) => val,
+            Err(rejection) => rejection,
+        }
+    } else {
+        v
+    }
+}

package/crates/tish_runtime/src/promise.rs

@@ -0,0 +1,77 @@
+//! Promise static methods for compiled Tish (resolve, reject, all, race).
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::Arc;
+use tish_core::Value;
+
+/// Promise.resolve(value) - returns the value (immediate resolve).
+pub fn promise_resolve(args: &[Value]) -> Value {
+    args.first().cloned().unwrap_or(Value::Null)
+}
+
+/// Promise.reject(value) - returns value as "rejected" placeholder.
+/// Note: await on this in native compile may not throw; use try/catch in interpreter for full support.
+pub fn promise_reject(args: &[Value]) -> Value {
+    args.first().cloned().unwrap_or(Value::Null)
+}
+
+/// Promise.all(iterable) - awaits each Promise in the array, returns array of resolved values.
+pub fn promise_all(args: &[Value]) -> Value {
+    match args.first() {
+        Some(Value::Array(arr)) => {
+            let arr = arr.borrow();
+            let resolved: Vec<Value> = arr
+                .iter()
+                .map(|v| {
+                    if let Value::Promise(p) = v {
+                        match tish_core::TishPromise::block_until_settled(p.as_ref()) {
+                            Ok(val) => val,
+                            Err(rejection) => rejection,
+                        }
+                    } else {
+                        v.clone()
+                    }
+                })
+                .collect();
+            Value::Array(Rc::new(RefCell::new(resolved)))
+        }
+        Some(v) => v.clone(),
+        None => Value::Null,
+    }
+}
+
+/// Promise.race(iterable) - returns first element of array.
+pub fn promise_race(args: &[Value]) -> Value {
+    match args.first() {
+        Some(Value::Array(arr)) => arr
+            .borrow()
+            .first()
+            .cloned()
+            .unwrap_or(Value::Null),
+        _ => Value::Null,
+    }
+}
+
+/// Build the Promise object with resolve, reject, all, race static methods.
+pub fn promise_object() -> Value {
+    let mut map: HashMap<Arc<str>, Value> = HashMap::new();
+    map.insert(
+        Arc::from("resolve"),
+        Value::Function(Rc::new(|args: &[Value]| promise_resolve(args))),
+    );
+    map.insert(
+        Arc::from("reject"),
+        Value::Function(Rc::new(|args: &[Value]| promise_reject(args))),
+    );
+    map.insert(
+        Arc::from("all"),
+        Value::Function(Rc::new(|args: &[Value]| promise_all(args))),
+    );
+    map.insert(
+        Arc::from("race"),
+        Value::Function(Rc::new(|args: &[Value]| promise_race(args))),
+    );
+    Value::Object(Rc::new(RefCell::new(map)))
+}

package/crates/tish_runtime/src/promise_io.rs

@@ -0,0 +1,41 @@
+//! Promises carrying only Send payloads (string results for text(), etc.).
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::sync::{Arc, Mutex};
+use tish_core::{Value, TishPromise};
+use tokio::sync::oneshot;
+
+fn error_value(msg: String) -> Value {
+    let mut obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(2);
+    obj.insert(Arc::from("error"), Value::String(msg.into()));
+    obj.insert(Arc::from("ok"), Value::Bool(false));
+    Value::Object(Rc::new(RefCell::new(obj)))
+}
+
+pub struct StringResultPromise {
+    pub(crate) rx: Mutex<Option<oneshot::Receiver<Result<String, String>>>>,
+}
+
+impl TishPromise for StringResultPromise {
+    fn block_until_settled(&self) -> std::result::Result<Value, Value> {
+        let rx = self.rx.lock().unwrap().take();
+        if let Some(rx) = rx {
+            let result = crate::http::block_on_http(rx);
+            match result {
+                Ok(Ok(s)) => Ok(Value::String(s.into())),
+                Ok(Err(e)) => Err(error_value(e)),
+                Err(_) => Err(Value::String("Promise dropped".into())),
+            }
+        } else {
+            Err(Value::String("Promise already consumed".into()))
+        }
+    }
+}
+
+pub fn string_result_promise(rx: oneshot::Receiver<Result<String, String>>) -> Value {
+    Value::Promise(Arc::new(StringResultPromise {
+        rx: Mutex::new(Some(rx)),
+    }))
+}

package/crates/tish_runtime/src/timers.rs

@@ -0,0 +1,125 @@
+//! setTimeout, clearTimeout for compiled Tish and VM.
+//! Callbacks run when blocking ops (e.g. ws.receiveTimeout) yield in their poll loop.
+
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, Instant};
+
+use tish_core::Value;
+
+static NEXT_ID: AtomicU64 = AtomicU64::new(1);
+
+fn next_id() -> u64 {
+    NEXT_ID.fetch_add(1, Ordering::SeqCst)
+}
+
+struct TimerEntry {
+    due: Instant,
+    callback: Value,
+    args: Vec<Value>,
+    interval_ms: u64,
+}
+
+thread_local! {
+    static REGISTRY: RefCell<HashMap<u64, TimerEntry>> = RefCell::new(HashMap::new());
+}
+
+fn extract_num(v: Option<&Value>) -> u64 {
+    v.and_then(|x| match x {
+        Value::Number(n) if n.is_finite() && *n >= 0.0 => Some(*n as u64),
+        _ => None,
+    })
+    .unwrap_or(0)
+}
+
+/// Sleep for ms, running due timers before sleeping. Use this instead of thread::sleep
+/// in blocking loops so setTimeout callbacks can fire.
+pub fn sleep_with_drain(ms: u64) {
+    run_due_timers();
+    std::thread::sleep(Duration::from_millis(ms));
+}
+
+/// Run all due timer callbacks.
+fn run_due_timers() {
+    let due = take_due_timers();
+    for (id, callback, args, interval_ms) in due {
+        if let Value::Function(f) = &callback {
+            let _ = f(&args);
+        }
+        if interval_ms > 0 {
+            re_register_interval(id, callback, args, interval_ms);
+        }
+    }
+}
+
+fn take_due_timers() -> Vec<(u64, Value, Vec<Value>, u64)> {
+    let now = Instant::now();
+    REGISTRY.with(|r| {
+        let mut reg = r.borrow_mut();
+        let due: Vec<_> = reg
+            .iter()
+            .filter(|(_, e)| e.due <= now)
+            .map(|(id, e)| (*id, e.callback.clone(), e.args.clone(), e.interval_ms))
+            .collect();
+        for (id, _, _, _) in &due {
+            reg.remove(id);
+        }
+        due
+    })
+}
+
+fn re_register_interval(id: u64, callback: Value, args: Vec<Value>, interval_ms: u64) {
+    let due = Instant::now() + Duration::from_millis(interval_ms);
+    REGISTRY.with(|r| {
+        r.borrow_mut().insert(
+            id,
+            TimerEntry {
+                due,
+                callback,
+                args,
+                interval_ms,
+            },
+        );
+    });
+}
+
+/// setTimeout(callback, delayMs, ...args) - returns timer id.
+/// Callbacks run when run_due_timers() is invoked (e.g. from ws.receiveTimeout poll loop).
+pub fn set_timeout(args: &[Value]) -> Value {
+    let callback = args.first().cloned().unwrap_or(Value::Null);
+    let delay_ms = extract_num(args.get(1)).min(3600_000);
+    let extra_args: Vec<Value> = args.iter().skip(2).cloned().collect();
+    if matches!(callback, Value::Null) {
+        return Value::Number(next_id() as f64);
+    }
+    let id = next_id();
+    let due = Instant::now() + Duration::from_millis(delay_ms);
+    REGISTRY.with(|r| {
+        r.borrow_mut().insert(
+            id,
+            TimerEntry {
+                due,
+                callback,
+                args: extra_args,
+                interval_ms: 0,
+            },
+        );
+    });
+    Value::Number(id as f64)
+}
+
+/// clearTimeout(id) - removes timer.
+pub fn clear_timeout(args: &[Value]) -> Value {
+    let id = args
+        .first()
+        .and_then(|v| match v {
+            Value::Number(n) if n.is_finite() && *n >= 0.0 => Some(*n as u64),
+            _ => None,
+        })
+        .unwrap_or(0);
+    REGISTRY.with(|r| {
+        r.borrow_mut().remove(&id);
+    });
+    Value::Null
+}