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

jac_client/plugin/src/impl/config_loader.impl.jac

@@ -0,0 +1,119 @@
+"""Implementation of Jac Client configuration loader.
+
+This module provides the implementation for JacClientConfig, which inherits
+from PluginConfigBase for common configuration loading functionality.
+
+The base class handles: init, get_jac_config, get_section.
+This file implements plugin-specific methods including a custom load()
+that combines plugin config with npm dependencies.
+"""
+import from pathlib { Path }
+import from typing { Any }
+import from jaclang.project.plugin_config { deep_merge }
+
+"""Get the plugin section name for client."""
+impl JacClientConfig.get_plugin_name(self: JacClientConfig) -> str {
+    return "client";
+}
+
+"""Get default configuration structure for client."""
+impl JacClientConfig.get_default_config(self: JacClientConfig) -> dict[str, Any] {
+    return {
+        'vite': {
+            'plugins': [],
+            'lib_imports': [],
+            'build': {},
+            'server': {},
+            'resolve': {}
+        },
+        'ts': {'compilerOptions': {}, 'include': [], 'exclude': []},
+        'package': {
+            'name': '',
+            'version': '1.0.0',
+            'description': '',
+            'dependencies': {},
+            'devDependencies': {}
+        }
+    };
+}
+
+"""Load configuration from jac.toml, merging with defaults.
+
+Overrides base class to also include npm dependencies from [dependencies.npm].
+"""
+impl JacClientConfig.load(self: JacClientConfig) -> dict[str, Any] {
+    if self._config is not None {
+        return self._config;
+    }
+    default_config = self.get_default_config();
+    jac_config = self.get_jac_config();
+    # Get client plugin config from [plugins.client]
+    client_config = jac_config.get_plugin_config('client');
+    # Get npm dependencies from [dependencies.npm]
+    npm_deps = jac_config.get_plugin_deps('npm');
+    # Get npm dev dependencies from [dev-dependencies.npm]
+    # These are stored in plugin_dependencies["npm"]["dev"] after parsing
+    npm_plugin_deps = jac_config.plugin_dependencies.get('npm', {});
+    npm_dev_deps = npm_plugin_deps.get('dev', {})
+    if isinstance(npm_plugin_deps.get('dev'), dict)
+    else {};
+    # Build user config in the expected internal format
+    user_config: dict[str, Any] = {
+        'vite': client_config.get('vite', {}),
+        'ts': client_config.get('ts', {}),
+        'package': {
+            'name': jac_config.project.name,
+            'version': jac_config.project.version,
+            'description': jac_config.project.description,
+            'dependencies': npm_deps,
+            'devDependencies': npm_dev_deps
+        }
+    };
+    self._config = deep_merge(default_config, user_config);
+    return self._config;
+}
+
+"""Get package configuration (npm dependencies)."""
+impl JacClientConfig.get_package_config(self: JacClientConfig) -> dict[str, Any] {
+    config = self.load();
+    return config.get('package', {});
+}
+
+"""Get Vite-specific configuration."""
+impl JacClientConfig.get_vite_config(self: JacClientConfig) -> dict[str, Any] {
+    config = self.load();
+    return config.get('vite', {});
+}
+
+"""Get TypeScript-specific configuration for tsconfig.json customization."""
+impl JacClientConfig.get_ts_config(self: JacClientConfig) -> dict[str, Any] {
+    config = self.load();
+    return config.get('ts', {});
+}
+
+"""Save configuration back to jac.toml using core JacConfig."""
+impl JacClientConfig.save(self: JacClientConfig) -> None {
+    jac_config = self.get_jac_config();
+    jac_config.save();
+}
+
+"""Add an npm dependency."""
+impl JacClientConfig.add_dependency(
+    self: JacClientConfig, name: str, version: str, is_dev: bool = False
+) -> None {
+    jac_config = self.get_jac_config();
+    jac_config.add_dependency(name, version, dev=is_dev, dep_type="npm");
+    # Invalidate cache
+    self.invalidate();
+}
+
+"""Remove an npm dependency."""
+impl JacClientConfig.remove_dependency(
+    self: JacClientConfig, name: str, is_dev: bool = False
+) -> bool {
+    jac_config = self.get_jac_config();
+    result = jac_config.remove_dependency(name, dev=is_dev, dep_type="npm");
+    # Invalidate cache
+    self.invalidate();
+    return result;
+}

jac_client/plugin/src/impl/import_processor.impl.jac

@@ -0,0 +1,33 @@
+"""Check if an import should be processed (compiled/copied) vs left for Vite."""
+
+impl ImportProcessor.should_process_import(
+    self: ImportProcessor, import_path: Path
+) -> bool {
+    return (import_path.suffix in {'.jac','.js'});
+}
+
+"""Process client imports for Vite bundling."""
+impl ImportProcessor.process_vite_imports(
+    self: ImportProcessor, manifest: (ClientManifest | None), module_path: Path
+) -> list[(Path | None)] {
+    imported_js_modules: list[(Path | None)] = [];
+    if (manifest and manifest.imports) {
+        for (_, import_path) in manifest.imports.items() {
+            import_path_obj = Path(import_path);
+            if (import_path_obj.suffix == '.js') {
+                try {
+                    imported_js_modules.append(import_path_obj);
+                } except FileNotFoundError {
+                    imported_js_modules.append(None);
+                }
+            } elif (import_path_obj.suffix == '.jac') {
+                try {
+                    imported_js_modules.append(import_path_obj);
+                } except ClientBundleError {
+                    imported_js_modules.append(None);
+                }
+            }
+        }
+    }
+    return imported_js_modules;
+}

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

