@tishlang/tish 1.0.7 → 1.0.11

package/crates/tish_compile_js/src/error.rs

@@ -0,0 +1,20 @@
+#[derive(Debug)]
+pub struct CompileError {
+    pub message: String,
+}
+
+impl CompileError {
+    pub fn new(msg: &str) -> Self {
+        Self {
+            message: msg.to_string(),
+        }
+    }
+}
+
+impl std::fmt::Display for CompileError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl std::error::Error for CompileError {}

package/crates/tish_compile_js/src/js_intrinsics.rs

@@ -0,0 +1,82 @@
+//! JS-only call sites that require `new` (Tish has no `new`).
+//! Intrinsic names, validation, and runtime preamble live here — main codegen only dispatches.
+
+use tish_ast::{CallArg, Expr};
+
+use crate::error::CompileError;
+
+/// Built-in calls lowered to `new ...` in the JS emit.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum JsIntrinsic {
+    WebAudioCreateContext,
+    Uint8Array,
+}
+
+#[derive(Debug, Default)]
+pub struct JsIntrinsics {
+    pub needs_web_audio: bool,
+    pub needs_uint8_array: bool,
+}
+
+impl JsIntrinsics {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Recognize `webAudioCreateContext()` / `jsUint8Array(n)` and validate arguments.
+    pub fn classify_call(callee: &Expr, args: &[CallArg]) -> Result<Option<JsIntrinsic>, CompileError> {
+        let Expr::Ident { name, .. } = callee else {
+            return Ok(None);
+        };
+        match name.as_ref() {
+            "webAudioCreateContext" => {
+                if !args.is_empty() {
+                    return Err(CompileError::new(
+                        "webAudioCreateContext() takes no arguments (JS target only)",
+                    ));
+                }
+                Ok(Some(JsIntrinsic::WebAudioCreateContext))
+            }
+            "jsUint8Array" => {
+                if args.len() != 1 {
+                    return Err(CompileError::new(
+                        "jsUint8Array(length) expects one argument (JS target only)",
+                    ));
+                }
+                Ok(Some(JsIntrinsic::Uint8Array))
+            }
+            _ => Ok(None),
+        }
+    }
+
+    pub fn mark(&mut self, kind: JsIntrinsic) {
+        match kind {
+            JsIntrinsic::WebAudioCreateContext => self.needs_web_audio = true,
+            JsIntrinsic::Uint8Array => self.needs_uint8_array = true,
+        }
+    }
+
+    pub fn emit_expr(kind: JsIntrinsic, uint8_length_js: &str) -> String {
+        match kind {
+            JsIntrinsic::WebAudioCreateContext => "(__tishWebAudioCreateContext() ?? null)".to_string(),
+            JsIntrinsic::Uint8Array => format!("(__tishUint8Array({}) ?? null)", uint8_length_js),
+        }
+    }
+
+    /// Prepend runtime helpers (Uint8Array above AudioContext when both are used).
+    pub fn prepend_runtime_preamble(&self, mut output: String) -> String {
+        if self.needs_web_audio {
+            output = format!(
+                "function __tishWebAudioCreateContext(){{ return new AudioContext(); }}\n{}",
+                output
+            );
+        }
+        if self.needs_uint8_array {
+            output = format!(
+                "function __tishUint8Array(n){{ return new Uint8Array(n); }}\n{}",
+                output
+            );
+        }
+        output
+    }
+}

package/crates/tish_compile_js/src/lib.rs

