packages/reffuse/src/ReffuseExtension.ts

@@ -4,7 +4,7 @@ import * as ReffuseHelpers from "./ReffuseHelpers.js"
 import type { Merge, StaticType } from "./types.js"
 
 
-class Reffuse extends ReffuseHelpers.ReffuseHelpers<never> {}
+class Reffuse extends ReffuseHelpers.make([]) {}
 
 class MyService extends Effect.Service<MyService>()("MyService", {
     succeed: {}
@@ -15,15 +15,15 @@ const MyContext = ReffuseContext.make<MyService>()
 
 const make = <Ext extends object>(extension: Ext) =>
     <
-        BaseClass extends typeof Reffuse,
+        BaseClass extends ReffuseHelpers.ReffuseHelpersClass<R>,
-        R,
+        R
     >(
-        base: BaseClass & typeof Reffuse
+        self: BaseClass & ReffuseHelpers.ReffuseHelpersClass<R>
     ): (
         { new(): Merge<InstanceType<BaseClass>, Ext> } &
         StaticType<BaseClass>
     ) => {
-        const class_ = class extends base {}
+        const class_ = class extends self {}
         return class_
     }
 
@@ -31,10 +31,10 @@ export const withContexts = <R2 extends Array<unknown>>(
     ...contexts: [...{ [K in keyof R2]: ReffuseContext.ReffuseContext<R2[K]> }]
 ) =>
     <
-        BaseClass extends typeof ReffuseHelpers.ReffuseHelpers<R1>,
+        BaseClass extends ReffuseHelpers.ReffuseHelpersClass<R1>,
         R1
     >(
-        self: BaseClass & { new(): ReffuseHelpers.ReffuseHelpers<R1> }
+        self: BaseClass & ReffuseHelpers.ReffuseHelpersClass<R1>
     ): (
         {
             new(): Merge<
@@ -42,12 +42,13 @@ export const withContexts = <R2 extends Array<unknown>>(
                 ReffuseHelpers.ReffuseHelpers<R1 | R2[number]>
             >
         } &
-        StaticType<BaseClass>
+        Merge<
-    ) => new self().pipe(
+            StaticType<BaseClass>,
-        instance => class extends self {
+            StaticType<ReffuseHelpers.ReffuseHelpersClass<R1 | R2[number]>>
-            readonly contexts = [...instance.contexts, ...contexts] as any
+        >
-        } as any
+    ) => class extends self {
-    )
+        readonly contexts = [...self.contexts, ...contexts]
+    } as any
 
 
 const withMyContext = withContexts(MyContext)
@@ -56,13 +57,8 @@ class ReffuseWithMyContext extends clsWithMyContext {}
 
 const t = new ReffuseWithMyContext()
 
-
 const cls1 = make({
     prout<R>(this: ReffuseHelpers.ReffuseHelpers<R>) {}
 })(Reffuse)
 
 class Cls1 extends cls1 {}
-
-const cls2 = make({
-    aya() {}
-})(cls)

packages/reffuse/src/ReffuseHelpers.ts

@@ -5,7 +5,17 @@ import * as ReffuseRuntime from "./ReffuseRuntime.js"
 import * as SetStateAction from "./SetStateAction.js"
 
 
-export class ReffuseHelpers<R> {
+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
+}
+
+
+export abstract class ReffuseHelpers<R> {
 
     declare ["constructor"]: ReffuseHelpersClass<R>
 
@@ -373,16 +383,15 @@ ReffuseHelpers.prototype.pipe = function pipe() {
 
 export interface ReffuseHelpersClass<R> extends Pipeable.Pipeable {
     new(): ReffuseHelpers<R>
-    prototype: ReffuseHelpers<R>
     readonly contexts: readonly ReffuseContext.ReffuseContext<R>[]
 }
 
-
+(ReffuseHelpers as ReffuseHelpersClass<any>).pipe = function pipe() {
-export interface RenderOptions {
+    return Pipeable.pipeArguments(this, arguments)
-    /** 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
+export const make = <R = never>(contexts: readonly ReffuseContext.ReffuseContext<R>[]): ReffuseHelpersClass<R> =>
-}
+    class extends (ReffuseHelpers<R> as ReffuseHelpersClass<R>) {
+        static readonly contexts = contexts
+    }