Merge pull request '0.15.8-kotlin-2.1.0' (!51) from dev into master

Reviewed-on: #51

.github/workflows/build.yml

@@ -0,0 +1,21 @@
+name: Gradle build
+
+on:
+  push:
+    branches: [ dev, master ]
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 40
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v2.5.0
+        with:
+          java-version: 11
+          distribution: liberica
+      - uses: gradle/gradle-build-action@v2
+        with:
+          arguments: build

.github/workflows/publish.yml

@@ -0,0 +1,24 @@
+name: Gradle publish
+
+on:
+  workflow_dispatch:
+  release:
+    types: [ created ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 40
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v2.5.0
+        with:
+          java-version: 11
+          distribution: liberica
+      - uses: gradle/gradle-build-action@v2
+        with:
+          arguments: |
+            publishAllPublicationsToSpaceRepository
+            -Ppublishing.space.user=${{ secrets.SPACE_APP_ID }}
+            -Ppublishing.space.token=${{ secrets.SPACE_APP_SECRET }}

.space.kts

@@ -0,0 +1,43 @@
+import kotlin.io.path.readText
+
+job("Build") {
+    gradlew("openjdk:11", "build")
+}
+
+job("Publish"){
+    startOn {
+        gitPush { enabled = false }
+    }
+    container("openjdk:11") {
+        env["SPACE_USER"] = Secrets("space_user")
+        env["SPACE_TOKEN"] = Secrets("space_token")
+        kotlinScript { api ->
+
+            val spaceUser = System.getenv("SPACE_USER")
+            val spaceToken = System.getenv("SPACE_TOKEN")
+
+            // write version to the build directory
+            api.gradlew("version")
+
+            //read version from build file
+            val version = java.nio.file.Path.of("build/project-version.txt").readText()
+
+            api.space().projects.automation.deployments.start(
+                project = api.projectIdentifier(),
+                targetIdentifier = TargetIdentifier.Key("gradle-tools"),
+                version = version,
+                // automatically update deployment status based on a status of a job
+                syncWithAutomationJob = true
+            )
+            try {
+                api.gradlew(
+                    "publishAllPublicationsToSpaceRepository",
+                    "-Ppublishing.space.user=\"$spaceUser\"",
+                    "-Ppublishing.space.token=\"$spaceToken\"",
+                )
+            } catch (ex: Exception) {
+                println("Publish failed")
+            }
+        }
+    }
+}

CHANGELOG.md

@@ -0,0 +1,332 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+
+### Added
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+### Security
+
+## 0.15.4-kotlin-2.0.0 - 2024-06-04
+
+### Added
+
+- Pass `compose` extension to the kscience extension so compose dependencies could be called directly from kscience block
+
+### Changed
+
+- Use ES6 modules by default in JS
+- Kotlin 2.0
+
+## 0.15.2-kotlin-1.9.22 - 2024-02-09
+
+### 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.
+
+## 0.14.4-kotlin-1.8.20-RC - 2023-03-12
+
+### Added
+
+- Easier dependency handling in `kscience` block
+- Customizable base jdk version
+
+### Changed
+
+- MPP does not use JVM and JS(IR) targets anymore. They could be turned manually via `js()`, `jvm()` or `fullStack()`
+- Signing is not applied if signingId is not provided
+
+### Removed
+
+- FX plugins
+- Unnecessary library shortcuts (html and datetime)
+- deploy/release tasks
+
+### Fixed
+
+- Gradle 8 compatibility
+- Dokka publication
+- issues with test sourcesets
+
+## 0.13.4-kotlin-1.8.0 - 2022-12-31
+
+### Added
+
+- Public `isInDevelopment` project flag
+
+### Changed
+
+- Require manual pom config for publications
+- Kotlin 1.8.0
+- Versions update
+- Project group changed to `space.kscience`
+- Moved `yarn.lock` to `gradle` directory
+
+### Deprecated
+
+- FX configuration
+
+### Removed
+
+- Xjdk-release flag because it is broken until https://youtrack.jetbrains.com/issue/KT-52823
+- Use CSS loader in JS by default
+
+## 0.11.6-kotlin-1.7.0
+
+### Changed
+
+- Coroutines tests are applied only when explicit `useCoroutines` is used.
+
+### Removed
+
+- Atomicfu support inside the plugin
+
+### Fixed
+
+- Rollback coroutines to 1.6.1
+
+## 0.11.5-kotlin-1.7.0
+
+### Added
+
+- Coroutine tests as default dependency for tests
+- Context receiver flag
+
+### Changed
+
+- Separate release tasks for each target
+- Kotlin 1.7.0
+- Ktor 2.0.1
+- ExplicitAPI does not override existing value
+
+### Removed
+
+- Ktor specific artifacts from version catalog
+
+### Fixed
+
+- Moved signing out of sonatype block
+
+## 0.11.1-kotlin-1.6.10
+
+### Added
+
+- Default templates for README and ARTIFACT
+
+### Changed
+
+- Replaced Groovy templates by FreeMarker
+
+### Fixed
+
+- JS publication sources jar
+
+## 0.10.9-kotlin-1.6.10
+
+### Added
+
+- html builders for readme
+
+### Changed
+
+- Kotlin 1.6.0
+- Use indy lambdas by default #32
+- Change version scheme to `<version>-kotlin-<kotlin version>`
+
+### Fixed
+
+- remove `nativeMain` dependency from `nativeTest`
+
+## 0.10.4
+
+### Changed
+
+- Kotlin 1.6
+
+### Fixed
+
+- Some issues with opt-ins
+
+## 0.10.2
+
+### Added
+
+- Experimental automatic JS project bundling in MPP
+
+### Changed
+
+- Remove vcs requirement for Space publication
+
+## 0.10.0
+
+### Added
+
+- Lazy readme properties
+- BOM for kotlin-wrappers on JS
+- Jupyter loader
+
+### Changed
+
+- API validation disabled for dev versions
+- Kotlin plugins are propagated downstream
+
+### Removed
+
+- bson support
+
+## 0.9.5
+
+### Added
+
+- Disable API validation for snapshots
+- `-Xjvm-default=all` on JVM
+
+### Changed
+
+- `publication.platform` changed to `publishing.platform`
+- Dokka version to `1.4.30`
+- `useDateTime` in extension
+- Kotlin 1.5
+
+### Removed
+
+- Publish plugin. Use MavenPublish instead
+
+### Fixed
+
+- Removed unnecessary `afterEvaluate` for compatibility with gradle 7.0
+
+## 0.9.0
+
+### Added
+
+- Skip sonatype publishing for dev versions
+
+### Changed
+
+- Publishing repositories are explicit and defined in the top level project
+- Paths to publishing properties now use dot notation like `publishing.github.user`
+
+### Deprecated
+
+- Publishing plugin
+
+### Removed
+
+- Bintray publishing
+
+## 0.8.4
+
+### Added
+
+- Adaptive support for host OS in native
+- CSS support for JS targets
+
+### Changed
+
+- Kotlin 1.4.31
+- Coroutines 1.4.3
+
+### Fixed
+
+- Plugin loading order for publishing
+- Release task
+- Readme generation for multi-module project
+
+## 0.8.1
+
+### Added
+
+- Ktor version to versions
+- Add sonatype publishing
+- Per-platform release publishing
+
+### Changed
+
+- Kotlin to 1.4.30 stable.
+- Added intermediate jsCommon main/test sourcesSet for node plugin.
+- Plugin names changed to `ru.mipt.npm` package.
+- Common plugin id changed to `common`
+- Plugins group changed to `ru.mipt.npm` with `gradle` prefix
+
+### Removed
+
+- kaml
+
+### Fixed
+
+- Fix publishing load order for sonatype
+- Fix root project readme
+
+## 0.7.4
+
+### Added
+
+- Changelog plugin automatically applied to `project`.
+- Feature matrix and Readme generation task for a `project` plugin.
+- Add `binary-compatibility-validator` to the `project` plugin.
+- Separate `yamlKt` serialization target
+- Moved all logic to a common plugin, leaving only proxies for platform plugins
+- Suppress API validation for modules with maturity below DEVELOPMENT
+
+### Changed
+
+- Remove node plugin. Node binaries should be turned on manually.
+- Use default webpack distribution path.
+- `ru.mipt.npm.base` -> `ru.mipt.npm.project`.
+- Move publishing out of general extension and apply it to project plugin instead.
+- Platform plugins are now simple references to common plugin
+- FX configuration moved to extension
+- Moved internals to internals
+- Kotlin 1.4.30-RC
+
+### Deprecated
+
+- Support of `kaml` and `snake-yaml` in favor of `yamlKt`
+- Publish plugin
+
+### Removed
+
+- `useDokka` method. Documentation jar should be added manually if needed.
+
+## 0.6.0
+
+### Added
+
+- Migrate to kotlin 1.4.0
+- Separate Native (current platform) and nodeJs plugins.
+- Add `application()` toggle in plugin configuration to produce binaries on JS and applicaion plugin on jvm.
+- Add `publish` to expose publishing configuration.
+
+## 0.5.2
+
+### Added
+
+- Copy resources for jvm modules and jvm source sets in mpp.

README.md

@@ -0,0 +1,28 @@
+[![Maven Central](https://img.shields.io/maven-central/v/space.kscience.gradle.project/space.kscience.gradle.project.gradle.plugin.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22space.kscience.gradle.project%22%20AND%20a:%22space.kscience.gradle.project.gradle.plugin%22)
+
+# KScience build tools
+
+A collection of gradle plugins for building and publish in *kscience* and *dataforge* projects.
+
+## space.kscience.gradle.common
+A primary plugin. When used with kotlin-jvm, kotlin-js or kotlin-mulitplatform configures the project for appropriate target.
+
+## space.kscience.gradle.project
+Root project tool including JetBrains changelog plugin an kotlin binary compatibility validator tool.
+
+## space.kscience.gradle.mpp
+`= kotlin("multiplatform") + space.kscience.gradle.common`
+
+Includes JVM-IR and JS-IR-Browser targets.
+
+## space.kscience.gradle.jvm
+`= kotlin("jvm") + space.kscience.gradle.common`
+
+## space.kscience.gradle.js
+`= kotlin("js") + space.kscience.gradle.common`
+
+## space.kscience.gradle.native
+add default native targets to `space.kscience.gradle.mpp`
+
+## space.kscience.gradle.node
+add node target to `space.kscience.gradle.mpp`

build.gradle.kts

@@ -1,134 +1,206 @@
-import java.util.*
 
 plugins {
+    `java-gradle-plugin`
     `kotlin-dsl`
     `maven-publish`
-    id("com.jfrog.bintray") version "1.8.5"
+//    signing
+    `version-catalog`
+    alias(libs.plugins.maven.publish)
+    alias(libs.plugins.jetbrains.changelog)
+    alias(libs.plugins.jetbrains.dokka)
+    alias(libs.plugins.versions)
+    alias(libs.plugins.versions.update)
 }
 
-group = "scientifik"
+group = "space.kscience"
-version = "0.5.0"
+version = libs.versions.tools.get()
+
+description = "Build tools for kotlin for science projects"
+
+changelog.version.set(project.version.toString())
 
 repositories {
+    mavenCentral()
     gradlePluginPortal()
-    jcenter()
+    maven("https://repo.kotlin.link")
-    maven("https://kotlin.bintray.com/kotlinx")
-    maven("https://dl.bintray.com/kotlin/kotlin-eap")
 }
 
-val kotlinVersion = "1.3.72"
-
-java {
-    targetCompatibility = JavaVersion.VERSION_1_8
-}
-
-// Add plugins used in buildSrc as dependencies, also we should specify version only here
 dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
+    api(libs.kotlin.gradle)
-    implementation("org.jetbrains.kotlin:kotlin-serialization:$kotlinVersion")
+    api(libs.foojay.resolver)
-    implementation("org.jetbrains.kotlinx:atomicfu-gradle-plugin:0.14.3")
+    implementation(libs.binary.compatibility.validator)
-    implementation("org.jetbrains.dokka:dokka-gradle-plugin:0.10.1")
+    implementation(libs.changelog.gradle)
+    implementation(libs.dokka.gradle)
+    implementation(libs.kotlin.jupyter.gradle)
+    implementation(libs.kotlin.serialization)
+    implementation(libs.kotlinx.html)
+    implementation(libs.tomlj)
+//    // nexus publishing plugin
+//    implementation("io.github.gradle-nexus:publish-plugin:_")
+
+    implementation(libs.freemarker)
+
+    testImplementation(kotlin("test"))
 }
 
+tasks.test {
+    useJUnitPlatform()
+}
+
+//declaring exported plugins
+
 gradlePlugin {
     plugins {
-        create("scientifik-publish") {
+        create("project") {
-            id = "scientifik.publish"
+            id = "space.kscience.gradle.project"
-            description = "The publication plugin for bintray and github"
+            description = "The root plugin for multi-module project infrastructure"
-            implementationClass = "scientifik.ScientifikPublishPlugin"
+            implementationClass = "space.kscience.gradle.KScienceProjectPlugin"
         }
 
-        create("scientifik-mpp") {
+        create("mpp") {
-            id = "scientifik.mpp"
+            id = "space.kscience.gradle.mpp"
             description = "Pre-configured multiplatform project"
-            implementationClass = "scientifik.ScientifikMPPlugin"
+            implementationClass = "space.kscience.gradle.KScienceMPPlugin"
         }
 
-        create("scientifik-jvm") {
+        create("jvm") {
-            id = "scientifik.jvm"
+            id = "space.kscience.gradle.jvm"
             description = "Pre-configured JVM project"
-            implementationClass = "scientifik.ScientifikJVMPlugin"
+            implementationClass = "space.kscience.gradle.KScienceJVMPlugin"
         }
-
-        create("scientifik-js") {
-            id = "scientifik.js"
-            description = "Pre-configured JS project"
-            implementationClass = "scientifik.ScientifikJSPlugin"
-        }
-
-//        create("scientifik-atomic") {
-//            id = "scientifik.atomic"
-//            description = "Add kotlin atomic plugin to any flafor"
-//            implementationClass = "scientifik.ScientifikAtomicPlugin"
-//        }
     }
 }
 
-publishing {
+tasks.create("version") {
-    repositories {
+    group = "publishing"
-        maven("https://bintray.com/mipt-npm/scientifik")
+    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())
+    }
+}
+
+//publishing version catalog
+
+catalog.versionCatalog {
+    from(files("gradle/libs.versions.toml"))
+}
+
+//publishing the artifact
+
+val sourcesJar by tasks.creating(Jar::class) {
+    archiveClassifier.set("sources")
+    from(sourceSets.named("main").get().allSource)
+}
+
+val javadocsJar by tasks.creating(Jar::class) {
+    group = JavaBasePlugin.DOCUMENTATION_GROUP
+    archiveClassifier.set("javadoc")
+    from(tasks.dokkaHtml)
+}
+
+val emptyJavadocJar by tasks.creating(Jar::class) {
+    group = JavaBasePlugin.DOCUMENTATION_GROUP
+    archiveBaseName.set("empty")
+    archiveClassifier.set("javadoc")
+}
+
+
+val emptySourcesJar by tasks.creating(Jar::class) {
+    archiveClassifier.set("sources")
+    archiveBaseName.set("empty")
+}
+
+mavenPublishing {
+    configure(
+        com.vanniktech.maven.publish.GradlePlugin(
+            javadocJar = com.vanniktech.maven.publish.JavadocJar.Dokka("dokkaHtml"),
+            sourcesJar = true,
+        )
+    )
+
+    project.publishing.publications.create("maven", MavenPublication::class.java) {
+        from(project.components.getByName("versionCatalog"))
     }
 
-    val vcs = "https://github.com/mipt-npm/scientifik-gradle-tools"
+    val vcs = "https://git.sciprog.center/kscience/gradle-tools"
 
-    // Process each publication we have in this project
+    pom {
-    publications.filterIsInstance<MavenPublication>().forEach { publication ->
+        name.set(project.name)
+        description.set(project.description)
+        url.set(vcs)
 
-        publication.pom {
+        licenses {
-            name.set(project.name)
+            license {
-            description.set(project.description)
+                name.set("The Apache Software License, Version 2.0")
+                url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
+                distribution.set("repo")
+            }
+        }
+
+        developers {
+            developer {
+                id.set("SPC")
+                name.set("Scientific Programming Centre")
+                organization.set("SPC")
+                organizationUrl.set("https://sciprog.center/")
+            }
+        }
+
+        scm {
             url.set(vcs)
+            tag.set(project.version.toString())
+        }
+    }
 
-            licenses {
+    val spaceRepo = "https://maven.sciprog.center/kscience"
-                license {
+    val spcUser: String? = findProperty("publishing.spc.user") as? String
-                    name.set("The Apache Software License, Version 2.0")
+    val spcToken: String? = findProperty("publishing.spc.token") as? String
-                    url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
-                    distribution.set("repo")
-                }
-            }
-            developers {
-                developer {
-                    id.set("MIPT-NPM")
-                    name.set("MIPT nuclear physics methods laboratory")
-                    organization.set("MIPT")
-                    organizationUrl.set("http://npm.mipt.ru")
-                }
 
-            }
+    if (spcUser != null && spcToken != null) {
-            scm {
+        publishing.repositories.maven {
-                url.set(vcs)
+            name = "spc"
+            url = uri(spaceRepo)
+
+            credentials {
+                username = spcUser
+                password = spcToken
             }
         }
     }
 
-    bintray {
+    val centralUser: String? = project.findProperty("mavenCentralUsername") as? String
-        user = project.findProperty("bintrayUser") as? String ?: System.getenv("BINTRAY_USER")
+    val centralPassword: String? = project.findProperty("mavenCentralPassword") as? String
-        key = project.findProperty("bintrayApiKey") as? String? ?: System.getenv("BINTRAY_API_KEY")
-        publish = true
-        override = true // for multi-platform Kotlin/Native publishing
-
-        // We have to use delegateClosureOf because bintray supports only dynamic groovy syntax
-        // this is a problem of this plugin
-        pkg.apply {
-            userOrg = "mipt-npm"
-            repo = if (project.version.toString().contains("dev")) "dev" else "scientifik"
-            name = project.name
-            issueTrackerUrl = "$vcs/issues"
-            setLicenses("Apache-2.0")
-            vcsUrl = vcs
-            version.apply {
-                name = project.version.toString()
-                vcsTag = project.version.toString()
-                released = Date().toString()
-            }
-        }
-
-        //workaround bintray bug
-        project.afterEvaluate {
-            setPublications(*project.extensions.findByType<PublishingExtension>()!!.publications.names.toTypedArray())
-        }
 
+    if (centralUser != null && centralPassword != null) {
+        publishToMavenCentral(com.vanniktech.maven.publish.SonatypeHost.CENTRAL_PORTAL)
+        signAllPublications()
     }
 }
 
+kotlin {
+    explicitApiWarning()
+    jvmToolchain(17)
+}
+
+tasks.processResources.configure {
+    duplicatesStrategy = DuplicatesStrategy.INCLUDE
+    from("gradle/libs.versions.toml")
+}
+
+// Workaround for https://github.com/gradle/gradle/issues/15568
+tasks.withType<AbstractPublishToMaven>().configureEach {
+    mustRunAfter(tasks.withType<Sign>())
+}
+
+versionCatalogUpdate {
+    sortByKey.set(false)
+    keep {
+        keepUnusedVersions = true
+        keepUnusedPlugins = true
+        keepUnusedLibraries = true
+    }
+}
  

gradle.properties

@@ -0,0 +1,3 @@
+kotlin.code.style=official
+
+nl.littlerobots.vcu.resolver=true

gradle/libs.versions.toml

@@ -0,0 +1,118 @@
+[versions]
+# @pin
+kotlin = "2.1.0"
+# @pin
+tools = "0.15.8-kotlin-2.1.0"
+atomicfu = "0.26.1"
+changelog = "2.2.1"
+compose = "1.7.1"
+dokka = "2.0.0-Beta"
+jsBom = "1.0.0-pre.847"
+junit = "5.10.2"
+kotlin-jupyter = "0.12.0-352"
+kotlinx-benchmark = "0.4.13"
+kotlinx-cli = "0.3.6"
+kotlinx-coroutines = "1.9.0"
+kotlinx-datetime = "0.6.1"
+kotlinx-html = "0.11.0"
+kotlinx-knit = "0.5.0"
+kotlinx-nodejs = "0.0.7"
+kotlinx-serialization = "1.7.3"
+kover = "0.8.3"
+ktor = "3.0.2"
+ksp = "2.1.0-1.0.29"
+logback = "1.5.12"
+slf4j = "2.0.16"
+xmlutil = "0.90.3"
+yamlkt = "0.13.0"
+
+[plugins]
+maven-publish = { id = "com.vanniktech.maven.publish", version = "0.30.0" }
+compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+compose-jb = { id = "org.jetbrains.compose", version.ref = "compose" }
+jetbrains-changelog = "org.jetbrains.changelog:2.2.1"
+jetbrains-dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-android-extensions = { id = "org.jetbrains.kotlin.android.extensions", version.ref = "kotlin" }
+kotlin-dsl = "org.gradle.kotlin.kotlin-dsl:5.1.2"
+kotlin-js = { id = "org.jetbrains.kotlin.js", version.ref = "kotlin" }
+kotlin-jupyter-api = { id = "org.jetbrains.kotlin.jupyter.api", version.ref = "kotlin-jupyter" }
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" }
+kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+kotlin-native-cocoapods = { id = "org.jetbrains.kotlin.native.cocoapods", version.ref = "kotlin" }
+kotlin-plugin-allopen = { id = "org.jetbrains.kotlin.plugin.allopen", version.ref = "kotlin" }
+kotlin-plugin-jpa = { id = "org.jetbrains.kotlin.plugin.jpa", version.ref = "kotlin" }
+kotlin-plugin-lombok = { id = "org.jetbrains.kotlin.plugin.lombok", version.ref = "kotlin" }
+kotlin-plugin-noarg = { id = "org.jetbrains.kotlin.plugin.noarg", version.ref = "kotlin" }
+kotlin-plugin-parcelize = { id = "org.jetbrains.kotlin.plugin.parcelize", version.ref = "kotlin" }
+kotlin-plugin-scripting = { id = "org.jetbrains.kotlin.plugin.scripting", version.ref = "kotlin" }
+kotlin-plugin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+kotlin-plugin-spring = { id = "org.jetbrains.kotlin.plugin.spring", version.ref = "kotlin" }
+kotlinx-benchmark = { id = "org.jetbrains.kotlinx.benchmark", version.ref = "kotlinx-benchmark" }
+kotlinx-kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" }
+kscience-mpp = { id = "space.kscience.gradle.mpp", version.ref = "tools" }
+kscience-project = { id = "space.kscience.gradle.project", version.ref = "tools" }
+ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
+ktor = { id = "io.ktor.plugin", version.ref = "ktor" }
+versions = "com.github.ben-manes.versions:0.51.0"
+versions-update = "nl.littlerobots.version-catalog-update:0.8.5"
+
+[libraries]
+atomicfu = { module = "org.jetbrains.kotlinx:atomicfu", version.ref = "atomicfu" }
+atomicfu-gradle = { module = "org.jetbrains.kotlinx:atomicfu-gradle-plugin", version.ref = "atomicfu" }
+binary-compatibility-validator = "org.jetbrains.kotlinx:binary-compatibility-validator:0.15.0-Beta.3"
+changelog-gradle = { module = "org.jetbrains.intellij.plugins:gradle-changelog-plugin", version.ref = "changelog" }
+dokka-base = { module = "org.jetbrains.dokka:dokka-base", version.ref = "dokka" }
+dokka-gradle = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "dokka" }
+dokka-gradle-plugin = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "dokka" }
+foojay-resolver = "org.gradle.toolchains:foojay-resolver:0.9.0"
+freemarker = "org.freemarker:freemarker:2.3.33"
+gradle-changelog-plugin = { module = "org.jetbrains.intellij.plugins:gradle-changelog-plugin", version.ref = "changelog" }
+kotlin-assignment-compiler-plugin-embeddable = { module = "org.jetbrains.kotlin:kotlin-assignment-compiler-plugin-embeddable", version.ref = "kotlin" }
+kotlin-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+kotlin-js-wrappers = { module = "org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom", version.ref = "jsBom" }
+kotlin-jupyter-api-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-jupyter-api-gradle-plugin", version.ref = "kotlin" }
+kotlin-jupyter-gradle = { module = "org.jetbrains.kotlin:kotlin-jupyter-api-gradle-plugin", version.ref = "kotlin-jupyter" }
+kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
+kotlin-sam-with-receiver-compiler-plugin-embeddable = { module = "org.jetbrains.kotlin:kotlin-sam-with-receiver-compiler-plugin-embeddable", version.ref = "kotlin" }
+kotlin-scripting-compiler-embeddable = { module = "org.jetbrains.kotlin:kotlin-scripting-compiler-embeddable", version.ref = "kotlin" }
+kotlin-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kotlin" }
+kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
+kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test" }
+kotlinx-benchmark-runtime = { module = "org.jetbrains.kotlinx:kotlinx-benchmark-runtime", version.ref = "kotlinx-benchmark" }
+kotlinx-cli = { module = "org.jetbrains.kotlinx:kotlinx-cli", version.ref = "kotlinx-cli" }
+kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-debug = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-debug", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-guava = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-guava", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-javafx = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-javafx", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-jdk8 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-play-services = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-play-services", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-reactive = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-reactive", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-reactor = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-reactor", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-rx2 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-rx2", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-rx3 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-rx3", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-slf4j = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-slf4j", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-swing = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-swing", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
+kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
+kotlinx-html = { module = "org.jetbrains.kotlinx:kotlinx-html", version.ref = "kotlinx-html" }
+kotlinx-knit = { module = "org.jetbrains.kotlinx:kotlinx-knit", version.ref = "kotlinx-knit" }
+kotlinx-nodejs = { module = "org.jetbrains.kotlinx:kotlinx-nodejs", version.ref = "kotlinx-nodejs" }
+kotlinx-serialization-cbor = { module = "org.jetbrains.kotlinx:kotlinx-serialization-cbor", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-core = { module = "org.jetbrains.kotlinx:kotlinx-serialization-core", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-hocon = { module = "org.jetbrains.kotlinx:kotlinx-serialization-hocon", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-properties = { module = "org.jetbrains.kotlinx:kotlinx-serialization-properties", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-protobuf = { module = "org.jetbrains.kotlinx:kotlinx-serialization-protobuf", version.ref = "kotlinx-serialization" }
+ksp-api = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp" }
+ktor-bom = { module = "io.ktor:ktor-bom", version.ref = "ktor" }
+logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
+slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
+tomlj = "org.tomlj:tomlj:1.1.1"
+xmlutil-core = { module = "io.github.pdvrieze.xmlutil:core", version.ref = "xmlutil" }
+xmlutil-ktor = { module = "io.github.pdvrieze.xmlutil:ktor", version.ref = "xmlutil" }
+xmlutil-serialization = { module = "io.github.pdvrieze.xmlutil:serialization", version.ref = "xmlutil" }
+yamlkt = { module = "net.mamoe.yamlkt:yamlkt", version.ref = "yamlkt" }

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,78 +17,113 @@
 #
 
 ##############################################################################
-##
+#
-##  Gradle start up script for UN*X
+#   Gradle start up script for POSIX generated by Gradle.
-##
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
+app_path=$0
-# Need this for relative symlinks.
+
-while [ -h "$PRG" ] ; do
+# Need this for daisy-chained symlinks.
-    ls=`ls -ld "$PRG"`
+while
-    link=`expr "$ls" : '.*-> \(.*\)$'`
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    if expr "$link" : '/.*' > /dev/null; then
+    [ -h "$app_path" ]
-        PRG="$link"
+do
-    else
+    ls=$( ls -ld "$app_path" )
-        PRG=`dirname "$PRG"`"/$link"
+    link=${ls#*' -> '}
-    fi
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
+
-cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+APP_BASE_NAME=${0##*/}
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
+case "$( uname )" in                #(
-  CYGWIN* )
+  CYGWIN* )         cygwin=true  ;; #(
-    cygwin=true
+  Darwin* )         darwin=true  ;; #(
-    ;;
+  MSYS* | MINGW* )  msys=true    ;; #(
-  Darwin* )
+  NONSTOP* )        nonstop=true ;;
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -97,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -105,79 +140,95 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
+    case $MAX_FD in #(
-    if [ $? -eq 0 ] ; then
+      max*)
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+        MAX_FD=$( ulimit -H -n ) ||
-            MAX_FD="$MAX_FD_LIMIT"
+            warn "Could not query maximum file descriptor limit"
-        fi
+    esac
-        ulimit -n $MAX_FD
+    case $MAX_FD in  #(
-        if [ $? -ne 0 ] ; then
+      '' | soft) :;; #(
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
+      *)
-        fi
+        ulimit -n "$MAX_FD" ||
-    else
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
     esac
 fi
 
-# Escape application args
+# Collect all arguments for the java command, stacking in reverse order:
-save () {
+#   * args from the command line
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+#   * the main class name
-    echo " "
+#   * -classpath
-}
+#   * -D...appname settings
-APP_ARGS=`save "$@"`
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
+# For Cygwin or MSYS, switch paths to Windows format before running java
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -40,7 +40,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if "%ERRORLEVEL%" == "0" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -54,7 +54,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
+if exist "%JAVA_EXE%" goto execute
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -64,28 +64,14 @@ echo location of your Java installation.
 
 goto fail
 
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
+
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
 
 :end
 @rem End local scope for the variables with windows NT shell

settings.gradle

@@ -1,2 +0,0 @@
-rootProject.name = 'gradle-tools'
-

settings.gradle.kts

@@ -0,0 +1,5 @@
+rootProject.name = "gradle-tools"
+
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version("0.8.0")
+}

src/main/kotlin/Scientifik.kt

@@ -1,18 +0,0 @@
-import org.gradle.api.JavaVersion
-
-/**
- * Build constants
- */
-object Scientifik {
-    const val coroutinesVersion = "1.3.4"
-    const val serializationVersion = "0.20.0"
-
-    val JVM_TARGET = JavaVersion.VERSION_11
-//    val JVM_VERSION = JVM_TARGET.toString()
-
-    object Serialization{
-        const val xmlVersion = "0.20.0.0"
-        const val yamlVersion = "0.16.1"
-        const val bsonVersion = "0.2.1"
-    }
-}

src/main/kotlin/scientifik/ScientifikJSPlugin.kt

@@ -1,68 +0,0 @@
-package scientifik
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.tasks.Copy
-import org.gradle.kotlin.dsl.configure
-import org.gradle.kotlin.dsl.get
-import org.gradle.kotlin.dsl.getValue
-import org.gradle.kotlin.dsl.getting
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
-
-open class ScientifikJSPlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-
-        with(project) {
-            plugins.apply("org.jetbrains.kotlin.js")
-
-            repositories.applyRepos()
-
-            configure<KotlinJsProjectExtension> {
-                target {
-                    browser {
-                        webpackTask {
-                            outputFileName = "main.bundle.js"
-                        }
-                        distribution {
-                            directory = project.jsDistDirectory
-                        }
-                    }
-                }
-                sourceSets["main"].apply {
-                    languageSettings.applySettings()
-
-                    dependencies {
-                        api(kotlin("stdlib-js"))
-                    }
-                }
-
-                sourceSets["test"].apply {
-                    languageSettings.applySettings()
-                    dependencies {
-                        implementation(kotlin("test-js"))
-                    }
-                }
-            }
-
-            tasks.apply {
-
-                val processResources by getting(Copy::class)
-                processResources.copyJSResources(configurations["runtimeClasspath"])
-
-                val browserDistribution by getting {
-                    doLast {
-                        val indexFile = project.jsDistDirectory.resolve("index.html")
-                        if (indexFile.exists()) {
-                            println("Run JS distribution at: ${indexFile.canonicalPath}")
-                        }
-                    }
-                    group = "distribution"
-                }
-
-//                findByName("assemble")?.dependsOn(installJsDist)
-
-            }
-        }
-
-    }
-}

src/main/kotlin/scientifik/ScientifikJVMPlugin.kt

@@ -1,101 +0,0 @@
-package scientifik
-
-import Scientifik
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.plugins.JavaBasePlugin
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.tasks.bundling.Jar
-import org.gradle.api.tasks.testing.Test
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.dokka.gradle.DokkaTask
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
-open class ScientifikJVMPlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-        with(project) {
-            plugins.apply("org.jetbrains.kotlin.jvm")
-
-            repositories.applyRepos()
-
-            extensions.findByType<JavaPluginExtension>()?.apply {
-                targetCompatibility = Scientifik.JVM_TARGET
-            }
-
-            tasks.withType<KotlinCompile> {
-                kotlinOptions {
-                    jvmTarget = Scientifik.JVM_TARGET.toString()
-                }
-            }
-
-            configure<KotlinJvmProjectExtension> {
-
-                val sourceSet = sourceSets["main"].apply {
-                    languageSettings.applySettings()
-                    dependencies {
-                        api(kotlin("stdlib-jdk8"))
-                    }
-                }
-
-                sourceSets["test"].apply {
-                    languageSettings.applySettings()
-                    dependencies {
-                        implementation(kotlin("test"))
-//                        implementation(kotlin("test-junit"))
-                        implementation(kotlin("test-junit5"))
-                        implementation("org.junit.jupiter:junit-jupiter:5.6.1")
-                    }
-                }
-
-                val sourcesJar by tasks.registering(Jar::class) {
-                    archiveClassifier.set("sources")
-                    from(sourceSet.kotlin.srcDirs.first())
-                }
-
-                pluginManager.withPlugin("maven-publish") {
-
-                    configure<PublishingExtension> {
-                        publications {
-                            register("jvm", MavenPublication::class) {
-                                from(components["java"])
-                                artifact(sourcesJar.get())
-                            }
-                        }
-                    }
-
-                    pluginManager.withPlugin("org.jetbrains.dokka") {
-                        logger.info("Adding dokka functionality to project ${this@with.name}")
-
-                        val dokka by tasks.getting(DokkaTask::class) {
-                            outputFormat = "html"
-                            outputDirectory = "$buildDir/javadoc"
-                        }
-
-                        val kdocJar by tasks.registering(Jar::class) {
-                            group = JavaBasePlugin.DOCUMENTATION_GROUP
-                            dependsOn(dokka)
-                            archiveClassifier.set("javadoc")
-                            from("$buildDir/javadoc")
-                        }
-
-                        configure<PublishingExtension> {
-                            publications {
-                                getByName("jvm") {
-                                    this as MavenPublication
-                                    artifact(kdocJar.get())
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            tasks.withType<Test>(){
-                useJUnitPlatform()
-            }
-        }
-
-    }
-}

src/main/kotlin/scientifik/ScientifikMPPlugin.kt

@@ -1,140 +0,0 @@
-package scientifik
-
-import Scientifik
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.plugins.JavaBasePlugin
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.tasks.Copy
-import org.gradle.api.tasks.bundling.Jar
-import org.gradle.api.tasks.testing.Test
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.dokka.gradle.DokkaTask
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-
-open class ScientifikMPPlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-        project.run {
-
-            plugins.apply("org.jetbrains.kotlin.multiplatform")
-
-            repositories.applyRepos()
-
-            configure<KotlinMultiplatformExtension> {
-
-                jvm {
-                    compilations.all {
-                        kotlinOptions {
-                            jvmTarget = Scientifik.JVM_TARGET.toString()
-                        }
-                    }
-                }
-
-                val js = js {
-                    browser {
-                        webpackTask {
-                            outputFileName = "main.bundle.js"
-                        }
-                        distribution {
-                            directory = project.jsDistDirectory
-                        }
-                    }
-                }
-
-                sourceSets.invoke {
-                    val commonMain by getting {
-                        dependencies {
-                            api(kotlin("stdlib"))
-                        }
-                    }
-                    val commonTest by getting {
-                        dependencies {
-                            implementation(kotlin("test-common"))
-                            implementation(kotlin("test-annotations-common"))
-                        }
-                    }
-                    val jvmMain by getting {
-                        dependencies {
-                            api(kotlin("stdlib-jdk8"))
-                        }
-                    }
-                    val jvmTest by getting {
-                        dependencies {
-                            implementation(kotlin("test"))
-//                            implementation(kotlin("test-junit"))
-                            implementation(kotlin("test-junit5"))
-                            implementation("org.junit.jupiter:junit-jupiter:5.6.1")
-                        }
-                    }
-                    val jsMain by getting {
-                        dependencies {
-                            api(kotlin("stdlib-js"))
-                        }
-                    }
-                    val jsTest by getting {
-                        dependencies {
-                            implementation(kotlin("test-js"))
-                        }
-                    }
-                }
-
-                targets.all {
-                    sourceSets.all {
-                        languageSettings.applySettings()
-                    }
-                }
-
-                pluginManager.withPlugin("org.jetbrains.dokka") {
-                    logger.info("Adding dokka functionality to project ${this@run.name}")
-                    val dokka by tasks.getting(DokkaTask::class) {
-                        outputFormat = "html"
-                        outputDirectory = "$buildDir/javadoc"
-                        multiplatform {
-
-                        }
-                    }
-
-                    val kdocJar by tasks.registering(Jar::class) {
-                        group = JavaBasePlugin.DOCUMENTATION_GROUP
-                        dependsOn(dokka)
-                        archiveClassifier.set("javadoc")
-                        from("$buildDir/javadoc")
-                    }
-
-                    pluginManager.withPlugin("maven-publish") {
-                        configure<PublishingExtension> {
-
-                            targets.all {
-                                val publication = publications.findByName(name) as MavenPublication
-
-                                // Patch publications with fake javadoc
-                                publication.artifact(kdocJar.get())
-                            }
-                        }
-                    }
-                }
-
-                tasks.apply {
-                    val jsProcessResources by getting(Copy::class)
-                    jsProcessResources.copyJSResources(configurations["jsRuntimeClasspath"])
-
-                    val jsBrowserDistribution by getting {
-                        doLast {
-                            val indexFile = project.jsDistDirectory.resolve("index.html")
-                            if (indexFile.exists()) {
-                                println("Run JS distribution at: ${indexFile.canonicalPath}")
-                            }
-                        }
-                        group = "distribution"
-                    }
-
-                    withType<Test>() {
-                        useJUnitPlatform()
-                    }
-                }
-
-            }
-        }
-    }
-}

src/main/kotlin/scientifik/ScientifikNativePlugin.kt

@@ -1,38 +0,0 @@
-package scientifik
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-
-class ScientifikNativePlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        target.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-            target.configure<KotlinMultiplatformExtension> {
-                linuxX64()
-                mingwX64()
-
-                sourceSets.apply {
-                    val commonMain by getting {}
-
-                    val native by creating {
-                        dependsOn(commonMain)
-
-                        dependencies {
-                            api(kotlin("native"))
-                            //TODO add stdlib here
-                        }
-                    }
-
-                    mingwX64().compilations["main"].defaultSourceSet {
-                        dependsOn(native)
-                    }
-
-                    linuxX64().compilations["main"].defaultSourceSet {
-                        dependsOn(native)
-                    }
-                }
-            }
-        }
-    }
-}

