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

jac_client/tests/fixtures/spawn_test/app.jac

@@ -0,0 +1,133 @@
+"""Test module for spawn operator in both standard and reverse order."""
+
+# Server-side node and walker definitions
+node TestNode {
+    has value: int = 0;
+}
+
+walker test_walker {
+    has message: str = "Hello from walker";
+
+    can execute with `root entry {
+        report {"result": self.message} ;
+    }
+}
+
+walker parameterized_walker {
+    has value: int;
+
+    can execute with `root entry {
+        report {"computed": self.value * 2} ;
+    }
+}
+
+walker positional_walker {
+    has label: str;
+    has count: int;
+    has metadata: dict = {};
+
+    can execute with `root entry {
+        report {
+            "label": self.label,
+            "count": self.count,
+            "meta": self.metadata
+        } ;
+    }
+}
+
+# Client-side code testing both spawn orderings
+cl import from react {
+    useState,
+    useEffect
+}
+
+cl {
+    def app()  -> any {
+        let [standardResult, setStandardResult] = useState(None);
+        let [standardComputed, setStandardComputed] = useState(None);
+        let [reverseResult, setReverseResult] = useState(None);
+        let [uuidResult, setUuidResult] = useState(None);
+        let [reverseUuidResult, setReverseUuidResult] = useState(None);
+        let [positionalResult, setPositionalResult] = useState(None);
+        let [spreadResult, setSpreadResult] = useState(None);
+
+        async def loadData()  -> None {
+            # Test standard spawn order: node spawn walker()
+            data1 = root spawn test_walker();
+            setStandardResult(data1);
+
+            data2 = root spawn parameterized_walker(value=42);
+            setStandardComputed(data2);
+
+            # Test reverse spawn order: walker() spawn node
+            data3 = test_walker(message="Reverse spawn!") spawn root;
+            setReverseResult(data3);
+
+            # Test spawn with UUID string: uuid_string spawn walker()
+            node_id = "550e8400-e29b-41d4-a716-446655440000";
+            data4 = node_id spawn test_walker();
+            setUuidResult(data4);
+
+            # Test reverse spawn with UUID string: walker() spawn uuid_string
+            another_node_id = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+            data5 = parameterized_walker(value=100) spawn another_node_id;
+            setReverseUuidResult(data5);
+
+            # Test positional walker arguments inferred from has fields
+            data6 = node_id spawn positional_walker("Node positional", 2);
+            setPositionalResult(data6);
+
+            # Test **kwargs via spread when walker is on left-hand side
+            extra_fields = {"metadata": {"source": "client-side"}};
+            data7 = positional_walker("Spread order", 5, **extra_fields) spawn root;
+            setSpreadResult(data7);
+        }
+
+        useEffect(lambda   -> None{ loadData();} , []);
+
+        return <div>
+            <h1>
+                Spawn Operator Test
+            </h1>
+            <h2>
+                Standard Order (node spawn walker)
+            </h2>
+            <div>
+                Result: {JSON.stringify(standardResult)}
+            </div>
+            <div>
+                Computed: {JSON.stringify(standardComputed)}
+            </div>
+            <h2>
+                Reverse Order (walker spawn node)
+            </h2>
+            <div>
+                Result: {JSON.stringify(reverseResult)}
+            </div>
+            <h2>
+                UUID Spawn (uuid spawn walker)
+            </h2>
+            <div>
+                Result: {JSON.stringify(uuidResult)}
+            </div>
+            <h2>
+                Reverse UUID Spawn (walker spawn uuid)
+            </h2>
+            <div>
+                Result: {JSON.stringify(reverseUuidResult)}
+            </div>
+            <h2>
+                Positional Walker Arguments
+            </h2>
+            <div>
+                Result: {JSON.stringify(positionalResult)}
+            </div>
+            <h2>
+                Spread Walker Arguments
+            </h2>
+            <div>
+                Result: {JSON.stringify(spreadResult)}
+            </div>
+        </div>;
+    }
+}

jac_client/tests/fixtures/{test_fragments_spread.jac → test_fragments_spread/app.jac}

@@ -11,7 +11,7 @@ cl def FragmentTest() {
 cl def SpreadPropsTest() {
     # Test spread props
     unwrapped = {"id": "my-div", "class": "container", "data-role": "main"};
-    
+
     return <div {...unwrapped}>
         <span>{"Spread props work!"}</span>
     </div>;
@@ -20,7 +20,7 @@ cl def SpreadPropsTest() {
 cl def MixedTest() {
     # Test mixing spread props with regular props
     baseStyle = {"id": "base-id", "color": "blue"};
-    
+
     return <>
         <div {...baseStyle} class="override">
             {"Mixed test"}
@@ -42,3 +42,12 @@ cl def NestedFragments() {
     </div>;
 }
 
+cl def app() {
+    return <div>
+        <FragmentTest />
+        <SpreadPropsTest />
+        <MixedTest />
+        <NestedFragments />
+    </div>;
+}
+

jac_client/tests/test_asset_examples.py

@@ -0,0 +1,339 @@
+"""Tests for asset-serving and css-styling examples."""
+
+from __future__ import annotations
+
+from pathlib import Path
+import json
+import shutil
+import tempfile
+import subprocess
+
+from jaclang.runtimelib.machine import JacMachine as Jac
+from jaclang.utils.test import TestCase
+from jac_client.plugin.vite_client_bundle import ViteClientBundleBuilder
+
+
+class AssetServingExampleTests(TestCase):
+    """Test asset-serving examples."""
+
+    def setUp(self) -> None:
+        Jac.reset_machine()
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        Jac.reset_machine()
+        return super().tearDown()
+
+    def _create_test_project_with_vite(
+        self, temp_path: Path, include_assets: bool = False
+    ) -> tuple[Path, Path]:
+        """Create a minimal test project with Vite installed.
+
+        Args:
+            temp_path: Path to the temporary directory
+            include_assets: If True, includes asset handling setup
+        """
+        # Create package.json with base dependencies
+        package_data = {
+            "name": "test-client",
+            "version": "0.0.1",
+            "type": "module",
+            "scripts": {
+                "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',
+            },
+            "dependencies": {
+                "react": "^19.2.0",
+                "react-dom": "^19.2.0",
+                "react-router-dom": "^7.3.0",
+            },
+            "devDependencies": {
+                "vite": "^6.4.1",
+                "@babel/cli": "^7.28.3",
+                "@babel/core": "^7.28.5",
+                "@babel/preset-env": "^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(
+            """{
+    "presets": [[
+        "@babel/preset-env",
+        {
+            "modules": false
+        }
+    ], "@babel/preset-react"]
+}
+""",
+            encoding="utf-8",
+        )
+
+        # Create vite.config.js file
+        vite_config = temp_path / "vite.config.js"
+        if include_assets:
+            vite_config.write_text(
+                """import { defineConfig } from "vite";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  root: ".",
+  build: {
+    rollupOptions: {
+      input: "build/main.js",
+      output: {
+        entryFileNames: "client.[hash].js",
+        assetFileNames: "[name].[ext]",
+      },
+    },
+    outDir: "dist",
+    emptyOutDir: true,
+    minify: false,
+  },
+  publicDir: false,
+  resolve: {
+    alias: {
+      "@jac-client/utils": path.resolve(__dirname, "src/client_runtime.js"),
+      "@jac-client/assets": path.resolve(__dirname, "src/assets"),
+    },
+  },
+});
+""",
+                encoding="utf-8",
+            )
+        else:
+            vite_config.write_text(
+                """import { defineConfig } from "vite";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export default defineConfig({
+  root: ".",
+  build: {
+    rollupOptions: {
+      input: "build/main.js",
+      output: {
+        entryFileNames: "client.[hash].js",
+        assetFileNames: "[name].[ext]",
+      },
+    },
+    outDir: "dist",
+    emptyOutDir: true,
+    minify: false,
+  },
+  publicDir: false,
+  resolve: {
+    alias: {
+      "@jac-client/utils": path.resolve(__dirname, "src/client_runtime.js"),
+    },
+  },
+});
+""",
+                encoding="utf-8",
+            )
+
+        # Install dependencies
+        result = subprocess.run(
+            ["npm", "install"],
+            cwd=temp_path,
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            error_msg = f"npm install failed with exit code {result.returncode}\n"
+            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_image_asset_example(self) -> None:
+        """Test image-asset example with static asset paths."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            package_json, output_dir = self._create_test_project_with_vite(
+                temp_path, include_assets=True
+            )
+            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 image-asset example
+            examples_dir = (
+                Path(__file__).parent.parent
+                / "examples"
+                / "asset-serving"
+                / "image-asset"
+            )
+            (module,) = Jac.jac_import("app", str(examples_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)
+
+            # Verify image path is in the bundle
+            self.assertIn("/static/assets/burger.png", 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"
+            )
+
+            # Cleanup
+            builder.cleanup_temp_dir()
+
+    def test_css_with_image_example(self) -> None:
+        """Test css-with-image example with CSS and image assets."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            package_json, output_dir = self._create_test_project_with_vite(
+                temp_path, include_assets=True
+            )
+            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 css-with-image example
+            examples_dir = (
+                Path(__file__).parent.parent
+                / "examples"
+                / "asset-serving"
+                / "css-with-image"
+            )
+            (module,) = Jac.jac_import("app", str(examples_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)
+
+            # Verify CSS import is present (CSS should be extracted to separate file)
+            # The bundle should reference the CSS file
+            self.assertIn("import", bundle.code.lower())
+
+            # Verify image paths are in the bundle
+            self.assertIn("/static/assets/burger.png", bundle.code)
+
+            # Verify CSS file was extracted
+            css_files = list(output_dir.glob("*.css"))
+            self.assertGreater(len(css_files), 0, "Expected at least one CSS file")
+
+            # 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"
+            )
+
+            # Cleanup
+            builder.cleanup_temp_dir()
+
+    def test_import_alias_example(self) -> None:
+        """Test import-alias example with @jac-client/assets alias."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            package_json, output_dir = self._create_test_project_with_vite(
+                temp_path, include_assets=True
+            )
+            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 import-alias example
+            examples_dir = (
+                Path(__file__).parent.parent
+                / "examples"
+                / "asset-serving"
+                / "import-alias"
+            )
+            (module,) = Jac.jac_import("app", str(examples_dir))
+
+            # Copy assets from example directory to temp project's src/assets/
+            # This is needed because @jac-client/assets alias points to src/assets
+            example_assets_dir = examples_dir / "assets"
+            temp_assets_dir = temp_path / "src" / "assets"
+            if example_assets_dir.exists():
+                temp_assets_dir.mkdir(parents=True, exist_ok=True)
+                # Copy all files from example assets to temp assets
+                for asset_file in example_assets_dir.iterdir():
+                    if asset_file.is_file():
+                        shutil.copy2(asset_file, temp_assets_dir / asset_file.name)
+
+            # 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)
+
+            # Verify the import alias was processed by Vite
+            # Vite should have resolved the asset import
+            # The bundle should contain the processed asset URL
+            self.assertIn("burgerImage", 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"
+            )
+
+            # Cleanup
+            builder.cleanup_temp_dir()