nitrogen 0.2.24 → 0.29.5

package/src/autolinking/android/createGradleExtension.ts

@@ -0,0 +1,43 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { createFileMetadataString } from '../../syntax/helpers.js'
+import type { SourceFile } from '../../syntax/SourceFile.js'
+
+export interface GradleFile extends Omit<SourceFile, 'language'> {
+  language: 'gradle'
+}
+
+export function createGradleExtension(): GradleFile {
+  const name = NitroConfig.current.getAndroidCxxLibName()
+
+  const code = `
+${createFileMetadataString(`${name}+autolinking.gradle`)}
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// \`\`\`gradle
+/// apply from: '../nitrogen/generated/android/${name}+autolinking.gradle'
+/// \`\`\`
+
+logger.warn("[NitroModules] 🔥 ${name} is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "\${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}
+  `.trim()
+  return {
+    content: code,
+    language: 'gradle',
+    name: `${name}+autolinking.gradle`,
+    platform: 'android',
+    subdirectory: [],
+  }
+}

package/src/autolinking/android/createHybridObjectInitializer.ts

@@ -0,0 +1,174 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { createCppHybridObjectRegistration } from '../../syntax/c++/CppHybridObjectRegistration.js'
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js'
+import {
+  createFileMetadataString,
+  isNotDuplicate,
+} from '../../syntax/helpers.js'
+import { getJNINativeRegistrations } from '../../syntax/kotlin/JNINativeRegistrations.js'
+import { createJNIHybridObjectRegistration } from '../../syntax/kotlin/KotlinHybridObjectRegistration.js'
+import type { SourceFile, SourceImport } from '../../syntax/SourceFile.js'
+import { indent } from '../../utils.js'
+import { getBuildingWithGeneratedCmakeDefinition } from './createCMakeExtension.js'
+
+export function createHybridObjectIntializer(): SourceFile[] {
+  const cxxNamespace = NitroConfig.current.getCxxNamespace('c++')
+  const cppLibName = NitroConfig.current.getAndroidCxxLibName()
+  const javaNamespace = NitroConfig.current.getAndroidPackage('java/kotlin')
+  const autolinkingClassName = `${NitroConfig.current.getAndroidCxxLibName()}OnLoad`
+
+  const jniRegistrations = getJNINativeRegistrations()
+    .map((r) => `${r.namespace}::${r.className}::registerNatives();`)
+    .filter(isNotDuplicate)
+
+  const autolinkedHybridObjects =
+    NitroConfig.current.getAutolinkedHybridObjects()
+
+  const cppHybridObjectImports: SourceImport[] = []
+  const cppRegistrations: string[] = []
+  for (const hybridObjectName of Object.keys(autolinkedHybridObjects)) {
+    const config = autolinkedHybridObjects[hybridObjectName]
+
+    if (config?.cpp != null) {
+      // Autolink a C++ HybridObject!
+      const { cppCode, requiredImports } = createCppHybridObjectRegistration({
+        hybridObjectName: hybridObjectName,
+        cppClassName: config.cpp,
+      })
+      cppHybridObjectImports.push(...requiredImports)
+      cppRegistrations.push(cppCode)
+    }
+    if (config?.kotlin != null) {
+      // Autolink a Kotlin HybridObject through JNI/C++!
+      const { cppCode, requiredImports } = createJNIHybridObjectRegistration({
+        hybridObjectName: hybridObjectName,
+        jniClassName: config.kotlin,
+      })
+      cppHybridObjectImports.push(...requiredImports)
+      cppRegistrations.push(cppCode)
+    }
+  }
+
+  const buildingWithDefinition = getBuildingWithGeneratedCmakeDefinition()
+
+  const includes = [
+    ...getJNINativeRegistrations().map((r) => includeHeader(r.import)),
+    ...cppHybridObjectImports.map((i) => includeHeader(i)),
+  ]
+    .filter(isNotDuplicate)
+    .join('\n')
+
+  const hppCode = `
+${createFileMetadataString(`${autolinkingClassName}.hpp`)}
+
+#include <jni.h>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace ${cxxNamespace} {
+
+  /**
+   * Initializes the native (C++) part of ${cppLibName}, and autolinks all Hybrid Objects.
+   * Call this in your \`JNI_OnLoad\` function (probably inside \`cpp-adapter.cpp\`).
+   * Example:
+   * \`\`\`cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return ${cxxNamespace}::initialize(vm);
+   * }
+   * \`\`\`
+   */
+  int initialize(JavaVM* vm);
+
+} // namespace ${cxxNamespace}
+
+    `
+  const cppCode = `
+${createFileMetadataString(`${autolinkingClassName}.cpp`)}
+
+#ifndef ${buildingWithDefinition}
+#error ${autolinkingClassName}.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "${autolinkingClassName}.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+${includes}
+
+namespace ${cxxNamespace} {
+
+int initialize(JavaVM* vm) {
+  using namespace margelo::nitro;
+  using namespace ${cxxNamespace};
+  using namespace facebook;
+
+  return facebook::jni::initialize(vm, [] {
+    // Register native JNI methods
+    ${indent(jniRegistrations.join('\n'), '    ')}
+
+    // Register Nitro Hybrid Objects
+    ${indent(cppRegistrations.join('\n'), '    ')}
+  });
+}
+
+} // namespace ${cxxNamespace}
+  `.trim()
+
+  const kotlinCode = `
+${createFileMetadataString(`${autolinkingClassName}.kt`)}
+
+package ${javaNamespace}
+
+import android.util.Log
+
+internal class ${autolinkingClassName} {
+  companion object {
+    private const val TAG = "${autolinkingClassName}"
+    private var didLoad = false
+    /**
+     * Initializes the native part of "${cppLibName}".
+     * This method is idempotent and can be called more than once.
+     */
+    @JvmStatic
+    fun initializeNative() {
+      if (didLoad) return
+      try {
+        Log.i(TAG, "Loading ${cppLibName} C++ library...")
+        System.loadLibrary("${cppLibName}")
+        Log.i(TAG, "Successfully loaded ${cppLibName} C++ library!")
+        didLoad = true
+      } catch (e: Error) {
+        Log.e(TAG, "Failed to load ${cppLibName} C++ library! Is it properly installed and linked? " +
+                    "Is the name correct? (see \`CMakeLists.txt\`, at \`add_library(...)\`)", e)
+        throw e
+      }
+    }
+  }
+}
+  `.trim()
+
+  return [
+    {
+      content: hppCode,
+      language: 'c++',
+      name: `${autolinkingClassName}.hpp`,
+      platform: 'android',
+      subdirectory: [],
+    },
+    {
+      content: cppCode,
+      language: 'c++',
+      name: `${autolinkingClassName}.cpp`,
+      platform: 'android',
+      subdirectory: [],
+    },
+    {
+      content: kotlinCode,
+      language: 'kotlin',
+      name: `${autolinkingClassName}.kt`,
+      platform: 'android',
+      subdirectory: ['kotlin', ...javaNamespace.split('.')],
+    },
+  ]
+}

package/src/autolinking/createAndroidAutolinking.ts

@@ -0,0 +1,28 @@
+import type { SourceFile, SourceImport } from '../syntax/SourceFile.js'
+import { createCMakeExtension } from './android/createCMakeExtension.js'
+import { createGradleExtension } from './android/createGradleExtension.js'
+import { createHybridObjectIntializer } from './android/createHybridObjectInitializer.js'
+import type { Autolinking } from './Autolinking.js'
+
+interface JNIHybridRegistration {
+  sourceImport: SourceImport
+  registrationCode: string
+}
+
+interface AndroidAutolinking extends Autolinking {
+  jniHybridRegistrations: JNIHybridRegistration[]
+}
+
+export function createAndroidAutolinking(
+  allFiles: SourceFile[]
+): AndroidAutolinking {
+  const cmakeExtension = createCMakeExtension(allFiles)
+  const gradleExtension = createGradleExtension()
+  const hybridObjectInitializer = createHybridObjectIntializer()
+
+  return {
+    platform: 'android',
+    jniHybridRegistrations: [],
+    sourceFiles: [cmakeExtension, gradleExtension, ...hybridObjectInitializer],
+  }
+}

package/src/autolinking/createIOSAutolinking.ts

@@ -0,0 +1,24 @@
+import type { Autolinking } from './Autolinking.js'
+import { createHybridObjectIntializer } from './ios/createHybridObjectInitializer.js'
+import { createPodspecRubyExtension } from './ios/createPodspecRubyExtension.js'
+import { createSwiftCxxBridge } from './ios/createSwiftCxxBridge.js'
+import { createSwiftUmbrellaHeader } from './ios/createSwiftUmbrellaHeader.js'
+
+interface IOSAutolinking extends Autolinking {}
+
+export function createIOSAutolinking(): IOSAutolinking {
+  const podspecExtension = createPodspecRubyExtension()
+  const swiftCxxBridge = createSwiftCxxBridge()
+  const swiftUmbrellaHeader = createSwiftUmbrellaHeader()
+  const hybridObjectInitializer = createHybridObjectIntializer()
+
+  return {
+    platform: 'ios',
+    sourceFiles: [
+      podspecExtension,
+      ...swiftCxxBridge,
+      swiftUmbrellaHeader,
+      ...hybridObjectInitializer,
+    ],
+  }
+}