src/main/kotlin/scientifik/ScientifikPublishPlugin.kt

@@ -1,112 +0,0 @@
-package scientifik
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.kotlin.dsl.configure
-import org.gradle.kotlin.dsl.provideDelegate
-import org.gradle.kotlin.dsl.withType
-
-
-open class ScientifikPublishPlugin : Plugin<Project> {
-
-    override fun apply(project: Project) {
-
-        project.plugins.apply("maven-publish")
-
-        project.run {
-            val githubProject = findProperty("githubProject") as? String
-            val vcs = findProperty("vcs") as? String
-                ?: githubProject?.let { "https://github.com/mipt-npm/$it" }
-
-            if (vcs == null) {
-                project.logger.warn("[${project.name}] Missing deployment configuration. Skipping publish.")
-                return@apply
-            }
-
-            project.configure<PublishingExtension> {
-                // Process each publication we have in this project
-                publications.withType<MavenPublication>().forEach { publication ->
-                    @Suppress("UnstableApiUsage")
-                    publication.pom {
-                        name.set(project.name)
-                        description.set(project.description)
-                        url.set(vcs)
-
-                        licenses {
-                            license {
-                                name.set("The Apache Software License, Version 2.0")
-                                url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
-                                distribution.set("repo")
-                            }
-                        }
-                        developers {
-                            developer {
-                                id.set("MIPT-NPM")
-                                name.set("MIPT nuclear physics methods laboratory")
-                                organization.set("MIPT")
-                                organizationUrl.set("http://npm.mipt.ru")
-                            }
-
-                        }
-                        scm {
-                            url.set(vcs)
-                            tag.set(project.version.toString())
-                        }
-                    }
-                }
-
-                val githubUser: String? by project
-                val githubToken: String? by project
-
-                if (githubProject != null && githubUser != null && githubToken != null) {
-                    project.logger.info("Adding github publishing to project [${project.name}]")
-                    repositories {
-                        maven {
-                            name = "github"
-                            url = uri("https://maven.pkg.github.com/mipt-npm/$githubProject/")
-                            credentials {
-                                username = githubUser
-                                password = githubToken
-                            }
-
-                        }
-                    }
-                }
-
-
-                val bintrayOrg = project.findProperty("bintrayOrg") as? String ?: "mipt-npm"
-                val bintrayUser = project.findProperty("bintrayUser") as? String
-                val bintrayKey = project.findProperty("bintrayApiKey") as? String
-
-
-                val bintrayRepo = if (project.version.toString().contains("dev")) {
-                    "dev"
-                } else {
-                    findProperty("bintrayRepo") as? String
-                }
-
-                val projectName = project.name
-
-                if (bintrayRepo != null && bintrayUser != null && bintrayKey != null) {
-                    project.logger.info("Adding bintray publishing to project [$projectName]")
-
-                    repositories {
-                        maven {
-                            name = "bintray"
-                            url = uri(
-                                "https://api.bintray.com/maven/$bintrayOrg/$bintrayRepo/$projectName/;publish=0;override=1"
-                            )
-                            credentials {
-                                username = bintrayUser
-                                password = bintrayKey
-                            }
-                        }
-                    }
-
-                }
-            }
-        }
-    }
-}

