update wrapper

0.4.21

.github/workflows/gradle_build.yml

@@ -0,0 +1,16 @@
+name: Build
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 1.8
+        uses: actions/setup-java@v1
+        with:
+          java-version: 1.8
+      - name: Build with Gradle
+        run: ./gradlew build

CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## 0.4.22
+
+* `Versions`:
+    * `Exposed`: `0.28.1` -> `0.29.1`
+    * `Klock`: `2.0.2` -> `2.0.4`
+
+## 0.4.21
+
+* `Common`
+    * `JS`
+        * Extension `DataView#toByteArray` has been added
+        * Extension `ArrayBuffer#toByteArray` has been added
+        * Extension `ByteArray#toDataView` has been added
+        * Extension `ByteArray#toArrayBuffer` has been added
+* `Coroutines`
+    * `JS`
+        * Extension `Blob#toByteArray` has been added
+* `Crypto`
+    * Subproject has been created
+* `Serialization`
+    * `Base64`
+        * Currently, it is not depended on `common` project and use `crypto` instead
+
+## 0.4.20
+
+* `Serialization`
+    * `Encapsulator`:
+        * Has been created
+
+## 0.4.19
+
+* `Coroutines`:
+    * New extension `Iterable<Deferred>#awaitFirstWithDeferred` has been added to identify which of `Deferred`s was
+      normally completed
+    * New extensions `Iterable<Deferred<T>>#invokeOnFirst` and `Iterable<DeferredAction<*, O>>.invokeFirstOf` have been
+    added
+
+## 0.4.18
+
+* `Coroutines`:
+    * New extension `Iterable<Deferred>#awaitFirst` has been added
+* `Serialization`
+    * `Base 64`
+        * New `Base64ByteArraySerializer` has been added
+
+## 0.4.17
+
+* `Common`
+    * Functionality for decode/encode base 64 to/from `ByteArray`/`String` have been added
+* `Serialization`
+    * `Base 64`
+        * Project has been initiated
+
+## 0.4.16
+
+* `Coroutines`:
+    * `safely`:
+        * New `safelyWithoutExceptions` function may accept `onException` parameter with nullable result
+        * Old `safelyWithoutExceptions` now using `defaultSafelyWithoutExceptionHandler` to handle exceptions "like in
+          `safely`", but it is expected that `defaultSafelyWithoutExceptionHandler` will not throw any exception
+
 ## 0.4.15
 
 * `Coroutines`:

README.md

