peachsim 0.1.2199 → 0.1.2200

package/src/kotlin-app.ts

@@ -6,6 +6,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { readAndroidDrawables, type AndroidDrawable } from './android-drawables'
+import { readAndroidLayoutIds, type AndroidLayoutIds } from './android-layout-ids'
 import { readAndroidStrings, type AndroidStringResources } from './android-strings'
 import {
   readResourceValues,
@@ -18,6 +19,7 @@ import { parseXml, type XmlElement } from './android-xml'
 import frameworkThemes from './generated/android-framework-themes.json' with { type: 'json' }
 import { isRecord } from './is-record'
 import { composeBomVersions } from './kotlin-compose-bom'
+import { mavenKotlinSources } from './kotlin-maven-sources'
 import { KotlinVersionCatalog } from './kotlin-version-catalog'
 import type { AndroidGradleDependency } from './androidGradleContract'
 
@@ -60,6 +62,7 @@ export interface KotlinAppProject {
   strings: AndroidStringResources
   colors: KotlinAppColor[]
   drawables: AndroidDrawable[]
+  layoutIds: AndroidLayoutIds
 }
 
 // a color resource's ARGB in the day and the night configuration
@@ -244,6 +247,7 @@ function kotlinPluginVersion(
 }
 
 async function checkModuleGradle(
+  projectDir: string,
   gradle: { file: string; text: string },
   pins: AndroidPins,
   catalog: KotlinVersionCatalog,
@@ -258,7 +262,7 @@ async function checkModuleGradle(
     throw new Error(`${where}: ${value} is not a literal or catalog dependency`)
   }
   const platforms = new Map<string, string>()
-  const dependencies: { coordinate: string; where: string }[] = []
+  const dependencies: { coordinate: string; where: string; compile: boolean }[] = []
   let usesSerialization = false
   for (const match of gradle.text.matchAll(
     /\bid\(\s*"([^"]+)"\s*\)|\bkotlin\(\s*"([^"]+)"\s*\)|\balias\(\s*libs\.plugins\.([\w.]+)\s*\)/g,
@@ -291,6 +295,7 @@ async function checkModuleGradle(
       dependencies.push({
         coordinate: `${dependency.group}:${dependency.name}:${dependency.version}`,
         where: gradle.file,
+        compile: true,
       })
     }
   } else
@@ -321,6 +326,10 @@ async function checkModuleGradle(
         if (!call) throw new Error(`${where}: ${text} is not a literal dependency`)
         const [, configuration = '', value = ''] = call
         if (/^(test|androidTest|debug|release)/.test(configuration)) continue
+        const compile =
+          configuration === 'implementation' ||
+          configuration === 'api' ||
+          configuration === 'compileOnly'
         const platform = /^platform\(\s*(.*?)\s*\)$/.exec(
           platformVariables.get(value) ?? value,
         )
@@ -338,11 +347,13 @@ async function checkModuleGradle(
           }
         } else {
           for (const coordinate of coordinates(value, where))
-            dependencies.push({ coordinate, where })
+            dependencies.push({ coordinate, where, compile })
         }
       }
     }
-  for (const { coordinate, where } of dependencies) {
+  const librarySources: string[] = []
+  const seen = new Set<string>()
+  for (const { coordinate, where, compile } of dependencies) {
     const parts = /^([^:]+):([^:]+)(?::([^:]+))?$/.exec(coordinate)
     if (!parts)
       throw new Error(`${where}: ${coordinate} is not a group:artifact[:version]`)
@@ -361,10 +372,22 @@ async function checkModuleGradle(
         throw new Error(
           `${where}: ${name}:${version} differs from Peach's ${pin} pin ${pins[pin]}`,
         )
-    } else if (!PLATFORM_GROUPS.has(group) && !PLATFORM_ARTIFACTS.has(name))
-      throw new Error(`${where}: ${name} is not in Peach's Kotlin closure`)
+    } else if (!PLATFORM_GROUPS.has(group) && !PLATFORM_ARTIFACTS.has(name)) {
+      const sources = compile
+        ? await mavenKotlinSources(projectDir, { group, artifact, version }, where)
+        : null
+      if (!sources)
+        throw new Error(
+          `${where}: ${group}:${artifact}:${version} is not in Peach's Kotlin closure`,
+        )
+      for (const file of sources) {
+        if (seen.has(file)) continue
+        seen.add(file)
+        librarySources.push(file)
+      }
+    }
   }
-  return { usesSerialization }
+  return { usesSerialization, librarySources }
 }
 
 // Resources.selectDefaultTheme: the theme a context without one gets for its
