← GuidesWriting layoutsLayout JSON is the single biggest file family you author in a JsonUI project, and a handful of idioms make it much easier to read. The same JSON ships to iOS (SwiftUI / UIKit), Android (Compose / XML), and Web (React) — each platform's generator projects it into native code, but the vocabulary you author in is one. This guide walks the cross-platform essentials: how styles get shared, how sub-layouts are reused via include, how Collection cells and sections work, the @{binding} and visibility story, and the pitfalls every first-time layout author trips over.~18 min read
1. Orient yourselfFour locations matter when you author a layout. The primary layout JSON you edit; the cells/ directory with the reusable row layouts a Collection points at; the styles/ directory with shareable attribute bundles; and strings.json with the translations that layouts reference by key. All four live under docs/screens/ — the project root is where jui build reads from, and each platform gets a copy distributed to its own tree.
project tree
docs/ screens/ json/ <name>.spec.json ← authored screen_spec layouts/ <name>.json ← authored layout JSON (source of truth) cells/ <cell_name>.json ← reusable row layouts for Collections Resources/ strings.json ← en / ja translations, keyed by <namespace>_<key> styles/ <style_name>.json ← shared attribute bundles2. Style definitionsA style is a plain JSON file under docs/screens/styles/ that carries component attributes you want to share — colors, paddings, font weights, rounded corners — without copying them into every Label or Button. Attach it with the 'style' attribute by file name (no path, no extension). At build time each platform's generator deep-merges the style into the component; on any attribute collision, the value you wrote inline on the component wins, so you can override a shared style on one specific screen without editing the style file. The rule holds whether the target is React, SwiftUI / UIKit, or Compose / XML.• Style files are flat — there is no 'extends' or 'parent' mechanism. If you want composed behaviour, wrap the component in a View that carries the outer style and put the inner style on the child.• If the style file declares a 'type' and the component also does, the component's type wins. This lets a style file name itself a Button without preventing a View from picking it up (the type is treated as a hint, not a constraint).
docs/screens/styles/primary_button.json
{ "type": "Button", "width": "wrapContent", "height": "wrapContent", "paddings": [12, 24, 12, 24], "background": "accent", "fontColor": "accent_ink", "fontSize": 16, "fontWeight": "semibold", "cornerRadius": 10, "tapBackground": "accent_hover"}docs/screens/layouts/home.json (excerpt)
{ "type": "Button", "id": "home_hero_cta_primary", "style": "primary_button", "text": "hero_cta_primary", "onClick": "@{onHeroInstallTap}"}3. Include (sub-layout reuse)When a piece of UI repeats across screens without being data-driven — a back button, a compact brand lockup, a footer disclaimer — write it once under layouts/ and reference it via the 'include' attribute. Each platform's generator emits a reusable unit in its native idiom — a React component on Web, a SwiftUI View struct (or a UIView subclass in UIKit) on iOS, a Composable function (or an Android View) on Android — named after the file (path/to/main_menu → MainMenu). An include is an inline expansion: the included layout reads the including screen's data, and the screen's ViewModel owns it. With an 'id' on the include, the included layout's data names are prefixed by it (id 'side' + 'title' → 'sideTitle'). The include's object maps — 'shared_data', then 'data' — are laid over that data: each key is a name the included layout binds, each value a literal or a binding in the including screen. Web follows this too. This is distinct from Collection cells, which multiply one cell layout across rows driven by a data array; include is for single-insertion reuse.• An included layout may include others, and every generator and runtime expands the nesting all the way down; a cycle is an error. Prefixes compose: an outer include with id 'side' around an inner one with id 'card' makes the inner 'title' read 'sideCardTitle'. An inner include's map values are bindings in the outer partial's scope, applied after the outer map: with the outer map {title: "@{pageTitle}"} and the inner {deep: "@{title}"}, the inner @{deep} reads the screen's @{pageTitle}. An inner include with no map only gets the prefix and reads the screen's data as it is.• On web, an included layout's root takes its place in the including container as a direct child would, as on iOS and Android: an overlay's placement (alignLeft + alignBottom), the row a matchParent height is in, distribution, and the wrapContent cap. Every included component takes a jsonuiPlace prop and src/generated/includePlace.js (or .ts) is generated; a call site passes jsonuiPlace={{ add, drop }} only where the placement differs: here an alignLeft + alignBottom root in an overlay got add "absolute bottom-0 left-0", a matchParent-height root in a row got add "self-stretch" and drop "flex-1 min-w-0 min-h-0", and the same include alone in a container got nothing. A constraint on the root against a sibling of the include (alignTopOfView, alignLeftView, alignCenterVerticalView and the rest) applies on web too: the container runs the same relative-position pass for the include's root as for a direct child (here for alignTopOfView: "anchor"). A constraint between siblings inside the included layout, under an include with an id, works in the generated code of iOS, Android and web: the target gets the include's prefix as the ids do, so with id 'side' a pin at alignTopOfView 'anchor' points at 'sideAnchor'. The Dynamic runtimes, which draw the JSON at run time, follow too (jsonui-cli's word, the runtimes not run here). Read from the JSX that jui build wrote on a scratch web project and from the include expansion of sjui and kjui, no app compiled; where the boxes land is jsonui-cli's measurement. This site has no include, so its pages do not move.• On web, the ids a generator derives from an element's id take the include's prefix as well: a Segment's or TabView's tabs (`<id>_tab_<n>`), a Collection's cells (`<id>_item_<n>`) and a custom component's id. Here an include with id 'hero' around a Collection 'cards' and a Segment 'tabs' gave heroCards_item_0 and heroTabs_tab_1, the same partial under id 'side' gave sideCards_item_0, and a Collection on the screen itself kept cards_item_0. A custom component follows only when its converter writes the id with `id_attr = build_id_attr`, which `jui g converter` writes; a converter that writes the id otherwise keeps the id as written, and jui build names it in a WARN [converter-id] line (/guides/custom-components). Read from the TSX jui build wrote on a scratch web project, and the ids worked out by the generated includeId helper, no page rendered; that iOS and Android spell these ids this way is jsonui-cli's word. This site has no include, so no id here moves.
parent layout — include usage
{ "type": "View", "orientation": "vertical", "child": [ { "include": "common/back_button", "data": { "label": "< Back", "onBack": "@{onBack}" } }, { "type": "Label", "text": "title" } ]}docs/screens/layouts/common/back_button.json
{ "type": "Button", "width": "wrapContent", "height": "wrapContent", "paddings": [8, 12, 8, 12], "fontColor": "ink_subtle", "text": "@{label}", "onClick": "@{onBack}"}4. Collection basics (single cell type)A Collection renders a list or grid of cells driven by a data source. Three attributes are non-negotiable: items binds a CollectionDataSource from the ViewModel, cellIdProperty names the row field used as stable row identity (the React key on Web, SwiftUI's Identifiable conformance on iOS, the RecyclerView ViewHolder diff key on Android — without it identity falls back to the array index, which breaks diffing on reorders on every platform), and sections declares the cell layout path for each section. Everything else tunes the visual form — orientation, columnCount, lineSpacing / itemSpacing, lazy, scrollEnabled.Layout attributes worth knowing• orientation — 'vertical' (default) stacks rows top-to-bottom; 'horizontal' lines cells up in a row (common for chip strips and tab bars).• columnCount — integer > 1 turns the Collection into a grid of that many columns.• A grid (`columns` of 2 or more) whose cell's root is `height: matchParent`: Android draws each row as tall as its tallest cell, as iOS does, with `lazy: none` and on the lazy grid alike. A cell holding an image whose picture decides its height (an Image or NetworkImage without a numeric height) is left out on both and drawn its own height, because Compose's intrinsic measure answers with the picture's own pixel height; iOS aligns it. A flow is aligned on neither platform. Read from kjui's CollectionComponent with `columns: 2`: for a matchParent root it writes the row as `Row(modifier = Modifier.fillMaxWidth().height(IntrinsicSize.Min))` and each cell's box with `.fillMaxHeight()`, the lazy grid as one full-width item per row; a wrapContent root or an image cell gets the plain row. A cell that holds a SubcomposeLayout is left out, by kjui's own rule. Dynamic does the same; the drawing, and the flow, are jsonui-cli's word.• lineSpacing / itemSpacing — gap between rows (vertical) and between cells in a row (horizontal). You can also set spacing as a single-value fallback for both.• lazy — the Collection's container mode: `'lazy'` (default; virtualized, scrolls itself), `'eager'` (every row rendered inside a scroll container) or `'none'` (no scroll container of its own — the parent must scroll; use it inside a page-level Scroll, the common case). The value is a string or a binding; a boolean is not accepted, and the build warns `Attribute 'lazy' in 'Collection' expects string or binding, got boolean` (measured). For `layout: "flow"` the rule is: with lazy in effect (`'lazy'` or `'eager'`) the flow Collection scrolls vertically inside its own bounds; with `'none'` it only wraps.• scrollEnabled — false disables the Collection's own scroll gesture entirely; useful when the Collection should size to its content exactly and not intercept the parent's scroll (every platform honours this the same way).On the cell side, the layout starts with a 'data' block that declares the shape of the row the parent will pass in. Each platform's generator reads this block and emits a typed wrapper in its native language — a TypeScript interface on Web, a Swift struct on iOS, a Kotlin data class on Android — all named `<Cell>Data` with matching field names and types. The cell's bindings and the ViewModel's row construction stay type-aligned against that shared shape. You populate the data in the ViewModel and call CollectionDataSource.setCells(sectionIndex, rows); each platform then renders one cell per row using cellIdProperty for identity.
home.json (Collection excerpt)
{ "type": "Collection", "id": "home_agents_collection", "width": "matchParent", "height": "wrapContent", "topMargin": 16, "orientation": "vertical", "columnCount": 1, "lineSpacing": 12, "itemSpacing": 12, "lazy": false, "scrollEnabled": false, "items": "@{agents}", "cellIdProperty": "id", "sections": [ { "cell": "cells/agent_row" } ]}cells/agent_row.json (structure)
{ "type": "View", "orientation": "vertical", "child": [ { "data": [ { "name": "nameKey", "class": "String" }, { "name": "roleKey", "class": "String" }, { "name": "whenToUseKey", "class": "String" } ] }, { "type": "Label", "text": "@{nameKey}", "fontSize": 16 }, { "type": "Label", "text": "@{roleKey}", "fontSize": 11 }, { "type": "Label", "text": "@{whenToUseKey}", "fontSize": 13 } ]}AgentRowData — one shape, three platforms
// Web — src/generated/data/AgentRowData.ts (@generated)export interface AgentRowData { nameKey?: string; roleKey?: string; whenToUseKey?: string; cellId?: string;} // iOS — AgentRowData.swift (@generated — equivalent)struct AgentRowData { let nameKey: String? let roleKey: String? let whenToUseKey: String? let cellId: String?} // Android — AgentRowData.kt (@generated — equivalent)data class AgentRowData( val nameKey: String? = null, val roleKey: String? = null, val whenToUseKey: String? = null, val cellId: String? = null,)5. Collection multi-section (mixed cell types)One section = one cell type. None of the platform generators pick the cell layout dynamically per row. So to render, say, a featured card followed by a list of plain rows on the same Collection, declare two sections with their own cell: path, and have the ViewModel write to each section's cells array independently. The same applies to chat logs (user cell vs assistant cell), or a reference page that shows a summary row then a list of attribute rows. The rule is uniform across Web, iOS, and Android.• Tip: when a Collection has multiple sections, the item row that ships from the ViewModel must already be partitioned by section — Section 0 gets rows that fit its cell, Section 1 gets rows that fit its. Do not try to mix types in one section's cells array.• A cell's id counts across the sections. The cell ids a Collection with an id writes, `<id>_item_<n>`, number the cells across the drawn sections in order: the first section's cells are 0, 1, …, and a later section's follow on after them. Headers, footers and a grid's fillers are not counted, so n is the n an `Int` scrollTo names and a paging Collection's address. Two sections therefore never share an `_item_0` (/guides/testing). Read from rjui's converter on a Collection 'stops' with a cell section, a header-only section and a cell section: it writes `stops_item_${cellIndex}` for the first and starts the third at the first section's cell count. iOS and Android, generated and Dynamic, are jsonui-cli's word.Letting the user reorder rowsA vertical, single-column Collection can let the user reorder its rows on iOS, Android and web: long-press a row, drag it up or down within its section, and release it. Set reorderable to true, or to a binding that turns it on only while the value is true (an edit mode, say), and name a handler in onReorder. The Collection does not change the data itself: the ViewModel moves the row in its own list, and the rows are drawn from that list as usual. A grid, a horizontal Collection and a flow layout are drawn as before and do not reorder.• onReorder — called once per release with (section, from, to). to is the row's index after the move, so moving the first of three rows to the end gives (0, 0, 2). Rows move only within their own section, and releasing a row where it started does not call the handler. SwiftUI's onMove counts its destination before the row is taken out (3 in that example); the library converts it, so the handler gets the same to on every platform.• reorderHandle — the id of an element inside the cell, such as a grip at the row's right edge. Only a long press on that element picks the row up, and the rest of the row keeps its taps. Without it, a long press anywhere on the row picks it up.• reorderLockedProperty — a key of the cell data. A row whose value for that key is true cannot be picked up, and no other row can be moved past it, so a locked row splits the list into stretches that are reordered separately. Section headers and footers are not rows and never move.• reorderFixedProperty — a key of the cell data for a row that stays put but is not a barrier, such as a finished task. The row cannot be picked up and has no move-up or move-down action, but other rows are moved past it and count it in their to. A Collection with a reorderHandle treats a row whose handle is not drawn the same way. A row that is both locked and fixed is locked.• A dragged row passes another when the dragged row's centre goes beyond that row's near edge, as iOS 27's own reordering does. With rows 60 high, a drag of 31 passes the next row.• onReorderStart (section, index) and onReorderEnd (section): start is called when a row is picked up, and end once when that drag is over, after onReorder when the row moved. A ViewModel that rebuilds its rows on a timer can hold the rebuild between the two. A drag let go where it started or outside the Collection calls start and end with no onReorder between. Move up and move down call start, onReorder and end in one go.• If the rows change while a row is dragged, so that the ids differ in number or order or the locked or fixed rows differ, the drag is cancelled when the row is let go: the order goes back and onReorder is not called, because its indexes would name other rows. A change to text or colour alone is not a change, and the drag commits.• Where a release counts: anywhere inside the Collection's frame, header and footer included. Released over the header, the row goes to the first place it may take; over the footer, to the last. Released outside the frame, the move is cancelled and onReorder is not called.• Screen readers and keyboards: on the web every row gets “Move up” and “Move down” buttons (“上へ移動” / “下へ移動” on a Japanese page), hidden until they have focus, which call onReorder with to = from − 1 or from + 1 and announce the new position. A button is left out where that move is not allowed: up on the first row, down on the last, into or across a locked row, and on a fixed row. The words come from the app's strings.json when it has the keys jsonui.reorder_move_up, jsonui.reorder_move_down and jsonui.reorder_moved_to (the place in {count}), in the page's language, so any language the app translates is read out; without them the helper falls back to Japanese or English. jsonui-cli says VoiceOver on iOS and TalkBack on Android offer the same two actions.• Set cellIdProperty. Without it the rows are keyed by position, and while a row moves the wrong one can be shown for a moment. The layout validator warns about a reorderable Collection (true or a binding) that has no cellIdProperty. It is a warning, not an error, so the build still finishes.• iOS has two ways to drag. A Collection drawn as a stack (with sections and no listStyle, or lazy: 'none') uses SwiftUI's own reorderable / reorderContainer from iOS 27 and the library's drag below that. For such a Collection jui build prints one line, INFO [ios-reorder], when the app's minimum iOS is below 27 or cannot be read. It reads that minimum from platforms.ios.minimumOS in jui.config.json, then the Xcode project's IPHONEOS_DEPLOYMENT_TARGET, then Package.swift. The line is information, not a warning. A Collection with a reorderHandle or a reorderLockedProperty uses the library's drag on every iOS version, because SwiftUI's reorderable has no handle-only form and moves a locked row too. A Collection that declares onReorderStart or onReorderEnd also uses the library's drag on every iOS version, since SwiftUI's container has no pick-up or let-go hook. A Collection drawn as a List (a listStyle, or no sections, without lazy: 'none') uses onMove. None of these gets the line. A List that declares the callbacks gets INFO [ios-reorder-callbacks] instead: onMove has no pick-up, so start and end come together when the row lands.• On the web the generator wraps the rows in a helper it writes to src/generated only when a layout uses reorderable. The helper follows the pointer rather than HTML drag and drop, so it works with touch as well as a mouse. This site uses no reorderable Collection, so its generated files carry no such helper.Measured for this page: the web output for the Collection above; the web helper's release and move-up/move-down rules, run in Node on five rows with a locked middle row, which agree with the rule jsonui-cli shares across the platforms; the iOS INFO check, called on variants of that Collection; and the layout validator. No row was dragged in a browser or on a device here. How the drag looks is jsonui-cli's conformance measurement. Also measured: the converter passes onReorderStart, onReorderEnd and the fixed rows; the helper's drag, release, move-up/move-down and changed-rows rules, run in Node on five rows 60 high (fixed row 2 passed by row 1, which lands at 3; a locked row 2 stops it at 1); and the iOS INFO check with and without the callbacks.
Collection with two cell types
{ "type": "Collection", "id": "reference_index_collection", "width": "matchParent", "height": "wrapContent", "orientation": "vertical", "items": "@{referenceSections}", "cellIdProperty": "id", "sections": [ { "cell": "cells/reference_featured_card" }, { "cell": "cells/reference_overview_row" } ]}A reorderable Collection
{ "type": "Collection", "id": "task_list", "width": "matchParent", "height": "wrapContent", "items": "@{tasks}", "cellIdProperty": "id", "reorderable": "@{isEditing}", "onReorder": "@{onMoveTask}", "reorderHandle": "drag_handle", "reorderLockedProperty": "isPinned", "sections": [ { "cell": "cells/task_row" } ]}6. Binding and visibilityAnywhere in a layout a string attribute value is one whole @{name}, each platform's generator treats it as a binding that resolves at render time from the ViewModel's data. Text around a binding is a different thing: it is warned as binding-mixed-text — assemble the string in the ViewModel and bind it whole. The same @{name} syntax works identically on iOS, Android, and Web — each generator wires it to the platform's native observable story (Combine publishers or SwiftUI @State on iOS, StateFlow or Compose State on Android, React state hooks on Web). Beyond text, the most commonly bound attribute is visibility, which accepts three values with different layout-tree consequences. Knowing which one you want prevents a whole class of layout bugs.• 'visible' — the default; the element renders normally and occupies its space.• 'invisible' — the element is not painted but still occupies its space, and it disappears from the accessibility tree (useful when you want a placeholder to preserve alignment). Each platform maps this to its own mechanism — visibility: hidden on Web, opacity 0 + accessibility-hidden on SwiftUI, alpha 0 with cleared semantics on Compose — so the consequence is the same everywhere. On iOS that reaches UI tests too: XCUITest does not find the element either. `hidden: true` is the boolean shorthand for exactly this state (it does NOT collapse the space).• 'gone' — the element leaves the layout tree entirely and its space collapses. Each platform realises this differently — a conditional render on Web, an `if` wrap inside the SwiftUI body, View.GONE in Android XML, or an `if` around the Composable — but the intent is uniform: the neighbours close the gap.
binding + visibility
{ "type": "Label", "id": "form_error", "visibility": "@{errorVisibility}", "fontColor": "#B91C1C", "text": "@{errorMessage}"}// errorVisibility: "visible" | "invisible" | "gone"7. Common pitfallsA short list of layout surprises that catch almost everyone once. None of these are bugs in the generators; they are direct consequences of how the cross-platform attribute vocabulary maps onto each platform's layout model (flexbox on Web, stack layouts on SwiftUI, Row / Column with weights on Android Compose). Knowing them is the fix.• weight vs matchParent inside a horizontal parent: in a horizontal View, matchParent on the cross-axis (height) means 'fill the row's height', not 'take all the remaining horizontal space'. If you want a child to claim unused main-axis space among its siblings, write weight: 1. The rule is the same on every platform — flex-row on Web, HStack on SwiftUI, Row on Android Compose: matchParent is cross-axis fill, weight is main-axis growth. When the weights differ (3:2) and the row's height is wrapContent or not given, the row is as tall as its tallest child, on iOS (SwiftJsonUI's SwiftUI weighted stack) as on Android and web. A vertical stack with differing weights is likewise as wide as its widest child. A matchParent or fixed cross axis, and equal weights, are not affected. Read from WeightedStackView in SwiftJsonUI, nothing drawn here; that the drawn boxes match Android and web is jsonui-cli's conformance measurement.• topMargin is orientation-agnostic: on every platform it always means 'space above this element', regardless of whether the parent flow is horizontal or vertical. In a horizontal View that adds space above the element, not between it and its left neighbour. Use leftMargin (or the parent's itemSpacing) for sibling gaps in a row.• 'gone' drops the element from the layout tree on every platform, 'invisible' keeps it: a sibling that depends on a conditional element's space preservation must read 'invisible', not 'gone'. Choosing 'gone' when you wanted 'invisible' quietly collapses alignment; choosing 'invisible' when you wanted 'gone' leaves an empty gap. The same trap exists with the `hidden` boolean: it is the shorthand for 'invisible', so it never collapses the space — use visibility 'gone' for that. The semantics are uniform across Web (conditional render vs visibility:hidden), iOS (if-wrapped body vs opacity 0), and Android (dropped Composable vs alpha 0). On iOS this holds for a child placed by alignLeft, alignBottom and the like too, whether the value is written as a literal (or arrives as one through an include's data) or as a binding such as @{v}. Read from the generated SwiftUI; the drawing itself is jsonui-cli's measurement.• _overlay is internal: you may see it surface in emitted code (the @generated React tree, for example) but you never write it by hand. When you need absolute or z-ordered positioning, use zIndex as a number — each platform's generator maps it to its native z-order mechanism (CSS z-index on Web, .zIndex() modifier on SwiftUI, elevation / zIndex on Android).• In a View with no orientation, once one child is constrained against a sibling (alignTopOfView and the like), the children without a constraint overlap in the container on web, as on iOS and Android, so their own alignBottom, centerVertical, centerInParent or matchParent height places them in the container's full height. Here, beside an anchor and a child at alignTopOfView, an alignBottom child sits in the container's one cell aligned to its end. Read from the JSX jui build wrote on a scratch web project; the drawing is jsonui-cli's measurement. This site has no sibling constraint in its layouts, so its pages do not move.• A 'gone' element has no size and no position, so a constraint that names it (alignTopOfView: 'anchor' with the anchor gone) does not apply, and the element is placed as if it had no constraint on that axis. This rule is written into the attribute declaration, and web and the Dynamic runtimes follow it. Drawn here in headless Chromium from what jui build wrote, in a 100×100 frame with a 10×10 anchor at 50,50: with the anchor visible, a 20×20 box at alignTopOfView sat at 0,30; with the anchor gone it sat at 0,0. On iOS the generated code passes isGone to a relatively placed child that has a visibility (read from the generated SwiftUI).• A margin on an axis the element is centered on (centerInParent, centerVertical, centerHorizontal) does not move it: it only adds to the space the element takes, on web and in the Dynamic runtimes as on iOS. Drawn here: a 20×20 box at centerInParent in a 100×100 frame sat at 40,40 with leftMargin 20 or topMargin 20, the same as with no margin. A margin toward an edge the element is aligned to moves it (alignLeft with leftMargin 20: 20,0). That the margin counts in the size, and the same rule in Android's generated code and iOS's overlay, are jsonui-cli's word; this site builds web only.• `jui build` checks the target of every relative constraint. A target that is not a sibling of the element prints an ERROR [relative-constraints] line naming each one: its own container ('its container, not a sibling'), an element inside a sibling ('inside the sibling ..., not a sibling'), the element itself, or an id no element of the layout has. On Android such a constraint generates Compose that does not compile, and on iOS and web it is dropped or lands elsewhere. The build goes on, then exits 1 (0 with --allow-partial); a sibling target is not named. When iOS is a platform, `jui build` also prints INFO [ios-tap] for a tappable element with a fixed side under 26 pt (here a 20×20 Button; a 44×44 one was not named): a larger element behind it can take its taps on iOS. Nothing needs changing; suspect it when it does not respond. Measured with jui build on a scratch project; the exit status from a web-only build, and the 26 pt figure is jsonui-cli's rough guide that varies by device and OS.• Duplicate layout basenames. Layout file basenames must be unique across the whole project: Data models and generated components are emitted flat per basename on every platform (SummaryRowData.swift / .kt / .ts), so `sales/summary_row.json` and `dashboard/summary_row.json` collide. `jui build` detects duplicates and aborts with the full pair list — fix by renaming one file (e.g. `sales_summary_row.json`) and updating its references. Cell layouts shared by several screens are the usual place this bites.• SelectBox draws alike on iOS, Android and web: by default 0 above and below, 12 at the sides, a 16 × 16 arrow 8 from the text, and the height of its content when height is not given. A side is set by the default, then padding, then paddings, then that side's own attribute. On the web a declared padding replaces the built-in one. The web arrow is an icon drawn beside the select in the text colour, so it follows fontColor and a dark theme. caretAttributes.tintColor paints the default arrow, and an image given as caretAttributes.src keeps its own colours. caretAttributes.rightMargin moves the arrow (rjui's SelectBoxConverter: paddingRight 4 puts the arrow 4 from the edge with 28 of padding; tintColor #FF0000 colours the icon; iOS and Android drawing is jsonui-cli's word).
Keep reading
Developer menuThe DEBUG-only container that puts Dynamic Mode behind a long-press and hot-reloads the JSON you just authored. iOS + Android./guides/developer-menu
Writing your first specSpec drives the Data shape that layouts bind to./guides/writing-your-first-spec