@@ -22,6 +22,7 @@ You always can look at the <a href="https://github.com/InsanusMokrassar/MicroUti
 * `ktor` is a set of modules for `client`s and `server`s
 * `mime_types` is NOT lightweight set of `MimeType`s with a lot of different objected and serializable (with `Kotlin Serialization`) mime types
 * `pagination` is a complex of modules (explanation in [Complex modules structure](#complex-modules-structure) section) for lightweight pagination
+* `serialization` is a collection of projects with serializers for `kotlinx.serialization`
 * `repos` is a complex of modules (explanation in [Complex modules structure](#complex-modules-structure) section) for `KeyValue`/`OneToMany`/`CRUD` repos created to be able to exclude some heavy dependencies when you need some simple and lightweight typical repositories
 
 ## Complex modules structure

common/src/commonMain/kotlin/dev/inmo/micro_utils/common/Base64.kt

@@ -0,0 +1,89 @@
+package dev.inmo.micro_utils.common
+
+import kotlin.experimental.and
+
+private const val BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+private const val BASE64_MASK: Byte = 0x3f
+private const val BASE64_PAD = '='
+private val BASE64_INVERSE_ALPHABET = IntArray(256) {
+    BASE64_ALPHABET.indexOf(it.toChar())
+}
+
+internal fun Int.toBase64(): Char = BASE64_ALPHABET[this]
+internal fun Byte.fromBase64(): Byte = BASE64_INVERSE_ALPHABET[toInt() and 0xff].toByte() and BASE64_MASK
+
+const val replacedInCrypto = "Replaced in crypto subproject"
+
+@Deprecated(replacedInCrypto, ReplaceWith("EncodedBase64String", "dev.inmo.micro_utils.crypto"))
+typealias EncodedBase64String = String
+@Deprecated(replacedInCrypto, ReplaceWith("EncodedByteArray", "dev.inmo.micro_utils.crypto"))
+typealias EncodedByteArray = ByteArray
+
+@Deprecated(replacedInCrypto, ReplaceWith("encodeBase64String()", "dev.inmo.micro_utils.crypto"))
+fun String.encodeBase64String(): EncodedBase64String = encodeToByteArray().encodeBase64String()
+@Deprecated(replacedInCrypto, ReplaceWith("encodeBase64()", "dev.inmo.micro_utils.crypto"))
+fun String.encodeBase64(): EncodedByteArray = encodeToByteArray().encodeBase64()
+
+@Deprecated(replacedInCrypto, ReplaceWith("encodeBase64String()", "dev.inmo.micro_utils.crypto"))
+fun ByteArray.encodeBase64String(): EncodedBase64String = buildString {
+    var i = 0
+    while (this@encodeBase64String.size > i) {
+        val read = kotlin.math.min(3, this@encodeBase64String.size - i)
+        val data = ByteArray(3) {
+            if (it < read) {
+                this@encodeBase64String[it + i]
+            } else {
+                0
+            }
+        }
+
+        val padSize = (data.size - read) * 8 / 6
+        val chunk = ((data[0].toInt() and 0xFF) shl 16) or
+            ((data[1].toInt() and 0xFF) shl 8) or
+            (data[2].toInt() and 0xFF)
+
+        for (index in data.size downTo padSize) {
+            val char = (chunk shr (6 * index)) and BASE64_MASK.toInt()
+            append(char.toBase64())
+        }
+
+        repeat(padSize) { append(BASE64_PAD) }
+
+        i += read
+    }
+}
+@Deprecated(replacedInCrypto, ReplaceWith("encodeBase64()", "dev.inmo.micro_utils.crypto"))
+fun ByteArray.encodeBase64(): EncodedByteArray = encodeBase64String().encodeToByteArray()
+
+@Deprecated(replacedInCrypto, ReplaceWith("decodeBase64()", "dev.inmo.micro_utils.crypto"))
+fun EncodedBase64String.decodeBase64() = dropLastWhile { it == BASE64_PAD }.encodeToByteArray().decodeBase64()
+@Deprecated(replacedInCrypto, ReplaceWith("decodeBase64String()", "dev.inmo.micro_utils.crypto"))
+fun EncodedBase64String.decodeBase64String() = decodeBase64().decodeToString()
+
+@Deprecated(replacedInCrypto, ReplaceWith("decodeBase64()", "dev.inmo.micro_utils.crypto"))
+fun EncodedByteArray.decodeBase64(): ByteArray {
+    val result = mutableListOf<Byte>()
+    val data = ByteArray(4)
+    (0 until size step 4).forEach { i ->
+        var read = 0
+        for (j in 0 until 4) {
+            if (j + i < size) {
+                data[j] = get(j + i)
+                read++
+            } else {
+                break
+            }
+        }
+        val chunk = data.foldIndexed(0) { index, result, current ->
+            result or (current.fromBase64().toInt() shl ((3 - index) * 6))
+        }
+        for (index in data.size - 2 downTo (data.size - read)) {
+            val origin = (chunk shr (8 * index)) and 0xff
+            result.add(origin.toByte())
+        }
+    }
+
+    return result.toByteArray()
+}
+@Deprecated(replacedInCrypto, ReplaceWith("decodeBase64String()", "dev.inmo.micro_utils.crypto"))
+fun EncodedByteArray.decodeBase64String() = decodeBase64().decodeToString()

common/src/commonTest/kotlin/dev/inmo/micro_utils/common/Base64Text.kt

@@ -0,0 +1,33 @@
+package dev.inmo.micro_utils.common
+
+import kotlin.random.Random
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+
+
+class Base64Text {
+
+    val testText = """Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?"""
+    val base64Text = """TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlzIG5vc3RydWQgZXhlcmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1aXAgZXggZWEgY29tbW9kbyBjb25zZXF1YXQuIER1aXMgYXV0ZSBpcnVyZSBkb2xvciBpbiByZXByZWhlbmRlcml0IGluIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIGNpbGx1bSBkb2xvcmUgZXUgZnVnaWF0IG51bGxhIHBhcmlhdHVyLiBFeGNlcHRldXIgc2ludCBvY2NhZWNhdCBjdXBpZGF0YXQgbm9uIHByb2lkZW50LCBzdW50IGluIGN1bHBhIHF1aSBvZmZpY2lhIGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtLgpTZWQgdXQgcGVyc3BpY2lhdGlzIHVuZGUgb21uaXMgaXN0ZSBuYXR1cyBlcnJvciBzaXQgdm9sdXB0YXRlbSBhY2N1c2FudGl1bSBkb2xvcmVtcXVlIGxhdWRhbnRpdW0sIHRvdGFtIHJlbSBhcGVyaWFtLCBlYXF1ZSBpcHNhIHF1YWUgYWIgaWxsbyBpbnZlbnRvcmUgdmVyaXRhdGlzIGV0IHF1YXNpIGFyY2hpdGVjdG8gYmVhdGFlIHZpdGFlIGRpY3RhIHN1bnQgZXhwbGljYWJvLiBOZW1vIGVuaW0gaXBzYW0gdm9sdXB0YXRlbSBxdWlhIHZvbHVwdGFzIHNpdCBhc3Blcm5hdHVyIGF1dCBvZGl0IGF1dCBmdWdpdCwgc2VkIHF1aWEgY29uc2VxdXVudHVyIG1hZ25pIGRvbG9yZXMgZW9zIHF1aSByYXRpb25lIHZvbHVwdGF0ZW0gc2VxdWkgbmVzY2l1bnQuIE5lcXVlIHBvcnJvIHF1aXNxdWFtIGVzdCwgcXVpIGRvbG9yZW0gaXBzdW0gcXVpYSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIsIGFkaXBpc2NpIHZlbGl0LCBzZWQgcXVpYSBub24gbnVtcXVhbSBlaXVzIG1vZGkgdGVtcG9yYSBpbmNpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hbSBhbGlxdWFtIHF1YWVyYXQgdm9sdXB0YXRlbS4gVXQgZW5pbSBhZCBtaW5pbWEgdmVuaWFtLCBxdWlzIG5vc3RydW0gZXhlcmNpdGF0aW9uZW0gdWxsYW0gY29ycG9yaXMgc3VzY2lwaXQgbGFib3Jpb3NhbSwgbmlzaSB1dCBhbGlxdWlkIGV4IGVhIGNvbW1vZGkgY29uc2VxdWF0dXI/IFF1aXMgYXV0ZW0gdmVsIGV1bSBpdXJlIHJlcHJlaGVuZGVyaXQgcXVpIGluIGVhIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIHF1YW0gbmloaWwgbW9sZXN0aWFlIGNvbnNlcXVhdHVyLCB2ZWwgaWxsdW0gcXVpIGRvbG9yZW0gZXVtIGZ1Z2lhdCBxdW8gdm9sdXB0YXMgbnVsbGEgcGFyaWF0dXI/"""
+
+    @Test
+    fun decodeEncode() {
+        val encoded = testText.encodeBase64String()
+        assertEquals(base64Text, encoded)
+        val decoded = encoded.decodeBase64String()
+        assertEquals(testText, decoded)
+    }
+
+    val urlTestText = "https://example.com?isitexample=1"
+    val urlTestBase64Text = "aHR0cHM6Ly9leGFtcGxlLmNvbT9pc2l0ZXhhbXBsZT0x"
+
+    @Test
+    fun decodeEncodeUrl() {
+        val encoded = urlTestText.encodeBase64String()
+        assertEquals(urlTestBase64Text, encoded)
+        val decoded = encoded.decodeBase64String()
+        assertEquals(urlTestText, decoded)
+    }
+}

common/src/jsMain/kotlin/dev/inmo/micro_utils/common/ByteArrayDataView.kt

@@ -0,0 +1,15 @@
+package dev.inmo.micro_utils.common
+
+import org.khronos.webgl.*
+
+fun DataView.toByteArray() = ByteArray(this.byteLength) {
+    getInt8(it)
+}
+
+fun ArrayBuffer.toByteArray() = Int8Array(this) as ByteArray
+
+fun ByteArray.toDataView() = DataView(ArrayBuffer(size)).also {
+    forEachIndexed { i, byte -> it.setInt8(i, byte) }
+}
+
+fun ByteArray.toArrayBuffer() = toDataView().buffer

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/AwaitFirst.kt

@@ -0,0 +1,37 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import kotlin.coroutines.*
+
+suspend fun <T> Iterable<Deferred<T>>.awaitFirstWithDeferred(
+    scope: CoroutineScope,
+    cancelOnResult: Boolean = true
+): Pair<Deferred<T>, T> = suspendCoroutine<Pair<Deferred<T>, T>> { continuation ->
+    scope.launch(SupervisorJob()) {
+        val scope = this
+        forEach {
+            scope.launch {
+                continuation.resume(it to it.await())
+                scope.cancel()
+            }
+        }
+    }
+}.also {
+    if (cancelOnResult) {
+        forEach {
+            try {
+                it.cancel()
+            } catch (e: IllegalStateException) {
+                e.printStackTrace()
+            }
+        }
+    }
+}
+
+suspend fun <T> Iterable<Deferred<T>>.awaitFirst(
+    scope: CoroutineScope,
+    cancelOnResult: Boolean = true
+): T = awaitFirstWithDeferred(scope, cancelOnResult).second
+suspend fun <T> Iterable<Deferred<T>>.awaitFirst(
+    cancelOthers: Boolean = true
+): T = awaitFirst(CoroutineScope(coroutineContext), cancelOthers)

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/DoWithFirst.kt

@@ -0,0 +1,40 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+
+class DeferredAction<T, O>(
+    val deferred: Deferred<T>,
+    val callback: suspend (T) -> O
+) {
+    suspend operator fun invoke() = callback(deferred.await())
+}
+
+fun <T, O> Deferred<T>.buildAction(callback: suspend (T) -> O) = DeferredAction(this, callback)
+
+suspend fun <O> Iterable<DeferredAction<*, O>>.invokeFirstOf(
+    scope: CoroutineScope,
+    cancelOnResult: Boolean = true
+): O {
+    return map { it.deferred }.awaitFirstWithDeferred(scope, cancelOnResult).let { result ->
+        first { it.deferred == result.first }.invoke()
+    }
+}
+
+suspend fun <O> invokeFirstOf(
+    scope: CoroutineScope,
+    vararg variants: DeferredAction<*, O>,
+    cancelOnResult: Boolean = true
+): O = variants.toList().invokeFirstOf(scope, cancelOnResult)
+
+suspend fun <T, O> Iterable<Deferred<T>>.invokeOnFirst(
+    scope: CoroutineScope,
+    cancelOnResult: Boolean = true,
+    callback: suspend (T) -> O
+): O = map { it.buildAction(callback) }.invokeFirstOf(scope, cancelOnResult)
+
+suspend fun <T, O> invokeOnFirst(
+    scope: CoroutineScope,
+    vararg variants: Deferred<T>,
+    cancelOnResult: Boolean = true,
+    callback: suspend (T) -> O
+): O = variants.toList().invokeOnFirst(scope, cancelOnResult, callback)

coroutines/src/commonMain/kotlin/dev/inmo/micro_utils/coroutines/HandleSafely.kt

@@ -11,6 +11,17 @@ typealias ExceptionHandler<T> = suspend (Throwable) -> T
  */
 var defaultSafelyExceptionHandler: ExceptionHandler<Nothing> = { throw it }
 
+/**
+ * This instance will be used in all calls of [safelyWithoutExceptions] as an exception handler for [safely] call
+ */
+var defaultSafelyWithoutExceptionHandler: ExceptionHandler<Unit> = {
+    try {
+        defaultSafelyExceptionHandler(it)
+    } catch (e: Throwable) {
+         // do nothing
+    }
+}
+
 /**
  * Key for [SafelyExceptionHandler] which can be used in [CoroutineContext.get] to get current default
  * [SafelyExceptionHandler]
@@ -123,8 +134,23 @@ suspend inline fun <T> safely(
 }
 
 /**
- * Shortcut for [safely] without exception handler (instead of this you will receive null as a result)
+ * Shortcut for [safely] with exception handler, that as expected must return null in case of impossible creating of
+ * result from exception (instead of throwing it)
+ */
+suspend inline fun <T> safelyWithoutExceptions(
+    noinline onException: ExceptionHandler<T?>,
+    noinline block: suspend CoroutineScope.() -> T
+): T? = safely(onException, block)
+
+/**
+ * Shortcut for [safely] without exception handler (instead of this you will always receive null as a result)
  */
 suspend inline fun <T> safelyWithoutExceptions(
     noinline block: suspend CoroutineScope.() -> T
-): T? = safely({ null }, block)
+): T? = safelyWithoutExceptions(
+    {
+        defaultSafelyWithoutExceptionHandler.invoke(it)
+        null
+    },
+    block
+)

coroutines/src/jsMain/kotlin/dev.inmo.micro_utils.coroutines/ByteArrayBlob.kt

@@ -0,0 +1,10 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.await
+import org.khronos.webgl.Int8Array
+import org.w3c.fetch.Response
+import org.w3c.files.Blob
+
+suspend fun Blob.toByteArray() = Int8Array(
+    Response(this).arrayBuffer().await()
+) as ByteArray

coroutines/src/jvmTest/kotlin/dev/inmo/micro_utils/coroutines/AwaitFirstTests.kt

@@ -0,0 +1,34 @@
+package dev.inmo.micro_utils.coroutines
+
+import kotlinx.coroutines.*
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class AwaitFirstTests {
+    private fun CoroutineScope.createTestDeferred(value: Int, wait: Long = 100000) = async(start = CoroutineStart.LAZY) { delay(wait); value }
+    @Test
+    fun testThatAwaitFirstIsWorkingCorrectly() {
+        val baseScope = CoroutineScope(Dispatchers.Default)
+        val resultDeferred = baseScope.createTestDeferred(-1, 0)
+        val deferreds = listOf(
+            baseScope.async { createTestDeferred(0) },
+            baseScope.async { createTestDeferred(1) },
+            baseScope.async { createTestDeferred(2) },
+            resultDeferred
+        )
+        val controlJob = baseScope.launch {
+            delay(1000000)
+        }
+        val result = baseScope.launchSynchronously {
+            val result = deferreds.awaitFirst(baseScope)
+
+            assertTrue(baseScope.isActive)
+            assertTrue(controlJob.isActive)
+
+            result
+        }
+        assertEquals(baseScope.launchSynchronously { resultDeferred.await() }, result)
+        assertTrue(deferreds.all { it == resultDeferred || it.isCancelled })
+    }
+}

coroutines/src/jvmTest/kotlin/dev/inmo/micro_utils/coroutines/DoWithFirstTests.kt

@@ -0,0 +1,27 @@
+package dev.inmo.micro_utils.coroutines
+
+import dev.inmo.micro_utils.coroutines.asDeferred
+import dev.inmo.micro_utils.coroutines.launchSynchronously
+import kotlinx.coroutines.*
+import kotlin.test.*
+
+class DoWithFirstTests {
+    @Test
+    fun testHandleOneOf() {
+        val scope = CoroutineScope(Dispatchers.Default)
+        val happenedDeferreds = mutableListOf<Int>()
+        val deferredWhichMustHappen = (-1).asDeferred
+        scope.launchSynchronously {
+            scope.launch {
+                ((0 until 100).map {
+                    DeferredAction(
+                        scope.async { delay(10000); it },
+                        happenedDeferreds::add
+                    )
+                } + DeferredAction(deferredWhichMustHappen, happenedDeferreds::add)).invokeFirstOf(scope)
+            }.join()
+        }
+        assertEquals(1, happenedDeferreds.size)
+        assertEquals(scope.launchSynchronously { deferredWhichMustHappen.await() }, happenedDeferreds.first())
+    }
+}

crypto/build.gradle

@@ -0,0 +1,30 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppProjectWithSerializationPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api project(":micro_utils.common")
+            }
+        }
+        jsMain {
+            dependencies {
+                api npm("crypto-js", "$crypto_js_version")
+            }
+        }
+    }
+}
+
+android {
+    sourceSets {
+        main {
+            java.srcDirs += [ "src/jvmMain/kotlin" ]
+        }
+    }
+}

