match changelog style

CHANGELOG.md

@@ -1,29 +1,5 @@
 # Changelog
 
-## 0.33.0
-
-* `Versions`:
-  * `Exposed`: `1.5.1` -> `1.6.0`
-  * `Serialization`: `1.11.0` -> `1.12.0`
-  * `Compose`: `1.12.1` -> `1.12.2`
-  * `SQLite`: `3.53.4.0` -> `3.54.1.0`
-  * `Ktor`: `3.6.0` -> `3.6.1`
-* `Common`:
-  * Add JS `MutationObserverInit` factory that omits unspecified options and preserves browser defaults.
-  * Use safe `MutationObserver` options in `onRemoved` and cover DOM observation and outside-click cleanup with browser tests.
-
-## 0.32.1
-
-* `Coroutines`:
-  * `SmartSemaphore`:
-    * Optimize permit checks, acquisition, uncontended releases and already satisfied waits to reduce allocations while preserving cancellation handling.
-  * `SmartMutex`:
-    * Optimize waits for unlocked mutexes and uncontended unlocks to reduce allocations while preserving cancellation handling.
-  * `SmartRWLocker`:
-    * Remove redundant coroutine contexts during read releases, write unlocks and cancellation cleanup.
-  * `SmartKeyRWLocker`:
-    * Reduce allocations during keyed operations by inlining the locker allocation helper and using a hash map without insertion order tracking.
-
 ## 0.32.0
 
 * `Versions`:
@@ -43,13 +19,12 @@
   * `Gradle wrapper`: `9.3.1` -> `9.7.0`
 * `Coroutines`:
   * `SmartSemaphore`:
-    * Rewrite docs for `freePermits` property.
-    * Add constructor arguments requirements to fail on invalid `permits` and `acquiredPermits` values.
+    * Rewrite docs for `freePermits` property
+    * Add constructor arguments requirements to fail on invalid `permits` and `acquiredPermits` values
   * `SmartRWLocker`:
-    * Add constructor arguments requirements to fail on invalid `readPermits` values.
+    * Add constructor arguments requirements to fail on invalid `readPermits` values
   * `SmartKeyRWLocker`:
-      * Add constructor arguments requirements to fail on invalid `globalLockerReadPermits` and `perKeyReadPermits` values.
-
+    * Add constructor arguments requirements to fail on invalid `globalLockerReadPermits` and `perKeyReadPermits` values
 
 ## 0.31.1
 

common/build.gradle

