@oscarpalmer/timer 0.17.0 → 0.19.0

package/README.md

@@ -1,6 +1,6 @@
 # Timer
 
-[![npm version](https://badge.fury.io/js/@oscarpalmer%2Ftimer.svg)](https://badge.fury.io/js/@oscarpalmer%2Ftimer)
+[![npm](https://badge.fury.io/js/@oscarpalmer%2Ftimer.svg)](https://www.npmjs.com/package/@oscarpalmer/timer) [![Tests](https://github.com/oscarpalmer/timer/actions/workflows/test.yml/badge.svg)](https://github.com/oscarpalmer/timer/actions/workflows/test.yml)
 
 A better solution for timeout- and interval-based timers.
 
@@ -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,150 +1,162 @@
-var Timer = (() => {
-  var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __export = (target, all) => {
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-  var __copyProps = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp.call(to, key) && key !== except)
-          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-    }
-    return to;
-  };
-  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Timer = (function (exports) {
+    'use strict';
 
-  // src/index.js
-  var src_exports = {};
-  __export(src_exports, {
-    Repeated: () => Repeated,
-    Waited: () => Waited,
-    repeat: () => repeat,
-    wait: () => wait
-  });
-  var milliseconds = Math.round(1e3 / 60);
-  var request = requestAnimationFrame ?? function(callback) {
-    return setTimeout?.(() => {
-      callback(Date.now());
-    }, milliseconds);
-  };
-  function run(timed) {
-    timed.state.active = true;
-    timed.state.finished = false;
-    const isRepeated = timed instanceof Repeated;
-    let index = 0;
-    let start;
-    function step(timestamp) {
-      if (!timed.state.active) {
-        return;
-      }
-      start ?? (start = timestamp);
-      const elapsed = timestamp - start;
-      const elapsedMinimum = elapsed - milliseconds;
-      const elapsedMaximum = elapsed + milliseconds;
-      if (elapsedMinimum < timed.configuration.time && timed.configuration.time < elapsedMaximum) {
-        if (timed.state.active) {
-          timed.callbacks.default(isRepeated ? index : void 0);
-        }
-        index += 1;
-        if (isRepeated && index < timed.configuration.count) {
-          start = void 0;
-        } else {
-          timed.state.finished = true;
-          timed.stop();
-          return;
-        }
-      }
-      timed.state.frame = request(step);
-    }
-    timed.state.frame = request(step);
-  }
-  var Timed = class {
-    get active() {
-      return this.state.active;
-    }
-    get finished() {
-      return !this.active && this.state.finished;
-    }
-    /**
-     * @param {RepeatedCallback} callback
-     * @param {number} time
-     * @param {number} count
-     * @param {AfterCallback|undefined} 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 !== void 0 && typeof afterCallback !== "function") {
-        throw new TypeError(
-          "A repeated timer's after-callback must be a function"
-        );
-      }
-      this.configuration = { count, time };
-      this.callbacks = {
-        after: afterCallback,
-        default: callback
-      };
-      this.state = {
-        active: false,
-        finished: false,
-        frame: null
-      };
-    }
-    restart() {
-      this.stop();
-      run(this);
-      return this;
-    }
-    start() {
-      if (!this.state.active) {
-        run(this);
-      }
-      return this;
-    }
-    stop() {
-      this.state.active = false;
-      if (this.state.frame === void 0) {
-        return this;
-      }
-      (cancelAnimationFrame ?? clearTimeout)?.(this.state.frame);
-      this.callbacks.after?.(this.finished);
-      this.state.frame = void 0;
-      return this;
-    }
-  };
-  var Repeated = class extends Timed {
-  };
-  var Waited = class extends Timed {
-    /**
-     * @param {Function} callback
-     * @param {number} time
-     */
-    constructor(callback, time) {
-      super(callback, time, 1, null);
-    }
-  };
-  function repeat(callback, time, count, afterCallback) {
-    return new Repeated(callback, time, count, afterCallback).start();
-  }
-  function wait(callback, time) {
-    return new Waited(callback, time).start();
-  }
-  return __toCommonJS(src_exports);
-})();
+		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 = globalThis.requestAnimationFrame(step);
+		}
+		class Timed {
+			get active() {
+				return state.get(this)?.active ?? false;
+			}
+			get finished() {
+				return !this.active && (state.get(this)?.finished ?? false);
+			}
+			/**
+			 * @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,
+				});
+			}
+			restart() {
+				this.stop();
+				run(this);
+				return this;
+			}
+			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;
+			}
+		}
+		/**
+		 * 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}
+		 */
+		function wait(callback, time) {
+			return new Waited(callback, time).start();
+		}
+
+		exports.Repeated = Repeated;
+		exports.Waited = Waited;
+		exports.repeat = repeat;
+		exports.wait = wait;
+
+		return exports;
+
+})({});

package/dist/timer.js

@@ -1,128 +1,162 @@
-// src/index.js
-var milliseconds = Math.round(1e3 / 60);
-var request = requestAnimationFrame ?? function(callback) {
-  return setTimeout?.(() => {
-    callback(Date.now());
-  }, milliseconds);
-};
+/**
+ * @callback AfterCallback
+ * @param {boolean} finished Did the timer finish?
+ * @returns {void}
+ */
+/**
+ * @callback RepeatedCallback
+ * @param {number} index The index of the current iteration
+ * @returns {void}
+ */
+const callbacks = new WeakMap();
+const configuration = new WeakMap();
+const state = new WeakMap();
+const milliseconds = Math.round(1000 / 60);
 function run(timed) {
-  timed.state.active = true;
-  timed.state.finished = false;
-  const isRepeated = timed instanceof Repeated;
-  let index = 0;
-  let start;
-  function step(timestamp) {
-    if (!timed.state.active) {
-      return;
-    }
-    start ?? (start = timestamp);
-    const elapsed = timestamp - start;
-    const elapsedMinimum = elapsed - milliseconds;
-    const elapsedMaximum = elapsed + milliseconds;
-    if (elapsedMinimum < timed.configuration.time && timed.configuration.time < elapsedMaximum) {
-      if (timed.state.active) {
-        timed.callbacks.default(isRepeated ? index : void 0);
-      }
-      index += 1;
-      if (isRepeated && index < timed.configuration.count) {
-        start = void 0;
-      } else {
-        timed.state.finished = true;
-        timed.stop();
-        return;
-      }
-    }
-    timed.state.frame = request(step);
-  }
-  timed.state.frame = request(step);
+	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 = globalThis.requestAnimationFrame(step);
 }
-var Timed = class {
-  get active() {
-    return this.state.active;
-  }
-  get finished() {
-    return !this.active && this.state.finished;
-  }
-  /**
-   * @param {RepeatedCallback} callback
-   * @param {number} time
-   * @param {number} count
-   * @param {AfterCallback|undefined} 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 !== void 0 && typeof afterCallback !== "function") {
-      throw new TypeError(
-        "A repeated timer's after-callback must be a function"
-      );
-    }
-    this.configuration = { count, time };
-    this.callbacks = {
-      after: afterCallback,
-      default: callback
-    };
-    this.state = {
-      active: false,
-      finished: false,
-      frame: null
-    };
-  }
-  restart() {
-    this.stop();
-    run(this);
-    return this;
-  }
-  start() {
-    if (!this.state.active) {
-      run(this);
-    }
-    return this;
-  }
-  stop() {
-    this.state.active = false;
-    if (this.state.frame === void 0) {
-      return this;
-    }
-    (cancelAnimationFrame ?? clearTimeout)?.(this.state.frame);
-    this.callbacks.after?.(this.finished);
-    this.state.frame = void 0;
-    return this;
-  }
-};
-var Repeated = class extends Timed {
-};
-var Waited = class extends Timed {
-  /**
-   * @param {Function} callback
-   * @param {number} time
-   */
-  constructor(callback, time) {
-    super(callback, time, 1, null);
-  }
-};
+class Timed {
+	get active() {
+		return state.get(this)?.active ?? false;
+	}
+	get finished() {
+		return !this.active && (state.get(this)?.finished ?? false);
+	}
+	/**
+	 * @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,
+		});
+	}
+	restart() {
+		this.stop();
+		run(this);
+		return this;
+	}
+	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;
+	}
+}
+/**
+ * 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();
+	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();
+	return new Waited(callback, time).start();
 }
-export {
-  Repeated,
-  Waited,
-  repeat,
-  wait
-};
+
+export {Repeated, Waited, repeat, wait};

package/package.json

@@ -6,12 +6,18 @@
 	"browser": "dist/timer.iife.js",
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"esbuild": "^0.18",
-		"xo": "^0.54"
+		"@happy-dom/global-registrator": "^11.0",
+		"@rollup/plugin-typescript": "^11.1",
+		"bun": "^1.0",
+		"prettier": "^3.0",
+		"rollup": "^3.29",
+		"typescript": "^5.2",
+		"xo": "^0.56"
 	},
 	"files": [
 		"dist",
-		"src"
+		"src",
+		"types"
 	],
 	"jsdelivr": "dist/timer.iife.js",
 	"keywords": [
@@ -24,19 +30,39 @@
 	"main": "dist/timer.iife.js",
 	"module": "dist/timer.js",
 	"name": "@oscarpalmer/timer",
+	"prettier": {
+		"arrowParens": "avoid",
+		"bracketSpacing": false,
+		"singleQuote": true,
+		"switchIndent": true,
+		"trailingComma": "all",
+		"useTabs": true
+	},
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/oscarpalmer/timer.git"
 	},
 	"scripts": {
-		"build": "npm run build:esm; npm run build:iife; npm run types",
-		"build:esm": "esbuild ./src/index.js --bundle --format=esm --outfile=./dist/timer.js --target=es2020",
-		"build:iife": "esbuild ./src/index.js --bundle --format=iife --global-name=Timer --outfile=./dist/timer.iife.js --target=es2020",
-		"types": "./node_modules/.bin/tsc ./src/index.js --allowJs --declaration --emitDeclarationOnly --removeComments",
-		"xo": "./node_modules/.bin/xo ./src/*.js --env browser"
+		"build": "npm run build:esm && npm run build:iife",
+		"build:esm": "rollup -c",
+		"build:iife": "rollup -c --environment ROLLUP_FORMAT:iife",
+		"test": "bun test --coverage",
+		"types": "tsc ./src/index.ts --outdir ./types --declaration --emitDeclarationOnly",
+		"watch": "rollup -c -w",
+		"xo": "xo ./src/*.ts --env browser"
 	},
 	"type": "module",
 	"types": "src/index.d.ts",
 	"unpkg": "dist/timer.iife.js",
-	"version": "0.17.0"
-}
+	"version": "0.19.0",
+	"xo": {
+		"envs": [
+			"browser"
+		],
+		"prettier": true,
+		"rules": {
+			"import/extensions": "off",
+			"import/no-cycle": "off"
+		}
+	}
+}

package/src/index.ts

@@ -0,0 +1,230 @@
+type Callbacks = {
+	after: AfterCallback | undefined;
+	default: (index?: number) => void;
+};
+
+type Configuration = {
+	count: number;
+	time: number;
+};
+
+/**
+ * @param {boolean} finished Did the timer finish?
+ */
+export type AfterCallback = (finished: boolean) => void;
+
+/**
+ * @param {number} index The index of the current iteration
+ */
+export type RepeatedCallback = (index: number) => void;
+
+type State = {
+	active: boolean;
+	finished: boolean;
+	frame?: number;
+};
+
+const callbacks = new WeakMap<Timed<never, never>, Callbacks>();
+const configuration = new WeakMap<Timed<never, never>, Configuration>();
+const state = new WeakMap<Timed<never, never>, State>();
+
+const milliseconds = Math.round(1000 / 60);
+
+function run(timed: Timed<never, never>): void {
+	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: DOMHighResTimeStamp): void {
+		if (!timedState.active) {
+			return;
+		}
+
+		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 = globalThis.requestAnimationFrame(step);
+}
+
+class Timed<Type, Callback> {
+	get active(): boolean {
+		return state.get(this as never)?.active ?? false;
+	}
+
+	get finished(): boolean {
+		return !this.active && (state.get(this as never)?.finished ?? false);
+	}
+
+	/**
+	 * @param {Callback} callback
+	 * @param {number} time
+	 * @param {number} count
+	 * @param {AfterCallback=} afterCallback
+	 */
+	constructor(
+		callback: Callback,
+		time: number,
+		count: number,
+		afterCallback?: 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 as never, {
+			after: afterCallback,
+			default: callback as never,
+		});
+
+		configuration.set(this as never, {count, time});
+
+		state.set(this as never, {
+			active: false,
+			finished: false,
+		});
+	}
+
+	restart(): Type {
+		this.stop();
+
+		run(this as never);
+
+		return this as never;
+	}
+
+	start(): Type {
+		if (!this.active) {
+			run(this as never);
+		}
+
+		return this as never;
+	}
+
+	stop(): Type {
+		const timedCallbacks = callbacks.get(this as never)!;
+		const timedState = state.get(this as never)!;
+
+		timedState.active = false;
+
+		if (timedState.frame === undefined) {
+			return this as never;
+		}
+
+		globalThis.cancelAnimationFrame(timedState.frame);
+
+		timedCallbacks.after?.(this.finished);
+
+		timedState.frame = undefined;
+
+		return this as never;
+	}
+}
+
+/**
+ * A timer that waits and runs repeatedly
+ */
+export class Repeated extends Timed<Repeated, RepeatedCallback> {}
+
+/**
+ * A timer that waits and runs once
+ */
+export class Waited extends Timed<Waited, () => void> {
+	/**
+	 * Creates a new waited timer
+	 * @param {() => void} callback
+	 * @param {number} time
+	 */
+	constructor(callback: () => void, time: number) {
+		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}
+ */
+export function repeat(
+	callback: RepeatedCallback,
+	time: number,
+	count: number,
+	afterCallback?: AfterCallback,
+): Repeated {
+	return new Repeated(callback as never, time, count, afterCallback).start();
+}
+
+/**
+ * Creates and starts a new waited timer
+ * @param {() => void} callback
+ * @param {number} time
+ * @return {Waited}
+ */
+export function wait(callback: () => void, time: number): Waited {
+	return new Waited(callback, time).start();
+}

package/types/index.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @param {boolean} finished Did the timer finish?
+ */
+export type AfterCallback = (finished: boolean) => void;
+
+/**
+ * @param {number} index The index of the current iteration
+ */
+export type RepeatedCallback = (index: number) => void;
+
+declare class Timed<Type, Callback> {
+	get active(): boolean;
+	get finished(): boolean;
+
+	/**
+	 * @param {Callback} callback
+	 * @param {number} time
+	 * @param {number} count
+	 * @param {AfterCallback=} afterCallback
+	 */
+
+	constructor(
+		callback: () => void | ((index: number) => void),
+		time: number,
+		count: number,
+		afterCallback?: AfterCallback,
+	);
+
+	restart(): Type;
+	start(): Type;
+	stop(): Type;
+}
+
+/**
+ * A timer that waits and runs repeatedly
+ */
+export declare class Repeated extends Timed<Repeated, RepeatedCallback> {}
+
+/**
+ * A timer that waits and runs once
+ */
+export declare class Waited extends Timed<Waited, () => void> {
+	/**
+	 * Creates a new waited timer
+	 * @param {() => void} callback
+	 * @param {number} time
+	 */
+	constructor(callback: () => void, time: number);
+}
+
+/**
+ * Creates and starts a new repeated timer
+ * @param {RepeatedCallback} callback
+ * @param {number} time
+ * @param {number} count
+ * @param {AfterCallback=} afterCallback
+ * @return {Repeated}
+ */
+export declare function repeat(
+	callback: RepeatedCallback,
+	time: number,
+	count: number,
+	afterCallback?: AfterCallback,
+): Repeated;
+
+/**
+ * Creates and starts a new waited timer
+ * @param {() => void} callback
+ * @param {number} time
+ * @return {Waited}
+ */
+export declare function wait(callback: () => void, time: number): Waited;

package/src/index.d.ts

@@ -1,31 +0,0 @@
-export function repeat(callback: RepeatedCallback, time: number, count: number, afterCallback: AfterCallback | undefined): Repeated;
-export function wait(callback: Function, time: number): Waited;
-export class Repeated extends Timed {
-}
-export class Waited extends Timed {
-    constructor(callback: Function, time: number);
-}
-export type AfterCallback = (finished: boolean) => void;
-export type RepeatedCallback = (index: number) => void;
-declare class Timed {
-    constructor(callback: RepeatedCallback, time: number, count: number, afterCallback: AfterCallback | undefined);
-    get active(): boolean;
-    get finished(): boolean;
-    readonly configuration: {
-        count: number;
-        time: number;
-    };
-    readonly callbacks: {
-        after: AfterCallback | undefined;
-        default: RepeatedCallback;
-    };
-    readonly state: {
-        active: boolean;
-        finished: boolean;
-        frame?: DOMHighResTimeStamp;
-    };
-    restart(): Timed;
-    start(): Timed;
-    stop(): Timed;
-}
-export {};

package/src/index.js

@@ -1,210 +0,0 @@
-/**
- * @callback AfterCallback
- * @param {boolean} finished
- * @returns {void}
- */
-
-/**
- * @callback RepeatedCallback
- * @param {number} index
- * @returns {void}
- */
-
-const milliseconds = Math.round(1000 / 60);
-
-const request =
-	requestAnimationFrame ??
-	function (callback) {
-		return setTimeout?.(() => {
-			callback(Date.now());
-		}, milliseconds);
-	};
-
-/**
- * @param {Timed} timed
- */
-function run(timed) {
-	timed.state.active = true;
-	timed.state.finished = false;
-
-	const isRepeated = timed instanceof Repeated;
-
-	let index = 0;
-
-	let start;
-
-	function step(timestamp) {
-		if (!timed.state.active) {
-			return;
-		}
-
-		start ??= timestamp;
-
-		const elapsed = timestamp - start;
-
-		const elapsedMinimum = elapsed - milliseconds;
-		const elapsedMaximum = elapsed + milliseconds;
-
-		if (
-			elapsedMinimum < timed.configuration.time &&
-			timed.configuration.time < elapsedMaximum
-		) {
-			if (timed.state.active) {
-				timed.callbacks.default(isRepeated ? index : undefined);
-			}
-
-			index += 1;
-
-			if (isRepeated && index < timed.configuration.count) {
-				start = undefined;
-			} else {
-				timed.state.finished = true;
-
-				timed.stop();
-
-				return;
-			}
-		}
-
-		timed.state.frame = request(step);
-	}
-
-	timed.state.frame = request(step);
-}
-
-class Timed {
-	get active() {
-		return this.state.active;
-	}
-
-	get finished() {
-		return !this.active && this.state.finished;
-	}
-
-	/**
-	 * @param {RepeatedCallback} callback
-	 * @param {number} time
-	 * @param {number} count
-	 * @param {AfterCallback|undefined} 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",
-			);
-		}
-
-		/**
-		 * @readonly
-		 * @type {{count: number; time: number}}
-		 */
-		this.configuration = {count, time};
-
-		/**
-		 * @readonly
-		 * @type {{after: AfterCallback | undefined; default: RepeatedCallback}}
-		 */
-		this.callbacks = {
-			after: afterCallback,
-			default: callback,
-		};
-
-		/**
-		 * @readonly
-		 * @type {{active: boolean; finished: boolean; frame?: DOMHighResTimeStamp}}
-		 */
-		this.state = {
-			active: false,
-			finished: false,
-			frame: null,
-		};
-	}
-
-	restart() {
-		this.stop();
-
-		run(this);
-
-		return this;
-	}
-
-	start() {
-		if (!this.state.active) {
-			run(this);
-		}
-
-		return this;
-	}
-
-	stop() {
-		this.state.active = false;
-
-		if (this.state.frame === undefined) {
-			return this;
-		}
-
-		(cancelAnimationFrame ?? clearTimeout)?.(this.state.frame);
-
-		this.callbacks.after?.(this.finished);
-
-		this.state.frame = undefined;
-
-		return this;
-	}
-}
-
-export class Repeated extends Timed {}
-
-export class Waited extends Timed {
-	/**
-	 * @param {Function} callback
-	 * @param {number} time
-	 */
-	constructor(callback, time) {
-		super(callback, time, 1, null);
-	}
-}
-
-/**
- * @param {RepeatedCallback} callback
- * @param {number} time
- * @param {number} count
- * @param {AfterCallback|undefined} afterCallback
- * @return {Repeated} A repeated timer
- */
-export function repeat(callback, time, count, afterCallback) {
-	return new Repeated(callback, time, count, afterCallback).start();
-}
-
-/**
- * @param {Function} callback
- * @param {number} time
- * @return {Waited} A waited timer
- */
-export function wait(callback, time) {
-	return new Waited(callback, time).start();
-}