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

jac_client/plugin/src/targets/impl/registry.impl.jac

@@ -0,0 +1,64 @@
+"""Implementation of target registry."""
+
+"""Register a new build target."""
+impl TargetRegistry.register(target: ClientTarget) -> None {
+    self._targets[target.name] = target;
+    if target.default {
+        self._default_target = target.name;
+    }
+}
+
+"""Get a target by name."""
+impl TargetRegistry.get(name: str) -> Optional[ClientTarget] {
+    return self._targets.get(name);
+}
+
+"""Get the default target."""
+impl TargetRegistry.get_default -> Optional[ClientTarget] {
+    if self._default_target {
+        return self._targets.get(self._default_target);
+    }
+    # Find first target marked as default
+    for target in self._targets.values() {
+        if target.default {
+            return target;
+        }
+    }
+    return None;
+}
+
+"""Get all registered targets."""
+impl TargetRegistry.get_all -> list[ClientTarget] {
+    return list(self._targets.values());
+}
+
+"""Check if a target is registered."""
+impl TargetRegistry.has(name: str) -> bool {
+    return name in self._targets;
+}
+
+"""Set the default target."""
+impl TargetRegistry.set_default(name: str) -> None {
+    if name not in self._targets {
+        raise ValueError(f"ClientTarget '{name}' is not registered") ;
+    }
+    # Unset previous default
+    if self._default_target {
+        prev_target = self._targets.get(self._default_target);
+        if prev_target {
+            prev_target.default = False;
+        }
+    }
+    # Set new default
+    self._default_target = name;
+    target = self._targets.get(name);
+    if target {
+        target.default = True;
+    }
+}
+
+"""Clear all registered targets (for testing)."""
+impl TargetRegistry.clear -> None {
+    self._targets.clear();
+    self._default_target = None;
+}

jac_client/plugin/src/targets/impl/web_target.impl.jac

