@tishlang/tish 1.0.11 → 1.0.13

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tish"
-version = "0.1.0"
+version = "1.0.13"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish/src/main.rs

@@ -14,6 +14,7 @@ use rustyline::{Behavior, ColorMode, CompletionType, Config, Editor};
 #[derive(Parser)]
 #[command(name = "tish")]
 #[command(about = "Tish - minimal TS/JS-compatible language")]
+#[command(version = env!("CARGO_PKG_VERSION"))]
 #[command(after_help = "To disable optimizations: TISH_NO_OPTIMIZE=1")]
 pub(crate) struct Cli {
     #[command(subcommand)]

package/crates/tish/tests/integration_test.rs

@@ -163,6 +163,26 @@ fn tish_bin() -> PathBuf {
     default
 }
 
+/// tish -V and --version print the version.
+#[test]
+fn test_tish_version_flag() {
+    let bin = tish_bin();
+    assert!(bin.exists(), "tish binary not found. Run `cargo build -p tish` first.");
+    let out = Command::new(&bin).arg("-V").output().expect("run tish -V");
+    assert!(out.status.success(), "tish -V failed: {}", String::from_utf8_lossy(&out.stderr));
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains(env!("CARGO_PKG_VERSION")),
+        "tish -V should print version {}; got: {}",
+        env!("CARGO_PKG_VERSION"),
+        stdout
+    );
+    let out2 = Command::new(&bin).arg("--version").output().expect("run tish --version");
+    assert!(out2.status.success());
+    let stdout2 = String::from_utf8_lossy(&out2.stdout);
+    assert!(stdout2.contains(env!("CARGO_PKG_VERSION")), "tish --version should print version");
+}
+
 /// Parse async-await example (validates async fn parsing).
 #[test]
 fn test_async_await_parse() {

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -1,8 +1,10 @@
 #[cfg(test)]
 mod tests {
+    use std::io::Write;
+
     use tish_parser::parse;
 
-    use crate::{compile_with_jsx, JsxMode};
+    use crate::{compile_project_with_jsx, compile_with_jsx, JsxMode};
 
     #[test]
     fn lattish_jsx_emits_h_with_children_array() {
@@ -21,6 +23,54 @@ mod tests {
         assert!(js.contains("h(Fragment, null, ["));
     }
 
+    #[test]
+    fn jsx_text_whitespace_coalesced() {
+        let src = r#"fn X() { return <p>First paragraph</p> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        assert!(
+            js.contains("\"First paragraph\""),
+            "expected \"First paragraph\" in output, got: {}",
+            &js[..400.min(js.len())]
+        );
+        assert!(
+            !js.contains("\"First\", \"paragraph\""),
+            "text should be coalesced, not split"
+        );
+    }
+
+    #[test]
+    fn jsx_text_whitespace_coalesced_multiline() {
+        let src = "fn App() {\n  return <p>First paragraph</p>\n}";
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        assert!(
+            js.contains("\"First paragraph\""),
+            "multiline: expected \"First paragraph\", got: {}",
+            &js[..400.min(js.len())]
+        );
+    }
+
+    #[test]
+    fn jsx_text_whitespace_via_compile_project() {
+        let dir = std::env::temp_dir().join("tish_compile_project_test");
+        let _ = std::fs::create_dir_all(&dir);
+        let path = dir.join("test.tish");
+        let src = "fn App() {\n  return <p>First paragraph</p>\n}";
+        let mut f = std::fs::File::create(&path).unwrap();
+        f.write_all(src.as_bytes()).unwrap();
+        f.sync_all().unwrap();
+        drop(f);
+        let js = compile_project_with_jsx(&path, Some(&dir), false, JsxMode::LattishH)
+            .expect("compile_project_with_jsx failed");
+        assert!(
+            js.contains("\"First paragraph\""),
+            "compile_project: expected \"First paragraph\", got: {}",
+            &js[..500.min(js.len())]
+        );
+        let _ = std::fs::remove_file(&path);
+    }
+
     #[test]
     fn vdom_emits_vdom_h() {
         let src = r#"fn X() { return <p/> }"#;

package/crates/tish_jsx_web/vendor/Lattish.tish

@@ -27,6 +27,21 @@ export fn h(tag, props, children) {
   if (children === undefined || children === null) {
     children = []
   }
+  if (typeof tag === "function") {
+    let p = props && props !== null ? props : {}
+    if (children.length > 0) {
+      let newProps = {}
+      let keys = Object.keys(p)
+      let i = 0
+      while (i < keys.length) {
+        newProps[keys[i]] = p[keys[i]]
+        i = i + 1
+      }
+      newProps.children = children
+      p = newProps
+    }
+    return tag(p)
+  }
   if (tag === Fragment) {
     let f = document.createDocumentFragment()
     let i = 0

package/crates/tish_parser/src/parser.rs

@@ -1561,6 +1561,17 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// Push text child, merging with previous Text if any (preserves spaces between tokens).
+    fn push_or_merge_text(&self, children: &mut Vec<JsxChild>, s: Arc<str>) {
+        if let Some(JsxChild::Text(prev)) = children.last() {
+            let merged = format!("{} {}", prev.as_ref(), s.as_ref());
+            let last = children.len() - 1;
+            children[last] = JsxChild::Text(Arc::from(merged.as_str()));
+        } else {
+            children.push(JsxChild::Text(s));
+        }
+    }
+
     /// Parse JSX children until </Tag> or </>
     fn parse_jsx_children(&mut self, close_tag: &str) -> Result<Vec<JsxChild>, String> {
         let mut children = Vec::new();
@@ -1601,7 +1612,7 @@ impl<'a> Parser<'a> {
                     let t = self.advance().unwrap();
                     let s = t.literal.clone().unwrap_or_default();
                     if !s.is_empty() {
-                        children.push(JsxChild::Text(s));
+                        self.push_or_merge_text(&mut children, s);
                     }
                 }
                 Some(TokenKind::Ident) => {
@@ -1609,7 +1620,7 @@ impl<'a> Parser<'a> {
                     let t = self.advance().unwrap();
                     let s = t.literal.clone().unwrap_or_default();
                     if !s.is_empty() {
-                        children.push(JsxChild::Text(s));
+                        self.push_or_merge_text(&mut children, s);
                     }
                 }
                 _ => {
@@ -1659,7 +1670,14 @@ impl<'a> Parser<'a> {
                     let t = self.advance().unwrap();
                     let s = t.literal.clone().unwrap_or_default();
                     if !s.is_empty() {
-                        children.push(JsxChild::Text(s));
+                        self.push_or_merge_text(&mut children, s);
+                    }
+                }
+                Some(TokenKind::Ident) => {
+                    let t = self.advance().unwrap();
+                    let s = t.literal.clone().unwrap_or_default();
+                    if !s.is_empty() {
+                        self.push_or_merge_text(&mut children, s);
                     }
                 }
                 _ => return Err(format!("Unexpected token in JSX fragment: {:?}", self.peek_kind())),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, compile to native.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {