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

jac_client/plugin/impl/client.impl.jac

@@ -0,0 +1,193 @@
+import from jaclang.project.config { get_config }
+
+"""Send static file response (images, fonts, etc.)."""
+impl JacClient.send_static_file(
+    handler: BaseHTTPRequestHandler, file_path: Path, content_type: (str | None) = None
+) -> None {
+    import from jaclang.runtimelib.server { ResponseBuilder }
+    if (not file_path.exists() or not file_path.is_file()) {
+        ResponseBuilder.send_json(handler, 404, {'error': 'File not found'});
+        return;
+    }
+    try {
+        file_content = file_path.read_bytes();
+        if (content_type is None) {
+            (content_type, _) = mimetypes.guess_type(str(file_path));
+            if (content_type is None) {
+                content_type = 'application/octet-stream';
+            }
+        }
+        handler.send_response(200);
+        handler.send_header('Content-Type', content_type);
+        handler.send_header('Content-Length', str(len(file_content)));
+        handler.send_header('Cache-Control', 'public, max-age=3600');
+        ResponseBuilder._add_cors_headers(handler);
+        ResponseBuilder._add_custom_headers(handler);
+        handler.end_headers();
+        handler.wfile.write(file_content);
+    } except Exception as exc {
+        ResponseBuilder.send_json(handler, 500, {'error': str(exc)});
+    }
+}
+
+"""Build a client bundle for the supplied module."""
+impl JacClient.build_client_bundle(
+    module: types.ModuleType, force: bool = False
+) -> ClientBundle {
+    builder = JacClient.get_client_bundle_builder();
+    return builder.build(module, force=force);
+}
+
+"""Get the client bundle builder instance."""
+impl JacClient.get_client_bundle_builder -> ViteClientBundleBuilder {
+    import from jaclang.project.config { find_project_root }
+    # Find project root by looking for jac.toml (base_path_dir might be src/ for entry files)
+    base_path_dir = Path(Jac.base_path_dir);
+    project_root_result = find_project_root(base_path_dir);
+    if project_root_result {
+        (base_path, _) = project_root_result;
+    } else {
+        # Fallback to base_path_dir if no project root found
+        base_path = base_path_dir;
+    }
+    # Use ViteBundler to get the client directory
+    bundler = ViteBundler(base_path);
+    client_dir = bundler._get_client_dir();
+    # package.json should only exist in .jac/client/configs/
+    generated_package_json = client_dir / 'configs' / 'package.json';
+    # Generate package.json if it doesn't exist
+    if not generated_package_json.exists() {
+        generated_path = bundler.create_package_json();
+        # Verify the file was created and resolve to absolute path
+        if not generated_path.exists() {
+            raise ClientBundleError(
+                f'Failed to generate package.json at {generated_path}'
+            ) ;
+        }
+        package_json_path = generated_path.resolve();
+    } else {
+        package_json_path = generated_package_json.resolve();
+    }
+    # Final verification that package.json exists before creating builder
+    if not package_json_path.exists() {
+        raise ClientBundleError(
+            f'package.json not found at {package_json_path}. Expected at {generated_package_json}'
+        ) ;
+    }
+    output_dir = client_dir / 'dist';
+    runtime_path = Path(__file__).with_name('client_runtime.cl.jac');
+    return ViteClientBundleBuilder(
+        runtime_path=runtime_path,
+        vite_package_json=package_json_path,
+        vite_output_dir=output_dir,
+        vite_minify=False
+    );
+}
+
+"""Render HTML page for client function using the Vite bundle."""
+impl JacClient.render_page(
+    introspector: ModuleIntrospector,
+    function_name: str,
+    args: dict[(str, Any)],
+    username: str
+) -> dict[str, Any] {
+    introspector.load();
+    available_exports = (
+        set(introspector._client_manifest.get('exports', []))
+        or set(introspector.get_client_functions().keys())
+    );
+    if (function_name not in available_exports) {
+        raise ValueError(f"Client function '{function_name}' not found") ;
+    }
+    bundle_hash = introspector.ensure_bundle();
+    import from jaclang.project.config { find_project_root, get_config }
+    # Find project root by looking for jac.toml (base_path_dir might be src/ for entry files)
+    base_path_dir = Path(Jac.base_path_dir);
+    project_root_result = find_project_root(base_path_dir);
+    if project_root_result {
+        (base_path, _) = project_root_result;
+    } else {
+        # Fallback to base_path_dir if no project root found
+        base_path = base_path_dir;
+    }
+    # Get client directory from config or use default
+    config = get_config();
+    if config is not None {
+        dist_dir = config.get_client_dir() / 'dist';
+    } else {
+        dist_dir = base_path / '.jac' / 'client' / 'dist';
+    }
+    css_link = '';
+    css_file = dist_dir / 'styles.css';
+    if css_file.exists() {
+        css_hash = hashlib.sha256(css_file.read_bytes()).hexdigest()[:8];
+        css_link = f'<link rel="stylesheet" href="/static/styles.css?hash={css_hash}"/>';
+    }
+    # Get meta data from config
+    client_cfg = config.get_plugin_config("client") if config else None;
+    meta_data = client_cfg.get("app_meta_data", {}) if client_cfg else {};
+    charset = meta_data.get("charset", "UTF-8");
+    title = meta_data.get("title", function_name);
+    viewport = meta_data.get("viewport", "width=device-width, initial-scale=1");
+    description = meta_data.get("description", None);
+    robots = meta_data.get("robots", "index, follow");
+    canonical = meta_data.get("canonical", None);
+    og_type = meta_data.get("og_type", "website");
+    og_title = meta_data.get("og_title", title);
+    og_description = meta_data.get("og_description", None);
+    og_url = meta_data.get("og_url", None);
+    og_image = meta_data.get("og_image", None);
+    theme_color = meta_data.get("theme_color", "#ffffff");
+    icon = meta_data.get("icon", None);
+    # Build head content from TOML metadata
+    head_content = f'<meta charset="{html.escape(charset)}"/>\n            <meta name="viewport" content="{html.escape(
+        viewport
+    )}"/>\n            <title>{html.escape(title)}</title>';
+    head_content += f'\n            <meta name="robots" content="{html.escape(robots)}"/>';
+    head_content += f'\n            <meta name="theme-color" content="{html.escape(
+        theme_color
+    )}"/>';
+    head_content += f'\n            <meta property="og:type" content="{html.escape(
+        og_type
+    )}"/>';
+    head_content += f'\n            <meta property="og:title" content="{html.escape(
+        og_title
+    )}"/>';
+    if description {
+        head_content += f'\n            <meta name="description" content="{html.escape(
+            description
+        )}"/>';
+    }
+    if canonical {
+        head_content += f'\n            <link rel="canonical" href="{html.escape(
+            canonical
+        )}"/>';
+    }
+    if icon {
+        head_content += f'\n            <link rel="icon" href="{html.escape(icon)}"/>';
+    }
+    if og_url {
+        head_content += f'\n            <meta property="og:url" content="{html.escape(
+            og_url
+        )}"/>';
+    }
+    if og_image {
+        head_content += f'\n            <meta property="og:image" content="{html.escape(
+            og_image
+        )}"/>';
+    }
+    if og_description {
+        head_content += f'\n            <meta property="og:description" content="{html.escape(
+            og_description
+        )}"/>';
+    }
+    if css_link {
+        head_content += f"\n            {css_link}";
+    }
+    page = f'<!DOCTYPE html><html lang="en"><head>{head_content}</head><body><div id="root"></div><script src="/static/client.js?hash={bundle_hash}" defer></script></body></html>';
+    return {
+        'html': page,
+        'bundle_hash': bundle_hash,
+        'bundle_code': introspector._bundle.code
+    };
+}

