jrx 0.3.0-alpha.7 → 0.3.0-alpha.9

package/README.md

@@ -18,7 +18,6 @@ npm i jrx
 
 - Automatic cleanup for all effects and subscriptions
 - Built on the native `DisposableStack` / `AsyncDisposableStack` API
-- Retry logic with exponential backoff and cancellation
 - Zero dependencies
 - Composable reactive utilities
 - Browser and Node.js compatible
@@ -34,8 +33,6 @@ npm i jrx
 - [`createAnimationFrameLoop(cb)`](#createAnimationFrameloopcb) - Animation frame loops
 - [`createTimeout(cb, ms)`](#createTimeoutcb-ms) - Timeouts with cleanup
 - [`createTransition(cb, durationMs)`](#createTransitioncb-durationms) - Progress-based animations
-- [`computed(fn, getDeps?)`](#computedfn-getdeps) - Memoized computed values
-- [`retry(cb, backoffSec?)`](#retrycb-backoffsec) - Retry with exponential backoff
 - [`assignDispose(value, disposable)`](#assigndisposevalue-disposable) - Attach a `Symbol.dispose` to any value
 
 ## Naming convention
@@ -236,76 +233,6 @@ const handle = createTransition((progress) => {
 handle[Symbol.dispose]()
 ```
 
-### `computed(fn, getDeps?)`
-
-Creates a memoized computed value with optional dependency tracking.
-
-```typescript
-import {computed} from 'jrx'
-
-// Without dependencies - always recomputes
-const value1 = computed(() => expensiveCalculation())
-console.log(value1.value) // Computed
-console.log(value1.value) // Computed again
-
-// With dependencies - memoizes when deps unchanged
-let a = 1, b = 2
-const value2 = computed(
-  () => a + b,
-  () => [a, b] // Dependencies
-)
-
-console.log(value2.value) // Computed: 3
-console.log(value2.value) // Cached: 3
-
-a = 10
-console.log(value2.value) // Recomputed: 12
-```
-
-### `retry(cb, backoffSec?)`
-
-Retries an operation with exponential backoff on failure. Returns `Disposable & Promise<T>`.
-
-**Default backoff:** `[5, 5, 10, 10, 20, 20, 40, 40, 60, -1]` seconds (where `-1` means retry forever with 60s delay)
-
-```typescript
-import {retry} from 'jrx'
-
-// Basic usage - retries with default backoff
-const result = await retry(({resetBackoff}) => {
-  const promise = fetch('/api/data').then((r) => r.json())
-  return Object.assign(promise, {[Symbol.dispose]() {}})
-})
-
-// Custom backoff schedule (in seconds)
-await retry(
-  () => {
-    const promise = fetchData()
-    return Object.assign(promise, {[Symbol.dispose]() {}})
-  },
-  [1, 2, 5, 10, -1], // -1 means retry forever with last delay
-)
-
-// Cancellation via Disposable
-const r = retry(
-  ({resetBackoff}) => {
-    const promise = fetchData()
-    return Object.assign(promise, {[Symbol.dispose]() { /* cancel */ }})
-  },
-  [5, 10, 20, 40, -1],
-)
-
-// Cancel the retry loop
-r[Symbol.dispose]()
-
-// Returns undefined when disposed
-const data = await r // undefined
-```
-
-**Parameters:**
-- `cb`: Callback that returns `Disposable & (T | Promise<T>)`. Receives `{ resetBackoff() }` to reset the backoff counter.
-- `backoffSec`: Array of retry delays in seconds. Use `-1` for infinite retries with the last delay. Default: `[5, 5, 10, 10, 20, 20, 40, 40, 60, -1]`
-
 ### `assignDispose(value, disposable)`
 
 Attaches a `Symbol.dispose` to an existing value (object, function, array, promise, etc.) that delegates to a given `Disposable`. Returns the same value, now also typed as `Disposable`.
@@ -341,6 +268,8 @@ function loadThing() {
 }
 ```
 
+If `value` is itself a `Disposable`, disposing the returned value disposes `value` first, then `disposable`.
+
 ## Cleanup Pattern
 
 All effect functions return a `Disposable` object that stops the effect and runs any pending cleanup:

package/index.d.ts

@@ -1,6 +1,3 @@
-import retry from './retry.js';
-import computed from './computed.js';
-export { retry, computed };
 export declare function makeReset(): () => DisposableStack;
 export declare function makeAsyncReset(): () => Promise<AsyncDisposableStack>;
 export declare function makeRenderLoop(): {
@@ -28,5 +25,5 @@ export declare function createTransition(cb: (progress: number) => undefined | D
     [Symbol.dispose](): void;
 };
 export declare function assignDispose<T extends object>(value: T, disposable: Disposable): T & {
-    [Symbol.dispose]: () => void;
+    [Symbol.dispose](): void;
 };

package/index.js

@@ -1,6 +1,3 @@
-import retry from './retry.js';
-import computed from './computed.js';
-export { retry, computed };
 export function makeReset() {
     let stack = new DisposableStack();
     return () => {
@@ -129,7 +126,11 @@ export function createTransition(cb, durationMs) {
     }
 }
 export function assignDispose(value, disposable) {
+    const valueDispose = value?.[Symbol.dispose]?.bind(value);
     return Object.assign(value, {
-        [Symbol.dispose]: disposable[Symbol.dispose].bind(disposable),
+        [Symbol.dispose]() {
+            valueDispose?.();
+            disposable[Symbol.dispose]();
+        }
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "jrx",
-	"version": "0.3.0-alpha.7",
+	"version": "0.3.0-alpha.9",
 	"type": "module",
 	"scripts": {
 		"prepublishOnly": "npx tsc",
@@ -19,11 +19,7 @@
 	},
 	"files": [
 		"index.js",
-		"index.d.ts",
-		"retry.js",
-		"retry.d.ts",
-		"computed.js",
-		"computed.d.ts"
+		"index.d.ts"
 	],
 	"devDependencies": {
 		"@types/node": "^25.2.1",

package/computed.d.ts

@@ -1,3 +0,0 @@
-export default function computed<T, Deps extends any[] = unknown[]>(fn: () => T, getDeps?: () => Deps): {
-    readonly value: T;
-};

package/computed.js

@@ -1,17 +0,0 @@
-export default function computed(fn, getDeps) {
-    let cached;
-    let lastDeps;
-    let first = true;
-    return {
-        get value() {
-            if (!getDeps)
-                return fn();
-            const deps = getDeps();
-            if (!first && deps.length === lastDeps.length && deps.every((dep, idx) => Object.is(dep, lastDeps[idx])))
-                return cached;
-            first = false;
-            lastDeps = deps;
-            return (cached = fn());
-        },
-    };
-}

package/retry.d.ts

@@ -1,3 +0,0 @@
-export default function retry<T>(cb: (info: {
-    resetBackoff(): void;
-}) => T | Promise<T>, backoffSec?: number[]): Disposable & Promise<T | undefined>;

package/retry.js

@@ -1,35 +0,0 @@
-import { makeReset } from './index.js';
-export default function retry(cb, backoffSec = [5, 5, 10, 10, 20, 20, 40, 40, 60, -1]) {
-    const stack = new DisposableStack();
-    const reset = makeReset();
-    stack.defer(reset);
-    let count = 0;
-    let loopStack = reset();
-    return Object.assign((async () => {
-        while (true) {
-            if (backoffSec[count] !== -1)
-                count++;
-            try {
-                if (loopStack.disposed)
-                    return;
-                const value = cb({
-                    resetBackoff() {
-                        count = 1;
-                    },
-                });
-                return value?.[Symbol.dispose] ? loopStack.use(value) : value;
-            }
-            catch (e) {
-                if (stack.disposed)
-                    return;
-                if (count > backoffSec.length) {
-                    console.error('max retries reached:', e);
-                    throw e;
-                }
-                console.warn('Retrying due to error:', e);
-                loopStack = reset();
-                await new Promise(resolve => setTimeout(resolve, backoffSec[count - 1] * 1000));
-            }
-        }
-    })(), { [Symbol.dispose]: stack[Symbol.dispose].bind(stack) });
-}