jrx 0.3.0-alpha.6 → 0.3.0-alpha.8

package/README.md

@@ -36,6 +36,7 @@ npm i jrx
 - [`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
 
@@ -305,6 +306,43 @@ const data = await r // undefined
 - `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`.
+
+This is useful when a function needs to return a meaningful value **and** be disposable — for example, returning a promise, a function, or a tuple from a factory while still allowing the caller to clean up the underlying resources.
+
+```typescript
+import {assignDispose} from 'jrx'
+
+function makeThing() {
+  using stack = new DisposableStack()
+  stack.defer(() => console.log('cleanup'))
+
+  const obj = {value: 42}
+  return assignDispose(obj, stack.move())
+}
+```
+
+Async factory — wrap an in-flight promise so the caller can dispose the underlying resources mid-flight:
+
+```typescript
+import {assignDispose} from 'jrx'
+
+function loadThing() {
+  const stack = new DisposableStack()
+  return assignDispose(
+    (async () => {
+      const res = await fetch('/api/data', {signal: stack.adopt(new AbortController(), c => c.abort()).signal})
+      return await res.json()
+    })(),
+    stack,
+  )
+}
+```
+
+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

@@ -27,3 +27,6 @@ export declare function createTimeout(cb: () => void, ms: number): {
 export declare function createTransition(cb: (progress: number) => undefined | Disposable, durationMs: number): {
     [Symbol.dispose](): void;
 };
+export declare function assignDispose<T extends object>(value: T, disposable: Disposable): T & {
+    [Symbol.dispose](): void;
+};

package/index.js

@@ -128,3 +128,12 @@ export function createTransition(cb, durationMs) {
         }
     }
 }
+export function assignDispose(value, disposable) {
+    const valueDispose = value?.[Symbol.dispose]?.bind(value);
+    return Object.assign(value, {
+        [Symbol.dispose]() {
+            valueDispose?.();
+            disposable[Symbol.dispose]();
+        }
+    });
+}

package/package.json

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