ui-design-workbench-cli 0.6.7__tar.gz → 0.6.9__tar.gz

{ui_design_workbench_cli-0.6.7 → ui_design_workbench_cli-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ui-design-workbench-cli
-Version: 0.6.7
+Version: 0.6.9
 Summary: Repository UI indexing, graph, preview, and deterministic review CLI
 Author: Elgreed
 Project-URL: Homepage, https://github.com/Elgreed/ui-design-workbench
@@ -131,4 +131,4 @@ A Windows `.exe` is not published yet. PyPI + `pipx` is the primary cross-platfo
 - [IR schema](references/ir-schema.md)
 - [Review workflow](references/review-workflow.md)
 
-Current CLI version: `0.6.7`.
+Current CLI version: `0.6.9`.

{ui_design_workbench_cli-0.6.7 → ui_design_workbench_cli-0.6.9}/README.md

@@ -112,4 +112,4 @@ A Windows `.exe` is not published yet. PyPI + `pipx` is the primary cross-platfo
 - [IR schema](references/ir-schema.md)
 - [Review workflow](references/review-workflow.md)
 
-Current CLI version: `0.6.7`.
+Current CLI version: `0.6.9`.

{ui_design_workbench_cli-0.6.7 → ui_design_workbench_cli-0.6.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ui-design-workbench-cli"
-version = "0.6.7"
+version = "0.6.9"
 description = "Repository UI indexing, graph, preview, and deterministic review CLI"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -43,6 +43,10 @@ py-modules = [
   "fidelity_core",
   "fidelity_adapter_api",
   "fidelity_adapters",
+  "source_syntax",
+  "compose_syntax",
+  "compose_resources",
+  "compose_instances",
   "fidelity_platform_adapters",
   "android_resource_resolver",
   "apple_resource_resolver",
@@ -68,6 +72,10 @@ py-modules = [
   "scripts/coverage_report.py",
   "scripts/fidelity_adapter_api.py",
   "scripts/fidelity_adapters.py",
+  "scripts/source_syntax.py",
+  "scripts/compose_syntax.py",
+  "scripts/compose_resources.py",
+  "scripts/compose_instances.py",
   "scripts/fidelity_core.py",
   "scripts/fidelity_platform_adapters.py",
   "scripts/generate_interaction_matrix.py",

{ui_design_workbench_cli-0.6.7 → ui_design_workbench_cli-0.6.9}/references/fidelity.md

@@ -10,6 +10,18 @@ Use `uidw fidelity capabilities` for the installed support matrix, `uidw fidelit
 
 The HTML projection resolves recognized controls through the official-doc-first [platform component catalog](component-catalog.md). Catalog geometry is a render-only fallback: explicit source layout, theme, token, and style evidence always wins, and the source IR is not mutated.
 
+Compose translation follows unique local composable declarations, literal parameter defaults and constructor preview fixtures. Simple imported enum `entries.forEach` loops and literal resource getters can supply repeated content. Expansion is limited to six nested components and 2,000 calls per translated source; ambiguity, recursion and exhausted budgets remain explicit gaps. Runtime Kotlin, arbitrary collection transformations, slot forwarding, custom drawing and arbitrary theme providers are not evaluated.
+
+Literal project theme values and local font assets are resolved from source. The box model marks automatic text measurement as partial and lets the browser wrap and measure the loaded font, rather than treating average character widths as solved geometry. Browser line boxes and shadows can still differ from native rendering. A partial context does not establish native visual parity.
+
+For a user-requested native comparison, use the same authored preview state, locale, font scale and logical viewport. Capture metadata can provide `viewport.safeAreaInsets` in logical pixels for Compose system-bar padding. `smoke_preview.js --capture-device --capture-screen ID --capture-theme light --screenshot screen.png --geometry-output geometry.json` captures the device content after fonts load, excluding workbench chrome. Keep the native screenshot, device density, source revision and comparison results with the diagnostic artifact; system-bar icons themselves are outside the source projection.
+
+Flutter and SwiftUI use the same balanced source delimiter and literal masking utilities as Compose. Visual parameters are scoped to the current call, excluding child widgets and event handlers. SwiftUI expands unique local View declarations with literal member arguments and represents order-dependent frame/padding/background operations as separate source-backed nodes. Flutter resolves literal constructor defaults, distinguishes TextStyle height factors from widget heights, and propagates SizedBox tight constraints to its child. Expansion is capped at six component levels and 2,000 widget calls. Arbitrary control flow, unavailable SF Symbols and recursive expansion remain gaps.
+
+XAML translates four-value Thickness in left/top/right/bottom order, alpha-first colors, explicit grid tracks/cell spans and literal states. WPF Border and TextBlock defaults are distinct from generic card recipes. Resource bindings, control templates, nonliteral grid tracks and more complex platform layout behavior still require separate handling. Web handles the supported simple selectors in CSS cascade order, including importance and linked stylesheet order; unsupported at-rules are reported rather than applied unconditionally.
+
+The source fixtures in `fixtures/golden/platform-fidelity` exercise these shared failure patterns. A Flutter engine golden, a WPF RenderTargetBitmap and an original Web page can provide independent runtime evidence for their respective fixture. WPF evidence does not verify WinUI, and Flutter test-engine evidence does not verify every device configuration. SwiftUI iOS/macOS fixture assertions are source-only unless matching Apple runtime captures are supplied. Successful source tests or a small native comparison must never promote unrelated screens or platforms to verified visual parity.
+
 Use this contract before creating reviewable IR. The goal is not a visually pleasant approximation; it is a traceable projection of the authored UI.
 
 ## Evidence bundle per screen

ui_design_workbench_cli-0.6.9/scripts/compose_instances.py

@@ -0,0 +1,165 @@
+"""Static argument substitution for bounded local Compose component instances."""
+
+from __future__ import annotations
+
+import re
+import os
+
+from compose_syntax import arguments, closing, mask_literals, named_argument
+
+
+def substitute(expression: str, bindings: dict[str, str]) -> str:
+    masked = mask_literals(expression)
+    edits = []
+    for match in re.finditer(r"\b[A-Za-z_]\w*\b", masked):
+        if match.start() > 0 and masked[match.start() - 1] == ".":
+            continue
+        # Named argument keys and lambda parameter declarations are not values.
+        tail = masked[match.end():]
+        if re.match(r"\s*=(?!=)", tail) or re.match(r"\s*->", tail):
+            continue
+        value = bindings.get(match.group())
+        if value is not None and value != match.group():
+            edits.append((match.start(), match.end(), value))
+    for start, end, value in reversed(edits):
+        expression = expression[:start] + value + expression[end:]
+    return expression
+
+
+def static_value(expression: str, bindings: dict[str, str]) -> str:
+    expression = substitute(expression, bindings).strip()
+    # Read authored constructor fixtures such as ScreenState(selected = Choice.ONE).selected.
+    for match in reversed(list(re.finditer(r"\b[A-Z]\w*\s*\(", mask_literals(expression)))):
+        start = expression.find("(", match.start())
+        end = closing(expression, start)
+        member = re.match(r"\.(\w+)", expression[end + 1:]) if end is not None else None
+        if member:
+            value = named_argument(expression[start + 1:end], member.group(1))
+            if value is not None:
+                expression = expression[:match.start()] + value + expression[end + 1 + member.end():]
+    equality = re.fullmatch(r"([A-Z]\w*\.\w+|true|false|null)\s*==\s*([A-Z]\w*\.\w+|true|false|null)", expression)
+    if equality:
+        return "true" if equality.group(1) == equality.group(2) else "false"
+    condition = re.match(r"if\s*\(\s*([^()]+)\s*\)\s*", expression)
+    if condition:
+        test = condition.group(1).strip()
+        equality = re.fullmatch(r"([A-Z]\w*\.\w+|true|false)\s*==\s*([A-Z]\w*\.\w+|true|false)", test)
+        selected = test == "true" if test in {"true", "false"} else equality.group(1) == equality.group(2) if equality else None
+        if selected is not None:
+            branch_start = condition.end()
+            if expression[branch_start:branch_start + 1] == "{":
+                branch_end = closing(expression, branch_start)
+                if branch_end is not None:
+                    alternative = re.match(r"\s*else\s*", expression[branch_end + 1:])
+                    if alternative:
+                        second = expression[branch_end + 1 + alternative.end():].strip()
+                        return (expression[branch_start + 1:branch_end] if selected else second.removeprefix("{").removesuffix("}")).strip()
+            inline = re.fullmatch(r"([^\n]+?)\s+else\s+([^\n]+)", expression[branch_start:])
+            if inline:
+                return inline.group(1 if selected else 2).strip()
+    choice = re.match(r"when\s*\(\s*([A-Z]\w*\.\w+)\s*\)\s*\{", expression)
+    if choice:
+        branches = list(re.finditer(r"(?:^|\n)\s*([A-Z]\w*\.\w+|else)\s*->\s*", expression))
+        for index, branch in enumerate(branches):
+            if branch.group(1) in {choice.group(1), "else"}:
+                end = branches[index + 1].start() if index + 1 < len(branches) else expression.rfind("}")
+                return expression[branch.end():end].strip()
+    return expression
+
+
+def bind_parameters(parameters: str, args: str) -> dict[str, str]:
+    result = {}
+    names = []
+    for parameter in arguments(parameters):
+        match = re.match(r"(\w+)\s*:", parameter.strip())
+        if not match:
+            continue
+        name = match.group(1)
+        names.append(name)
+        default = re.search(r"(?<![=!])=(?!=)", parameter)
+        if default:
+            result[name] = parameter[default.end():].strip()
+    position = 0
+    for argument in arguments(args):
+        named = re.match(r"(\w+)\s*=\s*([\s\S]+)", argument)
+        if named:
+            if named.group(1) in names:
+                result[named.group(1)] = named.group(2)
+        elif position < len(names):
+            result[names[position]] = argument
+            position += 1
+    return result
+
+
+class StaticImports:
+    def __init__(self):
+        self.cache = {}
+        self.paths = {}
+
+    def source_paths(self, root):
+        if root not in self.paths:
+            paths = []
+            for directory, subdirs, files in os.walk(root):
+                subdirs[:] = [name for name in subdirs if name not in {
+                    "build", "node_modules", ".git", ".gradle", ".idea", ".codegraph", ".ui-design-workbench"}]
+                for name in files:
+                    if name.endswith(".kt"):
+                        path = root / os.path.relpath(os.path.join(directory, name), root)
+                        if "/src/" in path.as_posix():
+                            paths.append(path)
+            self.paths[root] = paths
+        return self.paths[root]
+
+    def sources(self, name, context):
+        key = (str(context.root), context.source, name)
+        if key not in self.cache:
+            imports = re.findall(rf"^import\s+([\w.]+\.{re.escape(name)})\s*$", context.text, re.M)
+            paths = []
+            for imported in imports:
+                package = imported.rsplit(".", 1)[0].replace(".", "/")
+                paths.extend(path for path in self.source_paths(context.root)
+                             if any(path.parent.as_posix().endswith(f"/{language}/{package}") for language in ("java", "kotlin")))
+            self.cache[key] = [(path, path.read_text(encoding="utf-8")) for path in sorted(set(paths)) if path.is_file()]
+        return self.cache[key]
+
+    def enum_entries(self, name, context):
+        matches = []
+        for path, text in self.sources(name, context):
+            match = re.search(rf"\benum\s+class\s+{re.escape(name)}\s*\{{([^{{}};]*)}}", mask_literals(text))
+            if match:
+                entries = [item.strip() for item in match.group(1).split(",") if item.strip()]
+                if all(re.fullmatch(r"[A-Z]\w*", item) for item in entries) and len(entries) <= 32:
+                    matches.append([f"{name}.{item}" for item in entries])
+        return matches[0] if len(matches) == 1 else []
+
+    def resolve_properties(self, expression, context):
+        for match in reversed(list(re.finditer(r"\b([A-Z]\w*\.\w+)\.(\w+)\b", expression))):
+            values = []
+            for path, text in self.sources(match.group(2), context):
+                owner = match.group(1).split(".")[0]
+                declaration = re.search(rf"\bval\s+{owner}\.{match.group(2)}\s*:\s*\w+\s+get\(\)\s*=\s*when\s*\(this\)\s*\{{", text)
+                if declaration:
+                    end = closing(text, text.find("{", declaration.start()))
+                    body = text[declaration.end():end] if end is not None else ""
+                    branch = re.search(rf"\b{re.escape(match.group(1))}\s*->\s*(R\.string\.\w+)\b", body)
+                    if branch:
+                        values.append(branch.group(1))
+            if len(values) == 1:
+                expression = expression[:match.start()] + values[0] + expression[match.end():]
+        return expression
+
+    def expand_calls(self, calls, body, context):
+        result = calls
+        for loop in re.finditer(r"\b(\w+)\.entries\.forEach\s*\{\s*(\w+)\s*->", mask_literals(body)):
+            end = closing(body, body.find("{", loop.start()))
+            entries = self.enum_entries(loop.group(1), context)
+            if end is None or not entries:
+                continue
+            enclosed = [call for call in result if loop.end() <= call["start"] < end]
+            if enclosed:
+                position = result.index(enclosed[0])
+                expanded = [{**call, "loopBindings": {**call.get("loopBindings", {}), loop.group(2): entry}, "loopInstance": entry}
+                            for entry in entries for call in enclosed]
+                result = [call for call in result if call not in enclosed]
+                result[position:position] = expanded
+        return result

ui_design_workbench_cli-0.6.9/scripts/compose_resources.py

@@ -0,0 +1,242 @@
+"""Resolve literal Compose theme values and local font assets without executing Kotlin."""
+
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+
+from compose_syntax import arguments, closing, mask_literals, named_argument
+from fidelity_core import property_evidence
+
+
+WEIGHTS = {"Thin": 100, "ExtraLight": 200, "Light": 300, "Normal": 400, "Medium": 500,
+           "SemiBold": 600, "Bold": 700, "ExtraBold": 800, "Black": 900}
+
+
+def expression_at(text: str, start: int) -> str:
+    masked = mask_literals(text)
+    depth = 0
+    for index in range(start, len(text)):
+        char = masked[index]
+        if char in "({[":
+            depth += 1
+        elif char in ")}]":
+            if depth == 0:
+                return text[start:index].strip()
+            depth -= 1
+        elif char in "\n;," and depth == 0:
+            return text[start:index].strip()
+    return text[start:].strip()
+
+
+class ComposeResources:
+    def __init__(self, contexts):
+        self.definitions = defaultdict(list)
+        self.aliases = {}
+        self.fonts = []
+        self.bindings = defaultdict(set)
+        self._resolved = {}
+        self.contexts = [context for context in contexts if context.path.suffix == ".kt" and
+                         (context.role == "theme" or "/theme/" in context.source)]
+        for context in self.contexts:
+            text = context.text
+            for match in re.finditer(r"\bval\s+(\w+)\s*(?::\s*[\w<>?.]+)?\s*=\s*", mask_literals(text)):
+                self.definitions[match.group(1)].append((expression_at(text, match.end()), context, match.start()))
+            for function in re.finditer(r"\bfun\s+(\w+)\s*\(\s*\)\s*:\s*Brush\s*\{", mask_literals(text)):
+                end = closing(text, text.find("{", function.start()))
+                body = text[function.end():end] if end is not None else ""
+                gradients = list(re.finditer(r"Brush\.verticalGradient\s*\(", mask_literals(body)))
+                if len(gradients) == 1:
+                    start = gradients[0].start()
+                    gradient_end = closing(body, body.find("(", start))
+                    if gradient_end is not None:
+                        from compose_instances import substitute
+                        bindings = {match.group(1): expression_at(body, match.end()) for match in
+                                    re.finditer(r"\bval\s+(\w+)\s*=\s*", mask_literals(body[:start]))}
+                        gradient = substitute(body[start:gradient_end + 1], bindings)
+                        self.definitions[function.group(1) + "()"].append((gradient, context, function.start()))
+            for match in re.finditer(r"\bval\s+Typography\.(\w+)\s*:\s*TextStyle\s+get\(\)\s*=\s*(\w+)", text):
+                self.aliases[f"MaterialTheme.typography.{match.group(1)}"] = match.group(2)
+            for match in re.finditer(r"\bobject\s+(\w+)\s*\{", mask_literals(text)):
+                end = closing(text, text.find("{", match.start()))
+                body = text[match.end():end] if end is not None else ""
+                for prop in re.finditer(r"\bval\s+(\w+)\s*:\s*\w+[\s\S]*?get\(\)\s*=\s*(\w+)\.current", body):
+                    self.aliases[f"{match.group(1)}.{prop.group(1)}"] = prop.group(2)
+            for match in re.finditer(r"\bMaterialTheme\s*\(", mask_literals(text)):
+                start = text.find("(", match.start())
+                end = closing(text, start)
+                if end is None:
+                    continue
+                for name in ("typography", "colorScheme", "shapes"):
+                    value = named_argument(text[start + 1:end], name)
+                    if value:
+                        self.bindings[name].add(value)
+        for name, values in self.bindings.items():
+            if len(values) == 1:
+                self.aliases[f"MaterialTheme.{name}"] = next(iter(values))
+        for name, definitions in self.definitions.items():
+            if len(definitions) != 1 or not definitions[0][0].startswith("FontFamily("):
+                continue
+            expression, context, offset = definitions[0]
+            for match in re.finditer(r"\bFont\s*\(", expression):
+                start = expression.find("(", match.start())
+                end = closing(expression, start)
+                if end is None:
+                    continue
+                args = expression[start + 1:end]
+                resource = re.search(r"R\.font\.(\w+)", args)
+                if resource is None:
+                    continue
+                assets = [path for path in context.root.glob(f"**/src/main/res/font/{resource.group(1)}.*")
+                          if path.suffix.lower() in {".ttf", ".otf", ".woff", ".woff2"}]
+                if len(assets) != 1:
+                    continue
+                weight = (named_argument(args, "weight") or "FontWeight.Normal").split(".")[-1]
+                self.fonts.append({"family": name, "asset": assets[0].relative_to(context.root).as_posix(),
+                                   "weight": WEIGHTS.get(weight, 400), "style": "normal"})
+
+    def resolve(self, expression, dark=False, seen=None):
+        if not isinstance(expression, str) or seen is not None:
+            return self._resolve(expression, dark, seen)
+        key = (expression.strip(), dark)
+        if key not in self._resolved:
+            self._resolved[key] = self._resolve(expression, dark, set())
+        return self._resolved[key]
+
+    def _resolve(self, expression, dark=False, seen=None):
+        if not isinstance(expression, str):
+            return expression
+        expression = expression.strip()
+        from compose_instances import static_value
+        selected = static_value(expression, {})
+        if selected != expression:
+            return self.resolve(selected, dark, seen)
+        seen = set(seen or ())
+        if expression in seen or len(seen) > 24:
+            return None
+        seen.add(expression)
+        dimension = re.fullmatch(r"(-?\d+(?:\.\d+)?)\.(?:dp|sp)", expression)
+        if dimension:
+            return f"{dimension.group(1)}px"
+        if expression.startswith("FontWeight."):
+            return WEIGHTS.get(expression.split(".")[-1])
+        color = re.fullmatch(r"Color\(0x([\da-fA-F]{8})\)", expression)
+        if color:
+            value = color.group(1).lower()
+            return "#" + value[2:] + (value[:2] if value[:2] != "ff" else "")
+        if expression in {"Color.White", "Color.Black", "Color.Transparent"}:
+            return {"Color.White": "#ffffff", "Color.Black": "#000000", "Color.Transparent": "transparent"}[expression]
+        conditional = re.fullmatch(r"if\s*\(\s*darkTheme\s*\)\s*(\w+)\s+else\s+(\w+)", expression)
+        if conditional:
+            return self.resolve(conditional.group(1 if dark else 2), dark, seen)
+        for alias in sorted(self.aliases, key=len, reverse=True):
+            if expression == alias or expression.startswith(alias + "."):
+                value = self.resolve(self.aliases[alias], dark, seen)
+                for part in expression[len(alias):].strip(".").split(".") if expression != alias else []:
+                    value = value.get(part) if isinstance(value, dict) else None
+                return value
+        if expression in self.definitions:
+            definitions = self.definitions[expression]
+            if len(definitions) != 1:
+                return None
+            value = definitions[0][0]
+            if value.startswith("FontFamily("):
+                return expression if any(font["family"] == expression for font in self.fonts) else None
+            local = re.fullmatch(r"staticCompositionLocalOf\s*\{\s*(\w+)\s*}", value, re.S)
+            return self.resolve(local.group(1) if local else value, dark, seen)
+        if re.fullmatch(r"\w+(?:\.\w+)+", expression):
+            parts = expression.split(".")
+            value = self.resolve(parts[0], dark, seen)
+            for part in parts[1:]:
+                value = value.get(part) if isinstance(value, dict) else None
+            return value
+        call = re.match(r"\w+\s*\(", expression)
+        if expression.startswith("RoundedCornerShape("):
+            values = arguments(expression[len("RoundedCornerShape("):-1])
+            if len(values) == 1 and "=" not in values[0]:
+                return self.resolve(values[0], dark, seen)
+        if expression.startswith("Brush.verticalGradient("):
+            args = expression[len("Brush.verticalGradient("):-1]
+            colors = named_argument(args, "colors")
+            if colors and colors.startswith("listOf("):
+                values = [self.resolve(value, dark, seen) for value in arguments(colors[7:-1])]
+                if len(values) >= 2 and all(isinstance(value, str) and value.startswith("#") for value in values):
+                    return "linear-gradient(to bottom, " + ", ".join(values) + ")"
+        if call and closing(expression, expression.find("(")) == len(expression) - 1:
+            values = {}
+            for argument in arguments(expression[expression.find("(") + 1:-1]):
+                field = re.match(r"(\w+)\s*=\s*([\s\S]+)", argument)
+                if field:
+                    value = self.resolve(field.group(2), dark, seen)
+                    if value is not None:
+                        values[field.group(1)] = value
+            return values or None
+        return None
+
+    def resolve_local(self, expression, context, dark=False):
+        value = self.resolve(expression, dark)
+        if value is not None or not re.fullmatch(r"\w+", expression.strip()):
+            return value
+        definitions = list(re.finditer(rf"\bval\s+{re.escape(expression.strip())}\s*=\s*", mask_literals(context.text)))
+        if len(definitions) == 1:
+            return self.resolve(expression_at(context.text, definitions[0].end()), dark)
+        return None
+
+    def apply(self, result, context):
+        from fidelity_adapters import _compose_named_value
+        for node in result.nodes.values():
+            for group in ("layout", "style"):
+                for key, expression in list(node.get(group, {}).items()):
+                    resolved = self.resolve(expression)
+                    if resolved is not None and not isinstance(resolved, dict):
+                        node[group][key] = resolved
+            # Node call arguments are kept local to this translation pass.
+            args = node.pop("_composeArguments", "")
+            style_expression = _compose_named_value(args, "style")
+            typography = self.resolve(style_expression)
+            if isinstance(typography, dict):
+                for key in ("fontSize", "fontFamily", "fontWeight", "lineHeight", "letterSpacing"):
+                    if key in typography and key not in node["style"]:
+                        node["style"][key] = typography[key]
+                        node["provenance"][f"style.{key}"] = property_evidence(context.source, node["source"]["line"], style_expression, "compose", "high")
+            color_expression = _compose_named_value(args, "color")
+            color = self.resolve(color_expression)
+            if isinstance(color, str) and color.startswith("#"):
+                key = "backgroundColor" if node.get("component") == "Surface" else "color"
+                node["style"][key] = color
+                node["provenance"][f"style.{key}"] = property_evidence(context.source, node["source"]["line"], color_expression, "compose", "high")
+                dark_color = self.resolve(color_expression, dark=True)
+                if isinstance(dark_color, str) and dark_color != color:
+                    node.setdefault("_composeDarkStyle", {})[key] = dark_color
+            def assign(group, key, value, expression):
+                if value is not None:
+                    node[group][key] = value
+                    node["provenance"][f"{group}.{key}"] = property_evidence(context.source, node["source"]["line"], expression, "compose", "high")
+                    dark_value = self.resolve(expression, dark=True)
+                    if isinstance(dark_value, dict):
+                        dark_value = dark_value.get({"borderColor": "color", "borderWidth": "width"}.get(key, key))
+                    if group == "style" and isinstance(dark_value, (str, int, float)) and dark_value != value:
+                        node.setdefault("_composeDarkStyle", {})[key] = dark_value
+            shape = _compose_named_value(args, "shape")
+            radius = self.resolve(shape)
+            if isinstance(radius, str):
+                assign("style", "radius", radius, shape)
+            border_expression = _compose_named_value(args, "border")
+            border = self.resolve(border_expression)
+            if isinstance(border, dict):
+                assign("style", "borderWidth", border.get("width"), border_expression)
+                assign("style", "borderColor", border.get("color"), border_expression)
+                assign("style", "borderStyle", "solid", border_expression)
+            padding_expression = _compose_named_value(args, "contentPadding")
+            padding = self.resolve(padding_expression)
+            if isinstance(padding, dict):
+                for key in ("horizontal", "vertical", "top", "bottom", "start", "end"):
+                    target = {"start": "Left", "end": "Right"}.get(key, key.title())
+                    assign("layout", "padding" + target, padding.get(key), padding_expression)
+            if node.get("component") == "Button":
+                for key, role in (("backgroundColor", "primary"), ("color", "onPrimary")):
+                    if key not in node["style"]:
+                        assign("style", key, self.resolve("MaterialTheme.colorScheme." + role), "MaterialTheme.colorScheme." + role)
+            if node.get("component") == "RadioButton":
+                role = "primary" if node.get("checked") else "onSurfaceVariant"
+                assign("style", "color", self.resolve("MaterialTheme.colorScheme." + role), "MaterialTheme.colorScheme." + role)

ui_design_workbench_cli-0.6.9/scripts/compose_syntax.py

@@ -0,0 +1,36 @@
+"""Bounded Kotlin syntax helpers; offsets always refer to the original source."""
+
+from __future__ import annotations
+
+import re
+from typing import Iterator
+
+
+from source_syntax import arguments, closing, mask_literals, named_argument
+
+
+def composable_functions(text: str) -> Iterator[dict]:
+    masked = mask_literals(text)
+    # A declaration may have visibility modifiers, annotations and function-typed parameters.
+    pattern = re.compile(r"@Composable\b(?:(?!\bfun\b)[\s\S])*?\bfun\s+([A-Z]\w*)\s*\(")
+    cursor = 0
+    while match := pattern.search(masked, cursor):
+        open_paren = masked.find("(", match.start(1))
+        end_args = closing(text, open_paren)
+        if end_args is None:
+            break
+        body_start = end_args + 1
+        while body_start < len(text) and masked[body_start].isspace():
+            body_start += 1
+        if masked[body_start:body_start + 1] == ":":
+            return_type = re.match(r":\s*Unit\s*", masked[body_start:])
+            body_start += len(return_type.group()) if return_type else 0
+        if masked[body_start:body_start + 1] != "{":
+            cursor = end_args + 1
+            continue
+        body_end = closing(text, body_start)
+        if body_end is None:
+            break
+        yield {"name": match.group(1), "start": match.start(), "bodyStart": body_start + 1,
+               "bodyEnd": body_end, "parameters": text[open_paren + 1:end_args]}
+        cursor = body_end + 1

{ui_design_workbench_cli-0.6.7 → ui_design_workbench_cli-0.6.9}/scripts/fidelity_adapter_api.py

@@ -27,6 +27,7 @@ class AdapterResult:
     themes: list[dict[str, Any]] = field(default_factory=list)
     components: list[dict[str, Any]] = field(default_factory=list)
     unsupported: list[dict[str, Any]] = field(default_factory=list)
+    fonts: list[dict[str, Any]] = field(default_factory=list)
 
 
 class UiSourceAdapter(Protocol):
@@ -83,7 +84,16 @@ def translate_sources(contexts: list[SourceContext]) -> AdapterResult:
         combined.nodes.update(result.nodes)
         for group, values in result.tokens.items():
             combined.tokens.setdefault(group, {}).update(values if isinstance(values, dict) else {})
-        combined.themes.extend(result.themes)
+        for theme in result.themes:
+            existing = next((item for item in combined.themes if item.get("id") == theme.get("id")), None)
+            if existing is None:
+                combined.themes.append(theme)
+            else:
+                for field in ("nodeOverrides", "tokenOverrides"):
+                    existing.setdefault(field, {}).update(theme.get(field, {}))
         combined.components.extend(result.components)
         combined.unsupported.extend(result.unsupported)
+        for font in result.fonts:
+            if font not in combined.fonts:
+                combined.fonts.append(font)
     return combined