build.gradle

apply plugin: 'com.android.library'
apply plugin: 'org.jetbrains.kotlin.multiplatform'
apply plugin: 'com.vanniktech.maven.publish'
apply plugin: 'org.jetbrains.dokka'
apply plugin: 'app.cash.molecule'
apply plugin: 'org.jetbrains.kotlinx.binary-compatibility-validator'

kotlin {
  explicitApi()

  androidTarget {
    publishLibraryVariants('release')
  }

  iosArm64()
  iosSimulatorArm64()
  iosX64()

  js {
    browser()
  }

  jvm()

  linuxArm64()
  linuxX64()

  macosArm64()
  macosX64()

  mingwX64()

  tvosArm64()
  tvosSimulatorArm64()
  tvosX64()

  wasmJs {
    browser()
  }

  watchosArm32()
  watchosArm64()
  watchosSimulatorArm64()
  watchosX64()

  applyDefaultHierarchyTemplate()

  sourceSets {
    configureEach {
      languageSettings.optIn("kotlinx.cinterop.BetaInteropApi")
      languageSettings.optIn("kotlinx.cinterop.ExperimentalForeignApi")
    }

    commonMain {
      dependencies {
        api libs.jetbrains.compose.runtime
        api libs.kotlinx.coroutines.core
      }
    }
    commonTest {
      dependencies {
        implementation libs.kotlin.test
        implementation libs.assertk
        implementation libs.kotlinx.coroutines.test
      }
    }

    androidMain {
      dependencies {
        implementation libs.androidx.core
      }
    }

    // We use a common folder instead of a common source set because there is no commonizer
    // which exposes the browser APIs across these two targets.
    jsMain {
      kotlin.srcDir('src/browserMain/kotlin')
    }
    wasmJsMain {
      kotlin.srcDir('src/browserMain/kotlin')
    }

    darwinMain {
      dependsOn(commonMain)
    }

    displayLinkMain {
      dependsOn(darwinMain)
    }
    displayLinkTest {
      dependsOn(commonTest)
    }

    quartzCoreMain {
      dependsOn(displayLinkMain)
    }

    iosMain {
      dependsOn(quartzCoreMain)
    }
    iosTest {
      // TODO Link against XCTest in order to get frame pulses on iOS.
      // dependsOn(displayLinkTest)
    }

    tvosMain {
      dependsOn(quartzCoreMain)
    }
    tvosTest {
      // TODO Link against XCTest in order to get frame pulses on tvOS.
      // dependsOn(displayLinkTest)
    }

    macosMain {
      dependsOn(displayLinkMain)
    }
    macosTest {
      dependsOn(displayLinkTest)
    }

    watchosMain {
      dependsOn(darwinMain)
    }
  }
}

dependencies {
  androidTestImplementation libs.androidx.test.runner
  androidTestImplementation libs.junit
  androidTestImplementation libs.assertk
  androidTestImplementation libs.kotlinx.coroutines.test

  // The kotlin.test library provides JVM variants for multiple testing frameworks. When used
  // as a test dependency this selection is transparent. But since we are using from an Android
  // configuration we have to select the desired variant via an explicit capability.
  add("androidTestImplementation", libs.kotlin.test) {
    capabilities {
      requireCapability(
        "org.jetbrains.kotlin:kotlin-test-framework-junit:${libs.versions.kotlin.get()}")
    }
  }
}

android {
  namespace 'app.cash.molecule'

  sourceSets {
    androidTest {
      java.srcDirs += 'src/commonTest/kotlin'
    }
  }

  defaultConfig {
    testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'
  }

  testOptions {
    unitTests.returnDefaultValues = true
  }

  packagingOptions {
    exclude 'META-INF/AL2.0'
    exclude 'META-INF/LGPL2.1'
  }
}

apiValidation {
  klib.enabled = true
}

spotless {
  kotlin {
    targetExclude(
      // Apache 2-licensed files from AOSP.
      "src/androidMain/kotlin/app/cash/molecule/AndroidUiDispatcher.kt",
      "src/androidMain/kotlin/app/cash/molecule/AndroidUiFrameClock.kt",
    )
  }
}