ReffuseReactContext provider split

packages/reffuse/src/Reffuse.ts

@@ -17,8 +17,9 @@ export class Reffuse<
         runtime: Runtime.Runtime<RuntimeR>,
         parent?: Reffuse<RuntimeR, ParentContextR, unknown, unknown>,
     ) {
-        // TODO: split into makeProvider and makeScopedProvider
-        this.Provider = ReffuseReactContext.makeProvider(runtime, this.Context, parent)
+        this.Provider = parent
+            ? ReffuseReactContext.makeNestedProvider(runtime, this.Context, parent)
+            : ReffuseReactContext.makeRootProvider<RuntimeR, OwnContextR>(runtime, this.Context)
     }
 
 

packages/reffuse/src/ReffuseReactContext.tsx

@@ -24,7 +24,29 @@ export interface ProviderProps<
     readonly children?: React.ReactNode
 }
 
-export function makeProvider<
+export function makeRootProvider<RuntimeR, ContextR>(
+    runtime: Runtime.Runtime<RuntimeR>,
+    ReactContext: React.Context<Value<RuntimeR, ContextR>>,
+): Provider<RuntimeR, ContextR, never> {
+    return function ReffuseRootReactContextProvider(props) {
+        const value = React.useMemo(() => ({
+            runtime,
+            context: Effect.context<ContextR>().pipe(
+                Effect.provide(props.layer),
+                Runtime.runSync(runtime),
+            ),
+        }), [props.layer])
+
+        return (
+            <ReactContext
+                {...props}
+                value={value}
+            />
+        )
+    }
+}
+
+export function makeNestedProvider<
     RuntimeR,
     ContextR extends ParentContextR | OwnContextR,
     OwnContextR,
@@ -32,43 +54,25 @@ export function makeProvider<
 >(
     runtime: Runtime.Runtime<RuntimeR>,
     ReactContext: React.Context<Value<RuntimeR, ContextR>>,
-    parent?: Reffuse.Reffuse<RuntimeR, ParentContextR, unknown, unknown>,
+    parent: Reffuse.Reffuse<RuntimeR, ParentContextR, unknown, unknown>,
 ): Provider<RuntimeR, OwnContextR, ParentContextR> {
-    return parent
-        ? function ReffuseReactContextProvider(props) {
-            const parentContext = parent.useContext()
+    return function ReffuseNestedReactContextProvider(props) {
+        const parentContext = parent.useContext()
 
-            const value = React.useMemo(() => ({
-                runtime,
-                context: Effect.context<ContextR>().pipe(
-                    Effect.provide(props.layer),
-                    Effect.provide(parentContext),
-                    Runtime.runSync(runtime),
-                ),
-            }), [props.layer, parentContext])
+        const value = React.useMemo(() => ({
+            runtime,
+            context: Effect.context<ContextR>().pipe(
+                Effect.provide(props.layer),
+                Effect.provide(parentContext),
+                Runtime.runSync(runtime),
+            ),
+        }), [props.layer, parentContext])
 
-            return (
-                <ReactContext
-                    {...props}
-                    value={value}
-                />
-            )
-        }
-        : function ReffuseReactContextProvider(props) {
-            const value = React.useMemo(() => ({
-                runtime,
-                context: Effect.context<ContextR>().pipe(
-                    Effect.provide(props.layer),
-                    Effect.provide(Context.empty() as Context.Context<ParentContextR>), // Required for type safety
-                    Runtime.runSync(runtime),
-                ),
-            }), [props.layer])
-
-            return (
-                <ReactContext
-                    {...props}
-                    value={value}
-                />
-            )
-        }
+        return (
+            <ReactContext
+                {...props}
+                value={value}
+            />
+        )
+    }
 }