@oscarpalmer/timer 0.3.0 → 0.4.0

package/dist/timer.js

@@ -7,51 +7,74 @@ var __publicField = (obj, key, value) => {
 };
 
 // src/index.ts
+var milliseconds = 1e3 / 60;
 var Timed = class {
-  constructor(callback, time, count) {
+  constructor(type, callback, time, count) {
+    __publicField(this, "callback");
+    __publicField(this, "count");
+    __publicField(this, "frame");
+    __publicField(this, "running", false);
+    __publicField(this, "time");
+    __publicField(this, "type");
+    if (typeof callback !== "function") {
+      throw new Error(`A ${type} timer must have a callback function`);
+    }
+    if (typeof time !== "number" || time < 0) {
+      throw new Error(`A ${type} timer must have a non-negative number as its time`);
+    }
+    if (type === "repeated" && (typeof count !== "number" || count < 2)) {
+      throw new Error(`A ${type} timer must have a number above 1 as its repeat count`);
+    }
+    this.type = type;
     this.callback = callback;
     this.time = time;
     this.count = count;
-    __publicField(this, "frame");
-    __publicField(this, "stopped", false);
-    Timed.run(this);
+  }
+  get active() {
+    return this.running;
   }
   restart() {
     this.stop();
-    this.stopped = false;
     Timed.run(this);
+    return this;
   }
   start() {
-    if (this.stopped) {
-      Timed.run(this);
+    if (this.running) {
+      return this;
     }
+    Timed.run(this);
+    return this;
   }
   stop() {
-    this.stopped = true;
+    this.running = false;
     if (typeof this.frame === "undefined") {
-      return;
+      return this;
     }
     window.cancelAnimationFrame(this.frame);
     this.frame = void 0;
+    return this;
   }
   static run(timed) {
-    const repeated = timed.count > 1;
+    timed.running = true;
     let count = 0;
     let start;
     function step(timestamp) {
-      if (timed.stopped) {
+      if (!timed.running) {
         return;
       }
       start ?? (start = timestamp);
       const elapsed = timestamp - start;
-      if (elapsed >= timed.time) {
-        if (!timed.stopped) {
-          timed.callback(repeated ? count : void 0);
+      const elapsedMinimum = elapsed - milliseconds;
+      const elapsedMaximum = elapsed + milliseconds;
+      if (elapsedMinimum < timed.time && timed.time < elapsedMaximum) {
+        if (timed.running) {
+          timed.callback(timed.type === "repeated" ? count : void 0);
         }
         count += 1;
-        if (timed.count > 1 && count < timed.count) {
+        if (timed.type === "repeated" && count < timed.count) {
           start = void 0;
         } else {
+          timed.stop();
           return;
         }
       }
@@ -61,15 +84,21 @@ var Timed = class {
   }
 };
 var Repeated = class extends Timed {
+  constructor(callback, time, count) {
+    super("repeated", callback, time, count);
+  }
 };
 var Waited = class extends Timed {
-};
-var Timer = class {
-  static repeat(callback, time, count) {
-    return new Repeated(callback, time, count);
+  constructor(callback, time) {
+    super("waited", callback, time, 1);
   }
-  static wait(callback, time) {
-    return new Waited(callback, time, 1);
+};
+var Timer = {
+  repeat: (callback, time, count) => {
+    return new Repeated(callback, time, count).start();
+  },
+  wait: (callback, time) => {
+    return new Waited(callback, time).start();
   }
 };
 export {

package/package.json

@@ -40,6 +40,7 @@
     "build": "esbuild ./src/index.ts --bundle --target=es2020 --platform=browser --outfile=./dist/timer.js --format=esm",
 		"watch": "esbuild ./src/index.ts --bundle --target=es2020 --platform=browser --outfile=./dist/timer.js --format=esm --watch"
 	},
+	"type": "module",
 	"unpkg": "dist/timer.js",
-	"version": "0.3.0"
+	"version": "0.4.0"
 }

package/src/index.d.ts

@@ -2,6 +2,7 @@ type RepeatedCallback = (index: number) => void;
 type WaitedCallback = () => void;
 
 interface Timed<Callback> {
+	get active(): boolean;
 	constructor(callback: Callback, time: number, count: number): void;
 	restart(): void;
 	start(): void;

package/src/index.ts

@@ -1,53 +1,81 @@
 type RepeatedCallback = (index: number) => void;
+type TimerType = 'repeated' | 'waited';
 type WaitedCallback = () => void;
 
+const milliseconds = 1000 / 60;
+
 abstract class Timed<Callback> {
+	private readonly callback: Callback;
+	private readonly count: number;
 	private frame: number | undefined;
-	private stopped = false;
-
-	constructor(
-		private readonly callback: Callback,
-		private readonly time: number,
-		private readonly count: number,
-	) {
-		Timed.run(this);
+	private running = false;
+	private readonly time: number;
+	private readonly type: TimerType;
+
+	get active(): boolean {
+		return this.running;
+	}
+
+	protected constructor(type: TimerType, callback: Callback, time: number,	count: number) {
+		if (typeof callback !== 'function') {
+			throw new Error(`A ${type} timer must have a callback function`);
+		}
+
+		if (typeof time !== 'number' || time < 0) {
+			throw new Error(`A ${type} timer must have a non-negative number as its time`);
+		}
+
+		if (type === 'repeated' && (typeof count !== 'number' || count < 2)) {
+			throw new Error(`A ${type} timer must have a number above 1 as its repeat count`);
+		}
+
+		this.type = type;
+		this.callback = callback;
+		this.time = time;
+		this.count = count;
 	}
 
-	restart(): void {
+	restart(): Timed<Callback> {
 		this.stop();
 
-		this.stopped = false;
+		Timed.run(this as never);
 
-		Timed.run(this);
+		return this;
 	}
 
-	start(): void {
-		if (this.stopped) {
-			Timed.run(this);
+	start(): Timed<Callback> {
+		if (this.running) {
+			return this;
 		}
+
+		Timed.run(this as never);
+
+		return this;
 	}
 
-	stop(): void {
-		this.stopped = true;
+	stop(): Timed<Callback> {
+		this.running = false;
 
 		if (typeof this.frame === 'undefined') {
-			return;
+			return this;
 		}
 
 		window.cancelAnimationFrame(this.frame);
 
 		this.frame = undefined;
+
+		return this;
 	}
 
 	private static run(timed: Timed<(index: number | undefined) => void>): void {
-		const repeated = timed.count > 1;
+		timed.running = true;
 
 		let count = 0;
 
 		let start: DOMHighResTimeStamp | undefined;
 
 		function step(timestamp: DOMHighResTimeStamp): void {
-			if (timed.stopped) {
+			if (!timed.running) {
 				return;
 			}
 
@@ -55,16 +83,21 @@ abstract class Timed<Callback> {
 
 			const elapsed = timestamp - start;
 
-			if (elapsed >= timed.time) {
-				if (!timed.stopped) {
-					timed.callback(repeated ? count : undefined);
+			const elapsedMinimum = elapsed - milliseconds;
+			const elapsedMaximum = elapsed + milliseconds;
+
+			if (elapsedMinimum < timed.time && timed.time < elapsedMaximum) {
+				if (timed.running) {
+					timed.callback(timed.type === 'repeated' ? count : undefined);
 				}
 
 				count += 1;
 
-				if (timed.count > 1 && count < timed.count) {
+				if (timed.type === 'repeated' && count < timed.count) {
 					start = undefined;
 				} else {
+					timed.stop();
+
 					return;
 				}
 			}
@@ -76,16 +109,24 @@ abstract class Timed<Callback> {
 	}
 }
 
-export class Repeated extends Timed<RepeatedCallback> {}
-export class Waited extends Timed<WaitedCallback> {}
-
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export class Timer {
-	static repeat(callback: RepeatedCallback, time: number, count: number): Repeated {
-		return new Repeated(callback, time, count);
+export class Repeated extends Timed<RepeatedCallback> {
+	constructor(callback: RepeatedCallback, time: number, count: number) {
+		super('repeated', callback, time, count);
 	}
+}
 
-	static wait(callback: WaitedCallback, time: number): Waited {
-		return new Waited(callback, time, 1);
+export class Waited extends Timed<WaitedCallback> {
+	constructor(callback: WaitedCallback, time: number) {
+		super('waited', callback, time, 1);
 	}
 }
+
+export const Timer = {
+	repeat: (callback: RepeatedCallback, time: number, count: number): Repeated => {
+		return (new Repeated(callback, time, count)).start();
+	},
+
+	wait: (callback: WaitedCallback, time: number): Waited => {
+		return (new Waited(callback, time)).start();
+	},
+}

package/test/index.html

@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<meta charset="utf-8" />
+		<title>Mocha Tests</title>
+		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<link rel="stylesheet" href="https://unpkg.com/mocha/mocha.css" />
+	</head>
+	<body>
+		<div id="mocha"></div>
+
+		<script src="https://unpkg.com/chai/chai.js"></script>
+		<script src="https://unpkg.com/mocha/mocha.js"></script>
+
+		<script class="mocha-init">
+			mocha.setup('bdd');
+			mocha.checkLeaks();
+		</script>
+		<script src="test/test.js" type="module"></script>
+		<script class="mocha-exec">
+			mocha.run();
+		</script>
+	</body>
+</html>

package/test/test.js

@@ -0,0 +1,121 @@
+import {Repeated, Timer, Waited} from '../dist/timer.js';
+
+describe('Timer, factory', function () {
+  it('should create and start a repeated timer', function () {
+		chai.assert.ok(Timer.repeat(() => {}, 0, 2) instanceof Repeated);
+	});
+
+	it('should create and start a waited timer', function () {
+		chai.assert.ok(Timer.wait(() => {}, 0) instanceof Waited);
+	});
+});
+
+describe('Timer, Repeated', function () {
+	describe('Constructor', function () {
+		it('should create a proper repeated timer', function () {
+			chai.assert.ok(new Repeated(() => {}, 0, 2) instanceof Repeated);
+		});
+	
+		it('should handle bad parameters', function () {
+			chai.assert.throws(function () { new Repeated(null, null, null); }, /callback/);
+			chai.assert.throws(function () { new Repeated(() => {}, null, null); }, /time/);
+			chai.assert.throws(function () { new Repeated(() => {}, 0, null); }, /count/);
+			chai.assert.throws(function () { new Repeated(() => {}, 0, 1); }, /count/);
+		});
+	});
+
+	describe('Run', function () {
+		it('should run as many times as set', function (done) {
+			let value = 0;
+
+			Timer.repeat(() => {
+				value += 1;
+			}, 25, 10);
+
+			Timer.wait(() => {
+				chai.assert.equal(value, 10);
+
+				done();
+			}, 500);
+		});
+
+		it('should run until canceled', function (done) {
+			let value = 0;
+
+			const repeated = Timer.repeat(() => {
+				value += 1;
+			}, 25, 10);
+
+			Timer.wait(() => {
+				repeated.stop();
+			}, 125);
+
+			Timer.wait(() => {
+				chai.assert.ok(value < 10);
+
+				done();
+			}, 500);
+		});
+	});
+});
+
+describe('Timer, Waited', function () {
+	describe('Constructor', function () {
+		it('should create a proper waited timer', function () {
+			chai.assert.ok(new Waited(() => {}, 0));
+		});
+	
+		it('should handle bad parameters', function () {
+			chai.assert.throws(function () { new Waited(null, null); }, /callback/);
+			chai.assert.throws(function () { new Waited(() => {}, null); }, /time/);
+		});
+	});
+});
+
+describe('Timer, Repeated & Waited', function () {
+	describe('Methods', function () {
+		it('should be able to start', function (done) {
+			(new Waited(() => {
+				done();
+			}, 125)).start();
+		});
+	
+		it('should be able to stop', function (done) {
+			let value = 0;
+	
+			const waited = new Waited(() => {
+				value = 1234;
+			}, 125);
+	
+			Timer.wait(() => {
+				waited.stop();
+			}, 250);
+	
+			Timer.wait(() => {
+				chai.assert.equal(value, 0);
+	
+				done();
+			}, 375);
+		});
+	
+		it('should be able to restart', function (done) {
+			let value = 0;
+	
+			const waited = new Waited(() => {
+				value += 1;
+			}, 125);
+	
+			waited.start();
+	
+			Timer.wait(() => {
+				waited.restart();
+			}, 250);
+	
+			Timer.wait(() => {
+				chai.assert.equal(value, 2);
+	
+				done();
+			}, 500);
+		});
+	});
+});