diff --git a/compose/api/compose.klib.api b/compose/api/compose.klib.api index 91a23eb..7c11078 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,12 +681,16 @@ 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] final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.Button.|(){}[0] final val Column // app.tinyui.components.generated/BuiltinSchemas.Column|{}Column[0] final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.Column.|(){}[0] + final val Divider // app.tinyui.components.generated/BuiltinSchemas.Divider|{}Divider[0] + final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.Divider.|(){}[0] final val Icon // app.tinyui.components.generated/BuiltinSchemas.Icon|{}Icon[0] final fun (): app.tinyui.schema/ComponentSchema // app.tinyui.components.generated/BuiltinSchemas.Icon.|(){}[0] final val LazyColumn // app.tinyui.components.generated/BuiltinSchemas.LazyColumn|{}LazyColumn[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..6c5a921 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 fresh each time (iOS caches it otherwise), so a zone changed in system settings shows up. */ +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..bb8dd0d 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/PageHost.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/PageHost.kt @@ -128,6 +128,8 @@ class PageHost internal constructor( private val timers = HashMap() private val subscriptions = HashMap() private val storeVersions = HashMap() + /** The system zone the page last got, once it subscribed without a host zone; under the runtime lock like [timers]. */ + private var systemZoneSeen: String? = null private val jsThread = newSingleThreadContext("tinyui-page") private val runtime = JsRuntime( JsEngineConfig(moduleScheme = MODULE_SCHEME, logger = sink::log, onUnhandledRejection = { report("E7", it.message ?: "unhandled rejection", stack = it.jsStack) }), @@ -178,6 +180,20 @@ class PageHost internal constructor( fun visible(visible: Boolean) { wantVisible = visible entry("visible", JsValue.Bool(visible)) + if (visible) systemZoneMoved() + } + + /** + * Without a host zone the page follows the system's, which has no change callback in common code: coming back on screen + * (the user may have just been in Settings) is when it is checked again. + */ + private fun systemZoneMoved() { + if (host.timeZone != null) return + val zone = host.systemZone() + var same = false + entry("emit", JsValue.Str("i18n.timeZone"), JsValue.Str(buildJsonObject { put("timeZone", zone) }.toString()), before = { + if (systemZoneSeen == null || systemZoneSeen == zone) same = true else systemZoneSeen = zone + }, skipWhen = { same }) } fun resolve(cbId: Int, resultJson: String) = entry("resolve", JsValue.Num(cbId), JsValue.Str(resultJson)) fun reject(cbId: Int, code: String, message: String) = reject(cbId, code, message, null) @@ -287,6 +303,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 +313,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(host.systemZone(), 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 +355,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 +432,16 @@ 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()) } } + } + val zone = host.timeZone + if (zone != null) { + subscriptions.getOrPut("i18n.timeZone") { follow(zone) { emit("i18n.timeZone", buildJsonObject { put("timeZone", it) }.toString()) } } + } else if (systemZoneSeen == null) { + systemZoneSeen = host.systemZone() + } } "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..4cd146c 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, @@ -41,6 +44,8 @@ class TinyUIHost( internal val storages = Storages(dataDir, sink) internal val missingKeys = MissingKeys() internal val defaultChannel: HttpChannel by lazy { KtorChannel(defaultHttpClient()) } + /** The platform's zone when [timeZone] is null; replaceable so tests can move it. */ + internal var systemZone: () -> String = ::systemTimeZone init { for (name in channels.keys) { @@ -55,6 +60,8 @@ class TinyUIHost( internal fun currentLocale(): String = locale?.value ?: systemLocale() + internal fun currentTimeZone(): String = timeZone?.value ?: systemZone() + internal companion object { const val DEFAULT_CHANNEL = "default" const val SESSION_SIGN_IN = "session.signIn" @@ -90,6 +97,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 +112,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..81f97bd 100644 --- a/compose/src/commonMain/kotlin/app/tinyui/components/Builtins.kt +++ b/compose/src/commonMain/kotlin/app/tinyui/components/Builtins.kt @@ -15,18 +15,24 @@ 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.DividerDefaults +import androidx.compose.material3.ExperimentalMaterial3Api import androidx.compose.material3.ExperimentalMaterial3ExpressiveApi +import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.LoadingIndicator 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 +131,14 @@ 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) } + register(BuiltinSchemas.Divider) { scope -> + HorizontalDivider( + modifier = scope.modifier(), + thickness = scope.get("thickness") ?: DividerDefaults.Thickness, + color = scope.color("color") ?: DividerDefaults.color, + ) + } } // 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 +247,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..f590a46 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,35 @@ 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 Divider = ComponentSchema( + type = "Divider", + props = mapOf( + "thickness" to PropSpec.Dp(default = 1.0, required = false, initial = false), + "color" to PropSpec.ColorSpec(default = "outlineVariant", required = false, initial = false), + ), + events = mapOf( + ), + commands = mapOf( + ), + children = false, + layout = true, + ) + + val all: List = listOf(Column, Row, Box, Text, Button, RadioButton, TextField, LazyColumn, Spacer, Icon, Loading, BottomSheet, Divider) /** 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..8dce218 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( - "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", + "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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..beaa174 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: "ORD-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,13 +84,14 @@ 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() private val store = tinyui.store - private fun host(props: String = "{}", maps: SourceMaps = SourceMaps.EMPTY) = - PageHost(RuntimeBundle(core, native), page, tinyui, props, listOf(Merchant provides "acme"), sourceMaps = maps) + private fun host(props: String = "{}", maps: SourceMaps = SourceMaps.EMPTY, app: TinyUIHost = tinyui) = + PageHost(RuntimeBundle(core, native), page, app, props, listOf(Merchant provides "acme"), sourceMaps = maps) // runTest's virtual time never advances the real engine thread: wait on a real dispatcher private suspend fun PageHost.await(check: () -> Boolean) = @@ -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 / 13", 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,55 @@ 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 withoutAHostZoneTheSystemZoneIsCheckedAgainWhenThePageComesBack() = runTest { + val system = MutableStateFlow("Europe/London") + val app = TinyUIHost(ComponentRegistry().registerBuiltins(), sink).apply { systemZone = { system.value } } + val host = host(app = app) + host.start() + host.await { host.tree.root.children.isNotEmpty() } + val text = { host.tree.node(1)!!.props["text"] as? String } + host.dispatch(2, "onI18nSubscribe", "{}") + host.await { text() == "subscribed" } + host.visible(false) + host.visible(true) + host.dispatch(2, "onZone", "{}") + host.await { text() == """"Europe/London"|0|60""" } + system.value = "Asia/Tokyo" + host.visible(false) + host.visible(true) + // #1: coming back with the zone unchanged sent nothing + host.await { text() == """i18n.timeZone {"timeZone":"Asia/Tokyo"} #1""" } + host.dispatch(2, "onZone", "{}") + host.await { text() == """"Asia/Tokyo"|540|540""" } + 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..2d9cc47 100644 --- a/compose/src/iosMain/kotlin/app/tinyui/Platform.ios.kt +++ b/compose/src/iosMain/kotlin/app/tinyui/Platform.ios.kt @@ -1,12 +1,20 @@ 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.resetSystemTimeZone import platform.Foundation.localeIdentifier import platform.Foundation.preferredLanguages +import platform.Foundation.timeZoneWithName import platform.UIKit.UIDevice internal actual fun platformInfo(): Map = mapOf( @@ -18,6 +26,18 @@ internal actual fun platformInfo(): Map = mapOf( internal actual fun systemLocale(): String = (NSLocale.preferredLanguages.firstOrNull() as? String) ?: NSLocale.currentLocale.localeIdentifier.replace('_', '-') +// the system zone is cached for the process until reset, so a change in Settings would never show +internal actual fun systemTimeZone(): String { + NSTimeZone.resetSystemTimeZone() + return 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..bca1674 100644 --- a/docs/components.md +++ b/docs/components.md @@ -77,6 +77,8 @@ 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` | | 是：弹层的内容 | +| `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）。 @@ -91,6 +93,18 @@ const ICONS: Record = { quota: bolt }; `Loading` 是 M3 Expressive 的 `LoadingIndicator`，不定进度；有进度的进度条等需求。`LoadingIndicator` 只在 CMP material3 的 alpha 线上有，库因此依赖与 CMP 同代的 material3 alpha（catalog `composeMaterial3`）。 +`BottomSheet` 是 M3 `ModalBottomSheet`，浮在页面之上，不占父容器的布局（2026-10-12 加，第一个需要的业务页面触发）。`open` 由页面掌握：变 true 滑入，变 false 播完收起动画再离开组合；用户下滑、点遮罩或按返回时，弹层已经自己收起，再报 `onDismiss`，页面在里面把 `open` 置回 false——不置的话它保持收起，直到 `open` 先 false 再 true。只有展开一档（内容多高就多高，不停在半屏）。内容的布局（内边距、标题、关闭按钮）由页面用 children 自己写。命令式的 `ui.alert` / `ui.confirm` 仍是纯文本对话框；声明式 `Dialog` 继续推迟。 + +```tsx +const [open, setOpen] = signal(false); +