crypto/src/commonMain/kotlin/dev/inmo/micro_utils/crypto/Base64.kt

@@ -0,0 +1,77 @@
+package dev.inmo.micro_utils.crypto
+
+import kotlin.experimental.and
+
+private const val BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+private const val BASE64_MASK: Byte = 0x3f
+private const val BASE64_PAD = '='
+private val BASE64_INVERSE_ALPHABET = IntArray(256) {
+    BASE64_ALPHABET.indexOf(it.toChar())
+}
+
+internal fun Int.toBase64(): Char = BASE64_ALPHABET[this]
+internal fun Byte.fromBase64(): Byte = BASE64_INVERSE_ALPHABET[toInt() and 0xff].toByte() and BASE64_MASK
+
+typealias EncodedBase64String = String
+typealias EncodedByteArray = ByteArray
+
+fun SourceString.encodeBase64String(): EncodedBase64String = encodeToByteArray().encodeBase64String()
+fun SourceString.encodeBase64(): EncodedByteArray = encodeToByteArray().encodeBase64()
+
+fun SourceBytes.encodeBase64String(): EncodedBase64String = buildString {
+    var i = 0
+    while (this@encodeBase64String.size > i) {
+        val read = kotlin.math.min(3, this@encodeBase64String.size - i)
+        val data = ByteArray(3) {
+            if (it < read) {
+                this@encodeBase64String[it + i]
+            } else {
+                0
+            }
+        }
+
+        val padSize = (data.size - read) * 8 / 6
+        val chunk = ((data[0].toInt() and 0xFF) shl 16) or
+            ((data[1].toInt() and 0xFF) shl 8) or
+            (data[2].toInt() and 0xFF)
+
+        for (index in data.size downTo padSize) {
+            val char = (chunk shr (6 * index)) and BASE64_MASK.toInt()
+            append(char.toBase64())
+        }
+
+        repeat(padSize) { append(BASE64_PAD) }
+
+        i += read
+    }
+}
+fun SourceBytes.encodeBase64(): EncodedByteArray = encodeBase64String().encodeToByteArray()
+
+fun EncodedBase64String.decodeBase64(): SourceBytes = dropLastWhile { it == BASE64_PAD }.encodeToByteArray().decodeBase64()
+fun EncodedBase64String.decodeBase64String(): SourceString = decodeBase64().decodeToString()
+
+fun EncodedByteArray.decodeBase64(): SourceBytes {
+    val result = mutableListOf<Byte>()
+    val data = ByteArray(4)
+    (0 until size step 4).forEach { i ->
+        var read = 0
+        for (j in 0 until 4) {
+            if (j + i < size) {
+                data[j] = get(j + i)
+                read++
+            } else {
+                break
+            }
+        }
+        val chunk = data.foldIndexed(0) { index, result, current ->
+            result or (current.fromBase64().toInt() shl ((3 - index) * 6))
+        }
+        for (index in data.size - 2 downTo (data.size - read)) {
+            val origin = (chunk shr (8 * index)) and 0xff
+            result.add(origin.toByte())
+        }
+    }
+
+    return result.toByteArray()
+}
+fun EncodedByteArray.decodeBase64String(): SourceString = decodeBase64().decodeToString()

