Moved to 1.3.40 and plugin-based build. Fix fo Styled.

build.gradle.kts

@@ -1,4 +1,4 @@
-val dataforgeVersion by extra("0.1.3-dev-5")
+val dataforgeVersion by extra("0.1.3-dev-6")
 
 allprojects {
     repositories {
@@ -11,8 +11,7 @@ allprojects {
 }
 
 subprojects {
-    apply(plugin = "dokka-publish")
     if (name.startsWith("dataforge")) {
-        apply(plugin = "npm-publish")
+        apply(plugin = "scientifik.publish")
     } 
 }

buildSrc/build.gradle.kts

@@ -7,7 +7,7 @@ repositories {
     jcenter()
 }
 
-val kotlinVersion = "1.3.31"
+val kotlinVersion = "1.3.40"
 
 // Add plugins used in buildSrc as dependencies, also we should specify version only here
 dependencies {
@@ -18,3 +18,16 @@ dependencies {
     implementation("com.moowork.gradle:gradle-node-plugin:1.3.1")
     implementation("org.openjfx:javafx-plugin:0.0.7")
 }
+
+gradlePlugin{
+    plugins {
+        create("scientifik-publish") {
+            id = "scientifik.publish"
+            implementationClass = "ScientifikPublishPlugin"
+        }
+        create("scientifik-mpp"){
+            id = "scientifik.mpp"
+            implementationClass = "ScientifikMPPlugin"
+        }
+    }
+}

buildSrc/src/main/kotlin/ScientifikMPPlugin.kt

@@ -0,0 +1,76 @@
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.getValue
+import org.gradle.kotlin.dsl.getting
+import org.gradle.kotlin.dsl.invoke
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+open class ScientifikMPPlugin : Plugin<Project> {
+    override fun apply(project: Project) {
+        project.plugins.apply("org.jetbrains.kotlin.multiplatform")
+
+        project.configure<KotlinMultiplatformExtension> {
+            jvm {
+                compilations.all {
+                    kotlinOptions {
+                        jvmTarget = "1.8"
+                    }
+                }
+            }
+
+            js {
+                compilations.all {
+                    kotlinOptions {
+                        sourceMap = true
+                        sourceMapEmbedSources = "always"
+                        moduleKind = "commonjs"
+                    }
+                }
+            }
+
+            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"))
+                    }
+                }
+                val jsMain by getting {
+                    dependencies {
+                        api(kotlin("stdlib-js"))
+                    }
+                }
+                val jsTest by getting {
+                    dependencies {
+                        implementation(kotlin("test-js"))
+                    }
+                }
+            }
+
+            targets.all {
+                sourceSets.all {
+                    languageSettings.progressiveMode = true
+                    languageSettings.enableLanguageFeature("InlineClasses")
+                }
+            }
+        }
+
+    }
+}

buildSrc/src/main/kotlin/ScientifikPublishPlugin.kt

