@tishlang/tish-format 1.0.12 → 1.0.13

package/crates/tish_runtime/src/native_promise.rs

@@ -0,0 +1,15 @@
+//! Native Promise entrypoints for fetch / fetchAll.
+
+use tishlang_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)
+}

package/crates/tish_runtime/src/promise.rs

@@ -0,0 +1,248 @@
+//! Promise helpers for the bytecode VM and native codegen (`Promise.resolve`, etc.).
+//!
+//! The global `Promise` value is an **object** with a `__call` entry so the VM can
+//! invoke `Promise(executor)` like `new Promise(executor)` in JS. Static methods live
+//! on the same object (`resolve`, `reject`, `all`, `race`).
+
+use std::sync::mpsc;
+use std::sync::{Arc, Mutex};
+
+use tishlang_core::{ObjectMap, TishPromise, Value, VmRef};
+
+/// Fulfilled or rejected before anyone awaits — `block_until_settled` consumes the result once.
+pub struct ImmediateSettledPromise {
+    slot: Mutex<Option<Result<Value, Value>>>,
+}
+
+impl ImmediateSettledPromise {
+    fn new(result: Result<Value, Value>) -> Self {
+        Self {
+            slot: Mutex::new(Some(result)),
+        }
+    }
+}
+
+impl TishPromise for ImmediateSettledPromise {
+    fn block_until_settled(&self) -> std::result::Result<Value, Value> {
+        self.slot
+            .lock()
+            .unwrap()
+            .take()
+            .unwrap_or(Err(Value::String(
+                "Promise already settled or consumed".into(),
+            )))
+    }
+}
+
+fn fulfilled(v: Value) -> Value {
+    Value::Promise(Arc::new(ImmediateSettledPromise::new(Ok(v))))
+}
+
+fn rejected(v: Value) -> Value {
+    Value::Promise(Arc::new(ImmediateSettledPromise::new(Err(v))))
+}
+
+fn flatten_chain_out(v: Value) -> std::result::Result<Value, Value> {
+    match v {
+        Value::Promise(p) => p.block_until_settled(),
+        other => Ok(other),
+    }
+}
+
+/// `Promise(executor)` — executor runs synchronously; `resolve` / `reject` unblock `recv`.
+struct DeferredChannelPromise {
+    rx: Mutex<Option<mpsc::Receiver<Result<Value, Value>>>>,
+}
+
+impl TishPromise for DeferredChannelPromise {
+    fn block_until_settled(&self) -> std::result::Result<Value, Value> {
+        let rx = self.rx.lock().unwrap().take();
+        match rx {
+            Some(r) => r.recv().unwrap_or(Err(Value::String(
+                "Promise executor did not call resolve or reject".into(),
+            ))),
+            None => Err(Value::String(
+                "Promise already consumed or settled".into(),
+            )),
+        }
+    }
+}
+
+/// `.then` / `.catch` chain: when awaited, settle the predecessor then optionally invoke a handler.
+pub struct ThenPromise {
+    pred: Arc<dyn TishPromise>,
+    on_fulfilled: Option<Value>,
+    on_rejected: Option<Value>,
+}
+
+impl TishPromise for ThenPromise {
+    fn block_until_settled(&self) -> std::result::Result<Value, Value> {
+        match self.pred.block_until_settled() {
+            Ok(v) => {
+                if let Some(Value::Function(f)) = &self.on_fulfilled {
+                    flatten_chain_out(f(&[v]))
+                } else {
+                    Ok(v)
+                }
+            }
+            Err(e) => {
+                if let Some(Value::Function(f)) = &self.on_rejected {
+                    flatten_chain_out(f(&[e]))
+                } else {
+                    Err(e)
+                }
+            }
+        }
+    }
+}
+
+/// `Promise.resolve(value)` — adopt promises, otherwise wrap in a fulfilled promise.
+pub fn promise_resolve(args: &[Value]) -> Value {
+    match args.first() {
+        Some(Value::Promise(p)) => Value::Promise(Arc::clone(p)),
+        Some(v) => fulfilled(v.clone()),
+        None => fulfilled(Value::Null),
+    }
+}
+
+/// `Promise.reject(reason)` — always a rejected promise.
+pub fn promise_reject(args: &[Value]) -> Value {
+    rejected(
+        args.first()
+            .cloned()
+            .unwrap_or(Value::Null),
+    )
+}
+
+/// `Promise.all(iterable)` — block on each promise in order; non-promises pass through.
+pub fn promise_all(args: &[Value]) -> Value {
+    match args.first() {
+        Some(Value::Array(arr)) => {
+            let mut out: Vec<Value> = Vec::new();
+            for v in arr.borrow().iter() {
+                let item = if let Value::Promise(p) = v {
+                    match p.block_until_settled() {
+                        Ok(x) => x,
+                        Err(rej) => return rejected(rej),
+                    }
+                } else {
+                    v.clone()
+                };
+                out.push(item);
+            }
+            fulfilled(Value::Array(VmRef::new(out)))
+        }
+        Some(v) => fulfilled(v.clone()),
+        None => fulfilled(Value::Null),
+    }
+}
+
+/// `Promise.race(iterable)` — first element wins (blocking first promise if it is one).
+pub fn promise_race(args: &[Value]) -> Value {
+    match args.first() {
+        Some(Value::Array(arr)) => {
+            let borrowed = arr.borrow();
+            for v in borrowed.iter() {
+                if let Value::Promise(p) = v {
+                    return match p.block_until_settled() {
+                        Ok(x) => fulfilled(x),
+                        Err(e) => rejected(e),
+                    };
+                }
+                return fulfilled(v.clone());
+            }
+            Value::Null
+        }
+        Some(v) => fulfilled(v.clone()),
+        None => Value::Null,
+    }
+}
+
+/// Build the global `Promise` object: `__call` (constructor) + static methods.
+pub fn promise_object() -> Value {
+    let mut map: ObjectMap = ObjectMap::default();
+
+    let ctor = Value::native(|args: &[Value]| match args.first() {
+        Some(Value::Function(f)) => {
+            let (tx, rx) = mpsc::channel();
+            let tx_cell = Arc::new(Mutex::new(Some(tx)));
+            let resolve = Value::native({
+                let tx_cell = Arc::clone(&tx_cell);
+                move |a: &[Value]| {
+                    if let Some(t) = tx_cell.lock().unwrap().take() {
+                        let _ = t.send(Ok(
+                            a.first().cloned().unwrap_or(Value::Null),
+                        ));
+                    }
+                    Value::Null
+                }
+            });
+            let reject = Value::native({
+                let tx_cell = Arc::clone(&tx_cell);
+                move |a: &[Value]| {
+                    if let Some(t) = tx_cell.lock().unwrap().take() {
+                        let _ = t.send(Err(
+                            a.first().cloned().unwrap_or(Value::Null),
+                        ));
+                    }
+                    Value::Null
+                }
+            });
+            let _ = f(&[resolve, reject]);
+            Value::Promise(Arc::new(DeferredChannelPromise {
+                rx: Mutex::new(Some(rx)),
+            }))
+        }
+        _ => Value::Null,
+    });
+
+    map.insert(Arc::from("__call"), ctor);
+    map.insert(
+        Arc::from("resolve"),
+        Value::native(|args: &[Value]| promise_resolve(args)),
+    );
+    map.insert(
+        Arc::from("reject"),
+        Value::native(|args: &[Value]| promise_reject(args)),
+    );
+    map.insert(
+        Arc::from("all"),
+        Value::native(|args: &[Value]| promise_all(args)),
+    );
+    map.insert(
+        Arc::from("race"),
+        Value::native(|args: &[Value]| promise_race(args)),
+    );
+    Value::object(map)
+}
+
+/// `.then(onFulfilled, onRejected)` for a `Value::Promise` instance (VM `GetMember`).
+pub fn promise_instance_then(p: &Arc<dyn TishPromise>, args: &[Value]) -> Value {
+    Value::Promise(Arc::new(ThenPromise {
+        pred: Arc::clone(p),
+        on_fulfilled: args.first().cloned(),
+        on_rejected: args.get(1).cloned(),
+    }))
+}
+
+/// `.catch(onRejected)` for a `Value::Promise` instance.
+pub fn promise_instance_catch(p: &Arc<dyn TishPromise>, args: &[Value]) -> Value {
+    Value::Promise(Arc::new(ThenPromise {
+        pred: Arc::clone(p),
+        on_fulfilled: None,
+        on_rejected: args.first().cloned(),
+    }))
+}
+
+/// Unwrap a settled [`Value::Promise`], or pass non-promise values through (VM `AwaitPromise` /
+/// `tish:http.await`). Fetch promises still require the `http` feature.
+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_io.rs

