@tishlang/tish 1.0.29 → 1.0.34

package/crates/tish_parser/src/parser.rs

@@ -53,9 +53,9 @@ macro_rules! binary_multi_op {
 
 use tishlang_ast::{
     ArrowBody, ArrayElement, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern,
-    DestructProp, ExportDeclaration, Expr, ImportSpecifier, JsxAttrValue, JsxChild, JsxProp,
-    Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Span, Statement, TypeAnnotation,
-    TypedParam, UnaryOp,
+    DestructProp, ExportDeclaration, Expr, FunParam, ImportSpecifier, JsxAttrValue, JsxChild,
+    JsxProp, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Span, Statement,
+    TypeAnnotation, TypedParam, UnaryOp,
 };
 use tishlang_lexer::{Token, TokenKind};
 
@@ -363,6 +363,55 @@ impl<'a> Parser<'a> {
         self.expect(TokenKind::RBrace)?;
         Ok(DestructPattern::Object(props))
     }
+
+    /// One formal parameter: `name`, `name: T`, `name = expr`, or a destructuring pattern.
+    fn parse_fun_param(&mut self) -> Result<FunParam, String> {
+        if matches!(
+            self.peek_kind(),
+            Some(TokenKind::LBracket | TokenKind::LBrace)
+        ) {
+            let pattern = self.parse_destruct_pattern()?;
+            let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
+                self.advance();
+                Some(self.parse_type_annotation()?)
+            } else {
+                None
+            };
+            let default = if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
+                self.advance();
+                Some(self.parse_expr()?)
+            } else {
+                None
+            };
+            return Ok(FunParam::Destructure {
+                pattern,
+                type_ann,
+                default,
+            });
+        }
+        let param_name = self
+            .expect(TokenKind::Ident)?
+            .literal
+            .clone()
+            .ok_or("Expected param name")?;
+        let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
+            self.advance();
+            Some(self.parse_type_annotation()?)
+        } else {
+            None
+        };
+        let default = if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
+            self.advance();
+            Some(self.parse_expr()?)
+        } else {
+            None
+        };
+        Ok(FunParam::Simple(TypedParam {
+            name: param_name,
+            type_ann,
+            default,
+        }))
+    }
     
     /// Parse a type annotation (number, string, T[], {a: T}, etc.)
     fn parse_type_annotation(&mut self) -> Result<TypeAnnotation, String> {
@@ -480,26 +529,7 @@ impl<'a> Parser<'a> {
                 }
                 break;
             }
-            let param_name = self
-                .expect(TokenKind::Ident)?
-                .literal
-                .clone()
-                .ok_or("Expected param name")?;
-            // Optional type annotation
-            let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
-                self.advance();
-                Some(self.parse_type_annotation()?)
-            } else {
-                None
-            };
-            // Optional default value
-            let default = if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
-                self.advance();
-                Some(self.parse_expr()?)
-            } else {
-                None
-            };
-            params.push(TypedParam { name: param_name, type_ann, default });
+            params.push(self.parse_fun_param()?);
             if !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
                 self.expect(TokenKind::Comma)?;
             }
@@ -597,6 +627,12 @@ impl<'a> Parser<'a> {
                     span: self.span_end(span_start),
                 });
             }
+            let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
+                self.advance();
+                Some(self.parse_type_annotation()?)
+            } else {
+                None
+            };
             let init_expr = if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
                 self.advance();
                 Some(self.parse_expr()?)
