Migrate Kitsu API to coroutines and kotlinx.serialization

app/src/main/java/eu/kanade/tachiyomi/util/lang/RxCoroutineBridge.kt

@@ -119,7 +119,8 @@ suspend fun <T> Single<T>.await(): T = suspendCancellableCoroutine { cont ->
 suspend fun <T> Observable<T>.awaitFirst(): T = first().awaitOne()
 
 @OptIn(InternalCoroutinesApi::class, ExperimentalCoroutinesApi::class)
-suspend fun <T> Observable<T>.awaitFirstOrDefault(default: T): T = firstOrDefault(default).awaitOne()
+suspend fun <T> Observable<T>.awaitFirstOrDefault(default: T): T =
+    firstOrDefault(default).awaitOne()
 
 @OptIn(InternalCoroutinesApi::class, ExperimentalCoroutinesApi::class)
 suspend fun <T> Observable<T>.awaitFirstOrNull(): T? = firstOrDefault(null).awaitOne()
@@ -137,7 +138,8 @@ suspend fun <T> Observable<T>.awaitLast(): T = last().awaitOne()
 @OptIn(InternalCoroutinesApi::class, ExperimentalCoroutinesApi::class)
 suspend fun <T> Observable<T>.awaitSingle(): T = single().awaitOne()
 
-suspend fun <T> Observable<T>.awaitSingleOrDefault(default: T): T = singleOrDefault(default).awaitOne()
+suspend fun <T> Observable<T>.awaitSingleOrDefault(default: T): T =
+    singleOrDefault(default).awaitOne()
 
 suspend fun <T> Observable<T>.awaitSingleOrNull(): T? = singleOrDefault(null).awaitOne()
 
@@ -203,9 +205,9 @@ fun <T : Any> Flow<T>.asObservable(backpressureMode: Emitter.BackpressureMode =
     return Observable.create(
         { emitter ->
             /*
-         * ATOMIC is used here to provide stable behaviour of subscribe+dispose pair even if
-         * asObservable is already invoked from unconfined
-         */
+             * ATOMIC is used here to provide stable behaviour of subscribe+dispose pair even if
+             * asObservable is already invoked from unconfined
+             */
             val job = GlobalScope.launch(Dispatchers.Unconfined, start = CoroutineStart.ATOMIC) {
                 try {
                     collect { emitter.onNext(it) }
@@ -224,3 +226,28 @@ fun <T : Any> Flow<T>.asObservable(backpressureMode: Emitter.BackpressureMode =
         backpressureMode
     )
 }
+
+fun <T> runAsObservable(
+    block: suspend () -> T,
+    backpressureMode: Emitter.BackpressureMode = Emitter.BackpressureMode.NONE
+): Observable<T> {
+    return Observable.create(
+        { emitter ->
+            val job = GlobalScope.launch(Dispatchers.Unconfined, start = CoroutineStart.ATOMIC) {
+                try {
+                    emitter.onNext(block())
+                    emitter.onCompleted()
+                } catch (e: Throwable) {
+                    // Ignore `CancellationException` as error, since it indicates "normal cancellation"
+                    if (e !is CancellationException) {
+                        emitter.onError(e)
+                    } else {
+                        emitter.onCompleted()
+                    }
+                }
+            }
+            emitter.setCancellation { job.cancel() }
+        },
+        backpressureMode
+    )
+}