peachsim 0.1.2198 → 0.1.2200

package/sdk/ios/System/Library/Frameworks/QuartzCore.framework/Headers/CoreAnimation.h

@@ -14,6 +14,7 @@
 #import <QuartzCore/CAEmitterCell.h>
 #import <QuartzCore/CAEmitterLayer.h>
 #import <QuartzCore/CAGradientLayer.h>
+#import <QuartzCore/CAMetalLayer.h>
 #import <QuartzCore/CAReplicatorLayer.h>
 #import <QuartzCore/CAScrollLayer.h>
 #import <QuartzCore/CAShapeLayer.h>

package/sdk/ios/System/Library/Frameworks/QuartzCore.framework/Modules/module.modulemap

@@ -8,5 +8,6 @@ framework module QuartzCore [system] {
   exclude header "CAFrameRateRange.h"
   exclude header "CATransform3D.h"
   exclude header "CABase.h"
+  exclude header "CAValueFunction.h"
   export *
 }

package/sdk/ios/System/Library/Frameworks/UIKitText.framework/Headers/UIKitText.apinotes

@@ -81,6 +81,20 @@ Tags:
 Typedefs:
 - Name: NSTextListMarkerFormat
   SwiftName: NSTextList.MarkerFormat
+- Name: NSAttributedStringDocumentAttributeKey
+  SwiftName: NSAttributedString.DocumentAttributeKey
+- Name: NSAttributedStringDocumentReadingOptionKey
+  SwiftName: NSAttributedString.DocumentReadingOptionKey
+- Name: NSAttributedStringDocumentType
+  SwiftName: NSAttributedString.DocumentType
+- Name: NSTextEffectStyle
+  SwiftName: NSAttributedString.TextEffectStyle
+- Name: NSTextHighlightStyle
+  SwiftName: NSAttributedString.TextHighlightStyle
+- Name: NSTextHighlightColorScheme
+  SwiftName: NSAttributedString.TextHighlightColorScheme
+- Name: NSTextLayoutSectionKey
+  SwiftName: NSAttributedString.TextLayoutSectionKey
 - Name: NSTextTabOptionKey
   SwiftName: NSTextTab.OptionKey
 - Name: UIFontDescriptorAttributeName

package/src/android-layout-ids.ts

@@ -0,0 +1,50 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { parseXml, type XmlElement } from './android-xml'
+
+// the layout names and view ids a module's R class declares: every layout
+// file's name, every `@+id/` or `@id/` an attribute names in a layout, and each
+// `<item type="id">` in values, as aapt2 declares them
+export interface AndroidLayoutIds {
+  layouts: string[]
+  ids: string[]
+  // the unqualified `layout` directory's files by name, which Resources inflates
+  elements: Map<string, XmlElement>
+}
+
+const LAYOUT_DIR = /^layout(?:-[A-Za-z0-9+-]+)?$/
+const ID_REFERENCE = /@\+?id\/([A-Za-z0-9_.]+)/g
+const ID_ITEM = /<item\b[^>]*\btype\s*=\s*"id"[^>]*>/g
+const ITEM_NAME = /\bname\s*=\s*"([^"]+)"/
+
+export function readAndroidLayoutIds(moduleDir: string): AndroidLayoutIds {
+  const res = path.join(moduleDir, 'src/main/res')
+  const layouts = new Set<string>()
+  const ids = new Set<string>()
+  const elements = new Map<string, XmlElement>()
+  for (const dir of fs.existsSync(res) ? fs.readdirSync(res).sort() : []) {
+    const directory = path.join(res, dir)
+    if (LAYOUT_DIR.test(dir)) {
+      for (const entry of fs.readdirSync(directory).sort()) {
+        if (!entry.endsWith('.xml')) continue
+        layouts.add(entry.slice(0, -'.xml'.length))
+        const xml = fs.readFileSync(path.join(directory, entry), 'utf8')
+        for (const match of xml.matchAll(ID_REFERENCE)) ids.add(match[1])
+        if (dir === 'layout') {
+          const root = parseXml(xml, path.join(directory, entry)).children[0]
+          if (root) elements.set(entry.slice(0, -'.xml'.length), root)
+        }
+      }
+    } else if (dir.startsWith('values')) {
+      for (const entry of fs.readdirSync(directory).sort()) {
+        if (!entry.endsWith('.xml')) continue
+        const xml = fs.readFileSync(path.join(directory, entry), 'utf8')
+        for (const item of xml.matchAll(ID_ITEM)) {
+          const name = ITEM_NAME.exec(item[0])?.[1]
+          if (name) ids.add(name)
+        }
+      }
+    }
+  }
+  return { layouts: [...layouts].sort(), ids: [...ids].sort(), elements }
+}

