Refactoring

2025-07-06 02:20:41 +02:00
parent 2e914fb15b
commit a296d4874c
4 changed files with 20 additions and 20 deletions
@@ -0,0 +1,152 @@
+import { Context, Effect, ExecutionStrategy, Exit, Function, Pipeable, Ref, Runtime, Scope, String, Tracer, type Types, type Utils } from "effect"
+import * as React from "react"
+
+
+export interface Component<E, R, P extends {}> extends Pipeable.Pipeable {
+    (props: P): Effect.Effect<React.ReactNode, E, R>
+    readonly displayName?: string
+    readonly options: Options
+}
+
+export interface Options {
+    readonly finalizerExecutionMode: "sync" | "fork"
+    readonly finalizerExecutionStrategy: ExecutionStrategy.ExecutionStrategy
+}
+
+export type Error<T> = T extends Component<infer E, infer _R, infer _P> ? E : never
+export type Context<T> = T extends Component<infer _E, infer R, infer _P> ? R : never
+export type Props<T> = T extends Component<infer _E, infer _R, infer P> ? P : never
+
+export const nonReactiveTags = [Tracer.ParentSpan] as const
+
+
+export interface MakeOptions {
+    readonly traced?: boolean
+    readonly finalizerExecutionMode?: "sync" | "fork"
+    readonly finalizerExecutionStrategy?: ExecutionStrategy.ExecutionStrategy
+}
+
+export const make = <
+    Eff extends Utils.YieldWrap<Effect.Effect<any, any, any>>,
+    P extends {} = {},
+>(
+    body: (props: P) => Generator<Eff, React.ReactNode, never>,
+    options?: MakeOptions,
+): Component<
+    [Eff] extends [never] ? never : [Eff] extends [Utils.YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E : never,
+    [Eff] extends [never] ? never : [Eff] extends [Utils.YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R : never,
+    P
+> => {
+    const displayName = !String.isEmpty(body.name) ? body.name : undefined
+
+    const f = ((options?.traced ?? true)
+        ? displayName
+            ? Effect.fn(displayName)(body)
+            : Effect.fn(body)
+        : Effect.fnUntraced(body)
+    ) as Component<any, any, any>
+
+    f.pipe = function pipe() { return Pipeable.pipeArguments(this, arguments) };
+    (f as Types.Mutable<typeof f>).displayName = displayName;
+    (f as Types.Mutable<typeof f>).options = {
+        finalizerExecutionMode: options?.finalizerExecutionMode ?? "sync",
+        finalizerExecutionStrategy: options?.finalizerExecutionStrategy ?? ExecutionStrategy.sequential,
+    }
+
+    return f
+}
+
+
+export const useFC: {
+    <E, R, P extends {}>(
+        self: Component<E, R, P>
+    ): Effect.Effect<React.FC<P>, never, Exclude<R, Scope.Scope>>
+} = Effect.fn("useFC")(function* <E, R, P extends {}>(
+    self: Component<E, R, P>
+) {
+    const runtimeRef = React.useRef<Runtime.Runtime<Exclude<R, Scope.Scope>>>(null!)
+    runtimeRef.current = yield* Effect.runtime<Exclude<R, Scope.Scope>>()
+
+    return React.useMemo(() => function ScopeProvider(props: P) {
+        const scope = useScope(runtimeRef.current, self.options)
+
+        const FC = React.useMemo(() => {
+            const f = (props: P) => Runtime.runSync(runtimeRef.current)(
+                Effect.provideService(self(props), Scope.Scope, scope)
+            )
+            f.displayName = self.displayName ?? "Anonymous"
+            return f
+        }, [scope])
+
+        return React.createElement(FC, props)
+    }, Array.from(
+        Context.omit(...nonReactiveTags)(runtimeRef.current.context).unsafeMap.values()
+    ))
+})
+
+const useScope = (
+    runtime: Runtime.Runtime<never>,
+    options: Options,
+) => {
+    const [isInitialRun, initialScope] = React.useMemo(() => Runtime.runSync(runtime)(
+        Effect.all([Ref.make(true), Scope.make(options.finalizerExecutionStrategy)])
+    ), [])
+    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: () => Scope.make(options.finalizerExecutionStrategy).pipe(
+                Effect.tap(scope => Effect.sync(() => setScope(scope))),
+                Effect.map(scope => () => closeScope(scope, runtime, options)),
+            ),
+        })
+    ), [])
+
+    return scope
+}
+
+const closeScope = (
+    scope: Scope.CloseableScope,
+    runtime: Runtime.Runtime<never>,
+    options: Options,
+) => {
+    switch (options.finalizerExecutionMode) {
+        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: Component<E, R, P>,
+        fn: (Component: React.FC<P>) => React.ReactNode,
+    ): Effect.Effect<React.ReactNode, never, Exclude<R, Scope.Scope>>
+} = Effect.fn("use")(function*(self, fn) {
+    return fn(yield* useFC(self))
+})
+
+export const withRuntime: {
+    <E, R, P extends {}>(
+        context: React.Context<Runtime.Runtime<R>>,
+    ): (self: Component<E, R | Scope.Scope, P>) => React.FC<P>
+    <E, R, P extends {}>(
+        self: Component<E, R | Scope.Scope, P>,
+        context: React.Context<Runtime.Runtime<R>>,
+    ): React.FC<P>
+} = Function.dual(2, <E, R, P extends {}>(
+    self: Component<E, R | Scope.Scope, P>,
+    context: React.Context<Runtime.Runtime<R>>,
+): React.FC<P> => function WithRuntime(props) {
+    const runtime = React.useContext(context)
+    return React.createElement(Runtime.runSync(runtime)(useFC(self)), props)
+})