@tishlang/tish 2.8.0 → 2.10.1

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -4,7 +4,10 @@ mod tests {
 
     use tishlang_parser::parse;
 
-    use crate::{compile_project_with_jsx, compile_with_jsx};
+    use crate::{
+        compile_module_esm, compile_project_esm, compile_project_with_jsx, compile_with_jsx,
+        EmittedJsModule, ImportRewrite,
+    };
 
     #[test]
     fn lattish_jsx_emits_h_with_children_array() {
@@ -455,4 +458,354 @@ fn factory() {
         let neg = crate::compile(&parse("console.log(-1 / 0)\n").unwrap(), true).unwrap();
         assert!(neg.contains("-Infinity"), "-1/0 must emit -Infinity:\n{neg}");
     }
+
+    // ── #282: ESM module output (one file per module, real import/export) ──────────────────────
+
+    /// Write a set of `(relative_path, source)` modules into a fresh temp dir and compile the entry
+    /// in ESM mode. Returns the emitted modules keyed for easy lookup by their output relative path.
+    fn build_esm(entry: &str, modules: &[(&str, &str)]) -> Vec<EmittedJsModule> {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        for (rel, src) in modules {
+            let p = dir.join(rel);
+            if let Some(parent) = p.parent() {
+                std::fs::create_dir_all(parent).unwrap();
+            }
+            let mut f = std::fs::File::create(&p).unwrap();
+            f.write_all(src.as_bytes()).unwrap();
+            f.sync_all().unwrap();
+        }
+        compile_project_esm(&dir.join(entry), Some(dir), false).expect("compile_project_esm failed")
+    }
+
+    fn module_js<'a>(mods: &'a [EmittedJsModule], rel: &str) -> &'a str {
+        mods.iter()
+            .find(|m| m.relative_path.to_string_lossy() == rel)
+            .map(|m| m.js.as_str())
+            .unwrap_or_else(|| panic!("module {rel} not emitted; got {:?}", mods.iter().map(|m| m.relative_path.display().to_string()).collect::<Vec<_>>()))
+    }
+
+    #[test]
+    fn esm_emits_named_and_default_exports() {
+        let mods = build_esm(
+            "main.tish",
+            &[(
+                "main.tish",
+                "export const VERSION = \"1.0\"\nexport fn greet(n) { return \"hi \" + n }\nexport default greet\n",
+            )],
+        );
+        let js = module_js(&mods, "main.js");
+        assert!(js.contains("export const VERSION = \"1.0\";"), "named const export:\n{js}");
+        assert!(js.contains("export function greet "), "named fn export:\n{js}");
+        assert!(js.contains("export default greet;"), "default export:\n{js}");
+    }
+
+    #[test]
+    fn esm_rewrites_import_specifier_to_js_with_alias() {
+        let mods = build_esm(
+            "main.tish",
+            &[
+                ("dep.tish", "export const ssrH = 42\nexport fn greet(n) { return n }\n"),
+                (
+                    "main.tish",
+                    "import { ssrH as h, greet } from \"./dep.tish\"\nimport * as M from \"./dep.tish\"\nconsole.log(h)\nconsole.log(greet(M.ssrH))\n",
+                ),
+            ],
+        );
+        let js = module_js(&mods, "main.js");
+        assert!(
+            js.contains("import { ssrH as h, greet } from \"./dep.js\";"),
+            "named import with alias, .tish->.js:\n{js}"
+        );
+        assert!(js.contains("import * as M from \"./dep.js\";"), "namespace import:\n{js}");
+    }
+
+    #[test]
+    fn esm_one_file_per_module_preserves_tree() {
+        let mods = build_esm(
+            "main.tish",
+            &[
+                ("lib/util.tish", "export fn id(x) { return x }\n"),
+                ("main.tish", "import { id } from \"./lib/util.tish\"\nconsole.log(id(1))\n"),
+            ],
+        );
+        // Nested module keeps its relative path; importer points at the nested `.js`.
+        let _ = module_js(&mods, "lib/util.js");
+        let main = module_js(&mods, "main.js");
+        assert!(
+            main.contains("from \"./lib/util.js\";"),
+            "nested relative import preserved:\n{main}"
+        );
+    }
+
+    #[test]
+    fn esm_module_outside_project_root_is_emitted() {
+        // #282 follow-up: a dependency in a *sibling* package (outside the entry's project root)
+        // must still be emitted — the output tree is rooted at the directory common to all modules.
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let base = tmp.path();
+        std::fs::create_dir_all(base.join("app/src")).unwrap();
+        std::fs::create_dir_all(base.join("lib")).unwrap();
+        std::fs::write(base.join("lib/util.tish"), "export fn id(x) { return x }\n").unwrap();
+        std::fs::write(
+            base.join("app/src/main.tish"),
+            "import { id } from \"../../lib/util.tish\"\nconsole.log(id(1))\n",
+        )
+        .unwrap();
+        // Project root is the entry's package (`app`); `lib/util.tish` lives outside it.
+        let mods = compile_project_esm(
+            &base.join("app/src/main.tish"),
+            Some(&base.join("app")),
+            false,
+        )
+        .expect("compile_project_esm failed for sibling dep");
+        let rels: Vec<String> = mods
+            .iter()
+            .map(|m| m.relative_path.to_string_lossy().replace('\\', "/"))
+            .collect();
+        let main_js = mods
+            .iter()
+            .find(|m| m.relative_path.to_string_lossy().replace('\\', "/").ends_with("app/src/main.js"))
+            .map(|m| m.js.clone());
+        assert!(
+            rels.iter().any(|r| r.ends_with("lib/util.js")),
+            "sibling dep emitted under common base: {:?}",
+            rels
+        );
+        assert!(
+            rels.iter().any(|r| r.ends_with("app/src/main.js")),
+            "entry emitted under its own subtree: {:?}",
+            rels
+        );
+        let main_js = main_js.expect("entry module present");
+        assert!(
+            main_js.contains("from \"../../lib/util.js\";"),
+            "relative import to sibling rewritten to .js:\n{main_js}"
+        );
+    }
+
+    #[test]
+    fn esm_bare_node_modules_dep_is_emitted() {
+        // #282 follow-up: a bare specifier resolved from `node_modules` (like `lattish`) is emitted
+        // into the output tree and the importer points at it with a relative `.js` specifier.
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let base = tmp.path();
+        std::fs::create_dir_all(base.join("src")).unwrap();
+        std::fs::create_dir_all(base.join("node_modules/pkg")).unwrap();
+        std::fs::write(
+            base.join("node_modules/pkg/package.json"),
+            "{\"name\":\"pkg\",\"main\":\"index.tish\"}\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("node_modules/pkg/index.tish"),
+            "export fn ping() { return \"pong\" }\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("src/main.tish"),
+            "import { ping } from \"pkg\"\nconsole.log(ping())\n",
+        )
+        .unwrap();
+        let mods = compile_project_esm(&base.join("src/main.tish"), Some(base), false)
+            .expect("compile_project_esm failed for node_modules dep");
+        let rels: Vec<String> = mods
+            .iter()
+            .map(|m| m.relative_path.to_string_lossy().replace('\\', "/"))
+            .collect();
+        let main_js = mods
+            .iter()
+            .find(|m| m.relative_path.to_string_lossy().replace('\\', "/").ends_with("src/main.js"))
+            .map(|m| m.js.clone());
+        assert!(
+            rels.iter().any(|r| r.ends_with("node_modules/pkg/index.js")),
+            "node_modules dep emitted: {:?}",
+            rels
+        );
+        let main_js = main_js.expect("entry module present");
+        assert!(
+            main_js.contains("from \"../node_modules/pkg/index.js\";"),
+            "bare specifier rewritten to relative .js path:\n{main_js}"
+        );
+    }
+
+    #[test]
+    fn esm_rejects_native_imports() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "import { readFile } from \"fs\"\nconsole.log(1)\n").unwrap();
+        let err = compile_project_esm(&p, Some(dir), false).unwrap_err();
+        assert!(
+            err.message.contains("Native module import") && err.message.contains("esm"),
+            "expected a native-import rejection for ESM, got: {}",
+            err.message
+        );
+    }
+
+    // ── #284: single-module compile for Vite dev (in-graph HMR) ───────────────────────────────
+
+    /// Write `modules` into a fresh temp dir and compile just `entry` (no graph resolution),
+    /// in Vite-dev import-rewrite mode without a source map.
+    fn build_module_vite(entry: &str, modules: &[(&str, &str)]) -> String {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        for (rel, src) in modules {
+            let p = dir.join(rel);
+            if let Some(parent) = p.parent() {
+                std::fs::create_dir_all(parent).unwrap();
+            }
+            let mut f = std::fs::File::create(&p).unwrap();
+            f.write_all(src.as_bytes()).unwrap();
+            f.sync_all().unwrap();
+        }
+        compile_module_esm(
+            &dir.join(entry),
+            Some(dir),
+            false,
+            ImportRewrite::ViteDev,
+            false,
+        )
+        .expect("compile_module_esm failed")
+        .js
+    }
+
+    #[test]
+    fn compile_module_esm_vite_preserves_relative_tish_imports() {
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { id } from \"./dep.tish\"\nconsole.log(id(1))\n",
+            )],
+        );
+        assert!(
+            js.contains("import { id } from \"./dep.tish\";"),
+            "Vite dev keeps the .tish specifier so resolveId re-enters the plugin:\n{js}"
+        );
+        assert!(
+            !js.contains("./dep.js"),
+            "Vite dev must NOT rewrite .tish to .js:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_vite_leaves_bare_specifiers_unchanged() {
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { h } from \"lattish\"\nconsole.log(h)\n",
+            )],
+        );
+        assert!(
+            js.contains("import { h } from \"lattish\";"),
+            "bare specifier passes through for normal Node/Vite resolution:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_vite_emits_exports() {
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "export const VERSION = \"1.0\"\nexport fn greet(n) { return \"hi \" + n }\nexport default greet\n",
+            )],
+        );
+        assert!(js.contains("export const VERSION = \"1.0\";"), "named const export:\n{js}");
+        assert!(js.contains("export function greet "), "named fn export:\n{js}");
+        assert!(js.contains("export default greet;"), "default export:\n{js}");
+    }
+
+    #[test]
+    fn compile_module_esm_does_not_resolve_graph() {
+        // Compiling a single module must not read or require its dependencies to exist on disk:
+        // only the entry file is created, yet the import to a missing `./dep.tish` compiles fine.
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { id } from \"./dep.tish\"\nconsole.log(id(1))\n",
+            )],
+        );
+        assert!(
+            js.contains("import { id } from \"./dep.tish\";"),
+            "single-module compile emits the import without loading the dependency:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_rejects_native_imports() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "import { readFile } from \"fs\"\nconsole.log(1)\n").unwrap();
+        let err = compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, false)
+            .unwrap_err();
+        assert!(
+            err.message.contains("Native module import"),
+            "expected a native-import rejection, got: {}",
+            err.message
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_source_map_maps_statement_to_tish_file() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "export fn greet(n) { return \"hi \" + n }\nconsole.log(greet(\"x\"))\n")
+            .unwrap();
+        let bundle =
+            compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, true).unwrap();
+        let map = bundle
+            .source_map_json
+            .expect("source map requested → must be present");
+        assert!(
+            map.contains("\"version\":3") || map.contains("\"version\": 3"),
+            "v3 source map:\n{map}"
+        );
+        assert!(
+            map.contains("main.tish"),
+            "map sources reference the .tish file:\n{map}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_source_map_embeds_sources_content() {
+        // The map must carry sourcesContent so Vite/devtools never resolve `sources` from disk
+        // (otherwise Vite warns "Sourcemap ... points to missing source files").
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        let src = "export fn greet(n) { return \"hi \" + n }\n";
+        std::fs::write(&p, src).unwrap();
+        let bundle =
+            compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, true).unwrap();
+        let map = bundle.source_map_json.expect("source map requested");
+        assert!(
+            map.contains("\"sourcesContent\""),
+            "map must include a sourcesContent field:\n{map}"
+        );
+        assert!(
+            map.contains("export fn greet"),
+            "sourcesContent must embed the original .tish source:\n{map}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_source_map_requires_no_optimize() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "console.log(1)\n").unwrap();
+        let err = compile_module_esm(&p, Some(dir), true, ImportRewrite::ViteDev, true)
+            .unwrap_err();
+        assert!(
+            err.message.to_lowercase().contains("optimiz"),
+            "source map + optimize must be rejected, got: {}",
+            err.message
+        );
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "2.8.0",
+  "version": "2.10.1",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {