peachsim 0.1.674 → 0.1.675

package/kotlin/AppSources/android/content/res/Configuration.kt

@@ -1,12 +1,15 @@
 package android.content.res
 
 // the device configuration an app reads through its resources: a phone's
-// normal ui mode type, night or not as the device's dark theme is set
+// normal ui mode type, night or not as the device's dark theme is set, and
+// the device locale's language tag
 class Configuration {
     var uiMode: Int = UI_MODE_TYPE_NORMAL or UI_MODE_NIGHT_NO
+    internal var localeTag: String = ""
 
     fun setTo(other: Configuration) {
         uiMode = other.uiMode
+        localeTag = other.localeTag
     }
 
     companion object {

package/kotlin/AppSources/android/content/res/Resources.kt

@@ -1,6 +1,50 @@
 package android.content.res
 
-class Resources internal constructor(val configuration: Configuration)
+import dev.peach.app.javaFormat
+import dev.peach.app.peachAppArrays
+import dev.peach.app.peachAppPlurals
+import dev.peach.app.peachAppStrings
+
+class Resources internal constructor(val configuration: Configuration) {
+    class NotFoundException(name: String) : RuntimeException(name)
+
+    fun getString(id: Int): String =
+        resolve(peachAppStrings[id]) ?: throw NotFoundException("String resource ID #0x${id.toString(16)}")
+
+    fun getString(id: Int, vararg formatArgs: Any?): String =
+        javaFormat(configuration.localeTag, getString(id), formatArgs)
+
+    // ResourcesImpl.getQuantityText: the item the locale's plural rule
+    // selects for the quantity, then the other item
+    fun getQuantityString(id: Int, quantity: Int): String {
+        val items = resolve(peachAppPlurals[id])
+            ?: throw NotFoundException("Plural resource ID #0x${id.toString(16)}")
+        val rule = pluralRule(configuration.localeTag, quantity)
+        return items[rule] ?: items["other"]
+            ?: throw NotFoundException("Plural resource ID #0x${id.toString(16)} quantity=$quantity item=$rule")
+    }
+
+    fun getQuantityString(id: Int, quantity: Int, vararg formatArgs: Any?): String =
+        javaFormat(configuration.localeTag, getQuantityString(id, quantity), formatArgs)
+
+    fun getStringArray(id: Int): Array<String> =
+        resolve(peachAppArrays[id])?.toTypedArray()
+            ?: throw NotFoundException("String array resource ID #0x${id.toString(16)}")
+
+    // the value the configuration's locale selects: its language and region,
+    // then its language, then the default values, as the resource table
+    // matches a locale qualifier. a plurals or array resource resolves whole
+    private fun <Value> resolve(values: Map<String, Value>?): Value? {
+        if (values == null) return null
+        val tag = configuration.localeTag
+        return values[tag] ?: values[tag.substringBefore('-')] ?: values[""]
+    }
+}
+
+// ICU's PluralRules.forLocale(locale).select(quantity); Intl reads the same
+// CLDR plural rules
+private fun pluralRule(locale: String, quantity: Int): String =
+    js("new Intl.PluralRules(locale || undefined).select(quantity)")
 
 // the app process's resources, set once the device configuration is known at
 // cold start; every context in the process reads the same configuration, which

package/kotlin/AppSources/androidx/compose/ui/platform/AndroidCompositionLocals.kt

@@ -0,0 +1,19 @@
+package androidx.compose.ui.platform
+
+import android.content.Context
+import android.content.res.Configuration
+import androidx.compose.runtime.compositionLocalOf
+import androidx.compose.runtime.neverEqualPolicy
+import androidx.compose.runtime.staticCompositionLocalOf
+
+// AndroidCompositionLocals.android.kt: the configuration and context a
+// ComposeView's content reads, provided where its composition starts
+val LocalConfiguration = compositionLocalOf<Configuration>(neverEqualPolicy()) {
+    noLocalProvidedFor("LocalConfiguration")
+}
+
+val LocalContext = staticCompositionLocalOf<Context> { noLocalProvidedFor("LocalContext") }
+
+private fun noLocalProvidedFor(name: String): Nothing {
+    error("CompositionLocal $name not present")
+}

package/kotlin/AppSources/androidx/compose/ui/res/StringResources.kt

@@ -0,0 +1,53 @@
+package androidx.compose.ui.res
+
+import android.content.res.Resources
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.ReadOnlyComposable
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
+
+// StringResources.android.kt and Resources.android.kt: a string, plural or
+// string array resource read through the composition's context, recomposed
+// when its configuration changes
+
+@Composable
+@ReadOnlyComposable
+fun stringResource(id: Int): String {
+    val resources = resources()
+    return resources.getString(id)
+}
+
+@Composable
+@ReadOnlyComposable
+fun stringResource(id: Int, vararg formatArgs: Any): String {
+    val resources = resources()
+    return resources.getString(id, *formatArgs)
+}
+
+@Composable
+@ReadOnlyComposable
+fun pluralStringResource(id: Int, count: Int): String {
+    val resources = resources()
+    return resources.getQuantityString(id, count)
+}
+
+@Composable
+@ReadOnlyComposable
+fun pluralStringResource(id: Int, count: Int, vararg formatArgs: Any): String {
+    val resources = resources()
+    return resources.getQuantityString(id, count, *formatArgs)
+}
+
+@Composable
+@ReadOnlyComposable
+fun stringArrayResource(id: Int): Array<String> {
+    val resources = resources()
+    return resources.getStringArray(id)
+}
+
+@Composable
+@ReadOnlyComposable
+internal fun resources(): Resources {
+    LocalConfiguration.current
+    return LocalContext.current.resources
+}

package/kotlin/AppSources/dev/peach/app/JavaFormat.kt

@@ -0,0 +1,264 @@
+package dev.peach.app
+
+// java.util.Formatter as String.format(locale, format, args) runs it on the
+// device, which Resources.getString(id, args) calls: the general, character,
+// integral and decimal float conversions with their flags, width, precision
+// and argument indexes, digits and separators in the locale's symbols. a
+// conversion outside those (scientific, hex float, date) is rejected by name.
+
+private val SPECIFIER = Regex("%(\\d+\\$)?([-#+ 0,(<]*)(\\d+)?(\\.\\d+)?([tT])?([a-zA-Z%])")
+
+private class Symbols(val zero: Char, val decimal: String, val group: String)
+
+// one part of the locale's number format, as ICU's decimal format symbols
+// give it (Intl reads the same CLDR data)
+private fun numberPart(locale: String, value: Double, type: String): String =
+    js("(new Intl.NumberFormat(locale || undefined, { useGrouping: true }).formatToParts(value).find((part) => part.type === type) || { value: '' }).value")
+
+private fun symbols(locale: String) = Symbols(
+    zero = numberPart(locale, 0.0, "integer").single(),
+    decimal = numberPart(locale, 1.5, "decimal"),
+    group = numberPart(locale, 1234567.0, "group"),
+)
+
+private class Spec(val flags: String, val width: Int, val precision: Int, val text: String) {
+    fun has(flag: Char) = flag in flags
+}
+
+internal fun javaFormat(locale: String, format: String, args: Array<out Any?>): String {
+    val out = StringBuilder()
+    var ordinary = 0
+    var last = -1
+    var index = 0
+    while (index < format.length) {
+        val percent = format.indexOf('%', index)
+        if (percent == -1) {
+            out.append(format, index, format.length)
+            break
+        }
+        out.append(format, index, percent)
+        val match = SPECIFIER.matchAt(format, percent)
+            ?: throw IllegalArgumentException(
+                "Conversion = '${format.getOrNull(percent + 1) ?: '%'}'",
+            )
+        index = match.range.last + 1
+        val (position, flags, width, precision, time, conversion) = match.destructured
+        if (time.isNotEmpty())
+            throw UnsupportedOperationException("peach kotlin: date conversion ${match.value} is not supported")
+        val spec = Spec(
+            flags,
+            width.toIntOrNull() ?: -1,
+            precision.drop(1).toIntOrNull() ?: -1,
+            match.value,
+        )
+        val c = conversion.single()
+        if (c == '%') {
+            out.append(justify(spec, "%"))
+            continue
+        }
+        if (c == 'n') {
+            out.append('\n')
+            continue
+        }
+        val argument = when {
+            spec.has('<') -> last
+            position.isNotEmpty() -> position.dropLast(1).toInt() - 1
+            else -> ordinary++
+        }
+        if (argument !in args.indices) throw IllegalArgumentException("Format specifier '${match.value}'")
+        last = argument
+        out.append(convert(c, args[argument], spec, locale))
+    }
+    return out.toString()
+}
+
+private fun justify(spec: Spec, value: String): String {
+    if (spec.width <= value.length) return value
+    val pad = " ".repeat(spec.width - value.length)
+    return if (spec.has('-')) value + pad else pad + value
+}
+
+private fun typeName(value: Any?): String = when (value) {
+    is String -> "java.lang.String"
+    is Int -> "java.lang.Integer"
+    is Long -> "java.lang.Long"
+    is Short -> "java.lang.Short"
+    is Byte -> "java.lang.Byte"
+    is Double -> "java.lang.Double"
+    is Float -> "java.lang.Float"
+    is Boolean -> "java.lang.Boolean"
+    is Char -> "java.lang.Character"
+    else -> value?.let { it::class.simpleName } ?: "null"
+}
+
+private fun mismatch(c: Char, value: Any?): Nothing =
+    throw IllegalArgumentException("$c != ${typeName(value)}")
+
+private fun convert(c: Char, value: Any?, spec: Spec, locale: String): String = when (c) {
+    'b', 'B' -> {
+        val text = when (value) {
+            null -> "false"
+            is Boolean -> value.toString()
+            else -> "true"
+        }
+        justify(spec, precise(spec, if (c == 'B') text.uppercase() else text))
+    }
+    's', 'S' -> {
+        val text = precise(spec, value.toString())
+        justify(spec, if (c == 'S') text.uppercase() else text)
+    }
+    'c', 'C' -> {
+        val text = when (value) {
+            null -> "null"
+            is Char -> value.toString()
+            is Int -> codePoint(value)
+            is Byte -> codePoint(value.toInt())
+            is Short -> codePoint(value.toInt())
+            else -> mismatch(c, value)
+        }
+        justify(spec, if (c == 'C') text.uppercase() else text)
+    }
+    'd' -> when (value) {
+        null -> justify(spec, "null")
+        is Int -> decimal(spec, value.toString(), symbols(locale))
+        is Long -> decimal(spec, value.toString(), symbols(locale))
+        is Short -> decimal(spec, value.toString(), symbols(locale))
+        is Byte -> decimal(spec, value.toString(), symbols(locale))
+        else -> mismatch(c, value)
+    }
+    'x', 'X', 'o' -> {
+        val radix = if (c == 'o') 8 else 16
+        val digits = when (value) {
+            null -> null
+            is Int -> value.toUInt().toString(radix)
+            is Long -> value.toULong().toString(radix)
+            is Short -> (value.toInt() and 0xffff).toString(radix)
+            is Byte -> (value.toInt() and 0xff).toString(radix)
+            else -> mismatch(c, value)
+        }
+        if (digits == null) justify(spec, "null")
+        else {
+            val prefix = if (spec.has('#')) (if (radix == 16) "0x" else "0") else ""
+            var body = digits
+            if (spec.has('0')) body = body.padStart(spec.width - prefix.length, '0')
+            val text = prefix + body
+            justify(spec, if (c == 'X') text.uppercase() else text)
+        }
+    }
+    'f' -> when (value) {
+        null -> justify(spec, "null")
+        is Double -> fixed(spec, value, symbols(locale))
+        is Float -> fixed(spec, value.toDouble(), symbols(locale))
+        else -> mismatch(c, value)
+    }
+    else -> throw UnsupportedOperationException("peach kotlin: conversion ${spec.text} is not supported")
+}
+
+private fun codePoint(value: Int): String =
+    if (value < 0x10000) value.toChar().toString()
+    else {
+        val offset = value - 0x10000
+        charArrayOf((0xd800 + (offset shr 10)).toChar(), (0xdc00 + (offset and 0x3ff)).toChar()).concatToString()
+    }
+
+private fun precise(spec: Spec, text: String) =
+    if (spec.precision >= 0 && spec.precision < text.length) text.take(spec.precision) else text
+
+// Formatter.print(long): the sign, then the localized magnitude zero padded
+// to the width, then the closing parenthesis, then the justification
+private fun decimal(spec: Spec, value: String, symbols: Symbols): String {
+    val negative = value.startsWith('-')
+    return signed(spec, negative, value.removePrefix("-"), symbols)
+}
+
+private fun signed(spec: Spec, negative: Boolean, magnitude: String, symbols: Symbols): String {
+    val out = StringBuilder()
+    if (negative) out.append(if (spec.has('(')) '(' else '-')
+    else if (spec.has('+')) out.append('+')
+    else if (spec.has(' ')) out.append(' ')
+    val width = if (spec.width != -1 && negative && spec.has('(')) spec.width - 1 else spec.width
+    localized(out, magnitude, spec, width, symbols)
+    if (negative && spec.has('(')) out.append(')')
+    return justify(spec, out.toString())
+}
+
+// Formatter.localizedMagnitude: each digit in the locale's digits, grouped
+// by three with the ',' flag, the decimal separator in place of the point,
+// and zero padding inserted after the sign
+private fun localized(out: StringBuilder, value: String, spec: Spec, width: Int, symbols: Symbols) {
+    val begin = out.length
+    val dot = value.indexOf('.').let { if (it == -1) value.length else it }
+    var group = spec.has(',')
+    for (index in value.indices) {
+        if (index == dot) {
+            out.append(symbols.decimal)
+            group = false
+            continue
+        }
+        out.append(symbols.zero + (value[index] - '0'))
+        if (group && index != dot - 1 && (dot - index) % 3 == 1) out.append(symbols.group)
+    }
+    if (width != -1 && spec.has('0')) while (out.length < width) out.insert(begin, symbols.zero)
+}
+
+// Formatter.print(double) for %f: the shortest decimal digits of the value,
+// rounded half up to the precision, as FormattedFloatingDecimal does
+private fun fixed(spec: Spec, value: Double, symbols: Symbols): String {
+    if (value.isNaN()) return justify(spec, "NaN")
+    val negative = value < 0.0 || (value == 0.0 && 1.0 / value < 0.0)
+    if (value.isInfinite()) {
+        val text = if (negative) (if (spec.has('(')) "(Infinity)" else "-Infinity")
+        else if (spec.has('+')) "+Infinity" else if (spec.has(' ')) " Infinity" else "Infinity"
+        return justify(spec, text)
+    }
+    val precision = if (spec.precision == -1) 6 else spec.precision
+    var magnitude = roundHalfUp(shortestDigits(kotlin.math.abs(value)), precision)
+    if (precision == 0 && spec.has('#')) magnitude += "."
+    return signed(spec, negative, magnitude, symbols)
+}
+
+// the shortest round trip decimal of a finite non negative double as plain
+// digits and a point, the digits Double.toString prints
+private fun shortestDigits(value: Double): String {
+    val text = value.toString()
+    val exponentAt = text.indexOfFirst { it == 'e' || it == 'E' }
+    if (exponentAt == -1) return text
+    val mantissa = text.substring(0, exponentAt)
+    val exponent = text.substring(exponentAt + 1).toInt()
+    val point = mantissa.indexOf('.').let { if (it == -1) mantissa.length else it }
+    val digits = mantissa.replace(".", "")
+    val shifted = point + exponent
+    return when {
+        shifted <= 0 -> "0." + "0".repeat(-shifted) + digits
+        shifted >= digits.length -> digits + "0".repeat(shifted - digits.length)
+        else -> digits.substring(0, shifted) + "." + digits.substring(shifted)
+    }
+}
+
+private fun roundHalfUp(decimal: String, precision: Int): String {
+    val point = decimal.indexOf('.')
+    val whole = if (point == -1) decimal else decimal.substring(0, point)
+    val fraction = if (point == -1) "" else decimal.substring(point + 1)
+    if (fraction.length <= precision) {
+        val padded = fraction.padEnd(precision, '0')
+        return if (precision == 0) whole else "$whole.$padded"
+    }
+    val kept = (whole + fraction.substring(0, precision)).toCharArray()
+    if (fraction[precision] >= '5') {
+        var carry = true
+        var index = kept.size - 1
+        while (carry && index >= 0) {
+            if (kept[index] == '9') kept[index] = '0'
+            else {
+                kept[index] = kept[index] + 1
+                carry = false
+            }
+            index--
+        }
+        val digits = (if (carry) "1" else "") + kept.concatToString()
+        val wholeLength = digits.length - precision
+        return if (precision == 0) digits else digits.substring(0, wholeLength) + "." + digits.substring(wholeLength)
+    }
+    val digits = kept.concatToString()
+    return if (precision == 0) digits else digits.substring(0, whole.length) + "." + digits.substring(whole.length)
+}

package/kotlin/AppSources/dev/peach/app/PeachApp.kt

@@ -20,6 +20,8 @@ import androidx.activity.compose.LocalOnBackPressedDispatcherOwner
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.PlatformArchitectureComponentsOwner
 import androidx.compose.ui.platform.PlatformInsets
 import androidx.compose.ui.platform.PlatformWindowInsets
@@ -27,6 +29,7 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.key
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.neverEqualPolicy
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.text.font.FontFamily
 import androidx.lifecycle.Lifecycle
@@ -130,13 +133,17 @@ private class AppProcess(
     var reportedNight = false
     // the software keyboard's height above the screen's bottom edge, in pixels
     var ime by mutableIntStateOf(0)
+    // the configuration the content view composes with: a copy the view's
+    // configuration change replaces, as AndroidComposeView's observer does
+    val configuration = mutableStateOf(Configuration(), neverEqualPolicy())
 }
 
 private var process: AppProcess? = null
 
-private fun nightConfiguration(night: Boolean) = Configuration().apply {
+private fun deviceConfiguration(night: Boolean, locale: String) = Configuration().apply {
     uiMode = Configuration.UI_MODE_TYPE_NORMAL or
         if (night) Configuration.UI_MODE_NIGHT_YES else Configuration.UI_MODE_NIGHT_NO
+    localeTag = locale
 }
 
 // a cold start in ActivityThread's order: the Application and its onCreate,
@@ -153,7 +160,7 @@ internal fun peachStartApp(
     try {
         require(backend == "graphite" || backend == "raster")
         preparePeachDevice(locale)
-        processResources = Resources(nightConfiguration(night))
+        processResources = Resources(deviceConfiguration(night, locale))
         val application = spec.createApplication()
         application.onCreate()
         val app = AppProcess(
@@ -235,12 +242,20 @@ private fun launchActivity(app: AppProcess, lastNonConfigurationInstance: Any?):
         insets = DeviceInsets(window, app.insets) { app.ime },
         clockRunning = { componentActivity == null || componentActivity.lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED) },
     )
+    app.configuration.value = Configuration().apply { setTo(activity.resources.configuration) }
     mount.setContent {
         val content = @Composable { held?.let { view -> key(place) { view.Content() } }; Unit }
-        // the content view's tree resolves the activity as its back dispatcher owner
-        if (componentActivity != null)
-            CompositionLocalProvider(LocalOnBackPressedDispatcherOwner provides componentActivity, content = content)
-        else content()
+        // the content view's context is the activity, its configuration the
+        // copy above, and its tree resolves the activity as its back
+        // dispatcher owner
+        CompositionLocalProvider(
+            LocalContext provides activity,
+            LocalConfiguration provides app.configuration.value,
+        ) {
+            if (componentActivity != null)
+                CompositionLocalProvider(LocalOnBackPressedDispatcherOwner provides componentActivity, content = content)
+            else content()
+        }
     }
     if (app.mountId == 0) app.mountId = addMount(mount)
     else {
@@ -319,6 +334,7 @@ private fun reportConfiguration(app: AppProcess): Boolean {
     }
     app.reportedNight = isNight(configuration)
     app.activity.performConfigurationChanged(Configuration().apply { setTo(configuration) })
+    app.configuration.value = Configuration().apply { setTo(configuration) }
     app.mount.night = app.reportedNight
     return false
 }
@@ -341,7 +357,7 @@ internal fun peachAppNight(night: Boolean) {
     val app = runningApp()
     val configuration = processResources.configuration
     if (isNight(configuration) == night) return
-    configuration.setTo(nightConfiguration(night))
+    configuration.setTo(deviceConfiguration(night, app.locale))
     app.application.onConfigurationChanged(Configuration().apply { setTo(configuration) })
     if (!app.stopped) reportConfiguration(app)
 }

package/kotlin/fixtures/kotlin-app-variants/Strings.kt

@@ -0,0 +1,49 @@
+package dev.contrast.kotlinapp
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.pluralStringResource
+import androidx.compose.ui.res.stringArrayResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+
+// string, plural and array resources read through the compose helpers and
+// the context, each line showing what aapt2 compiled, the plural rule chose
+// and String.format made of one rule
+@Composable
+fun StringsScreen() {
+    val context = LocalContext.current
+    Column(
+        Modifier.fillMaxSize().background(Color(0xFFE8EEF8)).safeDrawingPadding().padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        Text(stringResource(R.string.title))
+        Text(stringResource(R.string.greeting, "Ada", 3))
+        Text("[" + stringResource(R.string.spaced) + "]")
+        Text("[" + stringResource(R.string.quoted) + "]")
+        Text(context.getString(R.string.escaped))
+        Text(stringResource(R.string.styled))
+        Text(stringResource(R.string.entity))
+        Text(stringResource(R.string.percent))
+        Text(stringResource(R.string.numbers, 1234567, 1.005, 42, 255, "ab"))
+        Text(context.resources.getString(R.string.numbers, -7, 2.5, -3, -1, "x"))
+        Text(stringResource(R.string.signs, 5, -5, 1234.5678, 0.125f))
+        Text(
+            pluralStringResource(R.plurals.messages, 0, 0) + " / " +
+                pluralStringResource(R.plurals.messages, 1, 1) + " / " +
+                pluralStringResource(R.plurals.messages, 2, 2),
+        )
+        Text(pluralStringResource(R.plurals.only_other, 1) + " / " + context.resources.getQuantityString(R.plurals.messages, 1, 1))
+        Text(stringArrayResource(R.array.planets).joinToString("|"))
+        Text(context.resources.getStringArray(R.array.seasons).joinToString("|"))
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.674",
+  "version": "0.1.675",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",