PyPI - jac-client - Versions diffs - 0.2.0__py3-none-any.whl - Mend

jac-client 0.2.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (72) hide show

jac_client/docs/README.md +659 -0
jac_client/docs/advanced-state.md +1266 -0
jac_client/docs/assets/pipe_line.png +0 -0
jac_client/docs/guide-example/intro.md +117 -0
jac_client/docs/guide-example/step-01-setup.md +260 -0
jac_client/docs/guide-example/step-02-components.md +416 -0
jac_client/docs/guide-example/step-03-styling.md +478 -0
jac_client/docs/guide-example/step-04-todo-ui.md +477 -0
jac_client/docs/guide-example/step-05-local-state.md +530 -0
jac_client/docs/guide-example/step-06-events.md +750 -0
jac_client/docs/guide-example/step-07-effects.md +469 -0
jac_client/docs/guide-example/step-08-walkers.md +534 -0
jac_client/docs/guide-example/step-09-authentication.md +586 -0
jac_client/docs/guide-example/step-10-routing.md +540 -0
jac_client/docs/guide-example/step-11-final.md +964 -0
jac_client/docs/imports.md +1142 -0
jac_client/docs/lifecycle-hooks.md +774 -0
jac_client/docs/routing.md +660 -0
jac_client/examples/basic/.babelrc +9 -0
jac_client/examples/basic/README.md +16 -0
jac_client/examples/basic/app.jac +16 -0
jac_client/examples/basic/package.json +27 -0
jac_client/examples/basic/vite.config.js +28 -0
jac_client/examples/basic-auth/.babelrc +9 -0
jac_client/examples/basic-auth/README.md +16 -0
jac_client/examples/basic-auth/app.jac +308 -0
jac_client/examples/basic-auth/package.json +27 -0
jac_client/examples/basic-auth/vite.config.js +28 -0
jac_client/examples/basic-auth-with-router/.babelrc +9 -0
jac_client/examples/basic-auth-with-router/README.md +60 -0
jac_client/examples/basic-auth-with-router/app.jac +464 -0
jac_client/examples/basic-auth-with-router/package.json +28 -0
jac_client/examples/basic-auth-with-router/vite.config.js +28 -0
jac_client/examples/basic-full-stack/.babelrc +9 -0
jac_client/examples/basic-full-stack/README.md +18 -0
jac_client/examples/basic-full-stack/app.jac +320 -0
jac_client/examples/basic-full-stack/package.json +28 -0
jac_client/examples/basic-full-stack/vite.config.js +28 -0
jac_client/examples/full-stack-with-auth/.babelrc +9 -0
jac_client/examples/full-stack-with-auth/README.md +16 -0
jac_client/examples/full-stack-with-auth/app.jac +735 -0
jac_client/examples/full-stack-with-auth/package.json +28 -0
jac_client/examples/full-stack-with-auth/vite.config.js +30 -0
jac_client/examples/little-x/app.jac +615 -0
jac_client/examples/little-x/package.json +23 -0
jac_client/examples/little-x/submit-button.jac +8 -0
jac_client/examples/with-router/.babelrc +9 -0
jac_client/examples/with-router/README.md +17 -0
jac_client/examples/with-router/app.jac +323 -0
jac_client/examples/with-router/package.json +28 -0
jac_client/examples/with-router/vite.config.js +28 -0
jac_client/plugin/cli.py +239 -0
jac_client/plugin/client.py +89 -0
jac_client/plugin/client_runtime.jac +234 -0
jac_client/plugin/vite_client_bundle.py +355 -0
jac_client/tests/__init__.py +2 -0
jac_client/tests/fixtures/basic-app/app.jac +18 -0
jac_client/tests/fixtures/client_app_with_antd/app.jac +28 -0
jac_client/tests/fixtures/js_import/app.jac +30 -0
jac_client/tests/fixtures/js_import/utils.js +22 -0
jac_client/tests/fixtures/package-lock.json +329 -0
jac_client/tests/fixtures/package.json +11 -0
jac_client/tests/fixtures/relative_import/app.jac +13 -0
jac_client/tests/fixtures/relative_import/button.jac +6 -0
jac_client/tests/fixtures/spawn_test/app.jac +133 -0
jac_client/tests/fixtures/test_fragments_spread/app.jac +53 -0
jac_client/tests/test_cl.py +476 -0
jac_client/tests/test_create_jac_app.py +139 -0
jac_client-0.2.0.dist-info/METADATA +182 -0
jac_client-0.2.0.dist-info/RECORD +72 -0
jac_client-0.2.0.dist-info/WHEEL +4 -0
jac_client-0.2.0.dist-info/entry_points.txt +4 -0