@@ -0,0 +1,210 @@
+import com.jfrog.bintray.gradle.BintrayExtension
+import groovy.lang.GroovyObject
+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.publish.maven.internal.artifact.FileBasedMavenArtifact
+import org.gradle.api.tasks.bundling.Jar
+import org.gradle.kotlin.dsl.*
+import org.jetbrains.dokka.gradle.DokkaTask
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jfrog.gradle.plugin.artifactory.dsl.ArtifactoryPluginConvention
+import org.jfrog.gradle.plugin.artifactory.dsl.PublisherConfig
+import org.jfrog.gradle.plugin.artifactory.dsl.ResolverConfig
+
+
+open class ScientifikExtension {
+    var vcs = "https://github.com/altavir/dataforge-core"
+    var bintrayRepo = "dataforge"
+    var dokka = true
+}
+
+open class ScientifikPublishPlugin : Plugin<Project> {
+
+    override fun apply(project: Project) {
+
+        project.plugins.apply("maven-publish")
+        val extension = project.extensions.create<ScientifikExtension>("scientifik")
+
+
+
+        project.configure<PublishingExtension> {
+            repositories {
+                maven("https://bintray.com/mipt-npm/${extension.bintrayRepo}")
+            }
+
+            // Process each publication we have in this project
+            publications.filterIsInstance<MavenPublication>().forEach { publication ->
+
+                @Suppress("UnstableApiUsage")
+                publication.pom {
+                    name.set(project.name)
+                    description.set(project.description)
+                    url.set(extension.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(extension.vcs)
+                    }
+                }
+
+                val moduleFile = project.buildDir.resolve("publications/${publication.name}/module.json")
+                if (moduleFile.exists()) {
+                    publication.artifact(object : FileBasedMavenArtifact(moduleFile) {
+                        override fun getDefaultExtension() = "module"
+                    })
+                }
+            }
+        }
+
+        if(extension.dokka){
+            project.plugins.apply("org.jetbrains.dokka")
+
+            project.afterEvaluate {
+                extensions.findByType<KotlinMultiplatformExtension>()?.apply{
+                    val dokka by tasks.getting(DokkaTask::class) {
+                        outputFormat = "html"
+                        outputDirectory = "$buildDir/javadoc"
+                        jdkVersion = 8
+
+                        kotlinTasks {
+                            // dokka fails to retrieve sources from MPP-tasks so we only define the jvm task
+                            listOf(tasks.getByPath("compileKotlinJvm"))
+                        }
+                        sourceRoot {
+                            // assuming only single source dir
+                            path = sourceSets["commonMain"].kotlin.srcDirs.first().toString()
+                            platforms = listOf("Common")
+                        }
+                        // although the JVM sources are now taken from the task,
+                        // we still define the jvm source root to get the JVM marker in the generated html
+                        sourceRoot {
+                            // assuming only single source dir
+                            path = sourceSets["jvmMain"].kotlin.srcDirs.first().toString()
+                            platforms = listOf("JVM")
+                        }
+                    }
+
+                    val kdocJar by tasks.registering(Jar::class) {
+                        group = JavaBasePlugin.DOCUMENTATION_GROUP
+                        dependsOn(dokka)
+                        archiveClassifier.set("javadoc")
+                        from("$buildDir/javadoc")
+                    }
+
+                    configure<PublishingExtension> {
+
+                        targets.all {
+                            val publication = publications.findByName(name) as MavenPublication
+
+                            // Patch publications with fake javadoc
+                            publication.artifact(kdocJar.get())
+                        }
+                    }
+                }
+
+
+                extensions.findByType<KotlinJvmProjectExtension>()?.apply{
+                    val dokka by tasks.getting(DokkaTask::class) {
+                        outputFormat = "html"
+                        outputDirectory = "$buildDir/javadoc"
+                        jdkVersion = 8
+                    }
+
+                    val kdocJar by tasks.registering(Jar::class) {
+                        group = JavaBasePlugin.DOCUMENTATION_GROUP
+                        dependsOn(dokka)
+                        archiveClassifier.set("javadoc")
+                        from("$buildDir/javadoc")
+                    }
+
+                    configure<PublishingExtension> {
+                        publications.filterIsInstance<MavenPublication>().forEach { publication ->
+                            publication.artifact(kdocJar.get())
+                        }
+                    }
+                }
+            }
+        }
+
+        project.plugins.apply("com.jfrog.bintray")
+
+        project.configure<BintrayExtension> {
+            user = project.findProperty("bintrayUser") as? String ?: System.getenv("BINTRAY_USER")
+            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 = extension.bintrayRepo
+                name = project.name
+                issueTrackerUrl = "${extension.vcs}/issues"
+                setLicenses("Apache-2.0")
+                vcsUrl = extension.vcs
+                version.apply {
+                    name = project.version.toString()
+                    vcsTag = project.version.toString()
+                    released = java.util.Date().toString()
+                }
+            }
+
+            //workaround bintray bug
+            project.afterEvaluate {
+                setPublications(*project.extensions.findByType<PublishingExtension>()!!.publications.names.toTypedArray())
+            }
+
+//            project.tasks.figetByPath("bintrayUpload") {
+//                    dependsOn(publishToMavenLocal)
+//            }
+        }
+
+        project.plugins.apply("com.jfrog.artifactory")
+
+        project.configure<ArtifactoryPluginConvention> {
+            val artifactoryUser: String? by project
+            val artifactoryPassword: String? by project
+            val artifactoryContextUrl = "http://npm.mipt.ru:8081/artifactory"
+
+            setContextUrl(artifactoryContextUrl)//The base Artifactory URL if not overridden by the publisher/resolver
+            publish(delegateClosureOf<PublisherConfig> {
+                repository(delegateClosureOf<GroovyObject> {
+                    setProperty("repoKey", "gradle-dev-local")
+                    setProperty("username", artifactoryUser)
+                    setProperty("password", artifactoryPassword)
+                })
+
+                defaults(delegateClosureOf<GroovyObject> {
+                    invokeMethod("publications", arrayOf("jvm", "js", "kotlinMultiplatform", "metadata"))
+                })
+            })
+            resolve(delegateClosureOf<ResolverConfig> {
+                repository(delegateClosureOf<GroovyObject> {
+                    setProperty("repoKey", "gradle-dev")
+                    setProperty("username", artifactoryUser)
+                    setProperty("password", artifactoryPassword)
+                })
+            })
+        }
+    }
+}