src/main/kotlin/scientifik/common.kt

@@ -1,73 +0,0 @@
-package scientifik
-
-import org.gradle.api.Project
-import org.gradle.api.artifacts.Configuration
-import org.gradle.api.artifacts.ProjectDependency
-import org.gradle.api.artifacts.dsl.RepositoryHandler
-import org.gradle.api.tasks.Copy
-import org.gradle.kotlin.dsl.maven
-import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
-import java.io.File
-
-internal fun LanguageSettingsBuilder.applySettings(): Unit {
-    progressiveMode = true
-    enableLanguageFeature("InlineClasses")
-    useExperimentalAnnotation("kotlin.Experimental")
-    useExperimentalAnnotation("kotlin.ExperimentalUnsignedTypes")
-    useExperimentalAnnotation("kotlin.ExperimentalStdlibApi")
-    useExperimentalAnnotation("kotlin.time.ExperimentalTime")
-}
-
-internal fun RepositoryHandler.applyRepos(): Unit {
-    mavenCentral()
-    jcenter()
-    maven("https://dl.bintray.com/kotlin/kotlin-eap")
-    maven("https://kotlin.bintray.com/kotlinx")
-    maven("https://dl.bintray.com/mipt-npm/scientifik")
-    maven("https://dl.bintray.com/mipt-npm/dev")
-    maven("https://kotlin.bintray.com/kotlin-js-wrappers/")
-    maven("https://dl.bintray.com/mipt-npm/dataforge")
-}
-
-
-internal fun Copy.copyJSResources(configuration: Configuration): Unit = project.afterEvaluate {
-    val projectDeps = configuration
-        .allDependencies
-        .filterIsInstance<ProjectDependency>()
-        .map { it.dependencyProject }
-
-    val destination = destinationDir
-
-    projectDeps.forEach { dep ->
-        dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-            dep.tasks.findByName("jsProcessResources")?.let { task ->
-                val sourceDir = (task as Copy).destinationDir
-                inputs.files(sourceDir)
-                dependsOn(task)
-                from(sourceDir)
-            }
-        }
-        dep.pluginManager.withPlugin("org.jetbrains.kotlin.js") {
-            dep.tasks.findByName("processResources")?.let { task ->
-                val sourceDir = (task as Copy).destinationDir
-                inputs.files(sourceDir)
-                dependsOn(task)
-                from(sourceDir)
-            }
-        }
-    }
-}
-
-
-val Project.jsDistDirectory: File
-    get() {
-        val distributionName = listOf(
-            name,
-            "js",
-            version.toString()
-        ).joinToString("-")
-
-        return buildDir.resolve(
-            "distributions/$distributionName"
-        )
-    }