jac_client/plugin/client.py ADDED Viewed

@@ -0,0 +1,89 @@
+import html
+import types
+from pathlib import Path
+from typing import Any
+from jaclang.runtimelib.client_bundle import ClientBundle
+from jaclang.runtimelib.machine import (
+    JacMachine as Jac,
+    hookimpl,
+)
+from jaclang.runtimelib.server import ModuleIntrospector
+from .vite_client_bundle import ViteClientBundleBuilder
+class JacClientModuleIntrospector(ModuleIntrospector):
+    """Jac Client Module Introspector."""
+    def render_page(
+        self, function_name: str, args: dict[str, Any], username: str
+    ) -> dict[str, Any]:
+        """Render HTML page for client function using the Vite bundle."""
+        self.load()
+        available_exports = set(self._client_manifest.get("exports", [])) or set(
+            self.get_client_functions().keys()
+        )
+        if function_name not in available_exports:
+            raise ValueError(f"Client function '{function_name}' not found")
+        bundle_hash = self.ensure_bundle()
+        page = (
+            "<!DOCTYPE html>"
+            '<html lang="en">'
+            "<head>"
+            '<meta charset="utf-8"/>'
+            f"<title>{html.escape(function_name)}</title>"
+            "</head>"
+            "<body>"
+            '<div id="root"></div>'
+            f'<script src="/static/client.js?hash={bundle_hash}" defer></script>'
+            "</body>"
+            "</html>"
+        )
+        return {
+            "html": page,
+            "bundle_hash": bundle_hash,
+            "bundle_code": self._bundle.code,
+        }
+class JacClient:
+    """Jac Client."""
+    @staticmethod
+    @hookimpl
+    def get_client_bundle_builder() -> ViteClientBundleBuilder:
+        """Get the client bundle builder instance."""
+        base_path = Path(Jac.base_path_dir)
+        package_json_path = base_path / "package.json"
+        output_dir = base_path / "dist"
+        # Use the plugin's client_runtime.jac file
+        runtime_path = Path(__file__).with_name("client_runtime.jac")
+        return ViteClientBundleBuilder(
+            runtime_path=runtime_path,
+            vite_package_json=package_json_path,
+            vite_output_dir=output_dir,
+            vite_minify=False,
+        )
+    @staticmethod
+    @hookimpl
+    def build_client_bundle(
+        module: types.ModuleType,
+        force: bool = False,
+    ) -> ClientBundle:
+        """Build a client bundle for the supplied module."""
+        builder = JacClient.get_client_bundle_builder()
+        return builder.build(module, force=force)
+    @staticmethod
+    @hookimpl
+    def get_module_introspector(
+        module_name: str, base_path: str | None
+    ) -> ModuleIntrospector:
+        """Get a module introspector for the supplied module."""
+        return JacClientModuleIntrospector(module_name, base_path)

jac_client/plugin/client_runtime.jac ADDED Viewed

