@oscarpalmer/timer 0.13.0 → 0.15.0

package/dist/timer.cjs

@@ -40,7 +40,7 @@ function run(timed) {
   timed.state.active = true;
   timed.state.finished = false;
   const isRepeated = timed instanceof Repeated;
-  let count = 0;
+  let index = 0;
   let start;
   function step(timestamp) {
     if (!timed.state.active) {
@@ -52,10 +52,10 @@ function run(timed) {
     const elapsedMaximum = elapsed + milliseconds;
     if (elapsedMinimum < timed.configuration.time && timed.configuration.time < elapsedMaximum) {
       if (timed.state.active) {
-        timed.callbacks.default(isRepeated ? count : void 0);
+        timed.callbacks.default(isRepeated ? index : void 0);
       }
-      count += 1;
-      if (isRepeated && count < timed.configuration.count) {
+      index += 1;
+      if (isRepeated && index < timed.configuration.count) {
         start = void 0;
       } else {
         timed.state.finished = true;
@@ -69,15 +69,15 @@ function run(timed) {
 }
 var Timed = class {
   /**
-   * @param {Function} callback
+   * @param {RepeatedCallback} callback
    * @param {number} time
    * @param {number} count
-   * @param {Function?} afterCallback
+   * @param {AfterCallback|undefined} afterCallback
    */
   constructor(callback, time, count, afterCallback) {
     /**
      * @readonly
-     * @type {{after?: Function; default: Function}}
+     * @type {{after: AfterCallback | undefined; default: RepeatedCallback}}
      */
     __publicField(this, "callbacks");
     /**
@@ -96,13 +96,19 @@ var Timed = class {
       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`);
+      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");
+      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");
+      throw new TypeError(
+        "A repeated timer's after-callback must be a function"
+      );
     }
     this.configuration = { count, time };
     this.callbacks = {

package/dist/timer.js

@@ -16,7 +16,7 @@ function run(timed) {
   timed.state.active = true;
   timed.state.finished = false;
   const isRepeated = timed instanceof Repeated;
-  let count = 0;
+  let index = 0;
   let start;
   function step(timestamp) {
     if (!timed.state.active) {
@@ -28,10 +28,10 @@ function run(timed) {
     const elapsedMaximum = elapsed + milliseconds;
     if (elapsedMinimum < timed.configuration.time && timed.configuration.time < elapsedMaximum) {
       if (timed.state.active) {
-        timed.callbacks.default(isRepeated ? count : void 0);
+        timed.callbacks.default(isRepeated ? index : void 0);
       }
-      count += 1;
-      if (isRepeated && count < timed.configuration.count) {
+      index += 1;
+      if (isRepeated && index < timed.configuration.count) {
         start = void 0;
       } else {
         timed.state.finished = true;
@@ -45,15 +45,15 @@ function run(timed) {
 }
 var Timed = class {
   /**
-   * @param {Function} callback
+   * @param {RepeatedCallback} callback
    * @param {number} time
    * @param {number} count
-   * @param {Function?} afterCallback
+   * @param {AfterCallback|undefined} afterCallback
    */
   constructor(callback, time, count, afterCallback) {
     /**
      * @readonly
-     * @type {{after?: Function; default: Function}}
+     * @type {{after: AfterCallback | undefined; default: RepeatedCallback}}
      */
     __publicField(this, "callbacks");
     /**
@@ -72,13 +72,19 @@ var Timed = class {
       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`);
+      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");
+      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");
+      throw new TypeError(
+        "A repeated timer's after-callback must be a function"
+      );
     }
     this.configuration = { count, time };
     this.callbacks = {

package/package.json

@@ -7,20 +7,23 @@
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
 		"esbuild": "^0.17",
-		"typescript": "^5.0",
 		"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"
+			"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"
 	},
-	"files": ["dist", "src"],
+	"files": [
+		"dist",
+		"src"
+	],
 	"jsdelivr": "dist/timer.iife.js",
 	"keywords": [
 		"timer",
@@ -41,10 +44,11 @@
 		"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"
+		"types": "./node_modules/.bin/tsc ./src/index.js --allowJs --declaration --emitDeclarationOnly --removeComments",
+		"xo": "./node_modules/.bin/xo ./src/*.js --env browser"
 	},
 	"type": "module",
 	"types": "src/index.d.ts",
 	"unpkg": "dist/timer.iife.js",
-	"version": "0.13.0"
+	"version": "0.15.0"
 }

package/src/index.d.ts

@@ -1,15 +1,17 @@
-export function repeat(callback: Function, time: number, count: number, afterCallback: Function | null): Repeated;
+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: Function, time: number, count: number, afterCallback: Function | null);
+    constructor(callback: RepeatedCallback, time: number, count: number, afterCallback: AfterCallback | undefined);
     readonly callbacks: {
-        after?: Function;
-        default: Function;
+        after: AfterCallback | undefined;
+        default: RepeatedCallback;
     };
     readonly configuration: {
         count: number;

package/src/index.js

@@ -1,10 +1,23 @@
+/**
+ * @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);
-};
+const request = globalThis.requestAnimationFrame
+	?? function (callback) {
+		return setTimeout?.(() => {
+			callback(Date.now());
+		}, milliseconds);
+	};
 
 /**
  * @param {Timed} timed
@@ -15,7 +28,7 @@ function run(timed) {
 
 	const isRepeated = timed instanceof Repeated;
 
-	let count = 0;
+	let index = 0;
 
 	let start;
 
@@ -31,14 +44,17 @@ function run(timed) {
 		const elapsedMinimum = elapsed - milliseconds;
 		const elapsedMaximum = elapsed + milliseconds;
 
-		if (elapsedMinimum < timed.configuration.time && timed.configuration.time < elapsedMaximum) {
+		if (
+			elapsedMinimum < timed.configuration.time
+			&& timed.configuration.time < elapsedMaximum
+		) {
 			if (timed.state.active) {
-				timed.callbacks.default(isRepeated ? count : undefined);
+				timed.callbacks.default(isRepeated ? index : undefined);
 			}
 
-			count += 1;
+			index += 1;
 
-			if (isRepeated && count < timed.configuration.count) {
+			if (isRepeated && index < timed.configuration.count) {
 				start = undefined;
 			} else {
 				timed.state.finished = true;
@@ -58,7 +74,7 @@ function run(timed) {
 class Timed {
 	/**
 	 * @readonly
-	 * @type {{after?: Function; default: Function}}
+	 * @type {{after: AfterCallback | undefined; default: RepeatedCallback}}
 	 */
 	callbacks;
 
@@ -85,32 +101,40 @@ class Timed {
 	}
 
 	/**
-	 * @param {Function} callback
+	 * @param {RepeatedCallback} callback
 	 * @param {number} time
 	 * @param {number} count
-	 * @param {Function?} afterCallback
+	 * @param {AfterCallback|undefined} afterCallback
 	 */
 	constructor(callback, time, count, afterCallback) {
 		const isRepeated = this instanceof Repeated;
 
-		const type = isRepeated
-			? 'repeated'
-			: 'waited';
+		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`);
+			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');
+			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');
+		if (
+			isRepeated
+			&& afterCallback !== undefined
+			&& typeof afterCallback !== 'function'
+		) {
+			throw new TypeError(
+				'A repeated timer\'s after-callback must be a function',
+			);
 		}
 
 		this.configuration = {count, time};
@@ -173,14 +197,14 @@ export class Waited extends Timed {
 }
 
 /**
- * @param {Function} callback
+ * @param {RepeatedCallback} callback
  * @param {number} time
  * @param {number} count
- * @param {Function?} afterCallback
+ * @param {AfterCallback|undefined} afterCallback
  * @return {Repeated} A repeated timer
  */
 export function repeat(callback, time, count, afterCallback) {
-	return (new Repeated(callback, time, count, afterCallback)).start();
+	return new Repeated(callback, time, count, afterCallback).start();
 }
 
 /**
@@ -189,5 +213,5 @@ export function repeat(callback, time, count, afterCallback) {
  * @return {Waited} A waited timer
  */
 export function wait(callback, time) {
-	return (new Waited(callback, time)).start();
+	return new Waited(callback, time).start();
 }