@typed/fx 1.17.2 → 1.17.3

package/src/RefRemoteData.test.ts

@@ -0,0 +1,100 @@
+import { deepEqual, deepStrictEqual, ok } from 'assert'
+
+import { equals } from '@effect/data/Equal'
+import * as Option from '@effect/data/Option'
+import * as Effect from '@effect/io/Effect'
+import * as Fiber from '@effect/io/Fiber'
+import * as RemoteData from '@typed/remote-data'
+import { describe, it } from 'vitest'
+
+import { makeRefRemoteData } from './RefRemoteData.js'
+
+describe('RefRemoteData', () => {
+  const makeRef = makeRefRemoteData<Error, string>()
+  // const error = new Error('test')
+
+  it('initializes with no data', async () => {
+    const test = Effect.gen(function* ($) {
+      const ref = yield* $(makeRef)
+      const current = yield* $(ref.get)
+
+      deepStrictEqual(current, RemoteData.noData)
+    }).pipe(Effect.scoped)
+
+    await Effect.runPromise(test)
+  })
+
+  it('running an Effect updates the state to loading', async () => {
+    const test = Effect.gen(function* ($) {
+      const ref = yield* $(makeRef)
+
+      const fiber = yield* $(Effect.fork(ref.runEffect(Effect.delay(100)(Effect.succeed('test')))))
+
+      // Let fiber start executing
+      yield* $(Effect.sleep(1))
+
+      const current = yield* $(ref.get)
+
+      deepEqual(current, RemoteData.loading)
+
+      yield* $(Fiber.join(fiber))
+
+      const updated = yield* $(ref.get)
+
+      ok(equals(updated, RemoteData.success('test')))
+    }).pipe(Effect.scoped)
+
+    await Effect.runPromise(test)
+  })
+
+  it('stops loading when Effect is interrupted', async () => {
+    const test = Effect.gen(function* ($) {
+      const ref = yield* $(makeRef)
+
+      const fiber = yield* $(Effect.fork(ref.runEffect(Effect.delay(1000)(Effect.succeed('test')))))
+
+      // Let fiber start executing
+      yield* $(Effect.sleep(1))
+
+      const current = yield* $(ref.get)
+
+      deepEqual(current, RemoteData.loading)
+
+      yield* $(Fiber.interrupt(fiber))
+
+      const updated = yield* $(ref.get)
+
+      ok(equals(updated, RemoteData.noData))
+    }).pipe(Effect.scoped)
+
+    await Effect.runPromise(test)
+  })
+
+  it('allows matching over RemoteData with Effects', async () => {
+    const test = Effect.gen(function* ($) {
+      const ref = yield* $(makeRef)
+      const matched = ref.matchEffect({
+        onNoData: () => Effect.succeedNone,
+        onLoading: () => Effect.succeedNone,
+        onFailure: () => Effect.succeedNone,
+        onSuccess: Effect.succeedSome,
+      })
+
+      deepStrictEqual(yield* $(matched), Option.none())
+
+      yield* $(ref.set(RemoteData.loading))
+
+      deepStrictEqual(yield* $(matched), Option.none())
+
+      yield* $(ref.set(RemoteData.fail(new Error('test'))))
+
+      deepStrictEqual(yield* $(matched), Option.none())
+
+      yield* $(ref.set(RemoteData.success('test')))
+
+      deepStrictEqual(yield* $(matched), Option.some('test'))
+    }).pipe(Effect.scoped)
+
+    await Effect.runPromise(test)
+  })
+})

package/src/RefRemoteData.ts

@@ -4,8 +4,6 @@ import * as Option from '@effect/data/Option'
 import * as Cause from '@effect/io/Cause'
 import * as Effect from '@effect/io/Effect'
 import * as Exit from '@effect/io/Exit'
-import * as Fiber from '@effect/io/Fiber'
-import * as SynchronizedRef from '@effect/io/Ref/Synchronized'
 import * as Scope from '@effect/io/Scope'
 import * as RemoteData from '@typed/remote-data'
 import fastDeepEqual from 'fast-deep-equal'
@@ -105,30 +103,22 @@ export function makeRefRemoteData<E, A>(
     const isRefreshing = ref.map(RemoteData.isRefreshing)
     const isLoadingOrRefreshing = ref.map(RemoteData.isLoadingOrRefreshing)
 
-    // Ensure there can only ever be one loading fiber
-    const currentFiber = yield* $(
-      SynchronizedRef.make<Fiber.Fiber<never, boolean>>(Fiber.succeed(false)),
-    )
-
     const runEffect = <R>(effect: Effect.Effect<R, E, A>) =>
-      SynchronizedRef.updateAndGetEffect(currentFiber, (fiber) =>
-        Fiber.interrupt(fiber).pipe(
-          Effect.flatMap(() =>
-            ref.multiUpdate((current, set) =>
-              Effect.if(RemoteData.isLoadingOrRefreshing(current), {
-                onFalse: set(RemoteData.toLoading(current)).pipe(
-                  Effect.zipRight(effect),
-                  Effect.exit,
-                  Effect.flatMap((exit) => set(RemoteData.fromExit(exit))),
-                  Effect.as(true),
-                ),
-                onTrue: Effect.as(stopLoading, false),
-              }).pipe(Effect.onInterrupt(() => stopLoading)),
-            ),
-          ),
-          Effect.forkScoped,
-        ),
-      ).pipe(Effect.flatMap(Fiber.join))
+      Effect.gen(function* ($) {
+        const current = yield* $(ref.get)
+
+        if (RemoteData.isLoadingOrRefreshing(current)) {
+          return false
+        }
+
+        yield* $(toLoading)
+
+        const exit = yield* $(Effect.exit(effect))
+
+        yield* $(ref.set(RemoteData.fromExit(exit)))
+
+        return true
+      }).pipe(Effect.onInterrupt(() => stopLoading))
 
     const matchFx = <R2, E2, B, R3, E3, C, R4, E4, D, R5, E5, F>(options: {
       onNoData: () => Fx<R2, E2, B>