@oscarpalmer/timer 0.31.0 → 0.33.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

@@ -3,9 +3,9 @@ import type {
 	TimerOptions,
 	TimerState,
 	TimerType,
-	WorkHandler,
 	WorkHandlerType,
 } from './models';
+import {stop, work} from './work';
 
 export class Timer {
 	private declare readonly $timer: TimerType;
@@ -44,7 +44,6 @@ export class Timer {
 
 	constructor(
 		type: TimerType,
-		protected readonly worker: WorkHandler,
 		state: Pick<TimerState, 'callback' | 'trace'>,
 		protected readonly options: TimerOptions,
 		start: boolean,
@@ -82,11 +81,20 @@ export class Timer {
 
 		this.options.onAfter = noop;
 		this.options.onError = noop;
-
 		this.state.callback = noop;
-		this.state.trace = undefined;
 
-		this.#work('stop');
+		if (!globalThis._oscarpalmer_timer_debug) {
+			this.state.trace = undefined;
+		}
+
+		stop(
+			{
+				instance: this,
+				type: this.$timer,
+			},
+			this.state,
+			this.options,
+		);
 	}
 
 	/**
@@ -118,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,

package/src/when.ts

@@ -1,13 +1,19 @@
 import {noop} from '@oscarpalmer/atoms/function';
 import {destroyedMessage, milliseconds, startedMessage} from './constants';
 import {getValidNumber} from './get';
+import './global';
 import {TimerTrace, type WhenOptions, type WhenState} from './models';
 import {Timer} from './timer';
-import {work} from './work';
 
 class When {
 	private readonly $timer = 'when';
-	private readonly state: WhenState;
+	private readonly state: WhenState = {
+		promise: undefined as never,
+		rejecter: undefined as never,
+		resolver: undefined as never,
+		started: false,
+		timer: undefined as never,
+	};
 
 	/**
 	 * Is the timer active?
@@ -39,8 +45,53 @@ class When {
 			: undefined;
 	}
 
-	constructor(state: WhenState) {
-		this.state = state;
+	constructor(condition: () => boolean, options?: Partial<WhenOptions>) {
+		const {state} = this;
+
+		state.promise = new Promise<void>((resolve, reject) => {
+			state.resolver = resolve;
+			state.rejecter = reject;
+		});
+
+		let result = false;
+
+		this.state.timer = new Timer(
+			'when',
+			{
+				callback(): void {
+					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,
+		);
 	}
 
 	/**
@@ -56,12 +107,14 @@ class When {
 	 * Destroys the timer _(and stops it,if it was running)_
 	 */
 	destroy(): void {
-		this.state.timer?.destroy();
+		const {state} = this;
 
-		this.state.promise = undefined as never;
-		this.state.resolver = noop;
-		this.state.rejecter = noop;
-		this.state.timer = undefined as never;
+		state.timer?.destroy();
+
+		state.promise = undefined as never;
+		state.resolver = noop;
+		state.rejecter = noop;
+		state.timer = undefined as never;
 	}
 
 	/**
@@ -90,17 +143,21 @@ class When {
 		resolve?: (() => void) | null,
 		reject?: (() => void) | null,
 	): Promise<void> {
-		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;
+		state.started = true;
 
-		this.state.timer.start();
+		state.timer.start();
 
-		return this.state.promise.then(resolve ?? noop, reject ?? noop);
+		return state.promise.then(resolve ?? noop, reject ?? noop);
 	}
 }
 
@@ -111,61 +168,7 @@ export function when(
 	condition: () => boolean,
 	options?: Partial<WhenOptions>,
 ): When {
-	let called = false;
-	let result = false;
-
-	const state: WhenState = {
-		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,
-		),
-	} as never;
-
-	const promise = new Promise<void>((resolve, reject) => {
-		state.resolver = resolve;
-		state.rejecter = reject;
-	});
-
-	state.promise = promise;
-
-	const instance = new When(state);
-
-	return instance;
+	return new When(condition, options);
 }
 
 export type {When};

package/src/work.ts

@@ -3,6 +3,7 @@ import {
 	beginTypes,
 	endOrRestartTypes,
 	endTypes,
+	intervalBuffer,
 	milliseconds,
 	pauseTypes,
 } from './constants';
@@ -14,6 +15,27 @@ import type {
 } from './models';
 import type {Timer} from './timer';
 
+function endOrRestart(
+	type: WorkHandlerType,
+	timer: WorkHandlerTimer,
+	state: TimerState,
+	options: TimerOptions,
+): Timer {
+	cancelAnimationFrame(state.frame as never);
+
+	if (type === 'stop') {
+		options.onAfter?.(false);
+	}
+
+	state.active = false;
+	state.frame = undefined;
+	state.paused = type === 'pause';
+
+	return type === 'restart'
+		? work('start', timer, state, options)
+		: timer.instance;
+}
+
 function finish(
 	timer: WorkHandlerTimer,
 	state: TimerState,
@@ -33,60 +55,36 @@ function finish(
 	}
 }
 
-export function work(
-	type: WorkHandlerType,
-	timer: WorkHandlerTimer,
-	state: TimerState,
-	options: TimerOptions,
-): Timer {
-	if (
+function ignore(type: WorkHandlerType, state: TimerState): boolean {
+	return (
 		(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 as never);
-
-		if (type === 'stop') {
-			options.onAfter?.(false);
-		}
-
-		state.active = false;
-		state.frame = undefined;
-		state.paused = type === 'pause';
-
-		return type === 'restart'
-			? work('start', timer, state, options)
-			: timer.instance;
-	}
-
-	state.active = true;
-	state.paused = false;
+	);
+}
 
+function run(
+	timer: WorkHandlerTimer,
+	state: TimerState,
+	options: TimerOptions,
+): (now: DOMHighResTimeStamp) => void {
+	let last: DOMHighResTimeStamp | undefined;
 	let start: DOMHighResTimeStamp | undefined;
 
-	function step(now: DOMHighResTimeStamp): void {
+	return function step(now: DOMHighResTimeStamp): void {
 		if (!state.active) {
 			return;
 		}
 
+		last ??= now;
 		start ??= now;
 
-		const difference = now - start;
+		const difference = now - last;
 
 		state.elapsed += difference;
 		state.total += difference;
 
+		last = now;
+
 		if (options.timeout > 0 && state.total >= options.timeout) {
 			options.onError?.();
 
@@ -97,7 +95,7 @@ export function work(
 
 		if (
 			options.interval === milliseconds ||
-			state.elapsed >= options.interval - 5
+			state.elapsed >= options.interval - intervalBuffer
 		) {
 			if (options.count > -1) {
 				(state.callback as (index: number) => void)(state.index);
@@ -119,11 +117,49 @@ export function work(
 		}
 
 		state.frame = requestAnimationFrame(step);
+	};
+}
+
+function setState(type: WorkHandlerType, state: TimerState): void {
+	const pausable = pauseTypes.has(type);
+
+	state.elapsed = pausable ? state.elapsed : 0;
+	state.index = pausable ? state.index : 0;
+	state.total = pausable ? state.total : 0;
+}
+
+export function stop(
+	timer: WorkHandlerTimer,
+	state: TimerState,
+	options: TimerOptions,
+): void {
+	endOrRestart('stop', timer, state, options);
+}
+
+export function work(
+	type: WorkHandlerType,
+	timer: WorkHandlerTimer,
+	state: TimerState,
+	options: TimerOptions,
+): Timer {
+	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;
 }

package/types/constants.d.cts

@@ -2,7 +2,6 @@
 
 declare class Timer {
 	#private;
-	protected readonly worker: WorkHandler;
 	protected readonly options: TimerOptions;
 	private readonly $timer;
 	protected readonly state: TimerState;
@@ -22,7 +21,7 @@ declare class Timer {
 	 * Get the timer's origin _(if debugging is enabled)_
 	 */
 	get trace(): string | undefined;
-	constructor(type: TimerType, worker: WorkHandler, state: Pick<TimerState, "callback" | "trace">, options: TimerOptions, start: boolean);
+	constructor(type: TimerType, state: Pick<TimerState, "callback" | "trace">, options: TimerOptions, start: boolean);
 	/**
 	 * Continue running the timer _(if it's paused)_
 	 */
@@ -67,11 +66,6 @@ export type TimerState = {
 	trace: string | undefined;
 };
 export type TimerType = "repeat" | "wait" | "when";
-export type WorkHandler = (type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions) => Timer;
-export type WorkHandlerTimer = {
-	instance: Timer;
-	type: TimerType;
-};
 export type WorkHandlerType = "continue" | "pause" | "restart" | "start" | "stop";
 /**
  * A set of all active timers
@@ -81,6 +75,10 @@ export declare const activeTimers: Set<Timer>;
  * A set of types that allow work to begin
  */
 export declare const beginTypes: Set<WorkHandlerType>;
+/**
+ * Buffer value to use when evaluating if a specific time is within a certain range
+ */
+export declare const intervalBuffer = 5;
 /**
  * Message to show when a when-timer is destroyed
  */

package/types/constants.d.ts

@@ -8,6 +8,10 @@ export declare const activeTimers: Set<Timer>;
  * A set of types that allow work to begin
  */
 export declare const beginTypes: Set<WorkHandlerType>;
+/**
+ * Buffer value to use when evaluating if a specific time is within a certain range
+ */
+export declare const intervalBuffer = 5;
 /**
  * Message to show when a when-timer is destroyed
  */

package/types/index.d.cts

@@ -2,7 +2,6 @@
 
 export declare class Timer {
 	#private;
-	protected readonly worker: WorkHandler;
 	protected readonly options: TimerOptions;
 	private readonly $timer;
 	protected readonly state: TimerState;
@@ -22,7 +21,7 @@ export declare class Timer {
 	 * Get the timer's origin _(if debugging is enabled)_
 	 */
 	get trace(): string | undefined;
-	constructor(type: TimerType, worker: WorkHandler, state: Pick<TimerState, "callback" | "trace">, options: TimerOptions, start: boolean);
+	constructor(type: TimerType, state: Pick<TimerState, "callback" | "trace">, options: TimerOptions, start: boolean);
 	/**
 	 * Continue running the timer _(if it's paused)_
 	 */
@@ -101,19 +100,6 @@ export type WhenOptions = {
 	 */
 	timeout: number;
 };
-export type WhenState = {
-	promise: Promise<void>;
-	rejecter?: () => void;
-	resolver?: () => void;
-	started: boolean;
-	timer: Timer;
-};
-export type WorkHandler = (type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions) => Timer;
-export type WorkHandlerTimer = {
-	instance: Timer;
-	type: TimerType;
-};
-export type WorkHandlerType = "continue" | "pause" | "restart" | "start" | "stop";
 export declare class When {
 	private readonly $timer;
 	private readonly state;
@@ -133,7 +119,7 @@ export declare class When {
 	 * Get the timer's origin _(if debugging is enabled)_
 	 */
 	get trace(): string | undefined;
-	constructor(state: WhenState);
+	constructor(condition: () => boolean, options?: Partial<WhenOptions>);
 	/**
 	 * Continues the timer _(if it was paused)_
 	 */