jac-client 0.2.8__py3-none-any.whl → 0.2.10__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 @@
+"""Utility modules for jac-client plugin."""

jac_client/plugin/utils/impl/node_installer.impl.jac

@@ -0,0 +1,249 @@
+"""Implementation of Node.js installer methods."""
+
+"""Check if Node.js is installed and accessible."""
+impl NodeInstaller.is_node_installed -> bool {
+    try {
+        result = subprocess.run(
+            ['node', '--version'], capture_output=True, text=True, timeout=5
+        );
+        return result.returncode == 0;
+    } except (FileNotFoundError, subprocess.TimeoutExpired) {
+        return False;
+    }
+}
+
+"""Check if npm is installed and accessible."""
+impl NodeInstaller.is_npm_installed -> bool {
+    try {
+        result = subprocess.run(
+            ['npm', '--version'], capture_output=True, text=True, timeout=5
+        );
+        return result.returncode == 0;
+    } except (FileNotFoundError, subprocess.TimeoutExpired) {
+        return False;
+    }
+}
+
+"""Check if NVM is installed."""
+impl NodeInstaller.is_nvm_installed -> bool {
+    nvm_dir = Path.home() / '.nvm';
+    return nvm_dir.exists() and (nvm_dir / 'nvm.sh').exists();
+}
+
+"""Get the currently installed Node.js version."""
+impl NodeInstaller.get_node_version -> (str | None) {
+    try {
+        result = subprocess.run(
+            ['node', '--version'], capture_output=True, text=True, timeout=5
+        );
+        if result.returncode == 0 {
+            return result.stdout.strip();
+        }
+    } except (FileNotFoundError, subprocess.TimeoutExpired) { }
+    return None;
+}
+
+"""Install NVM (Node Version Manager)."""
+impl NodeInstaller.install_nvm -> tuple[bool, str] {
+    system = platform.system();
+    if system == 'Windows' {
+        return (
+            False,
+            'Windows detected. Please install Node.js manually:\n' + '  1. Download from: https://nodejs.org/\n' + '  2. Or use nvm-windows: https://github.com/coreybutler/nvm-windows\n' + '  After installation, run "jac add --cl" again.'
+        );
+    }
+    print('Installing NVM (Node Version Manager)...');
+    try {
+        # Download and run NVM installation script
+        install_script = subprocess.run(
+            ['curl', '-o-', NodeInstaller.NVM_INSTALL_URL],
+            capture_output=True,
+            text=True,
+            timeout=30
+        );
+
+        if install_script.returncode != 0 {
+            return (
+                False,
+                f'Failed to download NVM installer: {install_script.stderr}'
+            );
+        }
+
+        # Execute the installation script
+        result = subprocess.run(
+            ['bash', '-c', install_script.stdout],
+            capture_output=True,
+            text=True,
+            timeout=60
+        );
+
+        if result.returncode != 0 {
+            return (False, f'NVM installation failed: {result.stderr}');
+        }
+
+        print('NVM installed successfully!');
+        return (True, 'NVM installed successfully');
+    } except subprocess.TimeoutExpired {
+        return (
+            False,
+            'NVM installation timed out. Please check your internet connection.'
+        );
+    } except FileNotFoundError as e {
+        if 'curl' in str(e) {
+            return (
+                False,
+                'curl command not found. Please install curl first:\n' + '  Ubuntu/Debian: sudo apt-get install curl\n' + '  macOS: curl is pre-installed\n' + '  Fedora/RHEL: sudo dnf install curl'
+            );
+        }
+        return (False, f'Required command not found: {e}');
+    } except Exception as e {
+        return (False, f'Unexpected error during NVM installation: {e}');
+    }
+}
+
+"""Install Node.js using NVM."""
+impl NodeInstaller.install_node_via_nvm(version: str = "20") -> tuple[bool, str] {
+    print(f'Installing Node.js v{version} via NVM...');
+    nvm_dir = Path.home() / '.nvm';
+    nvm_script = nvm_dir / 'nvm.sh';
+    if not nvm_script.exists() {
+        return (False, 'NVM is not installed or nvm.sh not found');
+    }
+    try {
+        # Source NVM and install Node.js
+        command = (
+            'export NVM_DIR="$HOME/.nvm"\n' + '[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"\n' + f'nvm install {version}\n' + f'nvm use {version}\n' + f'nvm alias default {version}\n'
+        );
+
+        result = subprocess.run(
+            ['bash', '-c', command], capture_output=True, text=True, timeout=300
+        );
+
+        if result.returncode != 0 {
+            return (False, f'Node.js installation failed: {result.stderr}');
+        }
+
+        print(f'Node.js v{version} installed successfully!');
+        return (True, f'Node.js v{version} installed successfully');
+    } except subprocess.TimeoutExpired {
+        return (False, 'Node.js installation timed out. Please try again.');
+    } except Exception as e {
+        return (False, f'Unexpected error during Node.js installation: {e}');
+    }
+}
+
+"""Ensure Node.js is installed, installing automatically if needed.
+
+Returns tuple of (success: bool, message: str, was_just_installed: bool)
+"""
+impl NodeInstaller.ensure_node_installed(
+    interactive: bool = True
+) -> tuple[bool, str, bool] {
+    # Common fallback message for manual installation
+    manual_install_msg = (
+        'Please install Node.js manually:\n' + '  • Download from: https://nodejs.org/\n' + '  • Or install NVM: https://github.com/nvm-sh/nvm\n' + '  After installation, run "jac add --cl" again.'
+    );
+    # Check if Node.js is already available
+    if NodeInstaller.is_node_installed() and NodeInstaller.is_npm_installed() {
+        version = NodeInstaller.get_node_version();
+        return (True, f'Node.js {version} is already installed', False);
+    }
+    print('\nNode.js is not installed or not found in PATH.');
+    # Check for interactive mode
+    if interactive {
+        print(
+            '\nJac client requires Node.js to build and run client-side applications.'
+        );
+        print(
+            f'Would you like to automatically install Node.js v{NodeInstaller.DEFAULT_NODE_VERSION} using NVM?'
+        );
+        response = input('Install Node.js? [Y/n]: ').strip().lower();
+        if response and response not in ('y', 'yes') {
+            return (
+                False,
+                f'Node.js installation cancelled. {manual_install_msg}',
+                False
+            );
+        }
+    }
+    # Wrap entire installation process in error handling
+    try {
+        # Check if NVM is installed
+        if not NodeInstaller.is_nvm_installed() {
+            success_nvm = NodeInstaller.install_nvm();
+            if not success_nvm[0] {
+                return (
+                    False,
+                    f'Unable to automatically install Node.js.\n\nError: {success_nvm[
+                        1
+                    ]}\n\n{manual_install_msg}',
+                    False
+                );
+            }
+        }
+
+        # Install Node.js via NVM
+        success_node = NodeInstaller.install_node_via_nvm();
+        if not success_node[0] {
+            return (
+                False,
+                f'Unable to automatically install Node.js.\n\nError: {success_node[1]}\n\n{manual_install_msg}',
+                False
+            );
+        }
+
+        # Node.js is now available via NVM sourcing in subprocesses
+        print('\n' + '=' * 70);
+        print('Node.js has been installed successfully!');
+        print('Continuing with package installation...');
+        print('=' * 70 + '\n');
+
+        return (
+            True,
+            f'Node.js {NodeInstaller.DEFAULT_NODE_VERSION} installed successfully',
+            True
+        );
+    } except Exception as e {
+        # Catch any unexpected errors during installation
+        return (
+            False,
+            f'Unable to automatically install Node.js.\n\nUnexpected error: {str(e)}\n\n{manual_install_msg}',
+            False
+        );
+    }
+}
+
+"""Run npm command with NVM environment properly sourced.
+
+This method automatically sources NVM in a subprocess, so npm commands work
+immediately after NVM installation without requiring the user to reload their shell.
+"""
+impl NodeInstaller.run_npm_with_nvm(
+    args: list, cwd: Path, timeout: int = 300
+) -> object {
+    # First, try running npm directly (in case it's already in PATH)
+    try {
+        return subprocess.run(
+            ['npm'] + args,
+            cwd=cwd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=True
+        );
+    } except FileNotFoundError { }
+    # If npm is not in PATH, source NVM and run npm in a subprocess
+    # This allows npm to work immediately after installation without shell reload
+    args_str = ' '.join(args);
+    command = (
+        'export NVM_DIR="$HOME/.nvm"\n' + '[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"\n' + f'npm {args_str}\n'
+    );
+    return subprocess.run(
+        ['bash', '-c', command],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+        check=True
+    );
+}

