@oscarpalmer/timer 0.39.0 → 0.41.0

package/dist/constants.js

@@ -1,9 +1,23 @@
-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";
@@ -13,4 +27,4 @@ const WORK_PAUSE = "pause";
 const WORK_RESTART = "restart";
 const WORK_START = "start";
 const WORK_STOP = "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 };
+export { BUFFER_INTERVAL, DEFAULT_TIMEOUT, 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/index.js

@@ -1,7 +1,7 @@
-import { delay } from "./delay.js";
 import "./global.js";
 import { isRepeated, isTimer, isWaited, isWhen } from "./is.js";
 import { repeat } from "./repeat.js";
 import { wait } from "./wait.js";
 import { when } from "./when.js";
+import { delay } from "@oscarpalmer/atoms/promise";
 export { delay, isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };

package/dist/is.js

@@ -1,16 +1,36 @@
-import { TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN } from "./constants.js";
+import { TYPE_REPEAT, TYPE_WAIT } 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 { FRAME_RATE_MS, TYPE_REPEAT } from "./constants.js";
+import { 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, FRAME_RATE_MS),
+		interval: getValidNumber(options?.interval),
 		timeout: getValidNumber(options?.timeout)
 	}, true);
 }

package/dist/timer.full.js

@@ -1,29 +1,23 @@
-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(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
+*/
 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";
@@ -47,57 +41,125 @@ document.addEventListener("visibilitychange", () => {
 	}
 	from.clear();
 });