@@ -0,0 +1,41 @@
+"""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";';
+    return f"{jac_jsx_import}\n{js_code}";
+}
+
+"""Extract client globals from manifest and module."""
+impl JacToJSCompiler.extract_globals(
+    self: JacToJSCompiler, manifest: (ClientManifest | None), module: ModuleType
+) -> dict[str, Any] {
+    return self._extract_client_globals(manifest, module);
+}
+
+"""Extract client exports from manifest."""
+impl JacToJSCompiler.extract_exports(
+    self: JacToJSCompiler, manifest: (ClientManifest | None)
+) -> list[str] {
+    return self._extract_client_exports(manifest);
+}
+
+"""Compile a Jac module to JavaScript."""
+impl JacToJSCompiler.compile_module(
+    self: JacToJSCompiler, module_path: Path
+) -> tuple[str, (ModuleType | None), (ClientManifest | None)] {
+    (module_js, mod) = self._compile_to_js(module_path);
+    manifest = mod.gen.client_manifest if mod else None;
+    return (module_js, mod, manifest);
+}
+
+"""Initialize the Jac to JS compiler."""
+impl JacToJSCompiler.init(
+    self: JacToJSCompiler,
+    compile_to_js_func: Callable[([Path], tuple[(str, (ModuleType | None))])],
+    extract_exports_func: Callable[([Any], list[str])],
+    extract_globals_func: Callable[([Any, ModuleType], dict[(str, Any)])]
+) {
+    self._compile_to_js = compile_to_js_func;
+    self._extract_client_exports = extract_exports_func;
+    self._extract_client_globals = extract_globals_func;
+}

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

@@ -0,0 +1,105 @@
+"""List all installed packages from jac.toml."""
+
+impl PackageInstaller.list_packages(
+    self: PackageInstaller
+) -> dict[str, dict[str, str]] {
+    if not self.config_file.exists() {
+        raise ClientBundleError(
+            f'jac.toml not found at {self.config_file}. Run "jac init" first.'
+        ) ;
+    }
+    config = self.config_loader.load();
+    package_config = config.get('package', {});
+    return {
+        'dependencies': package_config.get('dependencies', {}),
+        'devDependencies': package_config.get('devDependencies', {})
+    };
+}
+
+"""Uninstall a package by removing it from jac.toml."""
+impl PackageInstaller.uninstall_package(
+    self: PackageInstaller, package_name: str, is_dev: bool = False
+) -> None {
+    if not self.config_file.exists() {
+        raise ClientBundleError(
+            f'jac.toml not found at {self.config_file}. Run "jac init" first.'
+        ) ;
+    }
+    # Remove the dependency using JacClientConfig
+    result = self.config_loader.remove_dependency(package_name, is_dev);
+    if not result {
+        deps_key = 'dev-dependencies' if is_dev else 'dependencies';
+        raise ClientBundleError(f'Package "{package_name}" not found in {deps_key}') ;
+    }
+    # Save the updated config
+    self.config_loader.save();
+    # Regenerate package.json and run npm install to actually remove the package
+    self._regenerate_and_install();
+}
+
+"""Regenerate package.json from jac.toml and run npm install."""
+impl PackageInstaller._regenerate_and_install(self: PackageInstaller) -> 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
+    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
+        );
+    } 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 ;
+    } finally {
+        # Always clean up root package.json and move package-lock.json
+        bundler._cleanup_root_package_files();
+    }
+}
+
+"""Install all packages from jac.toml (regenerate package.json and run npm install)."""
+impl PackageInstaller.install_all(self: PackageInstaller) -> None {
+    if not self.config_file.exists() {
+        raise ClientBundleError(
+            f'jac.toml not found at {self.config_file}. Run "jac init" first.'
+        ) ;
+    }
+    self._regenerate_and_install();
+}
+
+"""Install a package by adding it to jac.toml."""
+impl PackageInstaller.install_package(
+    self: PackageInstaller,
+    package_name: str,
+    version: (str | None) = None,
+    is_dev: bool = False
+) -> None {
+    if not self.config_file.exists() {
+        raise ClientBundleError(
+            f'jac.toml not found at {self.config_file}. Run "jac init" first.'
+        ) ;
+    }
+    # Add package with version (default to latest if not specified)
+    package_version = version or 'latest';
+    # Use JacClientConfig to add the dependency
+    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
+    self._regenerate_and_install();
+}
+
+"""Handles installing npm packages by updating jac.toml."""
+impl PackageInstaller.init(self: PackageInstaller, project_dir: Path) {
+    self.project_dir = project_dir;
+    self.config_loader = JacClientConfig(project_dir);
+    self.config_file = project_dir / 'jac.toml';
+}