crypto/src/commonMain/kotlin/dev/inmo/micro_utils/crypto/Common.kt

@@ -0,0 +1,11 @@
+package dev.inmo.micro_utils.crypto
+
+/**
+ * This typealias shows that corresponding [ByteArray] is an raw data
+ */
+typealias SourceBytes = ByteArray
+/**
+ * This typealias shows that corresponding [String] is an raw data
+ */
+typealias SourceString = String
+

crypto/src/commonMain/kotlin/dev/inmo/micro_utils/crypto/MD5.kt

@@ -0,0 +1,6 @@
+package dev.inmo.micro_utils.crypto
+
+typealias MD5 = String
+
+expect fun SourceBytes.md5(): MD5
+fun SourceString.md5(): MD5 = encodeToByteArray().md5()

crypto/src/commonTest/kotlin/dev/inmo/micro_utils/crypto/Base64Text.kt

@@ -0,0 +1,32 @@
+package dev.inmo.micro_utils.crypto
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+
+
+class Base64Text {
+
+    val testText = """Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui ratione voluptatem sequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam, quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas nulla pariatur?"""
+    val base64Text = """TG9yZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNlY3RldHVyIGFkaXBpc2NpbmcgZWxpdCwgc2VkIGRvIGVpdXNtb2QgdGVtcG9yIGluY2lkaWR1bnQgdXQgbGFib3JlIGV0IGRvbG9yZSBtYWduYSBhbGlxdWEuIFV0IGVuaW0gYWQgbWluaW0gdmVuaWFtLCBxdWlzIG5vc3RydWQgZXhlcmNpdGF0aW9uIHVsbGFtY28gbGFib3JpcyBuaXNpIHV0IGFsaXF1aXAgZXggZWEgY29tbW9kbyBjb25zZXF1YXQuIER1aXMgYXV0ZSBpcnVyZSBkb2xvciBpbiByZXByZWhlbmRlcml0IGluIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIGNpbGx1bSBkb2xvcmUgZXUgZnVnaWF0IG51bGxhIHBhcmlhdHVyLiBFeGNlcHRldXIgc2ludCBvY2NhZWNhdCBjdXBpZGF0YXQgbm9uIHByb2lkZW50LCBzdW50IGluIGN1bHBhIHF1aSBvZmZpY2lhIGRlc2VydW50IG1vbGxpdCBhbmltIGlkIGVzdCBsYWJvcnVtLgpTZWQgdXQgcGVyc3BpY2lhdGlzIHVuZGUgb21uaXMgaXN0ZSBuYXR1cyBlcnJvciBzaXQgdm9sdXB0YXRlbSBhY2N1c2FudGl1bSBkb2xvcmVtcXVlIGxhdWRhbnRpdW0sIHRvdGFtIHJlbSBhcGVyaWFtLCBlYXF1ZSBpcHNhIHF1YWUgYWIgaWxsbyBpbnZlbnRvcmUgdmVyaXRhdGlzIGV0IHF1YXNpIGFyY2hpdGVjdG8gYmVhdGFlIHZpdGFlIGRpY3RhIHN1bnQgZXhwbGljYWJvLiBOZW1vIGVuaW0gaXBzYW0gdm9sdXB0YXRlbSBxdWlhIHZvbHVwdGFzIHNpdCBhc3Blcm5hdHVyIGF1dCBvZGl0IGF1dCBmdWdpdCwgc2VkIHF1aWEgY29uc2VxdXVudHVyIG1hZ25pIGRvbG9yZXMgZW9zIHF1aSByYXRpb25lIHZvbHVwdGF0ZW0gc2VxdWkgbmVzY2l1bnQuIE5lcXVlIHBvcnJvIHF1aXNxdWFtIGVzdCwgcXVpIGRvbG9yZW0gaXBzdW0gcXVpYSBkb2xvciBzaXQgYW1ldCwgY29uc2VjdGV0dXIsIGFkaXBpc2NpIHZlbGl0LCBzZWQgcXVpYSBub24gbnVtcXVhbSBlaXVzIG1vZGkgdGVtcG9yYSBpbmNpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hbSBhbGlxdWFtIHF1YWVyYXQgdm9sdXB0YXRlbS4gVXQgZW5pbSBhZCBtaW5pbWEgdmVuaWFtLCBxdWlzIG5vc3RydW0gZXhlcmNpdGF0aW9uZW0gdWxsYW0gY29ycG9yaXMgc3VzY2lwaXQgbGFib3Jpb3NhbSwgbmlzaSB1dCBhbGlxdWlkIGV4IGVhIGNvbW1vZGkgY29uc2VxdWF0dXI/IFF1aXMgYXV0ZW0gdmVsIGV1bSBpdXJlIHJlcHJlaGVuZGVyaXQgcXVpIGluIGVhIHZvbHVwdGF0ZSB2ZWxpdCBlc3NlIHF1YW0gbmloaWwgbW9sZXN0aWFlIGNvbnNlcXVhdHVyLCB2ZWwgaWxsdW0gcXVpIGRvbG9yZW0gZXVtIGZ1Z2lhdCBxdW8gdm9sdXB0YXMgbnVsbGEgcGFyaWF0dXI/"""
+
+    @Test
+    fun decodeEncode() {
+        val encoded = testText.encodeBase64String()
+        assertEquals(base64Text, encoded)
+        val decoded = encoded.decodeBase64String()
+        assertEquals(testText, decoded)
+    }
+
+    val urlTestText = "https://example.com?isitexample=1"
+    val urlTestBase64Text = "aHR0cHM6Ly9leGFtcGxlLmNvbT9pc2l0ZXhhbXBsZT0x"
+
+    @Test
+    fun decodeEncodeUrl() {
+        val encoded = urlTestText.encodeBase64String()
+        assertEquals(urlTestBase64Text, encoded)
+        val decoded = encoded.decodeBase64String()
+        assertEquals(urlTestText, decoded)
+    }
+}