jac_client/plugin/utils/node_installer.jac

@@ -0,0 +1,41 @@
+"""Automatic Node.js installation utility using NVM."""
+
+import os;
+import platform;
+import subprocess;
+import from pathlib { Path }
+
+"""Handles Node.js installation and detection."""
+obj NodeInstaller {
+    static has DEFAULT_NODE_VERSION: str = "20",
+        NVM_INSTALL_URL: str = "https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh";
+
+    """Check if Node.js is installed and accessible."""
+    static def is_node_installed -> bool;
+
+    """Check if npm is installed and accessible."""
+    static def is_npm_installed -> bool;
+
+    """Check if NVM is installed."""
+    static def is_nvm_installed -> bool;
+
+    """Get the currently installed Node.js version."""
+    static def get_node_version -> (str | None);
+
+    """Install NVM (Node Version Manager)."""
+    static def install_nvm -> tuple[bool, str];
+
+    """Install Node.js using NVM."""
+    static def install_node_via_nvm(version: str = "20") -> tuple[bool, str];
+
+    """Ensure Node.js is installed, installing automatically if needed.
+
+    Returns tuple of (success: bool, message: str, was_just_installed: bool)
+    """
+    static def ensure_node_installed(
+        interactive: bool = True
+    ) -> tuple[bool, str, bool];
+
+    """Run npm command with NVM environment properly sourced."""
+    static def run_npm_with_nvm(args: list, cwd: Path, timeout: int = 300) -> object;
+}