Use setTimeout-based dispatcher when process is not available on the target runtime

Fixes #1404

Author: qwwdfsad

kotlinx-coroutines-core/js/src/CoroutineContext.kt

@@ -9,6 +9,7 @@ import kotlin.coroutines.*
 
 private external val navigator: dynamic
 private const val UNDEFINED = "undefined"
+internal external val process: dynamic
 
 internal actual fun createDefaultDispatcher(): CoroutineDispatcher = when {
     // Check if we are running under ReactNative. We have to use NodeDispatcher under it.
@@ -24,6 +25,8 @@ internal actual fun createDefaultDispatcher(): CoroutineDispatcher = when {
     // Check if we are in the browser and must use window.postMessage to avoid setTimeout throttling
     jsTypeOf(window) != UNDEFINED && window.asDynamic() != null && jsTypeOf(window.asDynamic().addEventListener) != UNDEFINED ->
         window.asCoroutineDispatcher()
+    // If process is undefined (e.g. in NativeScript, #1404), use SetTimeout-based dispatcher
+    jsTypeOf(process) == UNDEFINED -> SetTimeoutDispatcher
     // Fallback to NodeDispatcher when browser environment is not detected
     else -> NodeDispatcher
 }

kotlinx-coroutines-core/js/src/JSDispatcher.kt

@@ -7,32 +7,45 @@ package kotlinx.coroutines
 import kotlinx.coroutines.internal.*
 import org.w3c.dom.*
 import kotlin.coroutines.*
-import kotlin.js.*
+import kotlin.js.Promise
 
 private const val MAX_DELAY = Int.MAX_VALUE.toLong()
 
 private fun delayToInt(timeMillis: Long): Int =
     timeMillis.coerceIn(0, MAX_DELAY).toInt()
 
-internal object NodeDispatcher : CoroutineDispatcher(), Delay {
-    override fun dispatch(context: CoroutineContext, block: Runnable) = NodeJsMessageQueue.enqueue(block)
+internal sealed class SetTimeoutBasedDispatcher: CoroutineDispatcher(), Delay {
+    override fun invokeOnTimeout(timeMillis: Long, block: Runnable): DisposableHandle {
+        val handle = setTimeout({ block.run() }, delayToInt(timeMillis))
+        return ClearTimeout(handle)
+    }
 
     override fun scheduleResumeAfterDelay(timeMillis: Long, continuation: CancellableContinuation<Unit>) {
         val handle = setTimeout({ with(continuation) { resumeUndispatched(Unit) } }, delayToInt(timeMillis))
         // Actually on cancellation, but clearTimeout is idempotent
         continuation.invokeOnCancellation(handler = ClearTimeout(handle).asHandler)
     }
+}
+
+internal object NodeDispatcher : SetTimeoutBasedDispatcher() {
+    override fun dispatch(context: CoroutineContext, block: Runnable) = NodeJsMessageQueue.enqueue(block)
+}
+
+internal object SetTimeoutDispatcher : SetTimeoutBasedDispatcher() {
+    override fun dispatch(context: CoroutineContext, block: Runnable) = SetTimeoutMessageQueue.enqueue(block)
+}
 
-    private class ClearTimeout(private val handle: Int) : CancelHandler(), DisposableHandle {
-        override fun dispose() { clearTimeout(handle) }
-        override fun invoke(cause: Throwable?) { dispose() }
-        override fun toString(): String = "ClearTimeout[$handle]"
+private class ClearTimeout(private val handle: Int) : CancelHandler(), DisposableHandle {
+
+    override fun dispose() {
+        clearTimeout(handle)
     }
 
-    override fun invokeOnTimeout(timeMillis: Long, block: Runnable): DisposableHandle {
-        val handle = setTimeout({ block.run() }, delayToInt(timeMillis))
-        return ClearTimeout(handle)
+    override fun invoke(cause: Throwable?) {
+        dispose()
     }
+
+    override fun toString(): String = "ClearTimeout[$handle]"
 }
 
 internal class WindowDispatcher(private val window: Window) : CoroutineDispatcher(), Delay {
@@ -86,6 +99,16 @@ private object NodeJsMessageQueue : MessageQueue() {
     }
 }
 
+private object SetTimeoutMessageQueue : MessageQueue() {
+    override fun schedule() = scheduleProcess()
+
+    override fun reschedule() = scheduleProcess()
+
+    private fun scheduleProcess() {
+        setTimeout({ process() }, 0)
+    }
+}
+
 /**
  * An abstraction over JS scheduling mechanism that leverages micro-batching of [dispatch] blocks without
  * paying the cost of JS callbacks scheduling on every dispatch.
@@ -136,4 +159,3 @@ internal abstract class MessageQueue : ArrayQueue<Runnable>() {
 // using them via "window" (which only works in browser)
 private external fun setTimeout(handler: dynamic, timeout: Int = definedExternally): Int
 private external fun clearTimeout(handle: Int = definedExternally)
-private external val process: dynamic