jac_client/plugin/impl/client_runtime.impl.jac

@@ -0,0 +1,195 @@
+impl __jacJsx(tag: any, props: dict = {}, children: any = []) -> any {
+    if tag == None {
+        tag = React.Fragment;
+    }
+    childrenArray = [];
+    if children != None {
+        if Array.isArray(children) {
+            childrenArray = children;
+        } else {
+            childrenArray = [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);
+    }
+}
+
+impl useRouter -> dict {
+    navigate = reactRouterUseNavigate();
+    location = reactRouterUseLocation();
+    params = reactRouterUseParams();
+    return {
+        "navigate": navigate,
+        "location": location,
+        "params": params,
+        "pathname": location.pathname,
+        "search": location.search,
+        "hash": location.hash
+    };
+}
+
+impl navigate(path: str) -> None {
+    window.location.hash = "#" + path;
+}
+
+impl __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)
+        }
+    );
+    if not response.ok {
+        error_text = await response.json();
+        walker_name = f"{left}/{right}" if right else left;
+        raise Exception(f"Walker {walker_name} failed: {error_text}") ;
+    }
+    payload = await response.json();
+    return payload["data"] if payload["data"] else {};
+}
+
+impl jacSpawn(left: str, right: str = "", fields: dict = {}) -> any {
+    return __jacSpawn(left, right, fields);
+}
+
+impl __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})
+        }
+    );
+    payload = await response.json();
+    if not payload["ok"] {
+        error_msg = payload["error"] if payload["error"] else "Unknown error";
+        raise Exception(f"Function {function_name} failed: {error_msg}") ;
+    }
+    result = None;
+    try {
+        if payload["data"] and payload["data"]["result"] {
+            result = payload["data"]["result"];
+        }
+    } except Exception { }
+    return result;
+}
+
+impl jacSignup(username: str, password: str) -> dict {
+    response = await fetch(
+        "/user/register",
+        {
+            "method": "POST",
+            "headers": {"Content-Type": "application/json"},
+            "body": JSON.stringify({"username": username, "password": password})
+        }
+    );
+    if response.ok {
+        data = JSON.parse(await response.text());
+        token = None;
+        if data["data"] and data["data"]["token"] {
+            token = data["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};
+        }
+    }
+}
+
+impl 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());
+        console.log("data", data);
+        token = None;
+        try {
+            if data["data"] and data["data"]["token"] {
+                token = data["data"]["token"];
+            }
+        } except Exception { }
+        console.log("token", token);
+        if token {
+            __setLocalStorage("jac_token", token);
+            return True;
+        }
+    }
+    return False;
+}
+
+impl jacLogout -> None {
+    __removeLocalStorage("jac_token");
+}
+
+impl jacIsLoggedIn -> bool {
+    token = __getLocalStorage("jac_token");
+    return token != None and token != "";
+}
+
+impl __getLocalStorage(key: str) -> str {
+    storage = globalThis.localStorage;
+    return storage.getItem(key) if storage else "";
+}
+
+impl __setLocalStorage(key: str, value: str) -> None {
+    storage = globalThis.localStorage;
+    if storage {
+        storage.setItem(key, value);
+    }
+}
+
+impl __removeLocalStorage(key: str) -> None {
+    storage = globalThis.localStorage;
+    if storage {
+        storage.removeItem(key);
+    }
+}