package/src/autolinking/ios/createHybridObjectInitializer.ts

@@ -0,0 +1,112 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { createCppHybridObjectRegistration } from '../../syntax/c++/CppHybridObjectRegistration.js'
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js'
+import { createFileMetadataString } from '../../syntax/helpers.js'
+import type { SourceFile, SourceImport } from '../../syntax/SourceFile.js'
+import { createSwiftHybridObjectRegistration } from '../../syntax/swift/SwiftHybridObjectRegistration.js'
+import { indent } from '../../utils.js'
+import { getUmbrellaHeaderName } from './createSwiftUmbrellaHeader.js'
+
+type ObjcFile = Omit<SourceFile, 'language'> & { language: 'objective-c++' }
+type SwiftFile = Omit<SourceFile, 'language'> & { language: 'swift' }
+
+export function createHybridObjectIntializer(): [ObjcFile, SwiftFile] | [] {
+  const autolinkingClassName = `${NitroConfig.current.getIosModuleName()}Autolinking`
+  const umbrellaHeaderName = getUmbrellaHeaderName()
+  const bridgeNamespace = NitroConfig.current.getSwiftBridgeNamespace('swift')
+
+  const autolinkedHybridObjects =
+    NitroConfig.current.getAutolinkedHybridObjects()
+
+  const swiftFunctions: string[] = []
+  const cppRegistrations: string[] = []
+  const cppImports: SourceImport[] = []
+  let containsSwiftObjects = false
+  for (const hybridObjectName of Object.keys(autolinkedHybridObjects)) {
+    const config = autolinkedHybridObjects[hybridObjectName]
+
+    if (config?.cpp != null) {
+      // Autolink a C++ HybridObject!
+      const { cppCode, requiredImports } = createCppHybridObjectRegistration({
+        hybridObjectName: hybridObjectName,
+        cppClassName: config.cpp,
+      })
+      cppImports.push(...requiredImports)
+      cppRegistrations.push(cppCode)
+    }
+    if (config?.swift != null) {
+      // Autolink a Swift HybridObject!
+      containsSwiftObjects = true
+      const { cppCode, requiredImports, swiftFunction } =
+        createSwiftHybridObjectRegistration({
+          hybridObjectName: hybridObjectName,
+          swiftClassName: config.swift,
+        })
+      cppImports.push(...requiredImports)
+      cppRegistrations.push(cppCode)
+      swiftFunctions.push(swiftFunction)
+    }
+  }
+
+  if (cppRegistrations.length === 0) {
+    // Nothing to autolink!
+    return []
+  }
+
+  const umbrellaImport = containsSwiftObjects
+    ? `#import "${umbrellaHeaderName}"`
+    : ''
+  const imports = cppImports.map((i) => includeHeader(i, true)).join('\n')
+
+  const objcCode = `
+${createFileMetadataString(`${autolinkingClassName}.mm`)}
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+${umbrellaImport}
+#import <type_traits>
+
+${imports}
+
+@interface ${autolinkingClassName} : NSObject
+@end
+
+@implementation ${autolinkingClassName}
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace ${NitroConfig.current.getCxxNamespace('c++')};
+
+  ${indent(cppRegistrations.join('\n'), '  ')}
+}
+
+@end
+  `.trim()
+
+  const swiftCode = `
+${createFileMetadataString(`${autolinkingClassName}.swift`)}
+
+public final class ${autolinkingClassName} {
+  public typealias bridge = ${bridgeNamespace}
+
+  ${indent(swiftFunctions.join('\n\n'), '  ')}
+}
+  `.trim()
+
+  return [
+    {
+      content: objcCode,
+      language: 'objective-c++',
+      name: `${autolinkingClassName}.mm`,
+      platform: 'ios',
+      subdirectory: [],
+    },
+    {
+      content: swiftCode,
+      language: 'swift',
+      name: `${autolinkingClassName}.swift`,
+      platform: 'ios',
+      subdirectory: [],
+    },
+  ]
+}

