@oscarpalmer/timer 0.18.0 → 0.20.0

package/README.md

@@ -8,8 +8,6 @@ A better solution for timeout- and interval-based timers.
 
 Timer is available on _npm_ as [`@oscarpalmer/timer`](https://www.npmjs.com/package/@oscarpalmer/timer) to be bundled with your awesome projects.
 
-If you don't need to bundle things, you can use the CDN-version and include a script in your proejcts right away, thanks to [jsDelivr](https://www.jsdelivr.com/package/npm/@oscarpalmer/timer) and  [UNPKG](https://unpkg.com/@oscarpalmer/timer).
-
 ## Getting started
 
 This is fairly lightweight package, so hopefully you'll be up and running in seconds :blush:
@@ -21,55 +19,62 @@ The timers can be called with nice helper methods, which also auto-starts the ti
 ```typescript
 import {repeat, wait} from '@oscarpalmer/timer';
 
-let waited = wait(callback, time);
-let repeated = repeat(callback, time, count);
+const waited = wait(waitedCallback);
+const repeated = repeat(repeatedCallback, 10);
 ```
 
-Or they can be created using class syntax, but without being auto-started:
+Or they can be created using the `new`-keyword, but without being auto-started:
 
 ```typescript
-import {Repeated, Waited} from '@oscarpalmer/timer';
+import {Timer} from '@oscarpalmer/timer';
 
-waited = new Waited(callback, time);
-repeated = new Repeated(callback, time, count);
+const waited = new Timer(waitedCallback);
+const repeated = new Timer(repeatedCallback, 10);
 ```
 
-### CDN & IIFE
+## Parameters
 
-If you're using Timer by including the file suffixed with `.iife.js` – or one of the CDN-versions mentioned above – you won't have to import any of the classes or methods.
+When creating a _Timer_, either with the new `new`-keyword or using the functions, you can configure the timer with a few parameters:
 
-Instead, just include a `script`-tag in your HTML linking to Timer and you can access Timer in other scripts, as below:
+|Parameter|Description|
+|--------:|:----------|
+|`callback`|Callback function to be invoked for each run that are __required__ for all timers.<br>For more information on callbacks, please read [the callbacks section](#callbacks).|
+|`count`|How many times the timer should run.<br>If no value is provided, it will default to `1` when using the `new`-keyword and the `wait`-method, but throws an error for the `repeat`-method.|
+|`time`|How many milliseconds between each invokations of the provided callback.<br>Defaults to `0`, which is not really _0_ milliseconds, but close enough :wink:|
+|`after`|A callback to run after the timer finishes, both when cancelled and completed.<br>If _count_ is greater than `1` and _after_ __is not__ `undefined`, a function is expected.|
 
-```javascript
-// With auto-start
-var waited = Timer.wait(callback, time);
-var repeated = Timer.repeat(callback, time, count);
+## Methods and properties
 
-// With manual start
-waited = new Timer.Waited(callback, time);
-repeated = new Timer.Repeated(callback, time, count);
-```
+An instance of _Timer_ also has a few helpful methods and properties:
 
-## Methods
+|Name|Type|Description|
+|---:|----|:----------|
+|`active`|_Property_|A `boolean` value to check if the timer is running|
+|`finished`|_Property_|A `boolean` value to check if the timer was able to finish|
+|`start()`|_Method_|Starts the timer.<br>Necessary when creating a timer using the class syntax _(e.g. `new Waited...`)_, but helpful when the timer needs to be started at other times, as well.|
+|`stop()`|_Method_|Stops the timer|
+|`restart()`|_Method_|Restarts the timer|
 
-Both the nice helper methods and the class syntax create similar objects – `Waited` and `Repeated` – which share methods:
+## Callbacks
 
-|Method|Description|
-|-----:|:----------|
-|`start()`|Starts the timer: necessary when creating a timer using the class syntax _(e.g. `new Waited...`)_, but helpful when the timer needs to be started at other times, as well|
-|`stop()`|Stops the timer|
-|`restart()`|Restarts the timer|
+Callbacks for both waited and repeated timers receive one parameter:
 
-## Callbacks
+```typescript
+function callback(index) {
+	// 'index' is the current step
+	// starts at 0, goes up to a maximum of count - 1
+	// for this example: 0 → 9
+};
+```
 
-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:
+When you create a repeated timer, you can also provide a callback to run when the timer stops, as below:
 
 ```typescript
 function after(finished: boolean) {
 	// Let's do something fun!
 }
 
-repeat(() => {}, 0, 10, after);
+repeat(() => {}, 10, after);
 ```
 
 The `finished`-parameter for the `after`-function can be used to determine if the timer was stopped manually, or if it was able to finish its work.

package/dist/timer.js

@@ -1,170 +1,111 @@
-/**
- * @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) {
-	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);
+// src/index.ts
+var run = function(timer) {
+  const { _configuration, _state } = timer;
+  _state.active = true;
+  _state.finished = false;
+  const isRepeated = _configuration.count > 1;
+  let index = 0;
+  let start;
+  function step(timestamp) {
+    if (!_state.active) {
+      return;
+    }
+    start ??= timestamp;
+    const elapsed = timestamp - start;
+    const elapsedMinimum = elapsed - milliseconds;
+    const elapsedMaximum = elapsed + milliseconds;
+    if (elapsedMinimum < _configuration.time && _configuration.time < elapsedMaximum) {
+      if (_state.active) {
+        _configuration.callbacks.default(index);
+      }
+      index += 1;
+      if (isRepeated && index < _configuration.count) {
+        start = undefined;
+      } else {
+        _state.finished = true;
+        timer.stop();
+        return;
+      }
+    }
+    _state.frame = requestAnimationFrame(step);
+  }
+  _state.frame = requestAnimationFrame(step);
+};
+function repeat(callback, count, afterOrTime, after) {
+  if (typeof count !== "number" || count < 2) {
+    throw new TypeError("A repeated timer must have a number greater than or equal to 2 as its run count");
+  }
+  const afterOrTimeIsFunction = typeof afterOrTime === "function";
+  return new Timer(callback, afterOrTimeIsFunction ? 0 : afterOrTime, count, afterOrTimeIsFunction ? afterOrTime : after).start();
 }
-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();
+  return new Timer(callback, time).start();
 }
+var milliseconds = Math.round(16.666666666666668);
 
-export {Repeated, Waited, repeat, wait};
+class Timer {
+  get active() {
+    return this._state.active;
+  }
+  get finished() {
+    return this._state.finished;
+  }
+  constructor(callback, time, count, afterCallback) {
+    if (typeof callback !== "function") {
+      throw new TypeError("A timer must have a callback function");
+    }
+    const actualTime = typeof time === "number" ? time : 0;
+    if (actualTime < 0) {
+      throw new TypeError("A timer must have a non-negative number as its time");
+    }
+    const actualCount = typeof count === "number" ? count : 1;
+    if (actualCount < 1) {
+      throw new TypeError("A timer must have a number greater than or equal to 1 as its run count");
+    }
+    if (actualCount > 1 && afterCallback !== undefined && typeof afterCallback !== "function") {
+      throw new TypeError("A repeated timer's after-callback must be a function");
+    }
+    Object.defineProperty(this, "_configuration", {
+      value: {
+        callbacks: {
+          after: afterCallback,
+          default: callback
+        },
+        count: actualCount,
+        time: actualTime
+      }
+    });
+    Object.defineProperty(this, "_state", {
+      value: {
+        active: false,
+        finished: false
+      }
+    });
+  }
+  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(this._state.frame);
+    this._configuration.callbacks.after?.(this._state.finished);
+    this._state.frame = undefined;
+    return this;
+  }
+}
+export {
+  wait,
+  repeat,
+  Timer
+};

package/package.json

@@ -3,31 +3,17 @@
 		"name": "Oscar Palmér",
 		"url": "https://oscarpalmer.se"
 	},
-	"browser": "dist/timer.iife.js",
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"@happy-dom/global-registrator": "^11.0",
-		"@rollup/plugin-typescript": "^11.1",
+		"@biomejs/biome": "^1.4",
+		"@happy-dom/global-registrator": "^12.10",
 		"bun": "^1.0",
-		"prettier": "^3.0",
-		"rollup": "^3.29",
-		"typescript": "^5.2",
-		"xo": "^0.56"
+		"typescript": "^5.3"
 	},
-	"files": [
-		"dist",
-		"src",
-		"types"
-	],
-	"jsdelivr": "dist/timer.iife.js",
-	"keywords": [
-		"timer",
-		"setTimeout",
-		"setInterval",
-		"requestAnimationFrame"
-	],
+	"files": ["dist", "src", "types"],
+	"keywords": ["timer", "setTimeout", "setInterval", "requestAnimationFrame"],
 	"license": "MIT",
-	"main": "dist/timer.iife.js",
+	"main": "dist/timer.js",
 	"module": "dist/timer.js",
 	"name": "@oscarpalmer/timer",
 	"prettier": {
@@ -43,26 +29,13 @@
 		"url": "git+https://github.com/oscarpalmer/timer.git"
 	},
 	"scripts": {
-		"build": "npm run build:esm && npm run build:iife",
-		"build:esm": "rollup -c",
-		"build:iife": "rollup -c --environment ROLLUP_FORMAT:iife",
+		"build": "bun build ./src/index.ts --outfile ./dist/timer.js",
 		"test": "bun test --coverage",
-		"types": "tsc ./src/index.ts --outdir ./types --declaration --emitDeclarationOnly",
+		"types": "bunx tsc -p ./tsconfig.json",
 		"watch": "rollup -c -w",
 		"xo": "xo ./src/*.ts --env browser"
 	},
 	"type": "module",
 	"types": "src/index.d.ts",
-	"unpkg": "dist/timer.iife.js",
-	"version": "0.18.0",
-	"xo": {
-		"envs": [
-			"browser"
-		],
-		"prettier": true,
-		"rules": {
-			"import/extensions": "off",
-			"import/no-cycle": "off"
-		}
-	}
-}
+	"version": "0.20.0"
+}

package/src/index.ts

@@ -1,59 +1,41 @@
+export type AfterCallback = (finished: boolean) => void;
+
 type Callbacks = {
 	after: AfterCallback | undefined;
-	default: (index?: number) => void;
+	default: IndexedCallback;
 };
 
 type Configuration = {
+	callbacks: Callbacks;
 	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 IndexedCallback = (index: number) => void;
 
 type State = {
 	active: boolean;
 	finished: boolean;
-	frame?: DOMHighResTimeStamp;
+	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);
 
-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)!;
+function run(timer: Timer): void {
+	// @ts-expect-error Keep private status, but allow access
+	const {_configuration, _state} = timer;
 
-	timedState.active = true;
-	timedState.finished = false;
+	_state.active = true;
+	_state.finished = false;
 
-	const isRepeated = timed instanceof Repeated;
+	const isRepeated = _configuration.count > 1;
 
 	let index = 0;
 
 	let start;
 
-	function step(timestamp: DOMHighResTimeStamp) {
-		if (!timedState.active) {
+	function step(timestamp: DOMHighResTimeStamp): void {
+		if (!_state.active) {
 			return;
 		}
 
@@ -65,39 +47,42 @@ function run(timed: Timed<never, never>): void {
 		const elapsedMaximum = elapsed + milliseconds;
 
 		if (
-			elapsedMinimum < timedConfiguration.time &&
-			timedConfiguration.time < elapsedMaximum
+			elapsedMinimum < _configuration.time &&
+			_configuration.time < elapsedMaximum
 		) {
-			if (timedState.active) {
-				timedCallbacks.default(isRepeated ? index : undefined);
+			if (_state.active) {
+				_configuration.callbacks.default(index);
 			}
 
 			index += 1;
 
-			if (isRepeated && index < timedConfiguration.count) {
+			if (isRepeated && index < _configuration.count) {
 				start = undefined;
 			} else {
-				timedState.finished = true;
+				_state.finished = true;
 
-				timed.stop();
+				timer.stop();
 
 				return;
 			}
 		}
 
-		timedState.frame = request(step) as never;
+		_state.frame = requestAnimationFrame(step);
 	}
 
-	timedState.frame = request(step) as never;
+	_state.frame = requestAnimationFrame(step);
 }
 
-class Timed<Type, Callback> {
+export class Timer {
+	private declare readonly _configuration: Configuration;
+	private declare readonly _state: State;
+
 	get active(): boolean {
-		return state.get(this as never)?.active ?? false;
+		return this._state.active;
 	}
 
 	get finished(): boolean {
-		return !this.active && (state.get(this as never)?.finished ?? false);
+		return this._state.finished;
 	}
 
 	/**
@@ -107,33 +92,33 @@ class Timed<Type, Callback> {
 	 * @param {AfterCallback=} afterCallback
 	 */
 	constructor(
-		callback: () => void | ((index: number) => void),
-		time: number,
-		count: number,
+		callback: IndexedCallback,
+		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`);
+			throw new TypeError('A timer must have a callback function');
 		}
 
-		if (typeof time !== 'number' || time < 0) {
+		const actualTime = typeof time === 'number' ? time : 0;
+
+		if (actualTime < 0) {
 			throw new TypeError(
-				`A ${type} timer must have a non-negative number as its time`,
+				'A timer must have a non-negative number as its time',
 			);
 		}
 
-		if (isRepeated && (typeof count !== 'number' || count < 2)) {
+		const actualCount = typeof count === 'number' ? count : 1;
+
+		if (actualCount < 1) {
 			throw new TypeError(
-				'A repeated timer must have a number above 1 as its repeat count',
+				'A timer must have a number greater than or equal to 1 as its run count',
 			);
 		}
 
 		if (
-			isRepeated &&
+			actualCount > 1 &&
 			afterCallback !== undefined &&
 			typeof afterCallback !== 'function'
 		) {
@@ -142,98 +127,103 @@ class Timed<Type, Callback> {
 			);
 		}
 
-		callbacks.set(this as never, {
-			after: afterCallback,
-			default: callback,
+		Object.defineProperty(this, '_configuration', {
+			value: {
+				callbacks: {
+					after: afterCallback,
+					default: callback,
+				},
+				count: actualCount,
+				time: actualTime,
+			},
 		});
 
-		configuration.set(this as never, {count, time});
-
-		state.set(this as never, {
-			active: false,
-			finished: false,
-			frame: undefined,
+		Object.defineProperty(this, '_state', {
+			value: {
+				active: false,
+				finished: false,
+			},
 		});
 	}
 
-	restart(): Type {
+	restart(): Timer {
 		this.stop();
 
-		run(this as never);
+		run(this);
 
-		return this as never;
+		return this;
 	}
 
-	start(): Type {
-		if (!this.active) {
-			run(this as never);
+	start(): Timer {
+		if (!this._state.active) {
+			run(this);
 		}
 
-		return this as never;
+		return this;
 	}
 
-	stop(): Type {
-		const timedCallbacks = callbacks.get(this as never)!;
-		const timedState = state.get(this as never)!;
-
-		timedState.active = false;
+	stop(): Timer {
+		this._state.active = false;
 
-		if (timedState.frame === undefined) {
-			return this as never;
+		if (this._state.frame === undefined) {
+			return this;
 		}
 
-		(cancelAnimationFrame ?? clearTimeout)?.(timedState.frame);
-
-		timedCallbacks.after?.(this.finished);
-
-		timedState.frame = undefined;
+		cancelAnimationFrame(this._state.frame);
 
-		return this as never;
-	}
-}
+		this._configuration.callbacks.after?.(this._state.finished);
 
-/**
- * A timer that waits and runs repeatedly
- */
-export class Repeated extends Timed<Repeated, RepeatedCallback> {}
+		this._state.frame = undefined;
 
-/**
- * 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);
+		return this;
 	}
 }
 
 /**
  * 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: IndexedCallback, count: number): Timer;
 export function repeat(
-	callback: RepeatedCallback,
+	callback: IndexedCallback,
+	count: number,
+	afterCallback: AfterCallback,
+): Timer;
+export function repeat(
+	callback: IndexedCallback,
+	count: number,
 	time: number,
+): Timer;
+export function repeat(
+	callback: IndexedCallback,
 	count: number,
-	afterCallback?: AfterCallback,
-): Repeated {
-	return new Repeated(callback as never, time, count, afterCallback).start();
+	time: number,
+	afterCallback: AfterCallback,
+): Timer;
+export function repeat(
+	callback: IndexedCallback,
+	count: number,
+	afterOrTime?: number | AfterCallback,
+	after?: AfterCallback,
+): Timer {
+	if (typeof count !== 'number' || count < 2) {
+		throw new TypeError(
+			'A repeated timer must have a number greater than or equal to 2 as its run count',
+		);
+	}
+
+	const afterOrTimeIsFunction = typeof afterOrTime === 'function';
+
+	return new Timer(
+		callback,
+		afterOrTimeIsFunction ? 0 : afterOrTime,
+		count,
+		afterOrTimeIsFunction ? afterOrTime : after,
+	).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();
+export function wait(callback: IndexedCallback, time?: number): Timer {
+	return new Timer(callback, time).start();
 }

package/types/index.d.ts

@@ -1,72 +1,30 @@
-/**
- * @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);
+type IndexedCallback = (index: number) => void;
+export declare class Timer {
+    private readonly _configuration;
+    private readonly _state;
+    get active(): boolean;
+    get finished(): boolean;
+    /**
+     * @param {Callback} callback
+     * @param {number} time
+     * @param {number} count
+     * @param {AfterCallback=} afterCallback
+     */
+    constructor(callback: IndexedCallback, time?: number, count?: number, afterCallback?: AfterCallback);
+    restart(): Timer;
+    start(): Timer;
+    stop(): Timer;
 }
-
 /**
  * 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;
-
+export declare function repeat(callback: IndexedCallback, count: number): Timer;
+export declare function repeat(callback: IndexedCallback, count: number, afterCallback: AfterCallback): Timer;
+export declare function repeat(callback: IndexedCallback, count: number, time: number): Timer;
+export declare function repeat(callback: IndexedCallback, count: number, time: number, afterCallback: AfterCallback): Timer;
 /**
  * Creates and starts a new waited timer
- * @param {() => void} callback
- * @param {number} time
- * @return {Waited}
  */
-export declare function wait(callback: () => void, time: number): Waited;
+export declare function wait(callback: IndexedCallback, time?: number): Timer;
+export {};

package/dist/timer.iife.js

@@ -1,169 +0,0 @@
-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;
-})({});