jac-client 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

jac_client/tests/test_cl.py

@@ -22,10 +22,12 @@ class ViteClientBundleBuilderTests(TestCase):
     def tearDown(self) -> None:
         Jac.reset_machine()
         return super().tearDown()
-    
-    def _create_test_project_with_vite(self, temp_path: Path, include_antd: bool = False) -> tuple[Path, Path]:
+
+    def _create_test_project_with_vite(
+        self, temp_path: Path, include_antd: bool = False
+    ) -> tuple[Path, Path]:
         """Create a minimal test project with Vite installed.
-        
+
         Args:
             temp_path: Path to the temporary directory
             include_antd: If True, includes antd in dependencies
@@ -34,13 +36,13 @@ class ViteClientBundleBuilderTests(TestCase):
         dependencies = {
             "react": "^19.2.0",
             "react-dom": "^19.2.0",
-            "react-router-dom": "^7.3.0"
+            "react-router-dom": "^7.3.0",
         }
-        
+
         # Add antd if requested
         if include_antd:
             dependencies["antd"] = "^5.0.0"
-        
+
         # Create package.json structure
         package_data = {
             "name": "test-client",
@@ -50,7 +52,7 @@ class ViteClientBundleBuilderTests(TestCase):
                 "build": "npm run compile && vite build",
                 "dev": "vite dev",
                 "preview": "vite preview",
-                "compile": 'babel src --out-dir build --extensions ".jsx,.js" --out-file-extension .js'
+                "compile": 'babel src --out-dir build --extensions ".jsx,.js" --out-file-extension .js',
             },
             "dependencies": dependencies,
             "devDependencies": {
@@ -58,17 +60,18 @@ class ViteClientBundleBuilderTests(TestCase):
                 "@babel/cli": "^7.28.3",
                 "@babel/core": "^7.28.5",
                 "@babel/preset-env": "^7.28.5",
-                "@babel/preset-react": "^7.28.5"
-            }
+                "@babel/preset-react": "^7.28.5",
+            },
         }
-        
+
         package_json = temp_path / "package.json"
         with package_json.open("w", encoding="utf-8") as f:
             json.dump(package_data, f, indent=2)
-        
+
         # Create .babelrc file
         babelrc = temp_path / ".babelrc"
-        babelrc.write_text("""{
+        babelrc.write_text(
+            """{
     "presets": [[
         "@babel/preset-env",
         {
@@ -76,11 +79,14 @@ class ViteClientBundleBuilderTests(TestCase):
         }
     ], "@babel/preset-react"]
 }
-""", encoding="utf-8")
-        
+""",
+            encoding="utf-8",
+        )
+
         # Create vite.config.js file
         vite_config = temp_path / "vite.config.js"
-        vite_config.write_text("""import { defineConfig } from "vite";
+        vite_config.write_text(
+            """import { defineConfig } from "vite";
 import path from "path";
 import { fileURLToPath } from "url";
 
@@ -107,8 +113,10 @@ export default defineConfig({
     },
   },
 });
-""", encoding="utf-8")
-        
+""",
+            encoding="utf-8",
+        )
+
         # Install dependencies
         result = subprocess.run(
             ["npm", "install"],
@@ -122,27 +130,29 @@ export default defineConfig({
             error_msg += f"stdout: {result.stdout}\n"
             error_msg += f"stderr: {result.stderr}\n"
             raise RuntimeError(error_msg)
-        
+
         # Create output directory
         output_dir = temp_path / "dist"
         output_dir.mkdir(parents=True, exist_ok=True)
-        
+
         src_dir = temp_path / "src"
         src_dir.mkdir(parents=True, exist_ok=True)
-        
+
         build_dir = temp_path / "build"
         build_dir.mkdir(parents=True, exist_ok=True)
-        
+
         return package_json, output_dir
 
     def test_build_bundle_with_vite(self) -> None:
         """Test that Vite bundling produces optimized output with proper structure."""
         # Create a temporary directory for our test project
-        with tempfile.TemporaryDirectory() as temp_dir:            
+        with tempfile.TemporaryDirectory() as temp_dir:
             temp_path = Path(temp_dir)
- 
+
             package_json, output_dir = self._create_test_project_with_vite(temp_path)
-            runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
+            runtime_path = (
+                Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
+            )
             # Initialize the Vite builder
             builder = ViteClientBundleBuilder(
                 runtime_path=runtime_path,
@@ -162,16 +172,17 @@ export default defineConfig({
             self.assertIn("ButtonProps", bundle.client_functions)
             self.assertIn("API_LABEL", bundle.client_globals)
             self.assertGreater(len(bundle.hash), 10)
-            
+
             # Verify bundle code contains expected content
             self.assertIn("function app()", bundle.code)
             self.assertIn('API_LABEL = "Runtime Test";', bundle.code)
-            
-            
+
             # Verify bundle was written to output directory
             bundle_files = list(output_dir.glob("client.*.js"))
-            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
-            
+            self.assertGreater(
+                len(bundle_files), 0, "Expected at least one bundle file"
+            )
+
             # Verify cached bundle is identical
             cached = builder.build(module, force=False)
             self.assertEqual(bundle.hash, cached.hash)
@@ -181,33 +192,38 @@ export default defineConfig({
         """Test that missing package.json raises appropriate error."""
         fixtures_dir = Path(__file__).parent / "fixtures" / "basic-app"
         (module,) = Jac.jac_import("app", str(fixtures_dir))
-        
+
         runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-        
+
         # Create builder without package.json
         builder = ViteClientBundleBuilder(
             runtime_path=runtime_path,
             vite_package_json=Path("/nonexistent/package.json"),
             vite_output_dir=Path("/tmp/output"),
         )
-        
+
         # Building should raise an error
         from jaclang.runtimelib.client_bundle import ClientBundleError
+
         with self.assertRaises(ClientBundleError) as cm:
             builder.build(module, force=True)
-        
+
         self.assertIn("Vite package.json not found", str(cm.exception))
 
     def test_build_bundle_with_antd(self) -> None:
         """Test that Vite bundling works with Ant Design components."""
         with tempfile.TemporaryDirectory() as temp_dir:
-            
+
             temp_path = Path(temp_dir)
-            
+
             # Create project with Vite and Ant Design installed
-            package_json, output_dir = self._create_test_project_with_vite(temp_path, include_antd=True)
-            runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-            
+            package_json, output_dir = self._create_test_project_with_vite(
+                temp_path, include_antd=True
+            )
+            runtime_path = (
+                Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
+            )
+
             # Initialize the Vite builder
             builder = ViteClientBundleBuilder(
                 runtime_path=runtime_path,
@@ -215,36 +231,38 @@ export default defineConfig({
                 vite_output_dir=output_dir,
                 vite_minify=False,
             )
-            
+
             # Import the test module with Ant Design
             fixtures_dir = Path(__file__).parent / "fixtures" / "client_app_with_antd"
             (module,) = Jac.jac_import("app", str(fixtures_dir))
-            
+
             # Build the bundle
             bundle = builder.build(module, force=True)
-            
+
             # Verify bundle structure
             self.assertIsNotNone(bundle)
             self.assertEqual(bundle.module_name, "app")
             self.assertIn("ButtonTest", bundle.client_functions)
             self.assertIn("CardTest", bundle.client_functions)
             self.assertIn("APP_NAME", bundle.client_globals)
-            
+
             # Verify bundle code contains expected content
             self.assertIn("function ButtonTest()", bundle.code)
             self.assertIn("function CardTest()", bundle.code)
             self.assertIn('APP_NAME = "Ant Design Test";', bundle.code)
-            
+
             # verify antd components are present
             self.assertIn("ButtonGroup", bundle.code)
 
             # Verify the Ant Design fixture content is present
             self.assertIn("Testing Ant Design integration", bundle.code)
-            
+
             # Verify bundle was written to output directory
             bundle_files = list(output_dir.glob("client.*.js"))
-            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
-            
+            self.assertGreater(
+                len(bundle_files), 0, "Expected at least one bundle file"
+            )
+
             # Cleanup
             builder.cleanup_temp_dir()
 
@@ -252,11 +270,15 @@ export default defineConfig({
         """Test that relative imports work correctly in Vite bundling."""
         with tempfile.TemporaryDirectory() as temp_dir:
             temp_path = Path(temp_dir)
-            
+
             # Create project with Vite installed
-            package_json, output_dir = self._create_test_project_with_vite(temp_path, include_antd=True)
-            runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-            
+            package_json, output_dir = self._create_test_project_with_vite(
+                temp_path, include_antd=True
+            )
+            runtime_path = (
+                Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
+            )
+
             # Initialize the Vite builder
             builder = ViteClientBundleBuilder(
                 runtime_path=runtime_path,
@@ -264,32 +286,34 @@ export default defineConfig({
                 vite_output_dir=output_dir,
                 vite_minify=False,
             )
-            
+
             # Import the test module with relative import
             fixtures_dir = Path(__file__).parent / "fixtures" / "relative_import"
             (module,) = Jac.jac_import("app", str(fixtures_dir))
-            
+
             # Build the bundle
             bundle = builder.build(module, force=True)
-            
+
             # Verify bundle structure
             self.assertIsNotNone(bundle)
             self.assertEqual(bundle.module_name, "app")
             self.assertIn("RelativeImport", bundle.client_functions)
             self.assertIn("app", bundle.client_functions)
             self.assertIn("CustomButton", bundle.code)
-            
+
             # Verify bundle code contains expected content
             self.assertIn("function RelativeImport()", bundle.code)
             self.assertIn("function app()", bundle.code)
-            
+
             # Verify that the relative import (Button from .button) is properly resolved
             self.assertIn("ButtonGroup", bundle.code)
-            
+
             # Verify bundle was written to output directory
             bundle_files = list(output_dir.glob("client.*.js"))
-            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
-            
+            self.assertGreater(
+                len(bundle_files), 0, "Expected at least one bundle file"
+            )
+
             # Cleanup
             builder.cleanup_temp_dir()
 
@@ -299,7 +323,9 @@ export default defineConfig({
             temp_path = Path(temp_dir)
             # Create project with Vite installed
             package_json, output_dir = self._create_test_project_with_vite(temp_path)
-            runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
+            runtime_path = (
+                Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
+            )
             # Initialize the Vite builder
             builder = ViteClientBundleBuilder(
                 runtime_path=runtime_path,
@@ -307,53 +333,57 @@ export default defineConfig({
                 vite_output_dir=output_dir,
                 vite_minify=False,
             )
-            
+
             # Import the test module with JavaScript import
             fixtures_dir = Path(__file__).parent / "fixtures" / "js_import"
             (module,) = Jac.jac_import("app", str(fixtures_dir))
-            
+
             # Build the bundle
             bundle = builder.build(module, force=True)
-            
+
             # Verify bundle structure
             self.assertIsNotNone(bundle)
             self.assertEqual(bundle.module_name, "app")
             self.assertIn("JsImportTest", bundle.client_functions)
             self.assertIn("app", bundle.client_functions)
             self.assertIn("JS_IMPORT_LABEL", bundle.client_globals)
-            
+
             # Verify bundle code contains expected content
             self.assertIn("function JsImportTest()", bundle.code)
             self.assertIn("function app()", bundle.code)
             self.assertIn('JS_IMPORT_LABEL = "JavaScript Import Test";', bundle.code)
-            
+
             # Verify JavaScript imports are present in the bundle
             # The JavaScript functions should be available in the bundle
             self.assertIn("formatMessage", bundle.code)
             self.assertIn("calculateSum", bundle.code)
             self.assertIn("JS_CONSTANT", bundle.code)
             self.assertIn("MessageFormatter", bundle.code)
-            
+
             # Verify the JavaScript utility code is included
             self.assertIn("Hello,", bundle.code)  # From formatMessage function
             self.assertIn("Imported from JavaScript", bundle.code)  # From JS_CONSTANT
-            
+
             # Verify bundle was written to output directory
             bundle_files = list(output_dir.glob("client.*.js"))
-            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
-            
+            self.assertGreater(
+                len(bundle_files), 0, "Expected at least one bundle file"
+            )
+
             # Cleanup
             builder.cleanup_temp_dir()
-            
+
     def test_jsx_fragments_and_spread_props(self) -> None:
         """Test that JSX fragments and spread props work correctly."""
         with tempfile.TemporaryDirectory() as temp_dir:
             temp_path = Path(temp_dir)
-            
+
             # Create project with Vite installed
             package_json, output_dir = self._create_test_project_with_vite(temp_path)
-            runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
-            
+            runtime_path = (
+                Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
+            )
+
             # Initialize the Vite builder
             builder = ViteClientBundleBuilder(
                 runtime_path=runtime_path,
@@ -361,14 +391,14 @@ export default defineConfig({
                 vite_output_dir=output_dir,
                 vite_minify=False,
             )
-            
+
             # Import the test module with fragments and spread props
             fixtures_dir = Path(__file__).parent / "fixtures" / "test_fragments_spread"
             (module,) = Jac.jac_import("app", str(fixtures_dir))
-            
+
             # Build the bundle
             bundle = builder.build(module, force=True)
-            
+
             # Verify bundle structure
             self.assertIsNotNone(bundle)
             self.assertEqual(bundle.module_name, "app")
@@ -376,20 +406,22 @@ export default defineConfig({
             self.assertIn("SpreadPropsTest", bundle.client_functions)
             self.assertIn("MixedTest", bundle.client_functions)
             self.assertIn("NestedFragments", bundle.client_functions)
-            
+
             # Verify spread props handling (Object.assign is used by compiler)
             self.assertIn("Object.assign", bundle.code)
-            
+
             # Verify fragment test function exists
             self.assertIn("function FragmentTest()", bundle.code)
-            
+
             # Verify spread props test function exists
             self.assertIn("function SpreadPropsTest()", bundle.code)
-            
+
             # Verify bundle was written to output directory
             bundle_files = list(output_dir.glob("client.*.js"))
-            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
-            
+            self.assertGreater(
+                len(bundle_files), 0, "Expected at least one bundle file"
+            )
+
             # Cleanup
             builder.cleanup_temp_dir()
 
@@ -400,7 +432,9 @@ export default defineConfig({
 
             # Create project with Vite installed
             package_json, output_dir = self._create_test_project_with_vite(temp_path)
-            runtime_path = Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
+            runtime_path = (
+                Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
+            )
 
             # Initialize the Vite builder
             builder = ViteClientBundleBuilder(
@@ -434,7 +468,7 @@ export default defineConfig({
             # Should generate: __jacSpawn("test_walker", "", {message: "Reverse spawn!"})
             self.assertRegex(
                 bundle.code,
-                r'__jacSpawn\("test_walker",\s*"",\s*\{[^}]*"message":\s*"Reverse spawn!"[^}]*\}\)'
+                r'__jacSpawn\("test_walker",\s*"",\s*\{[^}]*"message":\s*"Reverse spawn!"[^}]*\}\)',
             )
 
             # Verify UUID spawn scenarios with complete calls
@@ -447,7 +481,7 @@ export default defineConfig({
             # Should generate: __jacSpawn("parameterized_walker", another_node_id, {value: 100})
             self.assertRegex(
                 bundle.code,
-                r'__jacSpawn\("parameterized_walker",\s*another_node_id,\s*\{[^}]*"value":\s*100[^}]*\}\)'
+                r'__jacSpawn\("parameterized_walker",\s*another_node_id,\s*\{[^}]*"value":\s*100[^}]*\}\)',
             )
             self.assertIn('"6ba7b810-9dad-11d1-80b4-00c04fd430c8"', bundle.code)
 
@@ -464,13 +498,57 @@ export default defineConfig({
 
             # Verify we have at least 7 __jacSpawn calls (previous cases + new positional/spread)
             self.assertTrue(
-                bundle.code.count('__jacSpawn') >= 7,
-                "Expected at least 7 __jacSpawn calls in bundle"
+                bundle.code.count("__jacSpawn") >= 7,
+                "Expected at least 7 __jacSpawn calls in bundle",
             )
 
             # Verify bundle was written to output directory
             bundle_files = list(output_dir.glob("client.*.js"))
-            self.assertGreater(len(bundle_files), 0, "Expected at least one bundle file")
+            self.assertGreater(
+                len(bundle_files), 0, "Expected at least one bundle file"
+            )
+
+            # Cleanup
+            builder.cleanup_temp_dir()
+
+    def test_serve_cl_file(self) -> None:
+        """Test that serving a .cl file works correctly."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create project with Vite installed
+            package_json, output_dir = self._create_test_project_with_vite(temp_path)
+            runtime_path = (
+                Path(__file__).parent.parent / "plugin" / "client_runtime.jac"
+            )
+
+            # Initialize the Vite builder
+            builder = ViteClientBundleBuilder(
+                runtime_path=runtime_path,
+                vite_package_json=package_json,
+                vite_output_dir=output_dir,
+                vite_minify=False,
+            )
 
+            # Import the test module with both spawn operator orderings
+            fixtures_dir = Path(__file__).parent / "fixtures" / "cl_file"
+            (module,) = Jac.jac_import("app", str(fixtures_dir))
+
+            # Build the bundle
+            bundle = builder.build(module, force=True)
+            # Verify bundle structure
+            self.assertIsNotNone(bundle)
+            self.assertEqual(bundle.module_name, "app")
+            self.assertIn("app", bundle.client_functions)
+
+            self.assertIn("function app()", bundle.code)
+            self.assertIn(
+                '__jacJsx("div", {}, [__jacJsx("h2", {}, ["My Todos"])', bundle.code
+            )
+            self.assertIn("root.render(/* @__PURE__ */ React.c", bundle.code)
+            self.assertIn(
+                "ar _useState = reactExports.useState([]), _useStat", bundle.code
+            )
+            self.assertIn('turn __jacSpawn("create_todo", ', bundle.code)
             # Cleanup
             builder.cleanup_temp_dir()