@@ -0,0 +1,157 @@
+"""Implementation of WebTarget methods."""
+import types;
+import from pathlib { Path }
+import from typing { Optional }
+import from jac_client.plugin.src.vite_bundler { ViteBundler }
+
+"""Build web bundle using existing Vite pipeline."""
+impl WebTarget.build(
+    self: WebTarget,
+    entry_file: Path,
+    project_dir: Path,
+    platform: Optional[str] = None
+) -> Path {
+    import os;
+    import shutil;
+    import from jaclang.pycore.runtime { JacRuntime as Jac }
+    import from jac_client.plugin.client { JacClient }
+    bundler = ViteBundler(project_dir=project_dir);
+    # Clean dist directory for fresh build
+    dist_dir = bundler.output_dir;
+    if dist_dir.exists() {
+        shutil.rmtree(dist_dir);
+    }
+    dist_dir.mkdir(parents=True, exist_ok=True);
+    # Load the module (same as jac start does via _proc_file + jac_import)
+    (base, mod) = os.path.split(str(entry_file));
+    base = base or "./";
+    if entry_file.name.endswith('.jac') {
+        mod = mod[:-4];
+    }
+    # Import the module (Jac.jac_import handles context creation internally)
+    Jac.jac_import(target=mod, base_path=base, lng='jac');
+    if Jac.program.errors_had {
+        errors = '\n'.join(Jac.program.errors_had);
+        raise RuntimeError(f"Failed to compile {entry_file}:\n{errors}") ;
+    }
+    # Get the loaded module
+    loaded_mod = Jac.loaded_modules.get(mod);
+    if not loaded_mod {
+        raise RuntimeError(f"Module '{mod}' not found after import") ;
+    }
+    # Type assertion: loaded_mod is guaranteed to be not None here
+    if not isinstance(loaded_mod, types.ModuleType) {
+        raise RuntimeError(f"Module '{mod}' is not a valid module type") ;
+    }
+    # Build bundle using ViteClientBundleBuilder (same as jac start's introspector.ensure_bundle)
+    builder = JacClient.get_client_bundle_builder();
+    bundle = builder.build(loaded_mod, force=True);
+    # Find the bundle file
+    bundle_path = bundler.find_bundle();
+    if not bundle_path {
+        raise RuntimeError("Web build failed: bundle not found") ;
+    }
+    # Always generate static index.html for static serving
+    _generate_index_html(
+        bundle_path=bundle_path,
+        bundler=bundler,
+        loaded_mod=loaded_mod,
+        project_dir=project_dir
+    );
+    return bundle_path;
+}
+
+"""Generate static index.html file for the built bundle."""
+def _generate_index_html(
+    bundle_path: Path,
+    bundler: ViteBundler,
+    loaded_mod: types.ModuleType,
+    project_dir: Path
+) -> None {
+    import html;
+    import hashlib;
+    import from jaclang.project.config { get_config }
+    import from jac_client.plugin.client { HeaderBuilder }
+    import from jaclang.pycore.runtime { JacRuntime as Jac }
+
+    # Get the first client export function (or default to 'app')
+    mod_path = getattr(loaded_mod, '__file__', None);
+    if mod_path {
+        mod = Jac.program.mod.hub.get(mod_path);
+        if mod and mod.gen.client_manifest {
+            client_exports = mod.gen.client_manifest.exports;
+            # client_exports is a list[str], not a dict
+            if client_exports and len(client_exports) > 0 {
+                function_name = client_exports[0];
+            } else {
+                function_name = 'app';
+            }
+        } else {
+            function_name = 'app';
+        }
+    } else {
+        function_name = 'app';
+    }
+
+    # Get module name
+    module_name = loaded_mod.__name__;
+
+    # Get dist directory (output_dir is already a Path)
+    dist_dir = Path(bundler.output_dir);
+
+    # Check for CSS file
+    css_link = '';
+    css_file = bundler.find_css();
+    if css_file {
+        css_hash = hashlib.sha256(css_file.read_bytes()).hexdigest()[:8];
+        css_filename = css_file.name;
+        css_link = f'<link rel="stylesheet" href="{css_filename}?hash={css_hash}"/>';
+    }
+
+    # Get meta data from config
+    config = get_config();
+    meta_data = {};
+    if config {
+        client_cfg = config.get_plugin_config("client");
+        if client_cfg {
+            meta_data = client_cfg.get("app_meta_data", {});
+        }
+    }
+
+    # Build HTML head using HeaderBuilder (same as render_page)
+    head_builder = HeaderBuilder(meta_data, function_name);
+    head_content = head_builder.build_head();
+    if css_link {
+        head_content += f"\n            {css_link}";
+    }
+
+    # Get bundle filename (relative to dist_dir)
+    bundle_filename = bundle_path.name;
+
+    # Generate HTML with __jac_init__ script tag for client runtime
+    init_payload = {
+        "module": module_name,
+        "function": function_name,
+        "args": {},
+        "argOrder": [],
+        "globals": {}
+    };
+    import json;
+    init_json = json.dumps(init_payload);
+
+    html_content = f'''<!DOCTYPE html>
+<html lang="en">
+  <head>
+{head_content}
+  </head>
+  <body>
+    <div id="root"></div>
+    <script id="__jac_init__" type="application/json">{html.escape(init_json)}</script>
+    <script src="{bundle_filename}" defer></script>
+  </body>
+</html>''';
+
+    # Write index.html to dist directory
+    index_html = dist_dir / 'index.html';
+    index_html.write_text(html_content, encoding='utf-8');
+}

jac_client/plugin/src/targets/register.jac

@@ -0,0 +1,21 @@
+"""Register all build targets.
+
+This module registers all available build targets when the plugin loads.
+"""
+import from jac_client.plugin.src.targets.registry { get_target_registry }
+import from jac_client.plugin.src.targets.web_target { WebTarget }
+import from jac_client.plugin.src.targets.desktop_target { DesktopTarget }
+# Note: Jac's annex pass should auto-discover .impl.jac files automatically
+# The impl files in impl/ directory should be loaded when the base classes are imported
+"""Register all available targets."""
+def register_targets -> None {
+    registry = get_target_registry();
+
+    # Register web target (default)
+    web_target = WebTarget();
+    registry.register(web_target);
+
+    # Register desktop target (placeholder for Phase 2)
+    desktop_target = DesktopTarget();
+    registry.register(desktop_target);
+}

jac_client/plugin/src/targets/registry.jac

