jac-client 0.2.9__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;
+}