tessl/maven-org-jetbrains-kotlin--kotlin-gradle-plugin

Official Gradle plugin for the Kotlin programming language that provides comprehensive build support for Kotlin projects including compilation, multiplatform development, Android integration, and native development capabilities

—

Pending

Overview

Eval results

Files

Dependency Management

Name: tessl/maven-org-jetbrains-kotlin--kotlin-gradle-plugin
Author: tessl

This document covers dependency resolution, automatic stdlib selection, and publishing configuration in Kotlin projects.

Dependency Declaration

Source Set Dependencies

interface KotlinDependencyHandler {
    fun implementation(dependencyNotation: Any)
    fun api(dependencyNotation: Any)
    fun compileOnly(dependencyNotation: Any)
    fun runtimeOnly(dependencyNotation: Any)
    
    // Test dependencies
    fun testImplementation(dependencyNotation: Any)
    fun testCompileOnly(dependencyNotation: Any)
    fun testRuntimeOnly(dependencyNotation: Any)
    
    // Platform-specific configurations
    fun expectedBy(dependency: Any)
}

Usage Example:

kotlin {
    sourceSets {
        commonMain {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
                implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
            }
        }
        
        commonTest {
            dependencies {
                implementation("org.jetbrains.kotlin:kotlin-test")
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3")
            }
        }
        
        jvmMain {
            dependencies {
                implementation("ch.qos.logback:logback-classic:1.4.11")
                implementation("io.ktor:ktor-server-netty:2.3.5")
            }
        }
        
        jsMain {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-html-js:0.9.1")
            }
        }
    }
}

Standard Library Management

The plugin automatically manages Kotlin standard library dependencies:

// Automatic stdlib selection based on targets
// JVM projects get kotlin-stdlib-jdk8
// JS projects get kotlin-stdlib-js  
// Common projects get kotlin-stdlib-common
// Native projects get kotlin-stdlib automatically

Stdlib Configuration:

// Disable automatic stdlib dependency
kotlin {
    explicitApi = org.jetbrains.kotlin.gradle.dsl.ExplicitApiMode.Strict
    
    // Custom stdlib version (not recommended)
    // Use plugin version instead
}

// In dependencies block for manual control
dependencies {
    implementation("org.jetbrains.kotlin:kotlin-stdlib:2.2.0")
}

NPM Dependencies (JavaScript)

NPM Dependency Declaration

interface NpmDependency {
    val name: String
    val version: String
    val scope: String?
}

interface NpmDependencyExtension {
    fun npm(name: String, version: String): NpmDependency
    fun npm(name: String, version: String, generateExternals: Boolean): NpmDependency
    fun devNpm(name: String, version: String): NpmDependency
    fun peerNpm(name: String, version: String): NpmDependency
    fun optionalNpm(name: String, version: String): NpmDependency
}

Usage Example:

kotlin {
    js(IR) {
        browser()
        nodejs()
    }
    
    sourceSets {
        jsMain {
            dependencies {
                implementation("org.jetbrains.kotlin-wrappers:kotlin-react:18.2.0-pre.467")
                
                // NPM dependencies
                implementation(npm("lodash", "4.17.21"))
                implementation(npm("axios", "1.5.0"))
                implementation(devNpm("webpack", "5.88.0"))
            }
        }
    }
}

NPM Configuration

// In build.gradle.kts for JS projects
rootProject.plugins.withType<org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin> {
    rootProject.the<org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension>().apply {
        nodeVersion = "18.17.0"
        npmVersion = "9.8.1"
    }
}

KAPT Dependencies

For annotation processing with KAPT:

// KAPT configuration
dependencies {
    kapt("com.google.dagger:dagger-compiler:2.48")
    kaptTest("com.google.dagger:dagger-compiler:2.48")
    
    implementation("com.google.dagger:dagger:2.48")
}

kapt {
    correctErrorTypes = true
    useBuildCache = false
    mapDiagnosticLocations = true
    
    arguments {
        arg("dagger.hilt.shareTestComponents", "true")
        arg("room.schemaLocation", "$projectDir/schemas")
    }
}

KSP Dependencies

For Kotlin Symbol Processing:

dependencies {
    ksp("com.google.devtools.ksp:symbol-processing:2.2.0-1.0.16")
    kspTest("com.google.devtools.ksp:symbol-processing:2.2.0-1.0.16")
}

