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

jac_client/plugin/impl/client.impl.jac

@@ -30,13 +30,6 @@ impl JacClient.send_static_file(
     }
 }
 
-"""Get a module introspector for the supplied module."""
-impl JacClient.get_module_introspector(
-    module_name: str, base_path: (str | None)
-) -> ModuleIntrospector {
-    return JacClientModuleIntrospector(module_name, base_path);
-}
-
 """Build a client bundle for the supplied module."""
 impl JacClient.build_client_bundle(
     module: types.ModuleType, force: bool = False
@@ -57,12 +50,13 @@ impl JacClient.get_client_bundle_builder -> ViteClientBundleBuilder {
         # Fallback to base_path_dir if no project root found
         base_path = base_path_dir;
     }
-    # package.json should only exist in .client-build/.jac-client.configs/
-    generated_package_json = base_path / '.client-build' / '.jac-client.configs' / 'package.json';
+    # 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() {
-        # Use ViteBundler to generate package.json from config.json
-        bundler = ViteBundler(base_path);
         generated_path = bundler.create_package_json();
         # Verify the file was created and resolve to absolute path
         if not generated_path.exists() {
@@ -80,7 +74,7 @@ impl JacClient.get_client_bundle_builder -> ViteClientBundleBuilder {
             f'package.json not found at {package_json_path}. Expected at {generated_package_json}'
         ) ;
     }
-    output_dir = base_path / '.client-build' / 'dist';
+    output_dir = client_dir / 'dist';
     runtime_path = Path(__file__).with_name('client_runtime.cl.jac');
     return ViteClientBundleBuilder(
         runtime_path=runtime_path,
@@ -91,22 +85,22 @@ impl JacClient.get_client_bundle_builder -> ViteClientBundleBuilder {
 }
 
 """Render HTML page for client function using the Vite bundle."""
-impl JacClientModuleIntrospector.render_page(
-    self: JacClientModuleIntrospector,
+impl JacClient.render_page(
+    introspector: ModuleIntrospector,
     function_name: str,
     args: dict[(str, Any)],
     username: str
 ) -> dict[str, Any] {
-    self.load();
+    introspector.load();
     available_exports = (
-        set(self._client_manifest.get('exports', []))
-        or set(self.get_client_functions().keys())
+        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 = self.ensure_bundle();
-    import from jaclang.project.config { find_project_root }
+    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);
@@ -116,19 +110,84 @@ impl JacClientModuleIntrospector.render_page(
         # Fallback to base_path_dir if no project root found
         base_path = base_path_dir;
     }
-    dist_dir = base_path / '.client-build' / 'dist';
+    # 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 / 'main.css';
+    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/main.css?hash={css_hash}"/>';
+        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
+        )}"/>';
     }
-    head_content = f'<meta charset="utf-8"/>\n            <title>{html.escape(
-        function_name
-    )}</title>';
     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': self._bundle.code};
+    return {
+        'html': page,
+        'bundle_hash': bundle_hash,
+        'bundle_code': introspector._bundle.code
+    };
 }

jac_client/plugin/impl/client_runtime.impl.jac

@@ -65,9 +65,11 @@ impl __jacSpawn(left: str, right: str = "", fields: dict = {}) -> any {
     );
     if not response.ok {
         error_text = await response.json();
-        raise Exception(f"Walker {walker} failed: {error_text}") ;
+        walker_name = f"{left}/{right}" if right else left;
+        raise Exception(f"Walker {walker_name} failed: {error_text}") ;
     }
-    return await response.json();
+    payload = await response.json();
+    return payload["data"] if payload["data"] else {};
 }
 
 impl jacSpawn(left: str, right: str = "", fields: dict = {}) -> any {
@@ -87,12 +89,18 @@ impl __jacCallFunction(function_name: str, args: dict = {}) -> any {
             "body": JSON.stringify({"args": args})
         }
     );
-    if not response.ok {
-        error_text = await response.text();
-        raise Exception(f"Function {function_name} failed: {error_text}") ;
+    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}") ;
     }
