jac-desktop 0.2.0__tar.gz

jac_desktop-0.2.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: jac-desktop
+Version: 0.2.0
+Summary: Jac-native desktop target: one nacompile'd binary + the OS webview.
+Author-email: Jason Mars <jason@mars.ninja>
+Maintainer-email: Jason Mars <jason@mars.ninja>
+License-Expression: MIT
+Keywords: jac,jaclang,jaseci,desktop,webview,native
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/jaseci-labs/jaseci
+Project-URL: Homepage, https://jaseci.org
+Project-URL: Documentation, https://jac-lang.org
+Project-URL: Source, https://github.com/jaseci-labs/jaseci/tree/main/jac-desktop
+Project-URL: Issues, https://github.com/jaseci-labs/jaseci/issues
+Project-URL: Changelog, https://github.com/jaseci-labs/jaseci/blob/main/docs/docs/community/release_notes/jac-desktop.md
+Requires-Dist: jaclang>=0.16.1
+Requires-Dist: jac-client>=0.3.22
+Provides-Extra: dev
+Requires-Dist: pytest==8.3.5; extra == "dev"
+Description-Content-Type: text/markdown
+
+# jac-desktop
+
+Jac-native desktop target for [Jac](https://jac-lang.org): a desktop app is **one
+`jac nacompile`d binary + the OS's own web engine** - no Rust toolchain, no
+PyInstaller, no separate process.
+
+## What you get
+
+- A `desktop` build target registered with `jac-client`'s target registry, so
+  `jac build --client desktop` and `jac start --client desktop` work once this
+  package is installed.
+- The build pipeline:
+  1. builds your `cl` codespace with the standard Vite pipeline (via `WebTarget`),
+  2. compiles a native host (`na`) that embeds CPython to serve that bundle on a
+     loopback port and renders it in the OS-native webview (WebKitGTK on Linux /
+     WKWebView on macOS / WebView2 on Windows),
+  3. produces a single self-contained binary under `.jac/client/desktop/`.
+
+The native webview binding + build tooling live under
+[`jac_desktop/native/webview/`](jac_desktop/native/webview/) (see its README for
+the phase-by-phase design and the dependency-free test suite).
+
+## Install
+
+```sh
+pip install jac-client jac-desktop
+```
+
+Building a desktop app needs the OS web engine + a C toolchain so the native host
+can link `libwebview.so` (built on first use). On Debian/Ubuntu:
+
+```sh
+sudo ./jac_desktop/native/webview/install_webkit_deps.sh
+# (build-essential, pkg-config, libgtk-3-dev, libwebkit2gtk-4.1-dev)
+```
+
+## Project flow
+
+```sh
+jac create --use fullstack my-app      # or any project with a cl codespace
+cd my-app
+jac build --client desktop             # -> .jac/client/desktop/<app>  (single binary)
+jac start --client desktop             # build + launch the native window
+```
+
+Window geometry + app identity come from `[plugins.desktop]` in `jac.toml`:
+
+```toml
+[plugins.desktop]
+name = "my-app"
+
+[plugins.desktop.window]
+title = "My App"
+width = 1000
+height = 700
+```
+
+## Status
+
+`jac build --client desktop` produces a working, self-contained native desktop
+binary that renders your `cl` UI. The host embeds CPython (it serves the bundle
+and is where `sv` runs in-process). Remaining: wiring the `sv` codespace/walkers
+onto the embedded interpreter, HMR dev mode, and per-OS packaging/signing - see
+[issue #6436](https://github.com/jaseci-labs/jaseci/issues/6436).

jac_desktop-0.2.0/README.md

@@ -0,0 +1,64 @@
+# jac-desktop
+
+Jac-native desktop target for [Jac](https://jac-lang.org): a desktop app is **one
+`jac nacompile`d binary + the OS's own web engine** - no Rust toolchain, no
+PyInstaller, no separate process.
+
+## What you get
+
+- A `desktop` build target registered with `jac-client`'s target registry, so
+  `jac build --client desktop` and `jac start --client desktop` work once this
+  package is installed.
+- The build pipeline:
+  1. builds your `cl` codespace with the standard Vite pipeline (via `WebTarget`),
+  2. compiles a native host (`na`) that embeds CPython to serve that bundle on a
+     loopback port and renders it in the OS-native webview (WebKitGTK on Linux /
+     WKWebView on macOS / WebView2 on Windows),
+  3. produces a single self-contained binary under `.jac/client/desktop/`.
+
+The native webview binding + build tooling live under
+[`jac_desktop/native/webview/`](jac_desktop/native/webview/) (see its README for
+the phase-by-phase design and the dependency-free test suite).
+
+## Install
+
+```sh
+pip install jac-client jac-desktop
+```
+
+Building a desktop app needs the OS web engine + a C toolchain so the native host
+can link `libwebview.so` (built on first use). On Debian/Ubuntu:
+
+```sh
+sudo ./jac_desktop/native/webview/install_webkit_deps.sh
+# (build-essential, pkg-config, libgtk-3-dev, libwebkit2gtk-4.1-dev)
+```
+
+## Project flow
+
+```sh
+jac create --use fullstack my-app      # or any project with a cl codespace
+cd my-app
+jac build --client desktop             # -> .jac/client/desktop/<app>  (single binary)
+jac start --client desktop             # build + launch the native window
+```
+
+Window geometry + app identity come from `[plugins.desktop]` in `jac.toml`:
+
+```toml
+[plugins.desktop]
+name = "my-app"
+
+[plugins.desktop.window]
+title = "My App"
+width = 1000
+height = 700
+```
+
+## Status
+
+`jac build --client desktop` produces a working, self-contained native desktop
+binary that renders your `cl` UI. The host embeds CPython (it serves the bundle
+and is where `sv` runs in-process). Remaining: wiring the `sv` codespace/walkers
+onto the embedded interpreter, HMR dev mode, and per-OS packaging/signing - see
+[issue #6436](https://github.com/jaseci-labs/jaseci/issues/6436).

jac_desktop-0.2.0/_jac_build.py

@@ -0,0 +1,19 @@
+"""Bundled PEP 517 build backend — generated by jac bundle, do not edit."""
+
+
+def get_requires_for_build_wheel(config_settings=None):
+    return []
+
+
+def build_wheel(wheel_directory, config_settings=None, metadata_directory=None):
+    from pathlib import Path
+    from jaclang.project.config import get_config
+    from jaclang.publish.builder import WheelBuilder
+
+    proj_root = Path.cwd()
+    config = get_config(start_path=proj_root, force_discover=True)
+    if config is None:
+        raise RuntimeError(f"No jac.toml found in {proj_root}.")
+    return WheelBuilder(config=config, project_root=proj_root).build_to(
+        Path(wheel_directory)
+    ).name

jac_desktop-0.2.0/jac.toml

@@ -0,0 +1,46 @@
+[project]
+name = "jac-desktop"
+version = "0.2.0"
+description = "Jac-native desktop target: one nacompile'd binary + the OS webview."
+authors = [{ name = "Jason Mars", email = "jason@mars.ninja" }]
+maintainers = [{ name = "Jason Mars", email = "jason@mars.ninja" }]
+license = "MIT"
+readme = "README.md"
+keywords = ["jac", "jaclang", "jaseci", "desktop", "webview", "native"]
+requires-python = ">=3.12"
+entry-point = "jac_desktop/plugin.jac"
+
+[project.urls]
+repository = "https://github.com/jaseci-labs/jaseci"
+homepage = "https://jaseci.org"
+documentation = "https://jac-lang.org"
+source = "https://github.com/jaseci-labs/jaseci/tree/main/jac-desktop"
+issues = "https://github.com/jaseci-labs/jaseci/issues"
+changelog = "https://github.com/jaseci-labs/jaseci/blob/main/docs/docs/community/release_notes/jac-desktop.md"
+
+[project.include]
+packages = ["jac_desktop*"]
+
+[project.include.data]
+# Ship the Jac-native webview binding + build tooling so the desktop target can
+# compile a host on the user's machine (libwebview.so is built on first use).
+# Explicit globs so tests/ and build caches don't end up in the wheel.
+jac_desktop = [
+    "native/webview/webview.na.jac",
+    "native/webview/build_libwebview.sh",
+    "native/webview/install_webkit_deps.sh",
+    "native/webview/README.md",
+]
+
+[dependencies]
+jaclang = ">=0.16.1"
+jac-client = ">=0.3.22"
+
+[optional-dependencies.dev]
+pytest = "==8.3.5"
+
+[entrypoints.jac]
+desktop_plugin_config = "jac_desktop.plugin_config:JacDesktopPluginConfig"
+
+[entrypoints.jac_client]
+desktop = "jac_desktop.plugin:JacDesktopPlugin"

jac_desktop-0.2.0/jac_desktop/config_loader.jac

@@ -0,0 +1,81 @@
+"""Configuration loader for jac-desktop.
+
+Loads from jac.toml under [plugins.desktop], inheriting PluginConfigBase like
+jac-scale and jac-client. Provides the app identity + window geometry the native
+desktop target bakes into the generated host.
+"""
+import from pathlib { Path }
+import from jaclang.project.plugin_config { PluginConfigBase }
+
+"""Desktop app identity (name, identifier, version)."""
+obj DesktopIdentity {
+    has name: str,
+        identifier: str,
+        version: str;
+}
+
+"""Main window geometry from [plugins.desktop.window]."""
+obj WindowConfig {
+    has title: str,
+        width: int = 1200,
+        height: int = 800,
+        min_width: int = 800,
+        min_height: int = 600,
+        resizable: bool = True;
+
+    static def from_dict(
+        data: dict[str, any], title_fallback: str = ""
+    ) -> WindowConfig {
+        title = str(data.get("title", title_fallback) or title_fallback);
+        return WindowConfig(
+            title=title,
+            width=int(data.get("width", 1200)),
+            height=int(data.get("height", 800)),
+            min_width=int(data.get("min_width", 800)),
+            min_height=int(data.get("min_height", 600)),
+            resizable=bool(data.get("resizable", True))
+        );
+    }
+}
+
+"""Default [plugins.desktop] values before merging user jac.toml."""
+obj DesktopDefaultConfig {
+    has name: str,
+        identifier: str,
+        version: str,
+        window: WindowConfig;
+
+    def to_dict -> dict[str, any] {
+        return {
+            'name': self.name,
+            'identifier': self.identifier,
+            'version': self.version,
+            'window': {
+                'title': self.window.title,
+                'width': self.window.width,
+                'height': self.window.height,
+                'min_width': self.window.min_width,
+                'min_height': self.window.min_height,
+                'resizable': self.window.resizable,
+                'fullscreen': False
+            }
+        };
+    }
+}
+
+"""Desktop plugin configuration loader."""
+class JacDesktopConfig(PluginConfigBase) {
+    override def get_plugin_name(self: JacDesktopConfig) -> str;
+    override def get_default_config(self: JacDesktopConfig) -> dict[str, any];
+    def get_identity(self: JacDesktopConfig) -> DesktopIdentity;
+    def get_window_config(self: JacDesktopConfig) -> WindowConfig;
+    def validate(self: JacDesktopConfig) -> None;
+}
+
+glob _desktop_config_instance: JacDesktopConfig | None = None;
+
+"""Get or create the desktop config singleton."""
+def get_desktop_config(project_dir: Path | None = None) -> JacDesktopConfig;
+
+"""Reset cached desktop config (for tests)."""
+def reset_desktop_config -> None;

jac_desktop-0.2.0/jac_desktop/impl/config_loader.impl.jac

@@ -0,0 +1,108 @@
+"""Implementation of jac-desktop configuration loader."""
+import from pathlib { Path }
+import from jaclang.cli.console { console }
+
+"""Plugin section name for [plugins.desktop]."""
+impl JacDesktopConfig.get_plugin_name(self: JacDesktopConfig) -> str {
+    return "desktop";
+}
+
+"""Default [plugins.desktop] configuration."""
+impl JacDesktopConfig.get_default_config(self: JacDesktopConfig) -> dict[str, any] {
+    project_name = "my-jac-app";
+    project_version = "1.0.0";
+    try {
+        jac_config = self.get_jac_config();
+        if jac_config and jac_config.project {
+            project_name = jac_config.project.name or project_name;
+            project_version = jac_config.project.version or project_version;
+        }
+    } except Exception {
+        console.warning("Failed to load JacConfig, using fallback defaults");
+    }
+    identifier = _generate_identifier(project_name);
+    return DesktopDefaultConfig(
+        name=project_name,
+        identifier=identifier,
+        version=project_version,
+        window=WindowConfig(title=project_name)
+    ).to_dict();
+}
+
+impl JacDesktopConfig.get_identity(self: JacDesktopConfig) -> DesktopIdentity {
+    config = self.load();
+    return DesktopIdentity(
+        name=str(config.get('name', '')),
+        identifier=str(config.get('identifier', '')),
+        version=str(config.get('version', '1.0.0'))
+    );
+}
+
+impl JacDesktopConfig.get_window_config(self: JacDesktopConfig) -> WindowConfig {
+    config = self.load();
+    identity = self.get_identity();
+    window_data: dict[str, any] = {};
+    raw_window = config.get('window', {});
+    if isinstance(raw_window, dict) {
+        window_data = raw_window;
+    }
+    return WindowConfig.from_dict(window_data, title_fallback=identity.name);
+}
+
+impl JacDesktopConfig.validate(self: JacDesktopConfig) -> None {
+    config = self.load();
+    name = str(config.get('name', ''));
+    if not name {
+        raise ValueError(
+            "Desktop configuration error: 'name' is required in [plugins.desktop]"
+        );
+    }
+    window = config.get('window', {});
+    width = window.get('width', 1200);
+    height = window.get('height', 800);
+    min_width = window.get('min_width', 800);
+    min_height = window.get('min_height', 600);
+    if min_width > width {
+        raise ValueError(
+            f"Desktop configuration error: window.min_width ({min_width}) "
+            f"cannot be greater than window.width ({width})"
+        );
+    }
+    if min_height > height {
+        raise ValueError(
+            f"Desktop configuration error: window.min_height ({min_height}) "
+            f"cannot be greater than window.height ({height})"
+        );
+    }
+}
+
+impl get_desktop_config(project_dir: Path | None = None) -> JacDesktopConfig {
+    # Module-level singleton mirrors jac-client/jac-scale; not thread-safe.
+    global _desktop_config_instance;
+    if (
+        _desktop_config_instance is not None
+        and project_dir != _desktop_config_instance.project_dir
+    ) {
+        _desktop_config_instance = None;
+    }
+    if _desktop_config_instance is None {
+        _desktop_config_instance = JacDesktopConfig(project_dir=project_dir);
+    }
+    return _desktop_config_instance;
+}
+
+impl reset_desktop_config -> None {
+    global _desktop_config_instance;
+    _desktop_config_instance = None;
+}
+
+def _generate_identifier(name: str) -> str {
+    import re;
+    cleaned = re.sub(r'[^a-zA-Z0-9.\-]', '', name.lower());
+    cleaned = re.sub(r'[.\-]+', '.', cleaned);
+    cleaned = cleaned.strip('.');
+    if not cleaned or not '.' in cleaned {
+        cleaned = f"com.{cleaned}" if cleaned else "com.myapp";
+    }
+    return cleaned;
+}

jac_desktop-0.2.0/jac_desktop/impl/plugin.impl.jac

@@ -0,0 +1,8 @@
+"""Implementation of jac-desktop runtime plugin hooks."""
+
+import from jac_client.plugin.src.targets.registry { ClientTarget }
+import from jac_desktop.targets.native_desktop_target { NativeDesktopTarget }
+
+impl JacDesktopPlugin.get_client_targets -> list[ClientTarget] {
+    return [NativeDesktopTarget()];
+}