@@ -7,22 +7,6 @@ plugins {
 apply from: "$mppJvmJsWasmJsAndroidLinuxMingwLinuxArm64Project"
 
 kotlin {
-    js {
-        browser {
-            testTask {
-                useKarma {
-                    useChromeHeadlessNoSandbox()
-                    useConfigDirectory(rootProject.relativeProjectPath("gradle/karma.config.d"))
-                }
-            }
-        }
-        nodejs {
-            testTask {
-                filter.excludeTestsMatching("dev.inmo.micro_utils.common.MutationObserverBrowserTests*")
-            }
-        }
-    }
-
     sourceSets {
         commonMain {
             dependencies {

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

@@ -1,9 +1,7 @@
 package dev.inmo.micro_utils.common
 
 import kotlinx.browser.document
-import org.w3c.dom.Element
-import org.w3c.dom.MutationObserver
-import org.w3c.dom.Node
+import org.w3c.dom.*
 
 fun Node.onRemoved(block: () -> Unit): MutationObserver {
     lateinit var observer: MutationObserver

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

@@ -1,31 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import org.w3c.dom.MutationObserverInit as NativeMutationObserverInit
-
-/**
- * Creates options for [org.w3c.dom.MutationObserver] without adding unspecified properties.
- *
- * Unlike the Kotlin DOM factory, this factory leaves absent options out of the JavaScript object. In particular,
- * an absent [attributeFilter] must not become a null sequence, and absent [attributes] and [characterData] must not
- * override the browser defaults implied by their filters or old-value options.
- *
- * Null arguments are omitted. Explicit false values and empty arrays are preserved. The browser remains responsible
- * for validating the options passed to [org.w3c.dom.MutationObserver.observe].
- */
-fun MutationObserverInit(
-    childList: Boolean? = null,
-    attributes: Boolean? = null,
-    characterData: Boolean? = null,
-    subtree: Boolean? = null,
-    attributeOldValue: Boolean? = null,
-    characterDataOldValue: Boolean? = null,
-    attributeFilter: Array<String>? = null
-): NativeMutationObserverInit = js("{}").unsafeCast<NativeMutationObserverInit>().apply {
-    if (childList != null) this.childList = childList
-    if (attributes != null) this.attributes = attributes
-    if (characterData != null) this.characterData = characterData
-    if (subtree != null) this.subtree = subtree
-    if (attributeOldValue != null) this.attributeOldValue = attributeOldValue
-    if (characterDataOldValue != null) this.characterDataOldValue = characterDataOldValue
-    if (attributeFilter != null) this.attributeFilter = attributeFilter
-}

common/src/jsTest/kotlin/dev/inmo/micro_utils/common/MutationObserverBrowserTests.kt

@@ -1,163 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import kotlinx.browser.document
-import org.w3c.dom.MutationObserver
-import org.w3c.dom.events.Event
-import org.w3c.dom.events.EventListener
-import kotlin.js.Promise
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFails
-import kotlin.test.assertNull
-import kotlin.test.assertSame
-import kotlin.test.assertTrue
-
-/** Runs only in the browser: jsNodeTest excludes this class rather than reporting DOM checks as passing. */
-class MutationObserverBrowserTests {
-    @Test
-    fun childListSubtreeRecordsCanBeDrainedAndDisconnected() {
-        val root = document.createElement("div")
-        val nested = document.createElement("div")
-        val child = document.createElement("span")
-        root.appendChild(nested)
-        val observer = MutationObserver { _, _ -> }
-        try {
-            observer.observe(root, MutationObserverInit(childList = true, subtree = true))
-            nested.appendChild(child)
-            val record = observer.takeRecords().single()
-            assertEquals("childList", record.type)
-            assertSame(nested, record.target)
-            assertSame(child, record.addedNodes.item(0))
-            assertEquals(0, record.removedNodes.length)
-            assertNull(record.attributeName)
-            assertTrue(observer.takeRecords().isEmpty())
-            observer.disconnect()
-            nested.removeChild(child)
-            assertTrue(observer.takeRecords().isEmpty())
-        } finally {
-            observer.disconnect()
-        }
-    }
-
-    @Test
-    fun attributeFilterEnablesObservationAndPreservesOldValues() {
-        val target = document.createElement("div")
-        target.setAttribute("data-state", "old")
-        val observer = MutationObserver { _, _ -> }
-        try {
-            observer.observe(target, MutationObserverInit(attributeFilter = arrayOf("data-state"), attributeOldValue = true))
-            target.setAttribute("ignored", "value")
-            target.setAttribute("data-state", "new")
-            val record = observer.takeRecords().single()
-            assertEquals("attributes", record.type)
-            assertSame(target, record.target)
-            assertEquals("data-state", record.attributeName)
-            assertEquals("old", record.oldValue)
-            assertNull(record.attributeNamespace)
-        } finally {
-            observer.disconnect()
-        }
-    }
-
-    @Test
-    fun characterDataOldValueEnablesObservation() {
-        val target = document.createTextNode("old")
-        val observer = MutationObserver { _, _ -> }
-        try {
-            observer.observe(target, MutationObserverInit(characterDataOldValue = true))
-            target.data = "new"
-            val record = observer.takeRecords().single()
-            assertEquals("characterData", record.type)
-            assertSame(target, record.target)
-            assertEquals("old", record.oldValue)
-        } finally {
-            observer.disconnect()
-        }
-    }
-
-    @Test
-    fun nullAttributeFilterIsOmittedInsteadOfConvertedToASequence() {
-        val target = document.createElement("div")
-        val observer = MutationObserver { _, _ -> }
-        try {
-            observer.observe(target, MutationObserverInit(childList = true, attributeFilter = null))
-            target.appendChild(document.createElement("span"))
-            assertEquals("childList", observer.takeRecords().single().type)
-        } finally {
-            observer.disconnect()
-        }
-    }
-
-    @Test
-    fun emptyAttributeFilterDoesNotObserveAllAttributes() {
-        val target = document.createElement("div")
-        val observer = MutationObserver { _, _ -> }
-        try {
-            observer.observe(target, MutationObserverInit(attributeFilter = emptyArray()))
-            target.setAttribute("data-state", "new")
-            assertTrue(observer.takeRecords().isEmpty())
-        } finally {
-            observer.disconnect()
-        }
-    }
-
-    @Test
-    fun nativeValidationRejectsContradictoryOptions() {
-        val target = document.createElement("div")
-        val observer = MutationObserver { _, _ -> }
-        try {
-            assertFails { observer.observe(target, MutationObserverInit()) }
-            assertFails {
-                observer.observe(target, MutationObserverInit(attributes = false, attributeFilter = arrayOf("class")))
-            }
-            assertFails {
-                observer.observe(target, MutationObserverInit(characterData = false, characterDataOldValue = true))
-            }
-        } finally {
-            observer.disconnect()
-        }
-    }
-
-    @Test
-    fun onRemovedCallsBackOnceAndDisconnects(): Promise<Unit> {
-        val parent = document.createElement("div")
-        val child = document.createElement("span")
-        var calls = 0
-        var observer: MutationObserver? = null
-        return Promise.resolve(Unit).then {
-            parent.appendChild(child)
-            document.body!!.appendChild(parent)
-            observer = child.onRemoved { calls++ }
-            parent.removeChild(child)
-        }.then {
-            assertEquals(1, calls)
-            parent.appendChild(child)
-            parent.removeChild(child)
-        }.then {
-            assertEquals(1, calls)
-        }.finally {
-            observer?.disconnect()
-            parent.parentNode?.removeChild(parent)
-        }
-    }
-
-    @Test
-    fun onClickOutsideStopsListeningAfterRemoval(): Promise<Unit> {
-        val target = document.createElement("div")
-        var calls = 0
-        var listener: EventListener? = null
-        return Promise.resolve(Unit).then {
-            document.body!!.appendChild(target)
-            listener = target.onClickOutside { calls++ }
-            document.dispatchEvent(Event("click"))
-            assertEquals(1, calls)
-            target.parentNode!!.removeChild(target)
-        }.then {
-            document.dispatchEvent(Event("click"))
-            assertEquals(1, calls)
-        }.finally {
-            listener?.let { document.removeEventListener("click", it) }
-            target.parentNode?.removeChild(target)
-        }
-    }
-}

common/src/jsTest/kotlin/dev/inmo/micro_utils/common/MutationObserverInitTests.kt

@@ -1,80 +0,0 @@
-package dev.inmo.micro_utils.common
-
-import org.w3c.dom.MutationObserverInit as NativeMutationObserverInit
-import kotlin.test.Test
-import kotlin.test.assertContentEquals
-import kotlin.test.assertEquals
-import kotlin.test.assertSame
-
-class MutationObserverInitTests {
-    private fun keys(options: NativeMutationObserverInit): List<String> =
-        js("Object.keys(options)").unsafeCast<Array<String>>().sorted()
-
-    @Test
-    fun emptyOptionsHaveNoProperties() {
-        assertEquals(emptyList(), keys(MutationObserverInit()))
-    }
-
-    @Test
-    fun childListOptionsOmitUnspecifiedProperties() {
-        val options = MutationObserverInit(childList = true, subtree = true)
-        assertEquals(listOf("childList", "subtree"), keys(options))
-        assertEquals(true, options.childList)
-        assertEquals(true, options.subtree)
-    }
-
-    @Test
-    fun explicitNullOptionsAreOmitted() {
-        val options = MutationObserverInit(
-            childList = null,
-            attributes = null,
-            characterData = null,
-            subtree = null,
-            attributeOldValue = null,
-            characterDataOldValue = null,
-            attributeFilter = null
-        )
-        assertEquals(emptyList(), keys(options))
-    }
-
-    @Test
-    fun explicitFalseAndEmptyFilterArePreserved() {
-        val filter = emptyArray<String>()
-        val options = MutationObserverInit(false, false, false, false, false, false, filter)
-        assertEquals(
-            listOf("attributeFilter", "attributeOldValue", "attributes", "characterData", "characterDataOldValue", "childList", "subtree"),
-            keys(options)
-        )
-        assertEquals(false, options.childList)
-        assertEquals(false, options.attributes)
-        assertEquals(false, options.characterData)
-        assertEquals(false, options.subtree)
-        assertEquals(false, options.attributeOldValue)
-        assertEquals(false, options.characterDataOldValue)
-        assertSame(filter, options.attributeFilter)
-        assertContentEquals(emptyArray(), options.attributeFilter)
-    }
-
-    @Test
-    fun filtersAndOldValueOptionsDoNotForceObservationFlags() {
-        val filter = arrayOf("class", "data-state")
-        val options = MutationObserverInit(
-            attributeFilter = filter,
-            attributeOldValue = true,
-            characterDataOldValue = true
-        )
-        assertEquals(listOf("attributeFilter", "attributeOldValue", "characterDataOldValue"), keys(options))
-        assertSame(filter, options.attributeFilter)
-        assertEquals(true, options.attributeOldValue)
-        assertEquals(true, options.characterDataOldValue)
-    }
-
-    @Test
-    fun eachCallCreatesIndependentOptions() {
-        val first = MutationObserverInit(childList = true)
-        val second = MutationObserverInit(attributes = true)
-        first.subtree = true
-        assertEquals(listOf("childList", "subtree"), keys(first))
-        assertEquals(listOf("attributes"), keys(second))
-    }
-}

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

@@ -37,7 +37,7 @@ class SmartKeyRWLocker<T>(
         readPermits = globalLockerReadPermits,
         writeIsLocked = globalLockerWriteIsLocked
     )
-    private val lockers = hashMapOf<T, SmartRWLocker>()
+    private val lockers = mutableMapOf<T, SmartRWLocker>()
     private val lockersMutex = Mutex()
     private val lockersWritingLocker = SmartSemaphore.Mutable(Int.MAX_VALUE)
     private val globalWritingLocker = SmartSemaphore.Mutable(Int.MAX_VALUE)
@@ -45,7 +45,7 @@ class SmartKeyRWLocker<T>(
     private fun allocateLockerWithoutLock(key: T) = lockers.getOrPut(key) {
         SmartRWLocker(perKeyReadPermits)
     }
-    private suspend inline fun allocateLocker(key: T) = lockersMutex.withLock {
+    private suspend fun allocateLocker(key: T) = lockersMutex.withLock {
         lockers.getOrPut(key) {
             SmartRWLocker(perKeyReadPermits)
         }

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

@@ -2,7 +2,6 @@ package dev.inmo.micro_utils.coroutines
 
 import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.currentCoroutineContext
-import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.first
@@ -50,31 +49,64 @@ sealed interface SmartMutex {
         override val lockStateFlow: StateFlow<Boolean> = _lockStateFlow.asStateFlow()
 
         private val internalChangesMutex = Mutex()
-        private val backingMutex = Mutex(locked = locked)
 
         fun immutable() = Immutable(lockStateFlow)
 
+        /**
+         * Holds call until this [SmartMutex] will be re-locked. That means that while [isLocked] == true, [holds] will
+         * wait for [isLocked] == false and then try to lock
+         */
         suspend fun lock() {
-            backingMutex.lock()
-            internalChangesMutex.withLock {
-                _lockStateFlow.value = true
-            }
+            do {
+                waitUnlock()
+                val shouldContinue = internalChangesMutex.withLock {
+                    if (_lockStateFlow.value) {
+                        true
+                    } else {
+                        _lockStateFlow.value = true
+                        false
+                    }
+                }
+            } while (shouldContinue && currentCoroutineContext().isActive)
         }
 
+        /**
+         * Will try to lock this [SmartMutex] immediataly
+         *
+         * @return True if lock was successful. False otherwise
+         */
         suspend fun tryLock(): Boolean {
-            val result = backingMutex.tryLock()
-            if (result) internalChangesMutex.withLock {
-                _lockStateFlow.value = true
+            return if (!_lockStateFlow.value) {
+                internalChangesMutex.withLock {
+                    if (!_lockStateFlow.value) {
+                        _lockStateFlow.value = true
+                        true
+                    } else {
+                        false
+                    }
+                }
+            } else {
+                false
             }
-            return result
         }
 
-        suspend fun unlock(): Boolean {
-            val tryUnlock = internalChangesMutex.withLock {
-                _lockStateFlow.value.also { if (it) _lockStateFlow.value = false }
+        /**
+         * If [isLocked] == true - will change it to false and return true. If current call will not unlock this
+         * [SmartMutex] - false
+         */
+        suspend fun unlock(): Boolean = withContext(NonCancellable) {
+            if (_lockStateFlow.value) {
+                internalChangesMutex.withLock {
+                    if (_lockStateFlow.value) {
+                        _lockStateFlow.value = false
+                        true
+                    } else {
+                        false
+                    }
+                }
+            } else {
+                false
             }
-            if (tryUnlock) backingMutex.unlock()
-            return tryUnlock
         }
     }
 }
@@ -102,11 +134,4 @@ suspend inline fun <T> SmartMutex.Mutable.withLock(action: () -> T): T {
  * Anyway, after the end of this block there are no any guaranties that [SmartMutex.isLocked] == false due to the fact
  * that some other parties may lock it again
  */
-suspend fun SmartMutex.waitUnlock(): Boolean {
-    currentCoroutineContext().ensureActive()
-    return if (!lockStateFlow.value) {
-        false
-    } else {
-        lockStateFlow.first { !it }
-    }
-}
+suspend fun SmartMutex.waitUnlock() = lockStateFlow.first { !it }

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

@@ -1,6 +1,8 @@
 package dev.inmo.micro_utils.coroutines
 
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.withContext
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -37,7 +39,9 @@ class SmartRWLocker(private val readPermits: Int = Int.MAX_VALUE, writeIsLocked:
     /**
      * Release one read permit in [readSemaphore]
      */
-    suspend fun releaseRead(): Boolean = _readSemaphore.release()
+    suspend fun releaseRead(): Boolean = withContext(NonCancellable) {
+        _readSemaphore.release()
+    }
 
     /**
      * Locking [writeMutex] and wait while all [readSemaphore] permits will be freed
@@ -47,7 +51,9 @@ class SmartRWLocker(private val readPermits: Int = Int.MAX_VALUE, writeIsLocked:
         try {
             _readSemaphore.acquire(readPermits)
         } catch (e: CancellationException) {
-            _writeMutex.unlock()
+            withContext(NonCancellable) {
+                _writeMutex.unlock()
+            }
             throw e
         }
     }
@@ -55,12 +61,13 @@ class SmartRWLocker(private val readPermits: Int = Int.MAX_VALUE, writeIsLocked:
     /**
      * Unlock [writeMutex]
      */
-    suspend fun unlockWrite(): Boolean =
+    suspend fun unlockWrite(): Boolean = withContext(NonCancellable) {
         _writeMutex.unlock().also { unlocked ->
             if (unlocked) {
                 _readSemaphore.release(readPermits)
             }
         }
+    }
 }
 
 /**

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

@@ -2,7 +2,6 @@ package dev.inmo.micro_utils.coroutines
 
 import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.currentCoroutineContext
-import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.first
@@ -61,34 +60,36 @@ sealed interface SmartSemaphore {
         override val permitsStateFlow: StateFlow<Int> = _freePermitsStateFlow.asStateFlow()
 
         private val internalChangesMutex = Mutex(false)
-        private val acquirePermitsMutex = Mutex(false)
 
         fun immutable() = Immutable(permitsStateFlow, maxPermits)
 
-        private fun checkedPermits(permits: Int) = permits.coerceIn(1, maxPermits)
+        private fun checkedPermits(permits: Int) = permits.coerceIn(1 .. this.maxPermits)
 
         /**
          * Holds call until this [SmartSemaphore] will be re-locked. That means that current method will
          */
         suspend fun acquire(permits: Int = 1) {
+            var acquiredPermits = 0
             val checkedPermits = checkedPermits(permits)
-            var changed = false
-            acquirePermitsMutex.withLock {
-                _freePermitsStateFlow.first {
-                    it >= checkedPermits
-                }
-                internalChangesMutex.withLock {
-                    try {
-                        _freePermitsStateFlow.value -= checkedPermits
-                        changed = true
-                        suspendPoint()
-                    } catch (e: Throwable) {
-                        if (changed) {
-                            _freePermitsStateFlow.value += checkedPermits
-                        }
-                        throw e
+            try {
+                do {
+                    val shouldContinue = internalChangesMutex.withLock {
+                        val requiredPermits = checkedPermits - acquiredPermits
+                        val acquiring = minOf(freePermits, requiredPermits).takeIf { it > 0 } ?: return@withLock true
+                        acquiredPermits += acquiring
+                        _freePermitsStateFlow.value -= acquiring
+
+                        acquiredPermits != checkedPermits
                     }
+                    if (shouldContinue) {
+                        waitRelease(checkedPermits - acquiredPermits)
+                    }
+                } while (shouldContinue && currentCoroutineContext().isActive)
+            } catch (e: Throwable) {
+                if (acquiredPermits > 0) {
+                    release(acquiredPermits)
                 }
+                throw e
             }
         }
 
@@ -96,9 +97,19 @@ sealed interface SmartSemaphore {
          * Holds call until this [SmartSemaphore] will be re-locked. That means that while [freePermits] == true, [holds] will
          * wait for [freePermits] == false and then try to lock
          */
-        @Deprecated("Use acquire instead", ReplaceWith("acquire(permits)"))
         suspend fun acquireByOne(permits: Int = 1) {
-            return acquire(permits)
+            val checkedPermits = checkedPermits(permits)
+            do {
+                waitRelease(checkedPermits)
+                val shouldContinue = internalChangesMutex.withLock {
+                    if (_freePermitsStateFlow.value < checkedPermits) {
+                        true
+                    } else {
+                        _freePermitsStateFlow.value -= checkedPermits
+                        false
+                    }
+                }
+            } while (shouldContinue && currentCoroutineContext().isActive)
         }
 
         /**
@@ -107,29 +118,18 @@ sealed interface SmartSemaphore {
          * @return True if lock was successful. False otherwise
          */
         suspend fun tryAcquire(permits: Int = 1): Boolean {
-            if (acquirePermitsMutex.tryLock() == false) return false
-
             val checkedPermits = checkedPermits(permits)
-            var changed = false
-
-            return internalChangesMutex.withLock {
-                try {
+            return if (_freePermitsStateFlow.value >= checkedPermits) {
+                internalChangesMutex.withLock {
                     if (_freePermitsStateFlow.value >= checkedPermits) {
                         _freePermitsStateFlow.value -= checkedPermits
-                        changed = true
-                        suspendPoint()
                         true
                     } else {
                         false
                     }
-                } catch (e: Throwable) {
-                    if (changed) {
-                        _freePermitsStateFlow.value += checkedPermits
-                    }
-                    throw e
-                } finally {
-                    acquirePermitsMutex.unlock()
                 }
+            } else {
+                false
             }
         }
 
@@ -137,32 +137,21 @@ sealed interface SmartSemaphore {
          * If [freePermits] == true - will change it to false and return true. If current call will not unlock this
          * [SmartSemaphore] - false
          */
-        suspend fun release(permits: Int = 1): Boolean {
+        suspend fun release(permits: Int = 1): Boolean = withContext(NonCancellable) {
             val checkedPermits = checkedPermits(permits)
-            if (_freePermitsStateFlow.value >= maxPermits) return false
-
-            // Updating permits without suspension remains safe in a cancelled coroutine.
-            if (internalChangesMutex.tryLock()) {
-                try {
-                    return releaseLocked(checkedPermits)
-                } finally {
-                    internalChangesMutex.unlock()
-                }
-            }
-
-            return withContext(NonCancellable) {
+            if (_freePermitsStateFlow.value < maxPermits) {
                 internalChangesMutex.withLock {
-                    releaseLocked(checkedPermits)
+                    if (_freePermitsStateFlow.value < maxPermits) {
+                        _freePermitsStateFlow.value = minOf(_freePermitsStateFlow.value + checkedPermits, maxPermits)
+                        true
+                    } else {
+                        false
+                    }
                 }
+            } else {
+                false
             }
         }
-
-        private fun releaseLocked(permits: Int): Boolean {
-            val freePermits = _freePermitsStateFlow.value
-            if (freePermits >= maxPermits) return false
-            _freePermitsStateFlow.value = minOf(freePermits + permits, maxPermits)
-            return true
-        }
     }
 }
 
@@ -189,14 +178,5 @@ suspend inline fun <T> SmartSemaphore.Mutable.withAcquire(permits: Int = 1, acti
  * Anyway, after the end of this block there are no any guaranties that [SmartSemaphore.freePermits] >= [permits] due to
  * the fact that some other parties may lock it again
  */
-suspend fun SmartSemaphore.waitRelease(permits: Int = 1): Int {
-    currentCoroutineContext().ensureActive()
-    val availablePermits = freePermits
-    return if (availablePermits >= permits) availablePermits else permitsStateFlow.first { it >= permits }
-}
-
-suspend fun SmartSemaphore.waitReleaseAll(): Int {
-    currentCoroutineContext().ensureActive()
-    val availablePermits = freePermits
-    return if (availablePermits == maxPermits) availablePermits else permitsStateFlow.first { it == maxPermits }
-}
+suspend fun SmartSemaphore.waitRelease(permits: Int = 1) = permitsStateFlow.first { it >= permits }
+suspend fun SmartSemaphore.waitReleaseAll() = permitsStateFlow.first { it == maxPermits }

coroutines/src/commonTest/kotlin/SmartMutexTests.kt

@@ -14,17 +14,6 @@ import kotlin.test.assertTrue
 import kotlin.time.Duration.Companion.seconds
 
 class SmartMutexTests {
-    @Test
-    fun initiallyLockedMutexCanBeReleasedAndReacquired() = runTest(timeout = 5.seconds) {
-        val mutex = SmartMutex.Mutable(locked = true)
-        assertTrue(mutex.isLocked)
-        assertFalse(mutex.tryLock())
-        assertTrue(mutex.unlock())
-        assertFalse(mutex.isLocked)
-        assertTrue(mutex.tryLock())
-        assertTrue(mutex.unlock())
-    }
-
     @Test
     fun cancelledUnlockCompletesUnderContention() = runTest(timeout = 5.seconds) {
         val mutex = SmartMutex.Mutable()
@@ -43,8 +32,7 @@ class SmartMutexTests {
         releaser.join()
 
         assertTrue(releaser.isCancelled)
-        assertTrue(mutex.isLocked, "Cancellation must not prevent the delegated unlock")
-        assertTrue(mutex.unlock())
+        assertFalse(mutex.isLocked, "Cancellation must not prevent the delegated unlock")
         assertTrue(mutex.tryLock())
         assertTrue(mutex.unlock())
     }

coroutines/src/commonTest/kotlin/SmartRWLockerTests.kt

@@ -13,25 +13,6 @@ import kotlin.time.Duration.Companion.days
 import kotlin.time.Duration.Companion.seconds
 
 class SmartRWLockerTests {
-    @Test
-    fun initiallyWriteLockedLockerReleasesReadPermits() = runTest(timeout = 5.seconds) {
-        val locker = SmartRWLocker(readPermits = 2, writeIsLocked = true)
-        assertTrue(locker.writeMutex.isLocked)
-        assertEquals(0, locker.readSemaphore.freePermits)
-
-        assertTrue(locker.unlockWrite())
-
-        assertFalse(locker.writeMutex.isLocked)
-        assertEquals(2, locker.readSemaphore.freePermits)
-        locker.withReadAcquire {
-            assertEquals(1, locker.readSemaphore.freePermits)
-        }
-        locker.withWriteLock {
-            assertEquals(0, locker.readSemaphore.freePermits)
-        }
-        assertEquals(2, locker.readSemaphore.freePermits)
-    }
-
     @Test
     fun compositeTest() {
         val locker = SmartRWLocker()

coroutines/src/commonTest/kotlin/SmartSemaphoreConcurrentReleaseTests.kt

@@ -1,72 +0,0 @@
-import dev.inmo.micro_utils.coroutines.SmartSemaphore
-import kotlinx.coroutines.CoroutineStart
-import kotlinx.coroutines.Deferred
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.test.runTest
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-import kotlin.time.Duration.Companion.seconds
-
-class SmartSemaphoreConcurrentReleaseTests {
-    @Test
-    fun queuedReleasesRestoreEveryAcquiredPermit() = runTest(timeout = 5.seconds) {
-        val semaphore = SmartSemaphore.Mutable(permits = 4, acquiredPermits = 4)
-
-        val results = releaseWithQueuedContenders(semaphore, contenderCount = 3)
-
-        assertEquals(listOf(true, true, true), results)
-        assertEquals(4, semaphore.freePermits)
-        assertTrue(semaphore.tryAcquire(4))
-        assertFalse(semaphore.tryAcquire())
-        assertEquals(0, semaphore.freePermits)
-    }
-
-    @Test
-    fun queuedReleasesRecheckCapacityAfterAcquiringTheMutex() = runTest(timeout = 5.seconds) {
-        val semaphore = SmartSemaphore.Mutable(permits = 2, acquiredPermits = 2)
-
-        val results = releaseWithQueuedContenders(semaphore, contenderCount = 3)
-
-        assertEquals(1, results.count { released -> released })
-        assertEquals(2, results.count { released -> !released })
-        assertEquals(2, semaphore.freePermits)
-        assertFalse(semaphore.release())
-    }
-
-    private suspend fun releaseWithQueuedContenders(
-        semaphore: SmartSemaphore.Mutable,
-        contenderCount: Int
-    ): List<Boolean> = coroutineScope {
-        val contenders = mutableListOf<Deferred<Boolean>>()
-        val observer = launch(Dispatchers.Unconfined) {
-            semaphore.permitsStateFlow.first { freePermits ->
-                if (freePermits == 1) {
-                    // The first release still holds the changes mutex while publishing.
-                    // Every contender observes spare capacity before waiting for the mutex.
-                    repeat(contenderCount) {
-                        val contender = async(Dispatchers.Unconfined, start = CoroutineStart.UNDISPATCHED) {
-                            semaphore.release()
-                        }
-                        contenders.add(contender)
-                        assertFalse(contender.isCompleted, "Competing releases must wait for the publishing release")
-                    }
-                    true
-                } else {
-                    false
-                }
-            }
-        }
-
-        assertTrue(semaphore.release())
-        observer.join()
-        assertEquals(contenderCount, contenders.size)
-        contenders.awaitAll()
-    }
-}

coroutines/src/commonTest/kotlin/SmartSemaphoreTests.kt

@@ -1,7 +1,6 @@
 import dev.inmo.micro_utils.coroutines.SmartSemaphore
 import dev.inmo.micro_utils.coroutines.withAcquire
 import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.awaitCancellation
 import kotlinx.coroutines.cancelAndJoin
 import kotlinx.coroutines.flow.first
@@ -39,6 +38,35 @@ class SmartSemaphoreTests {
         assertEquals(2, semaphore.freePermits)
     }
 
+    @Test
+    fun cancelledAcquireReturnsPartialPermitsUnderContention() = runTest(timeout = 5.seconds) {
+        // One permit belongs to another holder; the waiter can acquire two
+        // permits immediately, but must wait for the third.
+        val semaphore = SmartSemaphore.Mutable(permits = 3, acquiredPermits = 1)
+        lateinit var waiter: kotlinx.coroutines.Job
+        val cancellation = launch(Dispatchers.Unconfined) {
+            semaphore.permitsStateFlow.first { it == 1 }
+            waiter.cancel()
+        }
+        waiter = launch(Dispatchers.Unconfined) {
+            semaphore.acquire(3)
+        }
+        assertEquals(0, semaphore.freePermits)
+        assertFalse(waiter.isCompleted)
+
+        // Publishing this release resumes the observer while the internal
+        // mutex is held. The cancelled acquire must wait to roll back safely.
+        semaphore.release()
+        cancellation.join()
+        waiter.join()
+        assertTrue(waiter.isCancelled)
+        assertEquals(3, semaphore.freePermits, "Cancellation must return both partially acquired permits")
+        semaphore.withAcquire(3) {
+            assertEquals(0, semaphore.freePermits)
+        }
+        assertEquals(3, semaphore.freePermits)
+    }
+
     @Test
     fun cancelledAcquireWithoutPermitsDoesNotReleaseAnotherHoldersPermit() = runTest(timeout = 5.seconds) {
         val semaphore = SmartSemaphore.Mutable(permits = 1, acquiredPermits = 1)

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

@@ -1,78 +0,0 @@
-package dev.inmo.micro_utils.coroutines
-
-import java.util.concurrent.CyclicBarrier
-import java.util.concurrent.Executors
-import java.util.concurrent.TimeUnit
-import kotlinx.coroutines.asCoroutineDispatcher
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.joinAll
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.test.runTest
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFalse
-import kotlin.test.assertTrue
-import kotlin.time.Duration.Companion.seconds
-
-class SmartSemaphoreParallelReleaseTests {
-    @Test
-    fun parallelSinglePermitReleasesRestoreEveryPermit() = runTest(timeout = 30.seconds) {
-        assertParallelReleases(permits = 8, releasePermits = List(8) { 1 }, expectedSuccessfulReleases = 8)
-    }
-
-    @Test
-    fun parallelBulkReleasesRestoreEveryPermit() = runTest(timeout = 30.seconds) {
-        val releasePermits = (1 .. 8).toList()
-        assertParallelReleases(
-            permits = releasePermits.sum(),
-            releasePermits = releasePermits,
-            expectedSuccessfulReleases = releasePermits.size
-        )
-    }
-
-    @Test
-    fun parallelExcessReleasesStopAtCapacity() = runTest(timeout = 30.seconds) {
-        assertParallelReleases(permits = 3, releasePermits = List(8) { 1 }, expectedSuccessfulReleases = 3)
-        assertParallelReleases(permits = 5, releasePermits = List(8) { 3 }, expectedSuccessfulReleases = 2)
-    }
-
-    private suspend fun assertParallelReleases(
-        permits: Int,
-        releasePermits: List<Int>,
-        expectedSuccessfulReleases: Int
-    ) = coroutineScope {
-        val semaphore = SmartSemaphore.Mutable(permits = permits, acquiredPermits = permits)
-        val barrier = CyclicBarrier(releasePermits.size)
-        val results = BooleanArray(releasePermits.size)
-        val rounds = 100
-
-        Executors.newFixedThreadPool(releasePermits.size).asCoroutineDispatcher().use { dispatcher ->
-            releasePermits.mapIndexed { worker, count ->
-                launch(dispatcher) {
-                    repeat(rounds) { round ->
-                        // Blocking barriers on dedicated JVM threads produce actual parallel releases.
-                        barrier.await(5, TimeUnit.SECONDS)
-                        results[worker] = semaphore.release(count)
-                        barrier.await(5, TimeUnit.SECONDS)
-
-                        if (worker == 0) {
-                            assertEquals(permits, semaphore.freePermits, "Round $round must preserve released permits")
-                            assertEquals(expectedSuccessfulReleases, results.count { released -> released })
-                            assertFalse(semaphore.release(), "A full semaphore must reject another release")
-                            assertEquals(permits, semaphore.freePermits)
-                            if (round < rounds - 1) {
-                                assertTrue(semaphore.tryAcquire(permits))
-                                assertEquals(0, semaphore.freePermits)
-                            }
-                        }
-
-                        // Finish validation and reset before starting the next release wave.
-                        barrier.await(5, TimeUnit.SECONDS)
-                    }
-                }
-            }.joinAll()
-        }
-
-        assertEquals(permits, semaphore.freePermits)
-    }
-}

gradle.properties

@@ -16,5 +16,5 @@ crypto_js_version=4.2.0
 # Project data
 
 group=dev.inmo
-version=0.33.0
-android_code_version=321
+version=0.32.0
+android_code_version=319

gradle/libs.versions.toml

@@ -1,25 +1,25 @@
 [versions]
 
 kt = "2.4.21"
-kt-serialization = "1.12.0"
+kt-serialization = "1.11.0"
 kt-coroutines = "1.11.0"
 
 kotlinx-browser = "0.5.0"
 
 kslog = "2.1.0"
 
-jb-compose = "1.12.2"
+jb-compose = "1.12.1"
 jb-compose-material3 = "1.9.0"
 jb-compose-icons = "1.7.8"
-jb-exposed = "1.6.0"
+jb-exposed = "1.5.1"
 jb-dokka = "2.2.0"
 
-sqlite = "3.54.1.0"
+sqlite = "3.53.4.0"
 
 korlibs = "5.4.0"
 uuid = "0.8.4"
 
-ktor = "3.6.1"
+ktor = "3.6.0"
 
 gh-release = "2.5.2"
 

gradle/templates/defaultProject.gradle

@@ -4,7 +4,6 @@ project.group = "$group"
 apply plugin: 'org.jetbrains.dokka'
 
 kotlin {
-    jvmToolchain(17)
     sourceSets {
         commonMain {
             dependencies {

gradle/templates/enableMPPWasmJs.gradle

@@ -3,7 +3,7 @@ kotlin {
         browser {
             testTask {
                 useKarma {
-                    useChromeHeadlessNoSandbox()
+                    useChromeHeadless()
                     useConfigDirectory(rootProject.relativeProjectPath("gradle/karma.config.d"))
                 }
             }

koin/generator/build.gradle

@@ -19,7 +19,3 @@ java {
     sourceCompatibility = JavaVersion.VERSION_17
     targetCompatibility = JavaVersion.VERSION_17
 }
-
-kotlin {
-    jvmToolchain(17)
-}

ksp/classcasts/generator/build.gradle

@@ -19,7 +19,3 @@ java {
     sourceCompatibility = JavaVersion.VERSION_17
     targetCompatibility = JavaVersion.VERSION_17
 }
-
-kotlin {
-    jvmToolchain(17)
-}

ksp/generator/build.gradle

@@ -18,7 +18,3 @@ java {
     sourceCompatibility = JavaVersion.VERSION_17
     targetCompatibility = JavaVersion.VERSION_17
 }
-
-kotlin {
-    jvmToolchain(17)
-}

ksp/sealed/generator/build.gradle

@@ -19,7 +19,3 @@ java {
     sourceCompatibility = JavaVersion.VERSION_17
     targetCompatibility = JavaVersion.VERSION_17
 }
-
-kotlin {
-    jvmToolchain(17)
-}

ksp/variations/generator/build.gradle

@@ -20,7 +20,3 @@ java {
     sourceCompatibility = JavaVersion.VERSION_17
     targetCompatibility = JavaVersion.VERSION_17
 }
-
-kotlin {
-    jvmToolchain(17)
-}

language_codes/generator/build.gradle

@@ -31,7 +31,3 @@ java {
     sourceCompatibility = JavaVersion.VERSION_17
     targetCompatibility = JavaVersion.VERSION_17
 }
-
-kotlin {
-    jvmToolchain(17)
-}

repos/generator/build.gradle

@@ -19,7 +19,3 @@ java {
     sourceCompatibility = JavaVersion.VERSION_17
     targetCompatibility = JavaVersion.VERSION_17
 }
-
-kotlin {
-    jvmToolchain(17)
-}