@oscarpalmer/timer 0.28.0 → 0.30.0

package/dist/when.cjs

@@ -1,42 +1,56 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const _function = require("@oscarpalmer/atoms/function");
-const timer = require("./timer.cjs");
-const destroyedMessage = "Timer has already been destroyed";
-const startedMessage = "Timer has already been started";
-class When extends timer.BasicTimer {
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const _function = require('./node_modules/@oscarpalmer/atoms/dist/function.cjs');
+const constants = require('./constants.cjs');
+const get = require('./get.cjs');
+const models = require('./models.cjs');
+const timer = require('./timer.cjs');
+const work = require('./work.cjs');
+
+class When {
+  $timer = "when";
+  state;
+  /**
+   * Is the timer active?
+   */
   get active() {
-    var _a;
-    return ((_a = this.state.timer) == null ? void 0 : _a.active) ?? false;
+    return this.state.timer?.active ?? false;
   }
+  /**
+   * Is the timer destroyed?
+   */
   get destroyed() {
     return this.state.timer == null;
   }
+  /**
+   * Is the timer paused?
+   */
   get paused() {
-    var _a;
-    return ((_a = this.state.timer) == null ? void 0 : _a.paused) ?? false;
+    return this.state.timer?.paused ?? false;
   }
+  /**
+   * Get the timer's origin _(if debugging is enabled)_
+   */
   get trace() {
-    var _a;
-    return (_a = this.state.timer) == null ? void 0 : _a.trace;
+    return globalThis._oscarpalmer_timer_debug ?? false ? this.state.timer?.trace : void 0;
   }
   constructor(state) {
-    super("when", state);
+    this.state = state;
   }
   /**
    * Continues the timer _(if it was paused)_
    */
   continue() {
-    var _a;
-    (_a = this.state.timer) == null ? void 0 : _a.continue();
+    this.state.timer?.continue();
     return this;
   }
   /**
    * Destroys the timer _(and stops it,if it was running)_
    */
   destroy() {
-    var _a;
-    (_a = this.state.timer) == null ? void 0 : _a.destroy();
+    this.state.timer?.destroy();
     this.state.promise = void 0;
     this.state.resolver = _function.noop;
     this.state.rejecter = _function.noop;
@@ -46,16 +60,14 @@ class When extends timer.BasicTimer {
    * Pauses the timer _(if it was running)_
    */
   pause() {
-    var _a;
-    (_a = this.state.timer) == null ? void 0 : _a.pause();
+    this.state.timer?.pause();
     return this;
   }
   /**
    * Stops the timer _(if it was running)_
    */
   stop() {
-    var _a;
-    (_a = this.state.timer) == null ? void 0 : _a.stop();
+    this.state.timer?.stop();
     return this;
   }
   /**
@@ -63,10 +75,9 @@ class When extends timer.BasicTimer {
    */
   // biome-ignore lint/suspicious/noThenProperty: returning a promise-like object, so it's ok ;)
   then(resolve, reject) {
-    var _a;
-    if (this.state.timer == null || ((_a = this.state) == null ? void 0 : _a.started)) {
+    if (this.state.timer == null || this.state?.started) {
       throw new Error(
-        this.state.timer == null ? destroyedMessage : startedMessage
+        this.state.timer == null ? constants.destroyedMessage : constants.startedMessage
       );
     }
     this.state.started = true;
@@ -75,37 +86,41 @@ class When extends timer.BasicTimer {
   }
 }
 function when(condition, options) {
+  let called = false;
   let result = false;
   const state = {
     started: false,
-    timer: timer.timer(
-      "repeat",
-      () => {
-        if (condition()) {
-          result = true;
-          state.timer.stop();
-        }
+    timer: new timer.Timer(
+      "when",
+      work.work,
+      {
+        callback() {
+          if (condition()) {
+            result = true;
+            state.timer.stop();
+          }
+        },
+        trace: new models.TimerTrace().stack
       },
       {
-        afterCallback() {
-          var _a, _b;
-          if (!state.timer.paused) {
+        onAfter() {
+          if (!(state.timer?.paused ?? false) && !called) {
+            called = true;
             if (result) {
-              (_a = state.resolver) == null ? void 0 : _a.call(state);
+              state.resolver?.();
             } else {
-              (_b = state.rejecter) == null ? void 0 : _b.call(state);
+              state.rejecter?.();
             }
             instance.destroy();
           }
         },
-        errorCallback() {
-          var _a;
-          (_a = state.rejecter) == null ? void 0 : _a.call(state);
+        onError() {
+          state.rejecter?.();
           instance.destroy();
         },
-        count: options == null ? void 0 : options.count,
-        interval: options == null ? void 0 : options.interval,
-        timeout: options == null ? void 0 : options.timeout
+        count: get.getValidNumber(options?.count),
+        interval: get.getValidNumber(options?.interval, constants.milliseconds),
+        timeout: get.getValidNumber(options?.timeout)
       },
       false
     )
@@ -118,5 +133,5 @@ function when(condition, options) {
   const instance = new When(state);
   return instance;
 }
-exports.When = When;
+
 exports.when = when;

package/dist/when.js

@@ -1,40 +1,52 @@
-import { noop } from "@oscarpalmer/atoms/function";
-import { BasicTimer, timer } from "./timer.js";
-const destroyedMessage = "Timer has already been destroyed";
-const startedMessage = "Timer has already been started";
-class When extends BasicTimer {
+import { noop } from './node_modules/@oscarpalmer/atoms/dist/function.js';
+import { milliseconds, destroyedMessage, startedMessage } from './constants.js';
+import { getValidNumber } from './get.js';
+import { TimerTrace } from './models.js';
+import { Timer } from './timer.js';
+import { work } from './work.js';
+
+class When {
+  $timer = "when";
+  state;
+  /**
+   * Is the timer active?
+   */
   get active() {
-    var _a;
-    return ((_a = this.state.timer) == null ? void 0 : _a.active) ?? false;
+    return this.state.timer?.active ?? false;
   }
+  /**
+   * Is the timer destroyed?
+   */
   get destroyed() {
     return this.state.timer == null;
   }
+  /**
+   * Is the timer paused?
+   */
   get paused() {
-    var _a;
-    return ((_a = this.state.timer) == null ? void 0 : _a.paused) ?? false;
+    return this.state.timer?.paused ?? false;
   }
+  /**
+   * Get the timer's origin _(if debugging is enabled)_
+   */
   get trace() {
-    var _a;
-    return (_a = this.state.timer) == null ? void 0 : _a.trace;
+    return globalThis._oscarpalmer_timer_debug ?? false ? this.state.timer?.trace : void 0;
   }
   constructor(state) {
-    super("when", state);
+    this.state = state;
   }
   /**
    * Continues the timer _(if it was paused)_
    */
   continue() {
-    var _a;
-    (_a = this.state.timer) == null ? void 0 : _a.continue();
+    this.state.timer?.continue();
     return this;
   }
   /**
    * Destroys the timer _(and stops it,if it was running)_
    */
   destroy() {
-    var _a;
-    (_a = this.state.timer) == null ? void 0 : _a.destroy();
+    this.state.timer?.destroy();
     this.state.promise = void 0;
     this.state.resolver = noop;
     this.state.rejecter = noop;
@@ -44,16 +56,14 @@ class When extends BasicTimer {
    * Pauses the timer _(if it was running)_
    */
   pause() {
-    var _a;
-    (_a = this.state.timer) == null ? void 0 : _a.pause();
+    this.state.timer?.pause();
     return this;
   }
   /**
    * Stops the timer _(if it was running)_
    */
   stop() {
-    var _a;
-    (_a = this.state.timer) == null ? void 0 : _a.stop();
+    this.state.timer?.stop();
     return this;
   }
   /**
@@ -61,8 +71,7 @@ class When extends BasicTimer {
    */
   // biome-ignore lint/suspicious/noThenProperty: returning a promise-like object, so it's ok ;)
   then(resolve, reject) {
-    var _a;
-    if (this.state.timer == null || ((_a = this.state) == null ? void 0 : _a.started)) {
+    if (this.state.timer == null || this.state?.started) {
       throw new Error(
         this.state.timer == null ? destroyedMessage : startedMessage
       );
@@ -73,37 +82,41 @@ class When extends BasicTimer {
   }
 }
 function when(condition, options) {
+  let called = false;
   let result = false;
   const state = {
     started: false,
-    timer: timer(
-      "repeat",
-      () => {
-        if (condition()) {
-          result = true;
-          state.timer.stop();
-        }
+    timer: new Timer(
+      "when",
+      work,
+      {
+        callback() {
+          if (condition()) {
+            result = true;
+            state.timer.stop();
+          }
+        },
+        trace: new TimerTrace().stack
       },
       {
-        afterCallback() {
-          var _a, _b;
-          if (!state.timer.paused) {
+        onAfter() {
+          if (!(state.timer?.paused ?? false) && !called) {
+            called = true;
             if (result) {
-              (_a = state.resolver) == null ? void 0 : _a.call(state);
+              state.resolver?.();
             } else {
-              (_b = state.rejecter) == null ? void 0 : _b.call(state);
+              state.rejecter?.();
             }
             instance.destroy();
           }
         },
-        errorCallback() {
-          var _a;
-          (_a = state.rejecter) == null ? void 0 : _a.call(state);
+        onError() {
+          state.rejecter?.();
           instance.destroy();
         },
-        count: options == null ? void 0 : options.count,
-        interval: options == null ? void 0 : options.interval,
-        timeout: options == null ? void 0 : options.timeout
+        count: getValidNumber(options?.count),
+        interval: getValidNumber(options?.interval, milliseconds),
+        timeout: getValidNumber(options?.timeout)
       },
       false
     )
@@ -116,7 +129,5 @@ function when(condition, options) {
   const instance = new When(state);
   return instance;
 }
-export {
-  When,
-  when
-};
+
+export { when };

package/dist/work.cjs

@@ -0,0 +1,72 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('./constants.cjs');
+
+function finish(timer, state, options, success) {
+  constants.activeTimers.delete(timer.instance);
+  state.active = false;
+  state.elapsed = 0;
+  state.frame = void 0;
+  if (timer.type === "wait") {
+    state.callback();
+  } else {
+    options.onAfter?.(success);
+  }
+}
+function work(type, timer, state, options) {
+  if (state.destroyed && type !== "stop" || (state.active ? constants.beginTypes.has(type) : constants.endTypes.has(type))) {
+    return timer.instance;
+  }
+  const pausable = constants.pauseTypes.has(type);
+  state.elapsed = pausable ? state.elapsed : 0;
+  state.index = pausable ? state.index : 0;
+  state.total = pausable ? state.total : 0;
+  if (constants.endOrRestartTypes.has(type)) {
+    constants.activeTimers.delete(timer.instance);
+    cancelAnimationFrame(state.frame);
+    if (type === "stop") {
+      options.onAfter?.(false);
+    }
+    state.active = false;
+    state.frame = void 0;
+    state.paused = type === "pause";
+    return type === "restart" ? work("start", timer, state, options) : timer.instance;
+  }
+  state.active = true;
+  state.paused = false;
+  let start;
+  function step(now) {
+    if (!state.active) {
+      return;
+    }
+    start ??= now;
+    const difference = now - start;
+    state.elapsed += difference;
+    state.total += difference;
+    if (options.timeout > 0 && state.total >= options.timeout) {
+      options.onError?.();
+      finish(timer, state, options, false);
+      return;
+    }
+    if (options.interval === constants.milliseconds || state.elapsed >= options.interval - 5) {
+      if (options.count > -1) {
+        state.callback(state.index);
+      }
+      start = now;
+      state.elapsed = 0;
+      state.index += 1;
+      if (options.count === -1 || options.count > 0 && state.index >= options.count) {
+        finish(timer, state, options, true);
+        return;
+      }
+    }
+    state.frame = requestAnimationFrame(step);
+  }
+  constants.activeTimers.add(timer.instance);
+  state.frame = requestAnimationFrame(step);
+  return timer.instance;
+}
+
+exports.work = work;

package/dist/work.js

@@ -0,0 +1,68 @@
+import { beginTypes, endTypes, pauseTypes, endOrRestartTypes, activeTimers, milliseconds } from './constants.js';
+
+function finish(timer, state, options, success) {
+  activeTimers.delete(timer.instance);
+  state.active = false;
+  state.elapsed = 0;
+  state.frame = void 0;
+  if (timer.type === "wait") {
+    state.callback();
+  } else {
+    options.onAfter?.(success);
+  }
+}
+function work(type, timer, state, options) {
+  if (state.destroyed && type !== "stop" || (state.active ? beginTypes.has(type) : endTypes.has(type))) {
+    return timer.instance;
+  }
+  const pausable = pauseTypes.has(type);
+  state.elapsed = pausable ? state.elapsed : 0;
+  state.index = pausable ? state.index : 0;
+  state.total = pausable ? state.total : 0;
+  if (endOrRestartTypes.has(type)) {
+    activeTimers.delete(timer.instance);
+    cancelAnimationFrame(state.frame);
+    if (type === "stop") {
+      options.onAfter?.(false);
+    }
+    state.active = false;
+    state.frame = void 0;
+    state.paused = type === "pause";
+    return type === "restart" ? work("start", timer, state, options) : timer.instance;
+  }
+  state.active = true;
+  state.paused = false;
+  let start;
+  function step(now) {
+    if (!state.active) {
+      return;
+    }
+    start ??= now;
+    const difference = now - start;
+    state.elapsed += difference;
+    state.total += difference;
+    if (options.timeout > 0 && state.total >= options.timeout) {
+      options.onError?.();
+      finish(timer, state, options, false);
+      return;
+    }
+    if (options.interval === milliseconds || state.elapsed >= options.interval - 5) {
+      if (options.count > -1) {
+        state.callback(state.index);
+      }
+      start = now;
+      state.elapsed = 0;
+      state.index += 1;
+      if (options.count === -1 || options.count > 0 && state.index >= options.count) {
+        finish(timer, state, options, true);
+        return;
+      }
+    }
+    state.frame = requestAnimationFrame(step);
+  }
+  activeTimers.add(timer.instance);
+  state.frame = requestAnimationFrame(step);
+  return timer.instance;
+}
+
+export { work };

package/package.json

@@ -4,22 +4,22 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.82"
+		"@oscarpalmer/atoms": "^0.99"
 	},
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
 		"@biomejs/biome": "^1.9",
 		"@rollup/plugin-node-resolve": "^16",
 		"@rollup/plugin-typescript": "^12.1",
-		"@types/node": "^22.13",
-		"@vitest/coverage-istanbul": "^3",
+		"@types/node": "^22.15",
+		"@vitest/coverage-istanbul": "^3.1",
 		"dts-bundle-generator": "^9.5",
 		"glob": "^11",
-		"happy-dom": "^16.8",
+		"jsdom": "^26.1",
 		"tslib": "^2.8",
-		"typescript": "^5.7",
-		"vite": "^6",
-		"vitest": "^3"
+		"typescript": "^5.8",
+		"vite": "^6.3",
+		"vitest": "^3.1"
 	},
 	"exports": {
 		".": {
@@ -31,6 +31,46 @@
 				"types": "./types/index.d.cts",
 				"default": "./dist/index.cjs"
 			}
+		},
+		"./delay": {
+			"import": {
+				"types": "./types/delay.d.ts",
+				"default": "./dist/delay.js"
+			},
+			"require": {
+				"types": "./types/delay.d.cts",
+				"default": "./dist/delay.cjs"
+			}
+		},
+		"./repeat": {
+			"import": {
+				"types": "./types/repeat.d.ts",
+				"default": "./dist/repeat.js"
+			},
+			"require": {
+				"types": "./types/repeat.d.cts",
+				"default": "./dist/repeat.cjs"
+			}
+		},
+		"./wait": {
+			"import": {
+				"types": "./types/wait.d.ts",
+				"default": "./dist/wait.js"
+			},
+			"require": {
+				"types": "./types/wait.d.cts",
+				"default": "./dist/wait.cjs"
+			}
+		},
+		"./when": {
+			"import": {
+				"types": "./types/when.d.ts",
+				"default": "./dist/when.js"
+			},
+			"require": {
+				"types": "./types/when.d.cts",
+				"default": "./dist/when.cjs"
+			}
 		}
 	},
 	"files": ["dist", "src", "types"],
@@ -49,10 +89,10 @@
 		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
 		"rollup": "npx rollup -c",
 		"test": "npx vitest --coverage",
-		"types": "npx tsc && npx dts-bundle-generator --config ./dts.config.cts",
+		"types": "npx tsc && npx dts-bundle-generator --config ./dts.config.cts --silent",
 		"watch": "npx vite build --watch"
 	},
 	"type": "module",
 	"types": "types/index.d.cts",
-	"version": "0.28.0"
+	"version": "0.30.0"
 }

package/src/constants.ts

@@ -1,6 +1,32 @@
-import type {WorkType} from './models';
+import type {WorkHandlerType} from './models';
 import type {Timer} from './timer';
 
+/**
+ * Stepper to calculate the average refresh rate of the display
+ */
+function stepper(now: DOMHighResTimeStamp): void {
+	if (values.length === 7) {
+		milliseconds = Math.floor(
+			(values.slice(2).reduce((first, second) => first + second) / 5) * 2,
+		) / 2;
+
+		last = undefined;
+		values.length = 0;
+	} else {
+		last ??= now;
+
+		const difference = now - last;
+
+		if (difference > 0) {
+			values.push(difference);
+		}
+
+		last = now;
+
+		requestAnimationFrame(stepper);
+	}
+}
+
 /**
  * A set of all active timers
  */
@@ -9,17 +35,22 @@ export const activeTimers = new Set<Timer>();
 /**
  * A set of types that allow work to begin
  */
-export const beginTypes = new Set<WorkType>(['continue', 'start']);
+export const beginTypes = new Set<WorkHandlerType>(['continue', 'start']);
+
+/**
+ * Message to show when a when-timer is destroyed
+ */
+export const destroyedMessage = 'Timer has already been destroyed';
 
 /**
  * A set of types that allow work to end
  */
-export const endTypes = new Set<WorkType>(['pause', 'stop']);
+export const endTypes = new Set<WorkHandlerType>(['pause', 'stop']);
 
 /**
  * A set of types that allow work to end or restart
  */
-export const endOrRestartTypes = new Set<WorkType>([
+export const endOrRestartTypes = new Set<WorkHandlerType>([
 	'pause',
 	'restart',
 	'stop',
@@ -30,7 +61,21 @@ export const endOrRestartTypes = new Set<WorkType>([
  */
 export const hiddenTimers = new Set<Timer>();
 
+export const pauseTypes = new Set<WorkHandlerType>(['continue', 'pause']);
+
 /**
- * Milliseconds in a frame, probably ;-)
+ * Message to show when a when-timer is started
  */
-export const milliseconds = 1_000 / 60;
+export const startedMessage = 'Timer has already been started';
+
+//
+
+const values: number[] = [];
+let last: DOMHighResTimeStamp | undefined;
+
+/**
+ * A calculated average of the refresh rate of the display _(in milliseconds)_
+ */
+export let milliseconds = Math.floor((1000 / 60) * 2) / 2;
+
+requestAnimationFrame(stepper);

package/src/delay.ts

@@ -0,0 +1,25 @@
+import {milliseconds} from './constants';
+import {getValidNumber} from './get';
+
+/**
+ * Create a delayed promise that resolves after a certain amount of time _(in milliseconds; defaults to screen refresh rate)_
+ */
+export function delay(time?: number): Promise<void> {
+	return new Promise(resolve => {
+		const interval = getValidNumber(time, milliseconds);
+
+		let start: DOMHighResTimeStamp;
+
+		function step(now: DOMHighResTimeStamp) {
+			start ??= now;
+
+			if (interval === milliseconds || now - start >= interval - 5) {
+				resolve();
+			} else {
+				requestAnimationFrame(step);
+			}
+		}
+
+		requestAnimationFrame(step);
+	});
+}