packages/example/src/reffuse.ts

@@ -10,4 +10,8 @@ export const GlobalContext = ReffuseContext.make<
     | HttpClient.HttpClient
 >()
 
-export const R = Reffuse.make(GlobalContext)
+export class GlobalReffuse extends Reffuse.Reffuse.pipe(
+    Reffuse.withContexts(GlobalContext)
+) {}
+
+export const R = new GlobalReffuse()

packages/example/src/todos/reffuse.ts

@@ -1,7 +1,10 @@
-import { GlobalContext } from "@/reffuse"
+import { GlobalReffuse } from "@/reffuse"
 import { Reffuse, ReffuseContext } from "reffuse"
 import { TodosState } from "./services"
 
 
 export const TodosContext = ReffuseContext.make<TodosState.TodosState>()
-export const R = Reffuse.make(GlobalContext, TodosContext)
+
+export const R = new class TodosReffuse extends GlobalReffuse.pipe(
+    Reffuse.withContexts(TodosContext)
+) {}

packages/reffuse/src/ReffuseExtension.ts

@@ -1,18 +1,8 @@
-import { Effect } from "effect"
-import * as Reffuse from "./Reffuse.js"
-import * as ReffuseContext from "./ReffuseContext.js"
 import * as ReffuseHelpers from "./ReffuseHelpers.js"
 import type { Merge, StaticType } from "./types.js"
 
 
-class MyService extends Effect.Service<MyService>()("MyService", {
+export const make = <Ext extends object>(extension: Ext) =>
-    succeed: {}
-}) {}
-
-const MyContext = ReffuseContext.make<MyService>()
-
-
-const make = <Ext extends object>(extension: Ext) =>
     <
         BaseClass extends ReffuseHelpers.ReffuseHelpersClass<R>,
         R
@@ -26,20 +16,3 @@ const make = <Ext extends object>(extension: Ext) =>
         class_.prototype = { ...class_.prototype, ...extension } as any
         return class_ as any
     }
-
-
-const withMyContext = Reffuse.withContexts(MyContext)
-const clsWithMyContext = withMyContext(Reffuse.Reffuse)
-class ReffuseWithMyContext extends clsWithMyContext {}
-
-
-const withProut = make({
-    prout<R>(this: ReffuseHelpers.ReffuseHelpers<R>) {}
-})
-
-class MyReffuse extends Reffuse.Reffuse.pipe(
-    withProut,
-    Reffuse.withContexts(MyContext),
-) {}
-
-new MyReffuse().useFork()

packages/reffuse/src/ReffuseHelper.ts

@@ -1,57 +0,0 @@
-import type { Context, Effect, ExecutionStrategy, Fiber, Pipeable, Runtime, Scope, SubscriptionRef } from "effect"
-import type * as React from "react"
-
-
-export interface ReffuseHelper<R> extends Pipeable.Pipeable {
-    useContext(): Context.Context<R>
-
-    useRunSync(): <A, E>(effect: Effect.Effect<A, E, R>) => A
-    useRunPromise(): <A, E>(effect: Effect.Effect<A, E, R>, options?: {
-        readonly signal?: AbortSignal
-    }) => Promise<A>
-    useRunFork(): <A, E>(effect: Effect.Effect<A, E, R>, options?: Runtime.RunForkOptions) => Fiber.RuntimeFiber<A, E>
-    useRunCallback(): <A, E>(effect: Effect.Effect<A, E, R>, options?: Runtime.RunCallbackOptions<A, E>) => Runtime.Cancel<A, E>
-
-    useMemo<A, E>(
-        effect: Effect.Effect<A, E, R>,
-        deps?: React.DependencyList,
-        options?: RenderOptions,
-    ): A
-
-    useMemoScoped<A, E>(
-        effect: Effect.Effect<A, E, R | Scope.Scope>,
-        deps?: React.DependencyList,
-        options?: RenderOptions & ScopeOptions,
-    ): A
-
-    useLayoutEffect<A, E>(
-        effect: Effect.Effect<A, E, R | Scope.Scope>,
-        deps?: React.DependencyList,
-        options?: RenderOptions & ScopeOptions,
-    ): void
-
-    useFork<A, E>(
-        effect: Effect.Effect<A, E, R | Scope.Scope>,
-        deps?: React.DependencyList,
-        options?: Runtime.RunForkOptions & RenderOptions & ScopeOptions,
-    ): void
-
-    usePromise<A, E>(
-        effect: Effect.Effect<A, E, R | Scope.Scope>,
-        deps?: React.DependencyList,
-        options?: { readonly signal?: AbortSignal } & Runtime.RunForkOptions & RenderOptions & ScopeOptions,
-    ): Promise<A>
-
-    useRef<A>(value: A): SubscriptionRef.SubscriptionRef<A>
-    useRefState<A>(ref: SubscriptionRef.SubscriptionRef<A>): readonly [A, React.Dispatch<React.SetStateAction<A>>]
-}
-
-
-export interface RenderOptions {
-    /** Prevents re-executing the effect when the Effect runtime or context changes. Defaults to `false`. */
-    readonly doNotReExecuteOnRuntimeOrContextChange?: boolean
-}
-
-export interface ScopeOptions {
-    readonly finalizerExecutionStrategy?: ExecutionStrategy.ExecutionStrategy
-}

packages/reffuse/src/index.ts

@@ -1,4 +1,6 @@
 export * as Reffuse from "./Reffuse.js"
 export * as ReffuseContext from "./ReffuseContext.js"
+export * as ReffuseExtension from "./ReffuseExtension.js"
+export * as ReffuseHelpers from "./ReffuseHelpers.js"
 export * as ReffuseRuntime from "./ReffuseRuntime.js"
 export * as SetStateAction from "./SetStateAction.js"