peachsim 0.1.2193 → 0.1.2195

package/src/kotlin-app.ts

@@ -19,6 +19,7 @@ import frameworkThemes from './generated/android-framework-themes.json' with { t
 import { isRecord } from './is-record'
 import { composeBomVersions } from './kotlin-compose-bom'
 import { KotlinVersionCatalog } from './kotlin-version-catalog'
+import type { AndroidGradleDependency } from './androidGradleContract'
 
 // statusBarColor and navigationBarColor are ARGB
 export interface KotlinWindowTheme {
@@ -35,6 +36,7 @@ export interface KotlinAppProject {
   projectDir: string
   moduleDir: string
   sources: string[]
+  javaSources: string[]
   language: string
   usesSerialization: boolean
   packageName: string
@@ -93,6 +95,7 @@ const PLUGINS = new Set([
 // match their Android pins (Peach's activity actuals are that version's); the
 // lifecycle and savedstate artifacts are Peach's platform actuals.
 const PLATFORM_GROUPS = new Set(['androidx.lifecycle', 'androidx.savedstate'])
+const PLATFORM_ARTIFACTS = new Set(['androidx.databinding:viewbinding'])
 // pinned by group, or by group and artifact where a group's artifacts version
 // apart (material-icons-core stopped at 1.7, beside material-ripple)
 const ANDROID_PIN: Record<string, keyof AndroidPins> = {
@@ -104,10 +107,12 @@ const ANDROID_PIN: Record<string, keyof AndroidPins> = {
   'androidx.navigation': 'navigation',
   'androidx.activity': 'activity',
   'org.jetbrains.kotlinx:kotlinx-serialization-core': 'serializationCore',
+  'org.jetbrains.kotlinx:kotlinx-serialization-core-jvm': 'serializationCore',
   'org.jetbrains.kotlin:kotlin-stdlib': 'kotlin',
   'org.jetbrains.kotlin:kotlin-stdlib-jdk7': 'kotlin',
   'org.jetbrains.kotlin:kotlin-stdlib-jdk8': 'kotlin',
   'org.jetbrains.kotlinx:kotlinx-coroutines-core': 'coroutines',
+  'org.jetbrains.kotlinx:kotlinx-coroutines-core-jvm': 'coroutines',
   'org.jetbrains.kotlinx:kotlinx-coroutines-android': 'coroutines',
 }
 
@@ -242,6 +247,7 @@ async function checkModuleGradle(
   gradle: { file: string; text: string },
   pins: AndroidPins,
   catalog: KotlinVersionCatalog,
+  nativeDependencies: readonly AndroidGradleDependency[] | null,
 ) {
   const at = (index: number) => `${gradle.file}:${lineOf(gradle.text, index)}`
   const coordinates = (value: string, where: string): string[] => {
@@ -260,7 +266,13 @@ async function checkModuleGradle(
     const plugin = match[3]
       ? catalog.plugin(match[3], at(match.index)).id
       : (match[1] ?? `org.jetbrains.kotlin.${match[2]}`)
-    if (!PLUGINS.has(plugin))
+    if (
+      !PLUGINS.has(plugin) &&
+      !(
+        nativeDependencies !== null &&
+        (plugin === 'com.google.devtools.ksp' || plugin === 'io.gitlab.arturbosch.detekt')
+      )
+    )
       throw new Error(`${at(match.index)}: plugin ${plugin} is not supported by Peach`)
     if (
       plugin === 'org.jetbrains.kotlin.plugin.serialization' &&
@@ -270,53 +282,66 @@ async function checkModuleGradle(
     )
       usesSerialization = true
   }
-  for (const block of gradle.text.matchAll(/\bdependencies\s*\{/g)) {
-    // the block runs to its matching brace, on one line or many; every
-    // statement in it must be a literal dependency Peach can check
-    const start = block.index + block[0].length
-    let depth = 1
-    let end = start
-    for (; end < gradle.text.length && depth > 0; end++) {
-      if (gradle.text[end] === '{') depth++
-      else if (gradle.text[end] === '}') depth--
+  if (nativeDependencies !== null) {
+    for (const dependency of nativeDependencies) {
+      if (dependency.kind !== 'module')
+        throw new Error(
+          `${gradle.file}: ${dependency.kind} dependency ${dependency.name} is not in Peach's Kotlin closure`,
+        )
+      dependencies.push({
+        coordinate: `${dependency.group}:${dependency.name}:${dependency.version}`,
+        where: gradle.file,
+      })
     }
-    if (depth > 0) throw new Error(`${at(block.index)}: dependencies block never closes`)
-    const body = gradle.text.slice(start, end - 1)
-    const platformVariables = new Map<string, string>()
-    for (const statement of body.matchAll(/[^\n;]+/g)) {
-      const text = statement[0].replace(/\/\/.*$/, '').trim()
-      if (!text) continue
-      const where = at(start + statement.index)
-      const variable = /^val\s+(\w+)\s*=\s*(platform\(.*\))$/.exec(text)
-      if (variable?.[1] && variable[2]) {
-        platformVariables.set(variable[1], variable[2])
-        continue
+  } else
+    for (const block of gradle.text.matchAll(/\bdependencies\s*\{/g)) {
+      // the block runs to its matching brace, on one line or many; every
+      // statement in it must be a literal dependency Peach can check
+      const start = block.index + block[0].length
+      let depth = 1
+      let end = start
+      for (; end < gradle.text.length && depth > 0; end++) {
+        if (gradle.text[end] === '{') depth++
+        else if (gradle.text[end] === '}') depth--
       }
-      const call = /^(\w+)\s*\(\s*(.*?)\s*\)$/.exec(text)
-      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 platform = /^platform\(\s*(.*?)\s*\)$/.exec(
-        platformVariables.get(value) ?? value,
-      )
-      if (platform?.[1]) {
-        const declared = coordinates(platform[1], where)
-        if (declared.length !== 1 || !declared[0])
-          throw new Error(`${where}: platform expects one BOM coordinate`)
-        for (const [name, version] of await composeBomVersions(declared[0])) {
-          const previous = platforms.get(name)
-          if (previous && previous !== version)
-            throw new Error(
-              `${where}: conflicting BOM versions ${previous} and ${version} for ${name}`,
-            )
-          platforms.set(name, version)
+      if (depth > 0)
+        throw new Error(`${at(block.index)}: dependencies block never closes`)
+      const body = gradle.text.slice(start, end - 1)
+      const platformVariables = new Map<string, string>()
+      for (const statement of body.matchAll(/[^\n;]+/g)) {
+        const text = statement[0].replace(/\/\/.*$/, '').trim()
+        if (!text) continue
+        const where = at(start + statement.index)
+        const variable = /^val\s+(\w+)\s*=\s*(platform\(.*\))$/.exec(text)
+        if (variable?.[1] && variable[2]) {
+          platformVariables.set(variable[1], variable[2])
+          continue
+        }
+        const call = /^(\w+)\s*\(\s*(.*?)\s*\)$/.exec(text)
+        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 platform = /^platform\(\s*(.*?)\s*\)$/.exec(
+          platformVariables.get(value) ?? value,
+        )
+        if (platform?.[1]) {
+          const declared = coordinates(platform[1], where)
+          if (declared.length !== 1 || !declared[0])
+            throw new Error(`${where}: platform expects one BOM coordinate`)
+          for (const [name, version] of await composeBomVersions(declared[0])) {
+            const previous = platforms.get(name)
+            if (previous && previous !== version)
+              throw new Error(
+                `${where}: conflicting BOM versions ${previous} and ${version} for ${name}`,
+              )
+            platforms.set(name, version)
+          }
+        } else {
+          for (const coordinate of coordinates(value, where))
+            dependencies.push({ coordinate, where })
         }
-      } else {
-        for (const coordinate of coordinates(value, where))
-          dependencies.push({ coordinate, where })
       }
     }
-  }
   for (const { coordinate, where } of dependencies) {
     const parts = /^([^:]+):([^:]+)(?::([^:]+))?$/.exec(coordinate)
     if (!parts)
@@ -336,7 +361,7 @@ async function checkModuleGradle(
         throw new Error(
           `${where}: ${name}:${version} differs from Peach's ${pin} pin ${pins[pin]}`,
         )
-    } else if (!PLATFORM_GROUPS.has(group))
+    } else if (!PLATFORM_GROUPS.has(group) && !PLATFORM_ARTIFACTS.has(name))
       throw new Error(`${where}: ${name} is not in Peach's Kotlin closure`)
   }
   return { usesSerialization }
@@ -498,7 +523,7 @@ function isLauncher(element: XmlElement): boolean {
 
 export async function readKotlinApp(
   moduleArg: string,
-  options: { activity?: string; pins: AndroidPins },
+  options: { activity?: string; variant?: string; pins: AndroidPins },
 ): Promise<KotlinAppProject> {
   const moduleDir = fs.realpathSync(path.resolve(moduleArg))
   const manifestFile = path.join(moduleDir, 'src/main/AndroidManifest.xml')
@@ -520,12 +545,42 @@ export async function readKotlinApp(
   const gradle = readGradle(moduleDir)
   if (!gradle) throw new Error(`${moduleDir} has no build.gradle`)
   const catalog = new KotlinVersionCatalog(projectDir)
-  const { usesSerialization } = await checkModuleGradle(gradle, options.pins, catalog)
-  const namespace = gradleLiteral(gradle, 'namespace', '"[\\w.]+"', catalog)
-  const applicationId = gradleLiteral(gradle, 'applicationId', '"[\\w.]+"', catalog)
-  const targetSdk = Number(
-    gradleLiteral(gradle, 'targetSdk(?:Version)?', '\\d+', catalog),
+  const variant = options.variant
+  const selected =
+    variant === undefined
+      ? null
+      : await (async () => {
+          const { resolveAndroidGradleSources } = await import('./android-gradle-sources')
+          const [model] = await resolveAndroidGradleSources({
+            root: projectDir,
+            projects: [moduleDir],
+            variant,
+          })
+          if (!model || model.applicationId === null || model.targetSdk === null)
+            throw new Error(
+              `${moduleDir}: ${options.variant} is not an Android application variant`,
+            )
+          return {
+            ...model,
+            applicationId: model.applicationId,
+            targetSdk: model.targetSdk,
+          }
+        })()
+  const { usesSerialization } = await checkModuleGradle(
+    gradle,
+    options.pins,
+    catalog,
+    selected?.dependencies ?? null,
   )
+  const namespace = selected
+    ? selected.namespace
+    : gradleLiteral(gradle, 'namespace', '"[\\w.]+"', catalog)
+  const applicationId = selected
+    ? selected.applicationId
+    : gradleLiteral(gradle, 'applicationId', '"[\\w.]+"', catalog)
+  const targetSdk = selected
+    ? selected.targetSdk
+    : Number(gradleLiteral(gradle, 'targetSdk(?:Version)?', '\\d+', catalog))
   if (!Number.isInteger(targetSdk) || targetSdk <= 0)
     throw new Error(`${gradle.file}: declares no literal targetSdk`)
   const kotlin = kotlinPluginVersion(projectDir, gradle, catalog)
@@ -658,21 +713,22 @@ export async function readKotlinApp(
   if (!softInputAdjust)
     throw new Error(`${manifestFile}: unknown windowSoftInputMode ${adjust}`)
 
-  const sources: string[] = []
-  for (const set of ['java', 'kotlin']) {
-    const dir = path.join(moduleDir, 'src/main', set)
-    if (!fs.existsSync(dir)) continue
-    const walk = (current: string) => {
-      for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-        const full = path.join(current, entry.name)
-        if (entry.isDirectory()) walk(full)
-        else if (entry.name.endsWith('.java'))
-          throw new Error(`${full}: Java sources are not supported by peach open`)
-        else if (entry.name.endsWith('.kt')) sources.push(full)
+  const sources: string[] = selected ? selected.kotlin : []
+  if (!selected)
+    for (const set of ['java', 'kotlin']) {
+      const dir = path.join(moduleDir, 'src/main', set)
+      if (!fs.existsSync(dir)) continue
+      const walk = (current: string) => {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+          const full = path.join(current, entry.name)
+          if (entry.isDirectory()) walk(full)
+          else if (entry.name.endsWith('.java'))
+            throw new Error(`${full}: Java sources are not supported by peach open`)
+          else if (entry.name.endsWith('.kt')) sources.push(full)
+        }
       }
+      walk(dir)
     }
-    walk(dir)
-  }
   if (sources.length === 0)
     throw new Error(`${moduleDir}/src/main holds no Kotlin sources`)
   const resources = {
@@ -683,6 +739,7 @@ export async function readKotlinApp(
     projectDir,
     moduleDir,
     sources: sources.sort(),
+    javaSources: selected ? selected.java : [],
     language,
     usesSerialization,
     packageName: applicationId ?? base,

package/src/kotlin-host.ts

@@ -918,6 +918,7 @@ export async function kotlinAppArtifact(
       toolchain,
       language: app.language,
       sources: app.sources,
+      javaSpecs: app.javaSources,
       generated,
       sdkProfile: 'app',
       usesCompose: true,

package/src/kotlinSdkContract.ts

@@ -37,12 +37,19 @@ export const KOTLIN_SDK_PROFILES = {
       'BridgeSources',
       'AndroidViewSources',
       'ComposeSources',
+      'AndroidComposeSources',
       'ExpoComposeSources',
     ],
   },
   app: {
     compose: true,
-    directories: [...platform, 'ComposeSources', 'AppSources', 'AndroidViewSources'],
+    directories: [
+      ...platform,
+      'ComposeSources',
+      'AppSources',
+      'AndroidViewSources',
+      'AndroidComposeSources',
+    ],
   },
 } satisfies Record<string, { compose: boolean; directories: string[] }>