Update gradle plugin: Deprecate experimental configuration for Compose for Web (#4796)

Since 1.6.10 Compose for Web goes to Alpha and experimental
configuration is not needed anymore. We'll configure the web targets by
default when they're added to projects.


## Testing
- I built the plugin to mavenLocal. And used it in a couple of our
samples.
- After gradle sync completes, I observe the Deprecation warning in
build.gradle.kts on `compose.experimental.web` usages (see a screenshot
below)
<img width="1022" alt="Screenshot 2024-05-10 at 15 41 14"
src="https://github.com/JetBrains/compose-multiplatform/assets/7372778/e8ede073-8d34-4dd7-ae74-c83ca0ff5c96">


Then I remove deprecated API usages and test that the project works
without it:
- run `./gradlew clean` just in case
- run the app: `./gradlew wasmJsBrowserRun` and `./gradlew jsBrowserRun`
- both run fine
- build the production distribution: `./gradlew
wasmJsBrowserDistribution`
- `cd ..../build/dist/wasmJs/productionExecutable` and run `python -m
http.server`, open a browser at `http://localhost:8000` - the app should
work the same way it works with gradle tasks above

<!-- Optional -->
This should be tested by QA

## Release Notes

### Highlights - Web
- Compose for Web goes to Alpha!
Some experimental Compose Multiplatform Gradle plugin APIs for web app
configuration were deprecated. Their usage is not required anymore.

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/ComposePlugin.kt

@@ -27,6 +27,7 @@ import org.jetbrains.compose.internal.utils.currentTarget
 import org.jetbrains.compose.resources.ResourcesExtension
 import org.jetbrains.compose.resources.configureComposeResources
 import org.jetbrains.compose.web.WebExtension
+import org.jetbrains.compose.web.internal.configureWeb
 import org.jetbrains.kotlin.com.github.gundy.semver4j.SemVer
 import org.jetbrains.kotlin.gradle.dsl.KotlinCompile
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsCompile
@@ -65,7 +66,7 @@ abstract class ComposePlugin : Plugin<Project> {
 
         project.afterEvaluate {
             configureDesktop(project, desktopExtension)
-            project.configureExperimental(composeExtension, experimentalExtension)
+            project.configureWeb(composeExtension)
             project.plugins.withId(KOTLIN_MPP_PLUGIN_ID) {
                 val mppExt = project.mppExt
                 project.configureExperimentalTargetsFlagsCheck(mppExt)

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/experimental/dsl/ExperimentalExtension.kt

@@ -12,7 +12,15 @@ import javax.inject.Inject
 abstract class ExperimentalExtension @Inject constructor(
     objects: ObjectFactory
 ) {
+
+    @Deprecated(
+        message = "Starting from 1.6.10, Compose for Web goes to Alpha. Experimental configuration is not needed anymore.",
+    )
     val web: ExperimentalWebExtension = objects.newInstance(ExperimentalWebExtension::class.java)
+
+    @Deprecated(
+        message = "Starting from 1.6.10, Compose for Web goes to Alpha. Experimental configuration is not needed anymore."
+    )
     fun web(action: Action<ExperimentalWebExtension>) {
         action.execute(web)
     }

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/experimental/dsl/ExperimentalWebApplication.kt

@@ -7,6 +7,9 @@ package org.jetbrains.compose.experimental.dsl
 
 import javax.inject.Inject
 
+@Deprecated(
+    message = "Starting from 1.6.10, Compose for Web goes to Alpha. Experimental configuration is not needed anymore.",
+)
 abstract class ExperimentalWebApplication  @Inject constructor(
     @Suppress("unused")
     val name: String,

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/experimental/dsl/ExperimentalWebExtension.kt

@@ -10,15 +10,24 @@ import org.gradle.api.model.ObjectFactory
 import org.gradle.api.plugins.ExtensionAware
 import javax.inject.Inject
 
+@Deprecated(
+    message = "Starting from 1.6.10, Compose for Web goes to Alpha. Experimental configuration is not needed anymore.",
+)
 abstract class ExperimentalWebExtension @Inject constructor(private val objectFactory: ObjectFactory) : ExtensionAware {
     internal var _isApplicationInitialized = false
         private set
 
+    @Deprecated(
+        message = "Starting from 1.6.10, Compose for Web goes to Alpha. Experimental configuration is not needed anymore.",
+    )
     val application: ExperimentalWebApplication by lazy {
         _isApplicationInitialized = true
         objectFactory.newInstance(ExperimentalWebApplication::class.java, "main")
     }
 
+    @Deprecated(
+        message = "Starting from 1.6.10, Compose for Web goes to Alpha. Experimental configuration is not needed anymore.",
+    )
     fun application(fn: Action<ExperimentalWebApplication>) {
         fn.execute(application)
     }

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/experimental/internal/checkExperimentalTargets.kt

@@ -27,7 +27,6 @@ private val TargetType.gradlePropertyName get() = "org.jetbrains.compose.experim
 private val EXPERIMENTAL_TARGETS: Set<TargetType> = setOf(
     TargetType("macos", presets = listOf("macosX64", "macosArm64")),
     TargetType("jscanvas", presets = listOf("jsIr", "js")),
-    TargetType("wasm", presets = listOf("wasm", "wasmJs")),
 )
 
 private sealed interface CheckResult {

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/experimental/internal/configureExperimental.kt

@@ -1,24 +0,0 @@
-/*
- * Copyright 2020-2021 JetBrains s.r.o. and respective authors and developers.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
- */
-
-package org.jetbrains.compose.experimental.internal
-
-import org.gradle.api.Project
-import org.jetbrains.compose.ComposeExtension
-import org.jetbrains.compose.experimental.dsl.ExperimentalExtension
-import org.jetbrains.compose.experimental.web.internal.configureExperimentalWebApplication
-import org.jetbrains.compose.web.WebExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-
-internal fun Project.configureExperimental(
-    composeExt: ComposeExtension,
-    experimentalExt: ExperimentalExtension
-) {
-    if (experimentalExt.web._isApplicationInitialized) {
-        val webExt = composeExt.extensions.getByType(WebExtension::class.java)
-        webExt.targetsToConfigure(project)
-            .configureExperimentalWebApplication(project, experimentalExt.web.application)
-    }
-}

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/experimental/web/tasks/ExperimentalUnpackSkikoWasmRuntimeTask.kt

@@ -5,46 +5,10 @@
 
 package org.jetbrains.compose.experimental.web.tasks
 
-import org.gradle.api.DefaultTask
-import org.gradle.api.file.ArchiveOperations
-import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.file.FileCollection
-import org.gradle.api.file.FileSystemOperations
-import org.gradle.api.tasks.InputFiles
-import org.gradle.api.tasks.OutputDirectory
-import org.gradle.api.tasks.TaskAction
-import org.jetbrains.compose.internal.utils.clearDirs
-import java.io.File
-import javax.inject.Inject
+import org.jetbrains.compose.web.tasks.UnpackSkikoWasmRuntimeTask
 
-abstract class ExperimentalUnpackSkikoWasmRuntimeTask : DefaultTask() {
-    @get:InputFiles
-    lateinit var skikoRuntimeFiles: FileCollection
-
-    @get:OutputDirectory
-    abstract val outputDir: DirectoryProperty
-
-    @get:Inject
-    internal abstract val archiveOperations: ArchiveOperations
-
-    @get:Inject
-    internal abstract val fileOperations: FileSystemOperations
-
-    @TaskAction
-    fun run() {
-        fileOperations.clearDirs(outputDir)
-
-        for (file in skikoRuntimeFiles.files) {
-            if (file.name.endsWith(".jar", ignoreCase = true)) {
-                unpackJar(file)
-            }
-        }
-    }
-
-    private fun unpackJar(file: File) {
-        fileOperations.copy { copySpec ->
-            copySpec.from(archiveOperations.zipTree(file))
-            copySpec.into(outputDir)
-        }
-    }
-}
+@Deprecated(
+    message = "Starting from 1.6.10 Compose for Web goes to Alpha",
+    replaceWith = ReplaceWith("UnpackSkikoWasmRuntimeTask")
+)
+abstract class ExperimentalUnpackSkikoWasmRuntimeTask : UnpackSkikoWasmRuntimeTask()

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/web/dsl/WebApplication.kt

@@ -0,0 +1,10 @@
+package org.jetbrains.compose.web.dsl
+
+import javax.inject.Inject
+
+abstract class WebApplication  @Inject constructor(
+    @Suppress("unused")
+    val name: String,
+) {
+
+}

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/web/internal/configureWebApplication.kt

@@ -3,7 +3,7 @@
  * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
  */
 
-package org.jetbrains.compose.experimental.web.internal
+package org.jetbrains.compose.web.internal
 
 import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
@@ -11,16 +11,25 @@ import org.gradle.api.artifacts.ResolvedDependency
 import org.gradle.api.artifacts.UnresolvedDependency
 import org.gradle.api.provider.Provider
 import org.jetbrains.compose.ComposeBuildConfig
-import org.jetbrains.compose.experimental.dsl.ExperimentalWebApplication
-import org.jetbrains.compose.experimental.web.tasks.ExperimentalUnpackSkikoWasmRuntimeTask
+import org.jetbrains.compose.ComposeExtension
+import org.jetbrains.compose.web.tasks.UnpackSkikoWasmRuntimeTask
 import org.jetbrains.compose.internal.utils.*
 import org.jetbrains.compose.internal.utils.registerTask
 import org.jetbrains.compose.internal.utils.uppercaseFirstChar
+import org.jetbrains.compose.web.WebExtension
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
 
-internal fun Collection<KotlinJsIrTarget>.configureExperimentalWebApplication(
-    project: Project,
-    app: ExperimentalWebApplication
+internal fun Project.configureWeb(
+    composeExt: ComposeExtension,
+) {
+    val webExt = composeExt.extensions.getByType(WebExtension::class.java)
+    // configure only if there is k/wasm or k/js target:
+    webExt.targetsToConfigure(project)
+        .configureWebApplication(project)
+}
+
+internal fun Collection<KotlinJsIrTarget>.configureWebApplication(
+    project: Project
 ) {
     val skikoJsWasmRuntimeConfiguration = project.configurations.create("COMPOSE_SKIKO_JS_WASM_RUNTIME")
     val skikoJsWasmRuntimeDependency = skikoVersionProvider(project).map { skikoVersion ->
@@ -37,7 +46,7 @@ internal fun Collection<KotlinJsIrTarget>.configureExperimentalWebApplication(
         mainCompilation.defaultSourceSet.resources.srcDir(unpackedRuntimeDir)
         testCompilation.defaultSourceSet.resources.srcDir(unpackedRuntimeDir)
 
-        val unpackRuntime = project.registerTask<ExperimentalUnpackSkikoWasmRuntimeTask>(taskName) {
+        val unpackRuntime = project.registerTask<UnpackSkikoWasmRuntimeTask>(taskName) {
             skikoRuntimeFiles = skikoJsWasmRuntimeConfiguration
             outputDir.set(unpackedRuntimeDir)
         }

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/web/tasks/UnpackSkikoWasmRuntimeTask.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2020-2022 JetBrains s.r.o. and respective authors and developers.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
+ */
+
+package org.jetbrains.compose.web.tasks
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ArchiveOperations
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.FileCollection
+import org.gradle.api.file.FileSystemOperations
+import org.gradle.api.tasks.InputFiles
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+import org.jetbrains.compose.internal.utils.clearDirs
+import java.io.File
+import javax.inject.Inject
+
+abstract class UnpackSkikoWasmRuntimeTask : DefaultTask() {
+    @get:InputFiles
+    lateinit var skikoRuntimeFiles: FileCollection
+
+    @get:OutputDirectory
+    abstract val outputDir: DirectoryProperty
+
+    @get:Inject
+    internal abstract val archiveOperations: ArchiveOperations
+
+    @get:Inject
+    internal abstract val fileOperations: FileSystemOperations
+
+    @TaskAction
+    fun run() {
+        fileOperations.clearDirs(outputDir)
+
+        for (file in skikoRuntimeFiles.files) {
+            if (file.name.endsWith(".jar", ignoreCase = true)) {
+                unpackJar(file)
+            }
+        }
+    }
+
+    private fun unpackJar(file: File) {
+        fileOperations.copy { copySpec ->
+            copySpec.from(archiveOperations.zipTree(file))
+            copySpec.into(outputDir)
+        }
+    }
+}