AttributesCollection#plus

0.0.37

CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 0.0.38
+
+* Add support of `Toggle`
+* Attributes collection now can be concatenated
+
+## 0.0.37
+
+* `Dialog` now do not add auto margin by default
+* Support of `Accordion` element
+
+## 0.0.36
+
+* Reorder arguments in `DefaultComment` fun
+* Add `Vertical` and `Horizontal` members in margins
+* Add `afterHeaderBuilder` and `beforeFooterBuilder` properties in `Dialog` fun
+* Add `UIKitCustom` to be able for simple creating of custom modifiers
+* Add support of `UIKitForm`
+
+## 0.0.35
+
+* Add `UIKitModal`
+* Improve work with dialogs
+
+## 0.0.34
+
+* Add `Alert`
+* Add `Animation#KenBurns`
+
+## 0.0.33
+
+* Fixes in attributes building and related things
+
+## 0.0.32
+
+* Support of `UIKitHeight`
+* New builder `AttributesBuilder`
+* New `Percents`/`Pixels` abstractions
+* Fixes in `UIKitWidth#Fixed` classnames
+
 ## 0.0.31
 
 * Support of `UIKitVisibility`

gradle.properties

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

src/jsMain/kotlin/dev/inmo/jsuikit/UIKitAttributeValueBuilder.kt

@@ -1,8 +1,11 @@
 package dev.inmo.jsuikit
 
 import dev.inmo.jsuikit.modifiers.AttributeValue
+import dev.inmo.jsuikit.utils.AttributeBuilder
+import dev.inmo.jsuikit.utils.buildAttribute
 import org.jetbrains.compose.web.attributes.AttrsBuilder
 
