Finalization for 1.9.20

CHANGELOG.md

@@ -7,12 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## Unreleased
 
 ### Added
+- Add development mode for fullstack.
 
 ### Changed
+- Kotlin 1.9.20
+- Remove publishing defaults for Space and GitHub. Now publishing repositories is configured quasi-manually. Property keys for username and tokens are generated automatically.
+- All publishing targets are enabled by default. Introduce `publishing.targets` variable to regulate what is added to the module.
 
 ### Deprecated
+- JVM plugin in favor of Mpp.
 
 ### Removed
+- JS plugin. It is deprecated in favor of MPP.
+- Unnecessary `dependsOn` for native dependencies. 
+- Groovy gradle dependency notation.
 
 ### Fixed
 

build.gradle.kts

@@ -25,6 +25,7 @@ kotlin.explicitApiWarning()
 
 dependencies {
     api(libs.kotlin.gradle)
+    api("org.gradle.toolchains:foojay-resolver:0.7.0")
     implementation(libs.binary.compatibility.validator)
     implementation(libs.changelog.gradle)
     implementation(libs.dokka.gradle)
@@ -65,23 +66,17 @@ gradlePlugin {
             description = "Pre-configured JVM project"
             implementationClass = "space.kscience.gradle.KScienceJVMPlugin"
         }
-
-        create("js") {
-            id = "space.kscience.gradle.js"
-            description = "Pre-configured JS project"
-            implementationClass = "space.kscience.gradle.KScienceJSPlugin"
-        }
     }
 }
 
 tasks.create("version") {
     group = "publishing"
-    val versionFile = project.buildDir.resolve("project-version.txt")
-    outputs.file(versionFile)
+    val versionFileProvider = project.layout.buildDirectory.file("project-version.txt")
+    outputs.file(versionFileProvider)
     doLast {
+        val versionFile = versionFileProvider.get().asFile
         versionFile.createNewFile()
         versionFile.writeText(project.version.toString())
-        println(project.version)
     }
 }
 
