@ohos-ports/react-native-gradle-plugin 0.71.19-beta.0 → 0.86.0-beta.0

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/utils/AgpConfiguratorUtils.kt

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.utils
+
+import com.android.build.api.variant.ApplicationAndroidComponentsExtension
+import com.android.build.api.variant.LibraryAndroidComponentsExtension
+import com.android.build.gradle.LibraryExtension
+import com.facebook.react.ReactExtension
+import com.facebook.react.utils.ProjectUtils.isEdgeToEdgeEnabled
+import com.facebook.react.utils.ProjectUtils.isHermesEnabled
+import java.io.File
+import java.net.Inet4Address
+import java.net.NetworkInterface
+import javax.xml.parsers.DocumentBuilder
+import javax.xml.parsers.DocumentBuilderFactory
+import kotlin.plus
+import org.gradle.api.Action
+import org.gradle.api.Project
+import org.gradle.api.plugins.AppliedPlugin
+import org.w3c.dom.Element
+
+@Suppress("UnstableApiUsage")
+internal object AgpConfiguratorUtils {
+
+  fun configureBuildTypesForApp(project: Project) {
+    val action =
+        Action<AppliedPlugin> {
+          project.extensions
+              .getByType(ApplicationAndroidComponentsExtension::class.java)
+              .finalizeDsl { ext ->
+                ext.buildTypes {
+                  val debug =
+                      getByName("debug").apply {
+                        manifestPlaceholders["usesCleartextTraffic"] = "true"
+                      }
+                  getByName("release").apply {
+                    manifestPlaceholders["usesCleartextTraffic"] = "false"
+                  }
+                  maybeCreate("debugOptimized").apply {
+                    manifestPlaceholders["usesCleartextTraffic"] = "true"
+                    initWith(debug)
+                    matchingFallbacks += listOf("release")
+                    externalNativeBuild { cmake { arguments("-DCMAKE_BUILD_TYPE=Release") } }
+                  }
+                }
+              }
+        }
+    project.pluginManager.withPlugin("com.android.application", action)
+  }
+
+  fun configureBuildConfigFieldsForApp(project: Project, extension: ReactExtension) {
+    val action =
+        Action<AppliedPlugin> {
+          project.extensions
+              .getByType(ApplicationAndroidComponentsExtension::class.java)
+              .finalizeDsl { ext ->
+                ext.buildFeatures.buildConfig = true
+                ext.defaultConfig.buildConfigField("boolean", "IS_NEW_ARCHITECTURE_ENABLED", "true")
+                ext.defaultConfig.buildConfigField(
+                    "boolean",
+                    "IS_HERMES_ENABLED",
+                    project.isHermesEnabled.toString(),
+                )
+                ext.defaultConfig.buildConfigField(
+                    "boolean",
+                    "IS_EDGE_TO_EDGE_ENABLED",
+                    project.isEdgeToEdgeEnabled.toString(),
+                )
+              }
+        }
+    project.pluginManager.withPlugin("com.android.application", action)
+    project.pluginManager.withPlugin("com.android.library", action)
+  }
+
+  fun configureBuildConfigFieldsForLibraries(appProject: Project) {
+    appProject.rootProject.allprojects { subproject ->
+      subproject.pluginManager.withPlugin("com.android.library") {
+        subproject.extensions
+            .getByType(LibraryAndroidComponentsExtension::class.java)
+            .finalizeDsl { ext -> ext.buildFeatures.buildConfig = true }
+      }
+    }
+  }
+
+  fun configureDevServerLocation(project: Project) {
+    val devServerIp = project.properties["reactNativeDevServerIp"]?.toString() ?: getHostIpAddress()
+    val devServerPort =
+        project.properties["reactNativeDevServerPort"]?.toString() ?: DEFAULT_DEV_SERVER_PORT
+
+    val action =
+        Action<AppliedPlugin> {
+          project.extensions
+              .getByType(ApplicationAndroidComponentsExtension::class.java)
+              .finalizeDsl { ext ->
+                ext.buildFeatures.resValues = true
+                ext.defaultConfig.resValue(
+                    "string",
+                    "react_native_dev_server_ip",
+                    devServerIp,
+                )
+                ext.defaultConfig.resValue("integer", "react_native_dev_server_port", devServerPort)
+              }
+        }
+
+    project.pluginManager.withPlugin("com.android.application", action)
+    project.pluginManager.withPlugin("com.android.library", action)
+  }
+
+  fun configureNamespaceForLibraries(appProject: Project) {
+    appProject.rootProject.allprojects { subproject ->
+      subproject.pluginManager.withPlugin("com.android.library") {
+        subproject.extensions
+            .getByType(LibraryAndroidComponentsExtension::class.java)
+            .finalizeDsl { ext ->
+              if (ext.namespace == null) {
+                val android = subproject.extensions.getByType(LibraryExtension::class.java)
+                val manifestFile = android.sourceSets.getByName("main").manifest.srcFile
+
+                manifestFile
+                    .takeIf { it.exists() }
+                    ?.let { file ->
+                      getPackageNameFromManifest(file)?.let { packageName ->
+                        ext.namespace = packageName
+                      }
+                    }
+              }
+            }
+      }
+    }
+  }
+}
+
+const val DEFAULT_DEV_SERVER_PORT = "8081"
+
+fun getPackageNameFromManifest(manifest: File): String? {
+  val factory: DocumentBuilderFactory = DocumentBuilderFactory.newInstance()
+  val builder: DocumentBuilder = factory.newDocumentBuilder()
+
+  try {
+    val xmlDocument = builder.parse(manifest)
+
+    val manifestElement = xmlDocument.getElementsByTagName("manifest").item(0) as? Element
+    val packageName = manifestElement?.getAttribute("package")
+
+    return if (packageName.isNullOrEmpty()) null else packageName
+  } catch (e: Exception) {
+    return null
+  }
+}
+
+internal fun getHostIpAddress(): String =
+    NetworkInterface.getNetworkInterfaces()
+        .asSequence()
+        .filter { it.isUp && !it.isLoopback }
+        .flatMap { it.inetAddresses.asSequence() }
+        .filter { it is Inet4Address && !it.isLoopbackAddress }
+        .map { it.hostAddress }
+        .firstOrNull() ?: "localhost"

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/utils/BackwardCompatUtils.kt

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.utils
+
+import java.util.*
+import org.gradle.api.Project
+
+internal object BackwardCompatUtils {
+  private var hasShownJSCRemovalMessage = false
+
+  fun configureBackwardCompatibilityReactMap(project: Project) {
+    if (project.extensions.extraProperties.has("react")) {
+      @Suppress("UNCHECKED_CAST")
+      val reactMap =
+          project.extensions.extraProperties.get("react") as? Map<String, Any?> ?: mapOf()
+      if (reactMap.isNotEmpty()) {
+        project.logger.error(
+            """
+            ********************************************************************************
+
+            ERROR: Using old project.ext.react configuration.
+            We identified that your project is using a old configuration block as:
+
+            project.ext.react = [
+                // ...
+            ]
+
+            You should migrate to the new configuration:
+
+            react {
+                // ...
+            }
+            You can find documentation inside `android/app/build.gradle` on how to use it.
+
+            ********************************************************************************
+            """
+                .trimIndent()
+        )
+      }
+    }
+
+    // We set an empty react[] map so if a library is reading it, they will find empty values.
+    project.extensions.extraProperties.set("react", mapOf<String, String>())
+  }
+
+  fun showJSCRemovalMessage(project: Project) {
+    if (hasShownJSCRemovalMessage) {
+      return
+    }
+
+    val message =
+        """
+
+        =============== JavaScriptCore is being moved ===============
+        JavaScriptCore has been extracted from react-native core
+        and will be removed in a future release. It can now be
+        installed from `@react-native-community/javascriptcore`
+        See: https://github.com/react-native-community/javascriptcore
+        =============================================================
+
+        """
+            .trimIndent()
+    project.logger.warn(message)
+    hasShownJSCRemovalMessage = true
+  }
+}

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/utils/DependencyUtils.kt

