Cancellable Interval — JavaScript Challenge

Implement cancellableInterval(callback, delay, ...args), a function that behaves like setInterval but returns a cancel function instead of exposing the timer handle. Repeatedly call the callback with the supplied arguments after each delay. Calling the returned function stops future invocations of that interval. Native timer APIs are allowed.

Requirements

Export cancellableInterval(callback, delay, ...args) as both a named and default function, and return a zero-argument cancel function.

The first invocation is scheduled after delay milliseconds, followed by repeated invocations at that interval. Do not call the callback immediately. Native setInterval and clearInterval are allowed; a correct alternative timer implementation is also acceptable.

Forward all additional arguments to the callback in their original order on every invocation. Preserve values and references; do not invoke function-valued arguments or use callback return values to control scheduling.

Calling cancel() must stop future invocations and release any pending timer for this instance. It must work before the first invocation, between invocations, or inside the callback. Treat timer handles as opaque values; do not assume they are numeric. Cancellation does not interrupt code already running.

Repeated calls to the same cancel function must be safe and must not restart the interval or affect any other interval. Each call to cancellableInterval owns its own timer.

Inputs are a synchronous, non-throwing callback and a positive integer delay no greater than 2,147,483,647. Invalid or missing arguments, zero or negative delays, async callback coordination, pause/resume, and calling-context preservation are outside scope. Explicitly bound callbacks should work normally.

Real browsers may run timer callbacks later than requested. Tests use a controlled clock to check scheduling and cancellation deterministically; exact wall-clock timing is not a requirement.

Examples

Example 1

Input: const calls = [];
const cancel = cancellableInterval(() => calls.push("tick"), 100);
// Advance a controlled clock to 250 ms, then cancel().
Output: calls is ["tick", "tick"] from the scheduled 100 ms and 200 ms ticks. Later ticks are cancelled.

Example 2

Input: const cancel = cancellableInterval((name, count) => console.log(name, count), 100, "Ada", 2);
Output: Each invocation receives "Ada" and 2; cancel is a function.

Example 3

Input: const cancel = cancellableInterval(() => console.log("tick"), 100);
cancel();
cancel();
Output: No callback is invoked if cancelled before the first tick. Both cancellation calls are safe.

cancellableInterval(callback, delay, ...args) returns () => void. The callback receives only the supplied extra arguments. TypeScript infers a tuple of callback argument types so supplied arguments must match. Invoke cancel() to stop later ticks; invoking it again is harmless.