@@ -566,7 +589,8 @@ export async function readKotlinApp(
             targetSdk: model.targetSdk,
           }
         })()
-  const { usesSerialization } = await checkModuleGradle(
+  const { usesSerialization, librarySources } = await checkModuleGradle(
+    projectDir,
     gradle,
     options.pins,
     catalog,
@@ -729,6 +753,7 @@ export async function readKotlinApp(
       }
       walk(dir)
     }
+  sources.push(...librarySources)
   if (sources.length === 0)
     throw new Error(`${moduleDir}/src/main holds no Kotlin sources`)
   const resources = {
@@ -757,5 +782,6 @@ export async function readKotlinApp(
     strings: readAndroidStrings(moduleDir),
     colors: readAppColors(moduleDir, resources),
     drawables: readAndroidDrawables(moduleDir, resources),
+    layoutIds: readAndroidLayoutIds(moduleDir),
   }
 }

package/src/kotlin-host.ts

@@ -18,6 +18,7 @@ import {
   type BridgeModule,
   type BridgeSelection,
 } from './android-bridge-packages'
+import { layoutViewClasses } from './android-view-classes'
 import { rnxHomeDir } from './home-paths'
 import { isRecord } from './is-record'
 import {
@@ -39,6 +40,7 @@ import {
   type ViewModelClass,
 } from './kotlin-view-models'
 import type { DayNight, DrawableFile } from './android-drawables'
+import type { XmlElement } from './android-xml'
 import type { ExpoKotlinModules } from './expo-kotlin-host'
 import type { KotlinAppProject, KotlinWindowTheme } from './kotlin-app'
 import type { KotlinSdkProfile, KotlinToolchain } from './kotlinSdkContract'
@@ -968,7 +970,7 @@ function appResourceSources(app: KotlinAppProject): Record<string, string> {
         .map(([locale, value]) => `${literal(locale)} to ${render(value)}`)
         .join(', ')})`,
     }))
-  const kinds = [
+  const tableKinds = [
     {
       type: 'string',
       table: 'peachAppStrings',
@@ -1007,6 +1009,16 @@ function appResourceSources(app: KotlinAppProject): Record<string, string> {
           .join(',\n')}\n)`,
       })),
     },
+    // a layout is its element tree; one only in a qualified directory has none
+    {
+      type: 'layout',
+      table: 'peachAppLayouts',
+      value: 'LayoutNode?',
+      entries: app.layoutIds.layouts.map((name) => {
+        const element = app.layoutIds.elements.get(name)
+        return { name, init: element ? layoutInit(element) : 'null' }
+      }),
+    },
     // the day and the night ARGB
     {
       type: 'color',
@@ -1017,19 +1029,38 @@ function appResourceSources(app: KotlinAppProject): Record<string, string> {
         init: `intArrayOf(${argb(color.day)}, ${argb(color.night)})`,
       })),
     },
