diff --git a/compose/api/compose.klib.api b/compose/api/compose.klib.api index 6d4064d..d46c351 100644 --- a/compose/api/compose.klib.api +++ b/compose/api/compose.klib.api @@ -683,6 +683,8 @@ sealed class app.tinyui.schema/PropSpec { // app.tinyui.schema/PropSpec|null[0] } final object app.tinyui.components.generated/BuiltinSchemas { // app.tinyui.components.generated/BuiltinSchemas|null[0] + final val BackHandler // app.tinyui.components.generated/BuiltinSchemas.BackHandler|{}BackHandler[0] + final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.BackHandler.|(){}[0] final val BottomSheet // app.tinyui.components.generated/BuiltinSchemas.BottomSheet|{}BottomSheet[0] final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.BottomSheet.|(){}[0] final val Box // app.tinyui.components.generated/BuiltinSchemas.Box|{}Box[0] @@ -703,6 +705,8 @@ final object app.tinyui.components.generated/BuiltinSchemas { // app.tinyui.comp final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.LazyColumn.|(){}[0] final val Loading // app.tinyui.components.generated/BuiltinSchemas.Loading|{}Loading[0] final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.Loading.|(){}[0] + final val Menu // app.tinyui.components.generated/BuiltinSchemas.Menu|{}Menu[0] + final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.Menu.|(){}[0] final val Option // app.tinyui.components.generated/BuiltinSchemas.Option|{}Option[0] final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.Option.|(){}[0] final val Popover // app.tinyui.components.generated/BuiltinSchemas.Popover|{}Popover[0] @@ -719,6 +723,8 @@ final object app.tinyui.components.generated/BuiltinSchemas { // app.tinyui.comp final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.Text.|(){}[0] final val TextField // app.tinyui.components.generated/BuiltinSchemas.TextField|{}TextField[0] final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.TextField.|(){}[0] + final val TopAppBar // app.tinyui.components.generated/BuiltinSchemas.TopAppBar|{}TopAppBar[0] + final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.TopAppBar.|(){}[0] final val all // app.tinyui.components.generated/BuiltinSchemas.all|{}all[0] final fun (): kotlin.collections/List // app.tinyui.components.generated/BuiltinSchemas.all.|(){}[0] final val colorTokens // app.tinyui.components.generated/BuiltinSchemas.colorTokens|{}colorTokens[0] diff --git a/compose/build.gradle.kts b/compose/build.gradle.kts index 37019df..9b847ab 100644 --- a/compose/build.gradle.kts +++ b/compose/build.gradle.kts @@ -37,6 +37,8 @@ kotlin { api(libs.compose.runtime.retain) implementation(compose.foundation) implementation(libs.compose.material3) + // BackHandler takes system back through the same dispatcher as the host's navigation + implementation(libs.navigationevent.compose) implementation(libs.kotlinx.coroutines.core) implementation(libs.kotlinx.serialization.json) api(libs.okio) diff --git a/compose/src/commonMain/kotlin/app/tinyui/components/Builtins.kt b/compose/src/commonMain/kotlin/app/tinyui/components/Builtins.kt index 116b19f..cde3279 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/components/Builtins.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/components/Builtins.kt @@ -4,6 +4,7 @@ import androidx.compose.animation.AnimatedVisibility import androidx.compose.animation.core.MutableTransitionState import androidx.compose.animation.fadeIn import androidx.compose.animation.fadeOut +import androidx.compose.foundation.background import androidx.compose.foundation.border import androidx.compose.foundation.clickable import androidx.compose.foundation.horizontalScroll @@ -12,6 +13,8 @@ import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.WindowInsets +import androidx.compose.foundation.layout.windowInsetsPadding import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.padding @@ -29,6 +32,7 @@ import androidx.compose.foundation.text.KeyboardActions import androidx.compose.foundation.text.KeyboardOptions import androidx.compose.material3.Button import androidx.compose.material3.Checkbox +import androidx.compose.material3.DropdownMenu import androidx.compose.material3.DropdownMenuItem import androidx.compose.material3.ExposedDropdownMenuAnchorType import androidx.compose.material3.ExposedDropdownMenuBox @@ -52,8 +56,11 @@ import androidx.compose.material3.SheetValue import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.material3.TextButton +import androidx.compose.material3.TopAppBar +import androidx.compose.material3.TopAppBarDefaults import androidx.compose.material3.rememberBottomSheetState import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.key @@ -102,6 +109,11 @@ import androidx.compose.ui.unit.LayoutDirection import androidx.compose.ui.window.Popup import androidx.compose.ui.window.PopupPositionProvider import androidx.compose.ui.window.PopupProperties +import androidx.navigationevent.DirectNavigationEventInput +import androidx.navigationevent.NavigationEventInfo +import androidx.navigationevent.compose.LocalNavigationEventDispatcherOwner +import androidx.navigationevent.compose.NavigationBackHandler +import androidx.navigationevent.compose.rememberNavigationEventState import kotlinx.coroutines.flow.distinctUntilChanged import kotlinx.serialization.json.buildJsonObject import kotlinx.serialization.json.put @@ -112,6 +124,7 @@ import app.tinyui.schema.Commands import app.tinyui.schema.IconValue import app.tinyui.schema.ComponentRegistry import app.tinyui.schema.NodeScope +import app.tinyui.schema.SizeValue import app.tinyui.schema.Theme /** First batch of built-ins (docs/components.md §3); schemas come from schema/ via `tinyui schema`. */ @@ -194,6 +207,9 @@ fun ComponentRegistry.registerBuiltins(): ComponentRegistry = apply { register(BuiltinSchemas.Loading) { scope -> LoadingComponent(scope) } register(BuiltinSchemas.BottomSheet) { scope -> BottomSheetComponent(scope) } register(BuiltinSchemas.Popover) { scope -> PopoverComponent(scope) } + register(BuiltinSchemas.TopAppBar) { scope -> TopAppBarComponent(scope) } + register(BuiltinSchemas.BackHandler) { scope -> BackHandlerComponent(scope) } + register(BuiltinSchemas.Menu) { scope -> MenuComponent(scope) } register(BuiltinSchemas.Divider) { scope -> HorizontalDivider( modifier = scope.modifier(), @@ -558,6 +574,73 @@ private fun PopoverComponent(scope: NodeScope) { private val POPOVER_GAP = 8.dp +/** + * M3 small top app bar under the status bar; the children are the actions. The status bar padding sits outside the + * common modifier, so `height` sizes the bar itself; inset padding consumed by the host already (a Scaffold) is not + * added again. The back button injects a back into the system dispatcher, as a toolbar calls + * `onBackPressedDispatcher.onBackPressed()`: whatever would take system back takes it (a `BackHandler`, the host's + * navigation). Without a dispatcher there is no system back, so it does nothing, like a `BackHandler`. + */ +@OptIn(ExperimentalMaterial3Api::class) +@Composable +private fun TopAppBarComponent(scope: NodeScope) { + val container = scope.color("background") ?: MaterialTheme.colorScheme.surface + val backIcon = scope.get("backIcon") + val dispatcher = LocalNavigationEventDispatcherOwner.current?.navigationEventDispatcher + val input = remember { DirectNavigationEventInput() } + if (dispatcher != null) { + DisposableEffect(dispatcher, input) { + dispatcher.addInput(input) + onDispose { dispatcher.removeInput(input) } + } + } + Box(Modifier.background(container).windowInsetsPadding(TopAppBarDefaults.windowInsets)) { + TopAppBar( + title = { scope.get("title")?.takeIf { it.isNotEmpty() }?.let { Text(it, maxLines = 1, overflow = TextOverflow.Ellipsis) } }, + navigationIcon = { + if (backIcon != null) { + IconButton(onClick = { if (dispatcher != null) input.backCompleted() }) { + Icon(backIcon.vector, contentDescription = scope.get("backLabel")) + } + } + }, + actions = { scope.Children() }, + // the insets are padded above, outside the height the page gives + windowInsets = WindowInsets(0), + expandedHeight = (scope.get("height") as? SizeValue.Fixed)?.dp ?: TopAppBarDefaults.TopAppBarExpandedHeight, + colors = TopAppBarDefaults.topAppBarColors(containerColor = container), + modifier = scope.modifier(), + ) + } +} + +/** Takes back from the system dispatcher while enabled, which is also where the `TopAppBar` button sends it. */ +@Composable +private fun BackHandlerComponent(scope: NodeScope) { + // without a dispatcher there is no system back to take, from the gesture or the top bar button + if (LocalNavigationEventDispatcherOwner.current == null) return + val enabled = (scope.get("enabled") ?: true) && scope.has("onBack") + NavigationBackHandler(state = rememberNavigationEventState(NavigationEventInfo.None), isBackEnabled = enabled, onBackCompleted = { scope.dispatch("onBack") }) +} + +/** + * M3 dropdown menu anchored to the parent node, like [PopoverComponent]; the items are the `Option` children, read as + * data. `open` is the page's, but a pick or a tap outside closes it here at once and is then reported, as + * [BottomSheetComponent] does: it stays closed until `open` goes false and true again. + */ +@Composable +private fun MenuComponent(scope: NodeScope) { + val open = scope.get("open") == true + var showing by remember { mutableStateOf(false) } + LaunchedEffect(open) { showing = open } + val options = scope.node.children.filter { it.type == "Option" }.map { (it.props["value"] as? String ?: "") to (it.props["text"] as? String ?: "") } + DropdownMenu(expanded = showing, onDismissRequest = { showing = false; if (scope.has("onDismiss")) scope.dispatch("onDismiss") }) { + for ((value, text) in options) { + DropdownMenuItem(text = { Text(text) }, onClick = { showing = false; if (scope.has("onSelect")) scope.dispatch("onSelect", payload("value", value)) }) + } + } +} + /** * Where a popover of [content] size goes: on the [above] / below side of [anchor] with [gap] px between, start edges * aligned. The preferred side wins when it fits, else the other side when that fits, else the roomier side; the result diff --git a/compose/src/commonMain/kotlin/app/tinyui/components/generated/BuiltinSchemas.kt b/compose/src/commonMain/kotlin/app/tinyui/components/generated/BuiltinSchemas.kt index 2f0bd22..7ef964c 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/components/generated/BuiltinSchemas.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/components/generated/BuiltinSchemas.kt @@ -308,7 +308,51 @@ object BuiltinSchemas { layout = false, ) - val all: List = listOf(Column, Row, Box, Text, Button, RadioButton, TextField, LazyColumn, Spacer, Icon, Loading, BottomSheet, Divider, Checkbox, CodeField, Select, Option, Popover) + val TopAppBar = ComponentSchema( + type = "TopAppBar", + props = mapOf( + "title" to PropSpec.Str(default = null, required = false, initial = false), + "backIcon" to PropSpec.IconSpec(required = false, initial = false), + "backLabel" to PropSpec.Str(default = null, required = false, initial = false), + ), + events = mapOf( + ), + commands = mapOf( + ), + children = true, + layout = true, + ) + + val BackHandler = ComponentSchema( + type = "BackHandler", + props = mapOf( + "enabled" to PropSpec.Bool(default = true, required = false, initial = false), + ), + events = mapOf( + "onBack" to emptyMap(), + ), + commands = mapOf( + ), + children = false, + layout = false, + ) + + val Menu = ComponentSchema( + type = "Menu", + props = mapOf( + "open" to PropSpec.Bool(default = null, required = true, initial = false), + ), + events = mapOf( + "onSelect" to mapOf("value" to FieldSpec.Str), + "onDismiss" to emptyMap(), + ), + commands = mapOf( + ), + children = true, + layout = false, + ) + + val all: List = listOf(Column, Row, Box, Text, Button, RadioButton, TextField, LazyColumn, Spacer, Icon, Loading, BottomSheet, Divider, Checkbox, CodeField, Select, Option, Popover, TopAppBar, BackHandler, Menu) /** Theme token names the schema DSL knows; Theme.kt must resolve each (checked by test). */ val colorTokens: Set = setOf("primary", "onPrimary", "primaryContainer", "onPrimaryContainer", "inversePrimary", "secondary", "onSecondary", "secondaryContainer", "onSecondaryContainer", "tertiary", "onTertiary", "tertiaryContainer", "onTertiaryContainer", "background", "onBackground", "surface", "onSurface", "surfaceVariant", "onSurfaceVariant", "surfaceTint", "inverseSurface", "inverseOnSurface", "error", "onError", "errorContainer", "onErrorContainer", "outline", "outlineVariant", "scrim", "surfaceBright", "surfaceDim", "surfaceContainer", "surfaceContainerHigh", "surfaceContainerHighest", "surfaceContainerLow", "surfaceContainerLowest", "primaryFixed", "primaryFixedDim", "onPrimaryFixed", "onPrimaryFixedVariant", "secondaryFixed", "secondaryFixedDim", "onSecondaryFixed", "onSecondaryFixedVariant", "tertiaryFixed", "tertiaryFixedDim", "onTertiaryFixed", "onTertiaryFixedVariant") diff --git a/compose/src/commonMain/kotlin/app/tinyui/generated/RuntimeBytecode.kt b/compose/src/commonMain/kotlin/app/tinyui/generated/RuntimeBytecode.kt index 7d87a6f..657eac3 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/generated/RuntimeBytecode.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/generated/RuntimeBytecode.kt @@ -4,7 +4,7 @@ package app.tinyui.generated /** Base64 of the runtime modules' bytecode, split to fit JVM string constants. */ internal object RuntimeBytecode { val core: Array = arrayOf( - "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", + "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", ) val native: Array = arrayOf( diff --git a/compose/src/commonTest/kotlin/app/tinyui/PageHostTest.kt b/compose/src/commonTest/kotlin/app/tinyui/PageHostTest.kt index 55ab2aa..f2dfb4a 100644 --- a/compose/src/commonTest/kotlin/app/tinyui/PageHostTest.kt +++ b/compose/src/commonTest/kotlin/app/tinyui/PageHostTest.kt @@ -123,7 +123,7 @@ class PageHostTest { val host = host("""{"name":"tinyui"}""") host.start() host.await { host.tree.root.children.isNotEmpty() } - assertEquals("hello tinyui / 18", host.tree.node(1)!!.props["text"]) + assertEquals("hello tinyui / 21", host.tree.node(1)!!.props["text"]) assertNull(host.failure) host.close() } diff --git a/docs/components.md b/docs/components.md index 4c506ac..816c70f 100644 --- a/docs/components.md +++ b/docs/components.md @@ -76,13 +76,16 @@ prop 类型：`string` / `number` / `boolean` / `dp` / `sp` / `color`（`#RRGGBB | `TextField` | `initialText`（initial）、`placeholder`、`singleLine`、`keyboard`、`secure`（缺省跟 `keyboard="password"`）、`error`、`supportingText`、`prefixText`、`trailingIcon`（`icon` 类型）、`imeAction`（done / next）、`maxLength`（0 = 不限） | `onChange{text}`、`onCommit{text}`（IME 动作或失焦）、`onFocusChange{focused}`、`onTrailingClick`、`onPrefixClick` | `setText{text}`、`focus`、`blur` | | | `CodeField` | `length`（1–12，默认 6）、`secure`、`enabled`、`error`、`autofill`（none / oneTimeCode） | `onChange{text}`、`onComplete{text}`（填满最后一格） | `setText{text}`、`focus`、`clear` | | | `Select` | `value`、`placeholder`、`label`、`enabled` | `onSelect{value}` | | 是：`Option` | -| `Option` | `value`（必填）、`text`（必填）；不接受布局 prop | | | | +| `Option` | `value`（必填）、`text`（必填）；不接受布局 prop；`Select` 与 `Menu` 读它 | | | | | `LazyColumn` | `gap` | `onReachEnd`、`onScrollEnd{index}` | `scrollTo{index}` | 是，通常是一个 `` | | `Spacer` | （只有布局 prop） | | | | | `Icon` | `icon`（必填，`icon` 类型）、`size`（dp，默认 24）、`tint`（color，缺省跟随内容色）、`label`（读屏念的名字；紧挨文字的装饰图标不设） | `onClick` | | | | `Loading` | `size`（dp，默认 24）、`color`（缺省 `primary`） | | | | | `BottomSheet` | `open`（必填）；不接受布局 prop | `onDismiss` | | 是：弹层的内容 | | `Popover` | `open`（必填）、`placement`（above / below，默认 below）、`matchAnchorWidth`；不接受布局 prop | `onDismiss`（点了弹层外面） | | 是：卡片的内容 | +| `TopAppBar` | `title`、`backIcon`（`icon` 类型，设了才有返回按钮）、`backLabel`（返回按钮的读屏名） | | | 是：右侧的操作 | +| `BackHandler` | `enabled`（默认 true）；不接受布局 prop | `onBack` | | | +| `Menu` | `open`（必填）；不接受布局 prop | `onSelect{value}`、`onDismiss`（点了菜单外面） | | 是：`Option` | | `Divider` | `thickness`（dp，默认 1）、`color`（默认 `outlineVariant`） | | | | `RadioButton` 的选中态是普通 prop（2026-09-17 加）：它只报点击，选中哪个由 JS 决定——单选组的真值本来就在页面状态里，不属于 ADR-004 的"高频交互状态"。`TextField` 的文本与光标永远在 Kotlin 侧（ADR-004 §3.3）：`setText` 会同时触发 `onChange`。`LazyColumn` 的行就是它的 children，虚拟化只在组合层（ADR-003 §3.6）。 @@ -141,6 +144,35 @@ const [focused, setFocused] = signal(false); 叫 `Popover` 而不叫 `Tooltip`：M3 里最接近的是 rich tooltip，但 M3 的 tooltip 由框架在长按、悬停时自己触发，偏短文字，宽度上限 320dp；这里是页面掌握开关、内容不限的锚定浮层，与 Web（Radix、MUI 的 `Popover` / `Tooltip` 并存）和 iOS 的 popover 同义。`Tooltip` 这个名字留给将来按 M3 语义实现的那个（图标按钮长按出一句说明）。 +`TopAppBar` 是 M3 小顶栏（2026-10-29 加，注册流程触发：每一步的返回、帮助入口与语言切换不一样，放在页面里才能随页面热下发）。children 进右侧操作槽，用现有组件拼（文字按钮、`Row` + `Icon` + `Text` 的语言触发器）；`title` 可选，标题写在内容区大字里的页面不设。它自己让出状态栏：状态栏的内边距在公共 modifier 之外，所以 `height` 是栏本身的高度（缺省 M3 的 64dp），宿主已经消费过的 inset（如 `Scaffold` 的 innerPadding 配 `consumeWindowInsets`）不会再加一遍。底色缺省 `surface`，`background` 同时染状态栏那一段。 + +返回按钮只有设了 `backIcon` 才出现（流程第一页不设），图标照常由页面从包里引入。它**没有自己的事件**：点它就是往系统返回的 dispatcher 注入一次返回，同 Android 工具栏调 `onBackPressedDispatcher.onBackPressed()`——启用着的 `BackHandler` 先收到，没有就到宿主的导航（Navigation 3 弹出栈顶；宿主没接返回时 Android 结束 Activity，与按返回键一样）。要改返回行为只在 `BackHandler` 一处写，顶栏与系统返回是同一条路，优先级只有 dispatcher 那一份。宿主没提供 dispatcher 时没有系统返回，按钮也不起作用，与 `BackHandler` 一致；这种宿主（不是 `ComponentActivity` 的 Android 宿主、测试）要么补上 dispatcher，要么页面自己放一个调 `navigation.pop()` 的按钮。 + +`BackHandler` 是返回的拦截声明（2026-10-29 加）：不画任何东西，`enabled` 时把系统返回（Android 返回键与预测性返回手势、iOS 侧滑，经 `navigationevent` 的 dispatcher，与 Navigation 3 同一个；顶栏返回按钮也注入到这里）交给 `onBack`，页面在里面决定做什么，比如先确认再 `navigation.pop()`。按 ADR-002，拦不拦必须作为 prop 预先声明，宿主没法在手势发生时同步问 JS。多个启用着的以最后组合的为准（dispatcher 的规则）；打开着的 `BottomSheet` 先于它收到返回（M3 弹层自带）。宿主没提供 dispatcher 时它不起作用。 + +```tsx +import chevronLeft from "../icons/chevron-left.svg"; +const [leaving, setLeaving] = signal(false); + +