update compose

0.5.2

CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.6.0
+
+* `Kotlin`: `1.8.10`
+* `Compose`: `1.3.1-rc01`
+
+## 0.5.2
+
+* More fixes in Dialogs
+* Badge supported
+* Inline creation support
+
+## 0.5.1
+
+* Fixes in new `Dialog`s
+
 ## 0.5.0
 
 * Fully rework `Dialog` elements

gradle.properties

@@ -9,4 +9,4 @@ android.enableJetifier=true
 # Project data
 
 group=dev.inmo
-version=0.5.0
+version=0.6.0

gradle/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
 
-kt = "1.7.20"
+kt = "1.8.10"
-jb-compose = "1.2.2"
+jb-compose = "1.3.1-rc01"
 jb-dokka = "1.7.20"
 gh-release = "2.4.1"
 

src/jsMain/kotlin/dev/inmo/jsuikit/elements/Badge.kt

@@ -0,0 +1,25 @@
+package dev.inmo.jsuikit.elements
+
+import androidx.compose.runtime.Composable
+import dev.inmo.jsuikit.modifiers.UIKitBadge
+import dev.inmo.jsuikit.modifiers.include
+import org.jetbrains.compose.web.dom.AttrBuilderContext
+import org.jetbrains.compose.web.dom.ContentBuilder
+import org.jetbrains.compose.web.dom.Span
+import org.jetbrains.compose.web.dom.Text
+import org.w3c.dom.HTMLSpanElement
+
+@Composable
+fun Badge(
+    text: String,
+    onAfterText: ContentBuilder<HTMLSpanElement>? = null,
+    onBeforeText: ContentBuilder<HTMLSpanElement>? = null,
+    attrs: AttrBuilderContext<HTMLSpanElement>? = null
+) = Span({
+    include(UIKitBadge)
+    attrs ?.invoke(this)
+}) {
+    onAfterText ?.invoke(this)
+    Text(text)
+    onBeforeText ?.invoke(this)
+}

src/jsMain/kotlin/dev/inmo/jsuikit/elements/Dialog.kt

@@ -1,14 +1,13 @@
 package dev.inmo.jsuikit.elements
 
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import dev.inmo.jsuikit.modifiers.*
 import org.jetbrains.compose.web.dom.*
 import org.jetbrains.compose.web.renderComposableInBody
 import org.w3c.dom.HTMLDivElement
-import org.w3c.dom.MutationObserver
-import org.w3c.dom.MutationObserverInit
 import kotlin.random.Random
 import kotlin.random.nextUInt
 
