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

jac_client/plugin/src/asset_processor.jac

@@ -0,0 +1,33 @@
+"""Asset file processing and copying utilities."""
+import contextlib;
+import shutil;
+import from pathlib { Path }
+import from jaclang.project.config { get_config }
+
+"""Handles copying of asset files (CSS, images, fonts, etc.) between directories."""
+class AssetProcessor {
+    with entry {
+        ASSET_EXTENSIONS = {'.css','.scss','.sass','.less','.svg','.png','.jpg','.jpeg','.gif','.webp','.ico','.woff','.woff2','.ttf','.eot','.otf','.mp4','.webm','.mp3','.wav'};
+    }
+
+    def copy_assets(
+        self: AssetProcessor,
+        src_dir: Path,
+        dest_dir: Path,
+        preserve_structure: bool = True
+    ) -> None;
+
+    def copy_typescript_files(
+        self: AssetProcessor,
+        src_dir: Path,
+        dest_dir: Path,
+        preserve_structure: bool = True
+    ) -> None;
+
+    def copy_custom_asset_types(
+        self: AssetProcessor,
+        src_dir: Path,
+        dest_dir: Path,
+        preserve_structure: bool = True
+    ) -> None;
+}

jac_client/plugin/src/babel_processor.jac

@@ -0,0 +1,18 @@
+"""Babel processing for JavaScript transpilation."""
+import subprocess;
+import from pathlib { Path }
+import from jaclang.runtimelib.client_bundle { ClientBundleError }
+import from .asset_processor { AssetProcessor }
+import from .vite_bundler { ViteBundler }
+
+"""Handles Babel compilation of JavaScript files."""
+class BabelProcessor {
+    def init(self: BabelProcessor, project_dir: Path);
+    def compile(self: BabelProcessor) -> None;
+    def copy_assets_after_compile(
+        self: BabelProcessor,
+        compiled_dir: Path,
+        build_dir: Path,
+        asset_processor: AssetProcessor
+    ) -> None;
+}

jac_client/plugin/src/compiler.jac

