@tishlang/tish 1.5.0 → 1.7.0

package/crates/tish_compile/src/types.rs

@@ -45,9 +45,7 @@ impl RustType {
                 "any" => RustType::Value,
                 _ => RustType::Value, // Unknown types fall back to Value
             },
-            TypeAnnotation::Array(elem) => {
-                RustType::Vec(Box::new(Self::from_annotation(elem)))
-            }
+            TypeAnnotation::Array(elem) => RustType::Vec(Box::new(Self::from_annotation(elem))),
             TypeAnnotation::Object(fields) => {
                 let typed_fields: Vec<_> = fields
                     .iter()
@@ -66,13 +64,13 @@ impl RustType {
             TypeAnnotation::Union(types) => {
                 // Check for T | null pattern -> Option<T>
                 if types.len() == 2 {
-                    let has_null = types.iter().any(|t| {
-                        matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null")
-                    });
+                    let has_null = types
+                        .iter()
+                        .any(|t| matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null"));
                     if has_null {
-                        let non_null = types.iter().find(|t| {
-                            !matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null")
-                        });
+                        let non_null = types.iter().find(
+                            |t| !matches!(t, TypeAnnotation::Simple(s) if s.as_ref() == "null"),
+                        );
                         if let Some(inner) = non_null {
                             return RustType::Option(Box::new(Self::from_annotation(inner)));
                         }
@@ -271,9 +269,7 @@ impl TypeContext {
 
     /// Check if a variable is typed (has a non-Value type).
     pub fn is_typed(&self, name: &str) -> bool {
-        self.lookup(name)
-            .map(|ty| ty.is_native())
-            .unwrap_or(false)
+        self.lookup(name).map(|ty| ty.is_native()).unwrap_or(false)
     }
 
     /// Get the type of a variable, defaulting to Value if not found.
@@ -329,12 +325,12 @@ mod tests {
         ctx.define("x", RustType::F64);
         assert_eq!(ctx.get_type("x"), RustType::F64);
         assert!(ctx.is_typed("x"));
-        
+
         ctx.push_scope();
         ctx.define("y", RustType::String);
         assert_eq!(ctx.get_type("y"), RustType::String);
         assert_eq!(ctx.get_type("x"), RustType::F64); // Can still see outer scope
-        
+
         ctx.pop_scope();
         assert_eq!(ctx.get_type("y"), RustType::Value); // y no longer visible
     }

package/crates/tish_compile_js/src/codegen.rs

@@ -16,7 +16,9 @@ struct Codegen {
 fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
     matches!(
         stmt,
-        Some(Statement::Break { .. }) | Some(Statement::Return { .. }) | Some(Statement::Throw { .. })
+        Some(Statement::Break { .. })
+            | Some(Statement::Return { .. })
+            | Some(Statement::Throw { .. })
     )
 }
 
@@ -174,7 +176,12 @@ impl Codegen {
                 self.emit_statement(body)?;
                 self.indent -= 1;
             }
-            Statement::ForOf { name, iterable, body, .. } => {
+            Statement::ForOf {
+                name,
+                iterable,
+                body,
+                ..
+            } => {
                 let escaped = Self::escape_ident(name.as_ref());
                 let it = self.emit_expr(iterable)?;
                 self.writeln(&format!("for (const {} of {})", escaped, it));
@@ -204,7 +211,10 @@ impl Codegen {
                 let async_prefix = if *async_ { "async " } else { "" };
                 let escaped = Self::escape_ident(name.as_ref());
                 let params_str = self.emit_params(params, rest_param.as_ref())?;
-                self.writeln(&format!("{}function {} ({}) {{", async_prefix, escaped, params_str));
+                self.writeln(&format!(
+                    "{}function {} ({}) {{",
+                    async_prefix, escaped, params_str
+                ));
                 self.indent += 1;
                 if *async_ {
                     self.in_async = true;
@@ -337,9 +347,7 @@ impl Codegen {
                 let parts: Vec<String> = elements
                     .iter()
                     .map(|el| match el {
-                        Some(DestructElement::Ident(n)) => {
-                            Ok(Self::escape_ident(n.as_ref()))
-                        }
+                        Some(DestructElement::Ident(n)) => Ok(Self::escape_ident(n.as_ref())),
                         Some(DestructElement::Pattern(p)) => self.emit_destruct_pattern(p),
                         Some(DestructElement::Rest(n)) => {
                             Ok(format!("...{}", Self::escape_ident(n.as_ref())))
@@ -385,7 +393,9 @@ impl Codegen {
                 Literal::Null => "null".to_string(),
             },
             Expr::Ident { name, .. } => Self::escape_ident(name.as_ref()),
-            Expr::Binary { left, op, right, .. } => {
+            Expr::Binary {
+                left, op, right, ..
+            } => {
                 let l = self.emit_expr(left)?;
                 let r = self.emit_expr(right)?;
                 let op_str = match op {
@@ -451,7 +461,9 @@ impl Codegen {
                 let obj = self.emit_expr(object)?;
                 let expr = match prop {
                     MemberProp::Name(p) => {
-                        if p.parse::<u32>().is_ok() || !p.chars().all(|c| c.is_alphanumeric() || c == '_') {
+                        if p.parse::<u32>().is_ok()
+                            || !p.chars().all(|c| c.is_alphanumeric() || c == '_')
+                        {
                             format!("{}[{:?}]", obj, p.as_ref())
                         } else {
                             let sep = if *optional { "?." } else { "." };
@@ -548,7 +560,9 @@ impl Codegen {
             Expr::PrefixDec { name, .. } => {
                 format!("--{}", Self::escape_ident(name.as_ref()))
             }
-            Expr::CompoundAssign { name, op, value, .. } => {
+            Expr::CompoundAssign {
+                name, op, value, ..
+            } => {
                 let n = Self::escape_ident(name.as_ref());
                 let v = self.emit_expr(value)?;
                 let op_str = match op {
@@ -560,7 +574,9 @@ impl Codegen {
                 };
                 format!("({} {} {})", n, op_str, v)
             }
-            Expr::LogicalAssign { name, op, value, .. } => {
+            Expr::LogicalAssign {
+                name, op, value, ..
+            } => {
                 let n = Self::escape_ident(name.as_ref());
                 let v = self.emit_expr(value)?;
                 let op_str = match op {
@@ -570,7 +586,12 @@ impl Codegen {
                 };
                 format!("({} {} {})", n, op_str, v)
             }
-            Expr::MemberAssign { object, prop, value, .. } => {
+            Expr::MemberAssign {
+                object,
+                prop,
+                value,
+                ..
+            } => {
                 let obj = self.emit_expr(object)?;
                 let val = self.emit_expr(value)?;
                 format!("({}.{} = {})", obj, prop.as_ref(), val)
@@ -652,7 +673,6 @@ impl Codegen {
             CallArg::Spread(e) => Ok(format!("...{}", self.emit_expr(e)?)),
         }
     }
-
 }
 
 /// Compile a single program (no imports) to JavaScript. JSX lowers to `h` / `Fragment` (Lattish).
@@ -679,7 +699,8 @@ pub fn compile_project_with_jsx(
         .map_err(|e| CompileError { message: e })?;
     tishlang_compile::detect_cycles(&modules).map_err(|e| CompileError { message: e })?;
     let program = {
-        let prog = tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
+        let prog =
+            tishlang_compile::merge_modules(modules).map_err(|e| CompileError { message: e })?;
         if optimize {
             tishlang_opt::optimize(&prog)
         } else {

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -11,7 +11,11 @@ mod tests {
         let src = r#"fn X() { return <div class="a">{"hi"}</div> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains("h(\"div\", { class: \"a\" }, [\"hi\"])"), "{}", js);
+        assert!(
+            js.contains("h(\"div\", { class: \"a\" }, [\"hi\"])"),
+            "{}",
+            js
+        );
         assert!(!js.contains("function __h("));
     }
 
@@ -57,7 +61,11 @@ mod tests {
         let src = r#"fn X() { return <p>work!</p> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains(r#""work!""#), "expected 'work!', got: {}", &js[..400.min(js.len())]);
+        assert!(
+            js.contains(r#""work!""#),
+            "expected 'work!', got: {}",
+            &js[..400.min(js.len())]
+        );
     }
 
     #[test]
@@ -65,7 +73,11 @@ mod tests {
         let src = r#"fn X() { return <p>hello 😔</p> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains("😔"), "expected emoji, got: {}", &js[..400.min(js.len())]);
+        assert!(
+            js.contains("😔"),
+            "expected emoji, got: {}",
+            &js[..400.min(js.len())]
+        );
     }
 
     #[test]
@@ -93,10 +105,22 @@ mod tests {
         let src = r#"fn X() { return <div class="x">{"a"}</div> }"#;
         let program = parse(src).unwrap();
         let js = compile_with_jsx(&program, false).unwrap();
-        assert!(js.contains("h(\"div\", { class: \"x\" }"), "{}", &js[..500.min(js.len())]);
+        assert!(
+            js.contains("h(\"div\", { class: \"x\" }"),
+            "{}",
+            &js[..500.min(js.len())]
+        );
         assert!(!js.contains("__vdom_h"), "{}", &js[..600.min(js.len())]);
-        assert!(!js.contains("window.__LATTISH_JSX_VDOM"), "{}", &js[..600.min(js.len())]);
-        assert!(!js.contains("__lattishVdomPatch"), "{}", &js[..600.min(js.len())]);
+        assert!(
+            !js.contains("window.__LATTISH_JSX_VDOM"),
+            "{}",
+            &js[..600.min(js.len())]
+        );
+        assert!(
+            !js.contains("__lattishVdomPatch"),
+            "{}",
+            &js[..600.min(js.len())]
+        );
     }
 
     /// Component calls like {Panel()} return DOM elements. Wrapping in String() produces [object HTMLDivElement].

package/crates/tish_compiler_wasm/src/lib.rs

@@ -14,29 +14,34 @@ use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 pub fn compile_to_bytecode(source: &str) -> Result<String, JsValue> {
-    let program = tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let program =
+        tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
     let program = tishlang_opt::optimize(&program);
-    let chunk = tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let chunk =
+        tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
     Ok(base64::engine::general_purpose::STANDARD.encode(tishlang_bytecode::serialize(&chunk)))
 }
 
 #[wasm_bindgen]
 pub fn compile_to_js(source: &str) -> Result<String, JsValue> {
-    let program = tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
-    tishlang_compile_js::compile_with_jsx(&program, true)
-        .map_err(|e| JsValue::from_str(&e.message))
+    let program =
+        tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    tishlang_compile_js::compile_with_jsx(&program, true).map_err(|e| JsValue::from_str(&e.message))
 }
 
 #[wasm_bindgen]
-pub fn compile_to_bytecode_with_imports(entry_path: &str, files_json: &str) -> Result<String, JsValue> {
+pub fn compile_to_bytecode_with_imports(
+    entry_path: &str,
+    files_json: &str,
+) -> Result<String, JsValue> {
     let files: HashMap<String, String> = serde_json::from_str(files_json)
         .map_err(|e| JsValue::from_str(&format!("Invalid files JSON: {}", e)))?;
-    let modules = resolve_virtual(entry_path, &files)
-        .map_err(|e| JsValue::from_str(&e))?;
+    let modules = resolve_virtual(entry_path, &files).map_err(|e| JsValue::from_str(&e))?;
     detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
     let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
     let program = tishlang_opt::optimize(&program);
-    let chunk = tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let chunk =
+        tishlang_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
     Ok(base64::engine::general_purpose::STANDARD.encode(tishlang_bytecode::serialize(&chunk)))
 }
 
@@ -44,11 +49,9 @@ pub fn compile_to_bytecode_with_imports(entry_path: &str, files_json: &str) -> R
 pub fn compile_to_js_with_imports(entry_path: &str, files_json: &str) -> Result<String, JsValue> {
     let files: HashMap<String, String> = serde_json::from_str(files_json)
         .map_err(|e| JsValue::from_str(&format!("Invalid files JSON: {}", e)))?;
-    let modules = resolve_virtual(entry_path, &files)
-        .map_err(|e| JsValue::from_str(&e))?;
+    let modules = resolve_virtual(entry_path, &files).map_err(|e| JsValue::from_str(&e))?;
     detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
     let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
     let program = tishlang_opt::optimize(&program);
-    tishlang_compile_js::compile_with_jsx(&program, true)
-        .map_err(|e| JsValue::from_str(&e.message))
+    tishlang_compile_js::compile_with_jsx(&program, true).map_err(|e| JsValue::from_str(&e.message))
 }

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -33,6 +33,7 @@ fn normalize_builtin_spec(spec: &str) -> Option<String> {
 
 fn is_native_import(spec: &str) -> bool {
     spec.starts_with("tish:")
+        || spec.starts_with("cargo:")
         || spec.starts_with('@')
         || matches!(spec, "fs" | "http" | "process" | "ws")
 }
@@ -108,10 +109,16 @@ pub fn resolve_virtual(
         if files.contains_key(&with_ext) {
             with_ext
         } else {
-            return Err(format!("Entry file '{}' not in virtual file map", entry_path));
+            return Err(format!(
+                "Entry file '{}' not in virtual file map",
+                entry_path
+            ));
         }
     } else {
-        return Err(format!("Entry file '{}' not in virtual file map", entry_path));
+        return Err(format!(
+            "Entry file '{}' not in virtual file map",
+            entry_path
+        ));
     };
 
     let mut visited = HashSet::new();
@@ -147,9 +154,9 @@ fn load_module_recursive(
     }
     visited.insert(module_path.to_string());
 
-    let source = files.get(module_path).ok_or_else(|| {
-        format!("Module '{}' not in virtual file map", module_path)
-    })?;
+    let source = files
+        .get(module_path)
+        .ok_or_else(|| format!("Module '{}' not in virtual file map", module_path))?;
     let program = tishlang_parser::parse(source.trim())
         .map_err(|e| format!("Parse error in {}: {}", module_path, e))?;
 
@@ -161,13 +168,7 @@ fn load_module_recursive(
             }
             let dep_key = resolve_import_to_key(from, from_dir, files)?;
             if !path_to_module.contains_key(&dep_key) {
-                load_module_recursive(
-                    &dep_key,
-                    files,
-                    visited,
-                    path_to_module,
-                    load_order,
-                )?;
+                load_module_recursive(&dep_key, files, visited, path_to_module, load_order)?;
             }
         }
     }
@@ -196,11 +197,11 @@ pub fn detect_cycles_virtual(modules: &[VirtualModule]) -> Result<(), String> {
             &mut stack,
             &mut HashSet::new(),
         )? {
-            let path_names: Vec<_> = stack
-                .iter()
-                .map(|&i| modules[i].path.clone())
-                .collect();
-            return Err(format!("Circular import detected: {}", path_names.join(" -> ")));
+            let path_names: Vec<_> = stack.iter().map(|&i| modules[i].path.clone()).collect();
+            return Err(format!(
+                "Circular import detected: {}",
+                path_names.join(" -> ")
+            ));
         }
     }
     Ok(())
@@ -230,14 +231,8 @@ fn has_cycle_from(
                     stack.push(dep_idx);
                     let dep = &modules[dep_idx];
                     let dep_dir = parent_dir(&dep.path);
-                    if has_cycle_from(
-                        dep_dir,
-                        &dep.program,
-                        path_to_idx,
-                        modules,
-                        stack,
-                        visiting,
-                    )? {
+                    if has_cycle_from(dep_dir, &dep.program, path_to_idx, modules, stack, visiting)?
+                    {
                         return Ok(true);
                     }
                     stack.pop();
@@ -306,7 +301,11 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
         let dir = parent_dir(&module.path);
         for stmt in &module.program.statements {
             match stmt {
-                Statement::Import { specifiers, from, span } => {
+                Statement::Import {
+                    specifiers,
+                    from,
+                    span,
+                } => {
                     if is_native_import(from) {
                         let canonical_spec =
                             normalize_builtin_spec(from).unwrap_or_else(|| from.to_string());
@@ -386,18 +385,13 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                                     name: ns.clone(),
                                     mutable: false,
                                     type_ann: None,
-                                    init: Some(Expr::Object {
-                                        props,
-                                        span: *span,
-                                    }),
+                                    init: Some(Expr::Object { props, span: *span }),
                                     span: *span,
                                 });
                             }
                             ImportSpecifier::Default(bind) => {
-                                let source = dep_exports
-                                    .get("default")
-                                    .cloned()
-                                    .ok_or_else(|| {
+                                let source =
+                                    dep_exports.get("default").cloned().ok_or_else(|| {
                                         format!("Module '{}' has no default export", from)
                                     })?;
                                 statements.push(Statement::VarDecl {
@@ -414,21 +408,19 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                         }
                     }
                 }
-                Statement::Export { declaration, .. } => {
-                    match declaration.as_ref() {
-                        ExportDeclaration::Named(s) => statements.push(*s.clone()),
-                        ExportDeclaration::Default(e) => {
-                            let default_name = format!("__default_{}", idx);
-                            statements.push(Statement::VarDecl {
-                                name: Arc::from(default_name),
-                                mutable: false,
-                                type_ann: None,
-                                init: Some((*e).clone()),
-                                span: e.span(),
-                            });
-                        }
+                Statement::Export { declaration, .. } => match declaration.as_ref() {
+                    ExportDeclaration::Named(s) => statements.push(*s.clone()),
+                    ExportDeclaration::Default(e) => {
+                        let default_name = format!("__default_{}", idx);
+                        statements.push(Statement::VarDecl {
+                            name: Arc::from(default_name),
+                            mutable: false,
+                            type_ann: None,
+                            init: Some((*e).clone()),
+                            span: e.span(),
+                        });
                     }
-                }
+                },
                 _ => statements.push(stmt.clone()),
             }
         }

package/crates/tish_core/src/json.rs

@@ -228,7 +228,7 @@ fn parse_number(input: &str) -> Result<(Value, &str), String> {
 
     let num_str: String = chars[..end].iter().collect();
     let byte_len: usize = chars[..end].iter().map(|c| c.len_utf8()).sum();
-    
+
     num_str
         .parse::<f64>()
         .map(|n| (Value::Number(n), &input[byte_len..]))
@@ -306,7 +306,9 @@ mod tests {
         assert!(matches!(json_parse("true").unwrap(), Value::Bool(true)));
         assert!(matches!(json_parse("false").unwrap(), Value::Bool(false)));
         assert!(matches!(json_parse("42").unwrap(), Value::Number(n) if n == 42.0));
-        assert!(matches!(json_parse("\"hello\"").unwrap(), Value::String(s) if s.as_ref() == "hello"));
+        assert!(
+            matches!(json_parse("\"hello\"").unwrap(), Value::String(s) if s.as_ref() == "hello")
+        );
     }
 
     #[test]
@@ -315,7 +317,7 @@ mod tests {
         let value = json_parse(original).unwrap();
         let stringified = json_stringify(&value);
         let reparsed = json_parse(&stringified).unwrap();
-        
+
         match (&value, &reparsed) {
             (Value::Object(a), Value::Object(b)) => {
                 assert_eq!(a.borrow().len(), b.borrow().len());

package/crates/tish_core/src/lib.rs

@@ -10,6 +10,6 @@ mod uri;
 mod value;
 
 pub use console_style::{format_value_styled, format_values_for_console, use_console_colors};
-pub use value::*;
 pub use json::{json_parse, json_stringify};
 pub use uri::{percent_decode, percent_encode};
+pub use value::*;

package/crates/tish_core/src/uri.rs

@@ -10,13 +10,13 @@ pub fn percent_decode(input: &str) -> Result<String, String> {
         "%2F", "%2f", // /
         "%3F", "%3f", // ?
         "%3A", "%3a", // :
-        "%40",        // @
-        "%26",        // &
+        "%40", // @
+        "%26", // &
         "%3D", "%3d", // =
         "%2B", "%2b", // +
-        "%24",        // $
+        "%24", // $
         "%2C", "%2c", // ,
-        "%23",        // #
+        "%23", // #
     ];
 
     let mut result = String::with_capacity(input.len());
@@ -46,11 +46,14 @@ pub fn percent_decode(input: &str) -> Result<String, String> {
                     None => return Err("URIError: malformed URI sequence".to_string()),
                 }
             }
-            
+
             if hex.len() == 2 {
                 let encoded = format!("%{}", hex);
                 // Check if this is a reserved character that should NOT be decoded
-                if RESERVED_ENCODED.iter().any(|r| r.eq_ignore_ascii_case(&encoded)) {
+                if RESERVED_ENCODED
+                    .iter()
+                    .any(|r| r.eq_ignore_ascii_case(&encoded))
+                {
                     result.push_str(&encoded);
                 } else if let Ok(byte) = u8::from_str_radix(&hex, 16) {
                     result.push(byte as char);