@typed/fx 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed/fx",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -22,7 +22,7 @@
     "@fp-ts/core": "~0.0.11",
     "@fp-ts/data": "~0.0.36"
   },
-  "gitHead": "546af41ccf2a2441851d81c74f1f38278a337981",
+  "gitHead": "20d0f2bc1bceba5137c4ba3bab3d1ff3d057fd1b",
   "publishConfig": {
     "access": "public"
   }

package/src/operator/index.ts

@@ -30,6 +30,7 @@ export * from './map.js'
 export * from './mapCause.js'
 export * from './mapError.js'
 export * from './merge.js'
+export * from './mergeRace.js'
 export * from './multicast.js'
 export * from './onDone.js'
 export * from './onDoneCause.js'

package/src/operator/mergeRace.test.ts

@@ -0,0 +1,29 @@
+import { deepStrictEqual } from 'assert'
+
+import * as Effect from '@effect/io/Effect'
+import { millis } from '@fp-ts/data/Duration'
+import { pipe } from '@fp-ts/data/Function'
+import { describe, it } from 'vitest'
+
+import { at } from '../constructor/at.js'
+import { collectAll } from '../run/collectAll.js'
+
+import { mergeRace } from './mergeRace.js'
+
+describe(import.meta.url, () => {
+  describe(mergeRace.name, () => {
+    it('interrupts the second Fx when the first emits', async () => {
+      const test = pipe(at(millis(0), 1), mergeRace(at(millis(200), 2)), collectAll)
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [1])
+    })
+
+    it('emits both streams when second emits first', async () => {
+      const test = pipe(at(millis(200), 1), mergeRace(at(millis(0), 2)), collectAll)
+      const events = await Effect.unsafeRunPromise(test)
+
+      deepStrictEqual(events, [2, 1])
+    })
+  })
+})

package/src/operator/mergeRace.ts

@@ -0,0 +1,30 @@
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+
+import { Fx } from '../Fx.js'
+
+import { tap } from './tap.js'
+
+/**
+ * Merges two streams into one until the first stream emits. This is useful for
+ * creating loading screens which you only want to emit after giving a grace period
+ * to load data before showing the loading screen to avoid flashes of loading.
+ */
+export function mergeRace<R2, E2, B>(raced: Fx<R2, E2, B>) {
+  return <R, E, A>(fx: Fx<R, E, A>): Fx<R | R2, E | E2, A | B> =>
+    Fx((sink) =>
+      Effect.gen(function* ($) {
+        let interrupted = false
+        const racedFiber = yield* $(
+          Effect.forkScoped(raced.run(Fx.Sink(sink.event, sink.error, Effect.unit()))),
+        )
+
+        return yield* $(
+          // eslint-disable-next-line @typescript-eslint/no-unused-vars
+          tap((_: A) =>
+            interrupted ? Effect.unit() : ((interrupted = true), Fiber.interruptFork(racedFiber)),
+          )(fx).run(sink),
+        )
+      }),
+    )
+}

package/src/run/observe.ts

@@ -12,6 +12,15 @@ export function observe<A, R2, E2, B>(
   return flow(observe_(f), Effect.scoped)
 }
 
+export function observeSync<A, B>(
+  f: (a: A) => B,
+): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R, E, void> {
+  return flow(
+    observe_((a) => Effect.sync(() => f(a))),
+    Effect.scoped,
+  )
+}
+
 export function observe_<A, R2, E2, B>(
   f: (a: A) => Effect.Effect<R2, E2, B>,
 ): <R, E>(fx: Fx<R, E, A>) => Effect.Effect<R | R2 | Scope, E | E2, void> {

package/src/run/reduce.ts

@@ -3,7 +3,7 @@ import { pipe } from '@fp-ts/data/Function'
 
 import { Fx } from '../Fx.js'
 
-import { observe } from './observe.js'
+import { observeSync } from './observe.js'
 
 export const reduce: <B, A>(
   seed: B,
@@ -14,7 +14,7 @@ export const reduce: <B, A>(
 
     return pipe(
       fx,
-      observe((a) => Effect.sync(() => (acc = f(acc, a)))),
+      observeSync((a) => (acc = f(acc, a))),
       Effect.map(() => acc),
     )
   })

package/src/run/run.ts

@@ -42,7 +42,7 @@ export function run_<A, R2, E2, E, R3, E3, B, R4, E4>(
 
       const c = yield* $(Deferred.await(deferred))
 
-      yield* $(Fiber.interrupt(fiber))
+      yield* $(Fiber.interruptFork(fiber))
 
       return c
     })

package/src/run/unsafe.ts

@@ -1,14 +1,15 @@
-import {Cancel} from '@effect/io/Runtime'
 import * as Effect from '@effect/io/Effect'
 import * as Exit from '@effect/io/Exit'
 import * as Fiber from '@effect/io/Fiber'
+import { Cancel } from '@effect/io/Runtime'
 import * as Scope from '@effect/io/Scope'
 
 import { Fx } from '../Fx.js'
 
 import { drain } from './drain.js'
 
-export const unsafeRunAsync = <E, A>(fx: Fx<never, E, A>): Cancel<E, void> => Effect.unsafeRun(drain(fx))
+export const unsafeRunAsync = <E, A>(fx: Fx<never, E, A>): Cancel<E, void> =>
+  Effect.unsafeRun(drain(fx))
 
 export const unsafeRunAsyncWith =
   <E>(f: (exit: Exit.Exit<E, void>) => void) =>