jrx 0.1.0 → 0.2.1

package/README.md

@@ -5,7 +5,7 @@ A lightweight TypeScript library for managing side effects, subscriptions, and a
 ## Installation
 
 ```bash
-npm install jrx
+npm i jrx
 ```
 
 ## Features
@@ -20,6 +20,7 @@ npm install jrx
 ## API Overview
 
 - [`makeRenderLoop()`](#makerenderloop) - Render loops with automatic cleanup
+- [`addEvtListener(target, event, handler, option?)`](#addevtlistenertarget-event-handler-option) - Event listeners with cleanup
 - [`addInterval(cb, ms)`](#addintervalcb-ms) - Repeating intervals with cleanup
 - [`addIntervalAsync(cb, ms)`](#addintervalasynccb-ms) - Async intervals with cancellation
 - [`addRequestAnimationFrame(cb)`](#addrequestanimationframecb) - Single animation frame with cleanup
@@ -29,6 +30,7 @@ npm install jrx
 - [`addTransition(cb, durationMs)`](#addtransitioncb-durationms) - Progress-based animations
 - [`computed(fn, getDeps?)`](#computedfn-getdeps) - Memoized computed values
 - [`retry(cb, options?)`](#retrycb-options) - Async retry with exponential backoff
+- [`addRetry(cb, options?)`](#addretrycb-options) - Fire-and-forget retry with disposal
 
 ## API
 
@@ -58,6 +60,28 @@ requestAnimationFrame(loop)
 dispose()
 ```
 
+### `addEvtListener(target, event, handler, option?)`
+
+Adds an event listener to a target and returns a disposer that removes it. Works with any object that implements `addEventListener`/`removeEventListener` (DOM elements, `window`, `document`, etc.).
+
+```typescript
+import { addEvtListener } from 'jrx'
+
+// Basic usage
+const dispose = addEvtListener(window, 'resize', (e) => {
+  console.log('Window resized', e)
+})
+
+// With options
+const dispose2 = addEvtListener(element, 'click', (e) => {
+  console.log('Clicked', e)
+}, { capture: true })
+
+// Cleanup
+dispose()
+dispose2()
+```
+
 ### `addInterval(cb, ms)`
 
 Creates a repeating interval with cleanup. The callback can optionally return a cleanup function that runs before the next invocation.
@@ -238,7 +262,7 @@ Retries an async operation with exponential backoff on failure.
 **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/retry'
+import {retry} from 'jrx'
 
 // Basic usage - retries with default backoff
 const result = await retry(async (disposer, { resetBackoff }) => {
@@ -298,6 +322,37 @@ console.log(data) // T | undefined
 - `disposer`: A disposer for the current retry attempt. Check `disposer.signal.aborted` to handle cancellation
 - `info.resetBackoff()`: Call this to reset the backoff counter to the beginning (useful when making partial progress)
 
+### `addRetry(cb, options?)`
+
+Fire-and-forget version of `retry`. Starts the retry loop in the background and returns a dispose function to cancel it.
+
+```typescript
+import {addRetry} from 'jrx'
+
+// Start a retry loop in the background
+const dispose = addRetry(async (disposer, { resetBackoff }) => {
+  const response = await fetch('/api/data')
+  if (!response.ok) throw new Error('Failed')
+  processData(await response.json())
+})
+
+// Cancel the retry loop
+dispose()
+
+// With custom backoff
+const dispose2 = addRetry(
+  async (disposer) => {
+    await connectWebSocket()
+  },
+  { backoffSec: [1, 2, 5, -1] }
+)
+
+dispose2()
+```
+
+**Options:**
+- `backoffSec`: Array of retry delays in seconds (same as `retry`)
+
 ## Cleanup Pattern
 
 All functions return disposer functions that clean up resources:

package/addEvtListener.d.ts

@@ -0,0 +1,15 @@
+type IEventHandler<Target extends {
+    addEventListener(event: string, handler: any, option?: any): any;
+}, EventName> = Target['addEventListener'] extends (event: EventName, handler: infer Handler, ...args: any[]) => any ? Handler extends (...params: any[]) => any ? Handler : never : never;
+type IEventOption<Target extends {
+    addEventListener(event: string, handler: any, option?: any): any;
+}, EventName, Handler> = Target['addEventListener'] extends (event: EventName, handler: Handler, option: infer Option) => any ? Option : never;
+export default function addEvtListener<Target extends {
+    addEventListener(event: string, handler: any, option?: any): any;
+    removeEventListener(event: string, handler: any, option?: any): any;
+}, EventName extends Parameters<Target['addEventListener']>[0], Handler extends IEventHandler<Target, EventName>>(target: Target, event: EventName, handler: Handler, option?: IEventOption<Target, EventName, Handler>): () => void;
+export default function addEvtListener<Target extends {
+    addEventListener(event: string, handler: any, option?: any): any;
+    removeEventListener(event: string, handler: any, option?: any): any;
+}, EventName extends Parameters<Target['addEventListener']>[0]>(target: Target, event: EventName, handler: (...args: any[]) => any, option?: IEventOption<Target, EventName, IEventHandler<Target, EventName>>): () => void;
+export {};

package/addEvtListener.js

@@ -0,0 +1,6 @@
+export default function addEvtListener(target, event, handler, option) {
+    target.addEventListener(event, handler, option);
+    return function removeEvtListener() {
+        return target.removeEventListener(event, handler, option);
+    };
+}

package/index.d.ts

@@ -1,4 +1,8 @@
 import { type Disposer } from 'jdisposer';
+import retry, { addRetry } from './retry.js';
+import computed from './computed.js';
+import addEvtListener from './addEvtListener.js';
+export { retry, computed, addEvtListener, addRetry };
 export declare function makeRenderLoop(): {
     loop(this: void, time: DOMHighResTimeStamp): void;
     setLoop(this: void, loop: (time: DOMHighResTimeStamp) => void | (() => void)): () => void;

package/index.js

@@ -1,4 +1,8 @@
 import { makeDisposer, makeReset } from 'jdisposer';
+import retry, { addRetry } from './retry.js';
+import computed from './computed.js';
+import addEvtListener from './addEvtListener.js';
+export { retry, computed, addEvtListener, addRetry };
 export function makeRenderLoop() {
     let loop_;
     const reset = makeReset();

package/package.json

@@ -1,9 +1,9 @@
 {
 	"name": "jrx",
-	"version": "0.1.0",
+	"version": "0.2.1",
 	"type": "module",
 	"scripts": {
-		"prepublishOnly": "npx tsc index.ts retry.ts computed.ts --target esnext --declaration --moduleResolution node",
+		"prepublishOnly": "npx tsc",
 		"test": "node --test tests/*.test.ts",
 		"test:coverage": "node --test --experimental-test-coverage tests/*.test.ts"
 	},
@@ -11,14 +11,6 @@
 		".": {
 			"types": "./index.d.ts",
 			"import": "./index.js"
-		},
-		"./retry": {
-			"types": "./retry.d.ts",
-			"import": "./retry.js"
-		},
-		"./computed": {
-			"types": "./computed.d.ts",
-			"import": "./computed.js"
 		}
 	},
 	"repository": {
@@ -31,7 +23,9 @@
 		"retry.js",
 		"retry.d.ts",
 		"computed.js",
-		"computed.d.ts"
+		"computed.d.ts",
+		"addEvtListener.js",
+		"addEvtListener.d.ts"
 	],
 	"devDependencies": {
 		"@types/node": "^25.2.1",

package/retry.d.ts

@@ -10,3 +10,8 @@ export default function retry<T>(cb: (disposer: Disposer, info: {
     backoffSec?: number[];
     disposer: Disposer;
 }): Promise<T | undefined>;
+export declare function addRetry<T>(cb: (disposer: Disposer, info: {
+    resetBackoff(): void;
+}) => T | Promise<T>, options?: {
+    backoffSec?: number[];
+}): (this: void) => void;

package/retry.js

@@ -1,4 +1,4 @@
-import { makeReset } from 'jdisposer';
+import { makeDisposer, makeReset } from 'jdisposer';
 export default async function retry(cb, { backoffSec = [5, 5, 10, 10, 20, 20, 40, 40, 60, -1], // -1: retry forever with the last backoff . first element must not be -1
 disposer, } = {}) {
     const reset = makeReset();
@@ -30,3 +30,8 @@ disposer, } = {}) {
         }
     }
 }
+export function addRetry(cb, options) {
+    const disposer = makeDisposer();
+    void retry(cb, { ...options, disposer });
+    return disposer.dispose;
+}