buildSrc/src/main/kotlin/Versions.kt

@@ -2,8 +2,8 @@
 // define version in buildSrc and have autocompletion and compile-time check
 // Also dependencies itself can be moved here
 object Versions {
-    val ioVersion = "0.1.8"
+    val ioVersion = "0.1.10"
-    val coroutinesVersion = "1.2.1"
+    val coroutinesVersion = "1.2.2"
-    val atomicfuVersion = "0.12.6"
+    val atomicfuVersion = "0.12.9"
-    val serializationVersion = "0.11.0"
+    val serializationVersion = "0.11.1"
 }

buildSrc/src/main/kotlin/dokka-publish.gradle.kts

@@ -1,75 +0,0 @@
-import org.jetbrains.dokka.gradle.DokkaTask
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-
-plugins {
-    id("org.jetbrains.dokka")
-    `maven-publish`
-}
-
-afterEvaluate {
-
-    extensions.findByType<KotlinMultiplatformExtension>()?.apply{
-        val dokka by tasks.getting(DokkaTask::class) {
-            outputFormat = "html"
-            outputDirectory = "$buildDir/javadoc"
-            jdkVersion = 8
-
-            kotlinTasks {
-                // dokka fails to retrieve sources from MPP-tasks so we only define the jvm task
-                listOf(tasks.getByPath("compileKotlinJvm"))
-            }
-            sourceRoot {
-                // assuming only single source dir
-                path = sourceSets["commonMain"].kotlin.srcDirs.first().toString()
-                platforms = listOf("Common")
-            }
-            // although the JVM sources are now taken from the task,
-            // we still define the jvm source root to get the JVM marker in the generated html
-            sourceRoot {
-                // assuming only single source dir
-                path = sourceSets["jvmMain"].kotlin.srcDirs.first().toString()
-                platforms = listOf("JVM")
-            }
-        }
-
-        val kdocJar by tasks.registering(Jar::class) {
-            group = JavaBasePlugin.DOCUMENTATION_GROUP
-            dependsOn(dokka)
-            archiveClassifier.set("javadoc")
-            from("$buildDir/javadoc")
-        }
-
-        configure<PublishingExtension> {
-
-            targets.all {
-                val publication = publications.findByName(name) as MavenPublication
-
-                // Patch publications with fake javadoc
-                publication.artifact(kdocJar.get())
-            }
-        }
-    }
-
-
-    extensions.findByType<KotlinJvmProjectExtension>()?.apply{
-        val dokka by tasks.getting(DokkaTask::class) {
-            outputFormat = "html"
-            outputDirectory = "$buildDir/javadoc"
-            jdkVersion = 8
-        }
-
-        val kdocJar by tasks.registering(Jar::class) {
-            group = JavaBasePlugin.DOCUMENTATION_GROUP
-            dependsOn(dokka)
-            archiveClassifier.set("javadoc")
-            from("$buildDir/javadoc")
-        }
-
-        configure<PublishingExtension> {
-            publications.filterIsInstance<MavenPublication>().forEach { publication ->
-                publication.artifact(kdocJar.get())
-            }
-        }
-    }
-}

buildSrc/src/main/kotlin/js-test.gradle.kts

@@ -1,44 +0,0 @@
-import com.moowork.gradle.node.npm.NpmTask
-import com.moowork.gradle.node.task.NodeTask
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
-
-plugins {
-    id("com.moowork.node")
-    kotlin("multiplatform")
-}
-
-node {
-    nodeModulesDir = file("$buildDir/node_modules")
-}
-
-val compileKotlinJs by tasks.getting(Kotlin2JsCompile::class)
-val compileTestKotlinJs by tasks.getting(Kotlin2JsCompile::class)
-
-val populateNodeModules by tasks.registering(Copy::class) {
-    dependsOn(compileKotlinJs)
-    from(compileKotlinJs.destinationDir)
-
-    kotlin.js().compilations["test"].runtimeDependencyFiles.forEach {
-        if (it.exists() && !it.isDirectory) {
-            from(zipTree(it.absolutePath).matching { include("*.js") })
-        }
-    }
-
-    into("$buildDir/node_modules")
-}
-
-val installMocha by tasks.registering(NpmTask::class) {
-    setWorkingDir(buildDir)
-    setArgs(listOf("install", "mocha"))
-}
-
-val runMocha by tasks.registering(NodeTask::class) {
-    dependsOn(compileTestKotlinJs, populateNodeModules, installMocha)
-    setScript(file("$buildDir/node_modules/mocha/bin/mocha"))
-    setArgs(listOf(compileTestKotlinJs.outputFile))
-}
-
-tasks["jsTest"].dependsOn(runMocha)
-
-

