ourui 0.2.0__tar.gz → 0.2.2__tar.gz

{ourui-0.2.0 → ourui-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ourui
-Version: 0.2.0
+Version: 0.2.2
 Summary: Python-first UI compiler — write intent in Python, emit HTML/CSS/JS
 Author: OurUI contributors
 License: MIT License
@@ -46,7 +46,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
-# ourui 0.2.0
+# ourui 0.2.2
 
 Python package for the **OurUI** compiler and runtime.
 

{ourui-0.2.0 → ourui-0.2.2}/README.md

@@ -1,4 +1,4 @@
-# ourui 0.2.0
+# ourui 0.2.2
 
 Python package for the **OurUI** compiler and runtime.
 

ourui-0.2.2/ourui/design/__init__.py

@@ -0,0 +1,5 @@
+# Design resolution package (RFC-002).
+
+from ourui.design.resolve import ResolvedDesign, default_pack, resolve_design
+
+__all__ = ["ResolvedDesign", "default_pack", "resolve_design"]

ourui-0.2.2/ourui/design/resolve.py

@@ -0,0 +1,121 @@
+"""Design System resolution: Presentation Graph + pack → Resolved Design (RFC-002)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from ourui.theme import DEFAULT_DARK, DEFAULT_LIGHT
+
+PACK_ID = "ourui-default"
+
+
+def default_pack() -> dict[str, Any]:
+    """Seed Design System pack from current theme tables (provisional migration)."""
+    return {
+        "id": PACK_ID,
+        "modes": {
+            "light": dict(DEFAULT_LIGHT),
+            "dark": dict(DEFAULT_DARK),
+        },
+        "control": {
+            "pad_block": "space_sm",
+            "pad_inline": "space_md",
+            "radius": "radius",
+        },
+    }
+
+
+@dataclass
+class ResolvedDesign:
+    pack: str
+    mode: str
+    nodes: dict[str, dict[str, Any]] = field(default_factory=dict)
+    tokens: dict[str, dict[str, str]] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "pack": self.pack,
+            "mode": self.mode,
+            "nodes": {nid: self.nodes[nid] for nid in sorted(self.nodes)},
+            "tokens": {
+                "light": dict(self.tokens.get("light", {})),
+                "dark": dict(self.tokens.get("dark", {})),
+            },
+        }
+
+
+def _tone_pair(tone: str | None, mode_tokens: dict[str, str]) -> dict[str, str]:
+    if not tone:
+        return {
+            "fill": mode_tokens.get("muted", ""),
+            "fg": mode_tokens.get("muted_fg", ""),
+        }
+    fill_key = tone
+    fg_key = f"{tone}_fg"
+    if fill_key not in mode_tokens:
+        fill_key = "primary"
+        fg_key = "primary_fg"
+    return {
+        "fill": mode_tokens.get(fill_key, mode_tokens.get("primary", "")),
+        "fg": mode_tokens.get(fg_key, mode_tokens.get("primary_fg", "")),
+    }
+
+
+def resolve_design(
+    presentation_graph: Any,
+    *,
+    pack: dict[str, Any] | None = None,
+    mode: str = "light",
+    token_overrides: dict[str, dict[str, str]] | None = None,
+) -> ResolvedDesign:
+    """Pure resolution: PG + Design System pack → Resolved Design (no CSS)."""
+    pack = pack or default_pack()
+    modes = {
+        "light": dict(pack.get("modes", {}).get("light", DEFAULT_LIGHT)),
+        "dark": dict(pack.get("modes", {}).get("dark", DEFAULT_DARK)),
+    }
+    if token_overrides:
+        for m in ("light", "dark"):
+            if m in token_overrides:
+                modes[m].update(token_overrides[m])
+
+    mode_key = mode if mode in modes else "light"
+    mode_tokens = modes[mode_key]
+    control = pack.get("control") or {}
+    pad_block = mode_tokens.get(control.get("pad_block", "space_sm"), mode_tokens.get("space_sm", ""))
+    pad_inline = mode_tokens.get(control.get("pad_inline", "space_md"), mode_tokens.get("space_md", ""))
+    radius = mode_tokens.get(control.get("radius", "radius"), mode_tokens.get("radius", ""))
+
+    pg = presentation_graph.to_dict() if hasattr(presentation_graph, "to_dict") else dict(presentation_graph)
+    nodes_in = pg.get("nodes") or {}
+
+    out = ResolvedDesign(pack=str(pack.get("id", PACK_ID)), mode=mode_key, tokens=modes)
+    for nid, node in nodes_in.items():
+        tone = node.get("tone")
+        if isinstance(tone, str):
+            pair = _tone_pair(tone, mode_tokens)
+        else:
+            pair = _tone_pair(None, mode_tokens)
+        resolved: dict[str, Any] = {
+            "fill": pair["fill"],
+            "fg": pair["fg"],
+            "radius": radius,
+            "pad_block": pad_block,
+            "pad_inline": pad_inline,
+        }
+        entry = {
+            "id": nid,
+            "kind": node.get("kind"),
+            "role": node.get("role"),
+            "resolved": resolved,
+            "provenance": [*node.get("provenance", []), "resolve:design"],
+        }
+        if tone is not None:
+            entry["tone"] = tone
+        if "href" in node:
+            entry["href"] = node["href"]
+        if "shell_layout" in node:
+            entry["shell_layout"] = node["shell_layout"]
+        out.nodes[nid] = entry
+    return out

{ourui-0.2.0 → ourui-0.2.2}/ourui/emit/html.py

@@ -98,6 +98,60 @@ button.ourui-tone-muted {
   color: var(--ourui-muted-fg);
 }
 """
+# Tone classes above use CSS vars seeded from Resolved Design (Host Contract).
+# Per-node rules from Resolved Design override for concrete fill/fg/radius/pad.
+
+
+def _as_resolved_design(resolved_design: Any) -> dict[str, Any] | None:
+    if resolved_design is None:
+        return None
+    if hasattr(resolved_design, "to_dict"):
+        return resolved_design.to_dict()
+    return dict(resolved_design)
+
+
+def _tokens_from_resolved(rd: dict[str, Any]) -> dict[str, dict[str, str]]:
+    tokens = rd.get("tokens") or {}
+    return {
+        "light": dict(tokens.get("light") or {}),
+        "dark": dict(tokens.get("dark") or {}),
+    }
+
+
+def _emit_resolved_node_css(rd: dict[str, Any]) -> str:
+    """Host maps Resolved Design node values → CSS (no Design System tables)."""
+    lines: list[str] = []
+    nodes = rd.get("nodes") or {}
+    for nid in sorted(nodes):
+        node = nodes[nid]
+        role = node.get("role")
+        resolved = node.get("resolved") or {}
+        if role not in {"button", "link"}:
+            continue
+        fill = resolved.get("fill")
+        fg = resolved.get("fg")
+        if not fill and not fg:
+            continue
+        lines.append(f'[data-ourui-id="{nid}"] {{')
+        if role == "button":
+            if fill:
+                lines.append(f"  background: {fill};")
+            if fg:
+                lines.append(f"  color: {fg};")
+            if resolved.get("radius"):
+                lines.append(f"  border-radius: {resolved['radius']};")
+            pad_b = resolved.get("pad_block")
+            pad_i = resolved.get("pad_inline")
+            if pad_b and pad_i:
+                lines.append(f"  padding: {pad_b} {pad_i};")
+            lines.append("  border-color: transparent;")
+        else:
+            if fill:
+                lines.append(f"  color: {fill};")
+        lines.append("}")
+    if not lines:
+        return ""
+    return "\n".join(lines) + "\n"
 
 
 def _tone_name(attrs: dict[str, Any]) -> str | None:
@@ -232,7 +286,16 @@ def apply_state_values(rtr: dict[str, Any], state_values: dict[str, Any] | None)
     return out
 
 
-def emit_css(tokens: dict[str, dict[str, str]] | None = None) -> str:
+def emit_css(
+    tokens: dict[str, dict[str, str]] | None = None,
+    *,
+    resolved_design: Any = None,
+) -> str:
+    """Emit host CSS. Prefer Resolved Design tokens + per-node rules (Host Contract)."""
+    rd = _as_resolved_design(resolved_design)
+    if rd is not None:
+        token_block = emit_tokens_css(_tokens_from_resolved(rd))
+        return token_block + _BASE_CSS + _emit_resolved_node_css(rd)
     token_block = emit_tokens_css(tokens or default_tokens())
     return token_block + _BASE_CSS
 
@@ -244,8 +307,9 @@ def emit_html_document(
     state_values: dict[str, Any] | None = None,
     hmr: bool = False,
     tokens: dict[str, dict[str, str]] | None = None,
+    resolved_design: Any = None,
 ) -> str:
-    """Emit a full HTML document from an RTR dict (HostNode tree only)."""
+    """Emit HTML from Host Contract inputs: RTR + Resolved Design (+ optional tokens fallback)."""
     rtr = apply_state_values(rtr, state_values)
     nodes = rtr["nodes"]
     roots = rtr["roots"]
@@ -255,7 +319,7 @@ def emit_html_document(
     body_lines.append("  </div>")
 
     js = emit_js(rtr, hmr=hmr).rstrip("\n")
-    css = emit_css(tokens).rstrip("\n")
+    css = emit_css(tokens, resolved_design=resolved_design).rstrip("\n")
     parts = [
         "<!DOCTYPE html>",
         '<html lang="en">',
@@ -283,10 +347,13 @@ def emit_bundle(
     *,
     title: str = "OurUI",
     tokens: dict[str, dict[str, str]] | None = None,
+    resolved_design: Any = None,
 ) -> dict[str, str]:
     """Serializable emit artifacts (I10): html + css + js."""
     return {
-        "html": emit_html_document(rtr, title=title, tokens=tokens),
-        "css": emit_css(tokens),
+        "html": emit_html_document(
+            rtr, title=title, tokens=tokens, resolved_design=resolved_design
+        ),
+        "css": emit_css(tokens, resolved_design=resolved_design),
         "js": emit_js(rtr),
     }

{ourui-0.2.0 → ourui-0.2.2}/ourui/pipeline.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from typing import Any
 
 from ourui.analysis import build_semantic_graph
+from ourui.design import resolve_design
 from ourui.emit import emit_bundle, emit_html_document
 from ourui.lowering import lower_to_iir, lower_to_ltr, lower_to_presentation_graph, lower_to_rtr
 from ourui.serialize import dumps_deterministic
@@ -30,6 +31,10 @@ def compile_to_rtr(path: str | Path, *, route: str | None = None) -> dict[str, A
         sg.roots = [sg.routes[default_route]]
     iir = lower_to_iir(sg)
     presentation_graph = lower_to_presentation_graph(iir)
+    resolved_design = resolve_design(
+        presentation_graph,
+        token_overrides=sg.tokens,
+    )
     ltr = lower_to_ltr(iir)
     rtr = lower_to_rtr(ltr)
     return {
@@ -38,6 +43,7 @@ def compile_to_rtr(path: str | Path, *, route: str | None = None) -> dict[str, A
         "dependency_graph": dg,
         "iir": iir,
         "presentation_graph": presentation_graph,
+        "resolved_design": resolved_design,
         "ltr": ltr,
         "rtr": rtr,
     }
@@ -47,12 +53,13 @@ def compile_dump(path: str | Path) -> dict[str, Any]:
     path = Path(path)
     artifacts = compile_to_rtr(path)
     return {
-        "version": 11,
+        "version": 12,
         "source": artifacts["source"],
         "semantic_graph": artifacts["semantic_graph"].to_dict(),
         "dependency_graph": artifacts["dependency_graph"].to_dict(),
         "iir": artifacts["iir"].to_dict(),
         "presentation_graph": artifacts["presentation_graph"].to_dict(),
+        "resolved_design": artifacts["resolved_design"].to_dict(),
         "ltr": artifacts["ltr"].to_dict(),
         "rtr": artifacts["rtr"].to_dict(),
         "emit": {
@@ -63,6 +70,8 @@ def compile_dump(path: str | Path) -> dict[str, Any]:
             "components": True,
             "tokens": True,
             "presentation_graph": True,
+            "resolved_design": True,
+            "host_contract": True,
         },
     }
 
@@ -79,7 +88,7 @@ def emit_html(
     state_values: dict[str, Any] | None = None,
     hmr: bool = False,
 ) -> str:
-    """Compile source → RTR → HTML. Emitter consumes HostNode only."""
+    """Compile source → RTR + Resolved Design → HTML (Host Contract)."""
     artifacts = compile_to_rtr(path, route=route)
     doc_title = title or Path(path).stem
     return emit_html_document(
@@ -88,6 +97,7 @@ def emit_html(
         state_values=state_values,
         hmr=hmr,
         tokens=artifacts["semantic_graph"].tokens,
+        resolved_design=artifacts["resolved_design"],
     )
 
 
@@ -98,4 +108,5 @@ def emit_all(path: str | Path, *, title: str | None = None) -> dict[str, str]:
         artifacts["rtr"].to_dict(),
         title=doc_title,
         tokens=artifacts["semantic_graph"].tokens,
+        resolved_design=artifacts["resolved_design"],
     )

{ourui-0.2.0 → ourui-0.2.2}/ourui.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ourui
-Version: 0.2.0
+Version: 0.2.2
 Summary: Python-first UI compiler — write intent in Python, emit HTML/CSS/JS
 Author: OurUI contributors
 License: MIT License
@@ -46,7 +46,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
-# ourui 0.2.0
+# ourui 0.2.2
 
 Python package for the **OurUI** compiler and runtime.
 

{ourui-0.2.0 → ourui-0.2.2}/ourui.egg-info/SOURCES.txt

@@ -14,6 +14,8 @@ ourui.egg-info/entry_points.txt
 ourui.egg-info/top_level.txt
 ourui/analysis/__init__.py
 ourui/analysis/components.py
+ourui/design/__init__.py
+ourui/design/resolve.py
 ourui/emit/__init__.py
 ourui/emit/html.py
 ourui/emit/js.py

{ourui-0.2.0 → ourui-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ourui"
-version = "0.2.0"
+version = "0.2.2"
 description = "Python-first UI compiler — write intent in Python, emit HTML/CSS/JS"
 readme = "README.md"
 license = { file = "LICENSE" }