src/main/kotlin/scientifik/extensions.kt

@@ -1,97 +0,0 @@
-package scientifik
-
-import Scientifik
-import kotlinx.atomicfu.plugin.gradle.sourceSets
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.findByType
-import org.gradle.kotlin.dsl.invoke
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-
-enum class DependencyConfiguration {
-    API,
-    IMPLEMENTATION,
-    COMPILE_ONLY
-}
-
-enum class DependencySourceSet(val setName: String, val suffix: String) {
-    MAIN("main", "Main"),
-    TEST("test", "Test")
-}
-
-internal fun Project.useDependency(
-    vararg pairs: Pair<String, String>,
-    dependencySourceSet: DependencySourceSet = DependencySourceSet.MAIN,
-    dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.API
-) {
-    pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-        extensions.findByType<KotlinMultiplatformExtension>()?.apply {
-            sourceSets {
-                pairs.forEach { (target, dep) ->
-                    val name = target + dependencySourceSet.suffix
-                    findByName(name)?.apply {
-                        dependencies {
-                            when (dependencyConfiguration) {
-                                DependencyConfiguration.API -> api(dep)
-                                DependencyConfiguration.IMPLEMENTATION -> implementation(dep)
-                                DependencyConfiguration.COMPILE_ONLY-> compileOnly(dep)
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    pairs.find { it.first == "jvm" }?.let { dep ->
-        pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
-            sourceSets.findByName(dependencySourceSet.setName)?.apply {
-                dependencies.apply {
-                    val configurationName = when (dependencyConfiguration) {
-                        DependencyConfiguration.API -> apiConfigurationName
-                        DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
-                        DependencyConfiguration.COMPILE_ONLY-> compileOnlyConfigurationName
-                    }
-                    add(configurationName, dep.second)
-                }
-            }
-        }
-    }
-
-    pairs.find { it.first == "js" }?.let { dep ->
-        pluginManager.withPlugin("org.jetbrains.kotlin.js") {
-            sourceSets.findByName(dependencySourceSet.setName)?.apply {
-                dependencies.apply {
-                    val configurationName = when (dependencyConfiguration) {
-                        DependencyConfiguration.API -> apiConfigurationName
-                        DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
-                        DependencyConfiguration.COMPILE_ONLY-> compileOnlyConfigurationName
-                    }
-                    add(configurationName, dep.second)
-                }
-            }
-        }
-    }
-}
-
-fun Project.useCoroutines(
-    version: String = Scientifik.coroutinesVersion,
-    sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
-    configuration: DependencyConfiguration = DependencyConfiguration.API
-) = useDependency(
-    "common" to "org.jetbrains.kotlinx:kotlinx-coroutines-core-common:$version",
-    "jvm" to "org.jetbrains.kotlinx:kotlinx-coroutines-core:$version",
-    "js" to "org.jetbrains.kotlinx:kotlinx-coroutines-core-js:$version",
-    "native" to "org.jetbrains.kotlinx:kotlinx-coroutines-core-native:$version",
-    dependencySourceSet = sourceSet,
-    dependencyConfiguration = configuration
-)
-
-//fun Project.atomic(version: String = Scientifik.atomicfuVersion) {
-//    plugins.apply("kotlinx-atomicfu")
-//    useDependency(
-//        "commonMain" to "org.jetbrains.kotlinx:atomicfu-common:$version",
-//        "jvmMain" to "org.jetbrains.kotlinx:atomicfu:$version",
-//        "jsMain" to "org.jetbrains.kotlinx:atomicfu-js:$version",
-//        "nativeMain" to "org.jetbrains.kotlinx:atomicfu-native:$version"
-//    )
-//}

src/main/kotlin/scientifik/fx.kt

@@ -1,74 +0,0 @@
-package scientifik
-
-import org.apache.tools.ant.taskdefs.condition.Os
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.findByType
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
-
-enum class FXModule(val artifact: String, vararg val dependencies: FXModule) {
-    BASE("javafx-base"),
-    GRAPHICS("javafx-graphics", BASE),
-    CONTROLS("javafx-controls", GRAPHICS, BASE),
-    FXML("javafx-fxml", BASE),
-    MEDIA("javafx-media", GRAPHICS, BASE),
-    SWING("javafx-swing", GRAPHICS, BASE),
-    WEB("javafx-web", CONTROLS, GRAPHICS, BASE)
-}
-
-enum class FXPlatform(val id: String) {
-    WINDOWS("win"),
-    LINUX("linux"),
-    MAC("mac")
-}
-
-val defaultPlatform: FXPlatform = when {
-    Os.isFamily(Os.FAMILY_WINDOWS) -> FXPlatform.WINDOWS
-    Os.isFamily(Os.FAMILY_MAC) -> FXPlatform.MAC
-    Os.isFamily(Os.FAMILY_UNIX) -> FXPlatform.LINUX
-    else -> error("Platform not recognized")
-}
-
-fun KotlinDependencyHandler.addFXDependencies(
-    vararg modules: FXModule,
-    configuration: DependencyConfiguration,
-    version: String = "14",
-    platform: FXPlatform = defaultPlatform
-) {
-    modules.flatMap { it.dependencies.toList() + it }.distinct().forEach {
-        val notation = "org.openjfx:${it.artifact}:$version:${platform.id}"
-        when (configuration) {
-            DependencyConfiguration.API -> api(notation)
-            DependencyConfiguration.IMPLEMENTATION -> implementation(notation)
-            DependencyConfiguration.COMPILE_ONLY -> compileOnly(notation)
-        }
-    }
-}
-
-fun Project.useFx(
-    vararg modules: FXModule,
-    configuration: DependencyConfiguration = DependencyConfiguration.COMPILE_ONLY,
-    version: String = "14",
-    platform: FXPlatform = defaultPlatform
-): Unit = afterEvaluate{
-    pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-        extensions.findByType<KotlinMultiplatformExtension>()?.apply {
-            sourceSets.findByName("jvmMain")?.apply {
-                dependencies {
-                    addFXDependencies(*modules, configuration = configuration, version = version, platform = platform)
-                }
-            }
-        }
-    }
-
-    pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
-        extensions.findByType<KotlinJvmProjectExtension>()?.apply {
-            sourceSets.findByName("main")?.apply {
-                dependencies {
-                    addFXDependencies(*modules, configuration = configuration, version = version, platform = platform)
-                }
-            }
-        }
-    }
-}

src/main/kotlin/scientifik/serialization.kt

@@ -1,89 +0,0 @@
-package scientifik
-
-import Scientifik
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.maven
-import org.gradle.kotlin.dsl.repositories
-
-class SerializationTargets(
-    val sourceSet: DependencySourceSet,
-    val configuration: DependencyConfiguration
-) {
-    fun Project.cbor(
-        version: String = Scientifik.serializationVersion
-    ) {
-        useDependency(
-            "common" to "org.jetbrains.kotlinx:kotlinx-serialization-cbor-common:$version",
-            "jvm" to "org.jetbrains.kotlinx:kotlinx-serialization-cbor:$version",
-            "js" to "org.jetbrains.kotlinx:kotlinx-serialization-cbor-js:$version",
-            "native" to "org.jetbrains.kotlinx:kotlinx-serialization-cbor-native:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-
-    fun Project.protobuf(
-        version: String = Scientifik.serializationVersion
-    ) {
-        useDependency(
-            "common" to "org.jetbrains.kotlinx:kotlinx-serialization-protobuf-common:$version",
-            "jvm" to "org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$version",
-            "js" to "org.jetbrains.kotlinx:kotlinx-serialization-protobuf-js:$version",
-            "native" to "org.jetbrains.kotlinx:kotlinx-serialization-protobuf-native:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-
-    fun Project.xml(
-        version: String = Scientifik.Serialization.xmlVersion
-    ) {
-        repositories {
-            maven("https://dl.bintray.com/pdvrieze/maven")
-        }
-        useDependency(
-            "common" to "net.devrieze:xmlutil-serialization:$version",
-            "jvm" to "net.devrieze:xmlutil-serialization:$version",
-            "js" to "net.devrieze:xmlutil-serialization:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-
-    fun Project.yaml(
-        version: String = Scientifik.Serialization.yamlVersion
-    ) {
-        useDependency(
-            "jvm" to "com.charleskorn.kaml:kaml:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-
-    fun Project.bson(
-        version: String = Scientifik.Serialization.bsonVersion
-    ) {
-        useDependency(
-            "jvm" to "com.github.jershell:kbson:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-}
-
-fun Project.useSerialization(
-    version: String = Scientifik.serializationVersion,
-    sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
-    configuration: DependencyConfiguration = DependencyConfiguration.API,
-    block: SerializationTargets.() -> Unit = {}
-) {
-    plugins.apply("org.jetbrains.kotlin.plugin.serialization")
-    useDependency(
-        "common" to "org.jetbrains.kotlinx:kotlinx-serialization-runtime-common:$version",
-        "jvm" to "org.jetbrains.kotlinx:kotlinx-serialization-runtime:$version",
-        "js" to "org.jetbrains.kotlinx:kotlinx-serialization-runtime-js:$version",
-        "native" to "org.jetbrains.kotlinx:kotlinx-serialization-runtime-native:$version",
-        dependencySourceSet = sourceSet
-    )
-    SerializationTargets(sourceSet, configuration).apply(block)
-}

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

@@ -0,0 +1,547 @@
+package space.kscience.gradle
+
+import org.gradle.api.Project
+import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.plugins.ApplicationPlugin
+import org.gradle.api.plugins.ExtensionAware
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Copy
+import org.gradle.api.tasks.testing.Test
+import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.kotlin.dsl.*
+import org.gradle.language.jvm.tasks.ProcessResources
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
+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.KotlinJsBrowserDsl
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsTargetDsl
+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
+import javax.inject.Inject
+
+public enum class DependencyConfiguration {
+    API,
+    IMPLEMENTATION,
+    COMPILE_ONLY,
+}
+
+public enum class DependencySourceSet(public val setName: String, public val suffix: String) {
+    MAIN("main", "Main"),
+    TEST("test", "Test")
+}
+
+
+/**
+ * Check if this project version has a development tag (`development` property to true, "dev" in the middle or "SNAPSHOT" in the end).
+ */
+public val Project.isInDevelopment: Boolean
+    get() = findProperty("development") == true
+            || "dev" in version.toString()
+            || version.toString().endsWith("SNAPSHOT")
+
+
+private const val defaultJdkVersion = 17
+
+public abstract class KScienceExtension @Inject constructor(public val project: Project): ExtensionAware {
+
+    public val jdkVersionProperty: Property<Int> = project.objects.property<Int>().apply {
+        set(defaultJdkVersion)
+    }
+
+    public var jdkVersion: Int by jdkVersionProperty
+
+    /**
+     * Use coroutines-core with default version or [version]
+     */
+    public fun useCoroutines(
+        version: String = KScienceVersions.coroutinesVersion,
+        sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
+        configuration: DependencyConfiguration = DependencyConfiguration.API,
+    ) {
+        project.useCommonDependency(
+            "org.jetbrains.kotlinx:kotlinx-coroutines-core:$version",
+            dependencySourceSet = sourceSet,
+            dependencyConfiguration = configuration
+        )
+        project.useCommonDependency(
+            "org.jetbrains.kotlinx:kotlinx-coroutines-test:$version",
+            dependencySourceSet = DependencySourceSet.TEST,
+            dependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
+        )
+    }
+
+    /**
+     * Use core serialization library and configure targets
+     */
+    public fun useSerialization(
+        version: String = KScienceVersions.serializationVersion,
+        sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
+        configuration: DependencyConfiguration = DependencyConfiguration.API,
+        block: SerializationTargets.() -> Unit = {},
+    ): Unit = project.run {
+        plugins.apply("org.jetbrains.kotlin.plugin.serialization")
+        val artifactName = if (version.startsWith("0")) {
+            "kotlinx-serialization-runtime"
+        } else {
+            "kotlinx-serialization-core"
+        }
+        useCommonDependency(
+            "org.jetbrains.kotlinx:$artifactName:$version",
+            dependencySourceSet = sourceSet,
+            dependencyConfiguration = configuration
+        )
+        SerializationTargets(sourceSet, configuration).block()
+    }
+
+    public fun useKtor(version: String = KScienceVersions.ktorVersion): Unit = with(project) {
+        pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            configure<KotlinMultiplatformExtension> {
+                sourceSets.findByName("commonMain")?.apply {
+                    dependencies {
+                        api(project.dependencies.platform("io.ktor:ktor-bom:$version"))
+                    }
+                }
+            }
+        }
+        pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            configure<KotlinJvmProjectExtension> {
+                sourceSets.findByName("main")?.apply {
+                    dependencies {
+                        api(project.dependencies.platform("io.ktor:ktor-bom:$version"))
+                    }
+                }
+            }
+        }
+        pluginManager.withPlugin("org.jetbrains.kotlin.js") {
+            configure<KotlinJsProjectExtension> {
+                sourceSets.findByName("main")?.apply {
+                    dependencies {
+                        api(project.dependencies.platform("io.ktor:ktor-bom:$version"))
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Apply jupyter plugin and add entry point for the jupyter library.
+     * If left empty applies a plugin without declaring library producers
+     */
+    public fun jupyterLibrary(vararg pluginClasses: String) {
+        project.plugins.apply("org.jetbrains.kotlin.jupyter.api")
+        project.tasks.named("processJupyterApiResources", JupyterApiResourcesTask::class.java) {
+            libraryProducers = pluginClasses.toList()
+        }
+    }
+
+    /**
+     * Apply common dependencies for different kind of targets
+     */
+    public fun dependencies(sourceSet: String? = null, dependencyBlock: KotlinDependencyHandler.() -> Unit) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            project.configure<KotlinJvmProjectExtension> {
+                sourceSets.getByName(sourceSet ?: "main") {
+                    dependencies(dependencyBlock)
+                }
+            }
+        }
+
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                sourceSets.getByName(sourceSet ?: "commonMain") {
+                    dependencies(dependencyBlock)
+                }
+            }
+        }
+    }
+
+    public fun testDependencies(sourceSet: String? = null, dependencyBlock: KotlinDependencyHandler.() -> Unit) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            project.configure<KotlinJvmProjectExtension> {
+                sourceSets.getByName(sourceSet ?: "test") {
+                    dependencies(dependencyBlock)
+                }
+            }
+        }
+
+
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                sourceSets.getByName(sourceSet ?: "commonTest") {
+                    dependencies(dependencyBlock)
+                }
+            }
+        }
+    }
+
+    public class DefaultSourceSet(public val key: String)
+
+    public fun dependencies(
+        defaultSourceSet: DefaultSourceSet,
+        dependencyBlock: KotlinDependencyHandler.() -> Unit,
+    ): Unit = dependencies(defaultSourceSet.key, dependencyBlock)
+
+
+    /**
+     * 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
+        }
+
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            project.apply<ApplicationPlugin>()
+        }
+
+        project.extensions.findByType<KotlinJsProjectExtension>()?.apply {
+            js(IR) {
+                binaries.executable()
+            }
+        }
+
+        project.extensions.findByType<KotlinMultiplatformExtension>()?.apply {
+            targets.withType<KotlinJsTargetDsl> {
+                binaries.executable()
+            }
+
+            targets.withType<KotlinNativeTarget> {
+                binaries.executable()
+            }
+
+            targets.withType<KotlinWasmJsTargetDsl> {
+                binaries.executable()
+            }
+        }
+    }
+
+    /**
+     * Add context receivers to this project and all subprojects
+     */
+    public fun useContextReceivers() {
+        project.tasks.withType<KotlinCompile> {
+            compilerOptions{
+              freeCompilerArgs.add("-Xcontext-receivers")
+            }
+        }
+    }
+
+    public operator fun DefaultSourceSet.invoke(dependencyBlock: KotlinDependencyHandler.() -> Unit) {
+        dependencies(this, dependencyBlock)
+    }
+
+    public val commonMain: DefaultSourceSet get() = DefaultSourceSet("commonMain")
+    public val commonTest: DefaultSourceSet get() = DefaultSourceSet("commonTest")
+
+    public val jvmMain: DefaultSourceSet get() = DefaultSourceSet("jvmMain")
+    public val jvmTest: DefaultSourceSet get() = DefaultSourceSet("jvmTest")
+    public val jsMain: DefaultSourceSet get() = DefaultSourceSet("jsMain")
+    public val jsTest: DefaultSourceSet get() = DefaultSourceSet("jsTest")
+    public val nativeMain: DefaultSourceSet get() = DefaultSourceSet("nativeMain")
+    public val nativeTest: DefaultSourceSet get() = DefaultSourceSet("nativeTest")
+    public val wasmJsMain: DefaultSourceSet get() = DefaultSourceSet("wasmJsMain")
+    public val wasmJsTest: DefaultSourceSet get() = DefaultSourceSet("wasmJsTest")
+
+}
+
+public enum class KotlinNativePreset {
+    linuxX64,
+    mingwX64,
+    macosX64,
+    macosArm64,
+    iosX64,
+    iosArm64,
+    iosSimulatorArm64,
+}
+
+public data class KScienceNativeTarget(
+    val preset: KotlinNativePreset,
+    val targetName: String = preset.name,
+    val targetConfiguration: KotlinNativeTarget.() -> Unit = { },
+) {
+    public companion object {
+        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.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(private val project: Project) {
+
+
+    internal companion object {
+        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
+                )
+
+                hostOs == "Mac OS X" -> listOf(
+                    KScienceNativeTarget.macosX64,
+                    KScienceNativeTarget.macosArm64,
+                    KScienceNativeTarget.iosX64,
+                    KScienceNativeTarget.iosArm64,
+                    KScienceNativeTarget.iosSimulatorArm64,
+                )
+
+                hostOs == "Linux" -> listOf(KScienceNativeTarget.linuxX64)
+
+                else -> {
+                    emptyList()
+                }
+            }.associateBy { it.preset }
+        }
+    }
+
+
+    internal var targets: Map<KotlinNativePreset, KScienceNativeTarget> = defaultNativeTargets(project)
+
+
+    /**
+     * Replace all targets
+     */
+    public fun setTargets(vararg target: KScienceNativeTarget) {
+        targets = target.associateBy { it.preset }
+    }
+
+    /**
+     * Add a native target
+     */
+    public fun target(target: KScienceNativeTarget) {
+        targets += target.preset to target
+    }
+
+    public fun target(
+        preset: KotlinNativePreset,
+        targetName: String = preset.name,
+        targetConfiguration: KotlinNativeTarget.() -> Unit = { },
+    ): Unit = target(KScienceNativeTarget(preset, targetName, targetConfiguration))
+}
+
+public abstract class KScienceMppExtension @Inject constructor(project: Project) : KScienceExtension(project) {
+
+    /**
+     * Enable jvm target
+     */
+    public fun jvm(block: KotlinJvmTarget.() -> Unit = {}) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                jvm {
+                    @OptIn(ExperimentalKotlinGradlePluginApi::class)
+                    compilerOptions{
+                        freeCompilerArgs.addAll(defaultKotlinJvmArgs)
+                    }
+                    block()
+                }
+                sourceSets {
+                    getByName("jvmTest") {
+                        dependencies {
+                            implementation(kotlin("test-junit5"))
+                            implementation("org.junit.jupiter:junit-jupiter:${KScienceVersions.junit}")
+                        }
+                    }
+                }
+                jvmToolchain {
+                    languageVersion.set(jdkVersionProperty.map { JavaLanguageVersion.of(it) })
+                }
+            }
+            project.tasks.withType<Test> {
+                useJUnitPlatform()
+            }
+        }
+    }
+
+    /**
+     * Enable JS-IR (browser) target.
+     */
+    public fun js(block: KotlinJsTargetDsl.() -> Unit = {}) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                js(IR) {
+                    browser()
+                    useEsModules()
+                    block()
+                }
+                sourceSets {
+                    getByName("jsTest") {
+                        dependencies {
+                            implementation(kotlin("test-js"))
+                        }
+                    }
+                }
+            }
+            (project.tasks.findByName("jsProcessResources") as? Copy)?.apply {
+                fromJsDependencies("jsRuntimeClasspath")
+            }
+        }
+    }
+
+    /**
+     * Add Wasm/Js target
+     */
+    @OptIn(ExperimentalWasmDsl::class)
+    public fun wasm(block: KotlinWasmJsTargetDsl.() -> Unit = {}) {
+
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                wasmJs {
+                    browser {
+                        testTask {
+                            useKarma {
+                                useChromeHeadless()
+                            }
+                        }
+                    }
+                    block()
+                }
+                sourceSets {
+                    getByName("wasmJsTest") {
+                        dependencies {
+                            implementation(kotlin("test-wasm-js"))
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public fun jvmAndJs() {
+        jvm()
+        js()
+    }
+
+    /**
+     * Jvm and Js source sets including copy of Js bundle into JVM resources
+     */
+    public fun fullStack(
+        bundleName: String = "js/bundle.js",
+        development: Boolean = false,
+        jvmConfig: KotlinJvmTarget.() -> Unit = {},
+        jsConfig: KotlinJsTargetDsl.() -> Unit = {},
+        browserConfig: KotlinJsBrowserDsl.() -> Unit = {},
+    ) {
+        js {
+            browser {
+                commonWebpackConfig{
+                    outputFileName = bundleName
+                }
+                browserConfig()
+            }
+            useEsModules()
+            jsConfig()
+            binaries.executable()
+        }
+        jvm {
+            val processResourcesTaskName =
+                compilations[KotlinCompilation.MAIN_COMPILATION_NAME].processResourcesTaskName
+
+
+            val jsBrowserDistribution = project.tasks.getByName(
+                if (development) "jsBrowserDevelopmentExecutableDistribution" else "jsBrowserDistribution"
+            )
+
+            project.tasks.getByName<ProcessResources>(processResourcesTaskName) {
+                duplicatesStrategy = DuplicatesStrategy.WARN
+                dependsOn(jsBrowserDistribution)
+                from(jsBrowserDistribution)
+            }
+            jvmConfig()
+        }
+    }
+
+    /**
+     * Enable all supported native targets
+     */
+    public fun native(block: KScienceNativeConfiguration.() -> Unit = {}): Unit = with(project) {
+        val nativeConfiguration = KScienceNativeConfiguration(this).apply(block)
+        pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            configure<KotlinMultiplatformExtension> {
+                nativeConfiguration.targets.values.forEach { nativeTarget ->
+                    when (nativeTarget.preset) {
+                        KotlinNativePreset.linuxX64 -> linuxX64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
+
+                        KotlinNativePreset.mingwX64 -> mingwX64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
+
+                        KotlinNativePreset.macosX64 -> macosX64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
+
+                        KotlinNativePreset.macosArm64 -> macosArm64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
+
+                        KotlinNativePreset.iosX64 -> iosX64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
+
+                        KotlinNativePreset.iosArm64 -> iosArm64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
+
+                        KotlinNativePreset.iosSimulatorArm64 -> iosSimulatorArm64(
+                            nativeTarget.targetName,
+                            nativeTarget.targetConfiguration
+                        )
+                    }
+                }
+                applyDefaultHierarchyTemplate()
+            }
+        }
+    }
+}
+
+
+internal inline fun <reified T : KScienceExtension> Project.registerKScienceExtension():T {
+//    extensions.findByType<T>()?.let { return it }
+//    return constructor(this).also {
+//        extensions.add("kscience", it)
+//    }
+
+    return extensions.create("kscience", T::class.java)
+}

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

@@ -0,0 +1,59 @@
+package space.kscience.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.tasks.testing.Test
+import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+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 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 {
+            logger.info("Kotlin JVM plugin is already present")
+        }
+        val extension = registerKScienceExtension<KScienceExtension>()
+
+        //logger.info("Applying KScience configuration for JVM project")
+        configure<KotlinJvmProjectExtension> {
+            sourceSets.all {
+                languageSettings.applySettings()
+                compilerOptions{
+                    freeCompilerArgs.addAll(defaultKotlinJvmArgs)
+                }
+            }
+
+            sourceSets["test"].apply {
+                dependencies {
+                    implementation(kotlin("test-junit5"))
+                    implementation("org.junit.jupiter:junit-jupiter:${KScienceVersions.junit}")
+                }
+            }
+
+            if (explicitApi == null) explicitApiWarning()
+            jvmToolchain {
+                languageVersion.set(extension.jdkVersionProperty.map { JavaLanguageVersion.of(it) })
+            }
+        }
+
+        tasks.withType<Test> {
+            useJUnitPlatform()
+        }
+
+        // apply dokka for all projects
+        if (!plugins.hasPlugin("org.jetbrains.dokka")) {
+            apply<DokkaPlugin>()
+        }
+    }
+
+}

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

@@ -0,0 +1,66 @@
+package space.kscience.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.invoke
+import org.jetbrains.dokka.gradle.DokkaPlugin
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+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 {
+        if (!plugins.hasPlugin("org.jetbrains.kotlin.multiplatform")) {
+            //apply<KotlinMultiplatformPlugin>() for some reason it does not work
+            plugins.apply("org.jetbrains.kotlin.multiplatform")
+        } else {
+            logger.info("Kotlin MPP plugin is already present")
+        }
+
+        val kscience = registerKScienceExtension<KScienceMppExtension>()
+
+        configure<KotlinMultiplatformExtension> {
+            sourceSets {
+                getByName("commonMain") {
+                    dependencies {
+                        api(project.dependencies.platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:${KScienceVersions.jsBom}"))
+                    }
+                }
+                getByName("commonTest") {
+                    dependencies {
+                        implementation(kotlin("test"))
+                        implementation(kotlin("test-annotations-common"))
+                    }
+                }
+                all {
+                    languageSettings.applySettings()
+                }
+            }
+            @OptIn(ExperimentalKotlinGradlePluginApi::class)
+            compilerOptions {
+                freeCompilerArgs.addAll(defaultKotlinCommonArgs)
+            }
+
+            if (explicitApi == null) explicitApiWarning()
+
+            //pass compose extension inside kscience extensions to make it available inside kscience block
+            plugins.withId("org.jetbrains.compose") {
+                kscience.extensions.add(
+                    "compose",
+                    (this@configure as org.gradle.api.plugins.ExtensionAware).extensions.getByName("compose")
+                )
+            }
+
+        }
+
+
+        // apply dokka for all projects
+        if (!plugins.hasPlugin("org.jetbrains.dokka")) {
+            apply<DokkaPlugin>()
+        }
+    }
+}

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

@@ -0,0 +1,250 @@
+package space.kscience.gradle
+
+import kotlinx.validation.ApiValidationExtension
+import kotlinx.validation.BinaryCompatibilityValidatorPlugin
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.publish.maven.MavenPom
+import org.gradle.api.publish.maven.tasks.AbstractPublishToMaven
+import org.gradle.kotlin.dsl.*
+import org.gradle.plugins.signing.Sign
+import org.jetbrains.changelog.ChangelogPlugin
+import org.jetbrains.changelog.ChangelogPluginExtension
+import org.jetbrains.dokka.gradle.AbstractDokkaTask
+import org.jetbrains.dokka.gradle.DokkaPlugin
+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.
+ */
+public class KSciencePublishingExtension(public val project: Project) {
+    private var isVcsInitialized = false
+
+    /**
+     * Configures Git repository (sources) for the publication.
+     *
+     * @param vcsUrl URL of the repository's web interface.
+     * @param connectionUrl URL of the Git repository.
+     * @param developerConnectionUrl URL of the Git repository for developers.
+     */
+    public fun pom(
+        vcsUrl: String,
+        connectionUrl: String? = null,
+        developerConnectionUrl: String? = connectionUrl,
+        connectionPrefix: String = "scm:git:",
+        pomConfig: MavenPom.() -> Unit,
+    ) {
+        if (!isVcsInitialized) {
+            project.setupPublication {
+                url.set(vcsUrl)
+
+                scm {
+                    url.set(vcsUrl)
+                    connectionUrl?.let { connection.set("$connectionPrefix$it") }
+                    developerConnectionUrl?.let { developerConnection.set("$connectionPrefix$it") }
+                }
+                pomConfig()
+            }
+
+            isVcsInitialized = true
+        }
+    }
+
+    /**
+     * Add a repository with [repositoryName]. Uses "publishing.$repositoryName.user" and "publishing.$repositoryName.token"
+     * properties pattern to store user and token
+     */
+    public fun repository(
+        repositoryName: String,
+        url: String,
+    ) {
+        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.
+
+     */
+    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(sonatypeRoot)
+    }
+}
+
+/**
+ * Applies third-party plugins (Dokka, Changelog, binary compatibility validator); configures Maven publishing, README
+ * generation.
+ */
+public open class KScienceProjectPlugin : Plugin<Project> {
+    override fun apply(target: Project): Unit = target.run {
+        apply<ChangelogPlugin>()
+        apply<DokkaPlugin>()
+        apply<BinaryCompatibilityValidatorPlugin>()
+
+        allprojects {
+            repositories {
+                mavenCentral()
+                maven("https://repo.kotlin.link")
+                google()
+            }
+
+            // Workaround for https://github.com/gradle/gradle/issues/15568
+            tasks.withType<AbstractPublishToMaven>().configureEach {
+                mustRunAfter(tasks.withType<Sign>())
+            }
+        }
+
+        afterEvaluate {
+            if (isInDevelopment) {
+                configure<ApiValidationExtension> {
+                    validationDisabled = true
+                }
+            } else {
+                configure<ChangelogPluginExtension> {
+                    version.set(project.version.toString())
+                }
+            }
+        }
+
+        val rootReadmeExtension = KScienceReadmeExtension(this)
+        val ksciencePublish = KSciencePublishingExtension(this)
+        extensions.add("ksciencePublish", ksciencePublish)
+        extensions.add("readme", rootReadmeExtension)
+
+        //Add readme generators to individual subprojects
+        subprojects {
+            val readmeExtension = KScienceReadmeExtension(this)
+            extensions.add("readme", readmeExtension)
+
+            tasks.create("generateReadme") {
+                group = "documentation"
+                description = "Generate a README file if stub is present"
+
+                inputs.property("extension", readmeExtension)
+
+                if (readmeExtension.readmeTemplate.exists()) {
+                    inputs.file(readmeExtension.readmeTemplate)
+                }
+                readmeExtension.inputFiles.forEach {
+                    if (it.exists()) {
+                        inputs.file(it)
+                    }
+                }
+
+                val readmeFile = this@subprojects.file("README.md")
+                outputs.file(readmeFile)
+
+                doLast {
+                    val readmeString = readmeExtension.readmeString()
+                    if (readmeString != null) {
+                        readmeFile.writeText(readmeString)
+                    }
+                }
+            }
+
+//            tasks.withType<AbstractDokkaTask> {
+//                dependsOn(generateReadme)
+//            }
+        }
+
+        val generateReadme by tasks.creating {
+            group = "documentation"
+            description = "Generate a README file and a feature matrix if stub is present"
+
+            subprojects {
+                tasks.findByName("generateReadme")?.let {
+                    dependsOn(it)
+                }
+            }
+
+            inputs.property("extension", rootReadmeExtension)
+
+            if (rootReadmeExtension.readmeTemplate.exists()) {
+                inputs.file(rootReadmeExtension.readmeTemplate)
+            }
+
+            rootReadmeExtension.inputFiles.forEach {
+                if (it.exists()) {
+                    inputs.file(it)
+                }
+            }
+
+            val readmeFile = project.file("README.md")
+            outputs.file(readmeFile)
+
+            doLast {
+//                val projects = subprojects.associate {
+//                    val normalizedPath = it.path.replaceFirst(":","").replace(":","/")
+//                    it.path.replace(":","/") to it.extensions.findByType<KScienceReadmeExtension>()
+//                }
+
+                if (rootReadmeExtension.readmeTemplate.exists()) {
+
+                    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)")
+                                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)
+                                }
+                            }
+                        }
+                    }
+
+                    rootReadmeExtension.property("modules", modulesString)
+
+                    rootReadmeExtension.readmeString()?.let {
+                        readmeFile.writeText(it)
+                    }
+                }
+
+            }
+        }
+
+        tasks.withType<AbstractDokkaTask> {
+            dependsOn(generateReadme)
+        }
+
+        tasks.create("version") {
+            group = "publishing"
+            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())
+            }
+        }
+
+        // Disable API validation for snapshots
+        if (isInDevelopment) {
+            extensions.findByType<ApiValidationExtension>()?.apply {
+                validationDisabled = true
+                logger.warn("API validation is disabled for snapshot or dev version")
+            }
+        }
+
+        plugins.withType<YarnPlugin>() {
+            rootProject.configure<YarnRootExtension> {
+                lockFileDirectory = rootDir.resolve("gradle")
+                yarnLockMismatchReport = YarnLockMismatchReport.WARNING
+            }
+        }
+    }
+
+    public companion object {
+        public const val DEPLOY_GROUP: String = "deploy"
+    }
+}

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