jac_client/plugin/impl/vite_client_bundle.impl.jac

@@ -0,0 +1,72 @@
+"""Clean up the compiled directory and its contents."""
+
+impl ViteClientBundleBuilder.cleanup_temp_dir(self: ViteClientBundleBuilder) -> None {
+    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 / 'compiled';
+    if temp_dir.exists() {
+        with contextlib.suppress(OSError, shutil.Error) {
+            shutil.rmtree(temp_dir);
+        }
+    }
+}
+
+"""Override to use Vite bundling instead of simple concatenation."""
+impl ViteClientBundleBuilder._compile_bundle(
+    self: ViteClientBundleBuilder, module: ModuleType, module_path: Path
+) -> ClientBundle {
+    compiler = self._get_compiler();
+    (bundle_code, bundle_hash, client_exports, client_globals) = compiler.compile_and_bundle(
+        module, module_path
+    );
+    return ClientBundle(
+        module_name=module.__name__,
+        code=bundle_code,
+        client_functions=client_exports,
+        client_globals=client_globals,
+        hash=bundle_hash
+    );
+}
+
+"""Get or create the Vite compiler instance."""
+impl ViteClientBundleBuilder._get_compiler(
+    self: ViteClientBundleBuilder
+) -> ViteCompiler {
+    if (self._compiler is None) {
+        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'
+            ) ;
+        }
+        compile_to_js_func: Callable[([Path], tuple[(str, (ModuleType | None))])] = cast(
+            Callable[([Path], tuple[(str, (ModuleType | None))])], self._compile_to_js
+        );
+        self._compiler = ViteCompiler(
+            vite_package_json=self.vite_package_json,
+            vite_output_dir=self.vite_output_dir,
+            vite_minify=self.vite_minify,
+            runtime_path=self.runtime_path,
+            compile_to_js_func=compile_to_js_func,
+            extract_exports_func=self._extract_client_exports,
+            extract_globals_func=self._extract_client_globals
+        );
+    }
+    return self._compiler;
+}
+
+"""Initialize the Vite-enhanced bundle builder."""
+impl ViteClientBundleBuilder.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 {
+    super.init(runtime_path);
+    self.vite_output_dir = vite_output_dir;
+    self.vite_package_json = vite_package_json;
+    self.vite_minify = vite_minify;
+    self._compiler: (ViteCompiler | None) = None;
+}

