# @askrjs/askr/fx

> Published API exports for @askrjs/askr/fx.

Source: [https://askrjs.com/docs/reference/api/askr/fx](https://askrjs.com/docs/reference/api/askr/fx)

Status: stable. Packages: @askrjs/askr/fx.

**Published packages are authoritative.** Examples may lag behind a published contract. When guidance differs, verify the exports and TypeScript declarations in your installed package, then file an issue.

## Exports

This entrypoint publishes 18 exports from the declarations shipped by @askrjs/askr.

### `debounce`

```ts
debounce: <T extends AnyFn>(fn: T, ms: number, options?: DebounceOptions) => T & { cancel(): void; }
```

Debounce — delay execution, coalesce rapid calls

Useful for: text input, resize, autosave

````tsx
```ts
const save = debounce((text) => api.save(text), 500);
input.addEventListener('input', (e) => save(e.target.value));
save.cancel(); // stop any pending execution
```
````

### `debounceEvent`

```ts
debounceEvent: (ms: number, handler: EventListener, options?: { leading?: boolean; trailing?: boolean; }) => EventListener & { cancel(): void; flush(): void; }
```

Wrap an event handler so rapid events are coalesced and delayed by `ms`.

### `DebounceOptions`

```ts
DebounceOptions: any
```

Options for {@link debounce}.

- `leading`: leading?: boolean;

- `trailing`: trailing?: boolean;

### `defer`

```ts
defer: (fn: () => void) => void
```

Defer — schedule on microtask queue

Useful for: run-after-current-stack logic
More reliable than setTimeout(..., 0)

````tsx
```ts
defer(() => update()); // runs after current stack, before next macrotask
```
````

### `idle`

```ts
idle: (fn: () => void, options?: { timeout?: number; }) => void
```

Idle — schedule low-priority work

Useful for: background prep, non-urgent updates
Falls back to setTimeout if requestIdleCallback unavailable

````tsx
```ts
idle(() => prefetchData());
```
````

### `once`

```ts
once: <T extends AnyFn>(fn: T) => T
```

Once — guard against double execution

Useful for: init logic, event safety

````tsx
```ts
const init = once(setup);
init(); // runs
init(); // does nothing
init(); // does nothing
```
````

### `raf`

```ts
raf: <T extends AnyFn>(fn: T) => T
```

RAF — coalesce multiple updates into single frame

Useful for: animation, layout work, render updates

````tsx
```ts
const update = raf(render);
update(); // schedules on next frame
update(); // same frame, no duplicate
```
````

### `rafEvent`

```ts
rafEvent: (handler: EventListener) => EventListener & { cancel(): void; }
```

Wrap an event handler so it runs at most once per animation frame, using the latest event.

### `retry`

```ts
retry: <T>(fn: () => Promise<T>, options?: RetryOptions) => Promise<T>
```

Retry — attempt function with backoff

Useful for: network calls, transient failures

````tsx
```ts
const data = await retry(() => fetch(url), {
  maxAttempts: 3,
  delayMs: 100,
});
```
````

### `RetryOptions`

```ts
RetryOptions: any
```

Options for {@link retry}.

- `maxAttempts`: maxAttempts?: number;

- `delayMs`: delayMs?: number;

- `backoff`: backoff?: (attemptIndex: number) => number;

### `scheduleEventHandler`

```ts
scheduleEventHandler: (handler: EventListener) => EventListener
```

### `scheduleIdle`

```ts
scheduleIdle: (fn: () => void, options?: { timeout?: number; }) => CancelFn
```

Schedule `fn` during browser idle time, auto-cancelling on component cleanup.

### `scheduleRetry`

```ts
scheduleRetry: <T>(fn: () => Promise<T>, options?: RetryOptions$1) => { cancel(): void; }
```

Run `fn`, retrying with backoff on failure, auto-cancelling on component cleanup.

### `scheduleTimeout`

```ts
scheduleTimeout: (ms: number, fn: () => void) => CancelFn
```

Schedule `fn` after `ms`, auto-cancelling on component cleanup; returns a cancel function.

### `throttle`

```ts
throttle: <T extends AnyFn>(fn: T, ms: number, options?: ThrottleOptions) => T & { cancel(): void; }
```

Throttle — rate-limit execution, keep first/last

Useful for: scroll, mouse move, high-frequency events

````tsx
```ts
const handleScroll = throttle(updateUI, 100);
window.addEventListener('scroll', handleScroll);
handleScroll.cancel();
```
````

### `throttleEvent`

```ts
throttleEvent: (ms: number, handler: EventListener, options?: { leading?: boolean; trailing?: boolean; }) => EventListener & { cancel(): void; }
```

Wrap an event handler so it runs at most once per `ms` interval.

### `ThrottleOptions`

```ts
ThrottleOptions: any
```

Options for {@link throttle}.

- `leading`: leading?: boolean;

- `trailing`: trailing?: boolean;

### `timeout`

```ts
timeout: (ms: number) => Promise<void>
```

Timeout — Promise-based delay

Useful for: readable async code, waiting between retries

````tsx
```ts
await timeout(300);
console.log('300ms later');
```
````

## Documentation navigation

[Previous](https://askrjs.com/docs/reference/api/askr/testing/index.md) | [Next](https://askrjs.com/docs/reference/api/askr/router/index.md)