package/src/android-view-classes.ts

@@ -0,0 +1,41 @@
+import type { XmlElement } from './android-xml'
+
+// the framework view classes LayoutInflater can create; each is a Kotlin class
+// of the same name in AndroidViewSources, linked into an app only when one of
+// its layouts names it
+export const androidViewClasses = [
+  'android.view.View',
+  'android.widget.FrameLayout',
+  'android.widget.ImageView',
+  'android.widget.LinearLayout',
+  'android.widget.RelativeLayout',
+  'android.widget.TextView',
+]
+
+// PhoneLayoutInflater's prefixes, then LayoutInflater's own
+const classPrefixes = [
+  'android.widget.',
+  'android.webkit.',
+  'android.app.',
+  'android.view.',
+]
+
+// the classes a set of layout trees names, as the inflater resolves a tag: a
+// dotted name is that class, any other tries each framework prefix in order
+export function layoutViewClasses(roots: Iterable<XmlElement>): string[] {
+  const used = new Set<string>()
+  const visit = (element: XmlElement) => {
+    if (element.name !== 'include' && element.name !== 'merge') {
+      if (element.name.includes('.')) used.add(element.name)
+      else {
+        const found = classPrefixes
+          .map((prefix) => prefix + element.name)
+          .find((name) => androidViewClasses.includes(name))
+        if (found) used.add(found)
+      }
+    }
+    element.children.forEach(visit)
+  }
+  for (const root of roots) visit(root)
+  return [...used].sort()
+}

package/src/expo-native-workspace.ts

@@ -744,7 +744,7 @@ function trackedSourceEntries(root: string, work: string): string[] {
 function initializeWorkspaceGit(root: string, work: string) {
   requireNativeGit()
   const env = { ...process.env, ...isolatedGitEnv }
-  execFileSync('git', ['init', '--quiet'], { cwd: work, env, timeout: 60_000 })
+  execFileSync('git', ['init', '--quiet'], { cwd: work, env })
   execFileSync(
     'git',
     [
@@ -761,7 +761,7 @@ function initializeWorkspaceGit(root: string, work: string) {
       '-m',
       'prepared workspace',
     ],
-    { cwd: work, env, timeout: 60_000 },
+    { cwd: work, env },
   )
   const tracked = trackedSourceEntries(root, work)
   if (tracked.length > 0)
@@ -769,7 +769,6 @@ function initializeWorkspaceGit(root: string, work: string) {
       cwd: work,
       env,
       input: tracked.join('\0'),
-      timeout: 60_000,
     })
 }
 

package/src/expo-swift-host.ts

@@ -2353,7 +2353,12 @@ async function compileExpoSwiftModulesTraced(
               'react-native/package.json',
             ),
           )
-          const provider = prebuiltReactNativeCore(reactNativeRoot, module.root, 'expo')
+          const provider = await prebuiltReactNativeCore(
+            projectRoot,
+            reactNativeRoot,
+            module.root,
+            'expo',
+          )
           const headers = new Map<string, { file: string; relative: string }[]>()
           for (const [file, body] of Object.entries(provider.files)) {
             const relative = file.split('/upstream/react-native/')[1]

package/src/java-module-abi.ts

@@ -62,6 +62,7 @@ export async function readJavaModuleSpecs(
           typeof row.className !== 'string' ||
           (row.name !== null && typeof row.name !== 'string') ||
           typeof row.source !== 'string' ||
+          (row.application !== undefined && typeof row.application !== 'boolean') ||
           !Array.isArray(row.methods)
         )
           throw new Error('Java module reader printed an invalid spec')
@@ -73,6 +74,7 @@ export async function readJavaModuleSpecs(
           name: row.name,
           source: row.source,
           methods: row.methods.map(readBridgeMethod),
+          application: row.application === true,
         }
       })
     return { sha256: digest.digest('hex'), specs }

package/src/javaAbiContract.ts

@@ -6,6 +6,8 @@ export interface JavaModuleSpec {
   name: string | null
   source: string
   methods: BridgeMethod[]
+  // compiled with the application: it names classes only the application defines
+  application: boolean
 }
 
 export interface JavaModuleSpecs {

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)