From 6b6cddae4a65a03f727c72ddb115d04267bbf20e Mon Sep 17 00:00:00 2001 From: HarlonWang <81813780@qq.com> Date: Mon, 12 Oct 2026 11:33:54 +0800 Subject: [PATCH 1/7] =?UTF-8?q?feat:=20=E5=89=AA=E8=B4=B4=E6=9D=BF?= =?UTF-8?q?=E5=86=99=E5=85=A5=E3=80=81BottomSheet=E3=80=81=E6=8C=89?= =?UTF-8?q?=E6=97=B6=E5=8C=BA=E6=A0=BC=E5=BC=8F=E5=8C=96=E6=97=A5=E6=9C=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PingPong 交易详情页触发 roadmap D 组三项"等第一个需要的页面"： - clipboard.setText：J3，框架用 Compose Clipboard 实现，只写不读（读会触发 iOS 粘贴提示）， 宿主不接管；页面不在组合里时 E_UNSUPPORTED - BottomSheet 内置组件：M3 ModalBottomSheet，open 由页面掌握，置 false 播完收起动画； 用户下滑 / 点遮罩 / 返回后报 onDismiss；只有展开一档；不接受布局 prop - TinyUIHost.timeZone（IANA，缺省系统时区）+ J2 i18n.timeZone / i18n.zoneOffset + JS i18n.timeZone() / i18n.formatDate(ms, pattern)：原生只给那一刻的偏移（含夏令时）， 纯数字的 Unicode 模式在 JS 里格式化；时区变化经 K5 i18n.timeZone 重算绑定； 平台不认识的时区按系统时区显示并上报一次 sample 的 features 页加了三项演示；docs 同步 native-api §1/§2/§8/§15、components §3、roadmap D 组。 Co-Authored-By: Claude Opus 5.5 --- compose/api/compose.klib.api | 6 ++- .../kotlin/app/tinyui/Platform.android.kt | 11 +++++ .../kotlin/app/tinyui/HostInterfaces.kt | 13 +++++- .../commonMain/kotlin/app/tinyui/PageHost.kt | 24 ++++++++++- .../kotlin/app/tinyui/TinyUIHost.kt | 11 +++++ .../kotlin/app/tinyui/TinyUIPage.kt | 3 ++ .../kotlin/app/tinyui/components/Builtins.kt | 32 ++++++++++++++ .../components/generated/BuiltinSchemas.kt | 16 ++++++- .../app/tinyui/generated/RuntimeBytecode.kt | 4 +- .../kotlin/app/tinyui/PageHostTest.kt | 41 ++++++++++++++++-- .../iosMain/kotlin/app/tinyui/Platform.ios.kt | 15 +++++++ docs/components.md | 11 +++++ docs/native-api.md | 23 +++++++++- docs/roadmap.md | 6 +-- packages/core/src/generated/components.ts | 13 ++++++ packages/native/src/clipboard.ts | 7 +++ packages/native/src/i18n.ts | 43 ++++++++++++++++++- packages/native/src/index.ts | 1 + packages/native/test/native.test.ts | 37 +++++++++++++--- sample/js-extra/i18n/en.json | 9 +++- sample/js-extra/i18n/zh.json | 9 +++- sample/js-extra/src/generated/i18n.ts | 7 +++ sample/js-extra/src/pages/features.tsx | 24 ++++++++++- schema/components/bottom-sheet.ts | 12 ++++++ schema/index.ts | 3 +- 25 files changed, 355 insertions(+), 26 deletions(-) create mode 100644 packages/native/src/clipboard.ts create mode 100644 schema/components/bottom-sheet.ts diff --git a/compose/api/compose.klib.api b/compose/api/compose.klib.api index 91a23eb..75ee730 100644 --- a/compose/api/compose.klib.api +++ b/compose/api/compose.klib.api @@ -552,7 +552,7 @@ final class app.tinyui/StoreValue { // app.tinyui/StoreValue|null[0] } final class app.tinyui/TinyUIHost { // app.tinyui/TinyUIHost|null[0] - constructor (app.tinyui.schema/ComponentRegistry, app.tinyui/PageSink, app.tinyui/CapabilityRegistry = ..., kotlin.collections/Map = ..., kotlinx.coroutines.flow/StateFlow? = ..., app.tinyui/SessionSource? = ..., app.tinyui/AnalyticsSink? = ..., app.tinyui/LinkOpener? = ..., app.tinyui/Navigator = ..., okio/Path? = ...) // app.tinyui/TinyUIHost.|(app.tinyui.schema.ComponentRegistry;app.tinyui.PageSink;app.tinyui.CapabilityRegistry;kotlin.collections.Map;kotlinx.coroutines.flow.StateFlow?;app.tinyui.SessionSource?;app.tinyui.AnalyticsSink?;app.tinyui.LinkOpener?;app.tinyui.Navigator;okio.Path?){}[0] + constructor (app.tinyui.schema/ComponentRegistry, app.tinyui/PageSink, app.tinyui/CapabilityRegistry = ..., kotlin.collections/Map = ..., kotlinx.coroutines.flow/StateFlow? = ..., kotlinx.coroutines.flow/StateFlow? = ..., app.tinyui/SessionSource? = ..., app.tinyui/AnalyticsSink? = ..., app.tinyui/LinkOpener? = ..., app.tinyui/Navigator = ..., okio/Path? = ...) // app.tinyui/TinyUIHost.|(app.tinyui.schema.ComponentRegistry;app.tinyui.PageSink;app.tinyui.CapabilityRegistry;kotlin.collections.Map;kotlinx.coroutines.flow.StateFlow?;kotlinx.coroutines.flow.StateFlow?;app.tinyui.SessionSource?;app.tinyui.AnalyticsSink?;app.tinyui.LinkOpener?;app.tinyui.Navigator;okio.Path?){}[0] final val analytics // app.tinyui/TinyUIHost.analytics|{}analytics[0] final fun (): app.tinyui/AnalyticsSink? // app.tinyui/TinyUIHost.analytics.|(){}[0] @@ -580,6 +580,8 @@ final class app.tinyui/TinyUIHost { // app.tinyui/TinyUIHost|null[0] final fun (): app.tinyui/PageSink // app.tinyui/TinyUIHost.sink.|(){}[0] final val store // app.tinyui/TinyUIHost.store|{}store[0] final fun (): app.tinyui/Store // app.tinyui/TinyUIHost.store.|(){}[0] + final val timeZone // app.tinyui/TinyUIHost.timeZone|{}timeZone[0] + final fun (): kotlinx.coroutines.flow/StateFlow? // app.tinyui/TinyUIHost.timeZone.|(){}[0] } sealed class app.tinyui.schema/PropSpec { // app.tinyui.schema/PropSpec|null[0] @@ -679,6 +681,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 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] final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.Box.|(){}[0] final val Button // app.tinyui.components.generated/BuiltinSchemas.Button|{}Button[0] diff --git a/compose/src/androidMain/kotlin/app/tinyui/Platform.android.kt b/compose/src/androidMain/kotlin/app/tinyui/Platform.android.kt index 4e05639..4cb9935 100644 --- a/compose/src/androidMain/kotlin/app/tinyui/Platform.android.kt +++ b/compose/src/androidMain/kotlin/app/tinyui/Platform.android.kt @@ -1,9 +1,12 @@ package app.tinyui +import android.content.ClipData import android.os.Build +import androidx.compose.ui.platform.ClipEntry import io.ktor.client.HttpClient import io.ktor.client.engine.okhttp.OkHttp import java.util.Locale +import java.util.TimeZone import okio.FileSystem internal actual fun platformInfo(): Map = mapOf( @@ -14,6 +17,14 @@ internal actual fun platformInfo(): Map = mapOf( internal actual fun systemLocale(): String = Locale.getDefault().toLanguageTag() +internal actual fun systemTimeZone(): String = TimeZone.getDefault().id + +// getTimeZone answers GMT for an id it does not know rather than failing +internal actual fun zoneOffsetMinutes(zone: String, epochMs: Long): Int? = + TimeZone.getTimeZone(zone).takeIf { it.id == zone }?.getOffset(epochMs)?.div(60_000) + +internal actual fun plainTextClipEntry(text: String): ClipEntry = ClipEntry(ClipData.newPlainText(null, text)) + internal actual val platformFileSystem: FileSystem = FileSystem.SYSTEM internal actual fun defaultHttpClient(): HttpClient = HttpClient(OkHttp) diff --git a/compose/src/commonMain/kotlin/app/tinyui/HostInterfaces.kt b/compose/src/commonMain/kotlin/app/tinyui/HostInterfaces.kt index 8e0d256..81cf32d 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/HostInterfaces.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/HostInterfaces.kt @@ -1,5 +1,6 @@ package app.tinyui +import androidx.compose.ui.platform.ClipEntry import kotlin.concurrent.atomics.AtomicReference import kotlin.concurrent.atomics.ExperimentalAtomicApi import kotlin.concurrent.atomics.update @@ -110,9 +111,9 @@ class EventBus { /** Names the framework dispatches itself (J2 / J3 / J4); a host capability may not take one. */ internal val FrameworkNames = setOf( "device.info", "store.get", "store.set", "store.subscribe", "storage.get", "storage.set", "storage.remove", "storage.clear", - "i18n.t", "i18n.locale", "i18n.subscribe", "session.get", "session.subscribe", "session.signIn", + "i18n.t", "i18n.locale", "i18n.timeZone", "i18n.zoneOffset", "i18n.subscribe", "session.get", "session.subscribe", "session.signIn", "navigation.push", "navigation.pop", "events.emit", "events.subscribe", "http.request", "timer.schedule", "timer.cancel", - "ui.toast", "ui.alert", "ui.confirm", "linking.openUrl", "analytics.track", + "ui.toast", "ui.alert", "ui.confirm", "linking.openUrl", "clipboard.setText", "analytics.track", ) /** What every host offers, listed in the mount manifest ahead of the host's own; `session.signIn` only comes with a session. */ @@ -136,3 +137,11 @@ internal expect fun platformInfo(): Map /** BCP 47, e.g. `zh-Hans-CN`. */ internal expect fun systemLocale(): String + +/** IANA id, e.g. `Asia/Shanghai`; read each time, so a zone the user changes in system settings is picked up on the next format. */ +internal expect fun systemTimeZone(): String + +/** Minutes [zone] is ahead of UTC at [epochMs] (daylight saving included); null when the platform does not know [zone]. */ +internal expect fun zoneOffsetMinutes(zone: String, epochMs: Long): Int? + +internal expect fun plainTextClipEntry(text: String): ClipEntry diff --git a/compose/src/commonMain/kotlin/app/tinyui/PageHost.kt b/compose/src/commonMain/kotlin/app/tinyui/PageHost.kt index 86f22f7..5c95cac 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/PageHost.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/PageHost.kt @@ -287,6 +287,8 @@ class PageHost internal constructor( } "i18n.t" -> JsonPrimitive(translate(a.str("key") ?: "")).toString() "i18n.locale" -> JsonPrimitive(host.currentLocale()).toString() + "i18n.timeZone" -> JsonPrimitive(host.currentTimeZone()).toString() + "i18n.zoneOffset" -> JsonPrimitive(zoneOffset(a["ms"]?.jsonPrimitive?.doubleOrNull ?: 0.0)).toString() "session.get" -> sessionJson(host.session?.state?.value ?: Session.LoggedOut) else -> "null" } @@ -295,6 +297,15 @@ class PageHost internal constructor( private fun translate(key: String): String = page.i18n.lookup(key, host.currentLocale()) ?: key.also { if (host.missingKeys.firstTime("${page.pkg}:$it")) sink.log("i18n: ${page.pkg} has no \"$it\" in any language") } + /** A zone the platform does not know is reported once per host and shown in the system zone instead. */ + private fun zoneOffset(epochMs: Double): Int { + val zone = host.currentTimeZone() + return zoneOffsetMinutes(zone, epochMs.toLong()) ?: run { + if (host.missingKeys.firstTime("timeZone:$zone")) sink.log("i18n: unknown time zone \"$zone\", using the system zone") + zoneOffsetMinutes(systemTimeZone(), epochMs.toLong()) ?: 0 + } + } + private fun sessionJson(s: Session): String = buildJsonObject { put("loggedIn", s.loggedIn); put("userId", s.userId) }.toString() /** J3 (docs/native-api.md §6–§13); results come back through [resolve] / [reject] as one transaction each. */ @@ -328,6 +339,10 @@ class PageHost internal constructor( ) if (name == "ui.confirm") confirmed.toString() else "" } + "clipboard.setText" -> settle(cbId) { + context.copy(a.str("text") ?: throw HostException("E_INVALID", "clipboard.setText needs text")) + "" + } "linking.openUrl" -> settle(cbId) { val url = a.str("url")?.takeIf { URL_SCHEME.containsMatchIn(it) } ?: throw HostException("E_INVALID", "linking.openUrl needs an absolute URL") withContext(Dispatchers.Main) { (host.links ?: LinkOpener.System).open(url, context) } @@ -401,8 +416,13 @@ class PageHost internal constructor( "storage.clear" -> storage?.clear() "events.emit" -> host.events.emit(a.str("topic") ?: return, a["payload"]?.toString() ?: "{}") "events.subscribe" -> { val topic = a.str("topic") ?: return; subscriptions.getOrPut("events:$topic") { host.events.subscribe(topic) { json -> emit(topic, json) } } } - "i18n.subscribe" -> host.locale?.let { flow -> - subscriptions.getOrPut("i18n") { follow(flow) { emit("i18n.locale", buildJsonObject { put("locale", it) }.toString()) } } + "i18n.subscribe" -> { + host.locale?.let { flow -> + subscriptions.getOrPut("i18n") { follow(flow) { emit("i18n.locale", buildJsonObject { put("locale", it) }.toString()) } } + } + host.timeZone?.let { flow -> + subscriptions.getOrPut("i18n.timeZone") { follow(flow) { emit("i18n.timeZone", buildJsonObject { put("timeZone", it) }.toString()) } } + } } "session.subscribe" -> host.session?.let { source -> subscriptions.getOrPut("session") { follow(source.state) { emit("session", sessionJson(it)) } } diff --git a/compose/src/commonMain/kotlin/app/tinyui/TinyUIHost.kt b/compose/src/commonMain/kotlin/app/tinyui/TinyUIHost.kt index 5ceedd0..7d092f8 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/TinyUIHost.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/TinyUIHost.kt @@ -1,5 +1,6 @@ package app.tinyui +import androidx.compose.ui.platform.Clipboard import androidx.compose.ui.platform.UriHandler import app.tinyui.schema.ComponentRegistry import kotlin.concurrent.Volatile @@ -15,6 +16,7 @@ import okio.Path * * @param channels HTTP channels pages pick by name (`http.client("app")`); `default` is the framework's own and cannot be registered. * @param locale the user's language (BCP 47); the system language when null. + * @param timeZone the zone dates are shown in (IANA id, e.g. `Asia/Shanghai`); the system zone when null. * @param dataDir where `storage` keeps each package's file; `storage` answers E_UNSUPPORTED when null. Not the `Updates` directory. */ class TinyUIHost( @@ -23,6 +25,7 @@ class TinyUIHost( val capabilities: CapabilityRegistry = CapabilityRegistry(), val channels: Map = emptyMap(), val locale: StateFlow? = null, + val timeZone: StateFlow? = null, val session: SessionSource? = null, val analytics: AnalyticsSink? = null, val links: LinkOpener? = null, @@ -55,6 +58,8 @@ class TinyUIHost( internal fun currentLocale(): String = locale?.value ?: systemLocale() + internal fun currentTimeZone(): String = timeZone?.value ?: systemTimeZone() + internal companion object { const val DEFAULT_CHANNEL = "default" const val SESSION_SIGN_IN = "session.signIn" @@ -90,6 +95,7 @@ fun interface HostCapability { /** The mount a call came from: the page's module name and the objects its `locals` provide. */ class PageContext internal constructor(val name: String, @Volatile internal var locals: Map, Any>) { internal var uriHandler: UriHandler? = null + internal var clipboard: Clipboard? = null @Suppress("UNCHECKED_CAST") operator fun get(local: PageLocal): T? = locals[local] as T? @@ -104,6 +110,11 @@ class PageContext internal constructor(val name: String, @Volatile internal var } } } + + internal suspend fun copy(text: String) { + val target = clipboard ?: throw HostException("E_UNSUPPORTED", "the page is not on screen") + withContext(Dispatchers.Main) { target.setClipEntry(plainTextClipEntry(text)) } + } } /** A typed key for an object one mount hands to capabilities, such as its screen's view model. */ diff --git a/compose/src/commonMain/kotlin/app/tinyui/TinyUIPage.kt b/compose/src/commonMain/kotlin/app/tinyui/TinyUIPage.kt index 1e047bc..15d3f07 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/TinyUIPage.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/TinyUIPage.kt @@ -14,6 +14,7 @@ import androidx.compose.runtime.key import androidx.compose.runtime.remember import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalClipboard import androidx.compose.ui.platform.LocalUriHandler import androidx.lifecycle.Lifecycle import androidx.lifecycle.LifecycleEventObserver @@ -43,9 +44,11 @@ fun TinyUIPage( PageHost(page, host, propsJson, locals, sourceMaps = sourceMaps) } val uriHandler = LocalUriHandler.current + val clipboard = LocalClipboard.current // a new list of the same objects each recomposition must not remount the page: the context just follows it SideEffect { pageHost.context.uriHandler = uriHandler + pageHost.context.clipboard = clipboard pageHost.context.locals = locals.associate { it.local to it.value } } val lifecycle = LocalLifecycleOwner.current.lifecycle diff --git a/compose/src/commonMain/kotlin/app/tinyui/components/Builtins.kt b/compose/src/commonMain/kotlin/app/tinyui/components/Builtins.kt index cf79f4b..979dad6 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/components/Builtins.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/components/Builtins.kt @@ -15,6 +15,7 @@ import androidx.compose.foundation.verticalScroll import androidx.compose.foundation.text.KeyboardActions import androidx.compose.foundation.text.KeyboardOptions import androidx.compose.material3.Button +import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi import androidx.compose.material3.Icon import androidx.compose.material3.LoadingIndicator @@ -22,11 +23,14 @@ import androidx.compose.material3.LoadingIndicatorDefaults import androidx.compose.material3.LocalContentColor import androidx.compose.material3.LocalTextStyle import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.ModalBottomSheet import androidx.compose.material3.OutlinedButton import androidx.compose.material3.OutlinedTextField import androidx.compose.material3.RadioButton +import androidx.compose.material3.SheetValue import androidx.compose.material3.Text import androidx.compose.material3.TextButton +import androidx.compose.material3.rememberBottomSheetState import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue @@ -125,6 +129,7 @@ fun ComponentRegistry.registerBuiltins(): ComponentRegistry = apply { Icon(icon.vector, contentDescription = scope.get("label"), tint = scope.color("tint") ?: LocalContentColor.current, modifier = scope.modifier().size(scope.get("size") ?: 24.dp)) } register(BuiltinSchemas.Loading) { scope -> LoadingComponent(scope) } + register(BuiltinSchemas.BottomSheet) { scope -> BottomSheetComponent(scope) } } // a scrolling axis is unbounded, so there is no remaining space to share: weight is ignored there rather than collapsing the child to 0 @@ -233,3 +238,30 @@ private fun LoadingComponent(scope: NodeScope) { color = scope.color("color") ?: LoadingIndicatorDefaults.indicatorColor, ) } + +/** + * `open` is the page's; going false animates the sheet out before it leaves composition. A user dismissal (swipe, scrim, + * back) has already hidden it when `onDismiss` fires: it stays down until `open` goes false and true again. + */ +@OptIn(ExperimentalMaterial3Api::class) +@Composable +private fun BottomSheetComponent(scope: NodeScope) { + val open = scope.get("open") == true + var showing by remember { mutableStateOf(false) } + // content-sized, never parked half way + val state = rememberBottomSheetState(initialValue = SheetValue.Hidden, enabledValues = setOf(SheetValue.Hidden, SheetValue.Expanded)) + LaunchedEffect(open) { + when { + // reopened while the hide was still animating: still composed, so bring it back up + open && showing -> state.show() + open -> showing = true + showing -> { state.hide(); showing = false } + } + } + if (showing) { + ModalBottomSheet( + onDismissRequest = { showing = false; if (scope.has("onDismiss")) scope.dispatch("onDismiss") }, + sheetState = state, + ) { scope.Children() } + } +} 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 0aeddb3..6971db9 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/components/generated/BuiltinSchemas.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/components/generated/BuiltinSchemas.kt @@ -185,7 +185,21 @@ object BuiltinSchemas { layout = true, ) - val all: List = listOf(Column, Row, Box, Text, Button, RadioButton, TextField, LazyColumn, Spacer, Icon, Loading) + val BottomSheet = ComponentSchema( + type = "BottomSheet", + props = mapOf( + "open" to PropSpec.Bool(default = null, required = true, initial = false), + ), + events = mapOf( + "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) /** 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 118d63e..52dfc56 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/generated/RuntimeBytecode.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/generated/RuntimeBytecode.kt @@ -4,10 +4,10 @@ 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( - "UUpLQjQAAAABAAAAMDRiZTI0NjAwMTU5OWY1OTk1ZmEyZjJkOGM5MWEwZjE5OGQzZjM0YwWmARp0aW55dWktbmF0aXZlFnRpbnl1aS1jb3JlEkhvc3RFcnJvcg5WRVJTSU9OEmFuYWx5dGljcwxjYWNoZWQMZXZlbnRzCGhvc3QIaHR0cAhpMThuDmxpbmtpbmcUbmF2aWdhdGlvbg5zZXNzaW9uDnN0b3JhZ2UKc3RvcmUEdWkQaW50ZXJuYWwMc2lnbmFsEm9uQ2xlYW51cBJpbnRlcm5hbDISaW50ZXJuYWwzEmludGVybmFsNBJpbnRlcm5hbDUSaW50ZXJuYWw2DnNpZ25hbDISaW50ZXJuYWw3DnNpZ25hbDMSaW50ZXJuYWw4DnNpZ25hbDQSaW50ZXJuYWw5FGludGVybmFsMTAUSG9zdEVycm9yMhRpbnRlcm5hbDExFEhvc3RFcnJvcjMSX19kZWZQcm9wEF9fZXhwb3J0JG5hdmlnYXRpb25fZXhwb3J0cwhwdXNoBnBvcBBvblJlc3VsdBpzdG9yZV9leHBvcnRzCndhdGNoHGV2ZW50c19leHBvcnRzCGVtaXQEb24YaHR0cF9leHBvcnRzDmNoYW5uZWwQZmFsbGJhY2sMY2xpZW50DnJlcXVlc3QIZ2V0Mghwb3N0BnB1dAZkZWwYaG9zdF9leHBvcnRzCGNhbGwec3RvcmFnZV9leHBvcnRzCGdldDMIc2V0MgxyZW1vdmUKY2xlYXIYaTE4bl9leHBvcnRzDmN1cnJlbnQUc2V0Q3VycmVudBRzdWJzY3JpYmVkDGZvbGxvdwxsb2NhbGUCdB5zZXNzaW9uX2V4cG9ydHMQY3VycmVudDIWc2V0Q3VycmVudDIWc3Vic2NyaWJlZDIKc3RhdGUMc2lnbkluFHVpX2V4cG9ydHMKdG9hc3QKYWxlcnQOY29uZmlybR5saW5raW5nX2V4cG9ydHMOb3BlblVybCJhbmFseXRpY3NfZXhwb3J0cwp0cmFjaxBsb2dnZWRJbgx1c2VySWQKMC45LjIGYWxsCHBhZ2UMcGFyYW1zCHNlbmQebmF2aWdhdGlvbi5wdXNoDHJlc3VsdBxuYXZpZ2F0aW9uLnBvcARmbgxvbkVtaXQibmF2aWdhdGlvbi5yZXN1bHQCcAJyBmtleQJ2CnF1ZXJ5EnN0b3JlLmdldBJzdG9yZS5zZXQSc3RyaW5naWZ5EHNldFZhbHVlHnN0b3JlLnN1YnNjcmliZQxzdG9yZToKdG9waWMOcGF5bG9hZBZldmVudHMuZW1pdCBldmVudHMuc3Vic2NyaWJlEHJlcXVlc3QyDG1ldGhvZAZ1cmwIYm9keQ5vcHRpb25zGGh0dHAucmVxdWVzdAZHRVQIUE9TVAZQVVQMREVMRVRFCGFyZ3MWc3RvcmFnZS5nZXQIY29kZRZzdG9yYWdlLnNldBpzdG9yYWdlLnNldCgiFiIpIGZhaWxlZDogHHN0b3JhZ2UucmVtb3ZlGnN0b3JhZ2UuY2xlYXIOZmV0Y2hlcghkYXRhDnNldERhdGEObG9hZGluZxRzZXRMb2FkaW5nCmVycm9yEHNldEVycm9yEGRpc3Bvc2VkDGxhdGVzdAZydW4OcmVmZXRjaAhydW4yEGN1cnJlbnQzDnBlbmRpbmcCZRZpMThuLmxvY2FsZRxpMThuLnN1YnNjcmliZQxsaXN0ZW4IcmVzdAh0ZXh0DGkxOG4udA5yZXBsYWNlAm0Wc2Vzc2lvbi5nZXQic2Vzc2lvbi5zdWJzY3JpYmUcc2Vzc2lvbi5zaWduSW4QdWkudG9hc3QQdWkuYWxlcnQUdWkuY29uZmlybR5saW5raW5nLm9wZW5VcmwKcHJvcHMCaw5lbnRyaWVzEkVfSU5WQUxJRCJhbmFseXRpY3MudHJhY2soIggiKTogUiBpcyBub3QgYSBzdHJpbmcsIG51bWJlciwgYm9vbGVhbiBvciBudWxsHmFuYWx5dGljcy50cmFjaw3mAwzoAwLoAwLoAwLoAwLoAwLoAwLoAwLoAwLoAwLoAwLoAwLoAwIOABLqAwBG7AMARO4DADDwAwAd8gMAKfQDACD2AwAx+AMAQvoDABX8AwA4/gMAK4AEABmCBAA+hAQAEwAAhgQAAQCGBAECAIgEAQMAhgQCBACGBAMFAIYEBAYA6gMFBwCGBAUIAIoEBQkAiAQFCgCGBAYLAIgEBgwAhgQHDQCIBAcOAIYECA8AhgQJEADqAwoRAIYEChIA6gMLAAwgBgGoAQAAAAUASzihBgCGBAAfAIwEAR8AiAQCHwCOBAMfAJAEBB8AkgQFHwDqAwYfAJQEBx8AigQIHwCWBAkfAJgECh8AmgQLHwCcBAwfAJ4EDR8AoAQOHwCiBA8fAKQEEB8ApgQRHwCoBBIfAKoEAAYArAQBBgCuBAIGALAEA0YBsgQERgG0BAVGAbYEBgYAigEHRgGMAQhGAbgECUYBugQKBgC8BAtGAb4EDEYBwAQNBgDCBA5GAcQEDwYAxgQQRgHIBBEGAMoEEgYAzAQTBgDOBBQGANAEFQYA0gQWBgDUBBdGAdYEGAYA2AQZRgHaBBpGAdwEG0YB3gQcRgHwAx1GAeAEHgYA4gQfBgDkBCAGAOYEIQYA6AQiRgHqBCNGAewEJEYB7gQlBgDwBCYGAPIEJwYA9AQoBgD2BClGAfgEKkYB+gQrBgD8BCxGAf4ELUYBgAUuRgGCBS8GAIQFMEYBhgUxBgCIBTJGAewDMwYA3AIABQCqAwAFANICAAUAygIABQAIaIcAAAC+BFwWAL4FXBcAvgZcGAC+ClwaAL4LXBsAvgxcHAC+D1weAL4QXB8AvhdcIQC+GFwjAL4aXCoAviBcLAC+IVwtAL4iXC4AviNcLwC+JFwwAL4nXDUAvihcNgC+KVw3AL4sXDwAvi1cPQC+MVw/AL4yXEAAvjNcQQC+NVxDAL43XEUAKThKAD1pAAAAXBMAvgBKFgEAAFwUAAtcFQBbFABbFQALvgFKGgEAAEkaAQAAvgJKGQEAAEkZAQAAvgNKGAEAAEkYAQAA7g4LXBkAWxQAWxkAC74HSkUAAABJRQAAAL4ISkYAAABJRgAAAL4JShwBAABJHAEAAO4OC1wdAFsUAFsdAAu+DUoeAQAASR4BAAC+DkofAQAASR8BAADuDgtcIABbFABbIAALvhFKIwEAAEkjAQAAvhJKCQAAAEkJAAAAvhNKRQAAAElFAAAAvhRKJgEAAEkmAQAAvhVKJwEAAEknAQAAvhZKJAEAAEkkAQAA7g5bIQAEFgAAAO1dIgA9JAEAAFwkAFsiAD1FAAAAXCUAWyIAPSYBAABcJgBbIgA9JwEAAFwnAFsiAD0JAAAAXCgAC1wpAFsUAFspAAu+GUoqAQAASSoBAADuDgtcKwBbFABbKwALvhtK+AAAAEn4AAAAvhxKLwEAAEkvAQAAvh1KRQAAAElFAAAAvh5KLgEAAEkuAQAAvh9KRgAAAElGAAAA7g4LXDEAWxQAWzEAC74lSjUBAABJNQEAAL4mSjYBAABJNgEAAO4OBhHw6RF7fgAOXDIAfgAOXDMAguoJDmQLAL/t6ukJXDQAC1w4AFsUAFs4AAu+Kko8AQAASTwBAAC+K0o7AQAASTsBAADuDgYR8OkRe34ADlw5AH4ADlw6AILqFQ5kDQALCUlFAQAAB0lGAQAA7erdCVw7AAtcPgBbFABbPgALvi5KPwEAAEk/AQAAvi9KQAEAAElAAQAAvjBKPgEAAEk+AQAA7g4LXEIAWxQAW0IAC740SkIBAABJQgEAAO4OC1xEAFsUAFtEAAu+NkpEAQAASUQBAADuDgRHAQAAXEYABi/mA7gBAAAAiQEAIBEMGw81AQAEDBQSLRESygEAAygUEiMREsoBAAMqFhIlERKOAQADHBISIRESAEwAAQACJg4qDgABCA8REBsTEgEREBsTEgQREBsTEgIREBsTEgQREBsTGRISIRESUgEAAxIYEicREgBAAAEAA4IBEhIhERKOAQAYCigWDhcnAAQsChInERKOAQAYCixSDhcpAAQeARIdERLKAQADIhgSJxESUgEAAxIcEisRElIBAAceCAAMAgYBAAIBAgcAAQAeA7QBAQAAkAUBAAB0AAAAqgQTAgDQeuoWx9vPwwvQw0NJRQAAAApJQwAAAO8OfejpDinmAxIBDwMIHB0HFAcQDBoHCAcBPjEADAIGAQAAAAABAAEAAgC0BBhCAdso5gMECQwCDAAMAgYBAAAAAAEAAQACALIEF0IB2yjmAwQKBwIMAAwCBgEAAAAAAQABAAIAsAQWQgHbKOYDBAsIAgwADEEGAbAEAgIBBQABAC8EkgUBAACUBQEAAJIF/////w8AoJQFAQCghgQAGgBeAQBeAADPx9AR8OgEDgvYyGQAAD5LAQAABEwBAAALz0lJAQAA0ElKAQAAJAIAKeYDCA4AWAQREHUKAAxBBgGyBAEBAAUAAQAkApoFAQAAmgX/////DwCghgQAGgBeAADPEfDoBA4H18dkAAA+SwEAAAROAQAAC89JTQEAACQCACnmAwgRAD8EERBXCgAMQwYBtAQBAAEEAQEBEwGeBQEAQIYEABoAZAAAPlABAAAEUQEAAL4AJAIAKeYDCBQAAwQRED4OAAxCBgEAAQEBAwABABgCpAUBAACmBQAAsJ4FAAEAXgAAz8fbXwAAPU0BAABfAAA9fwAAAO4p5gMSFScSMQcDCA8HBhECGxIRAhsXAAwCBgEAAAAAAQABAAIAigEaQgHbKOYDBB4HAgwADAIGAQAAAAABAAEAAgCMARtCAdso5gMEHwcCDAAMAgYBAAAAAAEAAQACALgEHEIB2yjmAwQgCQIMAAxDBgGKAQEBAQUAAQAnAqgFAQAAqgUAALCMBAEaAF4AAGQAAD5WAQAABFcBAAALz0lUAQAAJAIAx18AAPHoAwYoXwAAKOYDEiMAEhgRElcMESEIAREEGygROQAMQwYBjAECAAIHAAIAKQKoBQEAAIgBAQAAjAQBGgDcAkcDAGQAAD5LAQAABFgBAAALz0lUAQAAOAEAPlkBAADQJAEASUQAAAAkAgAp5gMQJwADBBESV0IRCBsWBwEqUwAMQwYBuAQBAgEFAQMBWQOoBQEAAIgBAACwtAUBAPCIBAIaAIoBGkIBjAQBGgBeAQBeAAAGEfDpDXt+AA7HfgAOyILqCw5kAADcz+3t6utkAgA+SwEAAARbAQAAC89JVAEAACQCAA5kAgA+UAEAAARcAQAAPmAAAADPJAEAvgAkAgAOXwAAKOYDHioAezgRDgcIBwEHBxI/ERJXChcbERJNIiATFxERDQAMQgYBAAEAAQIBAQEIAaQFAQBAtAUBGABkAAC+ACMBAOYDBi0jAg4bEAAMQgYBAAAAAAIAAQANAKQFAAEA2z1EAAAAEa7oAw4GKOYDBi0zAgwHAgAMAgYBAAAAAAEAAQACALwEHkIB2yjmAwQ0CAIMAAwCBgEAAAAAAQABAAIAvgQfQgHbKOYDBDUGAgwADEEGAbwEAgIBBQABAC8EugUBAAC8BQEAALoF/////w8AoLwFAQCgjgQDGgBeAQBeAADPx9AR8OgEDgvYyGQAAD5LAQAABF8BAAALz0ldAQAA0EleAQAAJAIAKeYDCDgAWAQREnUKAAxDBgG+BAIAAgUAAQAmAroFAQAAngUBAACOBAMaAGQAAD5LAQAABGABAAALz0ldAQAAJAIADmQAAD5QAQAAz9AkAgAp5gMSOwADBBESVwoXGxESGxAHDgcPAAwCBgEAAAAAAQABAAIAxgQjQgHbKOYDBEMKAgwADAIGAQAAAAABAAEAAgDQBCgCANso5gMERAoCDAAMAgYBAAAAAAEAAQACAMoEJQIA2yjmAwRFBwIMAAwCBgEAAAAAAQABAAIAzAQmAgDbKOYDBEYIAgwADAIGAQAAAAABAAEAAgDOBCcCANso5gMERwcCDAAMAgYBAAAAAAEAAQACAMgEJAIA2yjmAwRICwIMAAxDBgHCBAEBAQICAQVFAnQBAEDCBQAB8JAEBBoAXgAAvgBKYQEAAMcLXwAASSQBAAC+AUpFAAAASUUAAAC+AkomAQAASSYBAAC+A0onAQAASScBAAC+BEoJAAAASQkAAAAo5gMKSwA1Ig4HADgBFQAMQAYBAAQEAwYAAgBXCMQFAQAAxgUBAADIBQEAAMoFAQAAxAX/////DwCgxgUBAKDIBQIAoMoFAwCgkAQAGgB0AAEAXgMAXgIAXgEAXgAAz8fQyNHJ0hHw6AQOC9rKZAAAPioBAAAEZgEAAAvcSSEBAADPSWIBAADQSWMBAADRBqoR6AkOC9FJZAEAAAdQBg4O0gdQBg4OJQIA5gMRTBOJShESOUJcLAwKVzYgowEADEIGAQACAAIFAAEADgLGBQEAAMoFAQAAwgUAGABkAAAEZwEAAM8G0CMEAOYDCk8JAiQqIAwaBykADEIGAQADAAMFAAEADgPGBQEAAMgFAQAAygUBAADCBQAYAGQAAARoAQAAz9DRIwQA5gMMUAoCMCoiBwoHDAcnAAxCBgEAAwADBQABAA4DxgUBAADIBQEAAMoFAQAAwgUAGABkAAAEaQEAAM/Q0SMEAOYDDFEJAjAqIAcKBwwHJQAMQgYBAAIAAgUAAQAOAsYFAQAAygUBAADCBQAYAGQAAARqAQAAzwbQIwQA5gMKUgwCJComDBoHLwAMQwYBxgQBAAECAAEABQF0AQAAwgQhQgHbzyMBAOYDCFYAAxIHEAcdAAwCBgEAAAAAAQABAAIA1AQqQgHbKOYDBGIIAgwADEEGAdQEAgIBBAABAB4EdAEAANYFAQAAdP////8PAKDWBQEAoJIEBRoAXgEAXgAAz8fQEfDoBA4L2MhkAAA+KgEAAM/QJQIA5gMMZQBYEhESGwwHDAc3AAwCBgEAAAAAAQABAAIA8AMwQgHbKOYDBGwKAgwADAIGAQAAAAABAAEAAgDeBC9CAdso5gMEbQkCDAAMAgYBAAAAAAEAAQACANgELEIB2yjmAwRuBwIMAAwCBgEAAAAAAQABAAIA3AQuQgHbKOYDBG8KAgwADAIGAQAAAAABAAEAAgDaBC1CAdso5gMEcAcCDAAMQwYB2AQBAQEFAAEAJwKoBQEAAKoFAACwlAQHGgBeAABkAAA+VgEAAARsAQAAC89JVAEAACQCAMdfAADx6AMGKF8AACjmAxJzABIYERJXDBEhCAERBBsoETkADEMGAdoEAgECCAADAFQDqAUBAACIAQEAANoFAACwlAQHGgDcAkcDAOoDBhoAXgAAZAAAPlYBAAAEbgEAAAvPSVQBAAA4AQA+WQEAANAkAQBJRAAAACQCAMdfAADx6SJkAgARXwAABG8BAAA+YAAAAM8EcAEAAF8AACQDACECADAp5gMidwASHhESV0gRCBsWBwEqVxEhCA0RChIGFhRDLCAiIE8RJQAMQwYB3AQBAAEFAAEAGAGoBQEAAJQEBxoAZAAAPksBAAAEcQEAAAvPSVQBAAAkAgAp5gMIfAADBBESVwoADEMGAd4EAAAABAABABIAlAQHGgBkAAA+SwEAAARyAQAACyQCACnmAwh/AAMEERI5CgAMQwYB8AMCCQIFBwUCpQELqAUBBEDmBQEGQOgFAACw6gUBAvDsBQIAsO4FAwPw8AUEALDyBQUF8PQFBgDg9gUHAeD4BQgAsNoELUIBqgNIAwCWBAkaANgELEIBigQIGgBeCABeBwBeBgBeBQBeBABeAwBeAgBeAQBeAAAGEfDpDXt+AA7HfgAOyILqCw5kAgDez+3t6usGEfDpDXt+AA7JfgAOyoLqCQ5kAgAJ7ertBhHw6Q97fgAOwQR+AA7BBYLqCQ5kAgAG7errCcEGs8EHZAQAvgDtDr4BSnwBAADBCF8IAOwOXwAAC18CAEl2AQAAXwQASXgBAABfCABJfQEAACYCACjmAyuCAQDkNBEQBwoHAQcJbAEWDnYVFg4XJxIDDRUbEjICAAI4ExEGDQpmQjlRAAxCBgEAAAAAAgABAAYA9AUGEAAKEWUAACnmAwWIAQwDDwAMQgYBAAAEAAQCCQNgBPwFAADw/gUBAfCABgIAoIIGAwCD9AUGEAD2BQcQAOoFARgA7gUDGADaBABCAagFAAEA8gUFGADmBQEBAKoDAQMAXgIAXgEAXgAAZAEAjRFlAQDHvgBKfwEAAMhkAwAK7Q5kBgAG7Q4GyWsOAAAAWwcA7GACAA7qGsprFgAAADgIAD6GAAAAxiQBAGACAA7qAjBfAgA+hAAAAL4BvgIkAgAp5gMliwEOMAoRAxsDKwgIHRYUDRMWEDIIEQ5FDREOGxAHATYzEQ4vCgAMQgYBAAAAAAIAAwAQAPQFABIA/AUAGAD2BQESAGQAAJQR6AkOZAEAZAIAqSjmAwuNARUCDioYERIRBwAMQgYBAAEBAQQBBgEyAqoFAQBAggYAAIP+BQEYAOoFAhoA7gUDGgDaBARCAagFBQIA8gUGGgBkAADslOgCKWQBAL4A7Q5kAgAJ7Q5rDQAAAN5bBADP7g4OKcdrDAAAAGQFAMPtDg4pMOYDH5YBEQMLERAXFQgDGw4NDRYUJw8HChEKBws2BxESBwEADEIGAQAAAAABAAEAAgCqBQABANso5gMFmQEOAgwADEIGAQABAAECAAMAFAGCBgEAAP4FARgA8gUGGgDuBQMaAGQAAOyU6AIpZAEAz+0OZAIACe0p5gMToAEHAwgREBcVCAMREgcBDQ8WFAAMAgYBAAAAAAEAAQACAOoENkIB2yjmAwWuAQoCDAAMAgYBAAAAAAEAAQACAOwEN0IB2yjmAwWvAQUCDAAMQwYB6AQAAAAEAAMBPgDkBDMCAOYENAIAmAQKGgDc6AIpCuDbZAIAPlYBAAAEggEAACQBAO0OZAIAPksBAAAEgwEAAAskAgAOZAIAPoQBAAAEggEAAL4AJAIAKeYDH7QBAAMMEgMIAw0ABxYREjQMER8NExESOQoXGxESPg4ADEIGAQABAAECAAEACgGkBQEAAOQEAAIA2889NQEAACMBAOYDC7oBIgIOBxYHAhsDAAxDBgHqBAAAAAEAAgAHAOgENUIB4gQyAgDb7A7cIwAA5gMLvAEAAwQHDA0CBw0ADEEGAewEAgIBBQEEA0gEqAUBAACKBgEAAIwGAACw1gUBAPDSAkkDAOgENUIB4gQyAgCYBAoaAA0BANReAQBeAADc7A7d7A5kAwA+VgEAAASHAQAAC89JVAEAACQCAMfQs0PIXwEA6BRfAAA+iAEAAL0AvQE0vgIkAgAoXwAAKOYDJ8ABADUEBwwNCwcODQwRElcMESEIBAwIBwsIBxsOEQg+EBaeARHRAQAHJlx7KFtBLVphLXowLTlfXSspXH0HdAEAAgAyAAAADgYAAAAGDfX///8TAAF7ABMBJAQAMAA5AEEAWgBfAF8AYQB6AA7o////FAEBfQAUABAMQgYBAAIAAgMAAgATApIGAQAAdAEAANYFARgA0gIAAwDQZAAApugLOAEAZAAA0EPtKM8o5gMVxQE1AhoHEBEFERQRDhEKBwEHCQweAAwCBgEAAAAAAQABAAIA+AQ9QgHbKOYDBcsBCgIMAAwCBgEAAAAAAQABAAIA9gQ8QgHbKOYDBcwBCQIMAAxDBgH2BAAAAAQABAFCAPIEOgIA9AQ7AgCcBAwaAPAEOQIA3JToOwrg22QCAD5WAQAABIoBAAAkAQDtDmQCAD5LAQAABIsBAAALJAIADmQCAD6EAQAABP8AAAC+ACQCAA7eIwAA5gMh0QEAAw4XBQ0ABxgREjQMER8NFRESOQoXGxESPg4YFQcNAAxCBgEAAQABAgABAAUBpAUBAADyBAACANvPIwEA5gMJ1gEgAg4HGAcBAAxBBgH4BAEBAAUAAQAjAuABAQAA4AH/////DwCgnAQMGgBeAADPEfDoBA6/18dkAAA+KgEAAASMAQAAC89JcAAAACUCAOYDCdoBAD8SERJXHwAMAgYBAAAAAAEAAQACAP4EQEIB2yjmAwXhAQkCDAAMAgYBAAAAAAEAAQACAIAFQUIB2yjmAwXiAQsCDAAMAgYBAAAAAAEAAQACAPwEP0IB2yjmAwXjAQkCDAAMQQYB/AQCAgEGAAEALgRsAQAAygUBAABs/////w8AoMoFAQCgoAQOGgBeAQBeAADPx9AR8OgEDgvYyGQAAD4qAQAABI0BAAALz0k2AAAA0AdQBg4OJQIA5gML5gEAWBIREldAIF8ADEMGAf4EAQABBgABABcBygUBAACgBA4aAGQAAD4qAQAABI4BAAALzwdQBg4OJQIA5gML6QEAAxIREjkuIE0ADEMGAYAFAQABBgABABcBygUBAACgBA4aAGQAAD4qAQAABI8BAAALzwdQBg4OJQIA5gML7AEAAxIREjkyIFEADAIGAQAAAAABAAEAAgCEBUNCAdso5gMF8wELAgwADEMGAYQFAQABBQABABcBxgUBAACiBA8aAGQAAD4qAQAABJABAAALz0ljAQAAJQIA5gMJ9gEAAxIRFFchAAwCBgEAAAAAAQABAAIAiAVFQgHbKOYDBf0BCQIMAAxBBgGIBQIEAQwAAwCmAQZ0AQAAogYBAAB0/////w8AoKIGAQCgpAYAALCqBQMAsMoCSgMApAQQGgCmBBEaAF4BAF4AAM/H0BHw6AQOC9jIXgMAXgIAOAAAPpMBAADQJAEAe+pde34ADsl+AA7Kgl8DAPHpTV8DAJUETAAAAKroQV8DAJUESgAAAKroNV8DAJUESwAAAKroKWQBABEElAEAAASVAQAAPmAAAADPBJYBAABfAgAElwEAACQEACECADB+AOihDoJkAgA+SwEAAASYAQAAC89JOgAAANBJkQEAACQCACnmAyyAAgB2LhEMGxIHAVM5EQQRJhEELy4RBC8uEQQwgQFhWCAWOVkRJygHERR1CgA=", + "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", ) } diff --git a/compose/src/commonTest/kotlin/app/tinyui/PageHostTest.kt b/compose/src/commonTest/kotlin/app/tinyui/PageHostTest.kt index f4b785f..3ab761b 100644 --- a/compose/src/commonTest/kotlin/app/tinyui/PageHostTest.kt +++ b/compose/src/commonTest/kotlin/app/tinyui/PageHostTest.kt @@ -25,6 +25,8 @@ class PageHostTest { override fun log(line: String) { log += line } } + private val zoneFlow = MutableStateFlow("America/New_York") + private val core = module("tinyui-core", """ let patches = [], count = 0, handler = null, page = null, emits = 0, settled = []; const settle = (line) => { settled.push(line); patches.push(["p",1,"text", settled.slice().sort().join(";")]); }; globalThis.__tinyui = { @@ -53,7 +55,12 @@ class PageHostTest { __host_call("http.request", 14, JSON.stringify({ channel: "app", method: "GET", url: "/gone" })); __host_call("http.request", 15, JSON.stringify({ channel: "nope", method: "GET", url: "/x" })); __host_call("session.signIn", 16, "{}"); + __host_call("clipboard.setText", 17, "{}"); + __host_call("clipboard.setText", 18, JSON.stringify({ text: "PP-1024" })); } + // 2026-01-01 and 2026-07-01 UTC: either side of daylight saving + if (event === "onZone") patches.push(["p",1,"text", [__host_query("i18n.timeZone", "{}"), __host_query("i18n.zoneOffset", JSON.stringify({ ms: 1767225600000 })), __host_query("i18n.zoneOffset", JSON.stringify({ ms: 1782864000000 }))].join("|")]); + if (event === "onI18nSubscribe") { __host_send("i18n.subscribe", "{}"); patches.push(["p",1,"text","subscribed"]); } }, emit(topic, json) { emits++; patches.push(["p",1,"text", topic + " " + json + " #" + emits]); }, flush() { if (count > 2) throw new Error("render exploded"); if (patches.length) { __host_apply(JSON.stringify(patches)); patches = []; } }, @@ -77,6 +84,7 @@ class PageHostTest { if (request.url == "/todos") HttpResponse(200, mapOf("content-type" to "application/json"), """[{"id":1}]""") else HttpResponse(404, emptyMap(), """{"gone":true}""") }), locale = MutableStateFlow("en"), + timeZone = zoneFlow, analytics = AnalyticsSink { name, props, page -> tracked += "${page.name} $name $props" }, ).apply { store.setJson("cart", """{"n":2}""") } private val tracked = mutableListOf() @@ -105,7 +113,7 @@ class PageHostTest { val host = host("""{"name":"tinyui"}""") host.start() host.await { host.tree.root.children.isNotEmpty() } - assertEquals("hello tinyui / 11", host.tree.node(1)!!.props["text"]) + assertEquals("hello tinyui / 12", host.tree.node(1)!!.props["text"]) assertNull(host.failure) host.close() } @@ -211,11 +219,13 @@ class PageHostTest { host.await { host.tree.root.children.isNotEmpty() } val text = { host.tree.node(1)!!.props["text"] as? String } host.dispatch(2, "onFramework", "{}") - host.await { text()?.count { it == ';' } == 2 } + host.await { text()?.count { it == ';' } == 4 } assertEquals( """rejected 14 {"status":404,"headers":{},"body":{"gone":true},"code":"E_HTTP","message":"HTTP 404"};""" + """rejected 15 {"code":"E_UNSUPPORTED","message":"the host has no http channel \"nope\""};""" + - """rejected 16 {"code":"E_UNSUPPORTED","message":"the host provides no session"}""", + """rejected 16 {"code":"E_UNSUPPORTED","message":"the host provides no session"};""" + + """rejected 17 {"code":"E_INVALID","message":"clipboard.setText needs text"};""" + + """rejected 18 {"code":"E_UNSUPPORTED","message":"the page is not on screen"}""", text(), ) assertEquals(listOf("pages/counter tap {n=2, ok=true, s=x}"), tracked) @@ -234,6 +244,31 @@ class PageHostTest { host.close() } + @Test + fun timeZoneQueriesFollowTheHostZoneIncludingDaylightSaving() = runTest { + val host = host() + host.start() + host.await { host.tree.root.children.isNotEmpty() } + val text = { host.tree.node(1)!!.props["text"] as? String } + host.dispatch(2, "onZone", "{}") + host.await { text() == """"America/New_York"|-300|-240""" } + host.dispatch(2, "onI18nSubscribe", "{}") + // the current locale and zone arrive first, in either order + host.await { text()?.endsWith("#2") == true } + zoneFlow.value = "Asia/Tokyo" + host.await { text() == """i18n.timeZone {"timeZone":"Asia/Tokyo"} #3""" } + host.dispatch(2, "onZone", "{}") + host.await { text() == """"Asia/Tokyo"|540|540""" } + zoneFlow.value = "Nowhere/Atlantis" + host.await { text() == """i18n.timeZone {"timeZone":"Nowhere/Atlantis"} #4""" } + host.dispatch(2, "onZone", "{}") + host.dispatch(2, "onZone", "{}") + val system = systemTimeZone() + host.await { text() == """"Nowhere/Atlantis"|${zoneOffsetMinutes(system, 1767225600000)}|${zoneOffsetMinutes(system, 1782864000000)}""" } + assertEquals(1, log.count { "unknown time zone \"Nowhere/Atlantis\"" in it }, "reported once, shown in the system zone") + host.close() + } + @Test fun renderErrorsFailThePage() = runTest { val host = host() diff --git a/compose/src/iosMain/kotlin/app/tinyui/Platform.ios.kt b/compose/src/iosMain/kotlin/app/tinyui/Platform.ios.kt index b607080..6edb37f 100644 --- a/compose/src/iosMain/kotlin/app/tinyui/Platform.ios.kt +++ b/compose/src/iosMain/kotlin/app/tinyui/Platform.ios.kt @@ -1,12 +1,19 @@ package app.tinyui +import androidx.compose.ui.ExperimentalComposeUiApi +import androidx.compose.ui.platform.ClipEntry import io.ktor.client.HttpClient import io.ktor.client.engine.darwin.Darwin import okio.FileSystem +import platform.Foundation.NSDate import platform.Foundation.NSLocale +import platform.Foundation.NSTimeZone import platform.Foundation.currentLocale +import platform.Foundation.dateWithTimeIntervalSince1970 +import platform.Foundation.localTimeZone import platform.Foundation.localeIdentifier import platform.Foundation.preferredLanguages +import platform.Foundation.timeZoneWithName import platform.UIKit.UIDevice internal actual fun platformInfo(): Map = mapOf( @@ -18,6 +25,14 @@ internal actual fun platformInfo(): Map = mapOf( internal actual fun systemLocale(): String = (NSLocale.preferredLanguages.firstOrNull() as? String) ?: NSLocale.currentLocale.localeIdentifier.replace('_', '-') +internal actual fun systemTimeZone(): String = NSTimeZone.localTimeZone.name + +internal actual fun zoneOffsetMinutes(zone: String, epochMs: Long): Int? = + NSTimeZone.timeZoneWithName(zone)?.secondsFromGMTForDate(NSDate.dateWithTimeIntervalSince1970(epochMs / 1000.0))?.toInt()?.div(60) + +@OptIn(ExperimentalComposeUiApi::class) +internal actual fun plainTextClipEntry(text: String): ClipEntry = ClipEntry.withPlainText(text) + internal actual val platformFileSystem: FileSystem = FileSystem.SYSTEM internal actual fun defaultHttpClient(): HttpClient = HttpClient(Darwin) diff --git a/docs/components.md b/docs/components.md index 60a2284..99ef1b8 100644 --- a/docs/components.md +++ b/docs/components.md @@ -77,6 +77,7 @@ prop 类型：`string` / `number` / `boolean` / `dp` / `sp` / `color`（`#RRGGBB | `Spacer` | （只有布局 prop） | | | | | `Icon` | `icon`（必填，`icon` 类型）、`size`（dp，默认 24）、`tint`（color，缺省跟随内容色）、`label`（读屏念的名字；紧挨文字的装饰图标不设） | `onClick` | | | | `Loading` | `size`（dp，默认 24）、`color`（缺省 `primary`） | | | | +| `BottomSheet` | `open`（必填）；不接受布局 prop | `onDismiss` | | 是：弹层的内容 | `RadioButton` 的选中态是普通 prop（2026-09-17 加）：它只报点击，选中哪个由 JS 决定——单选组的真值本来就在页面状态里，不属于 ADR-004 的"高频交互状态"。`TextField` 的文本与光标永远在 Kotlin 侧（ADR-004 §3.3）：`setText` 会同时触发 `onChange`。`LazyColumn` 的行就是它的 children，虚拟化只在组合层（ADR-003 §3.6）。 @@ -91,6 +92,16 @@ const ICONS: Record = { quota: bolt }; `Loading` 是 M3 Expressive 的 `LoadingIndicator`，不定进度；有进度的进度条等需求。`LoadingIndicator` 只在 CMP material3 的 alpha 线上有，库因此依赖与 CMP 同代的 material3 alpha（catalog `composeMaterial3`）。 +`BottomSheet` 是 M3 `ModalBottomSheet`，浮在页面之上，不占父容器的布局（2026-10-12 加，PingPong 交易详情页触发）。`open` 由页面掌握：变 true 滑入，变 false 播完收起动画再离开组合；用户下滑、点遮罩或按返回时，弹层已经自己收起，再报 `onDismiss`，页面在里面把 `open` 置回 false——不置的话它保持收起，直到 `open` 先 false 再 true。只有展开一档（内容多高就多高，不停在半屏）。内容的布局（内边距、标题、关闭按钮）由页面用 children 自己写。命令式的 `ui.alert` / `ui.confirm` 仍是纯文本对话框；声明式 `Dialog` 继续推迟。 + +```tsx +const [open, setOpen] = signal(false); +