jac-client 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

jac_client/plugin/src/compiler.jac

@@ -0,0 +1,66 @@
+"""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 _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) -> 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,84 @@
+"""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)
+        build_dir = self.project_dir / '.client-build';
+        node_modules = build_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';
+            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
+                subprocess.run(
+                    ['npm', 'install'],
+                    cwd=build_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 .client-build/ for npm run compile
+        build_package_json = build_dir / 'package.json';
+        configs_package_json = build_dir / '.jac-client.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
+        );
+    } finally {
+        # Clean up temporary package.json in .client-build/
+        build_package_json = build_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';
+        if build_package_lock.exists() {
+            configs_package_lock = build_dir / '.jac-client.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,251 @@
+"""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();
+    self.babel_processor.compile();
+    self.babel_processor.copy_assets_after_compile(
+        self.compiled_dir,
+        (self.project_dir / '.client-build' / 'build'),
+        self.asset_processor
+    );
+    entry_file = self.project_dir / '.client-build' / 'build' / 'main.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) -> 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';
+    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.project_dir / '.client-build' / '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);
+        output_path = self.compiled_dir / relative_path.with_suffix('.js');
+    } except ValueError {
+        output_path = self.compiled_dir / f"{module_path.stem}.js";
+    }
+    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;
+    # If package.json is in .client-build/.jac-client.configs/, go up two levels to get project root
+    if (
+        vite_package_json.parent.name == '.jac-client.configs'
+        and vite_package_json.parent.parent.name == '.client-build'
+    ) {
+        self.project_dir = vite_package_json.parent.parent.parent;
+    } elif (vite_package_json.parent.name == '.jac-client.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.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);
+}

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;
+}