@@ -0,0 +1,87 @@
+"""Target registry for build targets (web, desktop, mobile, etc.).
+
+This module provides a registry system for managing different build targets.
+Each target is a class that inherits from the base ClientTarget class.
+"""
+import from typing { Optional }
+import from pathlib { Path }
+
+"""Base class for all build targets.
+
+All targets must inherit from this class and implement the required methods.
+"""
+class ClientTarget {
+    has name: str,
+        default: bool = False,
+        requires_setup: bool = False,
+        config_section: str = "",
+        required_dependencies: list[str] = [],
+        output_dir: Optional[Path] = None;
+
+    """Setup the target (one-time initialization)."""
+    def setup(self: ClientTarget, project_dir: Path) -> None abs;
+
+    """Build the target."""
+    def build(
+        self: ClientTarget,
+        entry_file: Path,
+        project_dir: Path,
+        platform: Optional[str] = None
+    ) -> Path abs;
+
+    """Start dev server for the target."""
+    def dev(self: ClientTarget, entry_file: Path, project_dir: Path) -> None abs;
+
+    """Start the target (production mode - build and run)."""
+    def start(self: ClientTarget, entry_file: Path, project_dir: Path) -> None abs;
+}
+
+"""Central registry for build targets.
+
+This is a singleton that collects all build targets registered by plugins.
+The CLI uses this registry to delegate build operations to the appropriate target.
+"""
+obj TargetRegistry {
+    has _targets: dict[str, ClientTarget] = {},
+        _default_target: Optional[str] = None;
+
+    """Register a new build target."""
+    def register(target: ClientTarget) -> None;
+
+    """Get a target by name."""
+    def get(name: str) -> Optional[ClientTarget];
+
+    """Get the default target."""
+    def get_default -> Optional[ClientTarget];
+
+    """Get all registered targets."""
+    def get_all -> list[ClientTarget];
+
+    """Check if a target is registered."""
+    def has(name: str) -> bool;
+
+    """Set the default target."""
+    def set_default(name: str) -> None;
+
+    """Clear all registered targets (for testing)."""
+    def clear -> None;
+}
+
+# Global singleton instance
+glob _registry: TargetRegistry | None = None;
+
+"""Get or create the global target registry."""
+def get_target_registry -> TargetRegistry {
+    import from jac_client.plugin.src.targets.registry { TargetRegistry }
+    global _registry;
+    if _registry is None {
+        _registry = TargetRegistry();
+    }
+    return _registry;
+}
+# Target name: "web", "desktop", "android", "ios"
+# Is this the default target?
+# Does this target need setup?
+# Section in jac.toml (e.g., "desktop")
+# Required npm/system dependencies
+# Where build outputs go

jac_client/plugin/src/targets/web_target.jac

@@ -0,0 +1,35 @@
+"""Web target implementation.
+
+This is the default target for building web applications.
+"""
+import from pathlib { Path }
+import from typing { Optional }
+import from jac_client.plugin.src.targets.registry { ClientTarget }
+
+"""Web build target."""
+class WebTarget(ClientTarget) {
+    def init(self: WebTarget) {
+        self.name = "web";
+        self.default = True;
+        self.requires_setup = False;
+        self.config_section = "plugin.client";
+        self.output_dir = Path(".jac/client/dist");
+    }
+
+    """Setup web target (no-op for web, already set up by default)."""
+    override def setup(self: WebTarget, project_dir: Path) -> None;
+
+    """Build web bundle using existing Vite pipeline."""
+    override def build(
+        self: WebTarget,
+        entry_file: Path,
+        project_dir: Path,
+        platform: Optional[str] = None
+    ) -> Path;
+
+    """Start web dev server."""
+    override def dev(self: WebTarget, entry_file: Path, project_dir: Path) -> None;
+
+    """Start web target (no-op for web, handled by jac start)."""
+    override def start(self: WebTarget, entry_file: Path, project_dir: Path) -> None;
+}

jac_client/plugin/src/vite_bundler.jac

@@ -1,12 +1,15 @@
 """Vite bundling module."""
 import hashlib;
 import json;
+import logging;
 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 }