-function noop() {}
-new Set([
-	Int8Array,
-	Uint8Array,
-	Uint8ClampedArray,
-	Int16Array,
-	Uint16Array,
-	Int32Array,
-	Uint32Array,
-	Float32Array,
-	Float64Array,
-	BigInt64Array,
-	BigUint64Array
-]);
-function getCallback(value) {
-	return typeof value === "function" ? value : noop;
+const PROMISE_ABORT_OPTIONS = { once: true };
+const PROMISE_EVENT_NAME = "abort";
+function getNumberOrDefault(value) {
+	return typeof value === "number" && value > 0 ? value : 0;
 }
-function getValidTimeout(value) {
-	return typeof value === "number" && value > 0 ? value : DEFAULT_TIMEOUT;
+function getPromiseOptions(input) {
+	if (typeof input === "number") return { time: getNumberOrDefault(input) };
+	if (input instanceof AbortSignal) return {
+		signal: input,
+		time: 0
+	};
+	const options = typeof input === "object" && input !== null ? input : {};
+	return {
+		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
+		time: getNumberOrDefault(options.time)
+	};
 }
-function getValidNumber(value, defaultValue) {
-	const actualDefault = defaultValue ?? 0;
-	return typeof value === "number" && value > actualDefault ? value : actualDefault;
+function settlePromise(aborter, settler, value, signal) {
+	signal?.removeEventListener(PROMISE_EVENT_NAME, aborter);
+	settler(value);
 }
-function delay(time) {
-	return new Promise((resolve) => {
-		const interval = getValidNumber(time, frame_rate_default);
-		let start;
-		function step(now) {
-			start ??= now;
-			if (interval === frame_rate_default || now - start >= interval - BUFFER_INTERVAL) resolve();
-			else requestAnimationFrame(step);
-		}
-		requestAnimationFrame(step);
+function getInterval(value) {
+	return typeof value === "number" && value > 0 ? value : 0;
+}
+function getTimer(type, callback, time) {
+	const interval = getInterval(time);
+	function run(now) {
+		start ??= now;
+		if (interval === 0 || now - start >= interval - OFFSET) {
+			if (throttle) start = now;
+			callback(...args);
+		} else frame = requestAnimationFrame(run);
+	}
+	const throttle = type === TIMER_THROTTLE;
+	let args;
+	let frame;
+	let start;
+	const timer = (...parameters) => {
+		timer.cancel();
+		args = parameters;
+		frame = requestAnimationFrame(run);
+	};
+	timer.cancel = () => {
+		cancelAnimationFrame(frame);
+	};
+	return timer;
+}
+var OFFSET = 5;
+const TIMER_THROTTLE = "throttle";
+const TIMER_WAIT = "wait";
+function delay(options) {
+	const { signal, time } = getPromiseOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	function abort() {
+		timer.cancel();
+		rejector(signal.reason);
+	}
+	const timer = getTimer(TIMER_WAIT, () => {
+		settlePromise(abort, resolver, void 0, signal);
+	}, time);
+	signal?.addEventListener("abort", abort, PROMISE_ABORT_OPTIONS);
+	let rejector;
+	let resolver;
+	return new Promise((resolve, reject) => {
+		rejector = reject;
+		resolver = resolve;
+		if (time === 0) settlePromise(abort, resolve, void 0, signal);
+		else timer();
 	});
 }
 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([TYPE_WHEN], value) && typeof value.then === "function";
 }
+/**
+* A function that does nothing, which can be useful, I guess…
+*/
+function noop() {}
+function getCallback(value) {
+	return typeof value === "function" ? value : noop;
+}
+function getValidTimeout(value) {
+	return typeof value === "number" && value > 0 ? value : DEFAULT_TIMEOUT;
+}
+function getValidNumber(value, defaultValue) {
+	const actualDefault = defaultValue ?? 0;
+	return typeof value === "number" && value > actualDefault ? value : actualDefault;
+}
 var TimerTrace = class extends Error {
 	constructor() {
 		super();
@@ -139,7 +201,7 @@ function run(timer, state, options) {
 			finish(timer, state, options, false);
 			return;
 		}
-		if (options.interval === frame_rate_default || state.elapsed >= options.interval - BUFFER_INTERVAL) {
+		if (options.interval === 0 || state.elapsed >= options.interval - BUFFER_INTERVAL) {
 			if (options.count > -1) state.callback(state.index);
 			start = now;
 			state.elapsed = 0;
@@ -185,15 +247,27 @@ function work(type, timer, state, options) {
 }
 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;
 	}
@@ -212,9 +286,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;
@@ -226,15 +306,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);
 	}
@@ -245,6 +337,12 @@ var Timer = class {
 		}, this.state, this.options);
 	}
 };
+/**
+* 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),
@@ -253,10 +351,15 @@ function repeat(callback, options) {
 		onAfter: getCallback(options?.onAfter),
 		onError: getCallback(options?.onTimeout),
 		count: getValidNumber(options?.count),
-		interval: getValidNumber(options?.interval, frame_rate_default),
+		interval: getValidNumber(options?.interval),
 		timeout: getValidNumber(options?.timeout)
 	}, true);
 }
+/**
+* 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),
@@ -265,7 +368,7 @@ function wait(callback, time) {
 		onAfter: void 0,
 		onError: void 0,
 		count: -1,
-		interval: getValidNumber(time, frame_rate_default),
+		interval: getValidNumber(time),
 		timeout: 0
 	}, true);
 }
@@ -277,15 +380,27 @@ 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;
 	}
@@ -320,14 +435,20 @@ var When = class {
 				this.destroy();
 			},
 			count: getValidNumber(options?.count),
-			interval: getValidNumber(options?.interval, frame_rate_default),
+			interval: getValidNumber(options?.interval),
 			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();
@@ -336,10 +457,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);
@@ -348,14 +478,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/timer.js

@@ -3,15 +3,27 @@ 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;
 	}
@@ -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 { FRAME_RATE_MS, TYPE_WAIT } from "./constants.js";
+import { 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, FRAME_RATE_MS),
+		interval: getValidNumber(time),
 		timeout: 0
 	}, true);
 }

package/dist/when.js

@@ -1,4 +1,4 @@
-import { FRAME_RATE_MS, MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN } from "./constants.js";
+import { MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN } from "./constants.js";
 import { getValidNumber, getValidTimeout } from "./get.js";
 import "./global.js";
 import { TimerTrace } from "./models.js";
@@ -12,15 +12,27 @@ 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;
 	}
@@ -55,14 +67,20 @@ var When = class {
 				this.destroy();
 			},
 			count: getValidNumber(options?.count),
-			interval: getValidNumber(options?.interval, FRAME_RATE_MS),
+			interval: getValidNumber(options?.interval),
 			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, FRAME_RATE_MS, TIMERS_ACTIVE, TYPE_WAIT, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.js";
+import { TIMERS_ACTIVE, WORK_PAUSE, 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 === FRAME_RATE_MS || state.elapsed >= options.interval - 5) {
+		if (options.interval === 0 || 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.117"
+		"@oscarpalmer/atoms": "^0.152"
 	},
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"@types/node": "^25",
+		"@types/node": "^25.3",
 		"@vitest/coverage-istanbul": "^4",
-		"jsdom": "^27.3",
-		"oxfmt": "^0.19",
-		"oxlint": "^1.34",
-		"rolldown": "1.0.0-beta.55",
+		"jsdom": "^28.1",
+		"oxfmt": "^0.36",
+		"oxlint": "^1.51",
+		"rolldown": "1.0.0-rc.6",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
-		"vite": "8.0.0-beta.2",
+		"vite": "8.0.0-beta.16",
 		"vitest": "^4"
 	},
 	"exports": {
@@ -70,5 +70,5 @@
 	},
 	"type": "module",
 	"types": "types/index.d.ts",
-	"version": "0.39.0"
+	"version": "0.41.0"
 }

package/src/constants.ts

@@ -1,4 +1,3 @@
-import FRAME_RATE_MS from '@oscarpalmer/atoms/frame-rate';
 import type {TimerType, WorkHandlerType} from './models';
 import type {Timer} from './timer';
 
@@ -44,5 +43,3 @@ export const WORK_RESTART: WorkHandlerType = 'restart';
 export const WORK_START: WorkHandlerType = 'start';
 
 export const WORK_STOP: WorkHandlerType = 'stop';
-
-export {FRAME_RATE_MS};

package/src/index.ts

@@ -1,6 +1,6 @@
 import './global';
 
-export * from './delay';
+export {delay} from '@oscarpalmer/atoms/promise';
 export {isRepeated, isTimer, isWaited, isWhen} from './is';
 export * from './repeat';
 export type {Timer} from './timer';

package/src/repeat.ts

@@ -1,4 +1,4 @@
-import {FRAME_RATE_MS, TYPE_REPEAT} from './constants';
+import {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, FRAME_RATE_MS),
+			interval: getValidNumber(options?.interval),
 			timeout: getValidNumber(options?.timeout),
 		},
 		true,

package/src/wait.ts

@@ -1,4 +1,4 @@
-import {FRAME_RATE_MS, TYPE_WAIT} from './constants';
+import {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, FRAME_RATE_MS),
+			interval: getValidNumber(time),
 			timeout: 0,
 		},
 		true,

package/src/when.ts

@@ -1,12 +1,12 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import {FRAME_RATE_MS, MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN} from './constants';
+import {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 declare readonly $timer: string;
+	declare private readonly $timer: string;
 
 	private readonly state: WhenState = {
 		promise: undefined as never,
@@ -90,7 +90,7 @@ class When {
 					this.destroy();
 				},
 				count: getValidNumber(options?.count),
-				interval: getValidNumber(options?.interval, FRAME_RATE_MS),
+				interval: getValidNumber(options?.interval),
 				timeout: getValidTimeout(options?.timeout),
 			},
 			false,

package/src/work.ts

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

package/types/constants.d.ts

@@ -1,4 +1,3 @@
-import FRAME_RATE_MS from '@oscarpalmer/atoms/frame-rate';
 import type { TimerType, WorkHandlerType } from './models';
 import type { Timer } from './timer';
 /**
@@ -30,4 +29,3 @@ export declare const WORK_PAUSE: WorkHandlerType;
 export declare const WORK_RESTART: WorkHandlerType;
 export declare const WORK_START: WorkHandlerType;
 export declare const WORK_STOP: WorkHandlerType;
-export { FRAME_RATE_MS };

package/types/index.d.ts

@@ -1,5 +1,5 @@
 import './global';
-export * from './delay';
+export { delay } from '@oscarpalmer/atoms/promise';
 export { isRepeated, isTimer, isWaited, isWhen } from './is';
 export * from './repeat';
 export type { Timer } from './timer';

package/dist/delay.js

@@ -1,15 +0,0 @@
-import { BUFFER_INTERVAL, FRAME_RATE_MS } from "./constants.js";
-import { getValidNumber } from "./get.js";
-function delay(time) {
-	return new Promise((resolve) => {
-		const interval = getValidNumber(time, FRAME_RATE_MS);
-		let start;
-		function step(now) {
-			start ??= now;
-			if (interval === FRAME_RATE_MS || now - start >= interval - 5) resolve();
-			else requestAnimationFrame(step);
-		}
-		requestAnimationFrame(step);
-	});
-}
-export { delay };

package/src/delay.ts

@@ -1,27 +0,0 @@
-import {BUFFER_INTERVAL, FRAME_RATE_MS} from './constants';
-import {getValidNumber} from './get';
-
-/**
- * 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
- */
-export function delay(time?: number): Promise<void> {
-	return new Promise(resolve => {
-		const interval = getValidNumber(time, FRAME_RATE_MS);
-
-		let start: DOMHighResTimeStamp;
-
-		function step(now: DOMHighResTimeStamp) {
-			start ??= now;
-
-			if (interval === FRAME_RATE_MS || now - start >= interval - BUFFER_INTERVAL) {
-				resolve();
-			} else {
-				requestAnimationFrame(step);
-			}
-		}
-
-		requestAnimationFrame(step);
-	});
-}

package/types/delay.d.ts

@@ -1,6 +0,0 @@
-/**
- * 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
- */
-export declare function delay(time?: number): Promise<void>;