@@ -0,0 +1,38 @@
+//! Promises carrying only Send payloads (string results for text(), etc.).
+
+use std::sync::{Arc, Mutex};
+use tishlang_core::{ObjectMap, TishPromise, Value};
+use tokio::sync::oneshot;
+
+fn error_value(msg: String) -> Value {
+    let mut obj: ObjectMap = ObjectMap::with_capacity(2);
+    obj.insert(Arc::from("error"), Value::String(msg.into()));
+    obj.insert(Arc::from("ok"), Value::Bool(false));
+    Value::object(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,166 @@
+//! setTimeout, setInterval, clearTimeout, clearInterval 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 tishlang_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.
+#[allow(dead_code)] // Used by embedders with blocking poll loops; AppKit uses [`drain_timers`] instead.
+pub fn sleep_with_drain(ms: u64) {
+    run_due_timers();
+    std::thread::sleep(Duration::from_millis(ms));
+}
+
+/// Run all due timer callbacks (e.g. from an AppKit / GUI event pump).
+#[inline]
+pub fn drain_timers() {
+    run_due_timers();
+}
+
+/// Run all due timer callbacks (including timers scheduled by other timers).
+fn run_due_timers() {
+    for _ in 0..64 {
+        let due = take_due_timers();
+        if due.is_empty() {
+            break;
+        }
+        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)
+}
+
+/// setInterval(callback, intervalMs, ...args) — first run after `intervalMs`, then repeats.
+pub fn set_interval(args: &[Value]) -> Value {
+    let callback = args.first().cloned().unwrap_or(Value::Null);
+    let interval_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(interval_ms);
+    REGISTRY.with(|r| {
+        r.borrow_mut().insert(
+            id,
+            TimerEntry {
+                due,
+                callback,
+                args: extra_args,
+                interval_ms,
+            },
+        );
+    });
+    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
+}
+
+/// clearInterval(id) — same registry as clearTimeout.
+pub fn clear_interval(args: &[Value]) -> Value {
+    clear_timeout(args)
+}