jac-client 0.2.3__py3-none-any.whl → 0.2.8__py3-none-any.whl

jac_client/plugin/src/package_installer.jac

@@ -0,0 +1,26 @@
+"""Package installer for managing npm dependencies in jac.toml."""
+
+import shutil;
+import subprocess;
+import from pathlib { Path }
+import from jaclang.runtimelib.client_bundle { ClientBundleError }
+import from .config_loader { JacClientConfig }
+import from .vite_bundler { ViteBundler }
+
+class PackageInstaller {
+    def init(self: PackageInstaller, project_dir: Path);
+    def install_package(
+        self: PackageInstaller,
+        package_name: str,
+        version: (str | None) = None,
+        is_dev: bool = False
+    ) -> None;
+
+    def install_all(self: PackageInstaller) -> None;
+    def _regenerate_and_install(self: PackageInstaller) -> None;
+    def uninstall_package(
+        self: PackageInstaller, package_name: str, is_dev: bool = False
+    ) -> None;
+
+    def list_packages(self: PackageInstaller) -> dict[str, dict[(str, str)]];
+}

jac_client/plugin/src/vite_bundler.jac

@@ -0,0 +1,44 @@
+"""Vite bundling module."""
+import hashlib;
+import json;
+import shutil;
+import subprocess;
+import from pathlib { Path }
+import from typing { Any, Optional }
+import from jaclang.runtimelib.client_bundle { ClientBundleError }
+import from .config_loader { JacClientConfig }
+"""Handles Vite bundling operations."""
+class ViteBundler {
+    def init(
+        self: ViteBundler,
+        project_dir: Path,
+        output_dir: Optional[Path] = None,
+        minify: bool = False,
+        config_path: Optional[Path] = None
+    );
+
+    def _get_client_dir(self: ViteBundler) -> Path;
+    def build(self: ViteBundler, entry_file: Optional[Path] = None) -> None;
+    def find_bundle(self: ViteBundler) -> Optional[Path];
+    def find_css(self: ViteBundler) -> Optional[Path];
+    def read_bundle(self: ViteBundler) -> tuple[str, str];
+    def _has_typescript_support(self: ViteBundler) -> bool;
+    def create_vite_config(self: ViteBundler, entry_file: Path) -> Path;
+    def _get_plugin_var_name(self: ViteBundler, plugin_name: str) -> str;
+    def _format_plugin_options(self: ViteBundler, options: dict) -> str;
+    def _format_config_object(self: ViteBundler, config: dict, indent: int = 0) -> str;
+    def _ensure_root_package_json(self: ViteBundler) -> None;
+    def _cleanup_root_package_files(self: ViteBundler) -> None;
+    def create_package_json(
+        self: ViteBundler, project_name: Optional[str] = None
+    ) -> Path;
+
+    def create_tsconfig(self: ViteBundler) -> Path;
+    """Create a dev-mode vite config with API proxy for HMR."""
+    def create_dev_vite_config(
+        self: ViteBundler, entry_file: Path, api_port: int = 8000
+    ) -> Path;
+
+    """Start Vite dev server as a subprocess."""
+    def start_dev_server(self: ViteBundler, port: int = 3000) -> Any;
+}

jac_client/plugin/vite_client_bundle.jac

@@ -0,0 +1,31 @@
+"""Vite-enhanced client bundle generation for Jac web front-ends."""
+import contextlib;
+import shutil;
+import from collections.abc { Callable }
+import from pathlib { Path }
+import from types { ModuleType }
+import from typing { cast }
+import from jaclang.runtimelib.client_bundle {
+    ClientBundle,
+    ClientBundleBuilder,
+    ClientBundleError
+}
+import from .src { ViteCompiler }
+
+"""Enhanced ClientBundleBuilder that uses Vite for optimized bundling."""
+class ViteClientBundleBuilder(ClientBundleBuilder) {
+    def init(
+        self: ViteClientBundleBuilder,
+        runtime_path: (Path | None) = None,
+        vite_output_dir: (Path | None) = None,
+        vite_package_json: (Path | None) = None,
+        vite_minify: bool = False
+    ) -> None;
+
+    def _get_compiler(self: ViteClientBundleBuilder) -> ViteCompiler;
+    def _compile_bundle(
+        self: ViteClientBundleBuilder, module: ModuleType, module_path: Path
+    ) -> ClientBundle;
+
+    def cleanup_temp_dir(self: ViteClientBundleBuilder) -> None;
+}