@@ -0,0 +1,227 @@
+package space.kscience.gradle
+
+import freemarker.cache.StringTemplateLoader
+import freemarker.template.Configuration
+import freemarker.template.Template
+import freemarker.template.TemplateNotFoundException
+import kotlinx.html.TagConsumer
+import kotlinx.html.div
+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
+import kotlin.collections.component2
+import kotlin.collections.set
+
+public enum class Maturity {
+    PROTOTYPE,
+    EXPERIMENTAL,
+    DEVELOPMENT,
+    STABLE,
+    DEPRECATED
+}
+
+private fun Template.processToString(args: Map<String, Any?>): String {
+    val writer = StringWriter()
+    process(args, writer)
+    return writer.toString()
+}
+
+
+public class KScienceReadmeExtension(public val project: Project) {
+    public var description: String? = null
+        get() = field ?: project.description
+
+    public var maturity: Maturity = Maturity.EXPERIMENTAL
+        set(value) {
+            field = value
+            val projectName = project.name
+            if (value == Maturity.EXPERIMENTAL || value == Maturity.PROTOTYPE) {
+                project.rootProject.run {
+                    plugins.withId("org.jetbrains.kotlinx.binary-compatibility-validator") {
+                        extensions.findByType<ApiValidationExtension>()?.apply {
+                            project.logger.warn("$value project $projectName is excluded from API validation")
+                            ignoredProjects.add(projectName)
+                        }
+                    }
+                }
+            }
+        }
+
+    /**
+     * If true, use default templates provided by plugin if override is not defined
+     */
+    public var useDefaultReadmeTemplate: Boolean = true
+
+    /**
+     * Use this template file if it is provided, otherwise use default template
+     */
+    public var readmeTemplate: File = project.file("docs/README-TEMPLATE.md")
+        set(value) {
+            field = value
+            if (value.exists()) {
+                fmLoader.putTemplate("readme", value.readText())
+            }
+        }
+
+    private val fmLoader = StringTemplateLoader().apply {
+        putTemplate(
+            "artifact",
+            this@KScienceReadmeExtension.javaClass.getResource("/templates/ARTIFACT-TEMPLATE.md")!!.readText()
+        )
+        if (readmeTemplate.exists()) {
+            putTemplate("readme", readmeTemplate.readText())
+        } else if (useDefaultReadmeTemplate) {
+            putTemplate(
+                "readme",
+                this@KScienceReadmeExtension.javaClass.getResource("/templates/README-TEMPLATE.md")!!.readText()
+            )
+        }
+    }
+
+    private val fmCfg = Configuration(Configuration.VERSION_2_3_31).apply {
+        defaultEncoding = "UTF-8"
+        templateLoader = fmLoader
+    }
+
+    public data class Feature(val id: String, val description: String, val ref: String?, val name: String = id)
+
+    public val features: MutableList<Feature> = mutableListOf()
+
+    /**
+     * 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,
+        name: String = id,
+        htmlBuilder: TagConsumer<String>.() -> Unit,
+    ) {
+        val text = createHTML().apply {
+            div("readme-feature") {
+                htmlBuilder()
+            }
+        }.finalize()
+        features += Feature(id, text, ref, name)
+    }
+
+    private val properties: MutableMap<String, () -> Any?> = mutableMapOf(
+        "name" to { project.name },
+        "group" to { project.group },
+        "version" to { project.version },
+        "description" to { project.description ?: "" },
+        "features" to { featuresString() },
+        "published" to { project.plugins.findPlugin("maven-publish") != null },
+        "artifact" to {
+            val projectProperties = mapOf(
+                "name" to project.name,
+                "group" to project.group,
+                "version" to project.version
+            )
+            fmCfg.getTemplate("artifact").processToString(projectProperties)
+        }
+    )
+
+    public fun getPropertyValues(): Map<String, Any?> = properties.mapValues { (_, value) -> value() }
+
+    public fun property(key: String, value: Any?) {
+        properties[key] = { value }
+    }
+
+    public fun property(key: String, value: () -> Any?) {
+        properties[key] = value
+    }
+
+    public fun propertyByTemplate(key: String, templateString: String) {
+        //need to freeze it, otherwise values could change
+        val actual = getPropertyValues()
+        fmLoader.putTemplate(key, templateString)
+        val template = fmCfg.getTemplate(key)
+
+        properties[key] = { template.processToString(actual) }
+    }
+
+    /**
+     * Files that are use in readme generation
+     */
+    internal val inputFiles = ArrayList<File>()
+
+    public fun propertyByTemplate(key: String, templateFile: File) {
+        //need to freeze it, otherwise values could change
+        val actual = getPropertyValues()
+        fmLoader.putTemplate(key, templateFile.readText())
+        val template: Template = fmCfg.getTemplate(key)
+
+        properties[key] = { template.processToString(actual) }
+        inputFiles += templateFile
+    }
+
+    /**
+     * Generate a markdown string listing features
+     */
+    internal fun featuresString(itemPrefix: String = " - ", pathPrefix: String = ""): String = buildString {
+        features.forEach {
+            appendLine("$itemPrefix[${it.name}]($pathPrefix${it.ref ?: "#"}) : ${it.description}")
+        }
+    }
+
+    /**
+     * Generate a readme string from the template
+     */
+    public fun readmeString(): String? = try {
+        fmCfg.getTemplate("readme").processToString(getPropertyValues())
+    } catch (ex: TemplateNotFoundException) {
+        project.logger.warn("Template with name ${ex.templateName} not found in ${project.name}")
+        null
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as KScienceReadmeExtension
+
+        if (project != other.project) return false
+        if (maturity != other.maturity) return false
+        if (useDefaultReadmeTemplate != other.useDefaultReadmeTemplate) return false
+        if (readmeTemplate != other.readmeTemplate) return false
+        if (fmLoader != other.fmLoader) return false
+        if (fmCfg != other.fmCfg) return false
+        if (features != other.features) return false
+        if (properties != other.properties) return false
+        if (inputFiles != other.inputFiles) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = project.hashCode()
+        result = 31 * result + maturity.hashCode()
+        result = 31 * result + useDefaultReadmeTemplate.hashCode()
+        result = 31 * result + readmeTemplate.hashCode()
+        result = 31 * result + fmLoader.hashCode()
+        result = 31 * result + fmCfg.hashCode()
+        result = 31 * result + features.hashCode()
+        result = 31 * result + properties.hashCode()
+        result = 31 * result + inputFiles.hashCode()
+        return result
+    }
+
+
+}

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

@@ -0,0 +1,30 @@
+package space.kscience.gradle
+
+
+import org.tomlj.Toml
+
+/**
+ * Build constants
+ */
+public object KScienceVersions {
+
+    private val toml by lazy {
+        Toml.parse(javaClass.getResource("/libs.versions.toml")!!.readText())
+    }
+
+    public val kotlinVersion: String get() = toml.getString("versions.kotlin")!!
+    public val kotlinxNodeVersion: String get() = toml.getString("versions.kotlinx-nodejs")!!
+    public val coroutinesVersion: String get() = toml.getString("versions.kotlinx-coroutines")!!
+    public val serializationVersion: String get() = toml.getString("versions.kotlinx-serialization")!!
+    public val atomicVersion: String get() = toml.getString("versions.atomicfu")!!
+    public val ktorVersion: String get() = toml.getString("versions.ktor")!!
+    public val htmlVersion: String get() = toml.getString("versions.kotlinx-html")!!
+    public val dateTimeVersion: String get() = toml.getString("versions.kotlinx-datetime")!!
+    public val jsBom: String get() = toml.getString("versions.jsBom")!!
+    internal val junit: String get() = toml.getString("versions.junit")!!
+
+    public object Serialization {
+        public val xmlVersion: String get() = toml.getString("versions.xmlutil")!!
+        public val yamlKtVersion: String get() = toml.getString("versions.yamlkt")!!
+    }
+}

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

@@ -0,0 +1,49 @@
+package space.kscience.gradle
+
+import org.gradle.api.Project
+import space.kscience.gradle.internal.useCommonDependency
+
+public class SerializationTargets(
+    public val sourceSet: DependencySourceSet,
+    public val configuration: DependencyConfiguration,
+) {
+    public fun Project.json(
+        version: String = KScienceVersions.serializationVersion,
+    ): Unit = useCommonDependency(
+        "org.jetbrains.kotlinx:kotlinx-serialization-json:$version",
+        dependencySourceSet = sourceSet,
+        dependencyConfiguration = configuration,
+    )
+
+    public fun Project.cbor(
+        version: String = KScienceVersions.serializationVersion,
+    ): Unit = useCommonDependency(
+        "org.jetbrains.kotlinx:kotlinx-serialization-cbor:$version",
+        dependencySourceSet = sourceSet,
+        dependencyConfiguration = configuration,
+    )
+
+    public fun Project.protobuf(
+        version: String = KScienceVersions.serializationVersion,
+    ): Unit = useCommonDependency(
+        "org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$version",
+        dependencySourceSet = sourceSet,
+        dependencyConfiguration = configuration,
+    )
+
+    public fun Project.xml(
+        version: String = KScienceVersions.Serialization.xmlVersion,
+    ): Unit = useCommonDependency(
+        "io.github.pdvrieze.xmlutil:serialization:$version",
+        dependencySourceSet = sourceSet,
+        dependencyConfiguration = configuration,
+    )
+
+    public fun Project.yamlKt(
+        version: String = KScienceVersions.Serialization.yamlKtVersion,
+    ): Unit = useCommonDependency(
+        "net.mamoe.yamlkt:yamlkt:$version",
+        dependencySourceSet = sourceSet,
+        dependencyConfiguration = configuration,
+    )
+}

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

@@ -0,0 +1,60 @@
+package space.kscience.gradle.internal
+
+import org.gradle.api.artifacts.ProjectDependency
+import org.gradle.api.tasks.Copy
+import org.gradle.kotlin.dsl.get
+import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
+import space.kscience.gradle.KScienceVersions
+
+
+internal val defaultKotlinJvmArgs: List<String> = listOf(
+    "-Xjvm-default=all"
+)
+
+internal val defaultKotlinCommonArgs: List<String> = listOf(
+    "-Xexpect-actual-classes"
+)
+
+internal fun resolveKotlinVersion(): KotlinVersion {
+    val (major, minor, patch) = KScienceVersions.kotlinVersion.split(".", "-")
+    return KotlinVersion(major.toInt(), minor.toInt(), patch.toInt())
+}
+
+internal fun LanguageSettingsBuilder.applySettings(
+    kotlinVersion: KotlinVersion = resolveKotlinVersion(),
+) {
+    val versionString = "${kotlinVersion.major}.${kotlinVersion.minor}"
+    languageVersion = versionString
+    apiVersion = versionString
+    progressiveMode = true
+
+
+    optIn("kotlin.RequiresOptIn")
+    optIn("kotlin.ExperimentalUnsignedTypes")
+    optIn("kotlin.ExperimentalStdlibApi")
+    optIn("kotlin.time.ExperimentalTime")
+    optIn("kotlin.contracts.ExperimentalContracts")
+    optIn("kotlin.js.ExperimentalJsExport")
+}
+
+internal fun Copy.fromJsDependencies(configurationName: String) = project.run {
+    val configuration = configurations[configurationName]
+        ?: error("Configuration with name $configurationName could not be resolved.")
+    val projectDeps = configuration.allDependencies.filterIsInstance<ProjectDependency>().map {
+        it.dependencyProject
+    }
+    projectDeps.forEach { dep ->
+        dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            dep.tasks.findByName("jsProcessResources")?.let { task ->
+                dependsOn(task)
+                from(task)
+            }
+        }
+        dep.pluginManager.withPlugin("org.jetbrains.kotlin.js") {
+            dep.tasks.findByName("processResources")?.let { task ->
+                dependsOn(task)
+                from(task)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,119 @@
+package space.kscience.gradle.internal
+
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.invoke
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import space.kscience.gradle.DependencyConfiguration
+import space.kscience.gradle.DependencySourceSet
+
+internal fun Project.useDependency(
+    vararg pairs: Pair<String, String>,
+    dependencySourceSet: DependencySourceSet = DependencySourceSet.MAIN,
+    dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
+) {
+    pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+        configure<KotlinMultiplatformExtension> {
+            sourceSets {
+                pairs.forEach { (target, dep) ->
+                    val name = target + dependencySourceSet.suffix
+                    findByName(name)?.apply {
+                        dependencies {
+                            when (dependencyConfiguration) {
+                                DependencyConfiguration.API -> api(dep)
+                                DependencyConfiguration.IMPLEMENTATION -> implementation(dep)
+                                DependencyConfiguration.COMPILE_ONLY -> compileOnly(dep)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    pairs.find { it.first == "jvm" }?.let { dep ->
+        pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            configure<KotlinJvmProjectExtension> {
+                sourceSets.findByName(dependencySourceSet.setName)?.apply {
+                    dependencies.apply {
+                        val configurationName = when (dependencyConfiguration) {
+                            DependencyConfiguration.API -> apiConfigurationName
+                            DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
+                            DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
+                        }
+                        add(configurationName, dep.second)
+                    }
+                }
+            }
+        }
+    }
+
+    pairs.find { it.first == "js" }?.let { dep ->
+        pluginManager.withPlugin("org.jetbrains.kotlin.js") {
+            configure<KotlinJsProjectExtension> {
+                sourceSets.findByName(dependencySourceSet.setName)?.apply {
+                    dependencies.apply {
+                        val configurationName = when (dependencyConfiguration) {
+                            DependencyConfiguration.API -> apiConfigurationName
+                            DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
+                            DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
+                        }
+                        add(configurationName, dep.second)
+                    }
+                }
+            }
+        }
+    }
+}
+
+internal fun Project.useCommonDependency(
+    dep: String,
+    dependencySourceSet: DependencySourceSet = DependencySourceSet.MAIN,
+    dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
+): Unit = pluginManager.run {
+    withPlugin("org.jetbrains.kotlin.multiplatform") {
+        configure<KotlinMultiplatformExtension> {
+            sourceSets.findByName("common${dependencySourceSet.suffix}")?.apply {
+                dependencies {
+                    when (dependencyConfiguration) {
+                        DependencyConfiguration.API -> api(dep)
+                        DependencyConfiguration.IMPLEMENTATION -> implementation(dep)
+                        DependencyConfiguration.COMPILE_ONLY -> compileOnly(dep)
+                    }
+                }
+            }
+        }
+    }
+
+    withPlugin("org.jetbrains.kotlin.jvm") {
+        configure<KotlinJvmProjectExtension> {
+            sourceSets.findByName(dependencySourceSet.setName)?.apply {
+                dependencies.apply {
+                    val configurationName = when (dependencyConfiguration) {
+                        DependencyConfiguration.API -> apiConfigurationName
+                        DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
+                        DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
+                    }
+                    add(configurationName, dep)
+                }
+            }
+        }
+    }
+
+    withPlugin("org.jetbrains.kotlin.js") {
+        configure<KotlinJsProjectExtension> {
+            sourceSets.findByName(dependencySourceSet.setName)?.apply {
+                dependencies.apply {
+                    val configurationName = when (dependencyConfiguration) {
+                        DependencyConfiguration.API -> apiConfigurationName
+                        DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
+                        DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
+                    }
+                    add(configurationName, dep)
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,130 @@
+package space.kscience.gradle.internal
+
+import org.gradle.api.Project
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPom
+import org.gradle.api.publish.maven.MavenPublication
+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.KotlinJvmProjectExtension
+import space.kscience.gradle.isInDevelopment
+
+internal fun Project.requestPropertyOrNull(propertyName: String): String? = findProperty(propertyName) as? String
+    ?: System.getenv(propertyName)
+
+internal fun Project.requestProperty(propertyName: String): String = requestPropertyOrNull(propertyName)
+    ?: error("Property $propertyName not defined")
+
+
+internal fun Project.setupPublication(mavenPomConfiguration: MavenPom.() -> Unit = {}) = allprojects {
+    plugins.withId("maven-publish") {
+        configure<PublishingExtension> {
+
+            plugins.withId("org.jetbrains.kotlin.jvm") {
+                val kotlin = extensions.findByType<KotlinJvmProjectExtension>()!!
+
+                val sourcesJar by tasks.creating(Jar::class) {
+                    archiveClassifier.set("sources")
+                    kotlin.sourceSets.forEach {
+                        from(it.kotlin)
+                    }
+                }
+
+                publications.create<MavenPublication>("jvm") {
+                    from(project.components["java"])
+
+                    artifact(sourcesJar)
+                }
+            }
+
+            // Process each publication we have in this project
+            publications.withType<MavenPublication> {
+                pom {
+                    name.set(project.name)
+                    description.set(project.description ?: project.name)
+
+                    scm {
+                        tag.set(project.version.toString())
+                    }
+
+                    mavenPomConfiguration()
+                }
+            }
+
+            plugins.withId("org.jetbrains.dokka") {
+                val dokkaJar by tasks.creating(Jar::class) {
+                    group = "documentation"
+                    archiveClassifier.set("javadoc")
+                    from(tasks.findByName("dokkaHtml"))
+                }
+                publications.withType<MavenPublication> {
+                    artifact(dokkaJar)
+                }
+            }
+
+            if (requestPropertyOrNull("publishing.signing.id") != null || requestPropertyOrNull("signing.gnupg.keyName") != null) {
+
+                if (!plugins.hasPlugin("signing")) {
+                    apply<SigningPlugin>()
+                }
+
+                extensions.configure<SigningExtension>("signing") {
+                    val signingId: String? = requestPropertyOrNull("publishing.signing.id")
+                    if (!signingId.isNullOrBlank()) {
+                        val signingKey: String = requestProperty("publishing.signing.key")
+                        val signingPassphrase: String = requestProperty("publishing.signing.passPhrase")
+
+                        // if a key is provided, use it
+                        useInMemoryPgpKeys(signingId, signingKey, signingPassphrase)
+                    } // else use agent signing
+                    sign(publications)
+                }
+            } else {
+                logger.warn("Signing information is not provided. Skipping artefact signing.")
+            }
+        }
+    }
+}
+
+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")
+
+    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 $repositoryName publishing to project [${project.name}]")
+
+                repositories.maven {
+                    name = repositoryName
+                    url = uri(urlString)
+
+                    credentials {
+                        username = user
+                        password = token
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+internal fun Project.addSonatypePublishing(sonatypeRoot: String) {
+    if (isInDevelopment) {
+        logger.info("Sonatype publishing skipped for development version")
+    } else {
+        addPublishing("sonatype", "$sonatypeRoot/service/local/staging/deploy/maven2")
+    }
+}

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

@@ -0,0 +1,24 @@
+package space.kscience.gradle
+
+import org.gradle.api.publish.maven.MavenPom
+
+public fun MavenPom.useApache2Licence(){
+    licenses {
+        license {
+            name.set("The Apache Software License, Version 2.0")
+            url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
+            distribution.set("repo")
+        }
+    }
+}
+
+public fun MavenPom.useSPCTeam(){
+    developers {
+        developer {
+            id.set("SPC")
+            name.set("Scientific programming centre")
+            organization.set("SPC")
+            organizationUrl.set("https://sciprog.center/")
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+## Artifact:
+
+The Maven coordinates of this project are `${group}:${name}:${version}`.
+
+**Gradle Kotlin DSL:**
+```kotlin
+repositories {
+    maven("https://repo.kotlin.link")
+    mavenCentral()
+}
+
+dependencies {
+    implementation("${group}:${name}:${version}")
+}
+```

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

@@ -0,0 +1,15 @@
+# Module ${name}
+
+${description}
+
+<#if features?has_content>
+## Features
+
+${features}
+
+</#if>
+<#if published>
+## Usage
+
+${artifact}
+</#if>

src/test/kotlin/TestVersions.kt

@@ -0,0 +1,9 @@
+import org.junit.jupiter.api.Test
+import space.kscience.gradle.KScienceVersions
+
+class TestPlugins {
+    @Test
+    fun testVersions() {
+        println(KScienceVersions.coroutinesVersion)
+    }
+}