crypto/src/commonTest/kotlin/dev/inmo/micro_utils/crypto/MD5Test.kt

@@ -0,0 +1,17 @@
+package dev.inmo.micro_utils.crypto
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class MD5Test {
+    val source = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+    val expectedMD5 = "db89bb5ceab87f9c0fcc2ab36c189c2c"
+    @Test
+    fun testMD5() {
+        var i = 0
+        source.md5().forEach {
+            assertEquals(expectedMD5[i], it)
+            i++
+        }
+    }
+}

crypto/src/jsMain/kotlin/dev/inmo/micro_utils/crypto/CryptoJs.kt

@@ -0,0 +1,9 @@
+package dev.inmo.micro_utils.crypto
+
+external interface CryptoJs {
+    fun MD5(data: String): String
+}
+
+@JsModule("crypto-js")
+@JsNonModule
+external val CryptoJS: CryptoJs

crypto/src/jsMain/kotlin/dev/inmo/micro_utils/crypto/MD5Realization.kt

@@ -0,0 +1,3 @@
+package dev.inmo.micro_utils.crypto
+
+actual fun SourceBytes.md5(): MD5 = CryptoJS.MD5(decodeToString())

crypto/src/jvmMain/kotlin/dev/inmo/micro_utils/crypto/MD5Realization.kt