-    data = JSON.parse(await response.text());
-    return data["result"];
+    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 {
@@ -106,7 +114,10 @@ impl jacSignup(username: str, password: str) -> dict {
     );
     if response.ok {
         data = JSON.parse(await response.text());
-        token = data["token"];
+        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};
@@ -139,7 +150,14 @@ impl jacLogin(username: str, password: str) -> bool {
     );
     if response.ok {
         data = JSON.parse(await response.text());
-        token = data["token"];
+        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;

jac_client/plugin/plugin_config.jac

@@ -80,7 +80,7 @@ class JacClientPluginConfig {
             "name": "npm",
             "dev_name": "npm.dev",
             "cli_flag": "--cl",
-            "install_dir": ".client-build/.jac-client.configs",
+            "install_dir": ".jac/client/configs",
             "install_handler": _npm_install_handler,
             "install_all_handler": _npm_install_all_handler,
             "remove_handler": _npm_remove_handler
@@ -152,13 +152,13 @@ def _regenerate_and_install(project_dir: Path) -> None {
     bundler = ViteBundler(project_dir);
     bundler.create_package_json();
 
-    # Install to .client-build/ directory where babel processor expects it
-    build_dir = project_dir / '.client-build';
-    build_dir.mkdir(exist_ok=True);
+    # 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 .client-build/ for npm install
-    configs_package_json = build_dir / '.jac-client.configs' / 'package.json';
-    build_package_json = build_dir / 'package.json';
+    # 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);
     }
@@ -166,7 +166,7 @@ def _regenerate_and_install(project_dir: Path) -> None {
     try {
         subprocess.run(
             ["npm", "install"],
-            cwd=build_dir,
+            cwd=client_dir,
             check=True,
             capture_output=True,
             text=True
@@ -182,10 +182,10 @@ def _regenerate_and_install(project_dir: Path) -> None {
         if build_package_json.exists() {
             build_package_json.unlink();
         }
-        # Move package-lock.json to .jac-client.configs/ if it exists
-        build_package_lock = build_dir / 'package-lock.json';
+        # 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 = build_dir / '.jac-client.configs' / 'package-lock.json';
+            configs_package_lock = client_dir / 'configs' / 'package-lock.json';
             if configs_package_lock.exists() {
                 configs_package_lock.unlink();
             }

jac_client/plugin/src/compiler.jac

@@ -52,6 +52,7 @@ class ViteCompiler {
         source_root: (Path | None) = None
     ) -> None;
 
+    def _get_client_dir(self: ViteCompiler) -> Path;
     def _copy_js_file(self: ViteCompiler, js_path: Path, source_root: Path) -> None;
     def _copy_ts_file(self: ViteCompiler, ts_path: Path, source_root: Path) -> None;
     def _copy_asset_file(
@@ -59,7 +60,7 @@ class ViteCompiler {
     ) -> None;
 
     def copy_root_assets(self: ViteCompiler) -> None;
-    def create_entry_file(self: ViteCompiler) -> None;
+    def create_entry_file(self: ViteCompiler, module_path: Path) -> None;
     def compile_and_bundle(
         self: ViteCompiler, module: ModuleType, module_path: Path
     ) -> tuple[str, str, list[str], list[str]];

jac_client/plugin/src/impl/babel_processor.impl.jac

@@ -17,21 +17,21 @@ impl BabelProcessor.compile(self: BabelProcessor) -> None {
     bundler._ensure_root_package_json();
     try {
         # Ensure dependencies are installed (check if node_modules exists)
-        build_dir = self.project_dir / '.client-build';
-        node_modules = build_dir / 'node_modules';
+        client_dir = bundler._get_client_dir();
+        node_modules = client_dir / 'node_modules';
         if not node_modules.exists() {
-            # Temporarily copy package.json to .client-build/ for npm install
-            build_package_json = build_dir / 'package.json';
-            configs_package_json = build_dir / '.jac-client.configs' / 'package.json';
+            # Temporarily copy package.json to .jac/client/ for npm install
+            build_package_json = client_dir / 'package.json';
+            configs_package_json = client_dir / 'configs' / 'package.json';
             if configs_package_json.exists() and not build_package_json.exists() {
                 import shutil;
                 shutil.copy2(configs_package_json, build_package_json);
             }
             try {
-                # Install to .client-build/node_modules
+                # Install to .jac/client/node_modules
                 subprocess.run(
                     ['npm', 'install'],
-                    cwd=build_dir,
+                    cwd=client_dir,
                     check=True,
                     capture_output=True,
                     text=True
@@ -47,27 +47,32 @@ impl BabelProcessor.compile(self: BabelProcessor) -> None {
             }
         }
 
-        # Temporarily copy package.json to .client-build/ for npm run compile
-        build_package_json = build_dir / 'package.json';
-        configs_package_json = build_dir / '.jac-client.configs' / 'package.json';
+        # Temporarily copy package.json to .jac/client/ for npm run compile
+        build_package_json = client_dir / 'package.json';
+        configs_package_json = client_dir / 'configs' / 'package.json';
         if configs_package_json.exists() and not build_package_json.exists() {
             import shutil;
             shutil.copy2(configs_package_json, build_package_json);
         }
         command = ['npm', 'run', 'compile'];
-        subprocess.run(
-            command, cwd=build_dir, check=True, capture_output=True, text=True
+        result = subprocess.run(
+            command, cwd=client_dir, capture_output=True, text=True
         );
+        if result.returncode != 0 {
+            # Show the actual error from npm/babel
+            error_output = result.stderr or result.stdout or "Unknown error";
+            raise RuntimeError(f"Client bundle compilation failed:\n{error_output}") ;
+        }
     } finally {
-        # Clean up temporary package.json in .client-build/
-        build_package_json = build_dir / 'package.json';
+        # Clean up temporary package.json in .jac/client/
+        build_package_json = client_dir / 'package.json';
         if build_package_json.exists() {
             build_package_json.unlink();
         }
-        # Move package-lock.json to .jac-client.configs/ if it exists
-        build_package_lock = build_dir / 'package-lock.json';
+        # 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 = build_dir / '.jac-client.configs' / 'package-lock.json';
+            configs_package_lock = client_dir / 'configs' / 'package-lock.json';
             if configs_package_lock.exists() {
                 configs_package_lock.unlink();
             }

jac_client/plugin/src/impl/compiler.impl.jac

@@ -1,5 +1,18 @@
-"""Compile module and dependencies, then bundle with Vite."""
+"""Get the client build directory from project config."""
+impl ViteCompiler._get_client_dir(self: ViteCompiler) -> Path {
+    # Try to get from project config
+    try {
+        import from jaclang.project.config { get_config }
+        config = get_config();
+        if config is not None {
+            return config.get_client_dir();
+        }
+    } except ImportError { }
+    # Fallback to default
+    return self.project_dir / '.jac' / 'client';
+}
 
+"""Compile module and dependencies, then bundle with Vite."""
 impl ViteCompiler.compile_and_bundle(
     self: ViteCompiler, module: ModuleType, module_path: Path
 ) -> tuple[str, str, list[str], list[str]] {
@@ -16,14 +29,13 @@ impl ViteCompiler.compile_and_bundle(
         collected_globals=collected_globals
     );
     self.copy_root_assets();
-    self.create_entry_file();
+    self.create_entry_file(module_path);
     self.babel_processor.compile();
+    client_dir = self._get_client_dir();
     self.babel_processor.copy_assets_after_compile(
-        self.compiled_dir,
-        (self.project_dir / '.client-build' / 'build'),
-        self.asset_processor
+        self.compiled_dir, (client_dir / 'build'), self.asset_processor
     );
-    entry_file = self.project_dir / '.client-build' / 'build' / 'main.js';
+    entry_file = client_dir / 'build' / '_entry.js';
     self.vite_bundler.build(entry_file=entry_file);
     (bundle_code, bundle_hash) = self.vite_bundler.read_bundle();
     client_exports = sorted(collected_exports);
@@ -32,9 +44,12 @@ impl ViteCompiler.compile_and_bundle(
 }
 
 """Create the main entry file for Vite bundling."""
-impl ViteCompiler.create_entry_file(self: ViteCompiler) -> None {
-    entry_file = self.compiled_dir / 'main.js';
-    entry_content = 'import React from "react";\nimport { createRoot } from "react-dom/client";\nimport { app as App } from "./app.js";\n\nconst root = createRoot(document.getElementById("root"));\nroot.render(<App />);\n';
+impl ViteCompiler.create_entry_file(self: ViteCompiler, module_path: Path) -> None {
+    # Use _entry.js to avoid conflict with compiled modules that may be named main.js
+    entry_file = self.compiled_dir / '_entry.js';
+    # Derive the app module filename from the entry point (e.g., main.jac -> main.js, app.jac -> app.js)
+    app_module_name = module_path.stem;
+    entry_content = f'import React from "react";\nimport {{ createRoot }} from "react-dom/client";\nimport {{ app as App }} from "./{app_module_name}.js";\n\nconst root = createRoot(document.getElementById("root"));\nroot.render(React.createElement(App, null));\n';
     entry_file.write_text(entry_content, encoding='utf-8');
 }
 
@@ -46,7 +61,7 @@ impl ViteCompiler.copy_root_assets(self: ViteCompiler) -> None {
         self.asset_processor.copy_assets(root_assets_dir, compiled_assets_dir);
     }
     # Copy configured_asset files from root assets/ to build assets/ (bypassing compiled)
-    build_assets_dir = self.project_dir / '.client-build' / 'build' / 'assets';
+    build_assets_dir = self._get_client_dir() / 'build' / 'assets';
     if (root_assets_dir.exists() and root_assets_dir.is_dir()) {
         self.asset_processor.copy_custom_asset_types(root_assets_dir, build_assets_dir);
     }
@@ -149,9 +164,29 @@ impl ViteCompiler.compile_dependencies_recursively(
     combined_js = self.jac_compiler.add_runtime_imports(module_js);
     try {
         relative_path = module_path.relative_to(source_root);
-        output_path = self.compiled_dir / relative_path.with_suffix('.js');
+        # Handle compound extensions like .cl.jac, .impl.jac -> .js
+        rel_str = str(relative_path);
+        for compound_ext in ['.cl.jac', '.impl.jac', '.test.jac'] {
+            if rel_str.endswith(compound_ext) {
+                rel_str = rel_str[:-len(compound_ext)] + '.js';
+                break;
+            }
+        } else {
+            rel_str = str(relative_path.with_suffix('.js'));
+        }
+        output_path = self.compiled_dir / rel_str;
     } except ValueError {
-        output_path = self.compiled_dir / f"{module_path.stem}.js";
+        # Handle compound extensions in filename
+        name = module_path.name;
+        for compound_ext in ['.cl.jac', '.impl.jac', '.test.jac'] {
+            if name.endswith(compound_ext) {
+                name = name[:-len(compound_ext)] + '.js';
+                break;
+            }
+        } else {
+            name = module_path.stem + '.js';
+        }
+        output_path = self.compiled_dir / name;
     }
     output_path.parent.mkdir(parents=True, exist_ok=True);
     output_path.write_text(combined_js, encoding='utf-8');
@@ -228,19 +263,21 @@ impl ViteCompiler.init(
         ) ;
     }
     self.vite_package_json = vite_package_json;
-    # If package.json is in .client-build/.jac-client.configs/, go up two levels to get project root
+    # Detect project root: package.json may be in .jac/client/configs/ or project root
     if (
-        vite_package_json.parent.name == '.jac-client.configs'
-        and vite_package_json.parent.parent.name == '.client-build'
+        vite_package_json.parent.name == 'configs'
+        and vite_package_json.parent.parent.name == 'client'
+        and vite_package_json.parent.parent.parent.name == '.jac'
     ) {
-        self.project_dir = vite_package_json.parent.parent.parent;
-    } elif (vite_package_json.parent.name == '.jac-client.configs') {
+        # .jac/client/configs/package.json -> go up 3 levels to project root
+        self.project_dir = vite_package_json.parent.parent.parent.parent;
+    } elif (vite_package_json.parent.name == 'configs') {
         self.project_dir = vite_package_json.parent.parent;
     } else {
         self.project_dir = vite_package_json.parent;
     }
     self.runtime_path = runtime_path;
-    self.compiled_dir = self.project_dir / '.client-build' / 'compiled';
+    self.compiled_dir = self._get_client_dir() / 'compiled';
     self.jac_compiler = JacToJSCompiler(
         compile_to_js_func, extract_exports_func, extract_globals_func
     );