jac_client/tests/conftest.py

@@ -0,0 +1,283 @@
+"""Pytest configuration and shared fixtures for jac-client tests.
+
+This module provides session-scoped fixtures to optimize test execution by:
+1. Running npm install once per session and caching node_modules
+2. Providing shared Vite build infrastructure
+3. Mocking npm install for tests that only need jac.toml manipulation
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from collections.abc import Generator
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+from jaclang.pycore.runtime import JacRuntime as Jac
+from jaclang.pycore.runtime import JacRuntimeImpl, plugin_manager
+
+# Store unregistered plugins globally for session-level management
+_external_plugins: list = []
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    """Disable jac-scale plugin at the start of the test session.
+
+    jac-scale plugin is disabled during tests to avoid MongoDB connections
+    and other jac-scale specific dependencies. jac-client plugin is kept
+    enabled since we're testing it.
+    """
+    global _external_plugins
+    for name, plugin in list(plugin_manager.list_name_plugin()):
+        # Keep core runtime and jac-client plugins
+        if plugin is JacRuntimeImpl or name == "JacRuntimeImpl":
+            continue
+        if "client" in name.lower() or "JacClient" in str(type(plugin)):
+            continue
+        # Disable jac-scale and other external plugins
+        _external_plugins.append((name, plugin))
+        plugin_manager.unregister(plugin=plugin, name=name)
+
+
+def pytest_unconfigure(config: pytest.Config) -> None:
+    """Re-register external plugins at the end of the test session."""
+    global _external_plugins
+    for name, plugin in _external_plugins:
+        with contextlib.suppress(ValueError):
+            plugin_manager.register(plugin, name=name)
+    _external_plugins.clear()
+
+
+def _get_jac_command() -> list[str]:
+    """Get the jac command with proper path handling."""
+    # Try to find jac in PATH or use python -m jaclang
+    jac_path = shutil.which("jac")
+    if jac_path:
+        return [jac_path]
+    # Fall back to running via python module
+    return [sys.executable, "-m", "jaclang"]
+
+
+def _get_env_with_npm() -> dict[str, str]:
+    """Get environment dict with npm in PATH."""
+    env = os.environ.copy()
+    # npm might be installed via nvm, ensure PATH includes common locations
+    npm_path = shutil.which("npm")
+    if npm_path:
+        npm_dir = str(Path(npm_path).parent)
+        current_path = env.get("PATH", "")
+        if npm_dir not in current_path:
+            env["PATH"] = f"{npm_dir}:{current_path}"
+    return env
+
+
+@pytest.fixture(autouse=True)
+def reset_jac_machine() -> Generator[None, None, None]:
+    """Reset Jac machine before and after each test."""
+    Jac.reset_machine()
+    yield
+    Jac.reset_machine()
+
+
+# Session-scoped cache for npm installation
+_npm_cache_dir: Path | None = None
+
+
+def _get_minimal_jac_toml() -> str:
+    """Get minimal jac.toml content for npm cache setup."""
+    return """[project]
+name = "npm-cache"
+version = "0.0.1"
+description = "Cached npm modules"
+entry-point = "app.jac"
+
+[plugins.client.vite.build]
+minify = false
+"""
+
+
+@pytest.fixture(scope="session")
+def npm_cache_dir() -> Generator[Path, None, None]:
+    """Session-scoped fixture that provides a directory with npm packages installed.
+
+    This runs npm install once per test session and provides the path to the
+    .jac/client/configs directory containing node_modules.
+    """
+    global _npm_cache_dir
+
+    if _npm_cache_dir is not None and _npm_cache_dir.exists():
+        yield _npm_cache_dir
+        return
+
+    # Create a persistent temp directory for the session
+    cache_dir = Path(tempfile.mkdtemp(prefix="jac_npm_cache_"))
+
+    # Create jac.toml
+    jac_toml = cache_dir / "jac.toml"
+    jac_toml.write_text(_get_minimal_jac_toml())
+
+    # Run jac add --cl to install packages
+    jac_cmd = _get_jac_command()
+    env = _get_env_with_npm()
+    result = subprocess.run(
+        [*jac_cmd, "add", "--cl"],
+        cwd=cache_dir,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+
+    if result.returncode != 0:
+        # Clean up on failure
+        shutil.rmtree(cache_dir, ignore_errors=True)
+        pytest.skip(f"Failed to set up npm cache: {result.stderr}")
+
+    _npm_cache_dir = cache_dir
+    yield cache_dir
+
+    # Cleanup after all tests complete
+    shutil.rmtree(cache_dir, ignore_errors=True)
+
+
+@pytest.fixture
+def vite_project_dir(npm_cache_dir: Path, tmp_path: Path) -> Path:
+    """Fixture that provides a project directory with pre-installed node_modules.
+
+    This copies node_modules from the session cache instead of running npm install.
+    """
+    # Create jac.toml in the temp directory
+    jac_toml = tmp_path / "jac.toml"
+    jac_toml.write_text(_get_minimal_jac_toml())
+
+    # Copy .jac/client/configs directory (contains package.json)
+    source_configs = npm_cache_dir / ".jac" / "client" / "configs"
+    dest_configs = tmp_path / ".jac" / "client" / "configs"
+    if source_configs.exists():
+        dest_configs.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(source_configs, dest_configs, symlinks=True)
+
+    # Copy node_modules from project root (npm installs there, not in .jac/client/configs)
+    source_node_modules = npm_cache_dir / "node_modules"
+    dest_node_modules = tmp_path / "node_modules"
+    if source_node_modules.exists():
+        shutil.copytree(source_node_modules, dest_node_modules, symlinks=True)
+
+    # Create required directories
+    (tmp_path / "dist").mkdir(exist_ok=True)
+    (tmp_path / "compiled").mkdir(exist_ok=True)
+    (tmp_path / "build").mkdir(exist_ok=True)
+
+    return tmp_path
+
+
+@pytest.fixture
+def vite_project_with_antd(npm_cache_dir: Path, tmp_path: Path) -> Path:
+    """Fixture that provides a project directory with antd pre-installed."""
+    # Create jac.toml with antd dependency
+    jac_toml_content = """[project]
+name = "antd-test"
+version = "0.0.1"
+description = "Test project with antd"
+entry-point = "app.jac"
+
+[plugins.client.vite.build]
+minify = false
+
+[dependencies.npm]
+antd = "^6.0.0"
+"""
+    jac_toml = tmp_path / "jac.toml"
+    jac_toml.write_text(jac_toml_content)
+
+    # Copy base .jac/client/configs first for faster install
+    source_configs = npm_cache_dir / ".jac" / "client" / "configs"
+    dest_configs = tmp_path / ".jac" / "client" / "configs"
+    if source_configs.exists():
+        dest_configs.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(source_configs, dest_configs, symlinks=True)
+
+    # Copy base node_modules for faster install (npm will add antd on top)
+    source_node_modules = npm_cache_dir / "node_modules"
+    dest_node_modules = tmp_path / "node_modules"
+    if source_node_modules.exists():
+        shutil.copytree(source_node_modules, dest_node_modules, symlinks=True)
+
+    # Install antd on top (uses cached node_modules as base)
+    jac_cmd = _get_jac_command()
+    env = _get_env_with_npm()
+    result = subprocess.run(
+        [*jac_cmd, "add", "--cl"],
+        cwd=tmp_path,
+        capture_output=True,
+        text=True,
+        env=env,
+    )
+    if result.returncode != 0:
+        pytest.skip(f"Failed to install antd: {result.stderr}")
+
+    # Create required directories
+    (tmp_path / "dist").mkdir(exist_ok=True)
+    (tmp_path / "compiled").mkdir(exist_ok=True)
+    (tmp_path / "build").mkdir(exist_ok=True)
+
+    return tmp_path
+
+
+@pytest.fixture
+def mock_npm_install():
+    """Fixture that mocks npm install for tests that only test jac.toml manipulation.
+
+    Use this for CLI tests (add/remove commands) that don't need actual npm packages.
+    """
+    with patch(
+        "jac_client.plugin.src.package_installer.PackageInstaller._regenerate_and_install"
+    ) as mock:
+        yield mock
+
+
+@pytest.fixture
+def cli_test_dir(tmp_path: Path) -> Path:
+    """Fixture that provides a minimal test directory for CLI tests."""
+    return tmp_path
+
+
+def create_test_jac_toml(
+    path: Path,
+    deps: str = "",
+    dev_deps: str = "",
+    name: str = "test-project",
+) -> Path:
+    """Helper to create a jac.toml file for testing.
+
+    Args:
+        path: Directory to create jac.toml in
+        deps: Dependencies to add (TOML format, e.g., 'lodash = "^4.17.21"')
+        dev_deps: Dev dependencies to add (TOML format)
+        name: Project name
+
+    Returns:
+        Path to the created jac.toml file
+    """
+    deps_section = f"\n{deps}" if deps else ""
+    dev_deps_section = f"\n{dev_deps}" if dev_deps else ""
+
+    content = f"""[project]
+name = "{name}"
+version = "1.0.0"
+description = "Test project"
+entry-point = "app.jac"
+
+[dependencies.npm]{deps_section}
+
+[dev-dependencies.npm]{dev_deps_section}
+"""
+    config_path = path / "jac.toml"
+    config_path.write_text(content)
+    return config_path

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

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

jac_client/tests/fixtures/cl_file/app.cl.jac

@@ -1,8 +1,8 @@
 import from react { useState }
 
 def app()  -> any {
-    let [todos, setTodos] = useState([]);
-    let [input, setInput] = useState("");
+    [todos, setTodos] = useState([]);
+    [input, setInput] = useState("");
 
     # Event Handler
     async def addTodo()  -> None {

jac_client/tests/fixtures/client_app_with_antd/app.jac

@@ -2,7 +2,7 @@
 
 cl import from antd { Button }
 
-cl let APP_NAME: str = "Ant Design Test";
+cl glob APP_NAME: str = "Ant Design Test";
 
 cl def ButtonTest() {
     return <div>

jac_client/tests/fixtures/js_import/app.jac

@@ -2,13 +2,13 @@
 
 cl import from .utils { formatMessage, calculateSum, JS_CONSTANT, MessageFormatter }
 
-cl let JS_IMPORT_LABEL: str = "JavaScript Import Test";
+cl glob JS_IMPORT_LABEL: str = "JavaScript Import Test";
 
 cl def JsImportTest()  -> any {
-    let greeting = formatMessage("Jac");
-    let sum = calculateSum(5, 3);
-    let formatter = MessageFormatter("JS");
-    let formatted = formatter.format("Hello from JS class");
+    greeting = formatMessage("Jac");
+    sum = calculateSum(5, 3);
+    formatter = MessageFormatter("JS");
+    formatted = formatter.format("Hello from JS class");
 
     return <div class="js-import-test">
         <h1>

jac_client/tests/fixtures/spawn_test/app.jac

@@ -32,51 +32,48 @@ walker positional_walker {
 }
 
 # Client-side code testing both spawn orderings
-cl import from react {
-    useState,
-    useEffect
-}
+cl import from react { 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);
+        has standardResult: any = None;
+        has standardComputed: any = None;
+        has reverseResult: any = None;
+        has uuidResult: any = None;
+        has reverseUuidResult: any = None;
+        has positionalResult: any = None;
+        has spreadResult: any = None;
 
         async def loadData()  -> None {
             # Test standard spawn order: node spawn walker()
             data1 = root spawn test_walker();
-            setStandardResult(data1);
+            standardResult = data1;
 
             data2 = root spawn parameterized_walker(value=42);
-            setStandardComputed(data2);
+            standardComputed = data2;
 
             # Test reverse spawn order: walker() spawn node
             data3 = test_walker(message="Reverse spawn!") spawn root;
-            setReverseResult(data3);
+            reverseResult = 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);
+            uuidResult = 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);
+            reverseUuidResult = data5;
 
             # Test positional walker arguments inferred from has fields
             data6 = node_id spawn positional_walker("Node positional", 2);
-            setPositionalResult(data6);
+            positionalResult = 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);
+            spreadResult = data7;
         }
 
         useEffect(lambda   -> None{ loadData();} , []);

jac_client/tests/fixtures/with-ts/app.jac

@@ -0,0 +1,35 @@
+
+# Pages
+cl import from react { useEffect }
+cl import from ".components/Button.tsx" { Button }
+
+cl {
+    def app()  -> any {
+        has count: int = 0;
+        useEffect(lambda   -> None{ console.log("Count: ", count);} , [count]);
+        return <div
+            style={{padding: "2rem", fontFamily: "Arial, sans-serif"}}
+        >
+            <h1>
+                Hello, World!
+            </h1>
+            <p>
+                Count: {count}
+            </p>
+            <div
+                style={{display: "flex", gap: "1rem", marginTop: "1rem"}}
+            >
+                <Button
+                    label="Increment"
+                    onClick={lambda   -> None{ count = count + 1;} }
+                    variant="primary"
+                />
+                <Button
+                    label="Reset"
+                    onClick={lambda   -> None{ count = 0;} }
+                    variant="secondary"
+                />
+            </div>
+        </div>;
+    }
+}