@oscarpalmer/timer 0.30.0 → 0.32.0

package/dist/when.js

@@ -1,13 +1,19 @@
-import { noop } from './node_modules/@oscarpalmer/atoms/dist/function.js';
+import { noop } from '@oscarpalmer/atoms/function';
 import { milliseconds, destroyedMessage, startedMessage } from './constants.js';
 import { getValidNumber } from './get.js';
+import './global.js';
 import { TimerTrace } from './models.js';
 import { Timer } from './timer.js';
-import { work } from './work.js';
 
 class When {
   $timer = "when";
-  state;
+  state = {
+    promise: void 0,
+    rejecter: void 0,
+    resolver: void 0,
+    started: false,
+    timer: void 0
+  };
   /**
    * Is the timer active?
    */
@@ -32,8 +38,47 @@ class When {
   get trace() {
     return globalThis._oscarpalmer_timer_debug ?? false ? this.state.timer?.trace : void 0;
   }
-  constructor(state) {
-    this.state = state;
+  constructor(condition, options) {
+    const { state } = this;
+    state.promise = new Promise((resolve, reject) => {
+      state.resolver = resolve;
+      state.rejecter = reject;
+    });
+    let result = false;
+    this.state.timer = new Timer(
+      "when",
+      {
+        callback() {
+          try {
+            if (condition()) {
+              result = true;
+              state.timer.stop();
+            }
+          } catch {
+            state.timer.stop();
+          }
+        },
+        trace: new TimerTrace().stack
+      },
+      {
+        onAfter: () => {
+          if (result) {
+            state.resolver?.();
+          } else {
+            state.rejecter?.();
+          }
+          this.destroy();
+        },
+        onError: () => {
+          state.rejecter?.();
+          this.destroy();
+        },
+        count: getValidNumber(options?.count),
+        interval: getValidNumber(options?.interval, milliseconds),
+        timeout: getValidNumber(options?.timeout)
+      },
+      false
+    );
   }
   /**
    * Continues the timer _(if it was paused)_
@@ -46,11 +91,12 @@ class When {
    * Destroys the timer _(and stops it,if it was running)_
    */
   destroy() {
-    this.state.timer?.destroy();
-    this.state.promise = void 0;
-    this.state.resolver = noop;
-    this.state.rejecter = noop;
-    this.state.timer = void 0;
+    const { state } = this;
+    state.timer?.destroy();
+    state.promise = void 0;
+    state.resolver = noop;
+    state.rejecter = noop;
+    state.timer = void 0;
   }
   /**
    * Pauses the timer _(if it was running)_
@@ -71,63 +117,20 @@ class When {
    */
   // biome-ignore lint/suspicious/noThenProperty: returning a promise-like object, so it's ok ;)
   then(resolve, reject) {
-    if (this.state.timer == null || this.state?.started) {
-      throw new Error(
-        this.state.timer == null ? destroyedMessage : startedMessage
-      );
+    const { state } = this;
+    if (state.timer == null) {
+      throw new Error(destroyedMessage);
+    }
+    if (state.started) {
+      throw new Error(startedMessage);
     }
-    this.state.started = true;
-    this.state.timer.start();
-    return this.state.promise.then(resolve ?? noop, reject ?? noop);
+    state.started = true;
+    state.timer.start();
+    return state.promise.then(resolve ?? noop, reject ?? noop);
   }
 }
 function when(condition, options) {
-  let called = false;
-  let result = false;
-  const state = {
-    started: false,
-    timer: new Timer(
-      "when",
-      work,
-      {
-        callback() {
-          if (condition()) {
-            result = true;
-            state.timer.stop();
-          }
-        },
-        trace: new TimerTrace().stack
-      },
-      {
-        onAfter() {
-          if (!(state.timer?.paused ?? false) && !called) {
-            called = true;
-            if (result) {
-              state.resolver?.();
-            } else {
-              state.rejecter?.();
-            }
-            instance.destroy();
-          }
-        },
-        onError() {
-          state.rejecter?.();
-          instance.destroy();
-        },
-        count: getValidNumber(options?.count),
-        interval: getValidNumber(options?.interval, milliseconds),
-        timeout: getValidNumber(options?.timeout)
-      },
-      false
-    )
-  };
-  const promise = new Promise((resolve, reject) => {
-    state.resolver = resolve;
-    state.rejecter = reject;
-  });
-  state.promise = promise;
-  const instance = new When(state);
-  return instance;
+  return new When(condition, options);
 }
 
 export { when };

package/dist/work.cjs

@@ -4,6 +4,16 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const constants = require('./constants.cjs');
 
+function endOrRestart(type, timer, state, options) {
+  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;
+}
 function finish(timer, state, options, success) {
   constants.activeTimers.delete(timer.instance);
   state.active = false;
@@ -15,29 +25,12 @@ function finish(timer, state, options, success) {
     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;
+function ignore(type, state) {
+  return state.destroyed && type !== "stop" || (state.active ? constants.beginTypes.has(type) : constants.endTypes.has(type));
+}
+function run(timer, state, options) {
   let start;
-  function step(now) {
+  return function step(now) {
     if (!state.active) {
       return;
     }
@@ -50,7 +43,7 @@ function work(type, timer, state, options) {
       finish(timer, state, options, false);
       return;
     }
-    if (options.interval === constants.milliseconds || state.elapsed >= options.interval - 5) {
+    if (options.interval === constants.milliseconds || state.elapsed >= options.interval - constants.intervalBuffer) {
       if (options.count > -1) {
         state.callback(state.index);
       }
@@ -63,10 +56,32 @@ function work(type, timer, state, options) {
       }
     }
     state.frame = requestAnimationFrame(step);
+  };
+}
+function setState(type, state) {
+  const pausable = constants.pauseTypes.has(type);
+  state.elapsed = pausable ? state.elapsed : 0;
+  state.index = pausable ? state.index : 0;
+  state.total = pausable ? state.total : 0;
+}
+function stop(timer, state, options) {
+  endOrRestart("stop", timer, state, options);
+}
+function work(type, timer, state, options) {
+  if (ignore(type, state)) {
+    return timer.instance;
   }
+  setState(type, state);
+  if (constants.endOrRestartTypes.has(type)) {
+    return endOrRestart(type, timer, state, options);
+  }
+  state.active = true;
+  state.paused = false;
   constants.activeTimers.add(timer.instance);
-  state.frame = requestAnimationFrame(step);
+  const runner = run(timer, state, options);
+  state.frame = requestAnimationFrame(runner);
   return timer.instance;
 }
 
+exports.stop = stop;
 exports.work = work;

package/dist/work.js

@@ -1,5 +1,15 @@
-import { beginTypes, endTypes, pauseTypes, endOrRestartTypes, activeTimers, milliseconds } from './constants.js';
+import { endOrRestartTypes, activeTimers, beginTypes, endTypes, pauseTypes, milliseconds, intervalBuffer } from './constants.js';
 
+function endOrRestart(type, timer, state, options) {
+  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;
+}
 function finish(timer, state, options, success) {
   activeTimers.delete(timer.instance);
   state.active = false;
@@ -11,29 +21,12 @@ function finish(timer, state, options, success) {
     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;
+function ignore(type, state) {
+  return state.destroyed && type !== "stop" || (state.active ? beginTypes.has(type) : endTypes.has(type));
+}
+function run(timer, state, options) {
   let start;
-  function step(now) {
+  return function step(now) {
     if (!state.active) {
       return;
     }
@@ -46,7 +39,7 @@ function work(type, timer, state, options) {
       finish(timer, state, options, false);
       return;
     }
-    if (options.interval === milliseconds || state.elapsed >= options.interval - 5) {
+    if (options.interval === milliseconds || state.elapsed >= options.interval - intervalBuffer) {
       if (options.count > -1) {
         state.callback(state.index);
       }
@@ -59,10 +52,31 @@ function work(type, timer, state, options) {
       }
     }
     state.frame = requestAnimationFrame(step);
+  };
+}
+function setState(type, state) {
+  const pausable = pauseTypes.has(type);
+  state.elapsed = pausable ? state.elapsed : 0;
+  state.index = pausable ? state.index : 0;
+  state.total = pausable ? state.total : 0;
+}
+function stop(timer, state, options) {
+  endOrRestart("stop", timer, state, options);
+}
+function work(type, timer, state, options) {
+  if (ignore(type, state)) {
+    return timer.instance;
   }
+  setState(type, state);
+  if (endOrRestartTypes.has(type)) {
+    return endOrRestart(type, timer, state, options);
+  }
+  state.active = true;
+  state.paused = false;
   activeTimers.add(timer.instance);
-  state.frame = requestAnimationFrame(step);
+  const runner = run(timer, state, options);
+  state.frame = requestAnimationFrame(runner);
   return timer.instance;
 }
 
-export { work };
+export { stop, work };

package/package.json

@@ -94,5 +94,5 @@
 	},
 	"type": "module",
 	"types": "types/index.d.cts",
-	"version": "0.30.0"
+	"version": "0.32.0"
 }

package/src/constants.ts

@@ -1,30 +1,35 @@
 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);
+function calculate(): Promise<number> {
+	return new Promise(resolve => {
+		const values: number[] = [];
+
+		let last: DOMHighResTimeStamp | undefined;
+
+		function step(now: DOMHighResTimeStamp): void {
+			if (last != null) {
+				values.push(now - last);
+			}
+
+			last = now;
+
+			if (values.length >= 10) {
+				const median =
+					values
+						.sort()
+						.slice(2, -2)
+						.reduce((first, second) => first + second, 0) /
+					(values.length - 4);
+
+				resolve(median);
+			} else {
+				requestAnimationFrame(step);
+			}
 		}
 
-		last = now;
-
-		requestAnimationFrame(stepper);
-	}
+		requestAnimationFrame(step);
+	});
 }
 
 /**
@@ -37,6 +42,11 @@ export const activeTimers = new Set<Timer>();
  */
 export const beginTypes = new Set<WorkHandlerType>(['continue', 'start']);
 
+/**
+ * Buffer value to use when evaluating if a specific time is within a certain range
+ */
+export const intervalBuffer = 5;
+
 /**
  * Message to show when a when-timer is destroyed
  */
@@ -70,12 +80,11 @@ 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;
+export let milliseconds = 1000 / 60;
 
-requestAnimationFrame(stepper);
+calculate().then(value => {
+	milliseconds = value;
+});

package/src/delay.ts

@@ -1,4 +1,4 @@
-import {milliseconds} from './constants';
+import {intervalBuffer, milliseconds} from './constants';
 import {getValidNumber} from './get';
 
 /**
@@ -13,7 +13,10 @@ export function delay(time?: number): Promise<void> {
 		function step(now: DOMHighResTimeStamp) {
 			start ??= now;
 
-			if (interval === milliseconds || now - start >= interval - 5) {
+			if (
+				interval === milliseconds ||
+				now - start >= interval - intervalBuffer
+			) {
 				resolve();
 			} else {
 				requestAnimationFrame(step);

package/src/repeat.ts

@@ -1,8 +1,8 @@
 import {milliseconds} from './constants';
 import {getCallback, getValidNumber} from './get';
+import './global';
 import {type RepeatOptions, TimerTrace} from './models';
 import {Timer} from './timer';
-import {work} from './work';
 
 /**
  * Create a repeating timer
@@ -13,7 +13,6 @@ export function repeat(
 ): Timer {
 	return new Timer(
 		'repeat',
-		work,
 		{
 			callback: getCallback(callback),
 			trace: new TimerTrace().stack,

package/src/timer.ts

@@ -1,10 +1,11 @@
+import {noop} from '@oscarpalmer/atoms/function';
 import type {
 	TimerOptions,
 	TimerState,
 	TimerType,
-	WorkHandler,
 	WorkHandlerType,
 } from './models';
+import {stop, work} from './work';
 
 export class Timer {
 	private declare readonly $timer: TimerType;
@@ -43,7 +44,6 @@ export class Timer {
 
 	constructor(
 		type: TimerType,
-		protected readonly worker: WorkHandler,
 		state: Pick<TimerState, 'callback' | 'trace'>,
 		protected readonly options: TimerOptions,
 		start: boolean,
@@ -79,7 +79,22 @@ export class Timer {
 	destroy(): void {
 		this.state.destroyed = true;
 
-		this.#work('stop');
+		this.options.onAfter = noop;
+		this.options.onError = noop;
+		this.state.callback = noop;
+
+		if (!globalThis._oscarpalmer_timer_debug) {
+			this.state.trace = undefined;
+		}
+
+		stop(
+			{
+				instance: this,
+				type: this.$timer,
+			},
+			this.state,
+			this.options,
+		);
 	}
 
 	/**
@@ -111,7 +126,7 @@ export class Timer {
 	}
 
 	#work(type: WorkHandlerType): Timer {
-		return this.worker(
+		return work(
 			type,
 			{
 				instance: this,

package/src/wait.ts

@@ -1,8 +1,8 @@
 import {milliseconds} from './constants';
 import {getCallback, getValidNumber} from './get';
+import './global';
 import {TimerTrace} from './models';
 import {Timer} from './timer';
-import {work} from './work';
 
 /**
  * Create a waiting timer
@@ -12,7 +12,6 @@ import {work} from './work';
 export function wait(callback: () => void, time?: number): Timer {
 	return new Timer(
 		'wait',
-		work,
 		{
 			callback: getCallback(callback),
 			trace: new TimerTrace().stack,