buildSrc/src/main/kotlin/npm-multiplatform.gradle.kts

@@ -1,87 +0,0 @@
-import org.gradle.kotlin.dsl.`maven-publish`
-import org.gradle.kotlin.dsl.apply
-import org.gradle.kotlin.dsl.dependencies
-import org.gradle.kotlin.dsl.kotlin
-
-plugins {
-    kotlin("multiplatform")
-    `maven-publish`
-}
-
-
-kotlin {
-    jvm {
-        compilations.all {
-            kotlinOptions {
-                jvmTarget = "1.8"
-            }
-        }
-    }
-
-    js {
-        compilations.all {
-            kotlinOptions {
-                metaInfo = true
-                sourceMap = true
-                sourceMapEmbedSources = "always"
-                moduleKind = "commonjs"
-            }
-        }
-
-        compilations.named("main") {
-            kotlinOptions {
-                main = "call"
-            }
-        }
-    }
-
-    sourceSets {
-        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"))
-            }
-        }
-        val jsMain by getting {
-            dependencies {
-                api(kotlin("stdlib-js"))
-            }
-        }
-        val jsTest by getting {
-            dependencies {
-                implementation(kotlin("test-js"))
-            }
-        }
-    }
-
-    targets.all {
-        sourceSets.all {
-            languageSettings.progressiveMode = true
-            languageSettings.enableLanguageFeature("InlineClasses")
-        }
-    }
-
-    // Apply JS test configuration
-    val runJsTests by ext(false)
-
-    if (runJsTests) {
-        apply(plugin = "js-test")
-    }
-
-}

buildSrc/src/main/kotlin/npm-publish.gradle.kts

@@ -1,153 +0,0 @@
-@file:Suppress("UnstableApiUsage")
-
-import com.jfrog.bintray.gradle.tasks.BintrayUploadTask
-import groovy.lang.GroovyObject
-import org.gradle.api.publish.maven.internal.artifact.FileBasedMavenArtifact
-import org.jfrog.gradle.plugin.artifactory.dsl.PublisherConfig
-import org.jfrog.gradle.plugin.artifactory.dsl.ResolverConfig
-import org.jfrog.gradle.plugin.artifactory.task.ArtifactoryTask
-
-// Old bintray.gradle script converted to real Gradle plugin (precompiled script plugin)
-// It now has own dependencies and support type safe accessors
-// Syntax is pretty close to what we had in Groovy
-// (excluding Property.set and bintray dynamic configs)
-
-plugins {
-    `maven-publish`
-    id("com.jfrog.bintray")
-    id("com.jfrog.artifactory")
-}
-
-val vcs = "https://github.com/altavir/dataforge-core"
-val bintrayRepo = "https://bintray.com/mipt-npm/dataforge"
-
-// Configure publishing
-publishing {
-    repositories {
-        maven(bintrayRepo)
-    }
-
-    // Process each publication we have in this project
-    publications.filterIsInstance<MavenPublication>().forEach { publication ->
-
-        // use type safe pom config GSL instead of old dynamic
-        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)
-            }
-        }
-    }
-
-}
-
-bintray {
-    user = findProperty("bintrayUser") as? String ?: System.getenv("BINTRAY_USER")
-    key = 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 = "dataforge"
-        name = project.name
-        issueTrackerUrl = "$vcs/issues"
-        setLicenses("Apache-2.0")
-        vcsUrl = vcs
-        version.apply {
-            name = project.version.toString()
-            vcsTag = project.version.toString()
-            released = java.util.Date().toString()
-        }
-    }
-
-    //workaround bintray bug
-    afterEvaluate {
-        setPublications(*publishing.publications.names.toTypedArray())
-    }
-
-    tasks {
-        bintrayUpload {
-            dependsOn(publishToMavenLocal)
-        }
-    }
-}
-
-//workaround for bintray
-tasks.withType<BintrayUploadTask> {
-    doFirst {
-        publishing.publications
-            .filterIsInstance<MavenPublication>()
-            .forEach { publication ->
-                val moduleFile = buildDir.resolve("publications/${publication.name}/module.json")
-                if (moduleFile.exists()) {
-                    publication.artifact(object : FileBasedMavenArtifact(moduleFile) {
-                        override fun getDefaultExtension() = "module"
-                    })
-                }
-            }
-    }
-}
-
-artifactory {
-    val artifactoryUser: String? by project
-    val artifactoryPassword: String? by project
-    val artifactoryContextUrl = "http://npm.mipt.ru:8081/artifactory"
-
-    setContextUrl(artifactoryContextUrl)//The base Artifactory URL if not overridden by the publisher/resolver
-    publish(delegateClosureOf<PublisherConfig> {
-        repository(delegateClosureOf<GroovyObject> {
-            setProperty("repoKey", "gradle-dev-local")
-            setProperty("username", artifactoryUser)
-            setProperty("password", artifactoryPassword)
-        })
-
-        defaults(delegateClosureOf<GroovyObject> {
-            invokeMethod("publications", arrayOf("jvm", "js", "kotlinMultiplatform", "metadata"))
-        })
-    })
-    resolve(delegateClosureOf<ResolverConfig> {
-        repository(delegateClosureOf<GroovyObject> {
-            setProperty("repoKey", "gradle-dev")
-            setProperty("username", artifactoryUser)
-            setProperty("password", artifactoryPassword)
-        })
-    })
-}
-
-// Fixed module artifact uploading to artifactory
-tasks.withType<ArtifactoryTask> {
-    doFirst {
-        publishing.publications
-            .filterIsInstance<MavenPublication>()
-            .forEach { publication ->
-                val moduleFile = buildDir.resolve("publications/${publication.name}/module.json")
-                if (moduleFile.exists()) {
-                    publication.artifact(object : FileBasedMavenArtifact(moduleFile) {
-                        override fun getDefaultExtension() = "module"
-                    })
-                }
-            }
-    }
-}