jac_client/plugin/plugin_config.jac

@@ -0,0 +1,195 @@
+"""Plugin configuration hooks for jac-client.
+
+This module implements JacPluginConfig hooks to integrate with core's
+configuration system, registering:
+- Plugin metadata (name, version)
+- Config schema for [plugins.client] section
+- npm dependency type for [dependencies.npm] section
+"""
+
+import subprocess;
+import sys;
+import from pathlib { Path }
+import from typing { Any }
+import from jaclang.pycore.runtime { hookimpl }
+import from jaclang.project.config { JacConfig }
+
+"""Plugin configuration hooks for jac-client."""
+class JacClientPluginConfig {
+    """Return plugin metadata."""
+    @hookimpl
+    static def get_plugin_metadata -> dict[str, Any] {
+        return {
+            "name": "client",
+            "version": "1.0.0",
+            "description": "Jac client-side rendering with Vite bundling"
+        };
+    }
+
+    """Return the plugin's configuration schema for [plugins.client]."""
+    @hookimpl
+    static def get_config_schema -> dict[str, Any] {
+        return {
+            "section": "client",
+            "options": {
+                "vite": {
+                    "type": "dict",
+                    "default": {},
+                    "description": "Vite bundler configuration",
+                    "nested": {
+                        "plugins": {
+                            "type": "list",
+                            "default": [],
+                            "description": "Vite plugins to include"
+                        },
+                        "lib_imports": {
+                            "type": "list",
+                            "default": [],
+                            "description": "Library imports for vite.config.js"
+                        },
+                        "build": {
+                            "type": "dict",
+                            "default": {},
+                            "description": "Vite build options"
+                        },
+                        "server": {
+                            "type": "dict",
+                            "default": {},
+                            "description": "Vite dev server options"
+                        },
+                        "resolve": {
+                            "type": "dict",
+                            "default": {},
+                            "description": "Vite resolve options"
+                        }
+                    }
+                },
+                "ts": {
+                    "type": "dict",
+                    "default": {},
+                    "description": "TypeScript configuration overrides"
+                }
+            }
+        };
+    }
+
+    """Register npm as a dependency type for [dependencies.npm]."""
+    @hookimpl
+    static def register_dependency_type -> dict[str, Any] {
+        return {
+            "name": "npm",
+            "dev_name": "npm.dev",
+            "cli_flag": "--cl",
+            "install_dir": ".jac/client/configs",
+            "install_handler": _npm_install_handler,
+            "install_all_handler": _npm_install_all_handler,
+            "remove_handler": _npm_remove_handler
+        };
+    }
+}
+
+"""Install an npm package."""
+def _npm_install_handler(
+    config: JacConfig,
+    package_name: str,
+    version: str | None = None,
+    is_dev: bool = False
+) -> None {
+    import from jac_client.plugin.src.vite_bundler { ViteBundler }
+
+    if config.project_root is None {
+        raise RuntimeError("No project root found") ;
+    }
+
+    project_dir = config.project_root;
+
+    # Add to config (core JacConfig handles this)
+    package_version = version or "latest";
+    config.add_dependency(package_name, package_version, dev=is_dev, dep_type="npm");
+    config.save();
+
+    # Generate package.json and run npm install
+    _regenerate_and_install(project_dir);
+}
+
+"""Install all npm packages from jac.toml."""
+def _npm_install_all_handler(config: JacConfig) -> None {
+    if config.project_root is None {
+        raise RuntimeError("No project root found") ;
+    }
+
+    _regenerate_and_install(config.project_root);
+}
+
+"""Remove an npm package."""
+def _npm_remove_handler(
+    config: JacConfig, package_name: str, is_dev: bool = False
+) -> None {
+    if config.project_root is None {
+        raise RuntimeError("No project root found") ;
+    }
+
+    project_dir = config.project_root;
+
+    # Remove from config (core JacConfig handles this)
+    result = config.remove_dependency(package_name, dev=is_dev, dep_type="npm");
+    if not result {
+        deps_key = "dev-dependencies" if is_dev else "dependencies";
+        raise RuntimeError(f'Package "{package_name}" not found in {deps_key}') ;
+    }
+
+    config.save();
+
+    # Regenerate package.json and run npm install
+    _regenerate_and_install(project_dir);
+}
+
+"""Regenerate package.json from jac.toml and run npm install."""
+def _regenerate_and_install(project_dir: Path) -> None {
+    import from jac_client.plugin.src.vite_bundler { ViteBundler }
+    import shutil;
+
+    bundler = ViteBundler(project_dir);
+    bundler.create_package_json();
+
+    # Install to .jac/client/ directory where babel processor expects it
+    client_dir = bundler._get_client_dir();
+    client_dir.mkdir(parents=True, exist_ok=True);
+
+    # Copy package.json to .jac/client/ for npm install
+    configs_package_json = client_dir / 'configs' / 'package.json';
+    build_package_json = client_dir / 'package.json';
+    if configs_package_json.exists() {
+        shutil.copy2(configs_package_json, build_package_json);
+    }
+
+    try {
+        subprocess.run(
+            ["npm", "install"],
+            cwd=client_dir,
+            check=True,
+            capture_output=True,
+            text=True
+        );
+    } except subprocess.CalledProcessError as e {
+        raise RuntimeError(f"Failed to install npm packages: {e.stderr}") from e ;
+    } except FileNotFoundError {
+        raise RuntimeError(
+            "npm command not found. Ensure Node.js and npm are installed."
+        ) from None ;
+    } finally {
+        # Clean up temporary package.json
+        if build_package_json.exists() {
+            build_package_json.unlink();
+        }
+        # Move package-lock.json to configs/ if it exists
+        build_package_lock = client_dir / 'package-lock.json';
+        if build_package_lock.exists() {
+            configs_package_lock = client_dir / 'configs' / 'package-lock.json';
+            if configs_package_lock.exists() {
+                configs_package_lock.unlink();
+            }
+            build_package_lock.rename(configs_package_lock);
+        }
+    }
+}

jac_client/plugin/src/__init__.jac

@@ -0,0 +1,20 @@
+"""Vite client bundle processing modules."""
+import from jac_client.plugin.src.asset_processor { AssetProcessor }
+import from jac_client.plugin.src.babel_processor { BabelProcessor }
+import from jac_client.plugin.src.compiler { ViteCompiler }
+import from jac_client.plugin.src.config_loader { JacClientConfig }
+import from jac_client.plugin.src.import_processor { ImportProcessor }
+import from jac_client.plugin.src.jac_to_js { JacToJSCompiler }
+import from jac_client.plugin.src.package_installer { PackageInstaller }
+import from jac_client.plugin.src.vite_bundler { ViteBundler }
+
+glob __all__ = [
+         'AssetProcessor',
+         'BabelProcessor',
+         'ViteCompiler',
+         'JacClientConfig',
+         'ImportProcessor',
+         'JacToJSCompiler',
+         'ViteBundler',
+         'PackageInstaller'
+     ];