peachsim 0.1.673 → 0.1.675

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.673",
+  "version": "0.1.675",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",

package/src/android-strings.ts

@@ -0,0 +1,163 @@
+// an Android module's string resources as aapt2 compiles them: each
+// <string>, <plurals> and <string-array> under res/values and its locale
+// qualified directories, the text with its style tags removed (getString
+// returns the unstyled text) and aapt2's StringBuilder rules applied. a
+// qualifier Peach does not resolve yet, or a value that is a reference, is
+// rejected by name, never read as the default or as text.
+import fs from 'node:fs'
+import path from 'node:path'
+import { decodeXmlText } from './android-xml'
+
+// one resource's value per locale: '' for values, then a language or a
+// language and region as a BCP 47 tag (values-en-rGB is en-GB). the device
+// resolves a whole plurals or array resource to one locale, never per item
+export interface AndroidResource<Value> {
+  name: string
+  values: Record<string, Value>
+}
+
+export type PluralQuantity = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other'
+
+export interface AndroidStringResources {
+  strings: AndroidResource<string>[]
+  plurals: AndroidResource<Partial<Record<PluralQuantity, string>>>[]
+  arrays: AndroidResource<string[]>[]
+}
+
+const VALUES_DIR = /^values(?:-([a-z]{2,3})(?:-r([A-Z]{2}))?)?$/
+const ELEMENT =
+  /<(string|plurals|string-array)(?=[\s/>])([^>]*?)(?:\/>|>([\s\S]*?)<\/\1\s*>)/g
+const ITEM = /<item(?=[\s/>])([^>]*?)(?:\/>|>([\s\S]*?)<\/item\s*>)/g
+const NAME = /\bname\s*=\s*"([^"]*)"/
+const QUANTITY = /\bquantity\s*=\s*"([^"]*)"/
+const QUANTITIES: readonly PluralQuantity[] = [
+  'zero',
+  'one',
+  'two',
+  'few',
+  'many',
+  'other',
+]
+
+const isQuantity = (value: string): value is PluralQuantity =>
+  QUANTITIES.some((quantity) => quantity === value)
+
+export function readAndroidStrings(moduleDir: string): AndroidStringResources {
+  const strings = new Map<string, Record<string, string>>()
+  const plurals = new Map<
+    string,
+    Record<string, Partial<Record<PluralQuantity, string>>>
+  >()
+  const arrays = new Map<string, Record<string, string[]>>()
+  const res = path.join(moduleDir, 'src/main/res')
+  const dirs = fs.existsSync(res) ? fs.readdirSync(res).sort() : []
+  for (const dir of dirs) {
+    if (!dir.startsWith('values')) continue
+    const qualifier = VALUES_DIR.exec(dir)
+    for (const entry of fs.readdirSync(path.join(res, dir)).sort()) {
+      if (!entry.endsWith('.xml')) continue
+      const file = path.join(res, dir, entry)
+      const text = fs.readFileSync(file, 'utf8').replace(/<!--[\s\S]*?-->/g, '')
+      for (const match of text.matchAll(ELEMENT)) {
+        const kind = match[1] ?? ''
+        const name = NAME.exec(match[2] ?? '')?.[1]
+        if (!name) throw new Error(`${file}: a <${kind}> without a name`)
+        if (!qualifier)
+          throw new Error(
+            `${file}: ${kind} ${name} under ${dir} is not resolved by peach kotlin yet (only values, values-<language> and values-<language>-r<REGION>)`,
+          )
+        const locale = qualifier[2]
+          ? `${qualifier[1]}-${qualifier[2]}`
+          : (qualifier[1] ?? '')
+        const body = match[3] ?? ''
+        const where = `${file}: ${kind} ${name}`
+        if (kind === 'string')
+          add(strings, name, locale, compileString(body, where), where)
+        else if (kind === 'plurals') {
+          const items: Partial<Record<PluralQuantity, string>> = {}
+          for (const item of body.matchAll(ITEM)) {
+            const quantity = QUANTITY.exec(item[1] ?? '')?.[1] ?? ''
+            if (!isQuantity(quantity))
+              throw new Error(`${where} has an item with quantity "${quantity}"`)
+            if (quantity in items) throw new Error(`${where} defines ${quantity} twice`)
+            items[quantity] = compileString(item[2] ?? '', `${where} ${quantity}`)
+          }
+          add(plurals, name, locale, items, where)
+        } else
+          add(
+            arrays,
+            name,
+            locale,
+            [...body.matchAll(ITEM)].map((item, index) =>
+              compileString(item[2] ?? '', `${where} item ${index}`),
+            ),
+            where,
+          )
+      }
+    }
+  }
+  return { strings: sorted(strings), plurals: sorted(plurals), arrays: sorted(arrays) }
+}
+
+function add<Value>(
+  byName: Map<string, Record<string, Value>>,
+  name: string,
+  locale: string,
+  value: Value,
+  where: string,
+) {
+  const values = byName.get(name) ?? {}
+  if (locale in values) throw new Error(`${where} is defined twice for one locale`)
+  values[locale] = value
+  byName.set(name, values)
+}
+
+// the R class code compiles against lists only the resources the default
+// values define (AGP's ParseLibraryResourcesTask reads the unqualified
+// directories), so a resource only a qualified directory defines has no field
+const sorted = <Value>(
+  byName: Map<string, Record<string, Value>>,
+): AndroidResource<Value>[] =>
+  [...byName.entries()]
+    .filter(([, values]) => '' in values)
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .map(([name, values]) => ({ name, values }))
+
+// aapt2's StringBuilder over the decoded text: outside double quotes a run of
+// whitespace is one space and the ends are trimmed, an unescaped apostrophe is
+// an error; a double quote toggles quoting and is dropped; a backslash escapes
+// the next character (\n, \t and \uXXXX, any other character as itself). a
+// value beginning with @ or ? is a reference aapt2 resolves, which Peach does
+// not yet
+function compileString(raw: string, where: string): string {
+  const text = decodeXmlText(raw.replace(/<[^>]*>/g, ''), where)
+  if (/^\s*[@?]/.test(text))
+    throw new Error(`${where} is a resource reference, not resolved by peach kotlin yet`)
+  const out: { char: string; soft: boolean }[] = []
+  let quoted = false
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index] ?? ''
+    if (char === '\\') {
+      const next = text[index + 1]
+      if (next === undefined) break
+      index++
+      if (next === 'n') out.push({ char: '\n', soft: false })
+      else if (next === 't') out.push({ char: '\t', soft: false })
+      else if (next === 'u') {
+        const hex = text.slice(index + 1, index + 5)
+        if (!/^[0-9a-fA-F]{4}$/.test(hex))
+          throw new Error(`${where} has an invalid unicode escape \\u${hex}`)
+        out.push({ char: String.fromCharCode(Number.parseInt(hex, 16)), soft: false })
+        index += 4
+      } else out.push({ char: next, soft: false })
+    } else if (char === '"') quoted = !quoted
+    else if (char === "'" && !quoted)
+      throw new Error(`${where} has an unescaped apostrophe`)
+    else if (!quoted && /\s/.test(char)) {
+      if (out.at(-1)?.soft !== true) out.push({ char: ' ', soft: true })
+    } else out.push({ char, soft: false })
+  }
+  while (out[0]?.soft) out.shift()
+  while (out.at(-1)?.soft) out.pop()
+  return out.map((part) => part.char).join('')
+}

