Update libs.versions.toml

0.2.2

.github/workflows/build.yml

@@ -5,15 +5,11 @@ on: [push]
 jobs:
   build:
     runs-on: ubuntu-latest
-
     steps:
       - uses: actions/checkout@v2
-      - name: Set up JDK 1.8
+      - name: Set up JDK 11
         uses: actions/setup-java@v1
         with:
-          java-version: 1.8
-      - name: Fix android 31.0.0 dx
-        continue-on-error: true
-        run: cd /usr/local/lib/android/sdk/build-tools/31.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
+          java-version: 11
       - name: Build with Gradle
         run: ./gradlew build

CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.2.2
+
+* Add support of `Drop` component
+* Improve support of `Navbar`s
+
+## 0.2.1
+
+* `Tab` elements become supported
+
+## 0.2.0
+
+**ALL DEPRECATIONS HAVE BEEN REMOVED**
+
+* `Kotlin`: `1.7.0`
+* `Compose`: `1.2.0-alpha01-dev753`
+
+## 0.1.10
+
+* `Grid` support improvements
+
 ## 0.1.9
 
 * `Artile` elements become supported

gradle.properties

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

gradle/libs.versions.toml

@@ -1,8 +1,8 @@
 [versions]
 
-kt = "1.6.21"
-jb-compose = "1.2.0-alpha01-dev731"
-jb-dokka = "1.6.21"
+kt = "1.7.10"
+jb-compose = "1.2.0-beta01"
+jb-dokka = "1.7.10"
 gh-release = "2.4.1"
 
 [libraries]

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

@@ -1,26 +1,8 @@
 package dev.inmo.jsuikit
 
-import dev.inmo.jsuikit.modifiers.AttributeValue
 import dev.inmo.jsuikit.utils.*
 import org.jetbrains.compose.web.attributes.AttrsScope
 
-@Deprecated("Will be removed soon")
-class UIKitAttributeValueBuilder {
-    private val attrs = mutableListOf<Pair<String, String>>()
-
-    infix fun String.to(other: String?) {
-        other ?.let {
-            attrs.add(Pair(this, other))
-        }
-    }
-
-    infix fun String.to(other: AttributeValue?) {
-        this to other ?.name
-    }
-
-    fun build(): String = attrs.joinToString(";") { (k, v) -> "$k: $v" }
-}
-
 fun AttrsScope<*>.buildAndAddAttribute(
     attributeName: String,
     skipNullValues: Boolean = true,

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

@@ -0,0 +1,24 @@
+package dev.inmo.jsuikit.elements
+
+import androidx.compose.runtime.Composable
+import dev.inmo.jsuikit.modifiers.UIKitDrop
+import dev.inmo.jsuikit.modifiers.attrsBuilder
+import dev.inmo.jsuikit.utils.*
+import org.jetbrains.compose.web.dom.Div
+import org.w3c.dom.HTMLButtonElement
+import org.w3c.dom.HTMLDivElement
+
+@Composable
+fun Drop(
+    buttonBuilder: AttrsWithContentBuilder<HTMLButtonElement>,
+    dropBuilder: AttrsWithContentBuilder<HTMLDivElement>
+) {
+    DefaultButton(
+        attributesCustomizer = buttonBuilder.attributesBuilderContext,
+        contentAllocator = buttonBuilder.builder
+    )
+    Div(
+        (Attrs<HTMLDivElement>(UIKitDrop.Custom()) + dropBuilder.attrs).builder,
+        dropBuilder.builder
+    )
+}

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

@@ -10,7 +10,7 @@ import org.w3c.dom.HTMLLIElement
 import org.w3c.dom.HTMLUListElement
 
 @Composable
-fun <T> Iconnav(
+fun <T> IconNav(
     data: Iterable<T>,
     listAttrs: Attrs<HTMLUListElement> = Attrs.empty(),
     elementAttrsBuilder: AttrsScope<HTMLLIElement>.(T) -> Unit = {},
@@ -31,3 +31,11 @@ fun <T> Iconnav(
         }
     }
 }
+
+@Composable
+fun <T> Iconnav(
+    data: Iterable<T>,
+    listAttrs: Attrs<HTMLUListElement> = Attrs.empty(),
+    elementAttrsBuilder: AttrsScope<HTMLLIElement>.(T) -> Unit = {},
+    elementBuilder: @Composable ElementScope<HTMLLIElement>.(T) -> Unit
+) = IconNav(data, listAttrs, elementAttrsBuilder, elementBuilder)

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

@@ -43,25 +43,3 @@ fun <T> ListWithTitle(
     besidesTitleAndList ?.invoke()
     List(data, Attrs(*ulModifiers) { ulCustomizer(this) }, elementAllocator)
 }
-
-@Deprecated("Renamed", ReplaceWith("ListWithTitle", "dev.inmo.jsuikit.elements.ListWithTitle"))
-@Composable
-fun <T> List(
-    title: String,
-    data: SnapshotStateList<T>,
-    vararg titleModifiers: UIKitModifier,
-    ulModifiers: Array<UIKitModifier> = emptyArray(),
-    besidesTitleAndList: (@Composable () -> Unit)? = null,
-    titleCustomizer: AttrBuilderContext<HTMLHeadingElement> = {},
-    ulCustomizer: AttrBuilderContext<HTMLUListElement> = {},
-    elementAllocator: @Composable ElementScope<HTMLUListElement>.(T) -> Unit
-) = ListWithTitle(
-    title,
-    data,
-    *titleModifiers,
-    ulModifiers = ulModifiers,
-    besidesTitleAndList = besidesTitleAndList,
-    titleCustomizer = titleCustomizer,
-    ulCustomizer = ulCustomizer,
-    elementAllocator = elementAllocator
-)

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

@@ -22,33 +22,6 @@ fun Navbar(
     }
 }
 
