peachsim 0.1.2208 → 0.1.2210

package/src/android-theme.ts

@@ -1,4 +1,4 @@
-// android theme resolution for a pure Kotlin app's window: app styles from the
+// android theme resolution for a pure Kotlin app's window and default TextView: app styles from the
 // module's res/values over the device's framework styles, resolved the way
 // Resources.Theme does (explicit or dotted parents, `?attr` references,
 // `@color` references). the framework half is generated from the platform's
@@ -11,16 +11,27 @@ export interface StyleValues {
   items: Record<string, string>
 }
 
+// one item of a color state list file: the states it requires, its color and
+// the alpha it multiplies in
+export interface StateColorItem {
+  states: Partial<Record<string, boolean>>
+  color: string
+  alpha: string | null
+}
+
 // a values namespace: the framework's (`android:`) or the app's
 export interface ResourceValues {
   styles: Record<string, StyleValues>
   colors: Record<string, string>
+  dimens: Record<string, string>
+  // res/color state lists by name
+  stateColors: Record<string, StateColorItem[]>
 }
 
 export function readResourceValues(
   files: Array<{ file: string; text: string }>,
 ): ResourceValues {
-  const values: ResourceValues = { styles: {}, colors: {} }
+  const values: ResourceValues = { styles: {}, colors: {}, dimens: {}, stateColors: {} }
   for (const { file, text } of files) {
     for (const resources of parseXml(text, file).children) {
       if (resources.name !== 'resources') continue
@@ -28,6 +39,11 @@ export function readResourceValues(
         const name = entry.attributes.name
         if (!name) continue
         if (entry.name === 'color') values.colors[name] = entry.text.trim()
+        if (
+          entry.name === 'dimen' ||
+          (entry.name === 'item' && entry.attributes.type === 'dimen')
+        )
+          values.dimens[name] = entry.text.trim()
         if (entry.name !== 'style') continue
         const items: Record<string, string> = {}
         for (const item of entry.children)
@@ -203,3 +219,121 @@ export function attributeColor(value: string, sources: ThemeSources): number {
   if (!ref) throw new Error(`the color ${value} is not resolved by Peach yet`)
   return resourceColor(ref.namespace, ref.name, sources)
 }
+
+// a res/color selector as ColorStateList.inflate reads it
+export function readColorStateList(text: string, file: string): StateColorItem[] {
+  const selector = parseXml(text, file).children.find(
+    (child) => child.name === 'selector',
+  )
+  if (!selector) throw new Error(`${file}: not a color state list`)
+  return selector.children
+    .filter((item) => item.name === 'item')
+    .map((item) => {
+      const states: Record<string, boolean> = {}
+      for (const [key, value] of Object.entries(item.attributes))
+        if (key.startsWith('android:state_')) states[key.slice(8)] = value === 'true'
+      const color = item.attributes['android:color']
+      if (!color) throw new Error(`${file}: an item has no android:color`)
+      return { states, color, alpha: item.attributes['android:alpha'] ?? null }
+    })
+}
+
+// TextView's default color and size under a theme
+export interface TextAppearance {
+  color: number
+  // a dimension as written: `14sp`, `16dp` or `15px`
+  size: string
+}
+
+type Found = { value: string; namespace: Namespace }
+
+// what TextView's constructor reads when a layout sets neither: the
+// textAppearance its textViewStyle or the theme names, then a textColor or
+// textSize the style or the theme sets itself. with none, TextView's own
+// black and 15px.
+export function resolveTextAppearance(
+  theme: string,
+  sources: ThemeSources,
+): TextAppearance {
+  const themeChain = styleChain(styleRef(theme, 'app'), sources)
+  const android = (name: string) => ({ namespace: 'android' as const, name })
+  // follows `?attr` references through the theme
+  const resolve = (start: Found): Found => {
+    const seen = new Set<string>()
+    let found = start
+    for (;;) {
+      const attr = /^\?(?:(android):)?(?:attr\/)?(.+)$/.exec(found.value)
+      if (!attr?.[2]) return found
+      if (seen.has(`${found.namespace}:${found.value}`))
+        throw new Error(`${theme}: ${found.value} refers to itself`)
+      seen.add(`${found.namespace}:${found.value}`)
+      const next = lookup(themeChain, {
+        namespace: attr[1] ? 'android' : found.namespace,
+        name: attr[2],
+      })
+      if (!next) throw new Error(`${theme}: ${found.value} is not set`)
+      found = next
+    }
+  }
+  const style = (found: Found | null) => {
+    if (!found) return []
+    const { value, namespace } = resolve(found)
+    return styleChain(styleRef(value, namespace), sources)
+  }
+  const dimen = (found: Found): string => {
+    let { value, namespace } = resolve(found)
+    const seen = new Set<string>()
+    for (;;) {
+      const ref = /^@(?:(android):)?dimen\/(.+)$/.exec(value)
+      if (!ref?.[2]) return value
+      if (seen.has(value)) throw new Error(`${theme}: ${value} refers to itself`)
+      seen.add(value)
+      namespace = ref[1] ? 'android' : namespace
+      const next = sources[namespace].dimens[ref[2]]
+      if (next === undefined)
+        throw new Error(`@${namespace}:dimen/${ref[2]} is not defined`)
+      value = next
+    }
+  }
+  // a color or the color an enabled view in no other state takes from a
+  // state list, its alpha modulated as ColorStateList.modulateColor does
+  const colorOf = (found: Found): number => {
+    const { value, namespace } = resolve(found)
+    if (value.startsWith('#')) return color(value)
+    const ref = colorReference(value, namespace)
+    if (!ref)
+      throw new Error(`${theme}: the text color ${value} is not resolved by Peach yet`)
+    const list = sources[ref.namespace].stateColors[ref.name]
+    if (!list) return resourceColor(ref.namespace, ref.name, sources)
+    const item = list.find((entry) =>
+      Object.entries(entry.states).every(
+        ([state, on]) => on === (state === 'state_enabled'),
+      ),
+    )
+    if (!item) throw new Error(`@${ref.namespace}:color/${ref.name} has no enabled item`)
+    const base = colorOf({ value: item.color, namespace: ref.namespace })
+    if (item.alpha === null) return base
+    const alphaMod = Number(dimen({ value: item.alpha, namespace: ref.namespace }))
+    if (!Number.isFinite(alphaMod))
+      throw new Error(
+        `@${ref.namespace}:color/${ref.name}: unreadable alpha ${item.alpha}`,
+      )
+    const alpha = Math.min(255, Math.max(0, Math.trunc((base >>> 24) * alphaMod + 0.5)))
+    return ((alpha << 24) | (base & 0xffffff)) >>> 0
+  }
+  const textViewStyle = style(lookup(themeChain, android('textViewStyle')))
+  const appearance = style(
+    lookup(textViewStyle, android('textAppearance')) ??
+      lookup(themeChain, android('textAppearance')),
+  )
+  const attribute = (name: string) =>
+    lookup(textViewStyle, android(name)) ??
+    lookup(themeChain, android(name)) ??
+    lookup(appearance, android(name))
+  const textColor = attribute('textColor')
+  const textSize = attribute('textSize')
+  const size = textSize ? dimen(textSize) : '15px'
+  if (!/^\d+(?:\.\d+)?(?:sp|dp|dip|px)$/.test(size))
+    throw new Error(`${theme}: the text size ${size} is not resolved by Peach yet`)
+  return { color: textColor ? colorOf(textColor) : 0xff000000, size }
+}

package/src/expo-swift-host.ts

@@ -1020,6 +1020,88 @@ function enrichInstalledUnits(
   for (const unit of units) unit.nativeFiles = { ...unit.nativeFiles, ...support }
 }
 
+// Swift compiled without the pod's Objective-C still names those classes.
+// A requester keeps the protocol its header declares, so the generic
+// constraint can infer. The prepared workspace compiles the real .m files.
+function swiftAloneObjCClasses(
+  ios: string,
+  swift: string,
+  resolveSource: (file: string) => string,
+): string | null {
+  if (!fs.existsSync(ios)) return null
+  const interfaces = new Map<string, { superName?: string; protocols: string[] }>()
+  const visit = (dir: string) => {
+    for (const child of fs.readdirSync(resolveSource(dir), { withFileTypes: true })) {
+      if (
+        child.name.startsWith('.') ||
+        child.name === 'build' ||
+        child.name === 'node_modules' ||
+        /\.(?:xcframework|framework)$/.test(child.name)
+      )
+        continue
+      const file = path.join(dir, child.name)
+      const resolved = resolveSource(file)
+      const stat = fs.statSync(resolved)
+      if (stat.isDirectory()) {
+        visit(file)
+        continue
+      }
+      if (!stat.isFile() || !child.name.endsWith('.h')) continue
+      const text = fs.readFileSync(resolved, 'utf8')
+      for (const match of text.matchAll(
+        /@interface\s+(\w+)\s*(\([^)\n]*\))?\s*(?::\s*(\w+))?\s*(?:<([^>\n]+)>)?/g,
+      )) {
+        if (match[2]) continue
+        interfaces.set(match[1]!, {
+          ...(match[3] ? { superName: match[3] } : {}),
+          protocols: (match[4] ?? '')
+            .split(',')
+            .map((name) => name.trim())
+            .filter((name) => name.length > 0),
+        })
+      }
+    }
+  }
+  visit(ios)
+  if (interfaces.size === 0) return null
+  const code = swiftCodeMask(swift)
+  const declared = new Set(
+    [
+      ...code.matchAll(
+        /\b(?:class|struct|enum|protocol|actor|typealias)\s+([A-Za-z_]\w*)/g,
+      ),
+    ].map((match) => match[1]!),
+  )
+  const referenced = new Set(code.match(/[A-Za-z_]\w*/g) ?? [])
+  const needed = [...interfaces.keys()]
+    .filter((name) => referenced.has(name) && !declared.has(name))
+    .sort()
+  if (needed.length === 0) return null
+  const protocolsOf = (name: string, seen = new Set<string>()): string[] => {
+    if (seen.has(name)) return []
+    seen.add(name)
+    const item = interfaces.get(name)
+    if (!item) return []
+    return [
+      ...item.protocols,
+      ...(item.superName ? protocolsOf(item.superName, seen) : []),
+    ]
+  }
+  const classes = needed.map((name) => {
+    if (!new Set(protocolsOf(name)).has('EXPermissionsRequester'))
+      return `public class ${name}: NSObject {}`
+    return `public class ${name}: NSObject, EXPermissionsRequester {
+  public static func permissionType() -> String { "" }
+  public func getPermissions() -> [AnyHashable: Any] { [:] }
+  public func requestPermissions(
+    resolver resolve: @escaping EXPromiseResolveBlock,
+    rejecter reject: @escaping EXPromiseRejectBlock
+  ) {}
+}`
+  })
+  return `import ExpoModulesCore\nimport Foundation\n\n${classes.join('\n\n')}\n`
+}
+
 export async function collectExpoSwiftSources(
   appRoot: string,
   signal?: AbortSignal,
@@ -1580,10 +1662,17 @@ async function collectExpoSwiftSourcesUncached(
         walkFrameworks(canonical)
         // this path compiles Swift alone; the report names the cause when a
         // Swift file then fails on the pod's own Objective-C or C types.
-        if (nativeSources.size > 0 && !prepareNative && !metadataOnly)
+        if (nativeSources.size > 0 && !prepareNative && !metadataOnly) {
           report(
             `${packageName}: ${namespace} has Objective-C or C sources (${[...nativeSources].sort()[0]}), which compile only from a CocoaPods workspace a Mac prepares; compiling its Swift alone`,
           )
+          const surface = swiftAloneObjCClasses(
+            ios,
+            Object.values(files).join('\n'),
+            resolveSource,
+          )
+          if (surface) files[`Sources/${namespace}/PeachObjCSurface.swift`] = surface
+        }
       }
       // a module compiled from its own source declares its iOS floor in its
       // podspec; CocoaPods builds the pod at that floor.