jui-tools-mcp-server 2.5.0

package/src/tools/test/test_artifacts_pull.ts

@@ -0,0 +1,47 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "test_artifacts_pull",
+    "Pull test artifacts (screenshots/recordings) from the latest run (iOS xcresult / Android device / web Playwright output) into the project's configured artifacts directory, returning generated file paths",
+    {
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+      platform: z.enum(["ios", "android", "web", "all"]).optional().describe("Restrict pulling to one platform (default: all configured)"),
+      xcresult: z.string().optional().describe("Explicit .xcresult bundle path (iOS)"),
+      serial: z.string().optional().describe("adb device serial (Android)"),
+      clean: z.boolean().optional().describe("Remove artifacts from the device after pulling (Android)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["artifacts", "pull", "--json"];
+        if (params.platform) { args.push("--platform", params.platform); }
+        if (params.xcresult) { args.push("--xcresult", params.xcresult); }
+        if (params.serial) { args.push("--serial", params.serial); }
+        if (params.clean) { args.push("--clean"); }
+
+        // xcresult export can exceed the default 60s timeout.
+        const result = await runCli("jsonui-test", args, {
+          cwd: projectDir,
+          timeout: 180_000,
+        });
+        if (result.exitCode === 0) {
+          try {
+            JSON.parse(result.stdout);
+            // The CLI already emits a JSON document ({outputDir, files, skipped})
+            // — pass it through verbatim so callers don't peel a wrapper envelope.
+            return { content: [{ type: "text", text: result.stdout.trim() }] };
+          } catch {
+            // Not JSON — fall through to the standard envelope.
+          }
+        }
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/test/test_artifacts_status.ts

@@ -0,0 +1,34 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "test_artifacts_status",
+    "Show the resolved test-artifacts configuration (output dir, iOS xcresult discovery, Android appId) and list already-pulled artifact files",
+    {
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const result = await runCli("jsonui-test", ["artifacts", "status", "--json"], {
+          cwd: projectDir,
+        });
+        if (result.exitCode === 0) {
+          try {
+            JSON.parse(result.stdout);
+            // The CLI already emits a JSON document — pass it through verbatim.
+            return { content: [{ type: "text", text: result.stdout.trim() }] };
+          } catch {
+            // Not JSON — fall through to the standard envelope.
+          }
+        }
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/test/test_generate_description.ts

@@ -0,0 +1,33 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "test_generate_description",
+    "Generate a description JSON file for a screen or flow test case via the jsonui-test CLI",
+    {
+      test_type: z.enum(["screen", "flow"]).describe("Whether the case belongs to a screen or flow test"),
+      name: z.string().describe("Screen/flow name (e.g., login, checkout)"),
+      case_name: z.string().describe("Test case name (e.g., initial_display, happy_path)"),
+      path: z
+        .string()
+        .optional()
+        .describe("Output file path (default: tests/<type>s/<name>/descriptions/<case_name>.json)"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["generate", "description", params.test_type, params.name, params.case_name];
+        if (params.path) { args.push("--path", params.path); }
+
+        const result = await runCli("jsonui-test", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/test/test_generate_flow.ts

@@ -0,0 +1,33 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "test_generate_flow",
+    "Generate a flow test file template via the jsonui-test CLI",
+    {
+      name: z.string().describe("Flow name (e.g., login, checkout)"),
+      path: z.string().optional().describe("Output test file path (default: tests/flows/<name>/<name>.test.json)"),
+      platform: z
+        .enum(["ios", "ios-swiftui", "ios-uikit", "android", "web", "all"])
+        .optional()
+        .describe("Target platform"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["generate", "test", "flow", params.name];
+        if (params.path) { args.push("--path", params.path); }
+        if (params.platform) { args.push("--platform", params.platform); }
+
+        const result = await runCli("jsonui-test", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/test/test_generate_screen.ts

@@ -0,0 +1,33 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "test_generate_screen",
+    "Generate a screen test file template via the jsonui-test CLI",
+    {
+      name: z.string().describe("Screen name (e.g., login, home)"),
+      path: z.string().optional().describe("Output test file path (default: tests/screens/<name>/<name>.test.json)"),
+      platform: z
+        .enum(["ios", "ios-swiftui", "ios-uikit", "android", "web", "all"])
+        .optional()
+        .describe("Target platform"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["generate", "test", "screen", params.name];
+        if (params.path) { args.push("--path", params.path); }
+        if (params.platform) { args.push("--platform", params.platform); }
+
+        const result = await runCli("jsonui-test", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/test/test_mock_generate.ts

@@ -0,0 +1,58 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "test_mock_generate",
+    "Manage API mock files against an OpenAPI/Swagger spec via the jsonui-test CLI. Writes ONLY into <mockDir>/generated/, which it wipes and rewrites on each run — anything outside that directory is hand-written and never touched. Mocks are matched to operations by their source method+path, not by filename, so a project's own naming keeps working. Only the endpoints the project declares it consumes are scaffolded and checked: api.schemas.include_paths / exclude_paths (the same keys the DTO codegen filters on), or mock.includePaths / mock.excludePaths when the mock scope differs. A shared swagger's other realms are therefore NOT reported as mocks this project is missing — if a check reports many [MISSING] entries, read the paths before writing any, because endpoints from a realm the app cannot reach mean the scope is undeclared and the fix is one config key. A mock file serving an out-of-scope route is reported as [SCOPE] (an unused file, safe to delete) and does not fail; [ORPHAN] still means the swagger has no such endpoint at all, and still fails. check=true reports drift (response bodies are compared against the schema: types, required, enum) without writing. Findings under generated/ are warnings, findings outside it are errors, and a scenario that merely omits OPTIONAL fields is a note that does not fail — omitting an optional field is a valid instance, and failing on it buries the real violations (set strict=true to demand full coverage). Do NOT fill optional fields in to silence a note: a mechanical merge puts null into non-nullable slots and manufactures violations. update_default=true REPAIRS each existing mock's default scenario: it adds the required fields the contract has and the body lacks, refreshes the source route, and changes nothing else — no existing value is overwritten, nothing is removed, other scenarios are untouched. The default scenario is where a project keeps the data its tests assert on (scaffolding creates default and nothing else), so never replace a body wholesale to satisfy the check. Violations a merge cannot decide — wrong type, undeclared field — are reported for a person. dry_run=true previews. The 'mock serve' subcommand is intentionally NOT exposed over MCP (it is a long-running local HTTP server that executes run-targets).",
+    {
+      swagger: z
+        .array(z.string())
+        .optional()
+        .describe("Paths to OpenAPI files (repeatable). Defaults to the project mock config if omitted."),
+      out: z.string().optional().describe("Output mock dir (default: mock.mockDir or tests/mocks)"),
+      config_file: z.string().optional().describe("Config file (default: jui.config.json)"),
+      check: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("When true, report drift vs swagger and do NOT write (adds --check). Default false = regenerate <mockDir>/generated/."),
+      strict: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("With check=true, treat a missing OPTIONAL field as drift too (adds --strict). Off by default."),
+      update_default: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Repair each existing mock's default scenario by ADDING missing required fields (adds --update-default). Never overwrites a value or removes a field."),
+      dry_run: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("With update_default, report what would be added without writing (adds --dry-run)."),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["mock", "generate"];
+        for (const s of params.swagger ?? []) { args.push("--swagger", s); }
+        if (params.out) { args.push("--out", params.out); }
+        if (params.config_file) { args.push("--config", params.config_file); }
+        if (params.check) { args.push("--check"); }
+        if (params.strict) { args.push("--strict"); }
+        if (params.update_default) { args.push("--update-default"); }
+        if (params.dry_run) { args.push("--dry-run"); }
+
+        const result = await runCli("jsonui-test", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/test/test_report.ts

@@ -0,0 +1,32 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "test_report",
+    "Convert one or more results JSON files (results.schema.json format) into a JUnit XML or HTML report via the jsonui-test CLI",
+    {
+      files: z
+        .array(z.string())
+        .min(1)
+        .describe("Results JSON files to convert (multiple inputs merge into one report)"),
+      format: z.enum(["junit", "html"]).describe("Report format"),
+      output: z.string().optional().describe("Output file path (default: report.xml / report.html)"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["report", ...params.files, "--format", params.format];
+        if (params.output) { args.push("--output", params.output); }
+
+        const result = await runCli("jsonui-test", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/src/tools/test/test_validate.ts

@@ -0,0 +1,43 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { ServerConfig } from "../../config.js";
+import { runCli, formatResult } from "../../cli_runner.js";
+
+export function register(server: McpServer, config: ServerConfig) {
+  server.tool(
+    "test_validate",
+    "Validate JsonUI test files (screen/flow tests + descriptions) against the schema via the jsonui-test CLI. When the project config declares mock.swagger + mock.mockDir this ALSO regenerates <mockDir>/generated/ if it is missing or older than the swagger, and fails on mock contract drift — so a non-zero result here is not necessarily about the test files. A mock that merely omits optional fields does not fail this gate (set mock.checkOptionalFields=true in the project config to demand full coverage). Only the endpoints the project declares it consumes are checked (api.schemas.include_paths / exclude_paths, the same keys the DTO codegen filters on), so a shared swagger's other realms are not reported as missing mocks. Pass no_mock_check to validate the test files alone. Like the CLI, this installs (flatten-copies) the tests into the configured test.install destinations as a side effect — pass no_install to validate without consuming the files.",
+    {
+      files: z
+        .array(z.string())
+        .min(1)
+        .describe("Files or directories to validate (e.g., ['tests/screens'] or ['login.test.json'])"),
+      verbose: z.boolean().optional().describe("Show all files, including valid ones"),
+      quiet: z.boolean().optional().describe("Hide warnings, show only errors"),
+      no_mock_check: z
+        .boolean()
+        .optional()
+        .describe("Skip the mock-vs-swagger contract check that otherwise runs on the same gate"),
+      no_install: z
+        .boolean()
+        .optional()
+        .describe("Validate only; skip the flatten-install side effect even if test.install is configured (maps to CLI --no-install; default false, same behavior as the CLI)"),
+      project_dir: z.string().optional().describe("Project directory (overrides JUI_PROJECT_DIR env)"),
+    },
+    async (params) => {
+      try {
+        const projectDir = config.resolveProjectDir(params.project_dir);
+        const args = ["validate", ...params.files];
+        if (params.verbose) { args.push("--verbose"); }
+        if (params.quiet) { args.push("--quiet"); }
+        if (params.no_mock_check) { args.push("--no-mock-check"); }
+        if (params.no_install) { args.push("--no-install"); }
+
+        const result = await runCli("jsonui-test", args, { cwd: projectDir });
+        return { content: [{ type: "text", text: formatResult(result) }] };
+      } catch (e: any) {
+        return { content: [{ type: "text", text: `Error: ${e.message}` }] };
+      }
+    }
+  );
+}

package/tests/__snapshots__/derived.test.ts.snap

@@ -0,0 +1,279 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`derived constants (pinned) > BINDING_RULES snapshot 1`] = `
+{
+  "criticalRules": [
+    "Two-way binding expressions must be a single flat identifier — no dots, brackets, ??, or ! (binding-two-way-complex)",
+    "Frame values (width, height, etc.) MUST be read-only (data.). $data. is NOT allowed",
+    "Two-way binding is only for stateful input components",
+    "React auto-generates onPropertyNameChange for two-way bindings",
+    "Kotlin Dynamic uses updateData(mapOf(key to value)) for data updates",
+    "onclick (lowercase) = selector format (string), onClick (camelCase) = binding format (@{handler})",
+  ],
+  "description": "JsonUI binding syntax rules",
+  "directions": {
+    "read-only": {
+      "applicableAttributes": [
+        "Label.text",
+        "*.width / *.height (frame values)",
+        "*.enabled",
+        "*.hidden / *.visibility",
+        "*.background / *.fontColor",
+        "*.fontSize",
+        "*.opacity / *.alpha",
+      ],
+      "description": "Display data values only (no write-back)",
+      "kotlin": "data[propertyName]",
+      "react": "{data.propertyName}",
+      "swift": "data.propertyName",
+    },
+    "two-way": {
+      "applicableAttributes": [
+        "TextField.text",
+        "TextView.text",
+        "Switch.isOn",
+        "Toggle.isOn",
+        "CheckBox.checked",
+        "Slider.value",
+        "Segment.selectedIndex",
+        "Radio.selectedIndex",
+        "SelectBox.selectedIndex",
+        "TabView.selectedIndex",
+      ],
+      "description": "Component state changes reflect back to data model",
+      "kotlin": "mutableStateOf + updateData(mapOf(key to value))",
+      "react": "value={data.prop} + auto-generated onChange handler",
+      "swift": "$data.propertyName",
+    },
+  },
+  "format": {
+    "bindingExpression": "@{propertyName}",
+    "defaultValue": "@{propertyName ?? default} (one ?? max; string default in single or double quotes, or true/false/number; null = unresolved)",
+    "negation": "@{!propertyName} (boolean value attributes only — validator error elsewhere)",
+    "nestedPath": "@{user.name} / @{items[0].title} (dot path + bracket index — canonical on all platforms; see semantics)",
+  },
+}
+`;
+
+exports[`derived constants (pinned) > MODIFIER_ORDER snapshot 1`] = `
+{
+  "description": "Platform-specific modifier application order. Order affects rendering.",
+  "kotlin": {
+    "criticalRules": [
+      "Modifier.then() chains left-to-right; order matters",
+      "margins before size (outside to inside)",
+      "cornerRadius must be applied as clip before background",
+    ],
+    "order": [
+      "testTag",
+      "margins",
+      "weight (caller applies)",
+      "size (width/height, matchParent/wrapContent, min/max/aspectRatio)",
+      "alpha/opacity",
+      "shadow/elevation",
+      "background (cornerRadius -> clip -> border -> bgColor)",
+      "clickable",
+      "padding",
+      "alignment (RowScope/ColumnScope/BoxScope)",
+    ],
+  },
+  "react": {
+    "classOrder": [
+      "layout (flex, flex-col/row)",
+      "sizing (w-*, h-*)",
+      "spacing (p-*, m-*)",
+      "typography (text-*, font-*)",
+      "visual (bg-*, rounded-*, border-*, shadow-*)",
+      "opacity",
+      "overflow",
+      "cursor/interaction",
+    ],
+    "dynamicStyles": "Values not mappable to Tailwind use inline style objects",
+    "note": "React uses Tailwind CSS classes; ordering is less strict",
+  },
+  "swift": {
+    "criticalRules": [
+      "background MUST come after padding (background includes padding area)",
+      "border MUST come after cornerRadius (for rounded border)",
+      "frame MUST come before margins (size before external spacing)",
+      "Image: .resizable() must come first, then .aspectRatio",
+      "Label: .leading alignment added to frame for textAlign to work",
+    ],
+    "order": [
+      "centerAlignment",
+      "edgeAlignment",
+      "padding",
+      "frameConstraints (min/max)",
+      "frameSize (width/height)",
+      "insets/insetHorizontal",
+      "background",
+      "cornerRadius",
+      "border",
+      "margins",
+      "alpha/opacity",
+      "shadow",
+      "clipping",
+      "offset",
+      "visibility (hidden/opacity ternary)",
+      "safeAreaInsets",
+      "disabled",
+      "tag (for TabView)",
+      "tintColor",
+      "onClick/onTapGesture",
+      "lifecycle (onAppear/onDisappear)",
+      "confirmationDialog",
+      "accessibilityIdentifier",
+    ],
+  },
+}
+`;
+
+exports[`derived constants (pinned) > PLATFORM_MAPPING snapshot 1`] = `
+{
+  "contentMode": {
+    "aspectFill": {
+      "kotlin": "ContentScale.Crop",
+      "react": "object-cover",
+      "swift": ".fill",
+    },
+    "aspectFit": {
+      "kotlin": "ContentScale.Fit",
+      "react": "object-contain",
+      "swift": ".fit",
+    },
+    "scaleToFill": {
+      "kotlin": "ContentScale.FillBounds",
+      "react": "object-fill",
+      "swift": ".fill (no aspectRatio)",
+    },
+  },
+  "description": "Cross-platform attribute value conversion mapping",
+  "fontWeight": {
+    "bold": {
+      "kotlin": "FontWeight.Bold",
+      "react": "font-bold",
+      "swift": ".bold",
+    },
+    "light": {
+      "kotlin": "FontWeight.Light",
+      "react": "font-light",
+      "swift": ".light",
+    },
+    "medium": {
+      "kotlin": "FontWeight.Medium",
+      "react": "font-medium",
+      "swift": ".medium",
+    },
+    "semibold": {
+      "kotlin": "FontWeight.SemiBold",
+      "react": "font-semibold",
+      "swift": ".semibold",
+    },
+    "thin": {
+      "kotlin": "FontWeight.Thin",
+      "react": "font-thin",
+      "swift": ".thin",
+    },
+  },
+  "gravity": {
+    "center": {
+      "kotlin": "Alignment.Center",
+      "react": "items-center justify-center",
+      "swift": ".center",
+    },
+    "centerHorizontal": {
+      "kotlin_vertical": "Alignment.CenterHorizontally",
+      "react": "items-center (flex-col)",
+      "swift_vertical": ".center HStack alignment",
+    },
+    "centerVertical": {
+      "kotlin_horizontal": "Alignment.CenterVertically",
+      "react": "items-center (flex-row)",
+      "swift_horizontal": ".center VStack alignment",
+    },
+  },
+  "orientation": {
+    "horizontal": {
+      "kotlin": "Row",
+      "react": "flex flex-row",
+      "swift": "HStack",
+    },
+    "none": {
+      "kotlin": "Box",
+      "react": "relative",
+      "swift": "ZStack",
+    },
+    "vertical": {
+      "kotlin": "Column",
+      "react": "flex flex-col",
+      "swift": "VStack",
+    },
+  },
+  "textAlign": {
+    "center": {
+      "kotlin": "TextAlign.Center",
+      "react": "text-center",
+      "swift": ".center",
+    },
+    "left": {
+      "kotlin": "TextAlign.Start",
+      "react": "text-left",
+      "swift": ".leading",
+    },
+    "right": {
+      "kotlin": "TextAlign.End",
+      "react": "text-right",
+      "swift": ".trailing",
+    },
+  },
+  "types": {
+    "Array": {
+      "kotlin": "List<T>",
+      "react": "T[]",
+      "swift": "[T]",
+    },
+    "Bool": {
+      "kotlin": "Boolean",
+      "react": "boolean",
+      "swift": "Bool",
+    },
+    "Dictionary": {
+      "kotlin": "Map<String, Any>",
+      "react": "Record<string, any>",
+      "swift": "[String: Any]",
+    },
+    "Double": {
+      "kotlin": "Double",
+      "react": "number",
+      "swift": "Double",
+    },
+    "Float": {
+      "kotlin": "Float",
+      "react": "number",
+      "swift": "CGFloat",
+    },
+    "Int": {
+      "kotlin": "Int",
+      "react": "number",
+      "swift": "Int",
+    },
+    "String": {
+      "kotlin": "String",
+      "react": "string",
+      "swift": "String",
+    },
+  },
+  "values": {
+    "matchParent": {
+      "kotlin": "fillMaxWidth() / fillMaxHeight()",
+      "react": "w-full / h-full",
+      "swift": ".infinity (frame maxWidth/maxHeight)",
+    },
+    "wrapContent": {
+      "kotlin": "wrapContentWidth() / wrapContentHeight()",
+      "react": "w-fit / h-fit",
+      "swift": "Default (no frame specified)",
+    },
+  },
+}
+`;