jac-client 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

jac_client/plugin/plugin_config.jac

@@ -157,41 +157,26 @@ def _load_template(template_name: str) -> dict[str, Any] | None {
 # ===============================================================================
 # Post-create Hook for Client Template
 # ===============================================================================
-"""Post-create hook to ensure Node.js is installed and optionally install npm packages."""
+"""Post-create hook to ensure Bun is installed and optionally install packages."""
 def _post_create_client(project_path: Path, project_name: str) -> None {
     import from jac_client.plugin.src.vite_bundler { ViteBundler }
-    import from jac_client.plugin.utils.node_installer { NodeInstaller }
     import from jaclang.cli.console { console }
-    import shutil;
+    import from jac_client.plugin.utils { ensure_bun_available }
 
-    # First, ensure Node.js is installed
+    # First, ensure Bun is installed (prompt to install if not)
     console.print();
-    with console.status(
-        "[cyan]Checking Node.js installation...[/cyan]", spinner="dots"
-    ) as status {
-        node_result = NodeInstaller.ensure_node_installed(interactive=True);
-        node_installed = node_result[0];
-        message = node_result[1];
-        was_just_installed = node_result[2];
-    }
-
-    if not node_installed {
-        console.warning(f"Node.js is required for client development");
-        console.print(f"\n  {message}", file=sys.stderr);
-        console.print(
-            "  After installing Node.js, run: jac add --cl\n",
-            style="muted",
-            file=sys.stderr
-        );
+    if not ensure_bun_available() {
+        console.warning("Bun is required for client development");
+        console.print("  After installing Bun, run: jac add --cl\n", style="muted");
         return;
     }
 
-    console.print(f"  ✔ {message}", style="success");
+    console.print("  ✔ Bun is installed", style="success");
 
-    # Check if npm package installation should be skipped
+    # Check if package installation should be skipped
     if os.environ.get("JAC_CLIENT_SKIP_NPM_INSTALL") {
         console.print(
-            "\n  ⏭ Skipping npm package installation (JAC_CLIENT_SKIP_NPM_INSTALL is set)",
+            "\n  ⏭ Skipping package installation (JAC_CLIENT_SKIP_NPM_INSTALL is set)",
             style="muted"
         );
         console.print(
@@ -223,7 +208,7 @@ def _post_create_client(project_path: Path, project_name: str) -> None {
         client_dir = bundler._get_client_dir();
         client_dir.mkdir(parents=True, exist_ok=True);
 
-        # Copy package.json to .jac/client/ for npm install
+        # Copy package.json to .jac/client/ for bun install
         configs_package_json = client_dir / 'configs' / 'package.json';
         build_package_json = client_dir / 'package.json';
 
@@ -237,38 +222,38 @@ def _post_create_client(project_path: Path, project_name: str) -> None {
 
         shutil.copy2(configs_package_json, build_package_json);
 
-        # Run npm install using NodeInstaller to handle NVM environment
-        try {
-            console.print("  Installing npm packages...", style="cyan");
-            with console.status(
-                "[cyan]Installing npm packages...[/cyan]", spinner="dots"
-            ) as status {
-                NodeInstaller.run_npm_with_nvm(
-                    ['install'], cwd=client_dir, timeout=300
-                );
+        # Run bun install (ensure bun is available first)
+        import from jac_client.plugin.utils { ensure_bun_available }
+        if not ensure_bun_available() {
+            console.warning("Bun is required. Install manually: https://bun.sh");
+            console.print(
+                "  💡 You can install packages later with: jac add --cl\n",
+                style="muted"
+            );
+            # Clean up temporary package.json
+            if build_package_json.exists() {
+                build_package_json.unlink();
             }
+            return;
+        }
 
-            # Move package-lock.json to configs/ if it was created
-            build_package_lock = client_dir / 'package-lock.json';
-            configs_package_lock = client_dir / 'configs' / 'package-lock.json';
-            if build_package_lock.exists() {
-                if configs_package_lock.exists() {
-                    configs_package_lock.unlink();
+        try {
+            console.print("\n  ⏳ Installing packages...\n", style="cyan");
+            subprocess.run(['bun', 'install'], cwd=client_dir, check=True, timeout=300);
+
+            # Move bun.lockb to configs/ if it was created
+            build_bun_lockb = client_dir / 'bun.lockb';
+            configs_bun_lockb = client_dir / 'configs' / 'bun.lockb';
+            if build_bun_lockb.exists() {
+                if configs_bun_lockb.exists() {
+                    configs_bun_lockb.unlink();
                 }
-                shutil.move(str(build_package_lock), str(configs_package_lock));
+                shutil.move(str(build_bun_lockb), str(configs_bun_lockb));
             }
 
-            console.print("  ✔ npm packages installed", style="success");
+            console.print("  ✔ Packages installed", style="success");
         } except subprocess.CalledProcessError as e {
-            console.warning(f"Failed to install packages: {e.stderr}");
-            console.print(
-                "  💡 You can install packages later with: jac add --cl\n",
-                style="muted"
-            );
-        } except FileNotFoundError {
-            console.warning(
-                "npm command not found. This may require reloading your shell."
-            );
+            console.warning(f"Failed to install packages: {e}");
             console.print(
                 "  💡 You can install packages later with: jac add --cl\n",
                 style="muted"
@@ -285,19 +270,6 @@ def _post_create_client(project_path: Path, project_name: str) -> None {
             "  💡 You can install packages later with: jac add --cl\n", style="muted"
         );
     }
-
-    # If Node.js was just installed, offer to restart terminal for full integration
-    if was_just_installed {
-        console.print();
-        console.info("Node.js was just installed via NVM");
-        console.print(
-            "\n  For Node.js to be available in your current shell:", style="muted"
-        );
-        console.print("    1. Run: source ~/.nvm/nvm.sh", style="muted");
-        console.print("    2. Or restart your terminal", style="muted");
-        console.print("\n  💡 npm commands from jac work immediately", style="info");
-        console.print();
-    }
 }
 
 # ===============================================================================
@@ -357,39 +329,25 @@ def _npm_remove_handler(
     _regenerate_and_install(project_dir);
 }
 
-"""Regenerate package.json from jac.toml and run npm install."""
+"""Regenerate package.json from jac.toml and run bun install."""
 def _regenerate_and_install(project_dir: Path) -> None {
     import from jac_client.plugin.src.vite_bundler { ViteBundler }
-    import from jac_client.plugin.utils.node_installer { NodeInstaller }
+    import from jac_client.plugin.utils { ensure_bun_available }
     import shutil;
 
-    # Ensure Node.js is installed before proceeding
-    node_result = NodeInstaller.ensure_node_installed(interactive=True);
-    node_installed = node_result[0];
-    message = node_result[1];
-    was_just_installed = node_result[2];
-
-    if not node_installed {
-        raise RuntimeError(
-            f"Node.js installation required:\n{message}\n" + "Please install Node.js and try again."
-        ) ;
-    }
-
-    # Inform user if Node.js was just installed
-    if was_just_installed {
-        print(
-            "\nNote: Node.js was just installed. npm commands will work via NVM sourcing."
-        );
+    # Ensure Bun is installed before proceeding (prompt to install if not)
+    if not ensure_bun_available() {
+        raise RuntimeError("Bun is required. Install manually: https://bun.sh") from None ;
     }
 
     bundler = ViteBundler(project_dir);
     bundler.create_package_json();
 
-    # Install to .jac/client/ directory where babel processor expects it
+    # Install to .jac/client/ directory
     client_dir = bundler._get_client_dir();
     client_dir.mkdir(parents=True, exist_ok=True);
 
-    # Copy package.json to .jac/client/ for npm install
+    # Copy package.json to .jac/client/ for bun install
     configs_package_json = client_dir / 'configs' / 'package.json';
     build_package_json = client_dir / 'package.json';
     if configs_package_json.exists() {
@@ -397,27 +355,23 @@ def _regenerate_and_install(project_dir: Path) -> None {
     }
 
     try {
-        # Use NodeInstaller.run_npm_with_nvm to handle NVM environment
-        NodeInstaller.run_npm_with_nvm(["install"], cwd=client_dir, timeout=300);
+        # Run bun install
+        subprocess.run(['bun', 'install'], cwd=client_dir, check=True, timeout=300);
     } 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. This may require reloading your shell after Node.js installation."
-        ) from None ;
+        raise RuntimeError(f"Failed to install packages: {e}") from e ;
     } 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();
+        # Move bun.lockb to configs/ if it exists
+        build_bun_lockb = client_dir / 'bun.lockb';
+        if build_bun_lockb.exists() {
+            configs_bun_lockb = client_dir / 'configs' / 'bun.lockb';
+            if configs_bun_lockb.exists() {
+                configs_bun_lockb.unlink();
             }
-            build_package_lock.rename(configs_package_lock);
+            build_bun_lockb.rename(configs_bun_lockb);
         }
     }
 }

jac_client/plugin/src/__init__.jac

@@ -1,6 +1,5 @@
 """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 }
@@ -10,7 +9,6 @@ import from jac_client.plugin.src.vite_bundler { ViteBundler }
 
 glob __all__ = [
          'AssetProcessor',
-         'BabelProcessor',
          'ViteCompiler',
          'JacClientConfig',
          'ImportProcessor',

jac_client/plugin/src/compiler.jac

@@ -6,7 +6,6 @@ import from types { ModuleType }
 import from typing { TYPE_CHECKING, Any }
 import from jaclang.runtimelib.client_bundle { ClientBundleError }
 import from .asset_processor { AssetProcessor }
-import from .babel_processor { BabelProcessor }
 import from .import_processor { ImportProcessor }
 import from .jac_to_js { JacToJSCompiler }
 import from .vite_bundler { ViteBundler }

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

@@ -16,7 +16,6 @@ impl ViteCompiler._get_client_dir(self: ViteCompiler) -> Path {
 impl ViteCompiler.compile_and_bundle(
     self: ViteCompiler, module: ModuleType, module_path: Path
 ) -> tuple[str, str, list[str], list[str]] {
-    self.compile_runtime_utils();
     (module_js, mod, module_manifest) = self.jac_compiler.compile_module(module_path);
     collected_exports: set[str] = set(
         self.jac_compiler.extract_exports(module_manifest)
@@ -28,14 +27,14 @@ impl ViteCompiler.compile_and_bundle(
         collected_exports=collected_exports,
         collected_globals=collected_globals
     );
+    # Compile runtime AFTER dependencies so it overwrites any dependency-compiled
+    # version of client_runtime.js with the proper ES module exports
+    self.compile_runtime_utils();
     self.copy_root_assets();
     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, (client_dir / 'build'), self.asset_processor
-    );
-    entry_file = client_dir / 'build' / '_entry.js';
+    # Vite handles JSX/TSX transpilation natively with Bun - no Babel needed
+    # Vite builds directly from compiled/ directory
+    entry_file = self.compiled_dir / '_entry.js';
     self.vite_bundler.build(entry_file=entry_file);
     (bundle_code, bundle_hash) = self.vite_bundler.read_bundle();
     client_exports = sorted(collected_exports);
@@ -49,7 +48,7 @@ impl ViteCompiler.create_entry_file(self: ViteCompiler, module_path: Path) -> No
     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";\nimport {{ JacClientErrorBoundary, ErrorFallback }} from "@jac-client/utils";\n\nconst root = createRoot(document.getElementById("root"));\nroot.render(\n\tReact.createElement(\n\t\tJacClientErrorBoundary,{{ FallbackComponent: ErrorFallback }},\n\t\tReact.createElement(App, null)\n\t)\n);\n';
+    entry_content = f'import React from "react";\nimport {{ createRoot }} from "react-dom/client";\nimport {{ app as App }} from "./{app_module_name}.js";\nimport {{ JacClientErrorBoundary, ErrorFallback }} from "@jac/runtime";\n\nconst root = createRoot(document.getElementById("root"));\nroot.render(\n\tReact.createElement(\n\t\tJacClientErrorBoundary,{{ FallbackComponent: ErrorFallback }},\n\t\tReact.createElement(App, null)\n\t)\n);\n';
     entry_file.write_text(entry_content, encoding='utf-8');
 }
 
@@ -59,11 +58,10 @@ impl ViteCompiler.copy_root_assets(self: ViteCompiler) -> None {
     compiled_assets_dir = self.compiled_dir / 'assets';
     if (root_assets_dir.exists() and root_assets_dir.is_dir()) {
         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._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);
+        # Copy configured custom asset types to compiled/assets/
+        self.asset_processor.copy_custom_asset_types(
+            root_assets_dir, compiled_assets_dir
+        );
     }
 }
 
@@ -189,7 +187,21 @@ impl ViteCompiler.compile_dependencies_recursively(
         output_path = self.compiled_dir / name;
     }
     output_path.parent.mkdir(parents=True, exist_ok=True);
-    output_path.write_text(combined_js, encoding='utf-8');
+    # Add source file header comment for better error messages
+    source_header = f"/* Source: {module_path} */\n";
+    # Add ES module exports so Vite can resolve named imports between modules
+    module_export_names = sorted(set(exports_list + list(non_root_globals.keys())));
+    if module_export_names {
+        import re;
+        # Strip any existing export declarations to avoid duplicates
+        clean_combined_js = re.sub(r'\nexport\s*\{[^}]*\}\s*;?\s*', '\n', combined_js);
+        clean_combined_js = re.sub(
+            r'\bexport\s+(let|const|var|function|class)\b', r'\1', clean_combined_js
+        );
+        export_stmt = f"\nexport {{ {', '.join(module_export_names)} }};\n";
+        combined_js = clean_combined_js + export_stmt;
+    }
+    output_path.write_text(source_header + combined_js, encoding='utf-8');
     if (not manifest or not manifest.imports) {
         return;
     }
@@ -228,8 +240,29 @@ impl ViteCompiler.compile_runtime_utils(self: ViteCompiler) -> tuple[str, list[s
     runtimeutils_exports_list = self.jac_compiler.extract_exports(
         runtimeutils_manifest
     );
-    all_exports = sorted(set((runtimeutils_exports_list + self.ROUTER_EXPORTS)));
-    combined_runtime_utils_js = runtimeutils_js;
+    # Include both function exports and glob exports (e.g., useState, useEffect)
+    glob_names = list(runtimeutils_manifest.globals) if runtimeutils_manifest else [];
+    all_exports = sorted(
+        set(runtimeutils_exports_list + self.ROUTER_EXPORTS + glob_names)
+    );
+    # Strip all existing export statements from compiled JS to avoid duplicates.
+    # The codegen produces `export let`, `export function`, `export class`, and
+    # `export { ... }` forms. We remove the export keyword from declarations and
+    # remove export blocks entirely, then add one comprehensive export at the end.
+    import re;
+    clean_js = re.sub(r'\nexport\s*\{[^}]*\}\s*;?\s*', '\n', runtimeutils_js);
+    clean_js = re.sub(r'\bexport\s+(let|const|var|function|class)\b', r'\1', clean_js);
+    # Append single comprehensive ES module export for Vite to resolve @jac/runtime
+    export_names = [
+        e
+        for e in all_exports
+        if not e.startswith('_')
+    ];
+    # Also include internal names that are imported by compiled modules
+    internal_exports = ['__jacJsx', '__jacSpawn', '__jacCallFunction'];
+    all_export_names = sorted(set(export_names + internal_exports));
+    export_stmt = f"\nexport {{ {', '.join(all_export_names)} }};\n";
+    combined_runtime_utils_js = clean_js + export_stmt;
     self.compiled_dir.mkdir(parents=True, exist_ok=True);
     (self.compiled_dir / 'client_runtime.js').write_text(
         combined_runtime_utils_js, encoding='utf-8'
@@ -283,6 +316,5 @@ impl ViteCompiler.init(
     );
     self.import_processor = ImportProcessor();
     self.asset_processor = AssetProcessor();
-    self.babel_processor = BabelProcessor(self.project_dir);
     self.vite_bundler = ViteBundler(self.project_dir, vite_output_dir, vite_minify);
 }

jac_client/plugin/src/impl/jac_to_js.impl.jac

@@ -1,7 +1,11 @@
 """Add runtime imports to compiled JS code."""
 
 impl JacToJSCompiler.add_runtime_imports(self: JacToJSCompiler, js_code: str) -> str {
-    jac_jsx_import = 'import {__jacJsx, __jacSpawn} from "@jac-client/utils";';
+    # Skip adding import if this file IS the runtime (defines __jacJsx itself)
+    if "function __jacJsx(" in js_code {
+        return js_code;
+    }
+    jac_jsx_import = 'import {__jacJsx, __jacSpawn} from "@jac/runtime";';
     return f"{jac_jsx_import}\n{js_code}";
 }
 

jac_client/plugin/src/impl/package_installer.impl.jac

@@ -33,39 +33,39 @@ impl PackageInstaller.uninstall_package(
     }
     # Save the updated config
     self.config_loader.save();
-    # Regenerate package.json and run npm install to actually remove the package
+    # Regenerate package.json and run bun install to actually remove the package
     self._regenerate_and_install();
 }
 
-"""Regenerate package.json from jac.toml and run npm install."""
+"""Regenerate package.json from jac.toml and run bun install."""
 impl PackageInstaller._regenerate_and_install(self: PackageInstaller) -> None {
+    import from jac_client.plugin.utils { ensure_bun_available }
+    # Ensure bun is available before proceeding
+    if not ensure_bun_available() {
+        raise ClientBundleError('Bun is required. Install manually: https://bun.sh') from None ;
+    }
     # Regenerate package.json from updated jac.toml
     bundler = ViteBundler(self.project_dir);
     bundler.create_package_json();
-    # Ensure root package.json exists temporarily for npm commands
+    # Ensure root package.json exists temporarily for bun commands
     bundler._ensure_root_package_json();
     try {
-        # Run npm install to actually install the packages
-        subprocess.run(
-            ['npm', 'install'],
-            cwd=self.project_dir,
-            check=True,
-            capture_output=True,
-            text=True
+        # Run bun install to actually install the packages
+        print("\n  ⏳ Installing packages...\n", flush=True);
+        result = subprocess.run(
+            ['bun', 'install'], cwd=self.project_dir, check=False, text=True
         );
-    } except subprocess.CalledProcessError as e {
-        raise ClientBundleError(f'Failed to install npm packages: {e.stderr}') from e ;
-    } except FileNotFoundError {
-        raise ClientBundleError(
-            'npm command not found. Ensure Node.js and npm are installed.'
-        ) from None ;
+        if result.returncode != 0 {
+            raise ClientBundleError('Failed to install packages (see output above)') ;
+        }
+        print("\n  ✔ Packages installed", flush=True);
     } finally {
-        # Always clean up root package.json and move package-lock.json
+        # Always clean up root package.json and move bun.lockb
         bundler._cleanup_root_package_files();
     }
 }
 
-"""Install all packages from jac.toml (regenerate package.json and run npm install)."""
+"""Install all packages from jac.toml (regenerate package.json and run bun install)."""
 impl PackageInstaller.install_all(self: PackageInstaller) -> None {
     if not self.config_file.exists() {
         raise ClientBundleError(
@@ -93,11 +93,11 @@ impl PackageInstaller.install_package(
     self.config_loader.add_dependency(package_name, package_version, is_dev);
     # Save the updated config
     self.config_loader.save();
-    # Regenerate package.json and install the package via npm
+    # Regenerate package.json and install the package via bun
     self._regenerate_and_install();
 }
 
-"""Handles installing npm packages by updating jac.toml."""
+"""Handles installing packages by updating jac.toml."""
 impl PackageInstaller.init(self: PackageInstaller, project_dir: Path) {
     self.project_dir = project_dir;
     self.config_loader = JacClientConfig(project_dir);