@@ -30,8 +29,11 @@ fun Dialog(
     removeOnHide: Boolean = true,
     bodyBuilder: ContentBuilder<HTMLDivElement> = {}
 ) {
-    val drawDiv = remember { mutableStateOf(true) }
+    val draw = remember { mutableStateOf(true) }
-    val composition = renderComposableInBody {
+
+    remember {
+        renderComposableInBody {
+            if (draw.value) {
                 Div(
                     {
                         if (modifiers.none { it is UIKitModal.WithCustomAttributes }) {
@@ -40,42 +42,42 @@ fun Dialog(
                         id("dialog${Random.nextUInt()}")
                         include(*modifiers)
 
-                ref { htmlElement ->
-                    inline fun isShown() = htmlElement.classList.contains(UIKitUtility.Open.classes.first())
-
-                    var latestStateIsShown = isShown()
-
-                    val observer = MutationObserver { _, _ ->
-                        val currentStateIsShown = isShown()
-
-                        when (currentStateIsShown) {
-                            latestStateIsShown -> return@MutationObserver
-                            true -> onShown ?.invoke(htmlElement)
-                            false -> onHidden ?.invoke(htmlElement)
-                        }
-
-                        latestStateIsShown = currentStateIsShown
-
-                        if (removeOnHide && !currentStateIsShown) {
-                            htmlElement.remove()
-                        }
-                    }
-
-                    observer.observe(htmlElement, MutationObserverInit(attributes = true, attributeFilter = arrayOf("class")))
-
-                    if (autoShow) {
-                        UIKit.modal("#${htmlElement.id}") ?.show()
-                    }
-
-                    onDispose {
-                        observer.disconnect()
-                        drawDiv.value = false
-                    }
-                }
-
                         attributesCustomizer()
                     }
                 ) {
+                    DisposableEffect(true) {
+                        val htmlElement = scopeElement
+
+                        if (autoShow) {
+                            UIKit.modal(htmlElement).show()
+                        }
+
+                        if (onHidden != null || removeOnHide) {
+                            htmlElement.addEventListener("hidden", {
+                                if (it.target != htmlElement) return@addEventListener
+
+                                onHidden ?.invoke(htmlElement)
+
+                                if (removeOnHide) {
+                                    htmlElement.remove()
+                                }
+                            })
+                        }
+
+                        onShown ?.let {
+                            htmlElement.addEventListener("shown", {
+                                if (it.target != htmlElement) return@addEventListener
+
+                                onShown(htmlElement)
+                            })
+                        }
+
+
+                        onDispose {
+                            draw.value = false
+                        }
+                    }
+
                     Div(
                         {
                             include(UIKitModal.Dialog)
@@ -115,19 +117,17 @@ fun Dialog(
                     }
                 }
             }
+        }
+    }
 
-    if (drawDiv.value) {
     Div({
         hidden()
         ref {
             onDispose {
-                    composition.dispose()
+                draw.value = false
             }
         }
     })
-    } else {
-        runCatching { composition.dispose() }
-    }
 }
 
 @Composable
@@ -150,23 +150,23 @@ fun Dialog(
     bodyBuilder: ContentBuilder<HTMLDivElement> = {}
 ) = Dialog(
     modifiers = modifiers,
-    attributesCustomizer,
+    attributesCustomizer = attributesCustomizer,
-    onHidden,
+    onHidden = onHidden,
-    onShown,
+    onShown = onShown,
-    dialogAttrsBuilder,
+    dialogAttrsBuilder = dialogAttrsBuilder,
-    headerAttrsBuilder,
+    headerAttrsBuilder = headerAttrsBuilder,
     headerBuilder = {
         H2({ include(UIKitModal.Title) }) {
             Text(title)
         }
         headerBuilder ?.invoke(this)
     },
-    afterHeaderBuilder,
+    afterHeaderBuilder = afterHeaderBuilder,
-    beforeFooterBuilder,
+    beforeFooterBuilder = beforeFooterBuilder,
-    footerAttrsBuilder,
+    footerAttrsBuilder = footerAttrsBuilder,
-    footerBuilder,
+    footerBuilder = footerBuilder,
-    bodyAttrsBuilder,
+    bodyAttrsBuilder = bodyAttrsBuilder,
-    autoShow,
+    autoShow = autoShow,
-    removeOnHide,
+    removeOnHide = removeOnHide,
-    bodyBuilder
+    bodyBuilder = bodyBuilder
 )

src/jsMain/kotlin/dev/inmo/jsuikit/elements/Inline.kt

@@ -0,0 +1,18 @@
+package dev.inmo.jsuikit.elements
+
+import androidx.compose.runtime.Composable
+import dev.inmo.jsuikit.modifiers.UIKitUtility
+import dev.inmo.jsuikit.modifiers.include
+import org.jetbrains.compose.web.dom.AttrBuilderContext
+import org.jetbrains.compose.web.dom.ContentBuilder
+import org.jetbrains.compose.web.dom.Div
+import org.w3c.dom.HTMLDivElement
+
+@Composable
+fun Inline(
+    attrBuilderContext: AttrBuilderContext<HTMLDivElement>? = null,
+    contentBuilder: ContentBuilder<HTMLDivElement>
+) = Div({
+    include(UIKitUtility.Inline)
+    attrBuilderContext ?.invoke(this)
+}, contentBuilder)

src/jsMain/kotlin/dev/inmo/jsuikit/modifiers/UIKitBadge.kt

@@ -0,0 +1,7 @@
+package dev.inmo.jsuikit.modifiers
+
+sealed class UIKitBadge(classname: String) : UIKitModifier {
+    override val classes: Array<String> = arrayOf(classname)
+
+    companion object : UIKitBadge("uk-badge")
+}

src/jsMain/kotlin/dev/inmo/jsuikit/types/UIKit.kt

@@ -6,6 +6,7 @@ import kotlin.js.Json
 external interface UIKit {
     val notification: UIKitNotifications
     val modal: UIKitDialogs
+    val util: UIKitUtil
 
 
     fun notification(message: String, parameters: Json)

src/jsMain/kotlin/dev/inmo/jsuikit/types/UIKitUtil.kt

@@ -0,0 +1,8 @@
+package dev.inmo.jsuikit.types
+
+import org.w3c.dom.HTMLElement
+
+external interface UIKitUtil {
+    fun on(selector: String, event: String, callback: () -> Unit)
+    fun on(element: HTMLElement, event: String, callback: () -> Unit)
+}

src/jsMain/kotlin/dev/inmo/jsuikit/utils/AttributeBuilderContextSums.kt

@@ -0,0 +1,9 @@
+package dev.inmo.jsuikit.utils
+
+import org.jetbrains.compose.web.dom.AttrBuilderContext
+import org.w3c.dom.Element
+
+operator fun <T : Element> AttrBuilderContext<T>.plus(other: AttrBuilderContext<T>): AttrBuilderContext<T> = {
+    this@plus()
+    other()
+}