-@Deprecated("Will be removed soon. Use the variant with AttrsWithContentBuilders")
-@Composable
-fun Navbar(
-    leftBuilder: NavbarNavBuilder?,
-    centerBuilder: NavbarNavBuilder? = null,
-    rightBuilder: NavbarNavBuilder? = null,
-    vararg navModifiers: UIKitModifier,
-    attributesCustomizer: AttrBuilderContext<HTMLElement> = {},
-) {
-    Navbar(
-        {
-            include(*navModifiers)
-            attributesCustomizer()
-        }
-    ) {
-        leftBuilder ?.let {
-            Div({ include(UIKitNavbar.Alignment.Left) }) { it.draw() }
-        }
-        centerBuilder ?.let {
-            Div({ include(UIKitNavbar.Alignment.Center) }) { it.draw() }
-        }
-        rightBuilder ?.let {
-            Div({ include(UIKitNavbar.Alignment.Right) }) { it.draw() }
-        }
-    }
-}
-
 @Composable
 fun Navbar(
     leftBuilder: AttrsWithContentBuilder<HTMLDivElement>? = null,

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

@@ -5,8 +5,7 @@ import dev.inmo.jsuikit.modifiers.*
 import dev.inmo.jsuikit.utils.*
 import org.jetbrains.compose.web.attributes.AttrsScope
 import org.jetbrains.compose.web.dom.*
-import org.w3c.dom.HTMLLIElement
-import org.w3c.dom.HTMLUListElement
+import org.w3c.dom.*
 
 @Composable
 fun NavbarNav(
@@ -31,57 +30,16 @@ fun NavbarNav(
     attrs: Attrs<HTMLUListElement> = Attrs.empty()
 ) = NavbarNav(elements.toList(), attrs)
 
-@Deprecated("Will be removed soon. Use NavbarNavPart with AttrsWithContentBuilder instead")
-interface NavbarNavElement {
-    fun AttrsScope<HTMLLIElement>.setup() {}
-    @Composable
-    fun ElementScope<HTMLLIElement>.fill()
-
-    class Default(
-        private val setupCallback: AttrsScope<HTMLLIElement>.() -> Unit,
-        private val fillCallback: @Composable ElementScope<HTMLLIElement>.() -> Unit
-    ) : NavbarNavElement {
-        override fun AttrsScope<HTMLLIElement>.setup() {
-            setupCallback()
-        }
-
-        @Composable
-        override fun ElementScope<HTMLLIElement>.fill() {
-            fillCallback()
-        }
-    }
+fun NavbarNavBuilder(
+    elements: List<AttrsWithContentBuilder<HTMLLIElement>>,
+    attrs: Attrs<HTMLUListElement> = Attrs.empty(),
+    containerAttrs: Attrs<HTMLDivElement> = Attrs.empty()
+) = AttrsWithContentBuilder<HTMLDivElement>(containerAttrs) {
+    NavbarNav(elements, attrs)
 }
 
-@Deprecated("Will be removed soon. Use NavbarNavPart with AttrsWithContentBuilder instead")
-class NavbarNavBuilder(
-    private val modifiers: Array<UIKitModifier>,
-    private val elements: List<NavbarNavElement>,
-    private val attributesCustomizer: AttrBuilderContext<HTMLUListElement> = {}
-) {
-    constructor(
-        modifiers: Array<UIKitModifier>,
-        vararg elements: NavbarNavElement,
-        attributesCustomizer: AttrBuilderContext<HTMLUListElement> = {}
-    ) : this(modifiers, elements.toList(), attributesCustomizer)
-    constructor(
-        vararg elements: NavbarNavElement,
-        attributesCustomizer: AttrBuilderContext<HTMLUListElement> = {}
-    ) : this(emptyArray(), elements.toList(), attributesCustomizer)
-    @Composable
-    fun draw() {
-        Ul(
-            {
-                include(UIKitNavbar.Nav, *modifiers)
-                attributesCustomizer()
-            }
-        ) {
-            elements.forEach { element ->
-                Li(
-                    { element.apply { setup() } }
-                ) {
-                    element.apply { fill() }
-                }
-            }
-        }
-    }
-}
+fun NavbarNavBuilder(
+    vararg elements: AttrsWithContentBuilder<HTMLLIElement>,
+    attrs: Attrs<HTMLUListElement> = Attrs.empty(),
+    containerAttrs: Attrs<HTMLDivElement> = Attrs.empty()
+) = NavbarNavBuilder(elements.toList(), attrs, containerAttrs)

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

@@ -41,14 +41,3 @@ fun <T> StandardInput(
         attributesCustomizer()
     }
 }
-
-@Composable
-@Deprecated("Renamed", ReplaceWith("StandardInput", "dev.inmo.jsuikit.elements.StandardInput"))
-fun <T> TextField(
-    type: InputType<T>,
-    state: MutableState<T>,
-    disabledState: State<Boolean>? = null,
-    placeholder: String? = null,
-    vararg modifiers: UIKitModifier,
-    attributesCustomizer: AttrBuilderContext<HTMLInputElement> = {},
-) = StandardInput(type, state, disabledState, placeholder, modifiers = modifiers, attributesCustomizer)

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

@@ -0,0 +1,46 @@
+package dev.inmo.jsuikit.elements
+
+import androidx.compose.runtime.Composable
+import dev.inmo.jsuikit.modifiers.UIKitTab
+import dev.inmo.jsuikit.modifiers.include
+import dev.inmo.jsuikit.utils.optionallyDraw
+import org.jetbrains.compose.web.attributes.AttrsScope
+import org.jetbrains.compose.web.dom.*
+import org.w3c.dom.HTMLLIElement
+import org.w3c.dom.HTMLUListElement
+
+@Composable
+fun <T> Tabs(
+    data: Iterable<T>,
+    tabsItemBuilder: @Composable ElementScope<HTMLLIElement>.(i: Int, data: T) -> Unit,
+    tabsItemAttrs: AttrsScope<HTMLLIElement>.(i: Int, data: T) -> Unit = { _, _ -> },
+    tabsContainerAttrs: AttrsScope<HTMLUListElement>.() -> Unit = {},
+    contentContainerAttrs: (AttrsScope<HTMLUListElement>.() -> Unit)? = null,
+    contentItemAttrs: (AttrsScope<HTMLLIElement>.(i: Int, data: T) -> Unit)? = null,
+    contentItemBuilder: (@Composable ElementScope<HTMLLIElement>.(i: Int, data: T) -> Unit)? = null
+) {
+    Ul({
+        include(UIKitTab);
+        tabsContainerAttrs()
+    }) {
+        data.forEachIndexed { i, data ->
+            Li({ tabsItemAttrs(i, data) }) {
+                tabsItemBuilder(i, data)
+            }
+        }
+    }
+
+    optionallyDraw(contentItemAttrs != null, contentItemBuilder != null, contentContainerAttrs != null) {
+        Ul({
+            contentContainerAttrs ?.invoke(this)
+        }) {
+            optionallyDraw(contentItemAttrs != null, contentItemBuilder != null) {
+                data.forEachIndexed { i, data ->
+                    Li({ contentItemAttrs ?.invoke(this, i, data) }) {
+                        contentItemBuilder ?.invoke(this, i, data)
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,122 @@
+package dev.inmo.jsuikit.modifiers
+
+import dev.inmo.jsuikit.utils.*
+import org.jetbrains.compose.web.css.selectors.CSSSelector
+
+sealed class UIKitDrop(
+    override val classes: Array<String> = emptyArray(),
+    override val otherAttrs: Map<String, String> = emptyMap()
+) : UIKitModifier {
+    sealed class Position(name: String) : AttributeValue(name) {
+
+        sealed class Bottom(name: String) : Position("bottom-$name") {
+
+            object Left : Bottom("left")
+            object Center : Bottom("center")
+            object Right : Bottom("right")
+            object Justify : Bottom("justify")
+
+        }
+
+        sealed class Top(name: String) : Position("top-$name") {
+
+            object Left : Top("left")
+            object Center : Top("center")
+            object Right : Top("right")
+            object Justify : Top("justify")
+
+        }
+
+        sealed class Left(name: String) : Position("left-$name") {
+
+            object Top : Left("top")
+            object Center : Left("center")
+            object Bottom : Left("bottom")
+
+        }
+
+        sealed class Right(name: String) : Position("right-$name") {
+
+            object Top : Right("top")
+            object Center : Right("center")
+            object Bottom : Right("bottom")
+
+        }
+    }
+
+    sealed class Stretch(name: String) : AttributeValue(name) {
+        object True : Stretch("true")
+        object X : Stretch("x")
+        object Y : Stretch("y")
+    }
+
+    sealed class Mode(name: String) : AttributeValue(name) {
+
+        object Click : Mode("click")
+        object Hover : Mode("hover")
+
+        object None : Mode("")
+        object HoverAndClick : Mode("$Hover, $Click")
+
+    }
+
+    class Custom internal constructor(
+        classes: Array<String> = emptyArray(),
+        otherAttrs: Map<String, String> = emptyMap()
+    ) : UIKitDrop(classes, otherAttrs)
+
+    companion object {
+        operator fun invoke(
+            toggle: CSSSelector? = null,
+            position: Position? = null,
+            stretch: Stretch? = null,
+            mode: Mode? = null,
+            delayShow: Milliseconds? = null,
+            delayHide: Milliseconds? = null,
+            autoUpdate: Boolean? = null,
+            boundary: CSSSelector? = null,
+            boundaryX: CSSSelector? = null,
+            boundaryY: CSSSelector? = null,
+            target: CSSSelector? = null,
+            targetX: CSSSelector? = null,
+            targetY: CSSSelector? = null,
+            inset: Boolean? = null,
+            flip: Boolean? = null,
+            shift: Boolean? = null,
+            offset: Pixels? = null,
+            animation: UIKitAnimation? = null,
+            animationOut: Boolean? = null,
+            bgScroll: Boolean? = null,
+            duration: Milliseconds? = null,
+            container: Boolean? = null
+        ) = Custom(
+            arrayOf("uk-drop"),
+            mapOf(
+                buildAttribute("uk-drop") {
+                    "toggle" to toggle
+                    "position" to position
+                    "stretch" to stretch
+                    "mode" to mode
+                    "delay-show" to delayShow
+                    "delay-hide" to delayHide
+                    "auto-update" to autoUpdate
+                    "boundary" to boundary
+                    "boundary-x" to boundaryX
+                    "boundary-y" to boundaryY
+                    "target" to target
+                    "target-x" to targetX
+                    "target-y" to targetY
+                    "inset" to inset
+                    "flip" to flip
+                    "shift" to shift
+                    "offset" to offset
+                    "animation" to animation
+                    "animation-out" to animationOut
+                    "bg-scroll" to bgScroll
+                    "duration" to duration
+                    "container" to container
+                }
+            )
+        )
+    }
+}

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

@@ -14,6 +14,24 @@ sealed class UIKitGrid(vararg classnames: String) : UIKitModifier {
 
     }
 
+    sealed class Column(classname: String) : UIKitGrid(classname) {
+
+        object Small : Column("uk-grid-column-small")
+        object Medium : Column("uk-grid-column-medium")
+        object Large : Column("uk-grid-column-large")
+        object Collapse : Column("uk-grid-column-collapse")
+
+    }
+
+    sealed class Row(classname: String) : UIKitGrid(classname) {
+
+        object Small : Row("uk-grid-row-small")
+        object Medium : Row("uk-grid-row-medium")
+        object Large : Row("uk-grid-row-large")
+        object Collapse : Row("uk-grid-row-collapse")
+
+    }
+
     object Divider : UIKitGrid("uk-grid-divider")
 
     object MatchHeight : UIKitGrid("uk-grid-match")

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

@@ -0,0 +1,51 @@
+package dev.inmo.jsuikit.modifiers
+
+import dev.inmo.jsuikit.utils.buildAttribute
+import org.jetbrains.compose.web.css.selectors.CSSSelector
+import kotlin.time.Duration
+
+sealed class UIKitTab(
+    override val classes: Array<String> = emptyArray(),
+    override val otherAttrs: Map<String, String> = emptyMap()
+) : UIKitModifier {
+    sealed class Position(
+        classes: Array<String> = emptyArray(),
+        otherAttrs: Map<String, String> = emptyMap()
+    ) : UIKitTab(classes, otherAttrs) {
+        object Bottom : Position(arrayOf("uk-tab-bottom"))
+        object Left : Position(arrayOf("uk-tab-left"))
+        object Right : Position(arrayOf("uk-tab-right"))
+    }
+
+    class Custom(
+        connect: CSSSelector? = null,
+        toggle: CSSSelector? = null,
+        active: Int? = null,
+        animationsIn: Array<UIKitAnimation>? = null,
+        animationsOut: Array<UIKitAnimation>? = null,
+        animationDuration: Duration? = null,
+        swiping: Boolean? = null,
+        media: String? = null
+    ) : UIKitTab(
+        arrayOf("uk-tab"),
+        mapOf(
+            buildAttribute("uk-tab") {
+                "connect" to connect
+                "toggle" to toggle
+                "active" to active
+                "animation" to (
+                    (animationsIn ?.let {
+                        it.joinToString(" ") { it.name }
+                    } ?: "") + (animationsOut ?.let {
+                        it.joinToString(" ", ",") { it.name }
+                    } ?: "")
+                ).takeIf { it.isNotBlank() }
+                "duration" to animationDuration
+                "swiping" to swiping
+                "media" to media
+            }
+        )
+    )
+
+    companion object : UIKitTab(arrayOf("uk-tab"), mapOf("uk-tab" to ""))
+}

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

@@ -3,7 +3,9 @@ package dev.inmo.jsuikit.utils
 import dev.inmo.jsuikit.modifiers.UIKitModifier
 import dev.inmo.jsuikit.modifiers.include
 import org.jetbrains.compose.web.attributes.AttrsScope
+import org.jetbrains.compose.web.attributes.HtmlAttrMarker
 import org.jetbrains.compose.web.attributes.builders.InputAttrsScope
+import org.jetbrains.compose.web.dom.AttrBuilderContext
 import org.w3c.dom.Element
 import org.w3c.dom.HTMLInputElement
 

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

@@ -4,13 +4,19 @@ import androidx.compose.runtime.Composable
 import org.jetbrains.compose.web.dom.ContentBuilder
 import org.w3c.dom.Element
 
+@Composable
+inline fun optionallyDraw (
+    vararg bools: Boolean,
+    whatToDraw: @Composable () -> Unit
+) {
+    if (bools.any { it }) {
+        whatToDraw()
+    }
+}
+
 @Composable
 inline fun <T : Element> optionallyDraw (
     attrs: Attrs<T>? = null,
     noinline contentBuilder: ContentBuilder<T>? = null,
     whatToDraw: @Composable () -> Unit
-) {
-    if (attrs != null || contentBuilder != null) {
-        whatToDraw()
-    }
-}
+) = optionallyDraw(attrs != null || contentBuilder != null, whatToDraw = whatToDraw)

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

@@ -1,13 +1,17 @@
 package dev.inmo.jsuikit.utils
 
+import dev.inmo.jsuikit.modifiers.AttributeValue
+
 
 class ParametersBuilder(
     val skipNullValues: Boolean = true,
     private val parameters: MutableMap<String, String?> = mutableMapOf()
 ) {
     fun add(k: String, v: Any? = null) {
-        if (v != null || !skipNullValues) {
-            parameters[k] = v ?.toString()
+        when {
+            v is AttributeValue -> parameters[k] = v.name
+            v == null && skipNullValues -> return
+            else -> parameters[k] = v ?.toString()
         }
     }
     infix fun String.to(value: Any?) = add(this, value)