@oscarpalmer/timer 0.2.0 → 0.3.0

package/.eslintrc.json

@@ -0,0 +1,44 @@
+{
+	"root": true,
+	"extends": [
+		"xo",
+		"xo-typescript"
+	],
+	"parser": "@typescript-eslint/parser",
+	"parserOptions": {
+		"project": [
+			"./tsconfig.json"
+		]
+	},
+	"plugins": [
+		"@typescript-eslint"
+	],
+	"rules": {
+		"@typescript-eslint/member-ordering": [
+			"error",
+			{
+				"default": [
+					"signature",
+
+					"private-decorated-field", "protected-decorated-field", "public-decorated-field", "decorated-field",
+
+					"private-static-field", "protected-static-field", "public-static-field", "static-field",
+
+					["private-abstract-field", "private-instance-field", "private-field"],
+					["protected-abstract-field", "protected-instance-field", "protected-field"],
+					["public-abstract-field", "public-instance-field", "public-field"],
+					["abstract-field", "instance-field", "field"],
+
+					"private-constructor", "protected-constructor", "public-constructor", "constructor",
+
+					["public-abstract-method", "public-decorated-method", "public-instance-method", "public-method"],
+					["protected-abstract-method", "protected-decorated-method", "protected-instance-method", "protected-method"],
+					["private-abstract-method", "private-decorated-method", "private-instance-method", "private-method"],
+					["abstract-method", "decorated-method", "instance-method", "method"],
+
+					"static-method", "public-static-method", "protected-static-method", "private-static-method"
+				]
+			}
+		]
+	},
+}

package/dist/timer.js

@@ -1 +1,79 @@
 "use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/index.ts
+var Timed = class {
+  constructor(callback, time, count) {
+    this.callback = callback;
+    this.time = time;
+    this.count = count;
+    __publicField(this, "frame");
+    __publicField(this, "stopped", false);
+    Timed.run(this);
+  }
+  restart() {
+    this.stop();
+    this.stopped = false;
+    Timed.run(this);
+  }
+  start() {
+    if (this.stopped) {
+      Timed.run(this);
+    }
+  }
+  stop() {
+    this.stopped = true;
+    if (typeof this.frame === "undefined") {
+      return;
+    }
+    window.cancelAnimationFrame(this.frame);
+    this.frame = void 0;
+  }
+  static run(timed) {
+    const repeated = timed.count > 1;
+    let count = 0;
+    let start;
+    function step(timestamp) {
+      if (timed.stopped) {
+        return;
+      }
+      start ?? (start = timestamp);
+      const elapsed = timestamp - start;
+      if (elapsed >= timed.time) {
+        if (!timed.stopped) {
+          timed.callback(repeated ? count : void 0);
+        }
+        count += 1;
+        if (timed.count > 1 && count < timed.count) {
+          start = void 0;
+        } else {
+          return;
+        }
+      }
+      timed.frame = window.requestAnimationFrame(step);
+    }
+    timed.frame = window.requestAnimationFrame(step);
+  }
+};
+var Repeated = class extends Timed {
+};
+var Waited = class extends Timed {
+};
+var Timer = class {
+  static repeat(callback, time, count) {
+    return new Repeated(callback, time, count);
+  }
+  static wait(callback, time) {
+    return new Waited(callback, time, 1);
+  }
+};
+export {
+  Repeated,
+  Timer,
+  Waited
+};

package/package.json

@@ -6,21 +6,15 @@
 	"description": "A better timer?",
 	"devDependencies": {
 		"@tsconfig/recommended": "^1.0.0",
-		"@types/node": "^17.0.0",
+		"@types/node": "^18.0.0",
 		"@typescript-eslint/eslint-plugin": "^5.30.0",
 		"@typescript-eslint/parser": "^5.30.0",
 		"esbuild": "^0.14.0",
-		"eslint": "^8.18.0",
+		"eslint": "^8.19.0",
 		"eslint-config-xo": "^0.41.0",
 		"eslint-config-xo-typescript": "^0.51.0",
 		"typescript": "^4.7.0"
 	},
-	"eslintConfig": {
-		"extends": [
-			"xo",
-			"xo-typescript/space"
-		]
-	},
 	"exports": {
 		".": {
 			"import": "./dist/timer.js",
@@ -43,8 +37,9 @@
 		"url": "git+https://github.com/oscarpalmer/timer.git"
 	},
 	"scripts": {
-		"build": "esbuild ./src/index.ts --bundle --target=es2020 --platform=browser --outfile=dist/timer.js --format=esm"
+    "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"
 	},
 	"unpkg": "dist/timer.js",
-	"version": "0.2.0"
+	"version": "0.3.0"
 }

package/src/index.d.ts

@@ -0,0 +1,17 @@
+type RepeatedCallback = (index: number) => void;
+type WaitedCallback = () => void;
+
+interface Timed<Callback> {
+	constructor(callback: Callback, time: number, count: number): void;
+	restart(): void;
+	start(): void;
+	stop(): void;
+}
+
+export interface Repeated extends Timed<RepeatedCallback> {}
+export interface Waited extends Timed<WaitedCallback> {}
+
+export interface Timer {
+	repeated(callback: RepeatedCallback, time: number, count: number): Repeated;
+	waited(callback: WaitedCallback, time: number): Waited;
+}

package/src/index.ts

@@ -0,0 +1,91 @@
+type RepeatedCallback = (index: number) => void;
+type WaitedCallback = () => void;
+
+abstract class Timed<Callback> {
+	private frame: number | undefined;
+	private stopped = false;
+
+	constructor(
+		private readonly callback: Callback,
+		private readonly time: number,
+		private readonly count: number,
+	) {
+		Timed.run(this);
+	}
+
+	restart(): void {
+		this.stop();
+
+		this.stopped = false;
+
+		Timed.run(this);
+	}
+
+	start(): void {
+		if (this.stopped) {
+			Timed.run(this);
+		}
+	}
+
+	stop(): void {
+		this.stopped = true;
+
+		if (typeof this.frame === 'undefined') {
+			return;
+		}
+
+		window.cancelAnimationFrame(this.frame);
+
+		this.frame = undefined;
+	}
+
+	private static run(timed: Timed<(index: number | undefined) => void>): void {
+		const repeated = timed.count > 1;
+
+		let count = 0;
+
+		let start: DOMHighResTimeStamp | undefined;
+
+		function step(timestamp: DOMHighResTimeStamp): void {
+			if (timed.stopped) {
+				return;
+			}
+
+			start ??= timestamp;
+
+			const elapsed = timestamp - start;
+
+			if (elapsed >= timed.time) {
+				if (!timed.stopped) {
+					timed.callback(repeated ? count : undefined);
+				}
+
+				count += 1;
+
+				if (timed.count > 1 && count < timed.count) {
+					start = undefined;
+				} else {
+					return;
+				}
+			}
+
+			timed.frame = window.requestAnimationFrame(step);
+		}
+
+		timed.frame = window.requestAnimationFrame(step);
+	}
+}
+
+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);
+	}
+
+	static wait(callback: WaitedCallback, time: number): Waited {
+		return new Waited(callback, time, 1);
+	}
+}

package/tsconfig.json

@@ -26,6 +26,6 @@
 		"target": "ES2020",
 		"useDefineForClassFields": true
 	},
-	"include": ["src/**/*"],
-	"exclude": ["dist", "node_modules"]
+	"include": ["src/**/*.ts"],
+	"exclude": ["src/**/*.d.ts", "dist", "node_modules"]
 }