@askrjs/askr/fx

debouncetype

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

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

debounceEventtype

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`.

DebounceOptionstype

DebounceOptions: any

Options for {@link debounce}.

leading

leading?: boolean;

trailing

trailing?: boolean;

defertype

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

Defer — schedule on microtask queue Useful for: run-after-current-stack logic More reliable than setTimeout(..., 0)

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

idletype

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

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

oncetype

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

Once — guard against double execution Useful for: init logic, event safety

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

raftype

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

RAF — coalesce multiple updates into single frame Useful for: animation, layout work, render updates

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

rafEventtype

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

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

retrytype

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

Retry — attempt function with backoff Useful for: network calls, transient failures

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

RetryOptionstype

RetryOptions: any

Options for {@link retry}.

maxAttempts

maxAttempts?: number;

delayMs

delayMs?: number;

backoff

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

scheduleEventHandlertype

scheduleEventHandler: (handler: EventListener) => EventListener

scheduleIdletype

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

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

scheduleRetrytype

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

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

scheduleTimeouttype

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

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

throttletype

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

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

throttleEventtype

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.

ThrottleOptionstype

ThrottleOptions: any

Options for {@link throttle}.

leading

leading?: boolean;

trailing

trailing?: boolean;

timeouttype

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

Timeout — Promise-based delay Useful for: readable async code, waiting between retries

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