@oscarpalmer/timer 0.16.0 → 0.18.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.
 

package/dist/timer.iife.js

@@ -1 +1,169 @@
-var Timer=(()=>{var c=Object.defineProperty;var v=Object.getOwnPropertyDescriptor;var w=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var g=(t,e)=>{for(var s in e)c(t,s,{get:e[s],enumerable:!0})},y=(t,e,s,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of w(e))!b.call(t,i)&&i!==s&&c(t,i,{get:()=>e[i],enumerable:!(n=v(e,i))||n.enumerable});return t};var x=t=>y(c({},"__esModule",{value:!0}),t);var E={};g(E,{Repeated:()=>r,Waited:()=>f,repeat:()=>T,wait:()=>A});var h=Math.round(16.666666666666668),l=globalThis.requestAnimationFrame??function(t){return setTimeout?.(()=>{t(Date.now())},h)};function p(t){t.state.active=!0,t.state.finished=!1;let e=t instanceof r,s=0,n;function i(a){if(!t.state.active)return;n??(n=a);let o=a-n,d=o-h,m=o+h;if(d<t.configuration.time&&t.configuration.time<m)if(t.state.active&&t.callbacks.default(e?s:void 0),s+=1,e&&s<t.configuration.count)n=void 0;else{t.state.finished=!0,t.stop();return}t.state.frame=l(i)}t.state.frame=l(i)}var u=class{get active(){return this.state.active}get finished(){return!this.active&&this.state.finished}constructor(e,s,n,i){let a=this instanceof r,o=a?"repeated":"waited";if(typeof e!="function")throw new TypeError(`A ${o} timer must have a callback function`);if(typeof s!="number"||s<0)throw new TypeError(`A ${o} timer must have a non-negative number as its time`);if(a&&(typeof n!="number"||n<2))throw new TypeError("A repeated timer must have a number above 1 as its repeat count");if(a&&i!==void 0&&typeof i!="function")throw new TypeError("A repeated timer's after-callback must be a function");this.configuration={count:n,time:s},this.callbacks={after:i,default:e},this.state={active:!1,finished:!1,frame:null}}restart(){return this.stop(),p(this),this}start(){return this.state.active||p(this),this}stop(){return this.state.active=!1,this.state.frame===void 0?this:((globalThis.cancelAnimationFrame??clearTimeout)?.(this.state.frame),this.callbacks.after?.(this.finished),this.state.frame=void 0,this)}},r=class extends u{},f=class extends u{constructor(e,s){super(e,s,1,null)}};function T(t,e,s,n){return new r(t,e,s,n).start()}function A(t,e){return new f(t,e).start()}return x(E);})();
+var Timer = (function (exports) {
+	('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();
+					return;
+				}
+			}
+			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);
+		}
+		/**
+		 * @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,
+				frame: undefined,
+			});
+		}
+		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;
+			}
+			(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
+		 * @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,170 @@
-// src/index.js
-var milliseconds = Math.round(1e3 / 60);
-var request = globalThis.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);
+const 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);
+	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 = request(step);
+	}
+	timedState.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;
-    }
-    (globalThis.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,
+			frame: undefined,
+		});
+	}
+	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;
+		}
+		(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
+	 * @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,23 +6,18 @@
 	"browser": "dist/timer.iife.js",
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"esbuild": "^0.17",
-		"xo": "^0.54"
-	},
-	"exports": {
-		".": {
-			"types": "./src/index.d.ts",
-			"browser": "./dist/timer.iife.js",
-			"module": "./dist/timer.js",
-			"import": "./dist/timer.js",
-			"require": "./dist/timer.cjs",
-			"default": "./dist/timer.js"
-		},
-		"./package.json": "./package.json"
+		"@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": [
@@ -32,23 +27,42 @@
 		"requestAnimationFrame"
 	],
 	"license": "MIT",
-	"main": "dist/timer.cjs",
+	"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:cjs; npm run build:esm; npm run build:iife; npm run types",
-		"build:cjs": "esbuild ./src/index.js --bundle --format=cjs --outfile=./dist/timer.cjs --target=es2020",
-		"build:esm": "esbuild ./src/index.js --bundle --format=esm --outfile=./dist/timer.js --target=es2020",
-		"build:iife": "esbuild ./src/index.js --bundle --minify --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.16.0"
-}
+	"version": "0.18.0",
+	"xo": {
+		"envs": [
+			"browser"
+		],
+		"prettier": true,
+		"rules": {
+			"import/extensions": "off",
+			"import/no-cycle": "off"
+		}
+	}
+}

package/src/index.ts

@@ -0,0 +1,239 @@
+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?: DOMHighResTimeStamp;
+};
+
+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);
+
+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)!;
+	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) {
+		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 = request(step) as never;
+	}
+
+	timedState.frame = request(step) as never;
+}
+
+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: () => void | ((index: number) => void),
+		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,
+		});
+
+		configuration.set(this as never, {count, time});
+
+		state.set(this as never, {
+			active: false,
+			finished: false,
+			frame: undefined,
+		});
+	}
+
+	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;
+		}
+
+		(cancelAnimationFrame ?? clearTimeout)?.(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/dist/timer.cjs

@@ -1,148 +0,0 @@
-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);
-
-// src/index.js
-var src_exports = {};
-__export(src_exports, {
-  Repeated: () => Repeated,
-  Waited: () => Waited,
-  repeat: () => repeat,
-  wait: () => wait
-});
-module.exports = __toCommonJS(src_exports);
-var milliseconds = Math.round(1e3 / 60);
-var request = globalThis.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;
-    }
-    (globalThis.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();
-}

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,209 +0,0 @@
-/**
- * @callback AfterCallback
- * @param {boolean} finished
- * @returns {void}
- */
-
-/**
- * @callback RepeatedCallback
- * @param {number} index
- * @returns {void}
- */
-
-const milliseconds = Math.round(1000 / 60);
-
-const request = globalThis.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;
-		}
-
-		(globalThis.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();
-}