@@ -0,0 +1,27 @@
+//! Tish to JavaScript transpiler backend.
+//! Uses shared resolve from tish_compile for unified pipeline.
+
+mod codegen;
+mod error;
+mod js_intrinsics;
+
+#[cfg(test)]
+mod tests_jsx;
+
+pub use codegen::{compile_project_with_jsx, compile_with_jsx, JsxMode};
+pub use error::CompileError;
+
+/// Default JSX mode lowers to Lattish-style calls (implementation detail). Import what you use from
+/// `lattish` (e.g. `useState`, `createRoot`); the merged bundle includes the JSX runtime from that
+/// module. JSX-only files can use `import {} from "lattish"` to pull it in without bindings.
+pub fn compile(program: &tish_ast::Program, optimize: bool) -> Result<String, CompileError> {
+    compile_with_jsx(program, optimize, JsxMode::LattishH)
+}
+
+pub fn compile_project(
+    entry_path: &std::path::Path,
+    project_root: Option<&std::path::Path>,
+    optimize: bool,
+) -> Result<String, CompileError> {
+    compile_project_with_jsx(entry_path, project_root, optimize, JsxMode::LattishH)
+}

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -0,0 +1,32 @@
+#[cfg(test)]
+mod tests {
+    use tish_parser::parse;
+
+    use crate::{compile_with_jsx, JsxMode};
+
+    #[test]
+    fn lattish_jsx_emits_h_with_children_array() {
+        let src = r#"fn X() { return <div class="a">{"hi"}</div> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        assert!(js.contains("h(\"div\", { class: \"a\" }, [\"hi\"])"), "{}", js);
+        assert!(!js.contains("function __h("));
+    }
+
+    #[test]
+    fn fragment_lattish_uses_fragment_symbol() {
+        let src = "fn X() { return <><b>{\"1\"}</b></> }";
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        assert!(js.contains("h(Fragment, null, ["));
+    }
+
+    #[test]
+    fn vdom_emits_vdom_h() {
+        let src = r#"fn X() { return <p/> }"#;
+        let program = parse(src).unwrap();
+        let js = compile_with_jsx(&program, false, JsxMode::Vdom).unwrap();
+        assert!(js.contains("__vdom_h(\"p\", null, [])"), "{}", &js[..600.min(js.len())]);
+        assert!(js.contains("__lattishVdomPatch"));
+    }
+}

package/crates/tish_compiler_wasm/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "tish_compiler_wasm"
+version = "0.1.0"
+edition = "2021"
+description = "Tish compiler as WASM for browser (parse + bytecode + JS)"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+base64 = "0.22"
+serde_json = "1.0"
+wasm-bindgen = "0.2"
+
+tish_ast = { path = "../tish_ast" }
+tish_bytecode = { path = "../tish_bytecode" }
+tish_compile_js = { path = "../tish_compile_js" }
+tish_opt = { path = "../tish_opt" }
+tish_parser = { path = "../tish_parser" }

package/crates/tish_compiler_wasm/src/lib.rs

@@ -0,0 +1,55 @@
+//! Tish compiler exposed to JS via wasm-bindgen.
+//! Compiles single source string → bytecode (base64) or JS. Used by playground, REPL, try-it pages.
+//!
+//! `compile_to_js` / `compile_to_js_with_imports` use Lattish-style JSX lowering. Prepend a compiled
+//! **Lattish.tish** runtime (same as playground `lattish-runtime.js`) so the iframe/script scope has
+//! hooks and the JSX helpers; source files do not need to import the JSX helper by name.
+
+mod resolve_virtual;
+
+use base64::Engine;
+use resolve_virtual::{detect_cycles_virtual, merge_modules_virtual, resolve_virtual};
+use std::collections::HashMap;
+use tish_compile_js::JsxMode;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn compile_to_bytecode(source: &str) -> Result<String, JsValue> {
+    let program = tish_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    let program = tish_opt::optimize(&program);
+    let chunk = tish_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    Ok(base64::engine::general_purpose::STANDARD.encode(tish_bytecode::serialize(&chunk)))
+}
+
+#[wasm_bindgen]
+pub fn compile_to_js(source: &str) -> Result<String, JsValue> {
+    let program = tish_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    tish_compile_js::compile_with_jsx(&program, true, JsxMode::LattishH)
+        .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> {
+    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))?;
+    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 = tish_opt::optimize(&program);
+    let chunk = tish_bytecode::compile(&program).map_err(|e| JsValue::from_str(&e.to_string()))?;
+    Ok(base64::engine::general_purpose::STANDARD.encode(tish_bytecode::serialize(&chunk)))
+}
+
+#[wasm_bindgen]
+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))?;
+    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 = tish_opt::optimize(&program);
+    tish_compile_js::compile_with_jsx(&program, true, JsxMode::LattishH)
+        .map_err(|e| JsValue::from_str(&e.message))
+}