@oscarpalmer/timer 0.38.1 → 0.40.0

package/dist/constants.js

@@ -1,21 +1,24 @@
-function calculate() {
-	return new Promise((resolve) => {
-		const values = [];
-		let last;
-		function step(now) {
-			if (last != null) values.push(now - last);
-			last = now;
-			if (values.length >= 10) resolve(values.sort().slice(2, -2).reduce((first, second) => first + second, 0) / (values.length - 4));
-			else requestAnimationFrame(step);
-		}
-		requestAnimationFrame(step);
-	});
-}
+import FRAME_RATE_MS from "@oscarpalmer/atoms/frame-rate";
+/**
+* Buffer value to use when evaluating if a specific time is within a certain range
+*/
 const BUFFER_INTERVAL = 5;
 const DEFAULT_TIMEOUT = 3e4;
+/**
+* Message to show when a when-timer is destroyed
+*/
 const MESSAGE_DESTROYED = "Timer has already been destroyed";
+/**
+* Message to show when a when-timer is started
+*/
 const MESSAGE_STARTED = "Timer has already been started";
+/**
+* A set of all active timers
+*/
 const TIMERS_ACTIVE = /* @__PURE__ */ new Set();
+/**
+* A set of timers that were paused due to the document being hidden
+*/
 const TIMERS_HIDDEN = /* @__PURE__ */ new Set();
 const TYPE_REPEAT = "repeat";
 const TYPE_WAIT = "wait";
@@ -25,8 +28,4 @@ const WORK_PAUSE = "pause";
 const WORK_RESTART = "restart";
 const WORK_START = "start";
 const WORK_STOP = "stop";
-let MILLISECONDS = 1e3 / 60;
-calculate().then((value) => {
-	MILLISECONDS = value;
-});
-export { BUFFER_INTERVAL, DEFAULT_TIMEOUT, MESSAGE_DESTROYED, MESSAGE_STARTED, MILLISECONDS, TIMERS_ACTIVE, TIMERS_HIDDEN, TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP };
+export { BUFFER_INTERVAL, DEFAULT_TIMEOUT, FRAME_RATE_MS, MESSAGE_DESTROYED, MESSAGE_STARTED, TIMERS_ACTIVE, TIMERS_HIDDEN, TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP };

package/dist/delay.js

@@ -1,15 +1,10 @@
-import { BUFFER_INTERVAL, MILLISECONDS } from "./constants.js";
 import { getValidNumber } from "./get.js";
+/**
+* Create a delayed promise that resolves after a certain amount of time
+* @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
+* @returns A promise that resolves after the delay
+*/
 function delay(time) {
-	return new Promise((resolve) => {
-		const interval = getValidNumber(time, MILLISECONDS);
-		let start;
-		function step(now) {
-			start ??= now;
-			if (interval === MILLISECONDS || now - start >= interval - 5) resolve();
-			else requestAnimationFrame(step);
-		}
-		requestAnimationFrame(step);
-	});
+	return new Promise((resolve) => setTimeout(resolve, getValidNumber(time)));
 }
 export { delay };

package/dist/is.js

@@ -2,15 +2,35 @@ import { TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN } from "./constants.js";
 function is(names, value) {
 	return names.includes(value?.$timer);
 }
+/**
+* Is the value a repeating timer?
+* @param value Value to check
+* @returns `true` if the value is a repeating timer
+*/
 function isRepeated(value) {
 	return is([TYPE_REPEAT], value);
 }
+/**
+* Is the value a timer?
+* @param value Value to check
+* @returns `true` if the value is a timer
+*/
 function isTimer(value) {
 	return is([TYPE_REPEAT, TYPE_WAIT], value);
 }
+/**
+* Is the value a waiting timer?
+* @param value Value to check
+* @returns `true` if the value is a waiting timer
+*/
 function isWaited(value) {
 	return is([TYPE_WAIT], value);
 }
