add .kotlin in gitignore

.gitignore

@@ -17,3 +17,5 @@ publishing.sh
 
 local.*
 local/
+
+.kotlin/

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

@@ -8,34 +8,34 @@ fun CoroutineScope.launchSafely(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     onException: ExceptionHandler<Unit> = defaultSafelyExceptionHandler,
-    block: suspend CoroutineScope.() -> Unit
+    block: suspend () -> Unit
 ) = launch(context, start) {
-    runCatchingSafely(onException) { block() }
+    runCatchingSafely(onException, block = block)
 }
 
 fun CoroutineScope.launchSafelyWithoutExceptions(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     onException: ExceptionHandler<Unit?> = defaultSafelyWithoutExceptionHandlerWithNull,
-    block: suspend CoroutineScope.() -> Unit
+    block: suspend () -> Unit
 ) = launch(context, start) {
-    runCatchingSafelyWithoutExceptions(onException) { block() }
+    runCatchingSafelyWithoutExceptions(onException, block = block)
 }
 
 fun <T> CoroutineScope.asyncSafely(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     onException: ExceptionHandler<T> = defaultSafelyExceptionHandler,
-    block: suspend CoroutineScope.() -> T
+    block: suspend () -> T
 ) = async(context, start) {
-    runCatchingSafely(onException) { block() }
+    runCatchingSafely(onException, block = block)
 }
 
 fun <T> CoroutineScope.asyncSafelyWithoutExceptions(
     context: CoroutineContext = EmptyCoroutineContext,
     start: CoroutineStart = CoroutineStart.DEFAULT,
     onException: ExceptionHandler<T?> = defaultSafelyWithoutExceptionHandlerWithNull,
-    block: suspend CoroutineScope.() -> T
+    block: suspend () -> T
 ) = async(context, start) {
-    runCatchingSafelyWithoutExceptions(onException) { block() }
+    runCatchingSafelyWithoutExceptions(onException, block = block)
 }

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

@@ -10,8 +10,12 @@ fun CoroutineScope.LinkedSupervisorJob(
     additionalContext: CoroutineContext? = null
 ) = coroutineContext.LinkedSupervisorJob(additionalContext)
 
-fun CoroutineScope.LinkedSupervisorScope(
+
+fun CoroutineContext.LinkedSupervisorScope(
     additionalContext: CoroutineContext? = null
 ) = CoroutineScope(
-    coroutineContext + LinkedSupervisorJob(additionalContext)
+    this + LinkedSupervisorJob(additionalContext)
 )
+fun CoroutineScope.LinkedSupervisorScope(
+    additionalContext: CoroutineContext? = null
+) = coroutineContext.LinkedSupervisorScope(additionalContext)

fsm/common/src/commonMain/kotlin/dev/inmo/micro_utils/fsm/common/StatesMachine.kt

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.fsm.common
 
 import dev.inmo.micro_utils.common.Optional
-import dev.inmo.micro_utils.common.onPresented
 import dev.inmo.micro_utils.coroutines.*
 import dev.inmo.micro_utils.fsm.common.utils.StateHandlingErrorHandler
 import dev.inmo.micro_utils.fsm.common.utils.defaultStateHandlingErrorHandler
@@ -118,15 +117,17 @@ open class DefaultStatesMachine <T: State>(
      * [launchStateHandling] will returns some [State] then [statesManager] [StatesManager.update] will be used, otherwise
      * [StatesManager.endChain].
      */
-    override fun start(scope: CoroutineScope): Job = scope.launchSafelyWithoutExceptions {
+    override fun start(scope: CoroutineScope): Job {
-        (statesManager.getActiveStates().asFlow() + statesManager.onStartChain).subscribeSafelyWithoutExceptions(this) {
+        val supervisorScope = scope.LinkedSupervisorScope()
-            launch { performStateUpdate(Optional.absent(), it, scope.LinkedSupervisorScope()) }
+        supervisorScope.launchSafelyWithoutExceptions {
+            (statesManager.getActiveStates().asFlow() + statesManager.onStartChain).subscribeSafelyWithoutExceptions(supervisorScope) {
+                supervisorScope.launch { performStateUpdate(Optional.absent(), it, supervisorScope) }
             }
-        statesManager.onChainStateUpdated.subscribeSafelyWithoutExceptions(this) {
+            statesManager.onChainStateUpdated.subscribeSafelyWithoutExceptions(supervisorScope) {
-            launch { performStateUpdate(Optional.presented(it.first), it.second, scope.LinkedSupervisorScope()) }
+                supervisorScope.launch { performStateUpdate(Optional.presented(it.first), it.second, supervisorScope) }
             }
-        statesManager.onEndChain.subscribeSafelyWithoutExceptions(this) { removedState ->
+            statesManager.onEndChain.subscribeSafelyWithoutExceptions(supervisorScope) { removedState ->
-            launch {
+                supervisorScope.launch {
                     statesJobsMutex.withLock {
                         val stateInMap = statesJobs.keys.firstOrNull { stateInMap -> stateInMap == removedState }
                         if (stateInMap === removedState) {
@@ -137,6 +138,9 @@ open class DefaultStatesMachine <T: State>(
             }
         }
 
+        return supervisorScope.coroutineContext.job
+    }
+
     /**
      * Just calls [StatesManager.startChain] of [statesManager]
      */

ktor/server/src/jvmMain/kotlin/dev/inmo/micro_utils/ktor/server/TemporalFilesRoutingConfigurator.kt

@@ -41,7 +41,7 @@ class TemporalFilesRoutingConfigurator(
                     filesMutex: Mutex,
                     onNewFileFlow: Flow<TemporalFileId>
                 ): Job = scope.launchSafelyWithoutExceptions {
-                    while (isActive) {
+                    while (currentCoroutineContext().isActive) {
                         val filesWithCreationInfo = filesMap.mapNotNull { (fileId, file) ->
                             fileId to ((Files.getAttribute(file.toPath(), "creationTime") as? FileTime) ?.toMillis() ?: return@mapNotNull null)
                         }