Publishing Configuration

Maven Publishing

publishing {
    publications {
        withType<MavenPublication> {
            pom {
                name.set("My Kotlin Library")
                description.set("A Kotlin multiplatform library")
                url.set("https://github.com/user/repo")
                
                licenses {
                    license {
                        name.set("The Apache License, Version 2.0")
                        url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
                    }
                }
                
                developers {
                    developer {
                        id.set("username")
                        name.set("User Name")
                        email.set("user@example.com")
                    }
                }
                
                scm {
                    connection.set("scm:git:git://github.com/user/repo.git")
                    developerConnection.set("scm:git:ssh://github.com/user/repo.git")
                    url.set("https://github.com/user/repo")
                }
            }
        }
    }
}

Multiplatform Publishing

kotlin {
    jvm {
        mavenPublication {
            artifactId = "mylib-jvm"
        }
    }
    
    js(IR) {
        mavenPublication {
            artifactId = "mylib-js"
        }
    }
    
    sourceSets {
        commonMain {
            dependencies {
                // These will be included in all platform publications
                api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
            }
        }
    }
}

Android Library Publishing

kotlin {
    android {
        publishLibraryVariants("release", "debug")
        // or
        publishAllLibraryVariants()
    }
}

Dependency Configurations

Configuration Types

// Main configurations
val implementation: Configuration
val api: Configuration  
val compileOnly: Configuration
val runtimeOnly: Configuration

// Test configurations
val testImplementation: Configuration
val testCompileOnly: Configuration
val testRuntimeOnly: Configuration

// Platform-specific configurations (created automatically)
val jvmImplementation: Configuration
val jsImplementation: Configuration
val nativeImplementation: Configuration

Custom Configurations

configurations {
    val customImplementation by creating {
        extendsFrom(implementation.get())
    }
}

kotlin {
    sourceSets {
        commonMain {
            dependencies {
                "customImplementation"("some.group:artifact:1.0.0")
            }
        }
    }
}

Version Catalogs Integration

// With version catalogs (libs.versions.toml)
kotlin {
    sourceSets {
        commonMain {
            dependencies {
                implementation(libs.kotlinx.coroutines.core)
                implementation(libs.kotlinx.serialization.json)
            }
        }
        
        jvmMain {
            dependencies {
                implementation(libs.ktor.server.netty)
            }
        }
    }
}

Dependency Substitution

configurations.all {
    resolutionStrategy {
        dependencySubstitution {
            substitute(module("org.jetbrains.kotlin:kotlin-stdlib-jdk7"))
                .using(module("org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.2.0"))
                .because("Use JDK 8 stdlib")
        }
    }
}

Platform-Specific Dependencies

JVM Dependencies

kotlin {
    jvm {
        compilations.all {
            dependencies {
                implementation("org.slf4j:slf4j-api:2.0.9")
                implementation("ch.qos.logback:logback-classic:1.4.11")
                
                // JVM-only libraries
                implementation("com.fasterxml.jackson.core:jackson-core:2.15.2")
            }
        }
    }
}

Native Dependencies

kotlin {
    linuxX64 {
        compilations.main {
            cinterops {
                val libcurl by creating {
                    defFile(project.file("src/nativeInterop/cinterop/libcurl.def"))
                    packageName("libcurl")
                }
            }
        }
    }
}

Transitive Dependencies

Dependency Exclusions

kotlin {
    sourceSets {
        commonMain {
            dependencies {
                implementation("some.group:artifact:1.0.0") {
                    exclude(group = "unwanted.group", module = "unwanted-module")
                }
            }
        }
    }
}

Force Dependency Versions

configurations.all {
    resolutionStrategy {
        force("org.jetbrains.kotlin:kotlin-stdlib:2.2.0")
        failOnVersionConflict()
    }
}

Install with Tessl CLI

npx tessl i tessl/maven-org-jetbrains-kotlin--kotlin-gradle-plugin

docs

compilation-tasks.md

dependency-management.md

dsl-extensions.md

index.md

javascript-webassembly.md

multiplatform-targets.md

plugin-configuration.md

tile.json

tessl/maven-org-jetbrains-kotlin--kotlin-gradle-plugin