@@ -609,7 +645,7 @@ impl<'a> Parser<'a> {
             Some(Box::new(Statement::VarDecl {
                 name,
                 mutable,
-                type_ann: None, // For-loop variables don't have type annotations (yet)
+                type_ann,
                 init: init_expr,
                 span: self.span_end(var_span_start),
             }))
@@ -1117,8 +1153,97 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn parse_postfix(&mut self) -> Result<Expr, String> {
+    /// Member chain (`.`, `?.`, `[]`) without consuming a call `(...)`.
+    fn parse_member_expression_no_call(&mut self) -> Result<Expr, String> {
         let mut expr = self.parse_primary()?;
+        while let Some(kind) = self.peek_kind() {
+            match kind {
+                TokenKind::Dot | TokenKind::OptionalChain => {
+                    let optional = kind == TokenKind::OptionalChain;
+                    self.advance();
+                    let prop = self
+                        .expect(TokenKind::Ident)?
+                        .literal
+                        .clone()
+                        .ok_or("Expected property name")?;
+                    let start = expr.span().start;
+                    let end = self.peek().map(|x| x.span.start).unwrap_or(start);
+                    expr = Expr::Member {
+                        object: Box::new(expr),
+                        prop: MemberProp::Name(prop),
+                        optional,
+                        span: Span { start, end },
+                    };
+                }
+                TokenKind::LBracket => {
+                    self.advance();
+                    let index = self.parse_expr()?;
+                    self.expect(TokenKind::RBracket)?;
+                    let start = expr.span().start;
+                    let end = self.peek().map(|x| x.span.start).unwrap_or(start);
+                    expr = Expr::Index {
+                        object: Box::new(expr),
+                        index: Box::new(index),
+                        optional: false,
+                        span: Span { start, end },
+                    };
+                }
+                _ => break,
+            }
+        }
+        Ok(expr)
+    }
+
+    /// ECMAScript `NewExpression`: `new` chains, then member expression without call, optional `(...)`.
+    fn parse_new_expression(&mut self) -> Result<Expr, String> {
+        if matches!(self.peek_kind(), Some(TokenKind::New)) {
+            let span_start = self.peek().map(|t| t.span.start).unwrap_or((0, 0));
+            self.advance();
+            let callee = Box::new(self.parse_new_expression()?);
+            let args = if matches!(self.peek_kind(), Some(TokenKind::LParen)) {
+                self.advance();
+                let mut args = Vec::new();
+                while !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+                    if matches!(self.peek_kind(), Some(TokenKind::Spread)) {
+                        self.advance();
+                        let arg_expr = self.parse_expr()?;
+                        args.push(CallArg::Spread(arg_expr));
+                    } else {
+                        let arg_expr = self.parse_expr()?;
+                        args.push(CallArg::Expr(arg_expr));
+                    }
+                    if !matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+                        self.expect(TokenKind::Comma)?;
+                    }
+                }
+                self.expect(TokenKind::RParen)?;
+                args
+            } else {
+                Vec::new()
+            };
+            let end = self
+                .peek()
+                .map(|x| x.span.start)
+                .unwrap_or(callee.as_ref().span().end);
+            Ok(Expr::New {
+                callee,
+                args,
+                span: Span {
+                    start: span_start,
+                    end,
+                },
+            })
+        } else {
+            self.parse_member_expression_no_call()
+        }
+    }
+
+    fn parse_postfix(&mut self) -> Result<Expr, String> {
+        let mut expr = if matches!(self.peek_kind(), Some(TokenKind::New)) {
+            self.parse_new_expression()?
+        } else {
+            self.parse_primary()?
+        };
         while let Some(kind) = self.peek_kind() {
             match kind {
                 TokenKind::LParen => {
@@ -1243,7 +1368,11 @@ impl<'a> Parser<'a> {
                     let body = self.parse_arrow_body()?;
                     let end = self.previous_span_end();
                     return Ok(Expr::ArrowFunction {
-                        params: vec![TypedParam { name: name.clone(), type_ann: None, default: None }],
+                        params: vec![FunParam::Simple(TypedParam {
+                            name: name.clone(),
+                            type_ann: None,
+                            default: None,
+                        })],
                         body,
                         span: Span { start: span.start, end },
                     });
@@ -1418,39 +1547,26 @@ impl<'a> Parser<'a> {
                 is_arrow = true;
             }
         } else {
-            // Try to parse params: (x, y, z) or (x: Type, y: Type)
+            // Try to parse params: (x, y), ({ a }), ([a, b]), with optional types/defaults
+            let mut params_ok = true;
             loop {
-                if !matches!(self.peek_kind(), Some(TokenKind::Ident)) {
-                    break; // Not a valid arrow function param list
+                if matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+                    break;
+                }
+                match self.parse_fun_param() {
+                    Ok(param) => params.push(param),
+                    Err(_) => {
+                        params_ok = false;
+                        break;
+                    }
                 }
-                let name = self.advance().unwrap().literal.clone().ok_or("Expected param name")?;
-                
-                // Optional type annotation
-                let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
-                    self.advance();
-                    Some(self.parse_type_annotation()?)
-                } else {
-                    None
-                };
-                
-                // Optional default value
-                let default = if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
-                    self.advance();
-                    Some(self.parse_expr()?)
-                } else {
-                    None
-                };
-                
-                params.push(TypedParam { name, type_ann, default });
-                
                 if matches!(self.peek_kind(), Some(TokenKind::Comma)) {
                     self.advance();
                 } else {
                     break;
                 }
             }
-            
-            if matches!(self.peek_kind(), Some(TokenKind::RParen)) {
+            if params_ok && matches!(self.peek_kind(), Some(TokenKind::RParen)) {
                 self.advance(); // consume )
                 if matches!(self.peek_kind(), Some(TokenKind::Arrow)) {
                     self.advance(); // consume =>
@@ -1787,6 +1903,7 @@ impl ExprSpan for Expr {
             Expr::Binary { span, .. } => *span,
             Expr::Unary { span, .. } => *span,
             Expr::Call { span, .. } => *span,
+            Expr::New { span, .. } => *span,
             Expr::Member { span, .. } => *span,
             Expr::Index { span, .. } => *span,
             Expr::Conditional { span, .. } => *span,

package/crates/tish_runtime/src/http.rs

@@ -1,12 +1,11 @@
 //! HTTP server + shared request parsing. Client `fetch` lives in `http_fetch.rs`.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::fs::File;
 use std::io::Write;
 use std::rc::Rc;
 use std::sync::Arc;
-use tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 use tokio::runtime::Runtime;
 
 thread_local! {
@@ -80,7 +79,7 @@ pub(crate) fn extract_body(options: Option<&Value>) -> Option<String> {
 }
 
 pub(crate) fn build_error_response(error: &str) -> Value {
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(2);
+    let mut obj: ObjectMap = ObjectMap::with_capacity(2);
     obj.insert(Arc::from("error"), Value::String(error.into()));
     obj.insert(Arc::from("ok"), Value::Bool(false));
     Value::Object(Rc::new(RefCell::new(obj)))
@@ -147,7 +146,7 @@ pub fn create_server(port: u16) -> Result<tiny_http::Server, String> {
 }
 
 pub fn request_to_value(request: &mut tiny_http::Request) -> Value {
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(6);
+    let mut obj: ObjectMap = ObjectMap::with_capacity(6);
 
     obj.insert(
         Arc::from("method"),
@@ -164,7 +163,7 @@ pub fn request_to_value(request: &mut tiny_http::Request) -> Value {
     let query_string = request.url().split('?').nth(1).unwrap_or("");
     obj.insert(Arc::from("query"), Value::String(query_string.into()));
 
-    let mut headers_obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(request.headers().len());
+    let mut headers_obj: ObjectMap = ObjectMap::with_capacity(request.headers().len());
     for header in request.headers() {
         headers_obj.insert(
             Arc::from(header.field.as_str().as_str()),

package/crates/tish_runtime/src/http_fetch.rs

@@ -1,7 +1,6 @@
 //! Web Fetch–aligned Response, ReadableStream, reader.read(), text()/json().
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::pin::Pin;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
@@ -9,7 +8,7 @@ use std::sync::{Arc, Mutex};
 use bytes::Bytes;
 use futures::Stream;
 use futures::StreamExt;
-use tishlang_core::{NativeFn, TishOpaque, TishPromise, Value};
+use tishlang_core::{NativeFn, ObjectMap, TishOpaque, TishPromise, Value};
 
 use crate::http::{build_error_response, extract_body, extract_headers, extract_method};
 
@@ -77,14 +76,14 @@ impl TishPromise for ReadChunkPromise {
             let r = crate::http::block_on_http(rx);
             match r {
                 Ok(Ok(ReadChunk::Done)) => {
-                    let mut o = HashMap::new();
+                    let mut o = ObjectMap::default();
                     o.insert(Arc::from("done"), Value::Bool(true));
                     o.insert(Arc::from("value"), Value::Null);
                     Ok(Value::Object(Rc::new(RefCell::new(o))))
                 }
                 Ok(Ok(ReadChunk::Bytes(b))) => {
                     let arr: Vec<Value> = b.iter().map(|u| Value::Number(*u as f64)).collect();
-                    let mut o = HashMap::new();
+                    let mut o = ObjectMap::default();
                     o.insert(Arc::from("done"), Value::Bool(false));
                     o.insert(
                         Arc::from("value"),
@@ -93,7 +92,7 @@ impl TishPromise for ReadChunkPromise {
                     Ok(Value::Object(Rc::new(RefCell::new(o))))
                 }
                 Ok(Err(e)) => Err({
-                    let mut obj = HashMap::new();
+                    let mut obj = ObjectMap::default();
                     obj.insert(Arc::from("error"), Value::String(e.into()));
                     Value::Object(Rc::new(RefCell::new(obj)))
                 }),
@@ -118,13 +117,13 @@ impl TishPromise for JsonTextPromise {
                 Ok(Ok(s)) => match tishlang_core::json_parse(&s) {
                     Ok(v) => Ok(v),
                     Err(e) => Err({
-                        let mut obj = HashMap::new();
+                        let mut obj = ObjectMap::default();
                         obj.insert(Arc::from("error"), Value::String(e.into()));
                         Value::Object(Rc::new(RefCell::new(obj)))
                     }),
                 },
                 Ok(Err(e)) => Err({
-                    let mut obj = HashMap::new();
+                    let mut obj = ObjectMap::default();
                     obj.insert(Arc::from("error"), Value::String(e.into()));
                     Value::Object(Rc::new(RefCell::new(obj)))
                 }),
@@ -212,6 +211,10 @@ impl TishOpaque for HttpReadableStream {
         "ReadableStream"
     }
 
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
     fn get_method(&self, name: &str) -> Option<NativeFn> {
         if name != "getReader" {
             return None;
@@ -226,7 +229,7 @@ impl TishOpaque for HttpReadableStream {
                 }))
             }
             Err(e) => {
-                let mut m = HashMap::new();
+                let mut m = ObjectMap::default();
                 m.insert(Arc::from("error"), Value::String(e.into()));
                 Value::Object(Rc::new(RefCell::new(m)))
             }
@@ -248,6 +251,10 @@ impl TishOpaque for HttpStreamReader {
         "ReadableStreamDefaultReader"
     }
 
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
     fn get_method(&self, name: &str) -> Option<NativeFn> {
         if name != "read" {
             return None;
@@ -283,7 +290,7 @@ impl TishOpaque for HttpStreamReader {
 }
 
 fn headers_to_value(headers: &reqwest::header::HeaderMap) -> Value {
-    let mut headers_obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(headers.len());
+    let mut headers_obj: ObjectMap = ObjectMap::with_capacity(headers.len());
     for (key, value) in headers.iter() {
         if let Ok(v) = value.to_str() {
             headers_obj.insert(Arc::from(key.as_str()), Value::String(v.into()));
@@ -327,7 +334,7 @@ pub fn response_value_from_reqwest(response: reqwest::Response) -> Value {
             rx: Mutex::new(Some(rx)),
         }))
     });
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::new();
+    let mut obj: ObjectMap = ObjectMap::default();
     obj.insert(Arc::from("status"), Value::Number(status));
     obj.insert(Arc::from("ok"), Value::Bool(ok));
     obj.insert(Arc::from("headers"), headers_val);

package/crates/tish_runtime/src/lib.rs

@@ -13,8 +13,15 @@ use tishlang_builtins::helpers::extract_num;
 #[cfg(feature = "fs")]
 use tishlang_builtins::helpers::make_error_value;
 
+pub use tishlang_core::ObjectMap;
 pub use tishlang_core::Value;
 
+pub use tishlang_builtins::construct::{
+    audio_context_constructor_value as tish_audio_context_constructor,
+    construct as tish_construct,
+    uint8_array_constructor_value as tish_uint8_array_constructor,
+};
+
 // Re-export array methods from tishlang_builtins
 pub use tishlang_builtins::array::{
     push as array_push_impl,
@@ -754,7 +761,7 @@ pub fn regexp_exec(re: &Value, input: &Value) -> Value {
 
 #[cfg(feature = "regex")]
 fn regexp_exec_impl(re: &mut tishlang_core::TishRegExp, input: &str) -> Value {
-    use std::collections::HashMap;
+    use tishlang_core::ObjectMap;
 
     let start = if re.flags.global || re.flags.sticky {
         re.last_index
@@ -785,7 +792,7 @@ fn regexp_exec_impl(re: &mut tishlang_core::TishRegExp, input: &str) -> Value {
             let match_byte_start = byte_start + full_match.start();
             let match_char_index = input[..match_byte_start].chars().count();
 
-            let mut obj: HashMap<std::sync::Arc<str>, Value> = HashMap::new();
+            let mut obj: ObjectMap = ObjectMap::default();
             obj.insert(Arc::from("0"), Value::String(full_match.as_str().into()));
             for i in 1..caps.len() {
                 let val = match caps.get(i) {

package/crates/tish_runtime/src/promise.rs

@@ -1,10 +1,9 @@
 //! 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 tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 
 /// Promise.resolve(value) - returns the value (immediate resolve).
 pub fn promise_resolve(args: &[Value]) -> Value {
@@ -56,7 +55,7 @@ pub fn promise_race(args: &[Value]) -> Value {
 
 /// 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();
+    let mut map: ObjectMap = ObjectMap::default();
     map.insert(
         Arc::from("resolve"),
         Value::Function(Rc::new(|args: &[Value]| promise_resolve(args))),

package/crates/tish_runtime/src/promise_io.rs

@@ -1,14 +1,13 @@
 //! 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 tishlang_core::{Value, TishPromise};
+use tishlang_core::{ObjectMap, TishPromise, Value};
 use tokio::sync::oneshot;
 
 fn error_value(msg: String) -> Value {
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(2);
+    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(Rc::new(RefCell::new(obj)))

package/crates/tish_runtime/src/ws.rs

@@ -15,7 +15,7 @@ use std::time::{Duration, Instant};
 
 use futures_util::{SinkExt, StreamExt};
 use lazy_static::lazy_static;
-use tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 use tokio::sync::mpsc as tokio_mpsc;
 use tokio::runtime::Runtime;
 
@@ -194,7 +194,7 @@ pub fn ws_broadcast_native(args: &[Value]) -> Value {
 
 /// Build connection object: { _id, send, close, readyState, receive }. JS-like.
 fn conn_object(id: u32) -> Value {
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::new();
+    let mut obj: ObjectMap = ObjectMap::default();
     obj.insert(Arc::from("_id"), Value::Number(id as f64));
     obj.insert(Arc::from("readyState"), Value::Number(1.0)); // OPEN
     obj.insert(
@@ -216,7 +216,7 @@ fn conn_object(id: u32) -> Value {
         Value::Function(Rc::new(move |_args: &[Value]| {
             match conn_receive(id) {
                 Some(s) => {
-                    let mut ev: HashMap<Arc<str>, Value> = HashMap::new();
+                    let mut ev: ObjectMap = ObjectMap::default();
                     ev.insert(Arc::from("data"), Value::String(s.into()));
                     Value::Object(Rc::new(RefCell::new(ev)))
                 }
@@ -237,7 +237,7 @@ fn conn_object(id: u32) -> Value {
                 .unwrap_or(1000);
             match conn_receive_timeout(id_timeout, timeout_ms) {
                 Some(s) => {
-                    let mut ev: HashMap<Arc<str>, Value> = HashMap::new();
+                    let mut ev: ObjectMap = ObjectMap::default();
                     ev.insert(Arc::from("data"), Value::String(s.into()));
                     Value::Object(Rc::new(RefCell::new(ev)))
                 }
@@ -529,7 +529,7 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
         ws
     });
 
-    let mut m: HashMap<Arc<str>, Value> = HashMap::new();
+    let mut m: ObjectMap = ObjectMap::default();
     m.insert(Arc::from("_handle"), handle_val);
     m.insert(Arc::from("_onConnection"), Value::Null);
     m.insert(Arc::from("clients"), Value::Array(clients));
@@ -549,7 +549,7 @@ mod tests {
     fn ws_echo_roundtrip() {
         let port: u16 = 18_742;
         let opts = {
-            let mut m: HashMap<Arc<str>, Value> = HashMap::new();
+            let mut m: ObjectMap = ObjectMap::default();
             m.insert(Arc::from("port"), Value::Number(port as f64));
             Value::Object(Rc::new(RefCell::new(m)))
         };
@@ -632,7 +632,7 @@ mod tests {
     fn ws_gateway_agent_flow() {
         let port: u16 = 18_743;
         let opts = {
-            let mut m: HashMap<Arc<str>, Value> = HashMap::new();
+            let mut m: ObjectMap = ObjectMap::default();
             m.insert(Arc::from("port"), Value::Number(port as f64));
             Value::Object(Rc::new(RefCell::new(m)))
         };

package/crates/tish_ui/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "tishlang_ui"
+version = "0.1.0"
+edition = "2021"
+description = "Shared JSX lowering and UI runtime (vnode, hooks, host protocol) for Tish"
+
+license-file = { workspace = true }
+repository = { workspace = true }
+
+[features]
+default = ["runtime"]
+compiler = ["dep:tishlang_ast"]
+runtime = ["dep:tishlang_core"]
+
+[dependencies]
+tishlang_ast = { path = "../tish_ast", version = ">=0.1", optional = true }
+tishlang_core = { path = "../tish_core", version = ">=0.1", optional = true }