packages/reffuse/src/ReffuseExtension.ts

@@ -39,13 +39,15 @@ export const withContexts = <R2 extends Array<unknown>>(
         {
             new(): Merge<
                 InstanceType<BaseClass>,
-                ReffuseHelpers.ReffuseHelpers<R1 | R2[number]>
+                ReffuseHelpers.ReffuseHelpers<R1 | R2[number]> & {
+                    prototype: ReffuseHelpers.ReffuseHelpers<R1 | R2[number]>
+                }
             >
         } &
         StaticType<BaseClass>
     ) => new self().pipe(
         instance => class extends self {
-            readonly contexts = [...instance.contexts, ...contexts] as const
+            readonly contexts = [...instance.contexts, ...contexts] as any
         } as any
     )
 

packages/reffuse/src/ReffuseHelpers.ts

@@ -5,58 +5,13 @@ import * as ReffuseRuntime from "./ReffuseRuntime.js"
 import * as SetStateAction from "./SetStateAction.js"
 
 
-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 class ReffuseHelpers<R> {
 
-    readonly contexts: readonly ReffuseContext.ReffuseContext<R>[] = []
+    declare ["constructor"]: ReffuseHelpersClass<R>
 
 
     useContext(): Context.Context<R> {
-        return ReffuseContext.useMergeAll(...this.contexts)
+        return ReffuseContext.useMergeAll(...this.constructor.contexts)
     }
 
 
@@ -416,6 +371,13 @@ ReffuseHelpers.prototype.pipe = function pipe() {
 }
 
 
+export interface ReffuseHelpersClass<R> extends Pipeable.Pipeable {
+    new(): ReffuseHelpers<R>
+    prototype: ReffuseHelpers<R>
+    readonly contexts: readonly ReffuseContext.ReffuseContext<R>[]
+}
+
+
 export interface RenderOptions {
     /** Prevents re-executing the effect when the Effect runtime or context changes. Defaults to `false`. */
     readonly doNotReExecuteOnRuntimeOrContextChange?: boolean