+
+glob logger = logging.getLogger(__name__);
 """Handles Vite bundling operations."""
 class ViteBundler {
     def init(
@@ -34,6 +37,9 @@ class ViteBundler {
     ) -> Path;
 
     def create_tsconfig(self: ViteBundler) -> Path;
+    """Create config files from jac.toml [plugins.client.configs]."""
+    def create_config_files(self: ViteBundler) -> list[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

jac_client/plugin/utils/__init__.jac

@@ -0,0 +1,3 @@
+"""Utility modules for jac-client plugin."""
+
+import from .bun_installer { ensure_bun_available, prompt_install_bun }

jac_client/plugin/utils/bun_installer.jac

@@ -0,0 +1,16 @@
+"""Bun installer utility for jac-client.
+
+Provides functions to check for Bun availability and prompt for installation.
+"""
+
+"""Check if bun is available, add to PATH if needed, or prompt to install.
+
+Returns True if bun is available (or was successfully installed), False otherwise.
+"""
+def ensure_bun_available -> bool;
+
+"""Prompt user to install Bun and install if confirmed.
+
+Returns True if installation succeeded, False otherwise.
+"""
+def prompt_install_bun -> bool;

jac_client/plugin/utils/impl/bun_installer.impl.jac

@@ -0,0 +1,99 @@
+"""Implementation of Bun installer utility."""
+
+"""Check if bun is available, add to PATH if needed, or prompt to install."""
+impl ensure_bun_available -> bool {
+    import os;
+    import shutil;
+    # Check if bun is already in PATH
+    if shutil.which("bun") {
+        return True;
+    }
+    # Check if bun exists at ~/.bun/bin but not in PATH
+    bun_bin = os.path.expanduser("~/.bun/bin");
+    bun_path = os.path.join(bun_bin, "bun");
+    if os.path.exists(bun_path) {
+        # Add to PATH for current process
+        current_path = os.environ.get("PATH", "");
+        os.environ["PATH"] = f"{bun_bin}:{current_path}";
+        return True;
+    }
+    # Bun not found - prompt to install
+    return prompt_install_bun();
+}
+
+"""Prompt user to install Bun and install if confirmed."""
+impl prompt_install_bun -> bool {
+    import os;
+    import subprocess;
+    import sys;
+    import shutil;
+    print("\n  ⚠ Bun is required but not installed.", file=sys.stderr);
+    print(
+        "  Bun is a fast JavaScript runtime used for package management and bundling.",
+        file=sys.stderr
+    );
+    print("  Learn more: https://bun.sh\n", file=sys.stderr);
+    try {
+        response = input("  Install Bun now? [Y/n]: ").strip().lower();
+    } except (EOFError, KeyboardInterrupt) {
+        print("", file=sys.stderr);
+        return False;
+    }
+    if response and response not in ('y', 'yes', '') {
+        return False;
+    }
+    print("\n  ⏳ Installing Bun...", flush=True);
+    try {
+        # Check if curl is available
+        subprocess.run(
+            ["curl", "--version"], capture_output=True, check=True, timeout=5
+        );
+
+        # Install Bun via official script
+        result = subprocess.run(
+            ["sh", "-c", "curl -fsSL https://bun.sh/install | bash"],
+            timeout=120,
+            check=False
+        );
+
+        if result.returncode == 0 {
+            print("  ✔ Bun installed successfully!", flush=True);
+            # Add Bun to PATH for current session
+            bun_bin = os.path.expanduser("~/.bun/bin");
+            if os.path.exists(bun_bin) {
+                current_path = os.environ.get("PATH", "");
+                os.environ["PATH"] = f"{bun_bin}:{current_path}";
+                # Verify installation
+                if shutil.which("bun") {
+                    verify = subprocess.run(
+                        ["bun", "--version"], capture_output=True, text=True
+                    );
+                    if verify.returncode == 0 {
+                        print(f"  ✔ Verified: Bun {verify.stdout.strip()}", flush=True);
+                        return True;
+                    }
+                }
+            }
+            print(
+                "  ⚠ Bun installed but may require terminal restart.", file=sys.stderr
+            );
+            print("  Run: source ~/.bashrc (or restart terminal)", file=sys.stderr);
+            return True;
+        } else {
+            print("  ✖ Bun installation failed.", file=sys.stderr);
+            return False;
+        }
+    } except subprocess.TimeoutExpired {
+        print("  ✖ Installation timed out.", file=sys.stderr);
+        return False;
+    } except FileNotFoundError {
+        print(
+            "  ✖ curl not found. Please install Bun manually: https://bun.sh",
+            file=sys.stderr
+        );
+        return False;
+    } except Exception as e {
+        print(f"  ✖ Installation failed: {e}", file=sys.stderr);
+        return False;
+    }
+}

jac_client/templates/client.jacpack

@@ -0,0 +1,72 @@
+{
+  "name": "client",
+  "description": "Jac project with frontend client setup",
+  "config": {
+    "project": {
+      "name": "{{name}}",
+      "version": "1.0.0",
+      "description": "Jac client application: {{name}}",
+      "entry-point": "main.jac"
+    },
+    "dependencies": {},
+    "dependencies.npm": {
+      "jac-client-node": "1.0.4"
+    },
+    "dependencies.npm.dev": {
+      "@jac-client/dev-deps": "1.0.0"
+    },
+    "dev-dependencies": {
+      "watchdog": ">=3.0.0"
+    },
+    "serve": {
+      "base_route_app": "app"
+    },
+    "plugins.client": {}
+  },
+  "files": {
+    "main.jac": "\"\"\"Main entry point for {{name}}.\"\"\"\n\n# Client-side imports (useState is auto-injected when using `has` variables)\ncl import from react { useEffect }\ncl import from .components.Button { Button }\n\n# Client-side component\ncl {\n    def:pub app() -> any {\n        has count: int = 0;\n\n        useEffect(lambda -> None {\n            console.log(\"Count updated:\", count);\n        }, [count]);\n\n        return <div style={{padding: \"2rem\", fontFamily: \"Arial, sans-serif\"}}>\n            <h1>Hello, World!</h1>\n            <p>Count: {count}</p>\n            <div style={{display: \"flex\", gap: \"1rem\", marginTop: \"1rem\"}}>\n                <Button\n                    label=\"Increment\"\n                    onClick={lambda -> None { count = count + 1; }}\n                    variant=\"primary\"\n                />\n                <Button\n                    label=\"Reset\"\n                    onClick={lambda -> None { count = 0; }}\n                    variant=\"secondary\"\n                />\n            </div>\n        </div>;\n    }\n}\n",
+    "components/Button.cl.jac": "\"\"\"Button component for the Jac client application.\"\"\"\n\ndef:pub Button(label: str, onClick: any, variant: str = \"primary\", disabled: bool = False) -> any {\n    base_styles = {\n        \"padding\": \"0.75rem 1.5rem\",\n        \"fontSize\": \"1rem\",\n        \"fontWeight\": \"600\",\n        \"borderRadius\": \"0.5rem\",\n        \"border\": \"none\",\n        \"cursor\": \"not-allowed\" if disabled else \"pointer\",\n        \"transition\": \"all 0.2s ease\"\n    };\n\n    variant_styles = {\n        \"primary\": {\n            \"backgroundColor\": \"#9ca3af\" if disabled else \"#3b82f6\",\n            \"color\": \"#ffffff\"\n        },\n        \"secondary\": {\n            \"backgroundColor\": \"#e5e7eb\" if disabled else \"#6b7280\",\n            \"color\": \"#ffffff\"\n        }\n    };\n\n    return <button\n        style={{**base_styles, **variant_styles[variant]}}\n        onClick={onClick}\n        disabled={disabled}\n    >\n        {label}\n    </button>;\n}\n",
+    "README.md": "# {{name}}\n\nA Jac client-side application with React support.\n\n## Project Structure\n\n```\n{{name}}/\n\u251c\u2500\u2500 jac.toml              # Project configuration\n\u251c\u2500\u2500 main.jac              # Main application entry\n\u251c\u2500\u2500 components/           # Reusable components\n\u2502   \u2514\u2500\u2500 Button.cl.jac     # Example Jac component\n\u251c\u2500\u2500 assets/               # Static assets (images, fonts, etc.)\n\u2514\u2500\u2500 build/                # Build output (generated)\n```\n\n## Getting Started\n\nStart the development server:\n\n```bash\njac start main.jac\n```\n\n## Components\n\nCreate Jac components in `components/` as `.cl.jac` files and import them:\n\n```jac\ncl import from .components.Button { Button }\n```\n\n## Adding Dependencies\n\nAdd npm packages with the --cl flag:\n\n```bash\njac add --cl react-router-dom\n```\n"
+  },
+  "directories": [
+    "components",
+    "assets",
+    ".jac/client"
+  ],
+  "gitignore_entries": [
+    "# Ignore all build artifacts in .jac directory",
+    "*"
+  ],
+  "root_gitignore_entries": [
+    "# Jac project",
+    "packages/",
+    "*.jbc",
+    "*.jir",
+    "",
+    "# Python",
+    "__pycache__/",
+    "*.py[cod]",
+    ".venv/",
+    "venv/",
+    "",
+    "# IDE",
+    ".idea/",
+    ".vscode/",
+    "*.swp",
+    "",
+    "# Node.js",
+    "node_modules/",
+    "",
+    "# Build artifacts",
+    ".jac/",
+    "*.session",
+    "*.session.*"
+  ],
+  "jaclang": "0.9.8",
+  "plugins": [
+    {
+      "name": "jac-client",
+      "version": "0.2.8"
+    }
+  ]
+}