package/src/autolinking/ios/createPodspecRubyExtension.ts

@@ -0,0 +1,76 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { createFileMetadataString } from '../../syntax/helpers.js'
+import type { SourceFile } from '../../syntax/SourceFile.js'
+
+export interface RubyFile extends Omit<SourceFile, 'language'> {
+  language: 'ruby'
+}
+
+export function createPodspecRubyExtension(): RubyFile {
+  const name = NitroConfig.current.getIosModuleName()
+
+  const code = `
+${createFileMetadataString(`${name}+autolinking.rb`, '#')}
+
+# This is a Ruby script that adds all files generated by Nitrogen
+# to the given podspec.
+#
+# To use it, add this to your .podspec:
+# \`\`\`ruby
+# Pod::Spec.new do |spec|
+#   # ...
+#
+#   # Add all files generated by Nitrogen
+#   load 'nitrogen/generated/ios/${name}+autolinking.rb'
+#   add_nitrogen_files(spec)
+# end
+# \`\`\`
+
+def add_nitrogen_files(spec)
+  Pod::UI.puts "[NitroModules] 🔥 ${name} is boosted by nitro!"
+
+  spec.dependency "NitroModules"
+
+  current_source_files = Array(spec.attributes_hash['source_files'])
+  spec.source_files = current_source_files + [
+    # Generated cross-platform specs
+    "nitrogen/generated/shared/**/*.{h,hpp,c,cpp,swift}",
+    # Generated bridges for the cross-platform specs
+    "nitrogen/generated/ios/**/*.{h,hpp,c,cpp,mm,swift}",
+  ]
+
+  current_public_header_files = Array(spec.attributes_hash['public_header_files'])
+  spec.public_header_files = current_public_header_files + [
+    # Generated specs
+    "nitrogen/generated/shared/**/*.{h,hpp}",
+    # Swift to C++ bridging helpers
+    "nitrogen/generated/ios/${name}-Swift-Cxx-Bridge.hpp"
+  ]
+
+  current_private_header_files = Array(spec.attributes_hash['private_header_files'])
+  spec.private_header_files = current_private_header_files + [
+    # iOS specific specs
+    "nitrogen/generated/ios/c++/**/*.{h,hpp}",
+    # Views are framework-specific and should be private
+    "nitrogen/generated/shared/**/views/**/*"
+  ]
+
+  current_pod_target_xcconfig = spec.attributes_hash['pod_target_xcconfig'] || {}
+  spec.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    # Use C++ 20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    # Enables C++ <-> Swift interop (by default it's only C)
+    "SWIFT_OBJC_INTEROP_MODE" => "objcxx",
+    # Enables stricter modular headers
+    "DEFINES_MODULE" => "YES",
+  })
+end
+  `.trim()
+  return {
+    content: code,
+    language: 'ruby',
+    name: `${name}+autolinking.rb`,
+    platform: 'ios',
+    subdirectory: [],
+  }
+}

