[Gradle, JS]Add devNpm method for devDependencies to KotlinDependencyHandler

libraries/tools/kotlin-gradle-plugin-api/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/HasKotlinDependencies.kt

@@ -64,6 +64,12 @@ interface KotlinDependencyHandler {
         message = "Use npm(name, version) instead. Name like in package.json"
     )
     fun npm(org: String? = null, packageName: String, version: String = "*"): Dependency
+
+    fun devNpm(name: String, version: String = "*"): Dependency
+
+    fun devNpm(name: String, directory: File): Dependency
+
+    fun devNpm(directory: File): Dependency
 }
 
 interface HasKotlinDependencies {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/mpp/DefaultKotlinDependencyHandler.kt

@@ -107,4 +107,28 @@ class DefaultKotlinDependencyHandler(
 
     override fun npm(org: String?, packageName: String, version: String) =
         npm("${if (org != null) "@$org/" else ""}$packageName", version)
+
+    override fun devNpm(name: String, version: String): NpmDependency =
+        NpmDependency(
+            project = project,
+            name = name,
+            version = version,
+            scope = NpmDependency.Scope.DEV
+        )
+
+    override fun devNpm(name: String, directory: File): NpmDependency {
+        check(directory.isDirectory) {
+            "Dependency on local path should point on directory but $directory found"
+        }
+        return devNpm(
+            name = name,
+            version = fileVersion(directory)
+        )
+    }
+
+    override fun devNpm(directory: File): NpmDependency =
+        devNpm(
+            name = moduleName(directory),
+            directory = directory
+        )
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/npm/NpmDependencyExtension.kt

@@ -19,76 +19,89 @@ interface NpmDependencyExtension {
     operator fun invoke(directory: File): NpmDependency
 }
 
-fun Project.addNpmDependencyExtension() {
-    val dependencies = this.dependencies as ExtensionAware
+private abstract class AbstractNpmDependencyExtension(
+    dependencies: ExtensionAware,
+    private val project: Project,
+    private val scope: NpmDependency.Scope
+) : NpmDependencyExtension, Closure<NpmDependency>(dependencies) {
+    override operator fun invoke(name: String, version: String): NpmDependency =
+        NpmDependency(
+            project = project,
+            name = name,
+            version = version,
+            scope = scope
+        )
 
-    val npmDependencyExtension: NpmDependencyExtension = object : NpmDependencyExtension, Closure<NpmDependency>(dependencies) {
-        override operator fun invoke(name: String, version: String): NpmDependency =
-            NpmDependency(
-                project = this@addNpmDependencyExtension,
+    override operator fun invoke(name: String, directory: File): NpmDependency {
+        check(directory.isDirectory) {
+            "Dependency on local path should point on directory but $directory found"
+        }
+        return invoke(
+            name = name,
+            version = fileVersion(directory)
+        )
+    }
+
+    override operator fun invoke(directory: File): NpmDependency =
+        invoke(
+            name = moduleName(directory),
+            directory = directory
+        )
+
+    override fun call(vararg args: Any?): NpmDependency {
+        if (args.size > 2) throw npmDeclarationException(args)
+
+        val arg = args[0]
+        return when (arg) {
+            is String -> withName(
+                name = arg,
+                args = *args
+            )
+            is File -> invoke(arg)
+            else -> throw npmDeclarationException(args)
+        }
+    }
+
+    private fun withName(name: String, vararg args: Any?): NpmDependency {
+        val arg = if (args.size > 1) args[1] else null
+        return when (arg) {
+            null -> invoke(
+                name = name
+            )
+            is String -> invoke(
                 name = name,
-                version = version
+                version = arg
             )
-
-        override operator fun invoke(name: String, directory: File): NpmDependency {
-            check(directory.isDirectory) {
-                "Dependency on local path should point on directory but $directory found"
-            }
-            return invoke(
+            is File -> invoke(
                 name = name,
-                version = fileVersion(directory)
+                directory = arg
             )
+            else -> throw npmDeclarationException(args)
         }
+    }
 
-        override operator fun invoke(directory: File): NpmDependency =
-            invoke(
-                name = moduleName(directory),
-                directory = directory
-            )
-
-        override fun call(vararg args: Any?): NpmDependency {
-            if (args.size > 2) throw npmDeclarationException(args)
-
-            val arg = args[0]
-            return when (arg) {
-                is String -> withName(
-                    name = arg,
-                    args = *args
-                )
-                is File -> invoke(arg)
-                else -> throw npmDeclarationException(args)
-            }
-        }
-
-        private fun withName(name: String, vararg args: Any?): NpmDependency {
-            val arg = if (args.size > 1) args[1] else null
-            return when (arg) {
-                null -> invoke(
-                    name = name
-                )
-                is String -> invoke(
-                    name = name,
-                    version = arg
-                )
-                is File -> invoke(
-                    name = name,
-                    directory = arg
-                )
-                else -> throw npmDeclarationException(args)
-            }
-        }
-
-        private fun npmDeclarationException(args: Array<out Any?>): IllegalArgumentException {
-            return IllegalArgumentException(
-                """
+    private fun npmDeclarationException(args: Array<out Any?>): IllegalArgumentException {
+        return IllegalArgumentException(
+            """
                             Unable to add NPM dependency by $args
                             - npm('name') -> name:*
                             - npm('name', 'version') -> name:version
                             - npm('name', File) -> name:File
                             """.trimIndent()
-            )
-        }
+        )
     }
+}
+
+fun Project.addNpmDependencyExtension() {
+    val dependencies = this.dependencies as ExtensionAware
+
+    val npmDependencyExtension: NpmDependencyExtension = object : AbstractNpmDependencyExtension(
+        dependencies, this, NpmDependency.Scope.NORMAL
+    ) {}
+
+    val devNpmDependencyExtension: NpmDependencyExtension = object : AbstractNpmDependencyExtension(
+        dependencies, this, NpmDependency.Scope.DEV
+    ) {}
 
     dependencies
         .extensions
@@ -97,4 +110,12 @@ fun Project.addNpmDependencyExtension() {
             "npm",
             npmDependencyExtension
         )
-}
+
+    dependencies
+        .extensions
+        .add(
+            TypeOf.typeOf<NpmDependencyExtension>(NpmDependencyExtension::class.java),
+            "devNpm",
+            devNpmDependencyExtension
+        )
+}