-  ].map((kind, index) => ({
+  ]
+  // ids are named in R and in the name table; they hold no Resources value
+  const nameOnly = [{ type: 'id', names: app.layoutIds.ids }]
+  const numbered = <Kind extends { entries: Array<{ name: string }> }>(
+    kind: Kind,
+    index: number,
+  ): Omit<Kind, 'entries'> & {
+    entries: Array<Kind['entries'][number] & { id: string }>
+  } => ({
     ...kind,
     entries: kind.entries.map((entry, number) => ({
       ...entry,
       id: id(index + 1, number),
     })),
-  }))
+  })
+  const kinds = tableKinds.map((kind, index) => numbered(kind, index))
+  const viewClasses = layoutViewClasses(app.layoutIds.elements.values())
+  const rKinds = [
+    ...kinds,
+    ...nameOnly.map((kind, index) =>
+      numbered(
+        { type: kind.type, entries: kind.names.map((name) => ({ name })) },
+        kinds.length + index,
+      ),
+    ),
+  ]
   return {
     'R.kt': [
       `package ${app.namespace}`,
       '',
       'object R {',
-      ...kinds.flatMap((kind) => [
+      ...rKinds.flatMap((kind) => [
         `    object ${kind.type} {`,
         ...kind.entries.map(
           (entry) => `        const val ${field(entry.name)}: Int = ${entry.id}`,
@@ -1051,6 +1082,10 @@ function appResourceSources(app: KotlinAppProject): Record<string, string> {
         'androidx.compose.ui.graphics.vector.ImageVector',
         'androidx.compose.ui.graphics.vector.addPathNodes',
         'androidx.compose.ui.unit.Dp',
+        'android.content.Context',
+        'android.util.AttributeSet',
+        'android.view.LayoutNode',
+        'android.view.View',
       ].map((name) => `import ${name}`),
       '',
       ...kinds.flatMap((kind) => [
@@ -1059,16 +1094,45 @@ function appResourceSources(app: KotlinAppProject): Record<string, string> {
         ')',
         '',
       ]),
+      'internal val peachAppViews: Map<String, (Context, AttributeSet?) -> View> = mapOf(',
+      ...viewClasses.map(
+        (name) =>
+          `    ${literal(name)} to { context, attrs -> ${name}(context, attrs) },`,
+      ),
+      ')',
+      '',
+      `internal val peachAppNames: Map<Int, String> = mapOf(`,
+      ...rKinds.flatMap((kind) =>
+        kind.entries.map(
+          (entry) =>
+            `    ${entry.id} to ${literal(`${app.packageName}:${kind.type}/${entry.name}`)},`,
+        ),
+      ),
+      ')',
+      '',
       'internal val compiledAppResources = PeachAppResources(',
       ...kinds.map(
         (kind) =>
           `    ${kind.table.slice('peachApp'.length).toLowerCase()} = ${kind.table},`,
       ),
+      '    views = peachAppViews,',
+      '    names = peachAppNames,',
       ')',
     ].join('\n'),
   }
 }
 
+// the elements a layout inflates, without the namespace declarations and
+// tools attributes aapt2 strips
+function layoutInit(element: XmlElement): string {
+  const attributes = Object.entries(element.attributes)
+    .filter(([key]) => !key.startsWith('xmlns') && !key.startsWith('tools:'))
+    .map(([key, value]) => `${literal(key)} to ${literal(value)}`)
+  return `LayoutNode(${literal(element.name)}, mapOf(${attributes.join(', ')}), listOf(${element.children
+    .map(layoutInit)
+    .join(', ')}))`
+}
+
 // a drawable file's table entry: a vector as the ImageVector.Builder calls
 // XmlVectorParser makes, its colors chosen by the configuration's night
 // mode; a bitmap as its encoded bytes
@@ -1171,11 +1235,19 @@ async function compileKotlin(
   const sdk = await loadKotlinSdk(moduleRoot, toolchain)
   const plugin = path.join(sdk.root, 'plugin.jar')
   const sdkLibrary = path.join(sdk.root, `${sdkProfile}.klib`)
-  const java = javaSpecs.length
+  const javaRead = javaSpecs.length
     ? await readJavaModuleSpecs(javaSpecs, sdk.root, await ensureToolchain(toolchain))
     : null
+  const java =
+    javaRead && javaRead.specs.some((spec) => !spec.application)
+      ? { ...javaRead, specs: javaRead.specs.filter((spec) => !spec.application) }
+      : null
+  const applicationJava = javaRead?.specs.filter((spec) => spec.application) ?? []
   const generated = {
     ...sourceGenerated,
+    ...Object.fromEntries(
+      applicationJava.map((spec, index) => [`JavaApplication${index}.kt`, spec.source]),
+    ),
     'PeachBindingsInitialization.kt': [
       '@file:OptIn(kotlin.js.ExperimentalJsExport::class)',
       'package dev.peach.jni',
@@ -1209,7 +1281,7 @@ async function compileKotlin(
       sdk: sdk.sha256,
       sdkProfile,
       usesSerialization,
-      java: java?.sha256,
+      java: javaRead?.sha256,
     }),
   )
   for (const { file, bytes } of inputs)
@@ -1442,6 +1514,11 @@ async function compileKotlin(
         : ''
       for (const [name, source] of Object.entries(origins))
         output = output.replaceAll(path.join(generatedDir, name), source)
+      for (const [index, spec] of applicationJava.entries())
+        output = output.replaceAll(
+          path.join(generatedDir, `JavaApplication${index}.kt`),
+          spec.file,
+        )
       for (const { file, target } of compiledSources)
         output = output
           .replaceAll(target, file)

package/src/kotlin-maven-sources.ts

@@ -0,0 +1,248 @@
+// a dependency outside Peach's pinned closure compiles from the sources jar
+// the app's Maven repositories publish for that coordinate
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { inflateRawSync } from 'node:zlib'
+
+const pending = new Map<string, Promise<string[]>>()
+
+function braceBlock(text: string, from: number): { body: string; end: number } | null {
+  const open = text.indexOf('{', from)
+  if (open < 0) return null
+  let depth = 0
+  for (let index = open; index < text.length; index++) {
+    const char = text[index]
+    if (char === '{') depth++
+    else if (char === '}') {
+      depth--
+      if (depth === 0) return { body: text.slice(open + 1, index), end: index }
+    }
+  }
+  return null
+}
+
+function repositoryRoot(value: string, where: string): string {
+  if (value.startsWith('https://')) return value.replace(/\/+$/, '')
+  if (value.startsWith('/')) return value.replace(/\/+$/, '')
+  if (value.startsWith('file:')) {
+    const pathname = new URL(value).pathname
+    if (!pathname.startsWith('/'))
+      throw new Error(`${where}: Maven repository ${value} is not a local path`)
+    return decodeURIComponent(pathname).replace(/\/+$/, '')
+  }
+  throw new Error(
+    `${where}: Maven repository ${value} is not an https URL or a local path`,
+  )
+}
+
+// google(), mavenCentral(), mavenLocal(), or one literal maven URL
+function withoutComments(text: string): string {
+  let out = ''
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index]
+    const next = text[index + 1]
+    if (char === '"' || char === "'") {
+      const quote = char
+      out += char
+      index++
+      while (index < text.length && text[index] !== quote) {
+        out += text[index]
+        if (text[index] === '\\') {
+          index++
+          out += text[index] ?? ''
+        }
+        index++
+      }
+      out += text[index] ?? ''
+      continue
+    }
+    if (char === '/' && next === '/') {
+      while (index < text.length && text[index] !== '\n') index++
+      out += '\n'
+      continue
+    }
+    if (char === '/' && next === '*') {
+      index += 2
+      while (index < text.length && !(text[index] === '*' && text[index + 1] === '/'))
+        index++
+      index++
+      continue
+    }
+    out += char
+  }
+  return out
+}
+
+function repositories(body: string, where: string): string[] {
+  const stripped = withoutComments(body)
+  const roots: string[] = []
+  const leftover = stripped.replace(
+    /\b(google|mavenCentral|mavenLocal)\s*\(\s*\)|\bmaven\s*(?:\(\s*["']([^"']+)["']\s*\)|\{([^{}]*)\})/g,
+    (match, name: string, direct: string | undefined, block: string | undefined) => {
+      if (name === 'google') roots.push('https://dl.google.com/dl/android/maven2')
+      else if (name === 'mavenCentral') roots.push('https://repo1.maven.org/maven2')
+      else if (name === 'mavenLocal')
+        roots.push(path.join(os.homedir(), '.m2', 'repository'))
+      else {
+        const declared = direct ?? /["']([^"']+)["']/.exec(block ?? '')?.[1]
+        if (!declared)
+          throw new Error(`${where}: ${match.trim()} declares no repository URL`)
+        roots.push(repositoryRoot(declared, where))
+      }
+      return ''
+    },
+  )
+  if (leftover.replace(/[\s;]/g, ''))
+    throw new Error(`${where}: ${leftover.trim()} is not a literal Maven repository`)
+  return roots
+}
+
+function mavenRepositories(projectDir: string, where: string): string[] {
+  const file = ['settings.gradle.kts', 'settings.gradle']
+    .map((name) => path.join(projectDir, name))
+    .find((candidate) => fs.existsSync(candidate))
+  if (!file) throw new Error(`${where}: ${projectDir} has no settings.gradle`)
+  const text = fs.readFileSync(file, 'utf8')
+  const management = text.search(/\bdependencyResolutionManagement\b/)
+  if (management < 0)
+    throw new Error(`${where}: ${file} declares no dependency repositories`)
+  const managed = braceBlock(text, management)
+  if (!managed)
+    throw new Error(`${where}: ${file} dependencyResolutionManagement block never closes`)
+  const repositoriesAt = managed.body.search(/\brepositories\b/)
+  if (repositoriesAt < 0)
+    throw new Error(`${where}: ${file} declares no dependency repositories`)
+  const block = braceBlock(managed.body, repositoriesAt)
+  if (!block) throw new Error(`${where}: ${file} repositories block never closes`)
+  const roots = repositories(block.body, `${where}: ${file}`)
+  if (roots.length === 0)
+    throw new Error(`${where}: ${file} declares no dependency repositories`)
+  return roots
+}
+
+function zipSources(bytes: Buffer, where: string): { name: string; data: Buffer }[] {
+  let end = -1
+  const earliest = Math.max(0, bytes.length - 22 - 0xffff)
+  for (let index = bytes.length - 22; index >= earliest; index--) {
+    if (bytes.readUInt32LE(index) === 0x06054b50) {
+      end = index
+      break
+    }
+  }
+  if (end < 0) throw new Error(`${where}: sources jar is not a zip`)
+  const count = bytes.readUInt16LE(end + 8)
+  if (count !== bytes.readUInt16LE(end + 10))
+    throw new Error(`${where}: sources jar spans zip disks`)
+  let offset = bytes.readUInt32LE(end + 16)
+  if (offset === 0xffffffff) throw new Error(`${where}: sources jar is zip64`)
+  const entries: { name: string; data: Buffer }[] = []
+  for (let index = 0; index < count; index++) {
+    if (bytes.readUInt32LE(offset) !== 0x02014b50)
+      throw new Error(`${where}: sources jar has a broken central directory`)
+    const flags = bytes.readUInt16LE(offset + 8)
+    const method = bytes.readUInt16LE(offset + 10)
+    const compressed = bytes.readUInt32LE(offset + 20)
+    const nameLength = bytes.readUInt16LE(offset + 28)
+    const extraLength = bytes.readUInt16LE(offset + 30)
+    const commentLength = bytes.readUInt16LE(offset + 32)
+    const localOffset = bytes.readUInt32LE(offset + 42)
+    const name = bytes.toString('utf8', offset + 46, offset + 46 + nameLength)
+    offset += 46 + nameLength + extraLength + commentLength
+    if (name.endsWith('/')) continue
+    if (flags & 1) throw new Error(`${where}: ${name} is encrypted`)
+    if (name.startsWith('/') || name.split('/').includes('..'))
+      throw new Error(`${where}: ${name} escapes the sources jar`)
+    if (bytes.readUInt32LE(localOffset) !== 0x04034b50)
+      throw new Error(`${where}: ${name} has no local header`)
+    const localName = bytes.readUInt16LE(localOffset + 26)
+    const localExtra = bytes.readUInt16LE(localOffset + 28)
+    const start = localOffset + 30 + localName + localExtra
+    const payload = bytes.subarray(start, start + compressed)
+    const data =
+      method === 0 ? Buffer.from(payload) : method === 8 ? inflateRawSync(payload) : null
+    if (!data) throw new Error(`${where}: ${name} uses zip method ${method}`)
+    entries.push({ name, data })
+  }
+  return entries
+}
+
+function extract(bytes: Buffer, where: string): Promise<string[]> {
+  const key = createHash('sha256').update(bytes).digest('hex')
+  const cached = pending.get(key)
+  if (cached) return cached
+  const request = (async () => {
+    const dest = path.join(os.tmpdir(), 'peach-maven-sources', key)
+    const marker = path.join(dest, '.complete')
+    if (!fs.existsSync(marker)) {
+      const entries = zipSources(bytes, where)
+      const java = entries.find((entry) => entry.name.endsWith('.java'))
+      if (java) throw new Error(`${where}: ${java.name} is a Java source`)
+      const kotlin = entries.filter((entry) => entry.name.endsWith('.kt'))
+      if (kotlin.length === 0) throw new Error(`${where}: sources jar has no Kotlin`)
+      const staging = `${dest}.partial-${process.pid}`
+      fs.rmSync(staging, { recursive: true, force: true })
+      for (const entry of kotlin) {
+        const file = path.join(staging, entry.name)
+        fs.mkdirSync(path.dirname(file), { recursive: true })
+        fs.writeFileSync(file, entry.data)
+      }
+      fs.writeFileSync(path.join(staging, '.complete'), '')
+      try {
+        fs.renameSync(staging, dest)
+      } catch (error) {
+        fs.rmSync(staging, { recursive: true, force: true })
+        if (!fs.existsSync(marker)) throw error
+      }
+    }
+    return fs
+      .readdirSync(dest, { recursive: true })
+      .flatMap((entry) => {
+        const name = String(entry)
+        return name.endsWith('.kt') ? [path.join(dest, name)] : []
+      })
+      .sort()
+  })().catch((error: unknown) => {
+    pending.delete(key)
+    throw error
+  })
+  pending.set(key, request)
+  return request
+}
+
+async function sourcesJar(
+  root: string,
+  group: string,
+  artifact: string,
+  version: string,
+): Promise<Buffer | null> {
+  const parts = [
+    ...group.split('.'),
+    artifact,
+    version,
+    `${artifact}-${version}-sources.jar`,
+  ]
+  if (root.startsWith('https://')) {
+    const url = `${root}/${parts.join('/')}`
+    const response = await fetch(url)
+    if (response.status === 404) return null
+    if (!response.ok) throw new Error(`${url} answered ${response.status}`)
+    return Buffer.from(await response.arrayBuffer())
+  }
+  const file = path.join(root, ...parts)
+  return fs.existsSync(file) ? fs.readFileSync(file) : null
+}
+
+export async function mavenKotlinSources(
+  projectDir: string,
+  coordinate: { group: string; artifact: string; version: string },
+  where: string,
+): Promise<string[] | null> {
+  const { group, artifact, version } = coordinate
+  for (const root of mavenRepositories(projectDir, where)) {
+    const jar = await sourcesJar(root, group, artifact, version)
+    if (jar) return extract(jar, `${where}: ${group}:${artifact}:${version}`)
+  }
+  return null
+}

package/src/native-prebuilt.ts

@@ -58,7 +58,7 @@ export function nativeEntryKey(inputs: Record<string, string>): string {
 export const nativeEntryPrefix = (kind: NativeEntryKind, name: string, key: string) =>
   `native/${kind}/${name}/${key}`
 
-const entryCache = (kind: NativeEntryKind, name: string, key: string) =>
+export const nativeEntryCache = (kind: NativeEntryKind, name: string, key: string) =>
   path.join(peachCacheDir(), 'native-prebuilt', kind, name, key)
 
 // one GET; a missing object is null. a network failure is a miss too, since a
@@ -111,7 +111,7 @@ export function fetchNativeEntry(
   name: string,
   key: string,
 ): string | null {
-  const dir = entryCache(kind, name, key)
+  const dir = nativeEntryCache(kind, name, key)
   const descriptorFile = path.join(dir, 'descriptor.json')
   if (fs.existsSync(descriptorFile)) return dir
   const base = `${NATIVE_PREBUILT_ORIGIN}/${nativeEntryPrefix(kind, name, key)}`