package/src/autolinking/ios/createSwiftCxxBridge.ts

@@ -0,0 +1,137 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js'
+import { getAllKnownTypes } from '../../syntax/createType.js'
+import {
+  createFileMetadataString,
+  isNotDuplicate,
+} from '../../syntax/helpers.js'
+import type { SourceFile } from '../../syntax/SourceFile.js'
+import { getReferencedTypes } from '../../syntax/getReferencedTypes.js'
+import { SwiftCxxBridgedType } from '../../syntax/swift/SwiftCxxBridgedType.js'
+import { filterDuplicateHelperBridges, indent } from '../../utils.js'
+import { getTypeAs } from '../../syntax/types/getTypeAs.js'
+import { HybridObjectType } from '../../syntax/types/HybridObjectType.js'
+import { getForwardDeclaration } from '../../syntax/c++/getForwardDeclaration.js'
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js'
+
+export function createSwiftCxxBridge(): SourceFile[] {
+  const bridgeName = NitroConfig.current.getSwiftBridgeHeaderName()
+  const bridgeNamespace = NitroConfig.current.getSwiftBridgeNamespace('c++')
+
+  const types = getAllKnownTypes('swift').map((t) => new SwiftCxxBridgedType(t))
+
+  const bridges = types
+    .flatMap((t) => {
+      const referenced = getReferencedTypes(t.type)
+      return referenced.map((r) => {
+        const bridge = new SwiftCxxBridgedType(r)
+        return bridge.getRequiredBridge()
+      })
+    })
+    .filter((b) => b != null)
+    .flatMap((b) => [b, ...b?.dependencies])
+    .filter(filterDuplicateHelperBridges)
+  const headerHelperFunctions = bridges
+    .map((b) => `// pragma MARK: ${b.cxxType}\n${b.cxxHeader.code}`)
+    .filter(isNotDuplicate)
+    .join('\n\n')
+  const implementationHelperFunctions = bridges
+    .map((b) => {
+      if (b.cxxImplementation == null) return undefined
+      else return `// pragma MARK: ${b.cxxType}\n${b.cxxImplementation.code}`
+    })
+    .filter((c) => c != null)
+    .filter(isNotDuplicate)
+    .join('\n\n')
+
+  const requiredImportsHeader = bridges.flatMap(
+    (b) => b.cxxHeader.requiredIncludes
+  )
+  const includesHeader = requiredImportsHeader
+    .map((i) => includeHeader(i, true))
+    .filter(isNotDuplicate)
+  const forwardDeclarationsHeader = requiredImportsHeader
+    .map((i) => i.forwardDeclaration)
+    .filter((f) => f != null)
+    .filter(isNotDuplicate)
+
+  const includesImplementation = bridges
+    .flatMap((b) => b.cxxImplementation?.requiredIncludes)
+    .filter((i) => i != null)
+    .map((i) => includeHeader(i, true))
+    .filter(isNotDuplicate)
+
+  const forwardDeclaredSwiftTypes = types
+    .filter((t) => t.type.kind === 'hybrid-object')
+    .map((t) => {
+      const hybridObject = getTypeAs(t.type, HybridObjectType)
+      const hybridObjectModuleName =
+        hybridObject.sourceConfig.getIosModuleName()
+      const { HybridTSpecCxx } = getHybridObjectName(
+        hybridObject.hybridObjectName
+      )
+      return getForwardDeclaration(
+        'class',
+        HybridTSpecCxx,
+        hybridObjectModuleName
+      )
+    })
+    .filter(isNotDuplicate)
+
+  const header = `
+${createFileMetadataString(`${bridgeName}.hpp`)}
+
+#pragma once
+
+// Forward declarations of C++ defined types
+${forwardDeclarationsHeader.sort().join('\n')}
+
+// Forward declarations of Swift defined types
+${forwardDeclaredSwiftTypes.sort().join('\n')}
+
+// Include C++ defined types
+${includesHeader.sort().join('\n')}
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace ${bridgeNamespace} {
+
+  ${indent(headerHelperFunctions, '  ')}
+
+} // namespace ${bridgeNamespace}
+`
+
+  const source = `
+${createFileMetadataString(`${bridgeName}.cpp`)}
+
+#include "${bridgeName}.hpp"
+
+// Include C++ implementation defined types
+${includesImplementation.sort().join('\n')}
+
+namespace ${bridgeNamespace} {
+
+  ${indent(implementationHelperFunctions, '  ')}
+
+} // namespace ${bridgeNamespace}
+`
+
+  const files: SourceFile[] = []
+  files.push({
+    content: header,
+    language: 'c++',
+    name: `${bridgeName}.hpp`,
+    platform: 'ios',
+    subdirectory: [],
+  })
+  files.push({
+    content: source,
+    language: 'c++',
+    name: `${bridgeName}.cpp`,
+    platform: 'ios',
+    subdirectory: [],
+  })
+  return files
+}

