@oscarpalmer/timer 0.18.0 → 0.19.0

package/README.md

@@ -62,6 +62,16 @@ Both the nice helper methods and the class syntax create similar objects – `Wa
 
 ## Callbacks
 
+Callbacks for waited timers do not receive any arguments, but callbacks for repeated ones do:
+
+```typescript
+repeat(index => {
+	// 'index' is the current step
+	// starts at 0, goes up to a maximum of count - 1
+	// for this example: 0 → 9
+}, 0, 10);
+```
+
 When you create a repeated timer, you can also provide a fourth parameter to act as a callback to run when the timer stops, as below:
 
 ```typescript

package/dist/timer.iife.js

@@ -1,169 +1,162 @@
 var Timer = (function (exports) {
-	('use strict');
+    'use strict';
 
-	const callbacks = new WeakMap();
-	const configuration = new WeakMap();
-	const state = new WeakMap();
-	const milliseconds = Math.round(1000 / 60);
-	const request =
-		requestAnimationFrame ??
-		function (callback) {
-			return setTimeout?.(() => {
-				callback(Date.now());
-			}, milliseconds);
-		};
-	function run(timed) {
-		const timedConfiguration = configuration.get(timed);
-		const timedCallbacks = callbacks.get(timed);
-		const timedState = state.get(timed);
-		timedState.active = true;
-		timedState.finished = false;
-		const isRepeated = timed instanceof Repeated;
-		let index = 0;
-		let start;
-		function step(timestamp) {
-			if (!timedState.active) {
-				return;
-			}
-			start ?? (start = timestamp);
-			const elapsed = timestamp - start;
-			const elapsedMinimum = elapsed - milliseconds;
-			const elapsedMaximum = elapsed + milliseconds;
-			if (
-				elapsedMinimum < timedConfiguration.time &&
-				timedConfiguration.time < elapsedMaximum
-			) {
-				if (timedState.active) {
-					timedCallbacks.default(isRepeated ? index : undefined);
-				}
-				index += 1;
-				if (isRepeated && index < timedConfiguration.count) {
-					start = undefined;
-				} else {
-					timedState.finished = true;
-					timed.stop();
+		const callbacks = new WeakMap();
+		const configuration = new WeakMap();
+		const state = new WeakMap();
+		const milliseconds = Math.round(1000 / 60);
+		function run(timed) {
+			const timedConfiguration = configuration.get(timed);
+			const timedCallbacks = callbacks.get(timed);
+			const timedState = state.get(timed);
+			timedState.active = true;
+			timedState.finished = false;
+			const isRepeated = timed instanceof Repeated;
+			let index = 0;
+			let start;
+			function step(timestamp) {
+				if (!timedState.active) {
 					return;
 				}
+				start ?? (start = timestamp);
+				const elapsed = timestamp - start;
+				const elapsedMinimum = elapsed - milliseconds;
+				const elapsedMaximum = elapsed + milliseconds;
+				if (
+					elapsedMinimum < timedConfiguration.time &&
+					timedConfiguration.time < elapsedMaximum
+				) {
+					if (timedState.active) {
+						timedCallbacks.default(isRepeated ? index : undefined);
+					}
+					index += 1;
+					if (isRepeated && index < timedConfiguration.count) {
+						start = undefined;
+					} else {
+						timedState.finished = true;
+						timed.stop();
+						return;
+					}
+				}
+				timedState.frame = globalThis.requestAnimationFrame(step);
 			}
-			timedState.frame = request(step);
-		}
-		timedState.frame = request(step);
-	}
-	class Timed {
-		get active() {
-			return state.get(this)?.active ?? false;
-		}
-		get finished() {
-			return !this.active && (state.get(this)?.finished ?? false);
+			timedState.frame = globalThis.requestAnimationFrame(step);
 		}
-		/**
-		 * @param {Callback} callback
-		 * @param {number} time
-		 * @param {number} count
-		 * @param {AfterCallback=} afterCallback
-		 */
-		constructor(callback, time, count, afterCallback) {
-			const isRepeated = this instanceof Repeated;
-			const type = isRepeated ? 'repeated' : 'waited';
-			if (typeof callback !== 'function') {
-				throw new TypeError(`A ${type} timer must have a callback function`);
-			}
-			if (typeof time !== 'number' || time < 0) {
-				throw new TypeError(
-					`A ${type} timer must have a non-negative number as its time`,
-				);
+		class Timed {
+			get active() {
+				return state.get(this)?.active ?? false;
 			}
-			if (isRepeated && (typeof count !== 'number' || count < 2)) {
-				throw new TypeError(
-					'A repeated timer must have a number above 1 as its repeat count',
-				);
+			get finished() {
+				return !this.active && (state.get(this)?.finished ?? false);
 			}
-			if (
-				isRepeated &&
-				afterCallback !== undefined &&
-				typeof afterCallback !== 'function'
-			) {
-				throw new TypeError(
-					"A repeated timer's after-callback must be a function",
-				);
+			/**
+			 * @param {Callback} callback
+			 * @param {number} time
+			 * @param {number} count
+			 * @param {AfterCallback=} afterCallback
+			 */
+			constructor(callback, time, count, afterCallback) {
+				const isRepeated = this instanceof Repeated;
+				const type = isRepeated ? 'repeated' : 'waited';
+				if (typeof callback !== 'function') {
+					throw new TypeError(`A ${type} timer must have a callback function`);
+				}
+				if (typeof time !== 'number' || time < 0) {
+					throw new TypeError(
+						`A ${type} timer must have a non-negative number as its time`,
+					);
+				}
+				if (isRepeated && (typeof count !== 'number' || count < 2)) {
+					throw new TypeError(
+						'A repeated timer must have a number above 1 as its repeat count',
+					);
+				}
+				if (
+					isRepeated &&
+					afterCallback !== undefined &&
+					typeof afterCallback !== 'function'
+				) {
+					throw new TypeError(
+						"A repeated timer's after-callback must be a function",
+					);
+				}
+				callbacks.set(this, {
+					after: afterCallback,
+					default: callback,
+				});
+				configuration.set(this, {count, time});
+				state.set(this, {
+					active: false,
+					finished: false,
+				});
 			}
-			callbacks.set(this, {
-				after: afterCallback,
-				default: callback,
-			});
-			configuration.set(this, {count, time});
-			state.set(this, {
-				active: false,
-				finished: false,
-				frame: undefined,
-			});
-		}
-		restart() {
-			this.stop();
-			run(this);
-			return this;
-		}
-		start() {
-			if (!this.active) {
+			restart() {
+				this.stop();
 				run(this);
+				return this;
 			}
-			return this;
-		}
-		stop() {
-			const timedCallbacks = callbacks.get(this);
-			const timedState = state.get(this);
-			timedState.active = false;
-			if (timedState.frame === undefined) {
+			start() {
+				if (!this.active) {
+					run(this);
+				}
+				return this;
+			}
+			stop() {
+				const timedCallbacks = callbacks.get(this);
+				const timedState = state.get(this);
+				timedState.active = false;
+				if (timedState.frame === undefined) {
+					return this;
+				}
+				globalThis.cancelAnimationFrame(timedState.frame);
+				timedCallbacks.after?.(this.finished);
+				timedState.frame = undefined;
 				return this;
 			}
-			(cancelAnimationFrame ?? clearTimeout)?.(timedState.frame);
-			timedCallbacks.after?.(this.finished);
-			timedState.frame = undefined;
-			return this;
 		}
-	}
-	/**
-	 * A timer that waits and runs repeatedly
-	 */
-	class Repeated extends Timed {}
-	/**
-	 * A timer that waits and runs once
-	 */
-	class Waited extends Timed {
 		/**
-		 * Creates a new waited timer
+		 * A timer that waits and runs repeatedly
+		 */
+		class Repeated extends Timed {}
+		/**
+		 * A timer that waits and runs once
+		 */
+		class Waited extends Timed {
+			/**
+			 * Creates a new waited timer
+			 * @param {() => void} callback
+			 * @param {number} time
+			 */
+			constructor(callback, time) {
+				super(callback, time, 1);
+			}
+		}
+		/**
+		 * Creates and starts a new repeated timer
+		 * @param {RepeatedCallback} callback
+		 * @param {number} time
+		 * @param {number} count
+		 * @param {AfterCallback=} afterCallback
+		 * @return {Repeated}
+		 */
+		function repeat(callback, time, count, afterCallback) {
+			return new Repeated(callback, time, count, afterCallback).start();
+		}
+		/**
+		 * Creates and starts a new waited timer
 		 * @param {() => void} callback
 		 * @param {number} time
+		 * @return {Waited}
 		 */
-		constructor(callback, time) {
-			super(callback, time, 1);
+		function wait(callback, time) {
+			return new Waited(callback, time).start();
 		}
-	}
-	/**
-	 * Creates and starts a new repeated timer
-	 * @param {RepeatedCallback} callback
-	 * @param {number} time
-	 * @param {number} count
-	 * @param {AfterCallback=} afterCallback
-	 * @return {Repeated}
-	 */
-	function repeat(callback, time, count, afterCallback) {
-		return new Repeated(callback, time, count, afterCallback).start();
-	}
-	/**
-	 * Creates and starts a new waited timer
-	 * @param {() => void} callback
-	 * @param {number} time
-	 * @return {Waited}
-	 */
-	function wait(callback, time) {
-		return new Waited(callback, time).start();
-	}
 
-	exports.Repeated = Repeated;
-	exports.Waited = Waited;
-	exports.repeat = repeat;
-	exports.wait = wait;
+		exports.Repeated = Repeated;
+		exports.Waited = Waited;
+		exports.repeat = repeat;
+		exports.wait = wait;
+
+		return exports;
 
-	return exports;
 })({});

package/dist/timer.js

@@ -12,13 +12,6 @@ const callbacks = new WeakMap();
 const configuration = new WeakMap();
 const state = new WeakMap();
 const milliseconds = Math.round(1000 / 60);
-const request =
-	requestAnimationFrame ??
-	function (callback) {
-		return setTimeout?.(() => {
-			callback(Date.now());
-		}, milliseconds);
-	};
 function run(timed) {
 	const timedConfiguration = configuration.get(timed);
 	const timedCallbacks = callbacks.get(timed);
@@ -52,9 +45,9 @@ function run(timed) {
 				return;
 			}
 		}
-		timedState.frame = request(step);
+		timedState.frame = globalThis.requestAnimationFrame(step);
 	}
-	timedState.frame = request(step);
+	timedState.frame = globalThis.requestAnimationFrame(step);
 }
 class Timed {
 	get active() {
@@ -102,7 +95,6 @@ class Timed {
 		state.set(this, {
 			active: false,
 			finished: false,
-			frame: undefined,
 		});
 	}
 	restart() {
@@ -123,7 +115,7 @@ class Timed {
 		if (timedState.frame === undefined) {
 			return this;
 		}
-		(cancelAnimationFrame ?? clearTimeout)?.(timedState.frame);
+		globalThis.cancelAnimationFrame(timedState.frame);
 		timedCallbacks.after?.(this.finished);
 		timedState.frame = undefined;
 		return this;

package/package.json

@@ -54,7 +54,7 @@
 	"type": "module",
 	"types": "src/index.d.ts",
 	"unpkg": "dist/timer.iife.js",
-	"version": "0.18.0",
+	"version": "0.19.0",
 	"xo": {
 		"envs": [
 			"browser"

package/src/index.ts

@@ -21,7 +21,7 @@ export type RepeatedCallback = (index: number) => void;
 type State = {
 	active: boolean;
 	finished: boolean;
-	frame?: DOMHighResTimeStamp;
+	frame?: number;
 };
 
 const callbacks = new WeakMap<Timed<never, never>, Callbacks>();
@@ -30,14 +30,6 @@ const state = new WeakMap<Timed<never, never>, State>();
 
 const milliseconds = Math.round(1000 / 60);
 
-const request =
-	globalThis.requestAnimationFrame ??
-	function (callback) {
-		return setTimeout?.(() => {
-			callback(Date.now());
-		}, milliseconds);
-	};
-
 function run(timed: Timed<never, never>): void {
 	const timedConfiguration = configuration.get(timed)!;
 	const timedCallbacks = callbacks.get(timed)!;
@@ -52,7 +44,7 @@ function run(timed: Timed<never, never>): void {
 
 	let start;
 
-	function step(timestamp: DOMHighResTimeStamp) {
+	function step(timestamp: DOMHighResTimeStamp): void {
 		if (!timedState.active) {
 			return;
 		}
@@ -85,10 +77,10 @@ function run(timed: Timed<never, never>): void {
 			}
 		}
 
-		timedState.frame = request(step) as never;
+		timedState.frame = globalThis.requestAnimationFrame(step);
 	}
 
-	timedState.frame = request(step) as never;
+	timedState.frame = globalThis.requestAnimationFrame(step);
 }
 
 class Timed<Type, Callback> {
@@ -107,7 +99,7 @@ class Timed<Type, Callback> {
 	 * @param {AfterCallback=} afterCallback
 	 */
 	constructor(
-		callback: () => void | ((index: number) => void),
+		callback: Callback,
 		time: number,
 		count: number,
 		afterCallback?: AfterCallback,
@@ -144,7 +136,7 @@ class Timed<Type, Callback> {
 
 		callbacks.set(this as never, {
 			after: afterCallback,
-			default: callback,
+			default: callback as never,
 		});
 
 		configuration.set(this as never, {count, time});
@@ -152,7 +144,6 @@ class Timed<Type, Callback> {
 		state.set(this as never, {
 			active: false,
 			finished: false,
-			frame: undefined,
 		});
 	}
 
@@ -182,7 +173,7 @@ class Timed<Type, Callback> {
 			return this as never;
 		}
 
-		(cancelAnimationFrame ?? clearTimeout)?.(timedState.frame);
+		globalThis.cancelAnimationFrame(timedState.frame);
 
 		timedCallbacks.after?.(this.finished);