d3-timer

What is d3-timer?

The d3-timer package provides a set of tools for controlling the timing of animations, transitions, and other time-based operations. It allows for the efficient scheduling of new timers, the creation of timer queues, and the handling of elapsed time within scheduled callbacks.

What are d3-timer's main functionalities?

Creating and starting a timer

This feature allows you to create a new timer that calls a specified callback function on each animation frame with the elapsed time. The timer can be stopped by calling the stop method.

const timer = d3.timer(elapsed => {
  console.log('Timer elapsed time:', elapsed);
  if (elapsed > 2000) timer.stop();
});

Creating a timer with a delay and time limit

This feature allows you to create a timer with a delay before it starts invoking the callback function. The timer will automatically stop after a specified time limit.

const timer = d3.timer(elapsed => {
  console.log('Timer elapsed time with delay:', elapsed);
  if (elapsed > 1000) timer.stop();
}, 500);

Creating a timer queue

This feature allows you to create a queue of timers that will execute their callback functions after a specified delay. It is similar to using setTimeout but is integrated with the d3-timer's efficient timing mechanism.

const timer1 = d3.timeout(() => console.log('Timeout 1'), 1000);
const timer2 = d3.timeout(() => console.log('Timeout 2'), 2000);

Creating an interval timer

This feature allows you to create a timer that will execute its callback function at a specified interval. It is similar to using setInterval but provides more accurate and efficient timing.

const interval = d3.interval(() => {
  console.log('Interval tick');
  if (++count > 10) interval.stop();
}, 1000);

Other packages similar to d3-timer

raf-schd

raf-schd provides a scheduler for requestAnimationFrame, allowing you to throttle rendering updates for better performance. It is similar to d3-timer in that it helps manage animations, but it focuses on scheduling within the animation frame rate.

chrono-node

chrono-node is a high-resolution timer utility for Node.js, which can be used for performance testing and benchmarking. It offers precise timing but does not provide the same scheduling features as d3-timer.

later

later is a library for describing recurring schedules and calculating their occurrences. It provides a different set of features compared to d3-timer, focusing on recurring schedules rather than frame-based animation timing.

README

d3-timer

This module provides an efficient queue capable of managing thousands of concurrent animations, while guaranteeing consistent, synchronized timing with concurrent or staged animations. Internally, it uses requestAnimationFrame for fluid animation (if available), switching to setTimeout for delays longer than 24ms.

Installing

If you use npm, npm install d3-timer. You can also download the latest release on GitHub. For vanilla HTML in modern browsers, import d3-timer from Skypack:

<script type="module">

import {timer} from "https://cdn.skypack.dev/d3-timer@3";

const t = timer(callback);

</script>

For legacy environments, you can load d3-timer’s UMD bundle from an npm-based CDN such as jsDelivr; a d3 global is exported:

<script src="https://cdn.jsdelivr.net/npm/d3-timer@3"></script>
<script>

const timer = d3.timer(callback);

</script>

API Reference

# d3.now() <>

Returns the current time as defined by performance.now if available, and Date.now if not. The current time is updated at the start of a frame; it is thus consistent during the frame, and any timers scheduled during the same frame will be synchronized. If this method is called outside of a frame, such as in response to a user event, the current time is calculated and then fixed until the next frame, again ensuring consistent timing during event handling.

# d3.timer(callback[, delay[, time]]) <>

Schedules a new timer, invoking the specified callback repeatedly until the timer is stopped. An optional numeric delay in milliseconds may be specified to invoke the given callback after a delay; if delay is not specified, it defaults to zero. The delay is relative to the specified time in milliseconds; if time is not specified, it defaults to now.

The callback is passed the (apparent) elapsed time since the timer became active. For example:

const t = d3.timer((elapsed) => {
  console.log(elapsed);
  if (elapsed > 200) t.stop();
}, 150);

This produces roughly the following console output:

3
25
48
65
85
106
125
146
167
189
209

(The exact values may vary depending on your JavaScript runtime and what else your computer is doing.) Note that the first elapsed time is 3ms: this is the elapsed time since the timer started, not since the timer was scheduled. Here the timer started 150ms after it was scheduled due to the specified delay. The apparent elapsed time may be less than the true elapsed time if the page is backgrounded and requestAnimationFrame is paused; in the background, apparent time is frozen.

If timer is called within the callback of another timer, the new timer callback (if eligible as determined by the specified delay and time) will be invoked immediately at the end of the current frame, rather than waiting until the next frame. Within a frame, timer callbacks are guaranteed to be invoked in the order they were scheduled, regardless of their start time.

# timer.restart(callback[, delay[, time]]) <>

Restart a timer with the specified callback and optional delay and time. This is equivalent to stopping this timer and creating a new timer with the specified arguments, although this timer retains the original invocation priority.

# timer.stop() <>

Stops this timer, preventing subsequent callbacks. This method has no effect if the timer has already stopped.

# d3.timerFlush() <>

Immediately invoke any eligible timer callbacks. Note that zero-delay timers are normally first executed after one frame (~17ms). This can cause a brief flicker because the browser renders the page twice: once at the end of the first event loop, then again immediately on the first timer callback. By flushing the timer queue at the end of the first event loop, you can run any zero-delay timers immediately and avoid the flicker.

# d3.timeout(callback[, delay[, time]]) <>

Like timer, except the timer automatically stops on its first callback. A suitable replacement for setTimeout that is guaranteed to not run in the background. The callback is passed the elapsed time.

# d3.interval(callback[, delay[, time]]) <>

Like timer, except the callback is invoked only every delay milliseconds; if delay is not specified, this is equivalent to timer. A suitable replacement for setInterval that is guaranteed to not run in the background. The callback is passed the elapsed time.