@@ -0,0 +1,234 @@
+"""Client-side runtime for Jac JSX and walker interactions."""
+cl import from 'react' { * as React }
+cl import from 'react-dom/client' { * as ReactDOM }
+cl import from 'react-router-dom' {
+    HashRouter as ReactRouterHashRouter,
+    Routes as ReactRouterRoutes,
+    Route as ReactRouterRoute,
+    Link as ReactRouterLink,
+    Navigate as ReactRouterNavigate,
+    useNavigate as reactRouterUseNavigate,
+    useLocation as reactRouterUseLocation,
+    useParams as reactRouterUseParams
+}
+cl {
+    # JSX factory function - uses React.createElement
+    def __jacJsx(tag: any, props: dict = {}, children: any = []) -> any {
+        # Handle fragments: when tag is None/null, use React.Fragment
+        if tag == None {
+            tag = React.Fragment;
+        }
+        childrenArray = [];
+        if children != None {
+            if Array.isArray(children) {
+                childrenArray = children;
+            } else {
+                childrenArray = [children];
+            }
+        }
+        # Filter out null/undefined children
+        reactChildren = [];
+        for child in childrenArray {
+            if child != None {
+                reactChildren.push(child);
+            }
+        }
+        if reactChildren.length > 0 {
+            args = [tag, props];
+            for child in reactChildren {
+                args.push(child);
+            }
+            return React.createElement.apply(React, args);
+        } else {
+            return React.createElement(tag, props);
+        }
+    }
+    # ============================================================================
+    # React Router Integration (using react-router-dom v6)
+    # ============================================================================
+    # Direct re-exports of React Router components for seamless integration
+    # Router uses HashRouter for hash-based routing (#/path)
+    # See: https://reactrouter.com/6.30.1/router-components/hash-router
+    let Router = ReactRouterHashRouter;
+    let Routes = ReactRouterRoutes;
+    let Route = ReactRouterRoute;
+    let Link = ReactRouterLink;
+    let Navigate = ReactRouterNavigate;
+    # React Router Hooks - wrapped for Jac compatibility
+    let useNavigate = reactRouterUseNavigate;
+    let useLocation = reactRouterUseLocation;
+    let useParams = reactRouterUseParams;
+    # useRouter Hook - convenience hook that combines common router utilities
+    def useRouter()  -> dict {
+        navigate = reactRouterUseNavigate();
+        location = reactRouterUseLocation();
+        params = reactRouterUseParams();
+        return {
+            "navigate": navigate,
+            "location": location,
+            "params": params,
+            "pathname": location.pathname,
+            "search": location.search,
+            "hash": location.hash
+        };
+    }
+    # navigate function - programmatic navigation (backward compatibility)
+    # Note: Use useNavigate() hook inside components instead
+    def navigate(path: str) -> None {
+        window.location.hash = "#" + path;
+    }
+    # ============================================================================
+    # Walker spawn function
+    # ============================================================================
+    async def __jacSpawn(left: str, right: str = "", fields: dict = {}) -> any {
+        token = __getLocalStorage("jac_token");
+        url = f"/walker/{left}";
+        if right != "" {
+            url = f"/walker/{left}/{right}";
+        }
+        response = await fetch(
+            url,
+            {
+                "method": "POST",
+                "accept": "application/json",
+                "headers": {
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {token}" if token else ""
+                },
+                "body": JSON.stringify({"fields": fields})
+            }
+        );
+        if not response.ok {
+            error_text = await response.json();
+            raise Exception(f"Walker {walker} failed: {error_text}") ;
+        }
+        return await response.json();
+    }
+    def jacSpawn(left: str, right: str = "", fields: dict = {}) -> any {
+        return __jacSpawn(left, right, fields);
+    }
+    # Function call function - calls server-side functions from client
+    async def __jacCallFunction(function_name: str, args: dict = {}) -> any {
+        token = __getLocalStorage("jac_token");
+        response = await fetch(
+            f"/function/{function_name}",
+            {
+                "method": "POST",
+                "headers": {
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {token}" if token else ""
+                },
+                "body": JSON.stringify({"args": args})
+            }
+        );
+        if not response.ok {
+            error_text = await response.text();
+            raise Exception(f"Function {function_name} failed: {error_text}") ;
+        }
+        data = JSON.parse(await response.text());
+        return data["result"];
+    }
+    # Authentication helpers
+    async def jacSignup(username: str, password: str) -> dict {
+        response = await fetch(
+            "/user/create",
+            {
+                "method": "POST",
+                "headers": {"Content-Type": "application/json"},
+                "body": JSON.stringify({"username": username, "password": password})
+            }
+        );
+        if response.ok {
+            data = JSON.parse(await response.text());
+            token = data["token"];
+            if token {
+                __setLocalStorage("jac_token", token);
+                return {"success": True, "token": token, "username": username};
+            }
+            return {"success": False, "error": "No token received"};
+        } else {
+            error_text = await response.text();
+            try {
+                error_data = JSON.parse(error_text);
+                return {
+                    "success": False,
+                    "error": error_data["error"]
+                    if error_data["error"] != None
+                    else "Signup failed"
+                };
+            } except Exception {
+                return {"success": False, "error": error_text};
+            }
+        }
+    }
+    async def jacLogin(username: str, password: str) -> bool {
+        response = await fetch(
+            "/user/login",
+            {
+                "method": "POST",
+                "headers": {"Content-Type": "application/json"},
+                "body": JSON.stringify({"username": username, "password": password})
+            }
+        );
+        if response.ok {
+            data = JSON.parse(await response.text());
+            token = data["token"];
+            if token {
+                __setLocalStorage("jac_token", token);
+                return True;
+            }
+        }
+        return False;
+    }
+    def jacLogout()  -> None {
+        __removeLocalStorage("jac_token");
+    }
+    def jacIsLoggedIn()  -> bool {
+        token = __getLocalStorage("jac_token");
+        return token != None and token != "";
+    }
+    # Browser API shims
+    def __getLocalStorage(key: str) -> str {
+        storage = globalThis.localStorage;
+        return storage.getItem(key) if storage else "";
+    }
+    def __setLocalStorage(key: str, value: str) -> None {
+        storage = globalThis.localStorage;
+        if storage {
+            storage.setItem(key, value);
+        }
+    }
+    def __removeLocalStorage(key: str) -> None {
+        storage = globalThis.localStorage;
+        if storage {
+            storage.removeItem(key);
+        }
+    }
+}