@@ -0,0 +1,9 @@
+package dev.inmo.micro_utils.crypto
+
+import java.math.BigInteger
+import java.security.MessageDigest
+
+actual fun SourceBytes.md5(): MD5 = BigInteger(
+    1,
+    MessageDigest.getInstance("MD5").digest(this)
+).toString(16)

crypto/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.micro_utils.crypto"/>

gradle.properties

@@ -9,11 +9,11 @@ android.enableJetifier=true
 kotlin_version=1.4.21
 kotlin_coroutines_version=1.4.2
 kotlin_serialisation_core_version=1.0.1
-kotlin_exposed_version=0.28.1
+kotlin_exposed_version=0.29.1
 
 ktor_version=1.5.0
 
-klockVersion=2.0.2
+klockVersion=2.0.4
 
 github_release_plugin_version=2.2.12
 
@@ -33,6 +33,10 @@ junit_version=4.12
 test_ext_junit_version=1.1.2
 espresso_core=3.3.0
 
+# JS NPM
+
+crypto_js_version=4.0.0
+
 # Dokka
 
 dokka_version=1.4.20
@@ -40,5 +44,5 @@ dokka_version=1.4.20
 # Project data
 
 group=dev.inmo
-version=0.4.15
-android_code_version=19
+version=0.4.22
+android_code_version=26

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.7.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

