Refactoring

packages/effect-fc/src/ReactComponent.ts

@@ -1,7 +1,7 @@
-import { Context, Effect, Function, Runtime, Scope, Tracer } from "effect"
+import { Context, Effect, ExecutionStrategy, Exit, Function, Ref, Runtime, Scope, Tracer } from "effect"
 import type { Mutable } from "effect/Types"
 import * as React from "react"
-import * as ReactHook from "./ReactHook.js"
+import type * as ReactHook from "./ReactHook.js"
 
 
 export interface ReactComponent<E, R, P> {
@@ -11,6 +11,7 @@ export interface ReactComponent<E, R, P> {
 
 export const nonReactiveTags = [Tracer.ParentSpan] as const
 
+
 export const withDisplayName: {
     <C extends ReactComponent<any, any, any>>(displayName: string): (self: C) => C
     <C extends ReactComponent<any, any, any>>(self: C, displayName: string): C
@@ -22,6 +23,7 @@ export const withDisplayName: {
     return self
 })
 
+
 export const useFC: {
     <E, R, P extends {} = {}>(
         self: ReactComponent<E, R, P>,
@@ -35,7 +37,7 @@ export const useFC: {
     runtimeRef.current = yield* Effect.runtime<Exclude<R, Scope.Scope>>()
 
     return React.useMemo(() => function ScopeProvider(props: P) {
-        const scope = Runtime.runSync(runtimeRef.current)(ReactHook.useScope(options))
+        const scope = useScope(runtimeRef.current, options)
 
         const FC = React.useMemo(() => {
             const f = (props: P) => Runtime.runSync(runtimeRef.current)(
@@ -51,6 +53,49 @@ export const useFC: {
     ))
 })
 
+const useScope = (
+    runtime: Runtime.Runtime<never>,
+    options?: ReactHook.ScopeOptions,
+) => {
+    const [isInitialRun, initialScope] = React.useMemo(() => Runtime.runSync(runtime)(
+        Effect.all([Ref.make(true), makeScope(options)])
+    ), [])
+    const [scope, setScope] = React.useState(initialScope)
+
+    React.useEffect(() => Runtime.runSync(runtime)(
+        Effect.if(isInitialRun, {
+            onTrue: () => Effect.as(
+                Ref.set(isInitialRun, false),
+                () => closeScope(scope, runtime, options),
+            ),
+
+            onFalse: () => makeScope(options).pipe(
+                Effect.tap(scope => Effect.sync(() => setScope(scope))),
+                Effect.map(scope => () => closeScope(scope, runtime, options)),
+            ),
+        })
+    ), [])
+
+    return scope
+}
+
+const makeScope = (options?: ReactHook.ScopeOptions) => Scope.make(options?.finalizerExecutionStrategy ?? ExecutionStrategy.sequential)
+const closeScope = (
+    scope: Scope.CloseableScope,
+    runtime: Runtime.Runtime<never>,
+    options?: ReactHook.ScopeOptions,
+) => {
+    switch (options?.finalizerExecutionMode ?? "sync") {
+        case "sync":
+            Runtime.runSync(runtime)(Scope.close(scope, Exit.void))
+            break
+        case "fork":
+            Runtime.runFork(runtime)(Scope.close(scope, Exit.void))
+            break
+    }
+}
+
+
 export const use: {
     <E, R, P extends {} = {}>(
         self: ReactComponent<E, R, P>,

packages/effect-fc/src/ReactHook.ts

@@ -9,50 +9,6 @@ export interface ScopeOptions {
 }
 
 
-export const useScope: {
-    (options?: ScopeOptions): Effect.Effect<Scope.Scope>
-} = Effect.fnUntraced(function* (options?: ScopeOptions) {
-    const runtime = yield* Effect.runtime()
-
-    const [isInitialRun, initialScope] = React.useMemo(() => Runtime.runSync(runtime)(
-        Effect.all([Ref.make(true), makeScope(options)])
-    ), [])
-    const [scope, setScope] = React.useState(initialScope)
-
-    React.useEffect(() => Runtime.runSync(runtime)(
-        Effect.if(isInitialRun, {
-            onTrue: () => Effect.as(
-                Ref.set(isInitialRun, false),
-                () => closeScope(scope, runtime, options),
-            ),
-
-            onFalse: () => makeScope(options).pipe(
-                Effect.tap(scope => Effect.sync(() => setScope(scope))),
-                Effect.map(scope => () => closeScope(scope, runtime, options)),
-            ),
-        })
-    ), [])
-
-    return scope
-})
-
-const makeScope = (options?: ScopeOptions) => Scope.make(options?.finalizerExecutionStrategy ?? ExecutionStrategy.sequential)
-const closeScope = (
-    scope: Scope.CloseableScope,
-    runtime: Runtime.Runtime<never>,
-    options?: ScopeOptions,
-) => {
-    switch (options?.finalizerExecutionMode ?? "sync") {
-        case "sync":
-            Runtime.runSync(runtime)(Scope.close(scope, Exit.void))
-            break
-        case "fork":
-            Runtime.runFork(runtime)(Scope.close(scope, Exit.void))
-            break
-    }
-}
-
-
 export const useMemo: {
     <A, E, R>(
         factory: () => Effect.Effect<A, E, R>,