# @lumino/polling

> Lumino Polling

Latest version **2.1.6** (published 2026-07-03) · BSD-3-Clause license · 0 weekly downloads

## Install

```sh
npm install @lumino/polling
pnpm add @lumino/polling
yarn add @lumino/polling
bun add @lumino/polling
```

## Health

**Score 75/100 (B)** — status: active.

Positive: has types; esm support; no vulnerabilities; has provenance; recently updated; high maintenance score; high quality score.

Warnings: low downloads.

## Facts

| | |
|---|---|
| Version | 2.1.6 |
| Published | 2026-07-03 |
| First published | 2019-12-09 |
| Weekly downloads | 0 |
| License | BSD-3-Clause |
| TypeScript types | bundled |
| Module format | ESM + CommonJS |
| Dependencies | 3 |
| Unpacked size | 181.6 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Provenance | attested (GitHub Actions) |
| GitHub stars | 762 |
| Author | Project Jupyter |
| Maintainers | blink1073, ellisonbg, darian, jasongrout, jtpio, fcollonval, krassowski |

## Links

- npm: https://www.npmjs.com/package/@lumino/polling
- Repository: https://github.com/jupyterlab/lumino
- Issues: https://github.com/jupyterlab/lumino/issues
- npm.io page: https://npm.io/package/@lumino/polling

## Dependencies (3)

- [@lumino/coreutils](https://npm.io/package/@lumino/coreutils.md) ^2.2.3
- [@lumino/signaling](https://npm.io/package/@lumino/signaling.md) ^2.1.6
- [@lumino/disposable](https://npm.io/package/@lumino/disposable.md) ^2.1.6

## Recent versions

- 2.1.6 (latest) — 2026-07-03
- 2.0.0-rc.1 (next) — 2023-03-07
- 2.1.5 — 2025-11-13
- 2.1.4 — 2025-03-31
- 2.1.3 — 2024-06-28
- 2.1.2 — 2023-07-27
- 2.1.1 — 2023-04-27
- 2.1.0 — 2023-04-07
- 2.0.0 — 2023-03-15
- 2.0.0-rc.0 — 2023-02-23
- 2.0.0-beta.1 — 2023-01-24
- 1.11.4 — 2023-01-23
- 2.0.0-beta.0 — 2023-01-13
- 2.0.0-alpha.7 — 2023-01-03
- 1.11.3 — 2022-10-31
- … 34 more at https://npm.io/package/@lumino/polling/versions

## README

# @lumino/polling

This package provides a class for generic polling functionality (`Poll`). It
also provides rate limiters (`Debouncer` and `Throttler`).

The `Poll` class provides three different ways to "subscribe" to poll ticks:

- [`@lumino/signaling`](../signaling/): `Poll#ticked` is a Lumino signal that
  emits each time there is a poll tick.
- `Promise`-based: `Poll#tick` is a promise that resolves after every tick and
  only rejects when the poll is disposed.
- `AsyncIterable`: `Poll#[`Symbol.asyncIterator`]` implements the async iterable
  protocol that allows iteration using [`for-await...of`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of) loops.

## Example usage

These are examples from the unit tests for this package. They
demonstrate the three different ways polling is supported.

### Using `Poll#tick` promise

Here, we set up the testing state variables and create a new `Poll` instance.

```typescript
const expected = 'started resolved resolved';
const ticker: IPoll.Phase<any>[] = [];
const tock = (poll: Poll) => {
  ticker.push(poll.state.phase);
  poll.tick.then(tock).catch(() => undefined);
};
const poll = new Poll({
  auto: false,
  factory: () => Promise.resolve(),
  frequency: { interval: 100, backoff: false }
});
```

Next we assign the `tock` function to run after the poll ticks and
we start the poll.

```typescript
void poll.tick.then(tock);
void poll.start();
```

And we verify that the `ticker` did indeed get populated when `tock`
was called and the next promise was captured as well.

```typescript
await sleep(1000); // Sleep for longer than the interval.
expect(ticker.join(' ').startsWith(expected)).to.equal(true);
poll.dispose();
```

### Using `Poll#ticked` signal

Here, we set up the testing state variables and create a new `Poll` instance.

```typescript
const poll = new Poll<void, void>({
  factory: () => Promise.resolve(),
  frequency: { interval: 100, backoff: false }
});
```

Here we connect to the `ticked` signal and simply check that each
tick matches the poll `state` accessor's contents.

```typescript
poll.ticked.connect((_, tick) => {
  expect(tick).to.equal(poll.state);
});
await sleep(1000); // Sleep for longer than the interval.
poll.dispose();
```

### Using `Poll` as an `AsyncIterable`

Here, we set up the testing state variables and create a new `Poll` instance.

```typescript
let poll: Poll;
let total = 2;
let i = 0;

poll = new Poll({
  auto: false,
  factory: () => Promise.resolve(++i > total ? poll.dispose() : void 0),
  frequency: { interval: Poll.IMMEDIATE }
});

const expected = `started${' resolved'.repeat(total)}`;
const ticker: IPoll.Phase<any>[] = [];
```

Then the poll is started:

```typescript
void poll.start();
```

Instead of connecting to the `ticked` signal or awaiting the `tick` promise, we can now use a `for-await...of` loop:

```typescript
for await (const state of poll) {
  ticker.push(state.phase);
  if (poll.isDisposed) {
    break;
  }
}
```

And we check to make sure the results are as expected:

```typescript
// ticker and expected both equal:
// 'started resolved resolved disposed'
expect(ticker.join(' ')).to.equal(expected);
```

### Note for consumers of async iterators

In order to use `for-await...of` loops in TypeScript, you will need to use `ES2018` or above in your `lib` array in `tsconfig.json`.

---
_Source: https://npm.io/package/@lumino/polling · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._