serialization/base64/build.gradle

@@ -0,0 +1,17 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppProjectWithSerializationPresetPath"
+
+kotlin {
+    sourceSets {
+        commonMain {
+            dependencies {
+                api project(":micro_utils.crypto")
+            }
+        }
+    }
+}

serialization/base64/src/commonMain/kotlin/dev/inmo/micro_utils/serialization/base64/Base64Serializer.kt

@@ -0,0 +1,21 @@
+package dev.inmo.micro_utils.serialization.base64
+
+import dev.inmo.micro_utils.crypto.*
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+open class Base64Serializer<T>(
+    private val converterFrom: (T) -> String,
+    private val converterTo: (String) -> T,
+) : KSerializer<T> {
+    override val descriptor: SerialDescriptor = String.serializer().descriptor
+    override fun deserialize(decoder: Decoder): T = converterTo(decoder.decodeString().decodeBase64String())
+    override fun serialize(encoder: Encoder, value: T) = encoder.encodeString(converterFrom(value).encodeBase64String())
+}
+
+object Base64StringSerializer : Base64Serializer<String>({ it }, { it })
+object Base64ByteArraySerializer : Base64Serializer<ByteArray>({ it.decodeToString() }, { it.encodeToByteArray() })

serialization/base64/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.micro_utils.serialization.base64"/>