dataforge-context/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    `npm-multiplatform`
+    id("scientifik.mpp")
 }
 
 description = "Context and provider definitions"

dataforge-data/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    `npm-multiplatform`
+    id("scientifik.mpp")
 }
 
 val coroutinesVersion: String = Versions.coroutinesVersion

dataforge-io/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    `npm-multiplatform`
+    id("scientifik.mpp")
 }
 
 description = "IO for meta"

dataforge-meta/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    `npm-multiplatform`
+    id("scientifik.mpp")
 }
 
 description = "Meta definition and basic operations on meta"

dataforge-meta/src/commonMain/kotlin/hep/dataforge/meta/Styled.kt

@@ -16,7 +16,6 @@ class Styled(val base: Meta, val style: Config = Config().empty()) : AbstractMut
 
     override fun empty(): Styled  = Styled(EmptyMeta)
 
-    @Suppress("UNCHECKED_CAST")
     override val items: Map<NameToken, MetaItem<Styled>>
         get() = (base.items.keys + style.items.keys).associate { key ->
             val value = base.items[key]
@@ -25,7 +24,7 @@ class Styled(val base: Meta, val style: Config = Config().empty()) : AbstractMut
                 null -> when (styleValue) {
                     null -> error("Should be unreachable")
                     is MetaItem.NodeItem -> MetaItem.NodeItem(Styled(style.empty(), styleValue.node))
-                    else -> styleValue.value as MetaItem<Styled>
+                    is MetaItem.ValueItem -> styleValue
                 }
                 is MetaItem.ValueItem -> value as MetaItem<Styled>
                 is MetaItem.NodeItem -> MetaItem.NodeItem(

dataforge-output-html/build.gradle.kts

@@ -1,12 +1,10 @@
 plugins {
-    `npm-multiplatform`
+    id("scientifik.mpp")
 }
 
 val htmlVersion by rootProject.extra("0.6.12")
 
 kotlin {
-    jvm()
-    js()
     sourceSets {
         val commonMain by getting {
             dependencies {

dataforge-output/build.gradle.kts

@@ -1,10 +1,8 @@
 plugins {
-    `npm-multiplatform`
+    id("scientifik.mpp")
 }
 
 kotlin {
-    jvm()
-    js()
     sourceSets {
         val commonMain by getting{
             dependencies {

dataforge-scripting/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    `npm-multiplatform`
+    id("scientifik.mpp")
 }
 
 kotlin {

dataforge-workspace/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    `npm-multiplatform`
+    id("scientifik.mpp")
 }
 
 kotlin {

settings.gradle.kts

@@ -25,7 +25,7 @@ include(
     ":dataforge-context",
     ":dataforge-data",
     ":dataforge-output",
-    ":dataforge-output:dataforge-output-html",
+    ":dataforge-output-html",
     ":dataforge-workspace",
     ":dataforge-scripting"
 )