+/**
+* Is the value a conditional timer?
+* @param value Value to check
+* @returns `true` if the value is a conditional timer
+*/
 function isWhen(value) {
 	return is(["when"], value) && typeof value.then === "function";
 }

package/dist/repeat.js

@@ -1,8 +1,14 @@
-import { MILLISECONDS, TYPE_REPEAT } from "./constants.js";
+import { FRAME_RATE_MS, TYPE_REPEAT } from "./constants.js";
 import { getCallback, getValidNumber } from "./get.js";
 import "./global.js";
 import { TimerTrace } from "./models.js";
 import { Timer } from "./timer.js";
+/**
+* Create a repeating timer
+* @param callback Callback to run on each interval
+* @param options Timer options
+* @returns Timer instance
+*/
 function repeat(callback, options) {
 	return new Timer(TYPE_REPEAT, {
 		callback: getCallback(callback),
@@ -11,7 +17,7 @@ function repeat(callback, options) {
 		onAfter: getCallback(options?.onAfter),
 		onError: getCallback(options?.onTimeout),
 		count: getValidNumber(options?.count),
-		interval: getValidNumber(options?.interval, MILLISECONDS),
+		interval: getValidNumber(options?.interval, FRAME_RATE_MS),
 		timeout: getValidNumber(options?.timeout)
 	}, true);
 }

package/dist/timer.full.js

@@ -1,16 +1,24 @@
-function calculate$1() {
+function calculate() {
 	return new Promise((resolve) => {
 		const values = [];
 		let last;
 		function step(now) {
 			if (last != null) values.push(now - last);
 			last = now;
-			if (values.length >= 10) resolve(values.sort().slice(2, -2).reduce((first, second) => first + second, 0) / (values.length - 4));
+			if (values.length >= CALCULATION_TOTAL) resolve(values.sort().slice(CALCULATION_TRIM_PART, -CALCULATION_TRIM_PART).reduce((first, second) => first + second, 0) / (values.length - CALCULATION_TRIM_TOTAL));
 			else requestAnimationFrame(step);
 		}
 		requestAnimationFrame(step);
 	});
 }
+var CALCULATION_TOTAL = 10;
+var CALCULATION_TRIM_PART = 2;
+var CALCULATION_TRIM_TOTAL = 4;
+var FRAME_RATE_MS = 1e3 / 60;
+calculate().then((value) => {
+	FRAME_RATE_MS = value;
+});
+var frame_rate_default = FRAME_RATE_MS;
 /**
 * Buffer value to use when evaluating if a specific time is within a certain range
 */
@@ -40,14 +48,6 @@ const WORK_PAUSE = "pause";
 const WORK_RESTART = "restart";
 const WORK_START = "start";
 const WORK_STOP = "stop";
-/**
-* A calculated average of the refresh rate of the display _(in milliseconds)_
-*/
-let MILLISECONDS = 1e3 / 60;
-calculate$1().then((value) => {
-	MILLISECONDS = value;
-});
-
 if (globalThis._oscarpalmer_timers == null) Object.defineProperty(globalThis, "_oscarpalmer_timers", { get() {
 	return globalThis._oscarpalmer_timer_debug ? [...TIMERS_ACTIVE] : [];
 } });
@@ -62,29 +62,8 @@ document.addEventListener("visibilitychange", () => {
 	}
 	from.clear();
 });
-
-function calculate() {
-	return new Promise((resolve) => {
-		const values = [];
-		let last;
-		function step(now) {
-			if (last != null) values.push(now - last);
-			last = now;
-			if (values.length >= CALCULATION_TOTAL) resolve(values.sort().slice(2, -2).reduce((first, second) => first + second, 0) / (values.length - CALCULATION_TRIM));
-			else requestAnimationFrame(step);
-		}
-		requestAnimationFrame(step);
-	});
-}
 function noop() {}
-var CALCULATION_TOTAL = 10;
-var CALCULATION_TRIM = 4;
-let milliseconds = 1e3 / 60;
-calculate().then((value) => {
-	milliseconds = value;
-});
-
-var TYPED_ARRAYS = new Set([
+new Set([
 	Int8Array,
 	Uint8Array,
 	Uint8ClampedArray,
@@ -97,7 +76,6 @@ var TYPED_ARRAYS = new Set([
 	BigInt64Array,
 	BigUint64Array
 ]);
-
 function getCallback(value) {
 	return typeof value === "function" ? value : noop;
 }
@@ -108,25 +86,14 @@ function getValidNumber(value, defaultValue) {
 	const actualDefault = defaultValue ?? 0;
 	return typeof value === "number" && value > actualDefault ? value : actualDefault;
 }
-
 /**
 * Create a delayed promise that resolves after a certain amount of time
 * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
 * @returns A promise that resolves after the delay
 */
 function delay(time) {
-	return new Promise((resolve) => {
-		const interval = getValidNumber(time, MILLISECONDS);
-		let start;
-		function step(now) {
-			start ??= now;
-			if (interval === MILLISECONDS || now - start >= interval - BUFFER_INTERVAL) resolve();
-			else requestAnimationFrame(step);
-		}
-		requestAnimationFrame(step);
-	});
+	return new Promise((resolve) => setTimeout(resolve, getValidNumber(time)));
 }
-
 function is(names, value) {
 	return names.includes(value?.$timer);
 }
@@ -162,14 +129,12 @@ function isWaited(value) {
 function isWhen(value) {
 	return is([TYPE_WHEN], value) && typeof value.then === "function";
 }
-
 var TimerTrace = class extends Error {
 	constructor() {
 		super();
 		this.name = "TimerTrace";
 	}
 };
-
 function finish(timer, state, options, success) {
 	cancelAnimationFrame(state.frame);
 	TIMERS_ACTIVE.delete(timer.instance);
@@ -205,7 +170,7 @@ function run(timer, state, options) {
 			finish(timer, state, options, false);
 			return;
 		}
-		if (options.interval === MILLISECONDS || state.elapsed >= options.interval - BUFFER_INTERVAL) {
+		if (options.interval === frame_rate_default || state.elapsed >= options.interval - BUFFER_INTERVAL) {
 			if (options.count > -1) state.callback(state.index);
 			start = now;
 			state.elapsed = 0;
@@ -249,7 +214,6 @@ function work(type, timer, state, options) {
 	state.frame = requestAnimationFrame(runner);
 	return timer.instance;
 }
-
 var Timer = class {
 	state;
 	/**
@@ -278,7 +242,7 @@ var Timer = class {
 	}
 	constructor(type, state, options, start) {
 		this.options = options;
-		this.$timer = type;
+		Object.defineProperty(this, "$timer", { value: type });
 		this.state = {
 			...state,
 			active: false,
@@ -342,7 +306,6 @@ var Timer = class {
 		}, this.state, this.options);
 	}
 };
-
 /**
 * Create a repeating timer
 * @param callback Callback to run on each interval
@@ -357,11 +320,10 @@ function repeat(callback, options) {
 		onAfter: getCallback(options?.onAfter),
 		onError: getCallback(options?.onTimeout),
 		count: getValidNumber(options?.count),
-		interval: getValidNumber(options?.interval, MILLISECONDS),
+		interval: getValidNumber(options?.interval, frame_rate_default),
 		timeout: getValidNumber(options?.timeout)
 	}, true);
 }
-
 /**
 * Create a waiting timer
 * @param callback Callback to run when the timer has finished
@@ -375,13 +337,11 @@ function wait(callback, time) {
 		onAfter: void 0,
 		onError: void 0,
 		count: -1,
-		interval: getValidNumber(time, MILLISECONDS),
+		interval: getValidNumber(time, frame_rate_default),
 		timeout: 0
 	}, true);
 }
-
 var When = class {
-	$timer = TYPE_WHEN;
 	state = {
 		promise: void 0,
 		rejecter: void 0,
@@ -414,6 +374,7 @@ var When = class {
 		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.timer?.trace : void 0;
 	}
 	constructor(condition, options) {
+		Object.defineProperty(this, "$timer", { value: TYPE_WHEN });
 		const { state } = this;
 		state.promise = new Promise((resolve, reject) => {
 			state.resolver = resolve;
@@ -443,7 +404,7 @@ var When = class {
 				this.destroy();
 			},
 			count: getValidNumber(options?.count),
-			interval: getValidNumber(options?.interval, MILLISECONDS),
+			interval: getValidNumber(options?.interval, frame_rate_default),
 			timeout: getValidTimeout(options?.timeout)
 		}, false);
 	}
@@ -513,5 +474,4 @@ var When = class {
 function when(condition, options) {
 	return new When(condition, options);
 }
-
-export { delay, isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };
+export { delay, isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };

package/dist/timer.js

@@ -3,21 +3,33 @@ import { stop, work } from "./work.js";
 import { noop } from "@oscarpalmer/atoms/function";
 var Timer = class {
 	state;
+	/**
+	* Is the timer active?
+	*/
 	get active() {
 		return this.state.active;
 	}
+	/**
+	* Is the timer destroyed?
+	*/
 	get destroyed() {
 		return this.state.destroyed;
 	}
+	/**
+	* Is the timer paused?
+	*/
 	get paused() {
 		return this.state.paused;
 	}
+	/**
+	* Get the timer's origin _(if debugging is enabled)_
+	*/
 	get trace() {
 		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.trace : void 0;
 	}
 	constructor(type, state, options, start) {
 		this.options = options;
-		this.$timer = type;
+		Object.defineProperty(this, "$timer", { value: type });
 		this.state = {
 			...state,
 			active: false,
@@ -30,9 +42,15 @@ var Timer = class {
 		};
 		if (start) this.start();
 	}
+	/**
+	* Continue running the timer _(if it's paused)_
+	*/
 	continue() {
 		return this.#work(WORK_CONTINUE);
 	}
+	/**
+	* Destroy the timer
+	*/
 	destroy() {
 		this.state.destroyed = true;
 		this.options.onAfter = noop;
@@ -44,15 +62,27 @@ var Timer = class {
 			type: this.$timer
 		}, this.state, this.options);
 	}
+	/**
+	* Pause the timer _(if it's running)_
+	*/
 	pause() {
 		return this.#work(WORK_PAUSE);
 	}
+	/**
+	* Restart the timer _(or start it, if it's not running)_
+	*/
 	restart() {
 		return this.#work(WORK_RESTART);
 	}
+	/**
+	* Start the timer _(if it's not running)_
+	*/
 	start() {
 		return this.#work(WORK_START);
 	}
+	/**
+	* Stop the timer _(if it's running)_
+	*/
 	stop() {
 		return this.#work(WORK_STOP);
 	}

package/dist/wait.js

@@ -1,8 +1,13 @@
-import { MILLISECONDS, TYPE_WAIT } from "./constants.js";
+import { FRAME_RATE_MS, TYPE_WAIT } from "./constants.js";
 import { getCallback, getValidNumber } from "./get.js";
 import "./global.js";
 import { TimerTrace } from "./models.js";
 import { Timer } from "./timer.js";
+/**
+* Create a waiting timer
+* @param callback Callback to run when the timer has finished
+* @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
+*/
 function wait(callback, time) {
 	return new Timer(TYPE_WAIT, {
 		callback: getCallback(callback),
@@ -11,7 +16,7 @@ function wait(callback, time) {
 		onAfter: void 0,
 		onError: void 0,
 		count: -1,
-		interval: getValidNumber(time, MILLISECONDS),
+		interval: getValidNumber(time, FRAME_RATE_MS),
 		timeout: 0
 	}, true);
 }

package/dist/when.js

@@ -1,11 +1,10 @@
-import { MESSAGE_DESTROYED, MESSAGE_STARTED, MILLISECONDS, TYPE_WHEN } from "./constants.js";
+import { FRAME_RATE_MS, MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN } from "./constants.js";
 import { getValidNumber, getValidTimeout } from "./get.js";
 import "./global.js";
 import { TimerTrace } from "./models.js";
 import { Timer } from "./timer.js";
 import { noop } from "@oscarpalmer/atoms/function";
 var When = class {
-	$timer = TYPE_WHEN;
 	state = {
 		promise: void 0,
 		rejecter: void 0,
@@ -13,19 +12,32 @@ var When = class {
 		started: false,
 		timer: void 0
 	};
+	/**
+	* Is the timer active?
+	*/
 	get active() {
 		return this.state.timer?.active ?? false;
 	}
+	/**
+	* Is the timer destroyed?
+	*/
 	get destroyed() {
 		return this.state.timer == null;
 	}
+	/**
+	* Is the timer paused?
+	*/
 	get paused() {
 		return this.state.timer?.paused ?? false;
 	}
+	/**
+	* Get the timer's origin _(if debugging is enabled)_
+	*/
 	get trace() {
 		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.timer?.trace : void 0;
 	}
 	constructor(condition, options) {
+		Object.defineProperty(this, "$timer", { value: TYPE_WHEN });
 		const { state } = this;
 		state.promise = new Promise((resolve, reject) => {
 			state.resolver = resolve;
@@ -55,14 +67,20 @@ var When = class {
 				this.destroy();
 			},
 			count: getValidNumber(options?.count),
-			interval: getValidNumber(options?.interval, MILLISECONDS),
+			interval: getValidNumber(options?.interval, FRAME_RATE_MS),
 			timeout: getValidTimeout(options?.timeout)
 		}, false);
 	}
+	/**
+	* Continues the timer _(if it was paused)_
+	*/
 	continue() {
 		this.state.timer?.continue();
 		return this;
 	}
+	/**
+	* Destroys the timer _(and stops it,if it was running)_
+	*/
 	destroy() {
 		const { state } = this;
 		state.timer?.destroy();
@@ -71,10 +89,19 @@ var When = class {
 		state.rejecter = noop;
 		state.timer = void 0;
 	}
+	/**
+	* Pauses the timer _(if it was running)_
+	*/
 	pause() {
 		this.state.timer?.pause();
 		return this;
 	}
+	/**
+	* Start the timer
+	* @param resolve Optional resolve callback
+	* @param reject Optional reject callback
+	* @returns Promise that resolves when the condition is met
+	*/
 	start(resolve, reject) {
 		const { state } = this;
 		if (state.timer == null) throw new Error(MESSAGE_DESTROYED);
@@ -83,14 +110,30 @@ var When = class {
 		state.timer.start();
 		return state.promise.then(resolve ?? noop, reject ?? noop);
 	}
+	/**
+	* Stops the timer _(if it was running)_
+	*/
 	stop() {
 		this.state.timer?.stop();
 		return this;
 	}
+	/**
+	* Start the timer
+	* @deprecated Use `start()` instead
+	* @param resolve Optional resolve callback
+	* @param reject Optional reject callback
+	* @returns Promise that resolves when the condition is met
+	*/
 	then(resolve, reject) {
 		return this.start(resolve, reject);
 	}
 };
+/**
+* Create a conditional timer
+* @param condition Condition to check
+* @param options Timer options
+* @returns Timer instance
+*/
 function when(condition, options) {
 	return new When(condition, options);
 }

package/dist/work.js

@@ -1,4 +1,4 @@
-import { BUFFER_INTERVAL, MILLISECONDS, TIMERS_ACTIVE, TYPE_WAIT, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.js";
+import { BUFFER_INTERVAL, FRAME_RATE_MS, TIMERS_ACTIVE, TYPE_WAIT, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.js";
 function finish(timer, state, options, success) {
 	cancelAnimationFrame(state.frame);
 	TIMERS_ACTIVE.delete(timer.instance);
@@ -34,7 +34,7 @@ function run(timer, state, options) {
 			finish(timer, state, options, false);
 			return;
 		}
-		if (options.interval === MILLISECONDS || state.elapsed >= options.interval - 5) {
+		if (options.interval === FRAME_RATE_MS || state.elapsed >= options.interval - 5) {
 			if (options.count > -1) state.callback(state.index);
 			start = now;
 			state.elapsed = 0;

package/package.json

@@ -4,19 +4,19 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.115"
+		"@oscarpalmer/atoms": "^0.117"
 	},
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"@types/node": "^25",
+		"@types/node": "^25.2",
 		"@vitest/coverage-istanbul": "^4",
-		"jsdom": "^27.3",
-		"oxfmt": "^0.18",
-		"oxlint": "^1.33",
-		"rolldown": "1.0.0-beta.55",
+		"jsdom": "^28.1",
+		"oxfmt": "^0.33",
+		"oxlint": "^1.48",
+		"rolldown": "1.0.0-rc.4",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
-		"vite": "8.0.0-beta.2",
+		"vite": "8.0.0-beta.14",
 		"vitest": "^4"
 	},
 	"exports": {
@@ -64,11 +64,11 @@
 		"build": "npm run clean && npx vite build && npm run rolldown:build && npx tsc",
 		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
 		"rolldown:build": "npx rolldown -c",
-		"rolldown:watch": "npx rolldown -c --watch",
+		"rolldown:watch": "npx rolldown -c ./rolldown.config.js --watch",
 		"test": "npx vitest --coverage",
 		"watch": "npx vite build --watch"
 	},
 	"type": "module",
 	"types": "types/index.d.ts",
-	"version": "0.38.1"
+	"version": "0.40.0"
 }

package/src/constants.ts

@@ -1,39 +1,7 @@
+import FRAME_RATE_MS from '@oscarpalmer/atoms/frame-rate';
 import type {TimerType, WorkHandlerType} from './models';
 import type {Timer} from './timer';
 
-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);
-			}
-		}
-
-		requestAnimationFrame(step);
-	});
-}
-
-//
-
 /**
  * Buffer value to use when evaluating if a specific time is within a certain range
  */
@@ -77,13 +45,4 @@ export const WORK_START: WorkHandlerType = 'start';
 
 export const WORK_STOP: WorkHandlerType = 'stop';
 
-//
-
-/**
- * A calculated average of the refresh rate of the display _(in milliseconds)_
- */
-export let MILLISECONDS = 1000 / 60;
-
-calculate().then(value => {
-	MILLISECONDS = value;
-});
+export {FRAME_RATE_MS};

package/src/delay.ts

@@ -1,4 +1,3 @@
-import {BUFFER_INTERVAL, MILLISECONDS} from './constants';
 import {getValidNumber} from './get';
 
 /**
@@ -7,21 +6,5 @@ import {getValidNumber} from './get';
  * @returns A promise that resolves after the delay
  */
 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 - BUFFER_INTERVAL) {
-				resolve();
-			} else {
-				requestAnimationFrame(step);
-			}
-		}
-
-		requestAnimationFrame(step);
-	});
+	return new Promise(resolve => setTimeout(resolve, getValidNumber(time)));
 }

package/src/repeat.ts

@@ -1,4 +1,4 @@
-import {MILLISECONDS, TYPE_REPEAT} from './constants';
+import {FRAME_RATE_MS, TYPE_REPEAT} from './constants';
 import {getCallback, getValidNumber} from './get';
 import './global';
 import {type RepeatOptions, TimerTrace} from './models';
@@ -21,7 +21,7 @@ export function repeat(callback: (index: number) => void, options?: Partial<Repe
 			onAfter: getCallback(options?.onAfter),
 			onError: getCallback(options?.onTimeout),
 			count: getValidNumber(options?.count),
-			interval: getValidNumber(options?.interval, MILLISECONDS),
+			interval: getValidNumber(options?.interval, FRAME_RATE_MS),
 			timeout: getValidNumber(options?.timeout),
 		},
 		true,

package/src/timer.ts

@@ -42,7 +42,9 @@ export class Timer {
 		protected readonly options: TimerOptions,
 		start: boolean,
 	) {
-		this.$timer = type;
+		Object.defineProperty(this, '$timer', {
+			value: type,
+		});
 
 		this.state = {
 			...state,

package/src/wait.ts

@@ -1,4 +1,4 @@
-import {MILLISECONDS, TYPE_WAIT} from './constants';
+import {FRAME_RATE_MS, TYPE_WAIT} from './constants';
 import {getCallback, getValidNumber} from './get';
 import './global';
 import {TimerTrace} from './models';
@@ -20,7 +20,7 @@ export function wait(callback: () => void, time?: number): Timer {
 			onAfter: undefined,
 			onError: undefined,
 			count: -1,
-			interval: getValidNumber(time, MILLISECONDS),
+			interval: getValidNumber(time, FRAME_RATE_MS),
 			timeout: 0,
 		},
 		true,

package/src/when.ts

@@ -1,12 +1,12 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import {MESSAGE_DESTROYED, MILLISECONDS, MESSAGE_STARTED, TYPE_WHEN} from './constants';
+import {FRAME_RATE_MS, MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN} from './constants';
 import {getValidNumber, getValidTimeout} from './get';
 import './global';
 import {TimerTrace, type WhenOptions, type WhenState} from './models';
 import {Timer} from './timer';
 
 class When {
-	private readonly $timer = TYPE_WHEN;
+	declare private readonly $timer: string;
 
 	private readonly state: WhenState = {
 		promise: undefined as never,
@@ -45,6 +45,10 @@ class When {
 	}
 
 	constructor(condition: () => boolean, options?: Partial<WhenOptions>) {
+		Object.defineProperty(this, '$timer', {
+			value: TYPE_WHEN,
+		});
+
 		const {state} = this;
 
 		state.promise = new Promise<void>((resolve, reject) => {
@@ -86,7 +90,7 @@ class When {
 					this.destroy();
 				},
 				count: getValidNumber(options?.count),
-				interval: getValidNumber(options?.interval, MILLISECONDS),
+				interval: getValidNumber(options?.interval, FRAME_RATE_MS),
 				timeout: getValidTimeout(options?.timeout),
 			},
 			false,

package/src/work.ts

@@ -1,7 +1,7 @@
 import {
 	TIMERS_ACTIVE,
 	BUFFER_INTERVAL,
-	MILLISECONDS,
+	FRAME_RATE_MS,
 	TYPE_WAIT,
 	WORK_CONTINUE,
 	WORK_PAUSE,
@@ -84,7 +84,7 @@ function run(
 			return;
 		}
 
-		if (options.interval === MILLISECONDS || state.elapsed >= options.interval - BUFFER_INTERVAL) {
+		if (options.interval === FRAME_RATE_MS || state.elapsed >= options.interval - BUFFER_INTERVAL) {
 			if (options.count > -1) {
 				(state.callback as (index: number) => void)(state.index);
 			}

package/types/constants.d.ts

@@ -1,3 +1,4 @@
+import FRAME_RATE_MS from '@oscarpalmer/atoms/frame-rate';
 import type { TimerType, WorkHandlerType } from './models';
 import type { Timer } from './timer';
 /**
@@ -29,7 +30,4 @@ export declare const WORK_PAUSE: WorkHandlerType;
 export declare const WORK_RESTART: WorkHandlerType;
 export declare const WORK_START: WorkHandlerType;
 export declare const WORK_STOP: WorkHandlerType;
-/**
- * A calculated average of the refresh rate of the display _(in milliseconds)_
- */
-export declare let MILLISECONDS: number;
+export { FRAME_RATE_MS };