jrx 0.3.0-alpha.2 → 0.3.0-alpha.3

package/README.md

@@ -121,30 +121,30 @@ handle[Symbol.dispose]()
 
 ### `makeIntervalAsync(cb, ms)`
 
-Async version of `makeInterval`. Waits for the callback to complete before scheduling the next invocation.
+Async version of `makeInterval`. Waits for the callback to complete before scheduling the next invocation. Returns a `Disposable`.
 
 **Note:** The callback fires **immediately** on first call, then waits `ms` milliseconds **after** the previous async callback completes.
 
 ```typescript
 import {makeIntervalAsync} from 'jrx'
 
-const dispose = makeIntervalAsync(async () => {
+const handle = makeIntervalAsync(async () => {
   // Called immediately, then 5000ms after each completion
   await fetchData()
   processData()
 }, 5000)
 
-dispose()
+handle[Symbol.dispose]()
 ```
 
 ### `makeAnimationFrame(cb)`
 
-Executes a callback on the next animation frame with cleanup.
+Executes a callback on the next animation frame with cleanup. Returns a `Disposable`.
 
 ```typescript
 import {makeAnimationFrame} from 'jrx'
 
-const dispose = makeAnimationFrame((now) => {
+const handle = makeAnimationFrame((now) => {
   updateAnimation(now)
 
   // Optional: return a Disposable for cleanup
@@ -156,17 +156,17 @@ const dispose = makeAnimationFrame((now) => {
 })
 
 // Cancel if needed before the frame fires
-dispose()
+handle[Symbol.dispose]()
 ```
 
 ### `makeAnimationFrameLoop(cb)`
 
-Creates a continuous `requestAnimationFrame` loop with cleanup.
+Creates a continuous `requestAnimationFrame` loop with cleanup. Returns a `Disposable`.
 
 ```typescript
 import {makeAnimationFrameLoop} from 'jrx'
 
-const dispose = makeAnimationFrameLoop((now) => {
+const handle = makeAnimationFrameLoop((now) => {
   updateAnimation(now)
 
   // Optional: return a Disposable for cleanup
@@ -178,22 +178,22 @@ const dispose = makeAnimationFrameLoop((now) => {
 })
 
 // Stop the loop
-dispose()
+handle[Symbol.dispose]()
 ```
 
 ### `makeTimeout(cb, ms)`
 
-Creates a timeout with cleanup.
+Creates a timeout with cleanup. Returns a `Disposable`.
 
 ```typescript
 import {makeTimeout} from 'jrx'
 
-const cancel = makeTimeout(() => {
+const handle = makeTimeout(() => {
   console.log('Timeout fired')
 }, 1000)
 
 // Cancel if needed
-cancel()
+handle[Symbol.dispose]()
 ```
 
 ### `makeTransition(cb, durationMs)`
@@ -289,24 +289,22 @@ const data = await r // undefined
 
 ## Cleanup Pattern
 
-Functions that manage ongoing effects return either a dispose function or a `Disposable` object:
+All effect functions return a `Disposable` object that stops the effect and runs any pending cleanup:
 
 ```typescript
 import {makeInterval, makeTimeout, makeAnimationFrame, makeTransition} from 'jrx'
 
-// Functions returning Disposable objects (use with `using` or call [Symbol.dispose]())
+// Each function returns a Disposable
 const interval = makeInterval(() => console.log('tick'), 1000)
+const timeout = makeTimeout(() => console.log('timeout'), 5000)
+const raf = makeAnimationFrame((now) => render(now))
 const transition = makeTransition((p) => console.log(p), 1000)
 
+// Call [Symbol.dispose]() to stop the effect
 interval[Symbol.dispose]()
+timeout[Symbol.dispose]()
+raf[Symbol.dispose]()
 transition[Symbol.dispose]()
-
-// Functions returning dispose functions (call directly)
-const disposeTimeout = makeTimeout(() => console.log('timeout'), 5000)
-const disposeRaf = makeAnimationFrame((now) => render(now))
-
-disposeTimeout()
-disposeRaf()
 ```
 
 ## TypeScript

package/index.d.ts

@@ -12,10 +12,18 @@ export declare function makeRenderLoop(): {
 export declare function makeInterval(cb: () => undefined | Disposable, ms: number): {
     [Symbol.dispose](): void;
 };
-export declare function makeIntervalAsync(cb: () => void | Disposable | Promise<void>, ms: number): () => void;
-export declare function makeAnimationFrame(cb: (now: DOMHighResTimeStamp) => undefined | Disposable): () => void;
-export declare function makeAnimationFrameLoop(cb: (now: DOMHighResTimeStamp) => undefined | Disposable): () => void;
-export declare function makeTimeout(cb: () => void, ms: number): () => void;
+export declare function makeIntervalAsync(cb: () => void | Disposable | Promise<void>, ms: number): {
+    [Symbol.dispose](): void;
+};
+export declare function makeAnimationFrame(cb: (now: DOMHighResTimeStamp) => undefined | Disposable): {
+    [Symbol.dispose](): void;
+};
+export declare function makeAnimationFrameLoop(cb: (now: DOMHighResTimeStamp) => undefined | Disposable): {
+    [Symbol.dispose](): void;
+};
+export declare function makeTimeout(cb: () => void, ms: number): {
+    [Symbol.dispose](): void;
+};
 export declare function makeTransition(cb: (progress: number) => undefined | Disposable, durationMs: number): {
     [Symbol.dispose](): void;
 };

package/index.js

@@ -52,9 +52,11 @@ export function makeIntervalAsync(cb, ms) {
     const reset = makeReset();
     let timeout;
     void wrapper();
-    return () => {
-        reset();
-        clearTimeout(timeout);
+    return {
+        [Symbol.dispose]() {
+            reset();
+            clearTimeout(timeout);
+        },
     };
     async function wrapper() {
         const stack = reset();
@@ -70,17 +72,21 @@ export function makeAnimationFrame(cb) {
             return;
         stack.use(cb(now));
     });
-    return () => {
-        stack.dispose();
-        cancelAnimationFrame(raf);
+    return {
+        [Symbol.dispose]() {
+            stack.dispose();
+            cancelAnimationFrame(raf);
+        },
     };
 }
 export function makeAnimationFrameLoop(cb) {
     const reset = makeReset();
     let raf = requestAnimationFrame(wrapper);
-    return () => {
-        reset();
-        cancelAnimationFrame(raf);
+    return {
+        [Symbol.dispose]() {
+            reset();
+            cancelAnimationFrame(raf);
+        },
     };
     function wrapper(now) {
         reset().use(cb(now));
@@ -89,7 +95,11 @@ export function makeAnimationFrameLoop(cb) {
 }
 export function makeTimeout(cb, ms) {
     const timeout = setTimeout(cb, ms);
-    return () => clearTimeout(timeout);
+    return {
+        [Symbol.dispose]() {
+            clearTimeout(timeout);
+        },
+    };
 }
 export function makeTransition(cb, durationMs) {
     const reset = makeReset();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "jrx",
-	"version": "0.3.0-alpha.2",
+	"version": "0.3.0-alpha.3",
 	"type": "module",
 	"scripts": {
 		"prepublishOnly": "npx tsc",