@@ -0,0 +1,67 @@
+"""Main compilation orchestration module."""
+import contextlib;
+import from collections.abc { Callable }
+import from pathlib { Path }
+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 }
+
+with entry {
+    if TYPE_CHECKING { }
+}
+
+"""Orchestrates the compilation process for Vite client bundles."""
+class ViteCompiler {
+    with entry {
+        ROUTER_EXPORTS = [
+            'Router',
+            'Routes',
+            'Route',
+            'Link',
+            'Navigate',
+            'useNavigate',
+            'useLocation',
+            'useParams'
+        ];
+    }
+
+    def init(
+        self: ViteCompiler,
+        vite_package_json: Path,
+        vite_output_dir: (Path | None) = None,
+        vite_minify: bool = False,
+        runtime_path: (Path | None) = None,
+        compile_to_js_func:
+            (Callable[([Path], tuple[(str, (ModuleType | None))])] | None) = None,
+        extract_exports_func: (Callable[([Any], list[str])] | None) = None,
+        extract_globals_func: (Callable[([Any, ModuleType], dict[(str, Any)])] | None) = None
+    );
+
+    def compile_runtime_utils(self: ViteCompiler) -> tuple[str, list[str]];
+    def compile_dependencies_recursively(
+        self: ViteCompiler,
+        module_path: Path,
+        visited: (set[Path] | None) = None,
+        collected_exports: (set[str] | None) = None,
+        collected_globals: (dict[(str, Any)] | None) = None,
+        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(
+        self: ViteCompiler, asset_path: Path, source_root: Path
+    ) -> None;
+
+    def copy_root_assets(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/config_loader.jac

@@ -0,0 +1,32 @@
+"""Configuration loader for Jac Client build system.
+
+This module provides configuration access for the client plugin.
+Configuration is loaded from jac.toml under [plugins.client] section.
+
+Inherits from PluginConfigBase to eliminate boilerplate code.
+"""
+import from pathlib { Path }
+import from typing { Any }
+import from jaclang.project.plugin_config { PluginConfigBase }
+
+"""Client-specific configuration loader.
+
+Provides access to vite, ts, and package configuration
+from the [plugins.client] section of jac.toml.
+"""
+class JacClientConfig(PluginConfigBase) {
+    override def get_plugin_name(self: JacClientConfig) -> str;
+    override def get_default_config(self: JacClientConfig) -> dict[str, Any];
+    override def load(self: JacClientConfig) -> dict[str, Any];
+    def save(self: JacClientConfig) -> None;
+    def get_vite_config(self: JacClientConfig) -> dict[str, Any];
+    def get_ts_config(self: JacClientConfig) -> dict[str, Any];
+    def get_package_config(self: JacClientConfig) -> dict[str, Any];
+    def add_dependency(
+        self: JacClientConfig, name: str, version: str, is_dev: bool = False
+    ) -> None;
+
+    def remove_dependency(
+        self: JacClientConfig, name: str, is_dev: bool = False
+    ) -> bool;
+}

jac_client/plugin/src/impl/asset_processor.impl.jac

@@ -0,0 +1,127 @@
+"""Copy custom asset files (based on jac.toml configuration) from source to destination recursively."""
+
+impl AssetProcessor.copy_custom_asset_types(
+    self: AssetProcessor,
+    src_dir: Path,
+    dest_dir: Path,
+    preserve_structure: bool = True
+) -> None {
+    if not src_dir.exists() {
+        return;
+    }
+    dest_dir.mkdir(parents=True, exist_ok=True);
+    def copy_recursive(
+        source: Path, destination: Path, base: (Path | None) = None
+    ) -> None {
+        if not source.exists() {
+            return;
+        }
+        if (base is None) {
+            base = source;
+        }
+        for item in source.iterdir() {
+            if (item.is_file() and (item.suffix.lower() in custom_asset_extensions)) {
+                if preserve_structure {
+                    relative_path = item.relative_to(base);
+                    dest_file = destination / relative_path;
+                } else {
+                    dest_file = destination / item.name;
+                }
+                dest_file.parent.mkdir(parents=True, exist_ok=True);
+                with contextlib.suppress(OSError, shutil.Error) {
+                    shutil.copy2(item, dest_file);
+                }
+            } elif item.is_dir() {
+                copy_recursive(item, destination, base);
+            }
+        }
+    }
+    config = get_config();
+    assets_config = config.get_plugin_config("client").get("assets", {});
+    custom_asset_extensions = set(assets_config.get("custom_extensions", []));
+    if custom_asset_extensions {
+        copy_recursive(src_dir, dest_dir);
+    }
+    return;
+}
+
+"""Copy TypeScript files (.ts, .tsx) from source to destination recursively."""
+impl AssetProcessor.copy_typescript_files(
+    self: AssetProcessor,
+    src_dir: Path,
+    dest_dir: Path,
+    preserve_structure: bool = True
+) -> None {
+    if not src_dir.exists() {
+        return;
+    }
+    dest_dir.mkdir(parents=True, exist_ok=True);
+    ts_extensions = {'.ts','.tsx'};
+    def copy_recursive(
+        source: Path, destination: Path, base: (Path | None) = None
+    ) -> None {
+        if not source.exists() {
+            return;
+        }
+        if (base is None) {
+            base = source;
+        }
+        for item in source.iterdir() {
+            if (item.is_file() and (item.suffix.lower() in ts_extensions)) {
+                if preserve_structure {
+                    relative_path = item.relative_to(base);
+                    dest_file = destination / relative_path;
+                } else {
+                    dest_file = destination / item.name;
+                }
+                dest_file.parent.mkdir(parents=True, exist_ok=True);
+                with contextlib.suppress(OSError, shutil.Error) {
+                    shutil.copy2(item, dest_file);
+                }
+            } elif item.is_dir() {
+                copy_recursive(item, destination, base);
+            }
+        }
+    }
+    copy_recursive(src_dir, dest_dir);
+}
+
+"""Copy CSS and other asset files from source to destination recursively."""
+impl AssetProcessor.copy_assets(
+    self: AssetProcessor,
+    src_dir: Path,
+    dest_dir: Path,
+    preserve_structure: bool = True
+) -> None {
+    if not src_dir.exists() {
+        return;
+    }
+    dest_dir.mkdir(parents=True, exist_ok=True);
+    def copy_recursive(
+        source: Path, destination: Path, base: (Path | None) = None
+    ) -> None {
+        if not source.exists() {
+            return;
+        }
+        if (base is None) {
+            base = source;
+        }
+        for item in source.iterdir() {
+            if (item.is_file() and (item.suffix.lower() in self.ASSET_EXTENSIONS)) {
+                if preserve_structure {
+                    relative_path = item.relative_to(base);
+                    dest_file = destination / relative_path;
+                } else {
+                    dest_file = destination / item.name;
+                }
+                dest_file.parent.mkdir(parents=True, exist_ok=True);
+                with contextlib.suppress(OSError, shutil.Error) {
+                    shutil.copy2(item, dest_file);
+                }
+            } elif item.is_dir() {
+                copy_recursive(item, destination, base);
+            }
+        }
+    }
+    copy_recursive(src_dir, dest_dir);
+}

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

@@ -0,0 +1,89 @@
+"""Copy CSS, assets, and TypeScript files from compiled/ to build/ after Babel compilation."""
+
+impl BabelProcessor.copy_assets_after_compile(
+    self: BabelProcessor,
+    compiled_dir: Path,
+    build_dir: Path,
+    asset_processor: AssetProcessor
+) -> None {
+    asset_processor.copy_assets(compiled_dir, build_dir);
+    asset_processor.copy_typescript_files(compiled_dir, build_dir);
+}
+
+"""Run Babel compilation (npm run compile)."""
+impl BabelProcessor.compile(self: BabelProcessor) -> None {
+    bundler = ViteBundler(self.project_dir);
+    # Ensure root package.json exists temporarily for npm commands
+    bundler._ensure_root_package_json();
+    try {
+        # Ensure dependencies are installed (check if node_modules exists)
+        client_dir = bundler._get_client_dir();
+        node_modules = client_dir / 'node_modules';
+        if not node_modules.exists() {
+            # 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 .jac/client/node_modules
+                subprocess.run(
+                    ['npm', 'install'],
+                    cwd=client_dir,
+                    check=True,
+                    capture_output=True,
+                    text=True
+                );
+            } except subprocess.CalledProcessError as e {
+                raise ClientBundleError(
+                    f'Failed to install npm dependencies: {e.stderr}'
+                ) from e ;
+            } except FileNotFoundError {
+                raise ClientBundleError(
+                    'npm command not found. Ensure Node.js and npm are installed.'
+                ) from None ;
+            }
+        }
+
+        # 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'];
+        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 .jac/client/
+        build_package_json = client_dir / '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);
+        }
+        # Always clean up root package.json and move package-lock.json
+        bundler._cleanup_root_package_files();
+    }
+}
+
+"""Initialize the Babel processor."""
+impl BabelProcessor.init(self: BabelProcessor, project_dir: Path) {
+    self.project_dir = project_dir;
+}

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

@@ -0,0 +1,288 @@
+"""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]] {
+    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)
+    );
+    client_globals_map = self.jac_compiler.extract_globals(module_manifest, module);
+    collected_globals: dict[(str, Any)] = dict(client_globals_map);
+    self.compile_dependencies_recursively(
+        module_path,
+        collected_exports=collected_exports,
+        collected_globals=collected_globals
+    );
+    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';
+    self.vite_bundler.build(entry_file=entry_file);
+    (bundle_code, bundle_hash) = self.vite_bundler.read_bundle();
+    client_exports = sorted(collected_exports);
+    client_globals = list(collected_globals.keys());
+    return (bundle_code, bundle_hash, client_exports, client_globals);
+}
+
+"""Create the main entry file for Vite bundling."""
+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');
+}
+
+"""Copy assets from root assets/ folder to compiled/assets/ for @jac-client/assets alias."""
+impl ViteCompiler.copy_root_assets(self: ViteCompiler) -> None {
+    root_assets_dir = self.project_dir / 'assets';
+    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 an asset file to the compiled directory."""
+impl ViteCompiler._copy_asset_file(
+    self: ViteCompiler, asset_path: Path, source_root: Path
+) -> None {
+    if not asset_path.exists() {
+        return;
+    }
+    try {
+        relative_path = asset_path.relative_to(source_root);
+        output_path = self.compiled_dir / relative_path;
+    } except ValueError {
+        output_path = self.compiled_dir / asset_path.name;
+    }
+    output_path.parent.mkdir(parents=True, exist_ok=True);
+    with contextlib.suppress(FileNotFoundError, OSError) {
+        output_path.write_text(
+            asset_path.read_text(encoding='utf-8'), encoding='utf-8'
+        );
+    }
+}
+
+"""Copy a TypeScript file to the compiled directory."""
+impl ViteCompiler._copy_ts_file(
+    self: ViteCompiler, ts_path: Path, source_root: Path
+) -> None {
+    if not ts_path.exists() {
+        return;
+    }
+    try {
+        ts_code = ts_path.read_text(encoding='utf-8');
+        try {
+            relative_path = ts_path.relative_to(source_root);
+            output_path = self.compiled_dir / relative_path;
+        } except ValueError {
+            output_path = self.compiled_dir / ts_path.name;
+        }
+        output_path.parent.mkdir(parents=True, exist_ok=True);
+        output_path.write_text(ts_code, encoding='utf-8');
+    } except (FileNotFoundError, OSError) { }
+}
+
+"""Copy a JavaScript file to the compiled directory."""
+impl ViteCompiler._copy_js_file(
+    self: ViteCompiler, js_path: Path, source_root: Path
+) -> None {
+    try {
+        js_code = js_path.read_text(encoding='utf-8');
+        try {
+            relative_path = js_path.relative_to(source_root);
+            output_path = self.compiled_dir / relative_path;
+        } except ValueError {
+            output_path = self.compiled_dir / js_path.name;
+        }
+        output_path.parent.mkdir(parents=True, exist_ok=True);
+        output_path.write_text(js_code, encoding='utf-8');
+    } except FileNotFoundError { }
+}
+
+"""Recursively compile/copy .jac/.js imports to temp, skipping bundling."""
+impl ViteCompiler.compile_dependencies_recursively(
+    self: ViteCompiler,
+    module_path: Path,
+    visited: (set[Path] | None) = None,
+    collected_exports: (set[str] | None) = None,
+    collected_globals: (dict[(str, Any)] | None) = None,
+    source_root: (Path | None) = None
+) -> None {
+    if (visited is None) {
+        visited = set();
+    }
+    if (collected_exports is None) {
+        collected_exports = set();
+    }
+    if (collected_globals is None) {
+        collected_globals = {};
+    }
+    module_path = module_path.resolve();
+    if (module_path in visited) {
+        return;
+    }
+    visited.add(module_path);
+    if (source_root is None) {
+        source_root = module_path.parent.resolve();
+    }
+    (module_js, mod, manifest) = self.jac_compiler.compile_module(module_path);
+    exports_list = self.jac_compiler.extract_exports(manifest);
+    collected_exports.update(exports_list);
+    non_root_globals: dict[(str, Any)] = {};
+    if manifest {
+        for name in manifest.globals {
+            non_root_globals[name] = manifest.globals_values.get(name);
+        }
+    }
+    collected_globals.update(non_root_globals);
+    combined_js = self.jac_compiler.add_runtime_imports(module_js);
+    try {
+        relative_path = module_path.relative_to(source_root);
+        # 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 {
+        # 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');
+    if (not manifest or not manifest.imports) {
+        return;
+    }
+    for (_name, import_path) in manifest.imports.items() {
+        path_obj = Path(import_path).resolve();
+        if (path_obj in visited) {
+            continue;
+        }
+        if (path_obj.suffix == '.jac') {
+            self.compile_dependencies_recursively(
+                path_obj,
+                visited,
+                collected_exports=collected_exports,
+                collected_globals=collected_globals,
+                source_root=source_root
+            );
+        } elif (path_obj.suffix == '.js') {
+            self._copy_js_file(path_obj, source_root);
+        } elif (path_obj.suffix in {'.ts','.tsx'}) {
+            self._copy_ts_file(path_obj, source_root);
+        } elif path_obj.is_file() {
+            self._copy_asset_file(path_obj, source_root);
+        }
+    }
+}
+
+"""Compile client runtime utilities."""
+impl ViteCompiler.compile_runtime_utils(self: ViteCompiler) -> tuple[str, list[str]] {
+    if not self.runtime_path {
+        raise ClientBundleError('Runtime path not set') ;
+    }
+    runtime_utils_path = self.runtime_path.parent / 'client_runtime.cl.jac';
+    (runtimeutils_js, mod, runtimeutils_manifest) = self.jac_compiler.compile_module(
+        runtime_utils_path
+    );
+    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;
+    self.compiled_dir.mkdir(parents=True, exist_ok=True);
+    (self.compiled_dir / 'client_runtime.js').write_text(
+        combined_runtime_utils_js, encoding='utf-8'
+    );
+    return (combined_runtime_utils_js, all_exports);
+}
+
+"""Initialize the Vite compiler."""
+impl ViteCompiler.init(
+    self: ViteCompiler,
+    vite_package_json: Path,
+    vite_output_dir: (Path | None) = None,
+    vite_minify: bool = False,
+    runtime_path: (Path | None) = None,
+    compile_to_js_func: (Callable[([Path], tuple[(str, (ModuleType | None))])] | None) = None,
+    extract_exports_func: (Callable[([Any], list[str])] | None) = None,
+    extract_globals_func: (Callable[([Any, ModuleType], dict[(str, Any)])] | None) = None
+) {
+    if (not vite_package_json or not vite_package_json.exists()) {
+        raise ClientBundleError(
+            'Vite package.json not found. Set vite_package_json when using ViteCompiler'
+        ) ;
+    }
+    if (
+        (compile_to_js_func is None)
+        or (extract_exports_func is None)
+        or (extract_globals_func is None)
+    ) {
+        raise ClientBundleError(
+            'compile_to_js_func, extract_exports_func, and extract_globals_func are required'
+        ) ;
+    }
+    self.vite_package_json = vite_package_json;
+    # Detect project root: package.json may be in .jac/client/configs/ or project root
+    if (
+        vite_package_json.parent.name == 'configs'
+        and vite_package_json.parent.parent.name == 'client'
+        and vite_package_json.parent.parent.parent.name == '.jac'
+    ) {
+        # .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._get_client_dir() / 'compiled';
+    self.jac_compiler = JacToJSCompiler(
+        compile_to_js_func, extract_exports_func, extract_globals_func
+    );
+    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);
+}