0.2.1 (#26)

Co-authored-by: Julien Valverdé <julien.valverde@mailo.com>
Co-authored-by: Renovate Bot <renovate-bot@valverde.cloud>
Reviewed-on: Thilawyn/effect-fc#26

packages/effect-fc/src/SubscriptionRef.ts

@@ -1,41 +1,54 @@
-import { Effect, Equivalence, Ref, type Scope, Stream, SubscriptionRef } from "effect"
+import { Effect, Equivalence, Ref, Stream, SubscriptionRef } from "effect"
 import * as React from "react"
 import * as Component from "./Component.js"
 import * as SetStateAction from "./SetStateAction.js"
 
 
-export const useSubscriptionRefState: {
-    <A>(
-        ref: SubscriptionRef.SubscriptionRef<A>
-    ): Effect.Effect<readonly [A, React.Dispatch<React.SetStateAction<A>>], never, Scope.Scope>
-} = Effect.fnUntraced(function* <A>(ref: SubscriptionRef.SubscriptionRef<A>) {
+export declare namespace useSubscriptionRefState {
+    export interface Options<A> {
+        readonly equivalence?: Equivalence.Equivalence<A>
+    }
+}
+
+export const useSubscriptionRefState = Effect.fnUntraced(function* <A>(
+    ref: SubscriptionRef.SubscriptionRef<A>,
+    options?: useSubscriptionRefState.Options<NoInfer<A>>,
+): Effect.fn.Return<readonly [A, React.Dispatch<React.SetStateAction<A>>]> {
     const [reactStateValue, setReactStateValue] = React.useState(yield* Component.useOnMount(() => ref))
 
     yield* Component.useReactEffect(() => Effect.forkScoped(
         Stream.runForEach(
-            Stream.changesWith(ref.changes, Equivalence.strict()),
+            Stream.changesWith(ref.changes, options?.equivalence ?? Equivalence.strict()),
             v => Effect.sync(() => setReactStateValue(v)),
         )
     ), [ref])
 
-    const setValue = yield* Component.useCallbackSync((setStateAction: React.SetStateAction<A>) =>
-        Effect.andThen(
+    const setValue = yield* Component.useCallbackSync(
+        (setStateAction: React.SetStateAction<A>) => Effect.andThen(
             Ref.updateAndGet(ref, prevState => SetStateAction.value(setStateAction, prevState)),
             v => setReactStateValue(v),
         ),
-    [ref])
+        [ref],
+    )
 
     return [reactStateValue, setValue]
 })
 
-export const useSubscriptionRefFromState: {
-    <A>(state: readonly [A, React.Dispatch<React.SetStateAction<A>>]): Effect.Effect<SubscriptionRef.SubscriptionRef<A>, never, Scope.Scope>
-} = Effect.fnUntraced(function*([value, setValue]) {
+export declare namespace useSubscriptionRefFromState {
+    export interface Options<A> {
+        readonly equivalence?: Equivalence.Equivalence<A>
+    }
+}
+
+export const useSubscriptionRefFromState = Effect.fnUntraced(function* <A>(
+    [value, setValue]: readonly [A, React.Dispatch<React.SetStateAction<A>>],
+    options?: useSubscriptionRefFromState.Options<NoInfer<A>>,
+): Effect.fn.Return<SubscriptionRef.SubscriptionRef<A>> {
     const ref = yield* Component.useOnChange(() => Effect.tap(
         SubscriptionRef.make(value),
         ref => Effect.forkScoped(
             Stream.runForEach(
-                Stream.changesWith(ref.changes, Equivalence.strict()),
+                Stream.changesWith(ref.changes, options?.equivalence ?? Equivalence.strict()),
                 v => Effect.sync(() => setValue(v)),
             )
         ),