serialization/encapsulator/build.gradle

@@ -0,0 +1,7 @@
+plugins {
+    id "org.jetbrains.kotlin.multiplatform"
+    id "org.jetbrains.kotlin.plugin.serialization"
+    id "com.android.library"
+}
+
+apply from: "$mppProjectWithSerializationPresetPath"

serialization/encapsulator/src/commonMain/kotlin/dev/inmo/micro_utils/serialization/encapsulator/Encapsulator.kt

@@ -0,0 +1,23 @@
+package dev.inmo.micro_utils.serialization.encapsulator
+
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.encoding.Encoder
+import kotlin.reflect.KClass
+
+data class Encapsulator<T : Any>(
+    val klass: KClass<T>,
+    val serializer: KSerializer<T>
+) {
+    fun <O> encapsulate(
+        value: Any,
+        callback: KSerializer<T>.(T) -> O
+    ): O? = if (klass.isInstance(value)) {
+        callback(serializer, value as T)
+    } else {
+        null
+    }
+}
+
+fun <T : Any> Encapsulator<T>.tryEncode(encoder: Encoder, value: Any) = encapsulate(value) {
+    encoder.encodeSerializableValue(this, it)
+}

serialization/encapsulator/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.micro_utils.serialization.encapsulator"/>

settings.gradle

@@ -2,6 +2,7 @@ rootProject.name='micro_utils'
 
 String[] includes = [
     ":common",
+    ":crypto",
     ":selector:common",
     ":pagination:common",
     ":pagination:exposed",
@@ -21,6 +22,8 @@ String[] includes = [
     ":android:recyclerview",
     ":android:alerts:common",
     ":android:alerts:recyclerview",
+    ":serialization:base64",
+    ":serialization:encapsulator",
 
     ":dokka"
 ]