+@Deprecated("Will be removed soon")
 class UIKitAttributeValueBuilder {
     private val attrs = mutableListOf<Pair<String, String>>()
 
@@ -21,7 +24,10 @@ class UIKitAttributeValueBuilder {
 
 fun AttrsBuilder<*>.buildAndAddAttribute(
     attributeName: String,
-    block: UIKitAttributeValueBuilder.() -> Unit
+    skipNullValues: Boolean = true,
+    block: AttributeBuilder.() -> Unit
 ) {
-    attr(attributeName, UIKitAttributeValueBuilder().apply(block).build())
+    buildAttribute(attributeName, skipNullValues, block).let {
+        attr(it.first, it.second)
+    }
 }

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

@@ -0,0 +1,89 @@
+package dev.inmo.jsuikit.elements
+
+import androidx.compose.runtime.Composable
+import dev.inmo.jsuikit.modifiers.UIKitAccordion
+import dev.inmo.jsuikit.modifiers.include
+import dev.inmo.jsuikit.utils.Attrs
+import org.jetbrains.compose.web.attributes.AttrsBuilder
+import org.jetbrains.compose.web.dom.*
+import org.w3c.dom.*
+
+@Composable
+fun <T> Accordion(
+    data: Iterable<T>,
+    attrs: Attrs<HTMLUListElement> = Attrs.empty(),
+    itemAttrsBuilder: AttrsBuilder<HTMLLIElement>.(Int, T) -> Unit = { _, _ -> },
+    itemContentBuilder: @Composable ElementScope<HTMLLIElement>.(Int, T) -> Unit
+) {
+    Ul(
+        {
+            include(UIKitAccordion)
+            attrs.builder(this)
+        }
+    ) {
+        data.forEachIndexed { i, t ->
+            Li({ itemAttrsBuilder(i, t) }) {
+                itemContentBuilder(i, t)
+            }
+        }
+    }
+}
+
+@Composable
+fun <T> DefaultAccordion(
+    data: Iterable<T>,
+    attrs: Attrs<HTMLUListElement> = Attrs.empty(),
+    itemAttrsBuilder: AttrsBuilder<HTMLLIElement>.(Int, T) -> Unit = { _, _ -> },
+    titleAttrsBuilder: AttrsBuilder<HTMLAnchorElement>.(Int, T) -> Unit = { _, _ -> },
+    titleContentBuilder: @Composable ElementScope<HTMLAnchorElement>.(Int, T) -> Unit = { _, _ -> },
+    beforeTitleContentBuilder: @Composable ElementScope<HTMLLIElement>.(Int, T) -> Unit = { _, _ -> },
+    afterTitleContentBuilder: @Composable ElementScope<HTMLLIElement>.(Int, T) -> Unit = { _, _ -> },
+    afterContentContentBuilder: @Composable  ElementScope<HTMLLIElement>.(Int, T) -> Unit = { _, _ -> },
+    contentAttrsBuilder: AttrsBuilder<HTMLDivElement>.(Int, T) -> Unit = { _, _ -> },
+    contentContentBuilder: @Composable ElementScope<HTMLDivElement>.(Int, T) -> Unit
+) = Accordion(
+    data,
+    attrs,
+    itemAttrsBuilder
+) { i, t ->
+    beforeTitleContentBuilder(i, t)
+    A(
+        attrs = {
+            include(UIKitAccordion.Title)
+            titleAttrsBuilder(i, t)
+        }
+    ) {
+        titleContentBuilder(i, t)
+    }
+    afterTitleContentBuilder(i, t)
+    Div(
+        {
+            include(UIKitAccordion.Content)
+            contentAttrsBuilder(i, t)
+        }
+    ) {
+        contentContentBuilder(i, t)
+    }
+    afterContentContentBuilder(i, t)
+}
+
+@Composable
+fun <T> DefaultAccordion(
+    data: Iterable<T>,
+    titleResolver: (Int, T) -> String,
+    attrs: Attrs<HTMLUListElement> = Attrs.empty(),
+    itemAttrsBuilder: AttrsBuilder<HTMLLIElement>.(Int, T) -> Unit = { _, _ -> },
+    titleAttrsBuilder: AttrsBuilder<HTMLAnchorElement>.(Int, T) -> Unit = { _, _ -> },
+    contentAttrsBuilder: AttrsBuilder<HTMLDivElement>.(Int, T) -> Unit = { _, _ -> },
+    contentContentBuilder: @Composable ElementScope<HTMLDivElement>.(Int, T) -> Unit
+) = DefaultAccordion(
+    data,
+    attrs,
+    itemAttrsBuilder,
+    titleAttrsBuilder,
+    { i, t ->
+        org.jetbrains.compose.web.dom.Text(titleResolver(i, t))
+    },
+    contentAttrsBuilder = contentAttrsBuilder,
+    contentContentBuilder = contentContentBuilder
+)

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

@@ -0,0 +1,49 @@
+package dev.inmo.jsuikit.elements
+
+import androidx.compose.runtime.Composable
+import dev.inmo.jsuikit.buildAndAddAttribute
+import dev.inmo.jsuikit.modifiers.*
+import dev.inmo.jsuikit.utils.Attrs
+import dev.inmo.jsuikit.utils.Milliseconds
+import org.jetbrains.compose.web.dom.*
+import org.w3c.dom.HTMLAnchorElement
+import org.w3c.dom.HTMLDivElement
+
+@Composable
+fun Alert(
+    attrs: Attrs<HTMLDivElement> = Attrs.empty(),
+    animation: UIKitAnimation? = UIKitAnimation.Fade,
+    duration: Milliseconds? = null,
+    selClose: String? = null,
+    content: ContentBuilder<HTMLDivElement>
+) = Div(
+    {
+        attrs.builder(this)
+        include(UIKitAlert)
+
+        buildAndAddAttribute("uk-alert") {
+            "animation" to animation ?.classes ?.firstOrNull()
+            "duration" to duration
+            "sel-close" to selClose
+        }
+    },
+    content
+)
+
+@Composable
+fun AlertCloseButton(
+    attrs: Attrs<HTMLAnchorElement> = Attrs.empty(),
+    content: ContentBuilder<HTMLAnchorElement> = @Composable {}
+) {
+    A(
+        null,
+        {
+            include(UIKitAlert.Close, UIKitIcon)
+            attr("uk-close", "")
+            classes("uk-close")
+            attrs.builder(this)
+        },
+        content
+    )
+
+}

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

@@ -45,16 +45,16 @@ fun Comment(
 
 @Composable
 fun DefaultComment(
+    rootAttrs: Attrs<HTMLElement> = Attrs.empty(),
     headerGridAttrs: Attrs<HTMLDivElement>? = null,
+    headerAttrs: Attrs<HTMLElement>? = null,
+    additionalHeaderContent: ContentBuilder<HTMLElement>? = null,
     avatarUrl: String? = null,
     avatarAttrs: Attrs<HTMLImageElement>? = null,
     titleAttrs: Attrs<HTMLHeadingElement>? = null,
     titleContent: ContentBuilder<HTMLHeadingElement>? = null,
     metaAttrs: Attrs<HTMLUListElement>? = null,
     metaContent: ContentBuilder<HTMLUListElement>? = null,
-    rootAttrs: Attrs<HTMLElement> = Attrs.empty(),
-    headerAttrs: Attrs<HTMLElement>? = null,
-    additionalHeaderContent: ContentBuilder<HTMLElement>? = null,
     bodyAttrs: Attrs<HTMLDivElement>? = null,
     bodyContent: ContentBuilder<HTMLDivElement>? = null,
 ) {

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

@@ -2,8 +2,7 @@ package dev.inmo.jsuikit.elements
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.DisposableEffectResult
-import dev.inmo.jsuikit.modifiers.UIKitModifier
-import dev.inmo.jsuikit.modifiers.include
+import dev.inmo.jsuikit.modifiers.*
 import org.jetbrains.compose.web.dom.*
 import org.jetbrains.compose.web.dom.Text
 import org.w3c.dom.*
@@ -25,18 +24,25 @@ private class DialogDisposableEffectResult(
 
 @Composable
 fun Dialog(
-    title: String? = null,
     vararg modifiers: UIKitModifier,
-    hide: (() -> Unit)? = null,
-    hidden: (() -> Unit)? = null,
-    footerBuilder: (@Composable () -> Unit)? = null,
     attributesCustomizer: AttrBuilderContext<HTMLDivElement> = {},
-    bodyBuilder: @Composable () -> Unit
+    onHide: (() -> Unit)? = null,
+    onHidden: (() -> Unit)? = null,
+    dialogAttrsBuilder: AttrBuilderContext<HTMLDivElement>? = null,
+    headerAttrsBuilder: AttrBuilderContext<HTMLDivElement>? = null,
+    headerBuilder: ContentBuilder<HTMLDivElement>? = null,
+    afterHeaderBuilder: ContentBuilder<HTMLDivElement>? = null,
+    beforeFooterBuilder: ContentBuilder<HTMLDivElement>? = null,
+    footerAttrsBuilder: AttrBuilderContext<HTMLDivElement>? = null,
+    footerBuilder: ContentBuilder<HTMLDivElement>? = null,
+    bodyAttrsBuilder: AttrBuilderContext<HTMLDivElement>? = null,
+    bodyBuilder: ContentBuilder<HTMLDivElement>
 ) {
     Div(
         {
-            attr("uk-modal", "")
-            classes("uk-flex-top", "uk-modal")
+            if (modifiers.none { it is UIKitModal.WithCustomAttributes }) {
+                include(UIKitModal)
+            }
             id("dialog${Random.nextUInt()}")
             include(*modifiers)
             attributesCustomizer()
@@ -44,40 +50,44 @@ fun Dialog(
     ) {
         Div(
             {
-                classes("uk-modal-dialog", "uk-margin-auto-vertical")
+                include(UIKitModal.Dialog)
+                dialogAttrsBuilder ?.let { it() } ?: include(UIKitMargin.Auto.Vertical)
             }
         ) {
-            title ?.let {
+            headerBuilder ?.let {
                 Div(
                     {
-                        classes("uk-modal-header")
+                        include(UIKitModal.Header)
+                        headerAttrsBuilder ?.let { it() }
                     }
                 ) {
-                    H2({ classes("uk-modal-title") }) {
-                        Text(title)
-                    }
+                    it()
                 }
             }
+            afterHeaderBuilder ?.let { it() }
             Div(
                 {
-                    classes("uk-modal-body")
+                    include(UIKitModal.Body)
+                    bodyAttrsBuilder ?.let { it() }
                 }
             ) {
                 bodyBuilder()
             }
+            beforeFooterBuilder ?.let { it() }
             footerBuilder ?.let {
                 Div(
                     {
-                        classes("uk-modal-footer", "uk-text-right")
+                        include(UIKitModal.Footer)
+                        footerAttrsBuilder ?.let { it() } ?: include(UIKitText.Alignment.Horizontal.Right)
                     }
                 ) {
-                    footerBuilder()
+                    it()
                 }
             }
         }
 
         DisposableRefEffect {
-            DialogDisposableEffectResult(it, hide, hidden)
+            DialogDisposableEffectResult(it, onHide, onHidden)
         }
 
         DomSideEffect { htmlElement ->
@@ -85,13 +95,44 @@ fun Dialog(
             wrapper = { it: Event ->
                 htmlElement.removeEventListener("hidden", wrapper)
                 htmlElement.remove()
-                hidden ?.invoke()
+                onHidden ?.invoke()
             }
             htmlElement.addEventListener("hidden", wrapper)
 
-            val dialog = js("UIkit").modal("#${htmlElement.id}")
+            val dialog = UIKit.modal("#${htmlElement.id}")
             dialog.show()
             Unit
         }
     }
 }
+
+@Composable
+fun Dialog(
+    title: String,
+    vararg modifiers: UIKitModifier,
+    hide: (() -> Unit)? = null,
+    hidden: (() -> Unit)? = null,
+    footerBuilder: (@Composable () -> Unit)? = null,
+    attributesCustomizer: AttrBuilderContext<HTMLDivElement> = {},
+    bodyBuilder: @Composable () -> Unit
+) = Dialog(
+    modifiers = modifiers,
+    headerBuilder = {
+        H2({ include(UIKitModal.Title) }) {
+            Text(title)
+        }
+    },
+    onHide = hide,
+    onHidden = hidden,
+    footerBuilder = footerBuilder ?.let { _ ->
+        {
+            footerBuilder()
+        }
+    },
+    attributesCustomizer = {
+        attributesCustomizer()
+    },
+    bodyBuilder = {
+        bodyBuilder()
+    }
+)

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

@@ -4,6 +4,7 @@ import androidx.compose.runtime.Composable
 import dev.inmo.jsuikit.buildAndAddAttribute
 import dev.inmo.jsuikit.modifiers.*
 import dev.inmo.jsuikit.utils.Milliseconds
+import dev.inmo.jsuikit.utils.buildAttribute
 import org.jetbrains.compose.web.dom.*
 import org.w3c.dom.HTMLDivElement
 

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

@@ -211,8 +211,7 @@ sealed class Icon(val name: String) {
         onClick: ((Event) -> Unit)? = null
     ) {
         val configurer: AttrBuilderContext<out HTMLElement> = {
-            classes("uk-icon")
-            include(*modifiers, type)
+            include(*modifiers, type, UIKitIcon)
             attr("uk-icon", "icon: $name${if (ratio != null) { "; ratio: $ratio" } else ""}")
             onClick ?.let { _ ->
                 onClick { onClick(it.nativeEvent) }
@@ -251,4 +250,12 @@ sealed class Icon(val name: String) {
         attributesCustomizer: AttrBuilderContext<out HTMLElement> = {},
         onClick: ((Event) -> Unit)? = null
     ) = invoke(*modifiers, type = UIKitIconType.Link, ratio = ratio, onClick = onClick, attributesCustomizer = attributesCustomizer)
+
+    @Composable
+    fun drawAsFormInputPart(
+        vararg modifiers: UIKitModifier,
+        ratio: Float? = null,
+        attributesCustomizer: AttrBuilderContext<out HTMLElement> = {},
+        onClick: ((Event) -> Unit)? = null
+    ) = invoke(*modifiers, UIKitForm.Icon, ratio = ratio, onClick = onClick, attributesCustomizer = attributesCustomizer)
 }

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

@@ -0,0 +1,51 @@
+package dev.inmo.jsuikit.modifiers
+
+import dev.inmo.jsuikit.utils.*
+import org.w3c.dom.PageTransitionEvent
+
+sealed class UIKitAccordion(
+    vararg classnames: String,
+    override val otherAttrs: Map<String, String> = emptyMap()
+) : UIKitModifier {
+    @Suppress("UNCHECKED_CAST")
+    override val classes: Array<String> = classnames as Array<String>
+
+    object Title : UIKitAccordion("uk-accordion-title")
+    object Content : UIKitAccordion("uk-accordion-content")
+
+    class Custom internal constructor(
+        otherAttrs: Map<String, String> = emptyMap()
+    ) : UIKitAccordion (otherAttrs = otherAttrs)
+
+    companion object : UIKitAccordion("uk-accordion", otherAttrs = mapOf("uk-accordion" to "")) {
+        val Open = UIKitUtility.Open
+
+        operator fun invoke(
+            activeItemIndex: Int? = null,
+            animation: Boolean? = null,
+            collapsible: Boolean? = null,
+            contentSelector: String? = null,
+            animationDuration: Milliseconds? = null,
+            multiple: Boolean? = null,
+            targetsSelector: String? = null,
+            toggleSelector: String? = null,
+            transition: PageTransitionEvent? = null,
+            offsetTopPixels: Int? = null,
+        ) = Custom(
+            mapOf(
+                buildAttribute("uk-accordion") {
+                    "active" to activeItemIndex
+                    "animation" to animation
+                    "collapsible" to collapsible
+                    "content" to contentSelector
+                    "duration" to animationDuration
+                    "multiple" to multiple
+                    "targets" to targetsSelector
+                    "toggle" to toggleSelector
+                    "transition" to transition
+                    "offset" to offsetTopPixels
+                }
+            )
+        )
+    }
+}

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

@@ -0,0 +1,18 @@
+package dev.inmo.jsuikit.modifiers
+
+sealed class UIKitAlert(classname: String) : UIKitModifier {
+    override val classes: Array<String> = arrayOf(classname)
+
+    sealed class Style(classname: String) : UIKitAlert(classname) {
+
+        object Primary : Style("uk-alert-primary")
+        object Success : Style("uk-alert-success")
+        object Warning : Style("uk-alert-warning")
+        object Danger : Style("uk-alert-danger")
+
+    }
+
+    object Close : UIKitAlert("uk-alert-close")
+
+    companion object : UIKitAlert("uk-alert")
+}

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

@@ -60,4 +60,9 @@ sealed class UIKitAnimation (name: String) : UIKitModifier, AttributeValue(name)
 
     object Fast : UIKitAnimation("fast")
 
+    object KenBurns : UIKitAnimation("kenburns")
+
+    override fun toString(): String {
+        return classes.joinToString(" ")
+    }
 }

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

@@ -0,0 +1,6 @@
+package dev.inmo.jsuikit.modifiers
+
+class UIKitCustom(
+    override val classes: Array<String> = emptyArray(),
+    override val otherAttrs: Map<String, String> = emptyMap()
+) : UIKitModifier

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

@@ -0,0 +1,58 @@
+package dev.inmo.jsuikit.modifiers
+
+import dev.inmo.jsuikit.utils.buildAttribute
+
+sealed class UIKitForm(
+    vararg classnames: String,
+    override val otherAttrs: Map<String, String> = emptyMap()
+) : UIKitModifier {
+    @Suppress("UNCHECKED_CAST")
+    override val classes: Array<String> = classnames as Array<String>
+
+    object Fieldset : UIKitForm("uk-fieldset")
+    object Legend : UIKitForm("uk-legend")
+
+    object Input : UIKitForm("uk-input")
+    object Select : UIKitForm("uk-select")
+    object TextArea : UIKitForm("uk-textarea")
+    object Radio : UIKitForm("uk-radio", otherAttrs = mapOf("type" to "radio"))
+    object Checkbox : UIKitForm("uk-checkbox", otherAttrs = mapOf("type" to "checkbox"))
+    object Range : UIKitForm("uk-range", otherAttrs = mapOf("type" to "range"))
+
+    sealed class State(vararg classnames: String) : UIKitForm(*classnames) {
+        object Danger : State("uk-form-danger")
+        object Success : State("uk-form-success")
+    }
+    sealed class Size(vararg classnames: String) : UIKitForm(*classnames) {
+        object Large : Size("uk-form-large")
+        object Default : Size() // :)
+        object Small : Size("uk-form-small")
+    }
+    sealed class Width(vararg classnames: String) : UIKitForm(*classnames) {
+        object Large : Width("uk-form-width-large")
+        object Medium : Width("uk-form-width-medium")
+        object Small : Width("uk-form-width-small")
+        object XSmall : Width("uk-form-width-xsmall")
+    }
+
+    object Blank : UIKitForm("uk-form-blank")
+
+    sealed class Layout(vararg classnames: String) : UIKitForm(*classnames) {
+        object Stacked : Layout("uk-form-stacked")
+        object Horizontal : Layout("uk-form-horizontal")
+        object Label : Layout("uk-form-label")
+        object Controls : Layout("uk-form-controls")
+    }
+
+    object Icon : UIKitForm("uk-form-icon")
+
+    class Custom(
+        target: String = "true"
+    ) : UIKitForm(
+        otherAttrs = mapOf(
+            buildAttribute("uk-form-custom") {
+                "target" to target
+            }
+        )
+    )
+}

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

@@ -0,0 +1,80 @@
+package dev.inmo.jsuikit.modifiers
+
+import dev.inmo.jsuikit.utils.*
+import org.jetbrains.compose.web.css.CSSKeyframe
+
+sealed class UIKitHeight(
+    classname: String?,
+    override val otherAttrs: Map<String, String> = emptyMap()
+) : UIKitModifier {
+    override val classes: Array<String> = classname ?.let { arrayOf(it) } ?: emptyArray()
+
+    object Full : UIKitHeight("uk-height-1-1")
+
+    sealed class Size(classname: String) : UIKitHeight(classname) {
+
+        sealed class Small(classname: String = "uk-height-small") : Size(classname) {
+            object Max : Small("uk-height-max-small")
+
+            companion object : Small()
+        }
+
+        sealed class Medium(classname: String = "uk-height-medium") : Size(classname) {
+            object Max : Medium("uk-height-max-medium")
+
+            companion object : Medium()
+        }
+
+        sealed class Large(classname: String = "uk-height-large") : Size(classname) {
+            object Max : Large("uk-height-max-large")
+
+            companion object : Large()
+        }
+
+    }
+
+    class Viewport(offsetTop: Boolean? = null, offsetBottom: String? = null, expand: Boolean? = null, minHeight: Int? = null) : UIKitHeight(
+        null,
+        mapOf(
+            buildAttribute("uk-height-viewport") {
+                offsetTop ?.let { "offset-top" to it.toString() }
+                offsetBottom ?.let { "offset-bottom" to it }
+                expand ?.let { "expand" to it.toString() }
+                minHeight ?.let { "min-height" to it.toString() }
+            }
+        )
+    )
+
+    fun Viewport(
+        offsetTop: Boolean? = null,
+        offsetBottom: Boolean,
+        expand: Boolean? = null,
+        minHeight: Int? = null
+    ) = Viewport(offsetTop, offsetBottom.toString(), expand, minHeight)
+
+    fun Viewport(
+        offsetTop: Boolean? = null,
+        offsetBottom: Pixels,
+        expand: Boolean? = null,
+        minHeight: Int? = null
+    ) = Viewport(offsetTop, offsetBottom.toString(), expand, minHeight)
+
+    fun Viewport(
+        offsetTop: Boolean? = null,
+        offsetBottom: Percents,
+        expand: Boolean? = null,
+        minHeight: Int? = null
+    ) = Viewport(offsetTop, offsetBottom.toString(), expand, minHeight)
+
+
+    class Match(target: String? = null, row: Boolean? = null) : UIKitHeight(
+        null,
+        mapOf(
+            buildAttribute("uk-height-match") {
+                target ?.let { "target" to it }
+                row ?.let { "row" to it.toString() }
+            }
+        )
+    )
+
+}

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

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

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

@@ -1,68 +1,87 @@
 package dev.inmo.jsuikit.modifiers
 
-sealed class UIKitMargin(val classname: String) : UIKitModifier {
-    override val classes: Array<String> = arrayOf(classname)
+sealed class UIKitMargin(vararg classnames: String) : UIKitModifier {
+    @Suppress("UNCHECKED_CAST")
+    override val classes: Array<String> = classnames as Array<String>
 
-    object Top : Small("uk-margin-top")
-    object Bottom : Small("uk-margin-bottom")
-    object Left : Small("uk-margin-left")
-    object Right : Small("uk-margin-right")
+    object Top : UIKitMargin("uk-margin-top")
+    object Bottom : UIKitMargin("uk-margin-bottom")
+    object Left : UIKitMargin("uk-margin-left")
+    object Right : UIKitMargin("uk-margin-right")
+    object Vertical : UIKitMargin() { override val classes: Array<String> = Top.classes + Bottom.classes }
+    object Horizontal : UIKitMargin() { override val classes: Array<String> = Left.classes + Right.classes }
     companion object : Small("uk-margin")
 
-    sealed class Small(classname: String) : UIKitMargin(classname) {
+    sealed class Small(vararg classnames: String) : UIKitMargin(*classnames) {
 
         object Top : Small("uk-margin-small-top")
         object Bottom : Small("uk-margin-small-bottom")
         object Left : Small("uk-margin-small-left")
         object Right : Small("uk-margin-small-right")
+
+        object Vertical : Small() {
+            override val classes: Array<String> = Top.classes + Bottom.classes
+        }
+        object Horizontal : Small() {
+            override val classes: Array<String> = Left.classes + Right.classes
+        }
+
         companion object : Small("uk-margin-small")
 
     }
-    sealed class Medium(classname: String) : UIKitMargin(classname) {
+    sealed class Medium(vararg classnames: String) : UIKitMargin(*classnames) {
 
         object Top : Medium("uk-margin-medium-top")
         object Bottom : Medium("uk-margin-medium-bottom")
         object Left : Medium("uk-margin-medium-left")
         object Right : Medium("uk-margin-medium-right")
+        object Vertical : Medium() { override val classes: Array<String> = Top.classes + Bottom.classes }
+        object Horizontal : Medium() { override val classes: Array<String> = Left.classes + Right.classes }
         companion object : Medium("uk-margin-medium")
 
     }
-    sealed class Large(classname: String) : UIKitMargin(classname) {
+    sealed class Large(vararg classnames: String) : UIKitMargin(*classnames) {
 
         object Top : Large("uk-margin-large-top")
         object Bottom : Large("uk-margin-large-bottom")
         object Left : Large("uk-margin-large-left")
         object Right : Large("uk-margin-large-right")
+        object Vertical : Large() { override val classes: Array<String> = Top.classes + Bottom.classes }
+        object Horizontal : Large() { override val classes: Array<String> = Left.classes + Right.classes }
         companion object : Large("uk-margin-large")
 
     }
-    sealed class XLarge(classname: String) : UIKitMargin(classname) {
+    sealed class XLarge(vararg classnames: String) : UIKitMargin(*classnames) {
 
         object Top : XLarge("uk-margin-xlarge-top")
         object Bottom : XLarge("uk-margin-xlarge-bottom")
         object Left : XLarge("uk-margin-xlarge-left")
         object Right : XLarge("uk-margin-xlarge-right")
+        object Vertical : XLarge() { override val classes: Array<String> = Top.classes + Bottom.classes }
+        object Horizontal : XLarge() { override val classes: Array<String> = Left.classes + Right.classes }
         companion object : XLarge("uk-margin-xlarge")
 
     }
-    sealed class Auto(classname: String) : UIKitMargin(classname) {
+    sealed class Auto(vararg classnames: String) : UIKitMargin(*classnames) {
 
         object Top : Auto("uk-margin-auto-top")
         object Bottom : Auto("uk-margin-auto-bottom")
         object Left : Auto("uk-margin-auto-left")
         object Right : Auto("uk-margin-auto-right")
         object Vertical : Auto("uk-margin-auto-vertical")
+        object Horizontal : Auto() { override val classes: Array<String> = Left.classes + Right.classes }
         companion object : Auto("uk-margin-auto")
 
     }
 
-    sealed class Remove(classname: String) : UIKitMargin(classname) {
+    sealed class Remove(vararg classnames: String) : UIKitMargin(*classnames) {
 
         object Top : Remove("uk-margin-remove-top")
         object Bottom : Remove("uk-margin-remove-bottom")
         object Left : Remove("uk-margin-remove-left")
         object Right : Remove("uk-margin-remove-right")
         object Vertical : Remove("uk-margin-remove-vertical")
+        object Horizontal : Remove() { override val classes: Array<String> = Left.classes + Right.classes }
         object Adjacent : Remove("uk-margin-remove-adjacent")
         object FirstChild : Remove("uk-margin-remove-first-child")
         object LastChild : Remove("uk-margin-remove-last-child")

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

@@ -0,0 +1,58 @@
+package dev.inmo.jsuikit.modifiers
+
+import dev.inmo.jsuikit.utils.buildAttribute
+
+sealed class UIKitModal(
+    classname: String,
+    override val otherAttrs: Map<String, String> = emptyMap()
+) : UIKitModifier {
+    override val classes: Array<String> = arrayOf(classname)
+
+    object Dialog : UIKitModal("uk-modal-dialog")
+    object Title : UIKitModal("uk-modal-title")
+
+    object Header : UIKitModal("uk-modal-header")
+    object Body : UIKitModal("uk-modal-body")
+    object Footer : UIKitModal("uk-modal-footer")
+
+    object Container : UIKitModal("uk-modal-container")
+    object Full : UIKitModal("uk-modal-full")
+
+    object Page : UIKitModal("uk-modal-page")
+
+    sealed class Close(classname: String) : UIKitModal(classname) {
+        object Default : Close("uk-modal-close-default")
+        object Outside : Close("uk-modal-close-outside")
+        object Full : Close("uk-modal-close-full")
+
+        companion object : Close("uk-modal-close")
+    }
+
+    internal class WithCustomAttributes(
+        otherAttrs: Map<String, String> = emptyMap()
+    ) : UIKitModal("uk-modal", otherAttrs)
+
+    companion object : UIKitModal("uk-modal", mapOf("uk-modal" to "")) {
+        operator fun invoke(
+            escClose: Boolean? = null,
+            backgroundClose: Boolean? = null,
+            stack: Boolean? = null,
+            container: Boolean? = null,
+            classPage: String? = null,
+            classPanel: String? = null,
+            closingSelection: String? = null,
+        ): UIKitModal = WithCustomAttributes(
+            mapOf(
+                buildAttribute("uk-modal") {
+                    "esc-close" to escClose
+                    "bg-close" to backgroundClose
+                    "stack" to stack
+                    "container" to container
+                    "cls-page" to classPage
+                    "cls-panel" to classPanel
+                    "sel-close" to closingSelection
+                }
+            )
+        )
+    }
+}

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

@@ -0,0 +1,64 @@
+package dev.inmo.jsuikit.modifiers
+
+import dev.inmo.jsuikit.utils.Milliseconds
+import dev.inmo.jsuikit.utils.buildAttribute
+
+sealed class UIKitToggle(
+    vararg classnames: String,
+    override val otherAttrs: Map<String, String>
+) : UIKitModifier {
+    @Suppress("UNCHECKED_CAST")
+    override val classes: Array<String> = classnames as Array<String>
+
+    sealed class Mode {
+        abstract val mode: String
+
+        object Click : Mode() {
+            override val mode: String
+                get() = "click"
+        }
+
+        object Hover : Mode() {
+            override val mode: String
+                get() = "hover"
+        }
+
+        object ClickAndHover : Mode() {
+            override val mode: String
+                get() = "${Click.mode}, ${Hover.mode}"
+        }
+
+        object Media : Mode() {
+            override val mode: String
+                get() = "media"
+        }
+
+        override fun toString(): String = mode
+    }
+
+    class Custom internal constructor(otherAttrs: Map<String, String>) : UIKitToggle(otherAttrs = otherAttrs)
+
+    companion object {
+        operator fun invoke(
+            target: String? = null,
+            mode: Mode? = null,
+            classesToApplyOnToggle: String? = null,
+            media: String? = null,
+            animation: UIKitAnimation? = null,
+            duration: Milliseconds? = null,
+            queued: Boolean? = null
+        ) = Custom(
+            mapOf(
+                buildAttribute("uk-toggle") {
+                    "target" to target
+                    "mode" to mode
+                    "cls" to classesToApplyOnToggle
+                    "media" to media
+                    "animation" to animation
+                    "duration" to duration
+                    "queued" to queued
+                }
+            )
+        )
+    }
+}

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

@@ -1,5 +1,7 @@
 package dev.inmo.jsuikit.modifiers
 
+import dev.inmo.jsuikit.utils.buildAttribute
+
 class UIKitTooltipModifier(
     text: String,
     align: Align? = null,
@@ -8,16 +10,15 @@ class UIKitTooltipModifier(
     duration: Int? = null,
     animation: UIKitAnimation? = null
 ) : UIKitModifier {
-    private val parametersMap = listOfNotNull(
-        "title" to text,
-        align ?.let { it.k to it.v },
-        delay ?.let { "delay" to it.toString() },
-        offset ?.let { "offset" to it.toString() },
-        duration ?.let { "duration" to it.toString() },
-        animation ?.let { "animation" to it.name },
-    )
     override val otherAttrs: Map<String, String> = mapOf(
-        "uk-tooltip" to parametersMap.joinToString(";") { (k, v) -> "$k: $v" }
+        buildAttribute("uk-tooltip") {
+            "title" to text
+            align ?.let { it.k to it.v }
+            delay ?.let { "delay" to it.toString() }
+            offset ?.let { "offset" to it.toString() }
+            duration ?.let { "duration" to it.toString() }
+            animation ?.let { "animation" to it.name }
+        }
     )
 
     sealed class Align(name: String) {

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

@@ -109,4 +109,6 @@ sealed class UIKitUtility(classname: String) : UIKitModifier {
     object Disabled : UIKitUtility("uk-disabled")
     object Drag : UIKitUtility("uk-drag")
     object Active : UIKitUtility("uk-active")
+
+    object Open : UIKitUtility("uk-open")
 }

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

@@ -57,7 +57,7 @@ sealed class UIKitWidth(classname: String) : UIKitModifier {
         }
     }
 
-    sealed class Fixed(suffix: String) : UIKitWidth("uk-width-fixed-$suffix") {
+    sealed class Fixed(suffix: String) : UIKitWidth("uk-width-$suffix") {
 
         object Small : Fixed("small")
         object Medium : Fixed("medium")

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

@@ -0,0 +1,27 @@
+package dev.inmo.jsuikit.utils
+
+class AttributeBuilder (
+    val attributeName: String,
+    val skipNullValues: Boolean = true,
+    private val parametersPreset: MutableMap<String, String?> = mutableMapOf()
+) {
+
+    fun add(k: String, v: Any? = null) {
+        if (v != null || !skipNullValues) {
+            parametersPreset[k] = v ?.toString()
+        }
+    }
+    infix fun String.to(value: Any?) = add(this, value)
+    operator fun String.unaryPlus() = add(this, null)
+
+    fun build(): Pair<String, String> = Pair(
+        attributeName, parametersPreset.toList().joinToString(";") {
+            "${it.first}${it.second ?.let { ": $it" } ?: ""}"
+        }
+    )
+}
+
+inline fun buildAttribute(attributeName: String, skipNullValues: Boolean = true, block: AttributeBuilder.() -> Unit) = AttributeBuilder(
+    attributeName,
+    skipNullValues
+).apply(block).build()

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

@@ -15,6 +15,13 @@ class AttributesCollection<T : Element> (
         attrs()
     }
 
+    operator fun plus(other: AttributesCollection<T>) = AttributesCollection<T>(
+        *(modifiers + other.modifiers).distinct().toTypedArray()
+    ) {
+        this@AttributesCollection.attrs.invoke(this)
+        other.attrs.invoke(this)
+    }
+
     companion object {
         val Empty = Attrs<Element>()
 

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

@@ -0,0 +1,5 @@
+package dev.inmo.jsuikit.utils
+
+value class Percents(val int: Int) {
+    override fun toString(): String = "${int}%"
+}

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

@@ -0,0 +1,5 @@
+package dev.inmo.jsuikit.utils
+
+value class Pixels(val int: Int) {
+    override fun toString(): String = "${int}px"
+}