peachsim 0.1.1619 → 0.1.1625

package/src/native-app-identity.ts

@@ -1,13 +1,14 @@
 // generic native app identity: the values an installed iOS/Android binary
 // carries, read from the app's own native project (`Info.plist` resolved
-// against the Xcode Release build settings, or `android/app/build.gradle`), so
-// a simulator tenant reports the same identity the native Release build does.
+// against Xcode Release build settings, or a completed Android app manifest
+// merger output), so a simulator tenant reports the selected native build.
 //
 // identity travels in a bundle footer or response header. the one updates
 // receipt travels only in the response header so publisher JavaScript stays
 // unchanged. tenant boot validates both before evaluation and clears the realm
 // store when neither carries identity.
 
+import { nativeAppIdentityFromAndroidManifest } from './android-app-identity'
 import { findBundleFooter } from './bundleGlobalFooter'
 import {
   resolveNativeAppIconArtwork,
@@ -27,8 +28,14 @@ export interface NativeOneUpdatesReceipt {
   embeddedManifestJson: string | null
 }
 
+export interface AndroidManifestPermission {
+  name: string
+  minSdkVersion: number
+  maxSdkVersion?: number
+}
+
 export interface NativeAppIdentity {
-  // the user-facing name (CFBundleDisplayName, else CFBundleName).
+  // the user-facing name (iOS bundle name or a resolved Android app label).
   applicationName: string | null
   // the literal CFBundleDisplayName, without a bundle-name fallback.
   applicationDisplayName?: string
@@ -51,6 +58,9 @@ export interface NativeAppIdentity {
   buildVersion: string
   bundleIdentifier: string
   platform: NativeAppIdentityPlatform
+  // declarations from the selected app manifest merger output; install-time
+  // SDK filtering belongs to the evaluation's device, not the bundle builder.
+  androidManifestPermissions?: readonly AndroidManifestPermission[]
   permissionUsageDescriptions?: Readonly<Record<string, unknown>>
   urlQuerySchemes?: readonly unknown[]
   appIntentIdentifiers?: readonly string[]
@@ -60,6 +70,8 @@ export interface NativeAppIdentity {
   ipadSupportedInterfaceOrientations?: readonly string[]
   defaultScreenOrientationMask?: string
   shareIntoAppGroupId?: string
+  rtcAppGroupIdentifier?: string
+  screenShareExtensionBundleId?: string
   alternateIconNames?: readonly string[]
   appIconArtwork?: NativeAppIconArtwork
   // resolved Reanimated compile flags from the native build inputs.
@@ -113,6 +125,24 @@ export function isNativeAppIdentity(value: unknown): value is NativeAppIdentity
     typeof value.dtPlatformVersion !== 'string'
   )
     return false
+  if (
+    value.androidManifestPermissions !== undefined &&
+    (!Array.isArray(value.androidManifestPermissions) ||
+      !value.androidManifestPermissions.every(
+        (permission: unknown) =>
+          isRecord(permission) &&
+          typeof permission.name === 'string' &&
+          permission.name.length > 0 &&
+          Number.isInteger(permission.minSdkVersion) &&
+          typeof permission.minSdkVersion === 'number' &&
+          permission.minSdkVersion > 0 &&
+          (permission.maxSdkVersion === undefined ||
+            (typeof permission.maxSdkVersion === 'number' &&
+              Number.isInteger(permission.maxSdkVersion) &&
+              permission.maxSdkVersion >= 0)),
+      ))
+  )
+    return false
   const descriptions = value.permissionUsageDescriptions
   if (
     value.reanimatedStaticFeatureFlags !== undefined &&
@@ -150,6 +180,16 @@ export function isNativeAppIdentity(value: unknown): value is NativeAppIdentity
     typeof value.shareIntoAppGroupId !== 'string'
   )
     return false
+  if (
+    value.rtcAppGroupIdentifier !== undefined &&
+    typeof value.rtcAppGroupIdentifier !== 'string'
+  )
+    return false
+  if (
+    value.screenShareExtensionBundleId !== undefined &&
+    typeof value.screenShareExtensionBundleId !== 'string'
+  )
+    return false
   if (
     value.applicationDisplayName !== undefined &&
     typeof value.applicationDisplayName !== 'string'
@@ -244,6 +284,13 @@ export function readNativeAppIdentity(value: unknown): NativeAppIdentity | null
     ...(value.alternateIconNames === undefined
       ? {}
       : { alternateIconNames: [...value.alternateIconNames] }),
+    ...(value.androidManifestPermissions === undefined
+      ? {}
+      : {
+          androidManifestPermissions: value.androidManifestPermissions.map(
+            (permission) => ({ ...permission }),
+          ),
+        }),
     ...(value.permissionUsageDescriptions === undefined
       ? {}
       : {
@@ -276,6 +323,12 @@ export function readNativeAppIdentity(value: unknown): NativeAppIdentity | null
     ...(value.shareIntoAppGroupId === undefined
       ? {}
       : { shareIntoAppGroupId: value.shareIntoAppGroupId }),
+    ...(value.rtcAppGroupIdentifier === undefined
+      ? {}
+      : { rtcAppGroupIdentifier: value.rtcAppGroupIdentifier }),
+    ...(value.screenShareExtensionBundleId === undefined
+      ? {}
+      : { screenShareExtensionBundleId: value.screenShareExtensionBundleId }),
     ...(value.urlQuerySchemes === undefined
       ? {}
       : { urlQuerySchemes: [...value.urlQuerySchemes] }),
@@ -857,6 +910,20 @@ function nativeAppIdentityFromIos(
       : undefined
   if (shareIntoAppGroupId === null)
     throw new Error('native app Info.plist ExpoShareIntoAppGroupId is unresolved')
+  const declaredRtcGroup = dictionary.RTCAppGroupIdentifier
+  const rtcAppGroupIdentifier =
+    typeof declaredRtcGroup === 'string'
+      ? resolveBuildSetting(declaredRtcGroup, settings)
+      : undefined
+  if (rtcAppGroupIdentifier === null)
+    throw new Error('native app Info.plist RTCAppGroupIdentifier is unresolved')
+  const declaredScreenShareExtension = dictionary.ScreenShareExtensionBundleId
+  const screenShareExtensionBundleId =
+    typeof declaredScreenShareExtension === 'string'
+      ? resolveBuildSetting(declaredScreenShareExtension, settings)
+      : undefined
+  if (screenShareExtensionBundleId === null)
+    throw new Error('native app Info.plist ScreenShareExtensionBundleId is unresolved')
   const querySchemes = dictionary.LSApplicationQueriesSchemes
   if (querySchemes !== undefined && !Array.isArray(querySchemes)) {
     throw new Error('native app Info.plist LSApplicationQueriesSchemes is not an array')
@@ -991,6 +1058,10 @@ function nativeAppIdentityFromIos(
     permissionUsageDescriptions,
     urlQuerySchemes,
     ...(shareIntoAppGroupId === undefined ? {} : { shareIntoAppGroupId }),
+    ...(rtcAppGroupIdentifier === undefined ? {} : { rtcAppGroupIdentifier }),
+    ...(screenShareExtensionBundleId === undefined
+      ? {}
+      : { screenShareExtensionBundleId }),
     backgroundTaskIdentifiers: backgroundTaskIdentifiers.every((value) => value !== null)
       ? backgroundTaskIdentifiers
       : [],
@@ -1003,11 +1074,6 @@ function nativeAppIdentityFromIos(
   }
 }
 
-// android's shipped identity requires resolving the selected flavor and
-// buildType overrides (`productFlavors.prod`, `buildTypes.release`), which a
-// text reader of `defaultConfig` cannot distinguish from the defaults it
-// overrides. an Android project therefore ships no footer until that
-// resolution exists. unsupported or absent bundle platforms ship no footer.
 // the module an app's own sources start react native with: the template
 // `startReactNative(withModuleName: "X")`, RCTAppDelegate's
 // `self.moduleName = @"X"` and RCTRootView's `moduleName:@"X"`. a target that
@@ -1022,8 +1088,19 @@ export function readRootModuleName(sources: readonly string[]): string | undefin
   return names.size === 1 ? [...names][0] : undefined
 }
 
-export function canExtractNativeAppIdentity(platform: unknown): platform is 'ios' {
-  return platform === 'ios'
+export function canExtractNativeAppIdentity(
+  platform: unknown,
+): platform is NativeAppIdentityPlatform {
+  return platform === 'ios' || platform === 'android'
+}
+
+// the bundle platform's identity reader. selecting it here keeps every native
+// project reader free of platform branches.
+export function selectNativeAppIdentityReader<Reader>(
+  platform: unknown,
+  readers: Readonly<Record<NativeAppIdentityPlatform, Reader>>,
+): Reader | null {
+  return canExtractNativeAppIdentity(platform) ? readers[platform] : null
 }
 
 // read the identity a bundle builder transports. files are project-relative
@@ -1036,8 +1113,23 @@ export function extractNativeAppIdentityFromFiles(
   parseInfoPlist: (source: string) => unknown,
   iosTarget?: string,
   resourceUri?: (file: string) => string | undefined,
+  androidMergedManifest?: string,
 ): NativeAppIdentity | null {
-  return canExtractNativeAppIdentity(platform)
+  if (platform === 'android') {
+    const candidates = androidMergedManifest
+      ? [androidMergedManifest]
+      : Object.keys(files).filter((file) =>
+          /^android\/[^/]+\/build\/intermediates\/merged_manifests\/.+\/AndroidManifest\.xml$/.test(
+            file,
+          ),
+        )
+    if (candidates.length !== 1) return null
+    const source = files[candidates[0]!]
+    return source === undefined
+      ? null
+      : nativeAppIdentityFromAndroidManifest(source, candidates[0]!, files)
+  }
+  return platform === 'ios'
     ? nativeAppIdentityFromIos(files, parseInfoPlist, iosTarget, resourceUri)
     : null
 }

package/src/nitro-compile.ts

@@ -20,10 +20,7 @@ export function collectNitroCompileInput(
 ): { input: SwiftCompileInput; collection: NitroSourceCollection } {
   const collection = collectNitroSources(options)
   const files = { ...collection.files }
-  const platform = path.join(
-    options.moduleRoot,
-    'platform/react-native-nitro-modules',
-  )
+  const platform = path.join(options.moduleRoot, 'platform/react-native-nitro-modules')
   const read = (file: string) =>
     readPackageFile(
       platform,
@@ -71,7 +68,7 @@ export function collectNitroCompileInput(
     'let package = Package(name: "PeachNativeModule", targets: [',
     ...collection.targets.map(
       (target) =>
-        `.target(name: ${JSON.stringify(target.name)}, dependencies: ${JSON.stringify(target.dependencies?.map((dependency) => dependency.name) ?? [])}, path: ${JSON.stringify(target.path)}, cxxSettings: [.define("DEBUG")]),`,
+        `.target(name: ${JSON.stringify(target.name)}, dependencies: ${JSON.stringify(target.dependencies?.map((dependency) => dependency.name) ?? [])}, path: ${JSON.stringify(target.path)}, ${target.cxxInterop ? 'swiftSettings: [.interoperabilityMode(.Cxx)]' : 'cxxSettings: [.define("DEBUG")]'}),`,
     ),
     `.target(name: "${runtime}", dependencies: ["JsiBridge", "NitroCore"], cxxSettings: [.define("DEBUG")]),`,
     `.executableTarget(name: "PeachNitroApp", dependencies: ["${runtime}", "${implementation.name}"], swiftSettings: [.interoperabilityMode(.Cxx)]),`,

package/src/nitro-source.ts

@@ -55,61 +55,72 @@ function packageInfo(root: string): NitroSourceCollection['packages'][number] {
   return { name: value.name, version: value.version, root }
 }
 
-function registrations(root: string): {
-  namespace: string
-  classes: { name: string; implementation: string }[]
-} {
-  const config = readJson(root, 'nitro.json')
-  if (
-    !object(config) ||
-    !Array.isArray(config.cxxNamespace) ||
-    !config.cxxNamespace.every(
-      (part): part is string =>
-        typeof part === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(part),
-    ) ||
-    !object(config.autolinking)
-  )
-    throw new Error(`${root}: invalid Nitro C++ namespace or autolinking config`)
-  const classes: { name: string; implementation: string }[] = []
-  for (const [name, entry] of Object.entries(config.autolinking).sort(([a], [b]) =>
-    a.localeCompare(b),
+function registrations(root: string) {
+  // cocoapods compiles this generated initializer through +autolinking.rb.
+  // nitro.json is a generator input and need not ship in the package.
+  const directory = path.join(root, 'nitrogen/generated/ios')
+  const initializers = fs
+    .readdirSync(directory)
+    .filter((file) => file.endsWith('Autolinking.mm'))
+  if (initializers.length !== 1)
+    throw new Error(`${root}: expected one generated Nitro iOS initializer`)
+  const source = readPackageFile(
+    root,
+    path.join(directory, initializers[0]!),
+    MAX_SWIFT_COMPILE_SOURCE_BYTES,
+  ).toString('utf8')
+  const namespaces = [
+    ...source.matchAll(/\busing namespace (margelo::nitro(?:::[A-Za-z_]\w*)*)\s*;/g),
+  ]
+  const namespace = namespaces[1]?.[1]
+  if (namespaces.length !== 2 || namespaces[0]?.[1] !== 'margelo::nitro' || !namespace)
+    throw new Error(`${root}: invalid generated Nitro C++ namespace`)
+
+  const classes: (
+    | { name: string; implementation: string; language: 'c++' }
+    | { name: string; language: 'swift' }
+  )[] = []
+  let swiftModule: string | null = null
+  for (const registration of source.matchAll(
+    /\bHybridObjectRegistry::registerHybridObjectConstructor\(\s*("(?:[^"\\]|\\.)*")\s*,\s*\[\]\(\)\s*->\s*std::shared_ptr<HybridObject>\s*\{([\s\S]*?)\}\s*\);/g,
   )) {
-    if (!object(entry)) throw new Error(`${root}: invalid Nitro autolinking ${name}`)
-    // platform-specific registrations cannot be substituted for shared C++.
-    // report their actual language instead of silently dropping Swift or JNI.
-    if (
-      !object(entry.all) ||
-      entry.all.language !== 'c++' ||
-      Object.keys(entry).some((platform) => platform !== 'all')
-    ) {
-      const languages = Object.entries(entry).map(
-        ([platform, value]) =>
-          `${platform}:${object(value) ? String(value.language) : 'invalid'}`,
-      )
-      throw new Error(
-        `${root}: unsupported Nitro module ${name} (${languages.join(', ')}); ` +
-          'this collector supports shared all.language=c++ only, not Swift, Kotlin, Java or JNI',
+    const name: unknown = JSON.parse(registration[1]!)
+    const body = registration[2]!
+    if (typeof name !== 'string' || name.length === 0)
+      throw new Error(`${root}: invalid generated Nitro registration name`)
+    const cpp = /return\s+std::make_shared<([A-Za-z_]\w*)>\(\);/.exec(body)
+    const swift =
+      /=\s*([A-Za-z_]\w*)::([A-Za-z_]\w*)::create([A-Za-z_]\w*)\(\);\s*return hybridObject;/.exec(
+        body,
       )
+    if (cpp && !swift) {
+      classes.push({ name, implementation: cpp[1]!, language: 'c++' })
+    } else if (
+      swift &&
+      !cpp &&
+      swift[2] === `${swift[1]}Autolinking` &&
+      swift[3] === name &&
+      (swiftModule === null || swiftModule === swift[1])
+    ) {
+      swiftModule = swift[1]!
+      classes.push({ name, language: 'swift' })
+    } else {
+      throw new Error(`${root}: unsupported generated Nitro iOS registration ${name}`)
     }
-    const implementation = entry.all.implementationClassName
-    if (
-      name.length === 0 ||
-      typeof implementation !== 'string' ||
-      !/^[A-Za-z_][A-Za-z0-9_]*$/.test(implementation)
-    )
-      throw new Error(`${root}: invalid Nitro C++ implementation for ${name}`)
-    classes.push({ name, implementation })
-  }
-  if (classes.length === 0) throw new Error(`${root}: no Nitro C++ registrations`)
-  return {
-    namespace: ['margelo', 'nitro', ...config.cxxNamespace].join('::'),
-    classes,
   }
+  const count = [
+    ...source.matchAll(/\bHybridObjectRegistry::registerHybridObjectConstructor\s*\(/g),
+  ].length
+  if (classes.length === 0 || classes.length !== count)
+    throw new Error(`${root}: incomplete generated Nitro iOS registrations`)
+  if (new Set(classes.map(({ name }) => name)).size !== classes.length)
+    throw new Error(`${root}: duplicate generated Nitro iOS registration`)
+  classes.sort((a, b) => a.name.localeCompare(b.name))
+  return { namespace, swiftModule, classes }
 }
 
-/** collect installed C++ bodies, Nitro core and RN's JSI, without reading or
- * rewriting package JavaScript. views and platform implementations are outside
- * this C++ module collector; the caller must supply real platform bindings. */
+/** collect installed native bodies, generated bridges, Nitro core and RN's
+ * JSI without reading or rewriting package JavaScript. */
 export function collectNitroSources(options: NitroSourceOptions): NitroSourceCollection {
   const module = packageInfo(options.packageRoot)
   const config = registrations(module.root)
@@ -189,6 +200,7 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
     includeNamespace: string | null,
     skip: ReadonlySet<string> = new Set(),
     select: (file: string) => boolean = () => true,
+    extensions: RegExp = /\.(?:c|cc|cpp|cxx|h|hpp|hxx|inl)$/,
   ) => {
     const headers = new Map<string, string>()
     const walk = (relative: string) => {
@@ -204,7 +216,7 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
           walk(sourceRelative)
           continue
         }
-        if (!/\.(?:c|cc|cpp|cxx|h|hpp|hxx|inl)$/.test(entry.name)) continue
+        if (!extensions.test(entry.name)) continue
         if (!select(entry.name)) continue
         if (/[\p{Cc}"\\]/u.test(sourceRelative))
           throw new Error(`invalid Nitro source path: ${sourceRelative}`)
@@ -259,13 +271,72 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
     (file) => (file.endsWith('.h') && file !== 'JSIDynamic.h') || file === 'jsi.cpp',
   )
   collect(nitro.root, 'cpp', coreTarget, 'NitroModules', new Set(['views']))
-  const implementationHeaders = collect(module.root, 'cpp', targetName, null)
+  const implementationHeaders = fs.existsSync(path.join(module.root, 'cpp'))
+    ? collect(module.root, 'cpp', targetName, null)
+    : new Map<string, string>()
   collect(module.root, 'nitrogen/generated/shared/c++', targetName, null)
-  for (const { implementation } of config.classes)
-    if (!implementationHeaders.has(`${implementation}.hpp`))
+  for (const entry of config.classes)
+    if (
+      entry.language === 'c++' &&
+      !implementationHeaders.has(`${entry.implementation}.hpp`)
+    )
       throw new Error(
-        `${module.root}: missing C++ implementation header ${implementation}.hpp`,
+        `${module.root}: missing C++ implementation header ${entry.implementation}.hpp`,
+      )
+
+  if (config.swiftModule) {
+    for (const directory of ['ios/core', 'ios/utils'])
+      collect(
+        nitro.root,
+        directory,
+        coreTarget,
+        'NitroModules',
+        new Set(),
+        (file) => !file.endsWith('.swift'),
       )
+    const nitroSwift = target('NitroModules', [coreTarget, jsiTarget])
+    nitroSwift.cxxInterop = true
+    const packageSwift = target(config.swiftModule, [targetName, 'NitroModules'])
+    packageSwift.cxxInterop = true
+    result.targets.push(nitroSwift, packageSwift)
+    for (const directory of ['ios/core', 'ios/utils', 'ios/views'])
+      collect(
+        nitro.root,
+        directory,
+        'NitroModules',
+        null,
+        new Set(['HybridView.swift']),
+        () => true,
+        /\.swift$/,
+      )
+    add(
+      `${targetPath('NitroModules')}/PeachNitroExports.swift`,
+      `@_exported import ${coreTarget}\n`,
+    )
+    collect(
+      module.root,
+      'ios',
+      config.swiftModule,
+      null,
+      new Set(['Tests']),
+      () => true,
+      /\.swift$/,
+    )
+    collect(
+      module.root,
+      'nitrogen/generated/ios',
+      config.swiftModule,
+      null,
+      new Set(),
+      () => true,
+      /\.swift$/,
+    )
+    collect(module.root, 'nitrogen/generated/ios', targetName, null)
+    add(
+      `${targetPath(config.swiftModule)}/PeachNitroExports.swift`,
+      `@_exported import ${targetName}\n`,
+    )
+  }
 
   // explicit module maps avoid importing every RN view or private JSI header.
   add(
@@ -274,7 +345,7 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
   )
   add(
     `${targetPath(coreTarget)}/include/module.modulemap`,
-    `module ${coreTarget} { header "NitroModules/InstallNitro.hpp" export * }\n`,
+    `module ${coreTarget} { header "NitroModules/InstallNitro.hpp"${config.swiftModule ? ['ArrayBufferHolder.hpp', 'AnyMapUtils.hpp', 'PromiseHolder.hpp', 'Result.hpp', 'RuntimeError.hpp', 'DateToChronoDate.hpp'].map((header) => ` header "NitroModules/${header}"`).join('') : ''} export * }\n`,
   )
   add(
     result.registration.header,
@@ -282,7 +353,7 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
   )
   add(
     `${targetPath(targetName)}/include/module.modulemap`,
-    `module ${targetName} { header "PeachNitroRegistration.hpp" export * }\n`,
+    `module ${targetName} { header "PeachNitroRegistration.hpp"${config.swiftModule ? ` header "${config.swiftModule}-Swift-Cxx-Bridge.hpp"` : ''} export * }\n`,
   )
   add(
     `${targetPath(targetName)}/PeachNitroRegistration.cpp`,
@@ -291,15 +362,28 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
       '#include <NitroModules/HybridObjectRegistry.hpp>',
       '#include <memory>',
       '#include <type_traits>',
-      ...[...new Set(config.classes.map(({ implementation }) => implementation))].map(
-        (implementation) => `#include "${implementation}.hpp"`,
-      ),
+      ...(config.swiftModule
+        ? [`#include "${config.swiftModule}-Swift-Cxx-Umbrella.hpp"`]
+        : []),
+      ...[
+        ...new Set(
+          config.classes
+            .filter((entry) => entry.language === 'c++')
+            .map(({ implementation }) => implementation),
+        ),
+      ].map((implementation) => `#include "${implementation}.hpp"`),
       `extern "C" void ${result.registration.symbol}() {`,
-      ...config.classes.flatMap(({ name, implementation }) => [
-        `  static_assert(std::is_default_constructible_v<${config.namespace}::${implementation}>);`,
+      ...config.classes.flatMap((entry) => [
+        ...(entry.language === 'c++'
+          ? [
+              `  static_assert(std::is_default_constructible_v<${config.namespace}::${entry.implementation}>);`,
+            ]
+          : []),
         '  margelo::nitro::HybridObjectRegistry::registerHybridObjectConstructor(',
-        `    ${JSON.stringify(name)}, []() -> std::shared_ptr<margelo::nitro::HybridObject> {`,
-        `      return std::make_shared<${config.namespace}::${implementation}>();`,
+        `    ${JSON.stringify(entry.name)}, []() -> std::shared_ptr<margelo::nitro::HybridObject> {`,
+        entry.language === 'swift'
+          ? `      return ${config.swiftModule}::${config.swiftModule}Autolinking::create${entry.name}();`
+          : `      return std::make_shared<${config.namespace}::${entry.implementation}>();`,
         '    });',
       ]),
       '}',