jac_client/plugin/vite_client_bundle.py ADDED Viewed

@@ -0,0 +1,355 @@
+"""Vite-enhanced client bundle generation for Jac web front-ends."""
+from __future__ import annotations
+import contextlib
+import hashlib
+import shutil
+import subprocess
+from pathlib import Path
+from types import ModuleType
+from typing import Any, TYPE_CHECKING
+from jaclang.runtimelib.client_bundle import (
+    ClientBundle,
+    ClientBundleBuilder,
+    ClientBundleError,
+)
+if TYPE_CHECKING:
+    from jaclang.compiler.codeinfo import ClientManifest
+class ViteClientBundleBuilder(ClientBundleBuilder):
+    """Enhanced ClientBundleBuilder that uses Vite for optimized bundling."""
+    def __init__(
+        self,
+        runtime_path: Path | None = None,
+        vite_output_dir: Path | None = None,
+        vite_package_json: Path | None = None,
+        vite_minify: bool = False,
+    ) -> None:
+        """Initialize the Vite-enhanced bundle builder.
+        Args:
+            runtime_path: Path to client runtime file
+            vite_output_dir: Output directory for Vite builds (defaults to temp/dist)
+            vite_package_json: Path to package.json for Vite (required)
+            vite_minify: Whether to enable minification in Vite build
+        """
+        super().__init__(runtime_path)
+        self.vite_output_dir = vite_output_dir
+        self.vite_package_json = vite_package_json
+        self.vite_minify = vite_minify
+    def _process_imports(
+        self, manifest: ClientManifest | None, module_path: Path
+    ) -> list[Path | None]:  # type: ignore[override]
+        """Process client imports for Vite bundling.
+        Only mark modules as bundled when we actually inline their code (.jac files we compile
+        and local .js files we embed). Bare package specifiers (e.g., "antd") are left as real
+        ES imports so Vite can resolve and bundle them.
+        """
+        imported_js_modules: list[Path | None] = []
+        if manifest and manifest.imports:
+            for _, import_path in manifest.imports.items():
+                import_path_obj = Path(import_path)
+                if import_path_obj.suffix == ".js":
+                    # Inline local JS files and mark as bundled
+                    try:
+                        imported_js_modules.append(import_path_obj)
+                    except FileNotFoundError:
+                        imported_js_modules.append(None)
+                elif import_path_obj.suffix == ".jac":
+                    # Compile .jac imports and include transitive .jac imports
+                    try:
+                        imported_js_modules.append(import_path_obj)
+                    except ClientBundleError:
+                        imported_js_modules.append(None)
+                else:
+                    # Non .jac/.js entries (likely bare specifiers) should be handled by Vite.
+                    # Do not inline or mark as bundled so their import lines are preserved.
+                    pass
+        return imported_js_modules
+    def _compile_dependencies_recursively(
+        self,
+        module_path: Path,
+        visited: set[Path] | None = None,
+        collected_exports: set[str] | None = None,
+        collected_globals: dict[str, Any] | None = None,
+    ) -> None:
+        """Recursively compile/copy .jac/.js imports to temp, skipping bundling.
+        Only prepares dependency JS artifacts for Vite by writing compiled JS (.jac)
+        or copying local JS (.js) into the temp directory. Bare specifiers are left
+        untouched for Vite to resolve.
+        """
+        if visited is None:
+            visited = set()
+        if collected_exports is None:
+            collected_exports = set()
+        if collected_globals is None:
+            collected_globals = {}
+        module_path = module_path.resolve()
+        if module_path in visited:
+            return
+        visited.add(module_path)
+        manifest = None
+        # Compile current module to JS and append registration
+        module_js, mod = self._compile_to_js(module_path)
+        manifest = mod.gen.client_manifest if mod else None
+        # Extract exports from manifest
+        exports_list = self._extract_client_exports(manifest)
+        collected_exports.update(exports_list)
+        # Build globals map using manifest.globals_values only for non-root
+        non_root_globals: dict[str, Any] = {}
+        if manifest:
+            for name in manifest.globals:
+                non_root_globals[name] = manifest.globals_values.get(name)
+        collected_globals.update(non_root_globals)
+        export_block = (
+            f"export {{ {', '.join(exports_list)} }};\n" if exports_list else ""
+        )
+        # inport jacJsx from client_runtime_utils.jac
+        jac_jsx_path = 'import {__jacJsx, __jacSpawn} from "@jac-client/utils";'
+        combined_js = f"{jac_jsx_path}\n{module_js}\n{export_block}"
+        if self.vite_package_json is not None:
+            (
+                self.vite_package_json.parent / "src" / f"{module_path.stem}.js"
+            ).write_text(combined_js, encoding="utf-8")
+        if not manifest or not manifest.imports:
+            return
+        for _name, import_path in manifest.imports.items():
+            path_obj = Path(import_path).resolve()
+            # Avoid re-processing
+            if path_obj in visited:
+                continue
+            if path_obj.suffix == ".jac":
+                # Recurse into transitive deps
+                self._compile_dependencies_recursively(
+                    path_obj,
+                    visited,
+                    collected_exports=collected_exports,
+                    collected_globals=collected_globals,
+                )
+            elif path_obj.suffix == ".js":
+                try:
+                    js_code = path_obj.read_text(encoding="utf-8")
+                    if self.vite_package_json is not None:
+                        (
+                            self.vite_package_json.parent / "src" / path_obj.name
+                        ).write_text(js_code, encoding="utf-8")
+                except FileNotFoundError:
+                    pass
+            else:
+                # Bare specifiers or other assets handled by Vite
+                continue
+    def _compile_bundle(
+        self,
+        module: ModuleType,
+        module_path: Path,
+    ) -> ClientBundle:
+        """Override to use Vite bundling instead of simple concatenation."""
+        # Check if package.json exists before proceeding
+        if not self.vite_package_json or not self.vite_package_json.exists():
+            raise ClientBundleError(
+                "Vite package.json not found. Set vite_package_json when using ViteClientBundleBuilder"
+            )
+        # client_runtime for jac client utils
+        runtime_utils_path = self.runtime_path.parent / "client_runtime.jac"
+        runtimeutils_js, mod = self._compile_to_js(runtime_utils_path)
+        runtimeutils_manifest = mod.gen.client_manifest if mod else None
+        runtimeutils_exports_list = self._extract_client_exports(runtimeutils_manifest)
+        # Add React Router exports that are variable declarations (not functions)
+        # These need to be manually added since they're 'let' declarations, not 'def' functions
+        router_exports = [
+            "Router",
+            "Routes",
+            "Route",
+            "Link",
+            "Navigate",
+            "useNavigate",
+            "useLocation",
+            "useParams",
+        ]
+        # Combine manifest exports with router exports
+        all_exports = sorted(set(runtimeutils_exports_list + router_exports))
+        export_block = (
+            f"export {{ {', '.join(all_exports)} }};\n" if all_exports else ""
+        )
+        combined_runtime_utils_js = f"{runtimeutils_js}\n{export_block}"
+        (self.vite_package_json.parent / "src" / "client_runtime.js").write_text(
+            combined_runtime_utils_js, encoding="utf-8"
+        )
+        # Get manifest from JacProgram first to check for imports
+        # Collect exports/globals across root and recursive deps
+        module_js, mod = self._compile_to_js(module_path)
+        module_manifest = mod.gen.client_manifest if mod else None
+        collected_exports: set[str] = set(self._extract_client_exports(module_manifest))
+        client_globals_map = self._extract_client_globals(module_manifest, module)
+        collected_globals: dict[str, Any] = dict(client_globals_map)
+        # Recursively prepare dependencies and accumulate symbols
+        self._compile_dependencies_recursively(
+            module_path,
+            collected_exports=collected_exports,
+            collected_globals=collected_globals,
+        )
+        client_exports = sorted(collected_exports)
+        client_globals_map = collected_globals
+        entry_file = self.vite_package_json.parent / "src" / "main.js"
+        entry_content = """import React from "react";
+import { createRoot } from "react-dom/client";
+import { app as App } from "./app.js";
+const root = createRoot(document.getElementById("root"));
+root.render(<App />);
+"""
+        entry_file.write_text(entry_content, encoding="utf-8")
+        bundle_code, bundle_hash = self._bundle_with_vite(
+            module.__name__, client_exports
+        )
+        return ClientBundle(
+            module_name=module.__name__,
+            code=bundle_code,
+            client_functions=client_exports,
+            client_globals=list(client_globals_map.keys()),
+            hash=bundle_hash,
+        )
+    def _bundle_with_vite(
+        self, module_name: str, client_functions: list[str]
+    ) -> tuple[str, str]:
+        """Bundle JavaScript code using Vite for optimization.
+        Args:
+            module_name: Name of the module being bundled
+            client_functions: List of client function names
+        Returns:
+            Tuple of (bundle_code, bundle_hash)
+        Raises:
+            ClientBundleError: If Vite bundling fails
+        """
+        if not self.vite_package_json or not self.vite_package_json.exists():
+            raise ClientBundleError(
+                "Vite package.json not found. Set vite_package_json when using ViteClientBundleBuilder"
+            )
+        # Create temp directory for Vite build
+        project_dir = self.vite_package_json.parent
+        src_dir = project_dir / "src"
+        src_dir.mkdir(exist_ok=True)
+        output_dir = self.vite_output_dir or src_dir / "dist" / "assets"
+        output_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            # Run Vite build from project directory
+            # need to install packages you told in package.json inside here
+            # first compile the code
+            command = ["npm", "run", "compile"]
+            subprocess.run(
+                command, cwd=project_dir, check=True, capture_output=True, text=True
+            )
+            # then build the code
+            command = ["npm", "run", "build"]
+            subprocess.run(
+                command, cwd=project_dir, check=True, capture_output=True, text=True
+            )
+        except subprocess.CalledProcessError as e:
+            raise ClientBundleError(f"Vite build failed: {e.stderr}") from e
+        except FileNotFoundError:
+            raise ClientBundleError(
+                "npx or vite command not found. Ensure Node.js and npm are installed."
+            )
+        # Find the generated bundle file
+        bundle_file = self._find_vite_bundle(output_dir)
+        if not bundle_file:
+            raise ClientBundleError("Vite build completed but no bundle file found")
+        # Read the bundled code
+        bundle_code = bundle_file.read_text(encoding="utf-8")
+        bundle_hash = hashlib.sha256(bundle_code.encode("utf-8")).hexdigest()
+        return bundle_code, bundle_hash
+    def _generate_vite_config(self, entry_file: Path, output_dir: Path) -> str:
+        """Generate Vite configuration for bundling."""
+        entry_name = entry_file.as_posix()
+        output_dir_name = output_dir.as_posix()
+        minify_setting = "true" if self.vite_minify else "false"
+        return f"""
+            import {{ defineConfig }} from 'vite';
+            import {{ resolve }} from 'path';
+            export default defineConfig({{
+            build: {{
+                outDir: '{output_dir_name}',
+                emptyOutDir: true,
+                rollupOptions: {{
+                input: {{
+                    main: resolve(__dirname, '{entry_name}'),
+                }},
+                output: {{
+                    entryFileNames: 'client.[hash].js',
+                    format: 'iife',
+                    name: 'JacClient',
+                }},
+                }},
+                minify: {minify_setting}, // Configurable minification
+            }},
+            resolve: {{
+            }}
+            }});
+        """
+    def _find_vite_bundle(self, output_dir: Path) -> Path | None:
+        """Find the generated Vite bundle file."""
+        for file in output_dir.glob("client.*.js"):
+            return file
+        return None
+    def cleanup_temp_dir(self) -> None:
+        """Clean up the src directory and its contents."""
+        if not self.vite_package_json or not self.vite_package_json.exists():
+            return
+        project_dir = self.vite_package_json.parent
+        temp_dir = project_dir / "src"
+        if temp_dir.exists():
+            with contextlib.suppress(OSError):
+                shutil.rmtree(temp_dir)

jac_client/tests/__init__.py ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ """Tests for jac-client package."""
2	+

jac_client/tests/fixtures/basic-app/app.jac ADDED Viewed

@@ -0,0 +1,18 @@
+"""Sample Jac module containing client-side declarations."""
+cl let API_LABEL: str = "Runtime Test";
+cl obj ButtonProps {
+    has label: str = "Tap Me";
+    has color: str = "primary";
+}
+cl def app() {
+    let props = ButtonProps(label="Tap Me", color="primary");
+    return <div class="app">
+        <h1>{API_LABEL}</h1>
+        <button class={props.color} data-id="button">
+            {props.label}
+        </button>
+    </div>;
+}