package/src/autolinking/ios/createSwiftUmbrellaHeader.ts

@@ -0,0 +1,90 @@
+import { NitroConfig } from '../../config/NitroConfig.js'
+import { getForwardDeclaration } from '../../syntax/c++/getForwardDeclaration.js'
+import { includeHeader } from '../../syntax/c++/includeNitroHeader.js'
+import { getAllKnownTypes } from '../../syntax/createType.js'
+import { getHybridObjectName } from '../../syntax/getHybridObjectName.js'
+import {
+  createFileMetadataString,
+  isNotDuplicate,
+} from '../../syntax/helpers.js'
+import type { SourceFile } from '../../syntax/SourceFile.js'
+import { getTypeAs } from '../../syntax/types/getTypeAs.js'
+import { HybridObjectType } from '../../syntax/types/HybridObjectType.js'
+
+export function getUmbrellaHeaderName(): string {
+  const moduleName = NitroConfig.current.getIosModuleName()
+  return `${moduleName}-Swift-Cxx-Umbrella.hpp`
+}
+
+export function createSwiftUmbrellaHeader(): SourceFile {
+  const moduleName = NitroConfig.current.getIosModuleName()
+  const filename = getUmbrellaHeaderName()
+
+  const types = getAllKnownTypes('swift')
+
+  const swiftForwardDeclares = types
+    .filter((t) => t.kind === 'hybrid-object')
+    .map((t) => {
+      const hybridObjectType = getTypeAs(t, HybridObjectType)
+      const hybridObjectModuleName =
+        hybridObjectType.sourceConfig.getIosModuleName()
+      const name = getHybridObjectName(hybridObjectType.hybridObjectName)
+      return getForwardDeclaration(
+        'class',
+        name.HybridTSpecCxx,
+        hybridObjectModuleName
+      )
+    })
+    .filter(isNotDuplicate)
+
+  const imports = types.flatMap((t) => t.getRequiredImports('c++'))
+  const forwardDeclarations = imports
+    .map((i) => i.forwardDeclaration)
+    .filter((f) => f != null)
+    .filter(isNotDuplicate)
+  const includes = imports.map((i) => includeHeader(i)).filter(isNotDuplicate)
+
+  const code = `
+${createFileMetadataString(filename, '///')}
+
+#pragma once
+
+// Forward declarations of C++ defined types
+${forwardDeclarations.sort().join('\n')}
+
+// Include C++ defined types
+${includes.sort().join('\n')}
+
+// C++ helpers for Swift
+#include "${moduleName}-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+${swiftForwardDeclares.sort().join('\n')}
+
+// Include Swift defined types
+#if __has_include("${moduleName}-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "${moduleName}".
+#include "${moduleName}-Swift.h"
+// Same as above, but used when building with frameworks (\`use_frameworks\`)
+#elif __has_include(<${moduleName}/${moduleName}-Swift.h>)
+#include <${moduleName}/${moduleName}-Swift.h>
+#else
+#error ${moduleName}'s autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "${moduleName}", and try building the app first.
+#endif
+`
+
+  return {
+    content: code,
+    language: 'c++',
+    name: filename,
+    platform: 'ios',
+    subdirectory: [],
+  }
+}