Improve styles

4 files changed, 149 insertions, 72 deletions

diff --git a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
index 7a047d3c..abb4e85b 100644
--- a/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
+++ b/plugins/base/src/main/kotlin/renderers/html/HtmlRenderer.kt
@@ -22,7 +22,6 @@ import org.jetbrains.dokka.plugability.query
 import org.jetbrains.dokka.plugability.querySingle
 import org.jetbrains.dokka.utilities.htmlEscape
 import org.jetbrains.dokka.utilities.urlEncoded
-import java.io.File
 import java.net.URI
 
 open class HtmlRenderer(
@@ -278,12 +277,8 @@ open class HtmlRenderer(
                     val content = contentsForSourceSetDependent(divergentForPlatformDependent, pageContext)
 
                     consumer.onTagContentUnsafe {
-                        +createHTML().div("brief-with-platform-tags") {
-                            consumer.onTagContentUnsafe {
-                                +createHTML().div("inner-brief-with-platform-tags") {
-                                    consumer.onTagContentUnsafe { +it.key.first }
-                                }
-                            }
+                        +createHTML().div("with-platform-tags") {
+                            consumer.onTagContentUnsafe { +it.key.first }
 
                             consumer.onTagContentUnsafe {
                                 +createHTML().span("pull-right") {
@@ -296,7 +291,7 @@ open class HtmlRenderer(
                             }
                         }
                     }
-                    div("main-subrow") {
+                    div {
                         if (node.implicitlySourceSetHinted) {
                             buildPlatformDependent(divergentForPlatformDependent, pageContext)
                         } else {
@@ -366,64 +361,141 @@ open class HtmlRenderer(
             .filter { sourceSetRestriction == null || it.sourceSets.any { s -> s in sourceSetRestriction } }
             .takeIf { it.isNotEmpty() }
             ?.let {
-                val anchorName = node.dci.dri.first().anchor
-                withAnchor(anchorName) {
-                    div(classes = "table-row") {
-                        if (!style.contains(MultimoduleTable)) {
-                            attributes["data-filterable-current"] = node.sourceSets.joinToString(" ") {
-                                it.sourceSetIDs.merged.toString()
-                            }
-                            attributes["data-filterable-set"] = node.sourceSets.joinToString(" ") {
-                                it.sourceSetIDs.merged.toString()
-                            }
-                        }
+                when (pageContext) {
+                    is MultimoduleRootPage -> buildRowForMultiModule(node, it, pageContext, sourceSetRestriction, style)
+                    is ModulePage -> buildRowForModule(node, it, pageContext, sourceSetRestriction, style)
+                    else -> buildRowForContent(node, it, pageContext, sourceSetRestriction, style)
+                }
+            }
+    }
 
-                        it.filterIsInstance<ContentLink>().takeIf { it.isNotEmpty() }?.let {
-                            div("main-subrow " + node.style.joinToString(" ")) {
-                                it.filter { sourceSetRestriction == null || it.sourceSets.any { s -> s in sourceSetRestriction } }
-                                    .forEach {
-                                        span {
-                                            it.build(this, pageContext, sourceSetRestriction)
-                                            buildAnchor(anchorName)
-                                        }
-                                        if (ContentKind.shouldBePlatformTagged(node.dci.kind) && (node.sourceSets.size == 1 || pageContext is ModulePage))
-                                            createPlatformTags(node)
-                                    }
+    private fun FlowContent.buildRowForMultiModule(
+        contextNode: ContentGroup,
+        toRender: List<ContentNode>,
+        pageContext: ContentPage,
+        sourceSetRestriction: Set<DisplaySourceSet>?,
+        style: Set<Style>
+    ) {
+        val anchorName = contextNode.dci.dri.first().anchor
+        withAnchor(anchorName) {
+            div(classes = "table-row") {
+                div("main-subrow " + contextNode.style.joinToString(separator = " ")) {
+                    buildRowHeaderLink(toRender, pageContext, sourceSetRestriction, anchorName, "w-100")
+                    div {
+                        buildRowBriefSectionForDocs(toRender, pageContext, sourceSetRestriction)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun FlowContent.buildRowForModule(
+        contextNode: ContentGroup,
+        toRender: List<ContentNode>,
+        pageContext: ContentPage,
+        sourceSetRestriction: Set<DisplaySourceSet>?,
+        style: Set<Style>
+    ) {
+        val anchorName = contextNode.dci.dri.first().anchor
+        withAnchor(anchorName) {
+            div(classes = "table-row") {
+                addSourceSetFilteringAttributes(contextNode)
+                div {
+                    div("main-subrow " + contextNode.style.joinToString(separator = " ")) {
+                        buildRowHeaderLink(toRender, pageContext, sourceSetRestriction, anchorName)
+                        div("pull-right") {
+                            if (ContentKind.shouldBePlatformTagged(contextNode.dci.kind)) {
+                                createPlatformTags(contextNode, cssClasses = "no-gutters")
                             }
                         }
+                    }
+                    div {
+                        buildRowBriefSectionForDocs(toRender, pageContext, sourceSetRestriction)
+                    }
+                }
+            }
+        }
+    }
 
-                        it.filter { it !is ContentLink }.takeIf { it.isNotEmpty() }?.let {
-                            if (pageContext is ModulePage || pageContext is MultimoduleRootPage) {
+    private fun FlowContent.buildRowForContent(
+        contextNode: ContentGroup,
+        toRender: List<ContentNode>,
+        pageContext: ContentPage,
+        sourceSetRestriction: Set<DisplaySourceSet>?,
+        style: Set<Style>
+    ) {
+        val anchorName = contextNode.dci.dri.first().anchor
+        withAnchor(anchorName) {
+            div(classes = "table-row") {
+                addSourceSetFilteringAttributes(contextNode)
+                div("main-subrow keyValue " + contextNode.style.joinToString(separator = " ")) {
+                    buildRowHeaderLink(toRender, pageContext, sourceSetRestriction, anchorName)
+                    div {
+                        toRender.filter { it !is ContentLink && !it.hasStyle(ContentStyle.RowTitle)}.takeIf { it.isNotEmpty() }?.let {
+                            if (ContentKind.shouldBePlatformTagged(contextNode.dci.kind) && contextNode.sourceSets.size == 1)
+                                createPlatformTags(contextNode)
+
+                            div("title") {
                                 it.forEach {
-                                    span(classes = if (it.dci.kind == ContentKind.Comment) "brief-comment" else "") {
-                                        it.build(this, pageContext, sourceSetRestriction)
-                                    }
-                                }
-                            } else {
-                                div("platform-dependent-row keyValue") {
-                                    val title = it.filter { it.style.contains(ContentStyle.RowTitle) }
-                                    div {
-                                        title.forEach {
-                                            it.build(this, pageContext, sourceSetRestriction)
-                                        }
-                                    }
-                                    div("title") {
-                                        (it - title).forEach {
-                                            it.build(this, pageContext, sourceSetRestriction)
-                                        }
-                                    }
+                                    it.build(this, pageContext, sourceSetRestriction)
                                 }
                             }
                         }
                     }
                 }
             }
+        }
     }
 
-    private fun FlowContent.createPlatformTagBubbles(sourceSets: List<DisplaySourceSet>) {
+    private fun FlowContent.buildRowHeaderLink(
+        toRender: List<ContentNode>,
+        pageContext: ContentPage,
+        sourceSetRestriction: Set<DisplaySourceSet>?,
+        anchorName: String,
+        classes: String = ""
+    ) {
+        toRender.filter { it is ContentLink || it.hasStyle(ContentStyle.RowTitle) }.takeIf { it.isNotEmpty() }?.let {
+            div(classes) {
+                it.filter { sourceSetRestriction == null || it.sourceSets.any { s -> s in sourceSetRestriction } }
+                    .forEach {
+                        span("inline-flex") {
+                            it.build(this, pageContext, sourceSetRestriction)
+                            if(it is ContentLink) buildAnchor(anchorName)
+                        }
+                    }
+            }
+        }
+    }
+
+    private fun FlowContent.addSourceSetFilteringAttributes(
+        contextNode: ContentGroup,
+    ) {
+        attributes["data-filterable-current"] = contextNode.sourceSets.joinToString(" ") {
+            it.sourceSetIDs.merged.toString()
+        }
+        attributes["data-filterable-set"] = contextNode.sourceSets.joinToString(" ") {
+            it.sourceSetIDs.merged.toString()
+        }
+    }
+
+    private fun FlowContent.buildRowBriefSectionForDocs(
+        toRender: List<ContentNode>,
+        pageContext: ContentPage,
+        sourceSetRestriction: Set<DisplaySourceSet>?,
+    ){
+        toRender.filter { it !is ContentLink }.takeIf { it.isNotEmpty() }?.let {
+            it.forEach {
+                span(classes = if (it.dci.kind == ContentKind.Comment) "brief-comment" else "") {
+                    it.build(this, pageContext, sourceSetRestriction)
+                }
+            }
+        }
+    }
+
+    private fun FlowContent.createPlatformTagBubbles(sourceSets: List<DisplaySourceSet>, cssClasses: String = "") {
         if (shouldRenderSourceSetBubbles) {
-            div("platform-tags") {
-                sourceSets.forEach {
+            div("platform-tags " + cssClasses) {
+                sourceSets.sortedBy { it.name }.forEach {
                     div("platform-tag") {
                         when (it.platform.key) {
                             "common" -> classes = classes + "common-like"
@@ -440,12 +512,13 @@ open class HtmlRenderer(
 
     private fun FlowContent.createPlatformTags(
         node: ContentNode,
-        sourceSetRestriction: Set<DisplaySourceSet>? = null
+        sourceSetRestriction: Set<DisplaySourceSet>? = null,
+        cssClasses: String = ""
     ) {
         node.takeIf { sourceSetRestriction == null || it.sourceSets.any { s -> s in sourceSetRestriction } }?.let {
             createPlatformTagBubbles(node.sourceSets.filter {
                 sourceSetRestriction == null || it in sourceSetRestriction
-            })
+            }.sortedBy { it.name }, cssClasses)
         }
     }
 
diff --git a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
index 465f8cb7..6273e789 100644
--- a/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
+++ b/plugins/base/src/main/kotlin/signatures/KotlinSignatureProvider.kt
@@ -63,7 +63,7 @@ class KotlinSignatureProvider(ctcc: CommentsToContentConverter, logger: DokkaLog
             contentBuilder.contentFor(
                 e,
                 ContentKind.Symbol,
-                setOf(TextStyle.Monospace, TextStyle.Block) + e.stylesIfDeprecated(it),
+                setOf(TextStyle.Monospace) + e.stylesIfDeprecated(it),
                 sourceSets = setOf(it)
             ) {
                 group(styles = setOf(TextStyle.Block)) {
diff --git a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
index 41881baf..f5fbb51e 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/DefaultPageCreator.kt
@@ -117,7 +117,7 @@ open class DefaultPageCreator(
 
             link(it.name, it.dri)
             if (it.sourceSets.size == 1 || (documentations.isNotEmpty() && haveSameContent)) {
-                documentations.first()?.let { firstSentenceComment(kind = ContentKind.Comment, content = it) }
+                documentations.first()?.let { firstSentenceComment(kind = ContentKind.Comment, content = it.root) }
             }
         }
     }
@@ -169,8 +169,8 @@ open class DefaultPageCreator(
         ) {
             link(it.name, it.dri, kind = ContentKind.Main)
             sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependentHint) {
-                contentForBrief(it)
                 +buildSignature(it)
+                contentForBrief(it)
             }
         }
         s.safeAs<WithExtraProperties<Documentable>>()?.let { it.extra[InheritorsInfo] }?.let { inheritors ->
@@ -206,8 +206,8 @@ open class DefaultPageCreator(
         group(kind = ContentKind.Cover) {
             cover(e.name)
             sourceSetDependentHint(e.dri, e.sourceSets.toSet()) {
-                +contentForDescription(e)
                 +buildSignature(e)
+                +contentForDescription(e)
             }
         }
         group(styles = setOf(ContentStyle.TabbedContent)) {
@@ -226,8 +226,8 @@ open class DefaultPageCreator(
         group(kind = ContentKind.Cover, sourceSets = mainSourcesetData + extensions.sourceSets) {
             cover(c.name.orEmpty())
             sourceSetDependentHint(c.dri, c.sourceSets) {
-                +contentForDescription(c)
                 +buildSignature(c)
+                +contentForDescription(c)
             }
         }
 
@@ -249,8 +249,8 @@ open class DefaultPageCreator(
                         kind = ContentKind.SourceSetDependentHint,
                         styles = emptySet()
                     ) {
-                        contentForBrief(it)
                         +buildSignature(it)
+                        contentForBrief(it)
                     }
                 }
             }
@@ -267,8 +267,8 @@ open class DefaultPageCreator(
                 ) {
                     link(it.name, it.dri)
                     sourceSetDependentHint(it.dri, it.sourceSets.toSet(), kind = ContentKind.SourceSetDependentHint) {
-                        contentForBrief(it)
                         +buildSignature(it)
+                        contentForBrief(it)
                     }
                 }
             }
@@ -464,7 +464,8 @@ open class DefaultPageCreator(
         documentable.sourceSets.forEach { sourceSet ->
             documentable.documentation[sourceSet]?.children?.firstOrNull()?.root?.let {
                 group(sourceSets = setOf(sourceSet), kind = ContentKind.BriefComment) {
-                    comment(it)
+                    if(documentable.hasSeparatePage) firstSentenceComment(it)
+                    else comment(it)
                 }
             }
         }
@@ -495,13 +496,13 @@ open class DefaultPageCreator(
         }
         divergentGroup(ContentDivergentGroup.GroupID("member")) {
             instance(setOf(d.dri), d.sourceSets.toSet()) {
-                before {
-                    +contentForDescription(d)
-                    +contentForComments(d)
-                }
                 divergent(kind = ContentKind.Symbol) {
                     +buildSignature(d)
                 }
+                after {
+                    +contentForDescription(d)
+                    +contentForComments(d)
+                }
             }
         }
     }
@@ -535,15 +536,15 @@ open class DefaultPageCreator(
                             ) {
                                 elements.map {
                                     instance(setOf(it.dri), it.sourceSets.toSet(), extra = PropertyContainer.withAll(SymbolAnchorHint)) {
-                                        before {
-                                            contentForBrief(it)
-                                            contentForSinceKotlin(it)
-                                        }
                                         divergent {
                                             group {
                                                 +buildSignature(it)
                                             }
                                         }
+                                        after {
+                                            contentForBrief(it)
+                                            contentForSinceKotlin(it)
+                                        }
                                     }
                                 }
                             }
@@ -566,4 +567,7 @@ open class DefaultPageCreator(
 
     private val Documentable.descriptions: SourceSetDependent<Description>
         get() = groupedTags.withTypeUnnamed<Description>()
+
+    private val Documentable.hasSeparatePage: Boolean
+        get() = this !is DTypeAlias
 }
diff --git a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
index 42700f20..4bebd9f1 100644
--- a/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
+++ b/plugins/base/src/main/kotlin/translators/documentables/PageContentBuilder.kt
@@ -289,14 +289,14 @@ open class PageContentBuilder(
         }
 
         fun firstSentenceComment(
-            content: Description,
+            content: DocTag,
             kind: Kind = ContentKind.Comment,
             sourceSets: Set<DokkaSourceSet> = mainSourcesetData,
             styles: Set<Style> = mainStyles,
             extra: PropertyContainer<ContentNode> = mainExtra
         ){
             val builtDescription = commentsConverter.buildContent(
-                content.root,
+                content,
                 DCI(mainDRI, kind),
                 sourceSets
             )