package/src/android-xml.ts

@@ -21,7 +21,7 @@ const ENTITIES: Record<string, string> = {
 const TAG = /<(\/?)([\w:.-]+)((?:\s+[\w:.-]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>/y
 const ATTRIBUTE = /([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g
 
-function decode(value: string, file: string): string {
+export function decodeXmlText(value: string, file: string): string {
   return value.replace(/&(#x[0-9a-fA-F]+|#\d+|\w+);/g, (_match, entity: string) => {
     if (entity.startsWith('#x'))
       return String.fromCodePoint(Number.parseInt(entity.slice(2), 16))
@@ -42,7 +42,7 @@ export function parseXml(text: string, file: string): XmlElement {
     const open = body.indexOf('<', index)
     const content = body.slice(index, open === -1 ? body.length : open)
     const parent = stack.at(-1)
-    if (parent && content.trim()) parent.text += decode(content, file)
+    if (parent && content.trim()) parent.text += decodeXmlText(content, file)
     if (open === -1) break
     TAG.lastIndex = open
     const match = TAG.exec(body)
@@ -59,7 +59,7 @@ export function parseXml(text: string, file: string): XmlElement {
     }
     const attributes: Record<string, string> = {}
     for (const [, key, double, single] of (rawAttributes ?? '').matchAll(ATTRIBUTE))
-      if (key) attributes[key] = decode(double ?? single ?? '', file)
+      if (key) attributes[key] = decodeXmlText(double ?? single ?? '', file)
     const element: XmlElement = { name, attributes, children: [], text: '' }
     stack.at(-1)?.children.push(element)
     if (!selfClosing) stack.push(element)

package/src/kotlin-app.ts

@@ -5,6 +5,7 @@
 
 import fs from 'node:fs'
 import path from 'node:path'
+import { readAndroidStrings, type AndroidStringResources } from './android-strings'
 import {
   frameworkColor,
   readResourceValues,
@@ -47,6 +48,8 @@ export interface KotlinAppProject {
   // how the activity's window meets the keyboard: pan over a covered focused
   // view, resize above the keyboard, or nothing
   softInputAdjust: 'pan' | 'resize' | 'nothing'
+  // the module's string resources, which its R class names
+  strings: AndroidStringResources
 }
 
 export interface AndroidPins {
@@ -501,5 +504,6 @@ export function readKotlinApp(
     predictiveBack,
     handlesUiMode,
     softInputAdjust,
+    strings: readAndroidStrings(moduleDir),
   }
 }