https://github.com/marianmeres/ticker

Do something when it ticks.
https://github.com/marianmeres/ticker

interval subscribe svelte-store ticker

Last synced: 3 days ago
JSON representation

Do something when it ticks.

• Host: GitHub
• URL: https://github.com/marianmeres/ticker
• Owner: marianmeres
• License: mit
• Created: 2023-03-13T07:57:49.000Z (almost 2 years ago)
• Default Branch: master
• Last Pushed: 2024-08-14T08:42:45.000Z (4 months ago)
• Last Synced: 2024-11-18T21:01:40.449Z (about 1 month ago)
• Topics: interval, subscribe, svelte-store, ticker
• Language: TypeScript
• Homepage:
• Size: 292 KB
• Stars: 0
• Watchers: 2
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# @marianmeres/ticker

Do something when it ticks. With a [store compatible](https://github.com/marianmeres/store) API.

Under the hood it uses recursive `setTimeout` with interval corrections,

so it should guarantee the precise frequency **except** for the edge cases where the

**synchronous**

subscriber's work cannot keep up with the interval - it will never tick sooner before it

finishes.

## Install

```shell

$ npm i @marianmeres/ticker

```

## Usage

```typescript

import { createTicker } from '@marianmeres/ticker';

// once started, will tick every 1000 milliseconds

// (interval = 1000, start = false): Ticker

const t = createTicker(1_000);

// basic control api

t.start();

t.stop();

// decrease/increase frequency on existing instance

t.setInterval(ms);

// subscribe api

const unsub = t.subscribe((timestamp) => {

	if (timestamp) {

		// do something on tick

	} else {

		// ticker is stopped (or has not started yet)

	}

});

```

## Delayed Worker Ticker

Using a tick signal from a sync ticker shown above for a periodical **asynchronous** work

(e.g. periodical api data fetching) [may not be the best choice](https://developer.mozilla.org/en-US/docs/Web/API/setInterval#ensure_that_execution_duration_is_shorter_than_interval_frequency).

For such cases, use its "delayed" sibling. Instead of frequency, it guarantees a delay

between worker calls.

## Delayed Worker Ticker Usage

```typescript

import { createDelayedWorkerTicker } from '@marianmeres/ticker';

// once started, it will do the work, then pause for 1 second, then repeat...

// (worker: CallableFunction, interval = 1000, start = false): DelayedWorkerTicker

const t = createDelayedWorkerTicker(async () => fetch('/api'), 1_000);

// control api

t.start();

t.stop();

t.setInterval(ms);

// subscribe api

const unsub = t.subscribe(({ started, finished, error, result }) => {

	// both `started` and `finished` are timestamps (or zero)

	if (started && !finished) {

		// worker's work is in progress

	} else if (started && finished) {

		// do something with `result` or `error`

	} else {

		// ticker is stopped (or has not started yet)

	}

});

```

## Interval value as a function

If desired, you can define the interval value as a function which returns the number of ms.

```typescript

type Interval = number | ((previous: number) => number);

```