A modern programming language that makes developers happier.

kotlinlang

I don’t find any kotlin-dsl sample on javascript compilation. When can I found the options?

<@U0C1JH0RF> do you meant a sample of Korlin JS project using gradle kotlin dsl?

I don’t know how to write it now simpler than 
```
import org.gradle.kotlin.dsl.*
import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile

buildscript {
    repositories {
        jcenter()
    }

    val kotlinVersion by extra { "1.1.3-2" }

    dependencies {
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
    }
}

apply {
    plugin("kotlin2js")
}

repositories {
    jcenter()
}

dependencies {
    "compile"(kotlin("stdlib-js"))
}

val compileKotlin2Js: Kotlin2JsCompile by tasks

compileKotlin2Js.kotlinOptions {
    sourceMap = true
}

//tasks.withType&lt;Kotlin2JsCompile&gt; {
//    kotlinOptions.sourceMap = true
//}
//
//tasks.getByName("compileKotlin2Js") {
//    this as Kotlin2JsCompile
//    kotlinOptions.sourceMap = true
//}
```

Maybe GK DSL experts can help us :wink:
cc <@U0CHHN4F4>

I think that GK DSL authors are better experts than me. cc: <@U0QBCLV62>

The page <https://kotlinlang.org/docs/reference/using-gradle.html> indicates that plugin can be applied using the Gradle plugins DSL. 
```
plugins {
    id "org.jetbrains.kotlin.jvm" version "&lt;version to use&gt;"
}
```

gradle plugin for kotlin js is not available in plugin repo

I’m not sure to understand: it’s not possible to use gradle for kotlin js?

it means that you can’t use now mentioned above syntax for kotlin js
```

plugins {
    id ...
}
```

It’s frightening like sorcery. «You can use only that syntax  with kotlin.jvm» means the underlying stuff depends on the syntax. Which also means: «you cannot rely on previous documentation because the underlying objects are not the same». My personal translation is «go away, now or it will cost a lot of time». Am I wrong?

The maven version seems a lot more verbose but also a lot more stable.

what it doesn’t work for js now doesn’t mean that it will now work. I don’t work on this part of code but I think underlying objects was not changed so much.

Maybe it’s not more stable but more understandable. 

When I read the doc:
```
To target the JVM, the Kotlin plugin needs to be applied:

apply plugin: "kotlin"
Or, starting with Kotlin 1.1.1, the plugin can be applied using the Gradle plugins DSL:

plugins {
    id "org.jetbrains.kotlin.jvm" version "&lt;version to use&gt;"
}
```
I understand “there is just one plugin” with 2 ways of applying it.

Actually, right now the difference is only how to apply plugin. Other things will be more or less the same. I.e. I don’t see a simple way to configure a compiler even for JVM, but maybe for JVM it’s not required often.

So if it’s the same plugin it should work also for the js one.

That is my problem: you know some stuff that are really difficult for me to know (the jvm plugin works with the latest syntax, but not the js one). I fear to loose lot of time because of  information I don’t have.