@@ -117,7 +112,7 @@ val emptySourcesJar by tasks.creating(Jar::class) {
 }
 
 publishing {
-    val vcs = "https://github.com/mipt-npm/gradle-tools"
+    val vcs = "https://github.com/SciProgCentre/gradle-tools"
 
     // Process each publication we have in this project
     publications {
@@ -151,10 +146,10 @@ publishing {
 
                 developers {
                     developer {
-                        id.set("MIPT-NPM")
-                        name.set("MIPT nuclear physics methods laboratory")
-                        organization.set("MIPT")
-                        organizationUrl.set("https://npm.mipt.ru")
+                        id.set("SPC")
+                        name.set("Scientific Programming Centre")
+                        organization.set("SPC")
+                        organizationUrl.set("https://sciprog.center/")
                     }
                 }
 
@@ -166,20 +161,18 @@ publishing {
         }
     }
 
-    val spaceRepo = "https://maven.pkg.jetbrains.space/spc/p/sci/maven"
-    val spaceUser: String? = findProperty("publishing.space.user") as? String
-    val spaceToken: String? = findProperty("publishing.space.token") as? String
-
-    if (spaceUser != null && spaceToken != null) {
-        project.logger.info("Adding mipt-npm Space publishing to project [${project.name}]")
+    val spaceRepo = "https://maven.sciprog.center/kscience"
+    val spcUser: String? = findProperty("publishing.spc.user") as? String
+    val spcToken: String? = findProperty("publishing.spc.token") as? String
 
+    if (spcUser != null && spcToken != null) {
         repositories.maven {
-            name = "space"
+            name = "spc"
             url = uri(spaceRepo)
 
             credentials {
-                username = spaceUser
-                password = spaceToken
+                username = spcUser
+                password = spcToken
             }
         }
     }
@@ -211,7 +204,6 @@ publishing {
     }
 }
 
-
 kotlin {
     jvmToolchain {
         languageVersion.set(JavaLanguageVersion.of(11))

gradle/libs.versions.toml

@@ -1,26 +1,47 @@
 [versions]
-tools = "0.14.4-kotlin-1.8.20-RC"
-kotlin = "1.8.20-RC"
-atomicfu = "0.19.0"
-binary-compatibility-validator = "0.12.1"
-changelog = "2.0.0"
-dokka = "1.7.20"
-kotlin-jupyter = "0.11.0-317"
-kotlinx-benchmark = "0.4.7"
-kotlinx-cli = "0.3.5"
-kotlinx-coroutines = "1.6.4"
-kotlinx-datetime = "0.4.0"
-kotlinx-html = "0.8.0"
+tools = "0.15.0-kotlin-1.9.20"
+kotlin = "1.9.20"
+# https://github.com/Kotlin/kotlinx-atomicfu
+atomicfu = "0.22.0"
+# https://github.com/Kotlin/binary-compatibility-validator
+binary-compatibility-validator = "0.13.2"
+# https://github.com/JetBrains/gradle-changelog-plugin
+changelog = "2.2.0"
+# https://github.com/Kotlin/dokka
+dokka = "1.9.10"
+# https://github.com/Kotlin/kotlin-jupyter
+kotlin-jupyter = "0.12.0-81"
+# https://github.com/Kotlin/kotlinx-benchmark
+kotlinx-benchmark = "0.4.9"
+# https://github.com/Kotlin/kotlinx-cli
+kotlinx-cli = "0.3.6"
+# https://github.com/Kotlin/kotlinx.coroutines
+kotlinx-coroutines = "1.7.3"
+# https://github.com/Kotlin/kotlinx-datetime
+kotlinx-datetime = "0.4.1"
+# https://github.com/Kotlin/kotlinx.html
+kotlinx-html = "0.9.1"
+# https://github.com/Kotlin/kotlinx-knit
 kotlinx-knit = "0.4.0"
+# https://github.com/Kotlin/kotlinx-nodejs
 kotlinx-nodejs = "0.0.7"
-kotlinx-serialization = "1.4.1"
-ktor = "2.2.3"
-xmlutil = "0.84.3"
-yamlkt = "0.12.0"
-jsBom = "1.0.0-pre.509"
-junit = "5.9.2"
-compose = "1.3.0"
-logback = "1.4.5"
+# https://github.com/Kotlin/kotlinx.serialization
+kotlinx-serialization = "1.6.0"
+# https://ktor.io/
+ktor = "2.3.5"
+# https://github.com/pdvrieze/xmlutil
+xmlutil = "0.86.1"
+# https://github.com/Him188/yamlkt
+yamlkt = "0.13.0"
+# https://github.com/JetBrains/kotlin-wrappers
+jsBom = "1.0.0-pre.624"
+junit = "5.9.3"
+# https://github.com/JetBrains/compose-multiplatform
+compose = "1.5.3"
+# https://mvnrepository.com/artifact/org.slf4j/slf4j-api
+slf4j = "2.0.9"
+# https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
+logback = "1.4.11"
 
 [libraries]
 atomicfu-gradle = { module = "org.jetbrains.kotlinx:atomicfu-gradle-plugin", version.ref = "atomicfu" }
@@ -37,6 +58,8 @@ kotlin-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", v
 
 kotlin-jupyter-gradle = { module = "org.jetbrains.kotlin:kotlin-jupyter-api-gradle-plugin", version.ref = "kotlin-jupyter" }
 
+kotlin-js-wrappers = { module = "org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom", version.ref = "jsBom" }
+
 kotlinx-benchmark-runtime = { module = "org.jetbrains.kotlinx:kotlinx-benchmark-runtime", version.ref = "kotlinx-benchmark" }
 
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
@@ -79,13 +102,15 @@ xmlutil-serialization = { module = "io.github.pdvrieze.xmlutil:serialization", v
 
 yamlkt = { module = "net.mamoe.yamlkt:yamlkt", version.ref = "yamlkt" }
 
-logback-classic = {module = "ch.qos.logback:logback-classic", version.ref = "logback"}
+slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
+
+logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
 
 [plugins]
 changelog = { id = "org.jetbrains.changelog", version.ref = "changelog" }
 
 dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
-compose = {id = "org.jetbrains.compose", version.ref = "compose"}
+compose = { id = "org.jetbrains.compose", version.ref = "compose" }
 
 gradle-common = { id = "space.kscience.gradle.common", version.ref = "tools" }
 gradle-project = { id = "space.kscience.gradle.project", version.ref = "tools" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

src/main/kotlin/space/kscience/gradle/KScienceExtension.kt

@@ -13,17 +13,19 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
 import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl
 import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsBrowserDsl
 import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsTargetDsl
-import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinWasmTargetDsl
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinWasmJsTargetDsl
 import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlinx.jupyter.api.plugin.tasks.JupyterApiResourcesTask
 import space.kscience.gradle.internal.defaultKotlinJvmArgs
 import space.kscience.gradle.internal.fromJsDependencies
+import space.kscience.gradle.internal.requestPropertyOrNull
 import space.kscience.gradle.internal.useCommonDependency
 
 public enum class DependencyConfiguration {
@@ -105,7 +107,7 @@ public open class KScienceExtension(public val project: Project) {
             configure<KotlinMultiplatformExtension> {
                 sourceSets.findByName("commonMain")?.apply {
                     dependencies {
-                        api(platform("io.ktor:ktor-bom:$version"))
+                        api(project.dependencies.platform("io.ktor:ktor-bom:$version"))
                     }
                 }
             }
@@ -114,7 +116,7 @@ public open class KScienceExtension(public val project: Project) {
             configure<KotlinJvmProjectExtension> {
                 sourceSets.findByName("main")?.apply {
                     dependencies {
-                        api(platform("io.ktor:ktor-bom:$version"))
+                        api(project.dependencies.platform("io.ktor:ktor-bom:$version"))
                     }
                 }
             }
@@ -123,7 +125,7 @@ public open class KScienceExtension(public val project: Project) {
             configure<KotlinJsProjectExtension> {
                 sourceSets.findByName("main")?.apply {
                     dependencies {
-                        api(platform("io.ktor:ktor-bom:$version"))
+                        api(project.dependencies.platform("io.ktor:ktor-bom:$version"))
                     }
                 }
             }
@@ -179,13 +181,6 @@ public open class KScienceExtension(public val project: Project) {
             }
         }
 
-        project.pluginManager.withPlugin("org.jetbrains.kotlin.js") {
-            project.configure<KotlinJsProjectExtension> {
-                sourceSets.getByName(sourceSet ?: "test") {
-                    dependencies(dependencyBlock)
-                }
-            }
-        }
 
         project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
             project.configure<KotlinMultiplatformExtension> {
@@ -207,6 +202,7 @@ public open class KScienceExtension(public val project: Project) {
     /**
      * Mark this module as an application module. JVM application should be enabled separately
      */
+    @Deprecated("Use platform-specific applications")
     public fun application() {
         project.extensions.findByType<KotlinProjectExtension>()?.apply {
             explicitApi = null
@@ -231,7 +227,7 @@ public open class KScienceExtension(public val project: Project) {
                 binaries.executable()
             }
 
-            targets.withType<KotlinWasmTargetDsl> {
+            targets.withType<KotlinWasmJsTargetDsl> {
                 binaries.executable()
             }
         }
@@ -261,8 +257,8 @@ public open class KScienceExtension(public val project: Project) {
     public val jsTest: DefaultSourceSet get() = DefaultSourceSet("jsTest")
     public val nativeMain: DefaultSourceSet get() = DefaultSourceSet("nativeMain")
     public val nativeTest: DefaultSourceSet get() = DefaultSourceSet("nativeTest")
-    public val wasmMain: DefaultSourceSet get() = DefaultSourceSet("wasmMain")
-    public val wasmTest: DefaultSourceSet get() = DefaultSourceSet("wasmTest")
+    public val wasmJsMain: DefaultSourceSet get() = DefaultSourceSet("wasmJsMain")
+    public val wasmJsTest: DefaultSourceSet get() = DefaultSourceSet("wasmJsTest")
 
 }
 
@@ -285,21 +281,37 @@ public data class KScienceNativeTarget(
         public val linuxX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.linuxX64)
         public val mingwX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.mingwX64)
         public val macosX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.macosX64)
-        public val macosArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.macosX64)
+        public val macosArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.macosArm64)
         public val iosX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosX64)
         public val iosArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosArm64)
         public val iosSimulatorArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosSimulatorArm64)
     }
 }
 
-public class KScienceNativeConfiguration {
+public class KScienceNativeConfiguration(private val project: Project) {
 
 
     internal companion object {
-        private fun defaultNativeTargets(): Map<KotlinNativePreset, KScienceNativeTarget> {
-
+        private fun defaultNativeTargets(project: Project): Map<KotlinNativePreset, KScienceNativeTarget> {
             val hostOs = System.getProperty("os.name")
+
+            val targets = project.requestPropertyOrNull("publishing.targets")
+
             return when {
+                targets == "all" -> listOf(
+                    KScienceNativeTarget.linuxX64,
+                    KScienceNativeTarget.mingwX64,
+                    KScienceNativeTarget.macosX64,
+                    KScienceNativeTarget.macosArm64,
+                    KScienceNativeTarget.iosX64,
+                    KScienceNativeTarget.iosArm64,
+                    KScienceNativeTarget.iosSimulatorArm64,
+                )
+
+                targets != null -> {
+                    targets.split(",").map { KScienceNativeTarget(KotlinNativePreset.valueOf(it)) }
+                }
+
                 hostOs.startsWith("Windows") -> listOf(
                     KScienceNativeTarget.linuxX64,
                     KScienceNativeTarget.mingwX64
@@ -314,6 +326,7 @@ public class KScienceNativeConfiguration {
                 )
 
                 hostOs == "Linux" -> listOf(KScienceNativeTarget.linuxX64)
+
                 else -> {
                     emptyList()
                 }
@@ -322,7 +335,7 @@ public class KScienceNativeConfiguration {
     }
 
 
-    internal var targets: Map<KotlinNativePreset, KScienceNativeTarget> = defaultNativeTargets()
+    internal var targets: Map<KotlinNativePreset, KScienceNativeTarget> = defaultNativeTargets(project)
 
 
     /**
@@ -355,8 +368,8 @@ public open class KScienceMppExtension(project: Project) : KScienceExtension(pro
             project.configure<KotlinMultiplatformExtension> {
                 jvm {
                     compilations.all {
-                        kotlinOptions {
-                            freeCompilerArgs = freeCompilerArgs + defaultKotlinJvmArgs
+                        compilerOptions.configure {
+                            freeCompilerArgs.addAll(defaultKotlinJvmArgs)
                         }
                     }
                     block()
@@ -403,14 +416,35 @@ public open class KScienceMppExtension(project: Project) : KScienceExtension(pro
         }
     }
 
+    /**
+     * Add Wasm/Js target
+     */
     @OptIn(ExperimentalWasmDsl::class)
-    public fun wasm(block: KotlinWasmTargetDsl.() -> Unit = {}) {
+    public fun wasm(block: KotlinWasmJsTargetDsl.() -> Unit = {}) {
+//        if (project.requestPropertyOrNull("kscience.wasm.disabled") == "true") {
+//            project.logger.warn("Wasm target is disabled with 'kscience.wasm.disabled' property")
+//            return
+//        }
+
         project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
             project.configure<KotlinMultiplatformExtension> {
-                wasm {
-                    browser()
+                wasmJs {
+                    browser {
+                        testTask {
+                            useKarma {
+                                useChromeCanaryHeadless()
+                            }
+                        }
+                    }
                     block()
                 }
+                sourceSets {
+                    getByName("wasmJsTest") {
+                        dependencies {
+                            implementation(kotlin("test-wasm-js"))
+                        }
+                    }
+                }
             }
         }
     }
@@ -425,26 +459,29 @@ public open class KScienceMppExtension(project: Project) : KScienceExtension(pro
      */
     public fun fullStack(
         bundleName: String = "js/bundle.js",
+        development: Boolean = false,
         jvmConfig: KotlinJvmTarget.() -> Unit = {},
         jsConfig: KotlinJsTargetDsl.() -> Unit = {},
         browserConfig: KotlinJsBrowserDsl.() -> Unit = {},
     ) {
         js {
-            binaries.executable()
             browser {
                 webpackTask {
-                    outputFileName = bundleName
+                    mainOutputFileName.set(bundleName)
                 }
                 browserConfig()
             }
             jsConfig()
+            binaries.executable()
         }
         jvm {
             val processResourcesTaskName =
-                compilations[org.jetbrains.kotlin.gradle.plugin.KotlinCompilation.MAIN_COMPILATION_NAME]
-                    .processResourcesTaskName
+                compilations[KotlinCompilation.MAIN_COMPILATION_NAME].processResourcesTaskName
 
-            val jsBrowserDistribution = project.tasks.getByName("jsBrowserDistribution")
+
+            val jsBrowserDistribution = project.tasks.getByName(
+                if (development) "jsBrowserDevelopmentExecutableDistribution" else "jsBrowserDistribution"
+            )
 
             project.tasks.getByName<ProcessResources>(processResourcesTaskName) {
                 duplicatesStrategy = DuplicatesStrategy.WARN
@@ -459,81 +496,48 @@ public open class KScienceMppExtension(project: Project) : KScienceExtension(pro
      * Enable all supported native targets
      */
     public fun native(block: KScienceNativeConfiguration.() -> Unit = {}): Unit = with(project) {
-        val nativeConfiguration = KScienceNativeConfiguration().apply(block)
+        val nativeConfiguration = KScienceNativeConfiguration(this).apply(block)
         pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
             configure<KotlinMultiplatformExtension> {
-                val nativeTargets: List<KotlinNativeTarget> =
-                    nativeConfiguration.targets.values.map { nativeTarget ->
-                        when (nativeTarget.preset) {
-                            KotlinNativePreset.linuxX64 -> linuxX64(
-                                nativeTarget.targetName,
-                                nativeTarget.targetConfiguration
-                            )
+                nativeConfiguration.targets.values.forEach { nativeTarget ->
+                    when (nativeTarget.preset) {
+                        KotlinNativePreset.linuxX64 -> linuxX64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
 
-                            KotlinNativePreset.mingwX64 -> mingwX64(
-                                nativeTarget.targetName,
-                                nativeTarget.targetConfiguration
-                            )
+                        KotlinNativePreset.mingwX64 -> mingwX64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
 
-                            KotlinNativePreset.macosX64 -> macosX64(
-                                nativeTarget.targetName,
-                                nativeTarget.targetConfiguration
-                            )
+                        KotlinNativePreset.macosX64 -> macosX64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
 
-                            KotlinNativePreset.macosArm64 -> macosArm64(
-                                nativeTarget.targetName,
-                                nativeTarget.targetConfiguration
-                            )
+                        KotlinNativePreset.macosArm64 -> macosArm64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
 
-                            KotlinNativePreset.iosX64 -> iosX64(
-                                nativeTarget.targetName,
-                                nativeTarget.targetConfiguration
-                            )
+                        KotlinNativePreset.iosX64 -> iosX64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
 
-                            KotlinNativePreset.iosArm64 -> iosArm64(
-                                nativeTarget.targetName,
-                                nativeTarget.targetConfiguration
-                            )
+                        KotlinNativePreset.iosArm64 -> iosArm64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
 
-                            KotlinNativePreset.iosSimulatorArm64 -> iosSimulatorArm64(
-                                nativeTarget.targetName,
-                                nativeTarget.targetConfiguration
-                            )
-
-//                                else -> {
-//                                    logger.error("Native preset ${nativeTarget.preset} not recognised.")
-//                                    null
-//                                }
-                        }
-                    }
-
-                sourceSets {
-                    val commonMain by getting
-                    val commonTest by getting
-
-                    val nativeMain by creating {
-                        dependsOn(commonMain)
-                    }
-
-                    val nativeTest by creating {
-                        //should NOT depend on nativeMain because automatic dependency by plugin
-                        dependsOn(commonTest)
-                    }
-
-                    configure(nativeTargets) {
-                        compilations["main"]?.apply {
-                            configure(kotlinSourceSets) {
-                                dependsOn(nativeMain)
-                            }
-                        }
-
-                        compilations["test"]?.apply {
-                            configure(kotlinSourceSets) {
-                                dependsOn(nativeTest)
-                            }
-                        }
+                        KotlinNativePreset.iosSimulatorArm64 -> iosSimulatorArm64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
                     }
                 }
+
             }
         }
     }

src/main/kotlin/space/kscience/gradle/KScienceJSPlugin.kt

@@ -1,56 +0,0 @@
-package space.kscience.gradle
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.tasks.Copy
-import org.gradle.kotlin.dsl.apply
-import org.gradle.kotlin.dsl.configure
-import org.gradle.kotlin.dsl.get
-import org.jetbrains.dokka.gradle.DokkaPlugin
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
-import space.kscience.gradle.internal.applySettings
-import space.kscience.gradle.internal.fromJsDependencies
-
-public open class KScienceJSPlugin : Plugin<Project> {
-    override fun apply(project: Project): Unit = project.run {
-        if (!plugins.hasPlugin("org.jetbrains.kotlin.js")) {
-            plugins.apply("org.jetbrains.kotlin.js")
-        } else {
-            logger.info("Kotlin JS plugin is already present")
-        }
-        registerKScienceExtension(::KScienceExtension)
-
-        //logger.info("Applying KScience configuration for JS project")
-        configure<KotlinJsProjectExtension> {
-            js(IR) { browser { } }
-
-            sourceSets.all {
-                languageSettings.applySettings()
-            }
-
-            sourceSets["main"].apply {
-                dependencies {
-                    api(project.dependencies.platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:${KScienceVersions.jsBom}"))
-                }
-            }
-
-            sourceSets["test"].apply {
-                dependencies {
-                    implementation(kotlin("test-js"))
-                }
-            }
-
-            if (explicitApi == null) explicitApiWarning()
-        }
-
-        (tasks.findByName("processResources") as? Copy)?.apply {
-            fromJsDependencies("runtimeClasspath")
-        }
-
-
-        // apply dokka for all projects
-        if (!plugins.hasPlugin("org.jetbrains.dokka")) {
-            apply<DokkaPlugin>()
-        }
-    }
-}

src/main/kotlin/space/kscience/gradle/KScienceJVMPlugin.kt

@@ -10,12 +10,13 @@ import org.gradle.kotlin.dsl.get
 import org.gradle.kotlin.dsl.withType
 import org.jetbrains.dokka.gradle.DokkaPlugin
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import space.kscience.gradle.internal.applySettings
 import space.kscience.gradle.internal.defaultKotlinJvmArgs
 
 public open class KScienceJVMPlugin : Plugin<Project> {
     override fun apply(project: Project): Unit = project.run {
+
+        logger.warn("KSCience JVM plugin is deprecated. Use MPP.")
         if (!plugins.hasPlugin("org.jetbrains.kotlin.jvm")) {
             plugins.apply("org.jetbrains.kotlin.jvm")
         } else {
@@ -27,6 +28,9 @@ public open class KScienceJVMPlugin : Plugin<Project> {
         configure<KotlinJvmProjectExtension> {
             sourceSets.all {
                 languageSettings.applySettings()
+                compilerOptions{
+                    freeCompilerArgs.addAll(defaultKotlinJvmArgs)
+                }
             }
 
             sourceSets["test"].apply {
@@ -42,12 +46,6 @@ public open class KScienceJVMPlugin : Plugin<Project> {
             }
         }
 
-        tasks.withType<KotlinCompile> {
-            kotlinOptions {
-                freeCompilerArgs = freeCompilerArgs + defaultKotlinJvmArgs
-            }
-        }
-
         tasks.withType<Test> {
             useJUnitPlatform()
         }

src/main/kotlin/space/kscience/gradle/KScienceMPPlugin.kt

@@ -10,6 +10,7 @@ import org.jetbrains.dokka.gradle.DokkaPlugin
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMultiplatformPlugin
 import space.kscience.gradle.internal.applySettings
+import space.kscience.gradle.internal.defaultKotlinCommonArgs
 
 public open class KScienceMPPlugin : Plugin<Project> {
     override fun apply(project: Project): Unit = project.run {
@@ -23,23 +24,29 @@ public open class KScienceMPPlugin : Plugin<Project> {
         registerKScienceExtension(::KScienceMppExtension)
 
         configure<KotlinMultiplatformExtension> {
-
             sourceSets {
-                getByName("commonMain"){
+                getByName("commonMain") {
                     dependencies {
                         api(project.dependencies.platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:${KScienceVersions.jsBom}"))
                     }
                 }
-                getByName("commonTest"){
+                getByName("commonTest") {
                     dependencies {
-                        implementation(kotlin("test-common"))
+                        implementation(kotlin("test"))
                         implementation(kotlin("test-annotations-common"))
                     }
                 }
+                all {
+                    languageSettings.applySettings()
+                }
             }
 
-            sourceSets.all {
-                languageSettings.applySettings()
+            targets.all {
+                compilations.all {
+                    kotlinOptions{
+                        freeCompilerArgs += defaultKotlinCommonArgs
+                    }
+                }
             }
 
             if (explicitApi == null) explicitApiWarning()

src/main/kotlin/space/kscience/gradle/KScienceProjectPlugin.kt

@@ -12,7 +12,12 @@ import org.jetbrains.changelog.ChangelogPlugin
 import org.jetbrains.changelog.ChangelogPluginExtension
 import org.jetbrains.dokka.gradle.AbstractDokkaTask
 import org.jetbrains.dokka.gradle.DokkaPlugin
-import space.kscience.gradle.internal.*
+import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnLockMismatchReport
+import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin
+import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootExtension
+import space.kscience.gradle.internal.addPublishing
+import space.kscience.gradle.internal.addSonatypePublishing
+import space.kscience.gradle.internal.setupPublication
 
 /**
  * Simplifies adding repositories for Maven publishing, responds for releasing tasks for projects.
@@ -51,46 +56,24 @@ public class KSciencePublishingExtension(public val project: Project) {
     }
 
     /**
-     * Adds GitHub as VCS and adds GitHub Packages Maven repository to publishing.
-     *
-     * @param githubProject the GitHub project.
-     * @param githubOrg the GitHub user or organization.
-     * @param deploy publish packages in the `deploy` task to the GitHub repository.
+     * Add a repository with [repositoryName]. Uses "publishing.$repositoryName.user" and "publishing.$repositoryName.token"
+     * properties pattern to store user and token
      */
-    public fun github(
-        githubOrg: String,
-        githubProject: String,
-        deploy: Boolean = project.requestPropertyOrNull("publishing.github") == "true",
+    public fun repository(
+        repositoryName: String,
+        url: String,
     ) {
-        if (deploy) {
-            try {
-                project.addGithubPublishing(githubOrg, githubProject)
-            } catch (t: Throwable) {
-                project.logger.error("Failed to set up github publication", t)
-            }
-        }
-    }
-
-    /**
-     * Adds Space Packages Maven repository to publishing.
-     *
-     * @param spaceRepo the repository URL.
-     * @param deploy publish packages in the `deploy` task to the Space repository.
-     */
-    public fun space(
-        spaceRepo: String,
-    ) {
-        project.addSpacePublishing(spaceRepo)
+        require(isVcsInitialized) { "The project vcs is not set up use 'pom' method to do so" }
+        project.addPublishing(repositoryName, url)
     }
 
     /**
      * Adds Sonatype Maven repository to publishing.
-     *
-     * @param addToRelease  publish packages in the `release` task to the Sonatype repository.
+
      */
-    public fun sonatype() {
+    public fun sonatype(sonatypeRoot: String = "https://s01.oss.sonatype.org") {
         require(isVcsInitialized) { "The project vcs is not set up use 'pom' method to do so" }
-        project.addSonatypePublishing()
+        project.addSonatypePublishing(sonatypeRoot)
     }
 }
 
@@ -104,8 +87,8 @@ public open class KScienceProjectPlugin : Plugin<Project> {
         apply<DokkaPlugin>()
         apply<BinaryCompatibilityValidatorPlugin>()
 
-        allprojects{
-            repositories{
+        allprojects {
+            repositories {
                 mavenCentral()
                 maven("https://repo.kotlin.link")
                 maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
@@ -139,8 +122,7 @@ public open class KScienceProjectPlugin : Plugin<Project> {
             val readmeExtension = KScienceReadmeExtension(this)
             extensions.add("readme", readmeExtension)
 
-            @Suppress("UNUSED_VARIABLE")
-            val generateReadme by tasks.creating {
+            tasks.create("generateReadme") {
                 group = "documentation"
                 description = "Generate a README file if stub is present"
 
@@ -203,17 +185,18 @@ public open class KScienceProjectPlugin : Plugin<Project> {
                     val modulesString = buildString {
                         subprojects.forEach { subproject ->
 //                            val name = subproject.name
-                            subproject.extensions.findByType<KScienceReadmeExtension>()?.let { ext ->
-                                val path = subproject.path.replaceFirst(":", "").replace(":", "/")
-                                appendLine("\n### [$path]($path)")
-                                appendLine("> ${ext.description}")
-                                appendLine(">\n> **Maturity**: ${ext.maturity}")
-                                val featureString = ext.featuresString(itemPrefix = "> - ", pathPrefix = "$path/")
-                                if (featureString.isNotBlank()) {
-                                    appendLine(">\n> **Features:**")
-                                    appendLine(featureString)
+                            subproject.extensions.findByType<KScienceReadmeExtension>()
+                                ?.let { ext: KScienceReadmeExtension ->
+                                    val path = subproject.path.replaceFirst(":", "").replace(":", "/")
+                                    appendLine("\n### [$path]($path)")
+                                    ext.description?.let { appendLine("> ${ext.description}") }
+                                    appendLine(">\n> **Maturity**: ${ext.maturity}")
+                                    val featureString = ext.featuresString(itemPrefix = "> - ", pathPrefix = "$path/")
+                                    if (featureString.isNotBlank()) {
+                                        appendLine(">\n> **Features:**")
+                                        appendLine(featureString)
+                                    }
                                 }
-                            }
                         }
                     }
 
@@ -233,12 +216,12 @@ public open class KScienceProjectPlugin : Plugin<Project> {
 
         tasks.create("version") {
             group = "publishing"
-            val versionFile = project.buildDir.resolve("project-version.txt")
-            outputs.file(versionFile)
+            val versionFileProvider = project.layout.buildDirectory.file("project-version.txt")
+            outputs.file(versionFileProvider)
             doLast {
+                val versionFile = versionFileProvider.get().asFile
                 versionFile.createNewFile()
                 versionFile.writeText(project.version.toString())
-                println(project.version)
             }
         }
 
@@ -250,9 +233,11 @@ public open class KScienceProjectPlugin : Plugin<Project> {
             }
         }
 
-        plugins.withType(org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin::class.java) {
-            rootProject.the<org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootExtension>().lockFileDirectory =
-                rootDir.resolve("gradle")
+        plugins.withType<YarnPlugin>() {
+            rootProject.configure<YarnRootExtension> {
+                lockFileDirectory = rootDir.resolve("gradle")
+                yarnLockMismatchReport = YarnLockMismatchReport.WARNING
+            }
         }
     }
 

src/main/kotlin/space/kscience/gradle/KScienceReadmeExtension.kt

@@ -10,6 +10,7 @@ import kotlinx.html.stream.createHTML
 import kotlinx.validation.ApiValidationExtension
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.findByType
+import org.intellij.lang.annotations.Language
 import java.io.File
 import java.io.StringWriter
 import kotlin.collections.component1
@@ -32,7 +33,8 @@ private fun Template.processToString(args: Map<String, Any?>): String {
 
 
 public class KScienceReadmeExtension(public val project: Project) {
-    public var description: String = project.description ?: ""
+    public var description: String? = null
+        get() = field ?: project.description
 
     public var maturity: Maturity = Maturity.EXPERIMENTAL
         set(value) {
@@ -88,12 +90,23 @@ public class KScienceReadmeExtension(public val project: Project) {
 
     public data class Feature(val id: String, val description: String, val ref: String?, val name: String = id)
 
-    public val features: MutableList<Feature> = ArrayList()
+    public val features: MutableList<Feature> = mutableListOf()
 
-    public fun feature(id: String, ref: String? = null, name: String = id, description: () -> String) {
+    /**
+     * A plain readme feature with description
+     */
+    public fun feature(
+        id: String,
+        @Language("File") ref: String? = null,
+        name: String = id,
+        description: () -> String,
+    ) {
         features += Feature(id, description(), ref, name)
     }
 
+    /**
+     * A readme feature with HTML description
+     */
     public fun featureWithHtml(
         id: String,
         ref: String? = null,

src/main/kotlin/space/kscience/gradle/internal/common.kt

@@ -7,8 +7,15 @@ import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
 import space.kscience.gradle.KScienceVersions
 
 
-internal val defaultKotlinJvmArgs: List<String> =
-    listOf("-Xjvm-default=all", "-Xlambdas=indy"/* "-Xjdk-release=${KScienceVersions.JVM_TARGET}"*/)
+internal val defaultKotlinJvmArgs: List<String> = listOf(
+    "-Xjvm-default=all",
+    "-Xlambdas=indy",
+    /* "-Xjdk-release=${KScienceVersions.JVM_TARGET}"*/
+)
+
+internal val defaultKotlinCommonArgs: List<String> = listOf(
+    "-Xexpect-actual-classes"
+)
 
 internal fun resolveKotlinVersion(): KotlinVersion {
     val (major, minor, patch) = KScienceVersions.kotlinVersion.split(".", "-")
@@ -23,6 +30,7 @@ internal fun LanguageSettingsBuilder.applySettings(
     apiVersion = versionString
     progressiveMode = true
 
+
     optIn("kotlin.RequiresOptIn")
     optIn("kotlin.ExperimentalUnsignedTypes")
     optIn("kotlin.ExperimentalStdlibApi")

src/main/kotlin/space/kscience/gradle/internal/publishing.kt

@@ -8,9 +8,7 @@ import org.gradle.api.tasks.bundling.Jar
 import org.gradle.kotlin.dsl.*
 import org.gradle.plugins.signing.SigningExtension
 import org.gradle.plugins.signing.SigningPlugin
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.targets
 import space.kscience.gradle.isInDevelopment
 
 internal fun Project.requestPropertyOrNull(propertyName: String): String? = findProperty(propertyName) as? String
@@ -24,26 +22,6 @@ internal fun Project.setupPublication(mavenPomConfiguration: MavenPom.() -> Unit
     plugins.withId("maven-publish") {
         configure<PublishingExtension> {
 
-            plugins.withId("org.jetbrains.kotlin.js") {
-                val kotlin: KotlinJsProjectExtension = extensions.findByType()!!
-
-                val sourcesJar by tasks.creating(Jar::class) {
-                    archiveClassifier.set("sources")
-                    kotlin.sourceSets.forEach {
-                        from(it.kotlin)
-                    }
-                }
-
-                publications.create<MavenPublication>("js") {
-                    kotlin.targets.flatMap { it.components }.forEach {
-                        from(it)
-                    }
-
-                    artifact(sourcesJar)
-                }
-
-            }
-
             plugins.withId("org.jetbrains.kotlin.jvm") {
                 val kotlin = extensions.findByType<KotlinJvmProjectExtension>()!!
 
@@ -55,9 +33,7 @@ internal fun Project.setupPublication(mavenPomConfiguration: MavenPom.() -> Unit
                 }
 
                 publications.create<MavenPublication>("jvm") {
-                    kotlin.target.components.forEach {
-                        from(it)
-                    }
+                    from(project.components["java"])
 
                     artifact(sourcesJar)
                 }
@@ -100,7 +76,7 @@ internal fun Project.setupPublication(mavenPomConfiguration: MavenPom.() -> Unit
                         val signingKey: String = requestProperty("publishing.signing.key")
                         val signingPassphrase: String = requestProperty("publishing.signing.passPhrase")
 
-                        // if key is provided, use it
+                        // if a key is provided, use it
                         useInMemoryPgpKeys(signingId, signingKey, signingPassphrase)
                     } // else use agent signing
                     sign(publications)
@@ -112,34 +88,31 @@ internal fun Project.setupPublication(mavenPomConfiguration: MavenPom.() -> Unit
     }
 }
 
-internal fun Project.addGithubPublishing(
-    githubOrg: String,
-    githubProject: String,
-) {
-    if (requestPropertyOrNull("publishing.enabled") != "true") {
-        logger.info("Skipping github publishing because publishing is disabled")
-        return
-    }
-    if (requestPropertyOrNull("publishing.github") != "false") {
-        logger.info("Skipping github publishing  because `publishing.github != true`")
-        return
-    }
+internal fun Project.addPublishing(
+    repositoryName: String,
+    urlString:String
+){
+    require(repositoryName.matches("\\w*".toRegex())){"Repository name must contain only letters or numbers"}
+    val user: String? = requestPropertyOrNull("publishing.$repositoryName.user")
+    val token: String? = requestPropertyOrNull("publishing.$repositoryName.token")
 
-    val githubUser: String = requestProperty("publishing.github.user")
-    val githubToken: String = requestProperty("publishing.github.token")
+    if (user == null || token == null) {
+        logger.info("Skipping $repositoryName publishing because $repositoryName credentials are not defined")
+        return
+    }
 
     allprojects {
         plugins.withId("maven-publish") {
             configure<PublishingExtension> {
-                logger.info("Adding github publishing to project [${project.name}]")
+                logger.info("Adding $repositoryName publishing to project [${project.name}]")
 
                 repositories.maven {
-                    name = "github"
-                    url = uri("https://maven.pkg.github.com/$githubOrg/$githubProject/")
+                    name = repositoryName
+                    url = uri(urlString)
 
                     credentials {
-                        username = githubUser
-                        password = githubToken
+                        username = user
+                        password = token
                     }
                 }
             }
@@ -147,72 +120,11 @@ internal fun Project.addGithubPublishing(
     }
 }
 
-internal fun Project.addSpacePublishing(spaceRepo: String) {
-    if (requestPropertyOrNull("publishing.enabled") != "true") {
-        logger.info("Skipping space publishing because publishing is disabled")
-        return
-    }
-
-    if (requestPropertyOrNull("publishing.space") == "false") {
-        logger.info("Skipping space publishing because `publishing.space == false`")
-        return
-    }
-
-    val spaceUser: String = requestProperty("publishing.space.user")
-    val spaceToken: String = requestProperty("publishing.space.token")
-
-    allprojects {
-        plugins.withId("maven-publish") {
-            configure<PublishingExtension> {
-                project.logger.info("Adding mipt-npm Space publishing to project [${project.name}]")
-
-                repositories.maven {
-                    name = "space"
-                    url = uri(spaceRepo)
-
-                    credentials {
-                        username = spaceUser
-                        password = spaceToken
-                    }
-                }
-            }
-        }
-    }
-}
-
-internal fun Project.addSonatypePublishing() {
-    if (requestPropertyOrNull("publishing.enabled") != "true") {
-        logger.info("Skipping sonatype publishing because publishing is disabled")
-        return
-    }
 
+internal fun Project.addSonatypePublishing(sonatypeRoot: String) {
     if (isInDevelopment) {
         logger.info("Sonatype publishing skipped for development version")
-        return
-    }
-
-    if (requestPropertyOrNull("publishing.sonatype") == "false") {
-        logger.info("Skipping sonatype publishing because `publishing.sonatype == false`")
-        return
-    }
-
-    val sonatypeUser: String = requestProperty("publishing.sonatype.user")
-    val sonatypePassword: String = requestProperty("publishing.sonatype.password")
-
-    allprojects {
-        plugins.withId("maven-publish") {
-            configure<PublishingExtension> {
-                repositories.maven {
-                    val sonatypeRepo = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2"
-                    name = "sonatype"
-                    url = uri(sonatypeRepo)
-
-                    credentials {
-                        username = sonatypeUser
-                        password = sonatypePassword
-                    }
-                }
-            }
-        }
+    } else {
+        addPublishing("sonatype", "$sonatypeRoot/service/local/staging/deploy/maven2")
     }
 }

src/main/resources/templates/ARTIFACT-TEMPLATE.md

@@ -2,21 +2,12 @@
 
 The Maven coordinates of this project are `${group}:${name}:${version}`.
 
-**Gradle Groovy:**
-```groovy
-repositories {
-    maven { url 'https://repo.kotlin.link' }
-    mavenCentral()
-}
-
-dependencies {
-    implementation '${group}:${name}:${version}'
-}
-```
 **Gradle Kotlin DSL:**
 ```kotlin
 repositories {
     maven("https://repo.kotlin.link")
+    //uncomment to access development builds
+    //maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
     mavenCentral()
 }