peachsim 0.1.674 → 0.1.675

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),
   }
 }

package/src/kotlin-host.ts

@@ -410,6 +410,7 @@ export async function kotlinAppArtifact(
     'PeachEntry.kt': entrySource([]),
     'PeachViews.kt': viewsSource([]),
     'PeachAppEntry.kt': appEntry([]),
+    ...appResourceSources(app),
   }
   const shims = [
     ...kotlinSources(path.join(moduleRoot, 'Sources')),
@@ -435,6 +436,103 @@ export async function kotlinAppArtifact(
   )
 }
 
+// the module's R class in its namespace and the string, plurals and array
+// tables Resources reads. an id is 0x7f, the type, then the entry in name
+// order. a device's ids also count the module's other resource types and the
+// resources its libraries merge in, which Peach does not build, so the
+// numbers themselves differ
+function appResourceSources(app: KotlinAppProject): Record<string, string> {
+  const escapes: Record<string, string> = {
+    '\\': '\\\\',
+    '"': '\\"',
+    $: '\\$',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+  }
+  const literal = (value: string) =>
+    `"${value.replace(
+      /[\\"$\u0000-\u001f]/g,
+      (char) => escapes[char] ?? `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`,
+    )}"`
+  // aapt2 writes a resource name's dots and dashes as underscores in R
+  const field = (name: string) => `\`${name.replace(/[.-]/g, '_')}\``
+  const id = (type: number, entry: number) =>
+    `0x7f${type.toString(16).padStart(2, '0')}${entry.toString(16).padStart(4, '0')}`
+  const kinds = [
+    {
+      type: 'string',
+      table: 'peachAppStrings',
+      value: 'String',
+      resources: app.strings.strings,
+    },
+    {
+      type: 'plurals',
+      table: 'peachAppPlurals',
+      value: 'Map<String, String>',
+      resources: app.strings.plurals,
+    },
+    {
+      type: 'array',
+      table: 'peachAppArrays',
+      value: 'List<String>',
+      resources: app.strings.arrays,
+    },
+  ].map((kind, index) => ({
+    ...kind,
+    entries: kind.resources.map((resource, entry) => ({
+      name: resource.name,
+      id: id(index + 1, entry),
+      values: Object.entries(resource.values).map(
+        ([locale, value]: [
+          string,
+          string | string[] | Partial<Record<string, string>>,
+        ]) =>
+          `${literal(locale)} to ${
+            typeof value === 'string'
+              ? literal(value)
+              : Array.isArray(value)
+                ? `listOf(${value.map(literal).join(', ')})`
+                : `mapOf(${Object.entries(value)
+                    .map(
+                      ([quantity, text]) =>
+                        `${literal(quantity)} to ${literal(text ?? '')}`,
+                    )
+                    .join(', ')})`
+          }`,
+      ),
+    })),
+  }))
+  return {
+    'R.kt': [
+      `package ${app.namespace}`,
+      '',
+      'object R {',
+      ...kinds.flatMap((kind) => [
+        `    object ${kind.type} {`,
+        ...kind.entries.map(
+          (entry) => `        const val ${field(entry.name)}: Int = ${entry.id}`,
+        ),
+        '    }',
+      ]),
+      '}',
+      '',
+    ].join('\n'),
+    'PeachAppResources.kt': [
+      'package dev.peach.app',
+      '',
+      ...kinds.flatMap((kind) => [
+        `internal val ${kind.table}: Map<Int, Map<String, ${kind.value}>> = mapOf(`,
+        ...kind.entries.map(
+          (entry) => `    ${entry.id} to mapOf(${entry.values.join(', ')}),`,
+        ),
+        ')',
+        '',
+      ]),
+    ].join('\n'),
+  }
+}
+
 async function compileKotlin(
   input: {
     root: string