@@ -0,0 +1,299 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.utils
+
+import com.facebook.react.utils.PropertyUtils.DEFAULT_INTERNAL_HERMES_PUBLISHING_GROUP
+import com.facebook.react.utils.PropertyUtils.DEFAULT_INTERNAL_REACT_PUBLISHING_GROUP
+import com.facebook.react.utils.PropertyUtils.EXCLUSIVE_ENTEPRISE_REPOSITORY
+import com.facebook.react.utils.PropertyUtils.INCLUDE_JITPACK_REPOSITORY
+import com.facebook.react.utils.PropertyUtils.INCLUDE_JITPACK_REPOSITORY_DEFAULT
+import com.facebook.react.utils.PropertyUtils.INTERNAL_HERMES_PUBLISHING_GROUP
+import com.facebook.react.utils.PropertyUtils.INTERNAL_HERMES_V1_VERSION_NAME
+import com.facebook.react.utils.PropertyUtils.INTERNAL_HERMES_VERSION_NAME
+import com.facebook.react.utils.PropertyUtils.INTERNAL_REACT_NATIVE_MAVEN_LOCAL_REPO
+import com.facebook.react.utils.PropertyUtils.INTERNAL_REACT_PUBLISHING_GROUP
+import com.facebook.react.utils.PropertyUtils.INTERNAL_USE_HERMES_NIGHTLY
+import com.facebook.react.utils.PropertyUtils.INTERNAL_VERSION_NAME
+import com.facebook.react.utils.PropertyUtils.SCOPED_EXCLUSIVE_ENTEPRISE_REPOSITORY
+import com.facebook.react.utils.PropertyUtils.SCOPED_INCLUDE_JITPACK_REPOSITORY
+import java.io.File
+import java.net.URI
+import java.util.*
+import org.gradle.api.Project
+import org.gradle.api.artifacts.repositories.MavenArtifactRepository
+
+internal object DependencyUtils {
+
+  internal data class Coordinates(
+      val versionString: String,
+      val hermesVersionString: String,
+      val hermesV1VersionString: String,
+      val reactGroupString: String = DEFAULT_INTERNAL_REACT_PUBLISHING_GROUP,
+      val hermesGroupString: String = DEFAULT_INTERNAL_HERMES_PUBLISHING_GROUP,
+      private val isHermesNightly: Boolean = false,
+  ) {
+    val isNightly: Boolean
+      get() = versionString.isNightly() || isHermesNightly
+  }
+
+  /**
+   * This method takes care of configuring the repositories{} block for both the app and all the 3rd
+   * party libraries which are auto-linked.
+   */
+  fun configureRepositories(project: Project, isNightly: Boolean) {
+    val exclusiveEnterpriseRepository = project.rootProject.exclusiveEnterpriseRepository()
+    if (exclusiveEnterpriseRepository != null) {
+      project.logger.lifecycle(
+          "Replacing ALL Maven Repositories with: $exclusiveEnterpriseRepository"
+      )
+    }
+
+    project.rootProject.allprojects { eachProject ->
+      with(eachProject) {
+        if (hasProperty(INTERNAL_REACT_NATIVE_MAVEN_LOCAL_REPO)) {
+          val mavenLocalRepoPath = property(INTERNAL_REACT_NATIVE_MAVEN_LOCAL_REPO) as String
+          mavenRepoFromURI(File(mavenLocalRepoPath).toURI()) { repo ->
+            repo.content { it.excludeGroup("org.webkit") }
+          }
+        }
+
+        if (exclusiveEnterpriseRepository != null) {
+          // We remove all previously set repositories and only configure the proxy provided by the
+          // user.
+          rootProject.repositories.clear()
+          mavenRepoFromUrl(exclusiveEnterpriseRepository)
+          // We return here as we don't want to configure other repositories as well.
+          return@allprojects
+        }
+
+        if (isNightly) {
+          // We add the snapshot for users on nightlies.
+          mavenRepoFromUrl("https://central.sonatype.com/repository/maven-snapshots/") { repo ->
+            repo.content { it.excludeGroup("org.webkit") }
+          }
+        }
+        repositories.mavenCentral { repo ->
+          // We don't want to fetch JSC from Maven Central as there are older versions there.
+          repo.content { it.excludeGroup("org.webkit") }
+
+          // If the user provided a react.internal.mavenLocalRepo, do not attempt to load
+          // anything from Maven Central that is react related.
+          if (hasProperty(INTERNAL_REACT_NATIVE_MAVEN_LOCAL_REPO)) {
+            repo.content { it.excludeGroup("com.facebook.react") }
+          }
+        }
+        repositories.google { repo ->
+          repo.content {
+            // We don't want to fetch JSC or React from Google
+            it.excludeGroup("org.webkit")
+            it.excludeGroup("io.github.react-native-community")
+            it.excludeGroup("com.facebook.react")
+          }
+        }
+        if (shouldAddJitPack()) {
+          mavenRepoFromUrl("https://www.jitpack.io") { repo ->
+            repo.content { content ->
+              // We don't want to fetch JSC or React from JitPack
+              content.excludeGroup("org.webkit")
+              content.excludeGroup("io.github.react-native-community")
+              content.excludeGroup("com.facebook.react")
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * This method takes care of configuring the resolution strategy for both the app and all the 3rd
+   * party libraries which are auto-linked. Specifically it takes care of:
+   * - Forcing the react-android/hermes-android version to the one specified in the package.json
+   * - Substituting `react-native` with `react-android` and `hermes-engine` with `hermes-android`
+   * - Selecting between the classic Hermes and Hermes V1
+   */
+  fun configureDependencies(
+      project: Project,
+      coordinates: Coordinates,
+      hermesV1Enabled: Boolean = true,
+  ) {
+    if (
+        coordinates.versionString.isBlank() ||
+            (!hermesV1Enabled && coordinates.hermesVersionString.isBlank()) ||
+            (hermesV1Enabled && coordinates.hermesV1VersionString.isBlank())
+    )
+        return
+    project.rootProject.allprojects { eachProject ->
+      eachProject.configurations.all { configuration ->
+        // Here we set a dependencySubstitution for both react-native and hermes-engine as those
+        // coordinates are voided due to https://github.com/facebook/react-native/issues/35210
+        // This allows users to import libraries that are still using
+        // implementation("com.facebook.react:react-native:+") and resolve the right dependency.
+        configuration.resolutionStrategy.dependencySubstitution {
+          getDependencySubstitutions(coordinates, hermesV1Enabled).forEach { (module, dest, reason)
+            ->
+            it.substitute(it.module(module)).using(it.module(dest)).because(reason)
+          }
+        }
+        configuration.resolutionStrategy.force(
+            "${coordinates.reactGroupString}:react-android:${coordinates.versionString}",
+        )
+        if (!(eachProject.findProperty(INTERNAL_USE_HERMES_NIGHTLY) as? String).toBoolean()) {
+          // Contributors only: The hermes-engine version is forced only if the user has
+          // not opted into using nightlies for local development.
+          configuration.resolutionStrategy.force(
+              "${coordinates.hermesGroupString}:hermes-android:${if (hermesV1Enabled) coordinates.hermesV1VersionString else coordinates.hermesVersionString}"
+          )
+        }
+      }
+    }
+  }
+
+  internal fun getDependencySubstitutions(
+      coordinates: Coordinates,
+      hermesV1Enabled: Boolean = true,
+  ): List<Triple<String, String, String>> {
+    val dependencySubstitution = mutableListOf<Triple<String, String, String>>()
+    val hermesVersion =
+        if (hermesV1Enabled) coordinates.hermesV1VersionString else coordinates.hermesVersionString
+    val hermesVersionString = "${coordinates.hermesGroupString}:hermes-android:${hermesVersion}"
+    dependencySubstitution.add(
+        Triple(
+            "com.facebook.react:react-native",
+            "${coordinates.reactGroupString}:react-android:${coordinates.versionString}",
+            "The react-native artifact was deprecated in favor of react-android due to https://github.com/facebook/react-native/issues/35210.",
+        )
+    )
+    dependencySubstitution.add(
+        Triple(
+            "com.facebook.react:hermes-engine",
+            hermesVersionString,
+            "The hermes-engine artifact was deprecated in favor of hermes-android due to https://github.com/facebook/react-native/issues/35210.",
+        )
+    )
+    dependencySubstitution.add(
+        Triple(
+            "com.facebook.react:hermes-android",
+            hermesVersionString,
+            "The hermes-android artifact was moved to com.facebook.hermes publishing group.",
+        )
+    )
+    if (coordinates.reactGroupString != DEFAULT_INTERNAL_REACT_PUBLISHING_GROUP) {
+      dependencySubstitution.add(
+          Triple(
+              "com.facebook.react:react-android",
+              "${coordinates.reactGroupString}:react-android:${coordinates.versionString}",
+              "The react-android dependency was modified to use the correct Maven group.",
+          )
+      )
+      dependencySubstitution.add(
+          Triple(
+              "com.facebook.react:hermes-android",
+              hermesVersionString,
+              "The hermes-android dependency was modified to use the correct Maven group.",
+          )
+      )
+    }
+    if (coordinates.hermesGroupString != DEFAULT_INTERNAL_HERMES_PUBLISHING_GROUP) {
+      dependencySubstitution.add(
+          Triple(
+              "com.facebook.hermes:hermes-android",
+              hermesVersionString,
+              "The hermes-android dependency was modified to use the correct Maven group.",
+          )
+      )
+    }
+    return dependencySubstitution
+  }
+
+  fun readVersionAndGroupStrings(
+      project: Project,
+      propertiesFile: File,
+      hermesVersionFile: File,
+  ): Coordinates {
+    val reactAndroidProperties = Properties()
+    propertiesFile.inputStream().use { reactAndroidProperties.load(it) }
+    val versionStringFromFile = (reactAndroidProperties[INTERNAL_VERSION_NAME] as? String).orEmpty()
+    // If on a nightly, we need to fetch the -SNAPSHOT artifact from Sonatype.
+    val versionString =
+        if (versionStringFromFile.isNightly()) {
+          "$versionStringFromFile-SNAPSHOT"
+        } else {
+          versionStringFromFile
+        }
+    // Returns Maven group for repos using different group for Maven artifacts
+    val reactGroupString =
+        reactAndroidProperties[INTERNAL_REACT_PUBLISHING_GROUP] as? String
+            ?: DEFAULT_INTERNAL_REACT_PUBLISHING_GROUP
+    val hermesGroupString =
+        reactAndroidProperties[INTERNAL_HERMES_PUBLISHING_GROUP] as? String
+            ?: DEFAULT_INTERNAL_HERMES_PUBLISHING_GROUP
+
+    val hermesVersionProperties = Properties()
+    hermesVersionFile.inputStream().use { hermesVersionProperties.load(it) }
+
+    val hermesVersionString =
+        (hermesVersionProperties[INTERNAL_HERMES_VERSION_NAME] as? String).orEmpty()
+    val hermesVersion =
+        if (hermesVersionString.startsWith("0.0.0") || "-commitly-" in hermesVersionString) {
+          "$hermesVersionString-SNAPSHOT"
+        } else {
+          hermesVersionString
+        }
+
+    val hermesV1Version =
+        (hermesVersionProperties[INTERNAL_HERMES_V1_VERSION_NAME] as? String).orEmpty()
+    val isHermesNightly = (project.findProperty(INTERNAL_USE_HERMES_NIGHTLY) as? String).toBoolean()
+
+    return Coordinates(
+        versionString,
+        hermesVersion,
+        hermesV1Version,
+        reactGroupString,
+        hermesGroupString,
+        isHermesNightly,
+    )
+  }
+
+  fun Project.mavenRepoFromUrl(
+      url: String,
+      action: (MavenArtifactRepository) -> Unit = {},
+  ): MavenArtifactRepository =
+      project.repositories.maven {
+        it.url = URI.create(url)
+        action(it)
+      }
+
+  fun Project.mavenRepoFromURI(
+      uri: URI,
+      action: (MavenArtifactRepository) -> Unit = {},
+  ): MavenArtifactRepository =
+      project.repositories.maven {
+        it.url = uri
+        action(it)
+      }
+
+  internal fun Project.shouldAddJitPack() =
+      when {
+        hasProperty(SCOPED_INCLUDE_JITPACK_REPOSITORY) ->
+            property(SCOPED_INCLUDE_JITPACK_REPOSITORY).toString().toBoolean()
+        hasProperty(INCLUDE_JITPACK_REPOSITORY) ->
+            property(INCLUDE_JITPACK_REPOSITORY).toString().toBoolean()
+        else -> INCLUDE_JITPACK_REPOSITORY_DEFAULT
+      }
+
+  internal fun String.isNightly(): Boolean = this.startsWith("0.0.0") || "-nightly-" in this
+
+  internal fun Project.exclusiveEnterpriseRepository() =
+      when {
+        hasProperty(SCOPED_EXCLUSIVE_ENTEPRISE_REPOSITORY) ->
+            property(SCOPED_EXCLUSIVE_ENTEPRISE_REPOSITORY).toString()
+        hasProperty(EXCLUSIVE_ENTEPRISE_REPOSITORY) ->
+            property(EXCLUSIVE_ENTEPRISE_REPOSITORY).toString()
+        else -> null
+      }
+}

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/utils/JdkConfiguratorUtils.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.utils
+
+import com.android.build.api.variant.ApplicationAndroidComponentsExtension
+import com.android.build.api.variant.LibraryAndroidComponentsExtension
+import com.facebook.react.utils.PropertyUtils.INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT
+import org.gradle.api.Action
+import org.gradle.api.JavaVersion
+import org.gradle.api.Project
+import org.gradle.api.plugins.AppliedPlugin
+import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
+
+internal object JdkConfiguratorUtils {
+  /**
+   * Function that takes care of configuring the JDK toolchain for all the projects projects. As we
+   * do decide the JDK version based on the AGP version that RNGP brings over, here we can safely
+   * configure the toolchain to 17.
+   */
+  fun configureJavaToolChains(input: Project) {
+    // Check at the app level if react.internal.disableJavaVersionAlignment is set.
+    if (input.hasProperty(INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT)) {
+      return
+    }
+    input.rootProject.allprojects { project ->
+      // Allows every single module to set react.internal.disableJavaVersionAlignment also.
+      if (project.hasProperty(INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT)) {
+        return@allprojects
+      }
+
+      val applicationAction =
+          Action<AppliedPlugin> {
+            project.extensions
+                .getByType(ApplicationAndroidComponentsExtension::class.java)
+                .finalizeDsl { ext ->
+                  ext.compileOptions.sourceCompatibility = JavaVersion.VERSION_17
+                  ext.compileOptions.targetCompatibility = JavaVersion.VERSION_17
+                }
+          }
+      val libraryAction =
+          Action<AppliedPlugin> {
+            project.extensions
+                .getByType(LibraryAndroidComponentsExtension::class.java)
+                .finalizeDsl { ext ->
+                  ext.compileOptions.sourceCompatibility = JavaVersion.VERSION_17
+                  ext.compileOptions.targetCompatibility = JavaVersion.VERSION_17
+                }
+          }
+      project.pluginManager.withPlugin("com.android.application", applicationAction)
+      project.pluginManager.withPlugin("com.android.library", libraryAction)
+      project.pluginManager.withPlugin("org.jetbrains.kotlin.android") {
+        project.kotlinExtension.jvmToolchain(17)
+      }
+      project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+        project.kotlinExtension.jvmToolchain(17)
+      }
+    }
+  }
+}