@oscarpalmer/timer 0.37.0 → 0.38.1

package/dist/wait.js

@@ -1,4 +1,4 @@
-import { TYPE_WAIT, milliseconds } from "./constants.js";
+import { MILLISECONDS, TYPE_WAIT } from "./constants.js";
 import { getCallback, getValidNumber } from "./get.js";
 import "./global.js";
 import { TimerTrace } from "./models.js";
@@ -11,7 +11,7 @@ function wait(callback, time) {
 		onAfter: void 0,
 		onError: void 0,
 		count: -1,
-		interval: getValidNumber(time, milliseconds),
+		interval: getValidNumber(time, MILLISECONDS),
 		timeout: 0
 	}, true);
 }

package/dist/when.js

@@ -1,4 +1,4 @@
-import { TYPE_WHEN, destroyedMessage, milliseconds, startedMessage } from "./constants.js";
+import { MESSAGE_DESTROYED, MESSAGE_STARTED, MILLISECONDS, TYPE_WHEN } from "./constants.js";
 import { getValidNumber, getValidTimeout } from "./get.js";
 import "./global.js";
 import { TimerTrace } from "./models.js";
@@ -55,7 +55,7 @@ var When = class {
 				this.destroy();
 			},
 			count: getValidNumber(options?.count),
-			interval: getValidNumber(options?.interval, milliseconds),
+			interval: getValidNumber(options?.interval, MILLISECONDS),
 			timeout: getValidTimeout(options?.timeout)
 		}, false);
 	}
@@ -75,17 +75,20 @@ var When = class {
 		this.state.timer?.pause();
 		return this;
 	}
+	start(resolve, reject) {
+		const { state } = this;
+		if (state.timer == null) throw new Error(MESSAGE_DESTROYED);
+		if (state.started) throw new Error(MESSAGE_STARTED);
+		state.started = true;
+		state.timer.start();
+		return state.promise.then(resolve ?? noop, reject ?? noop);
+	}
 	stop() {
 		this.state.timer?.stop();
 		return this;
 	}
 	then(resolve, reject) {
-		const { state } = this;
-		if (state.timer == null) throw new Error(destroyedMessage);
-		if (state.started) throw new Error(startedMessage);
-		state.started = true;
-		state.timer.start();
-		return state.promise.then(resolve ?? noop, reject ?? noop);
+		return this.start(resolve, reject);
 	}
 };
 function when(condition, options) {

package/dist/work.js

@@ -1,7 +1,7 @@
-import { TYPE_WAIT, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP, activeTimers, intervalBuffer, milliseconds } from "./constants.js";
+import { BUFFER_INTERVAL, MILLISECONDS, 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);
-	activeTimers.delete(timer.instance);
+	TIMERS_ACTIVE.delete(timer.instance);
 	state.active = false;
 	state.elapsed = 0;
 	state.frame = void 0;
@@ -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 === MILLISECONDS || state.elapsed >= options.interval - 5) {
 			if (options.count > -1) state.callback(state.index);
 			start = now;
 			state.elapsed = 0;
@@ -55,7 +55,7 @@ function setState(type, state) {
 }
 function stop(timer, state, options) {
 	cancelAnimationFrame(state.frame);
-	activeTimers.delete(timer.instance);
+	TIMERS_ACTIVE.delete(timer.instance);
 	options.onAfter?.(false);
 	state.active = !stop;
 	state.frame = void 0;
@@ -73,7 +73,7 @@ function work(type, timer, state, options) {
 	state.active = true;
 	state.paused = type === WORK_PAUSE;
 	if (state.paused) return pause(timer, state);
-	activeTimers.add(timer.instance);
+	TIMERS_ACTIVE.add(timer.instance);
 	const runner = run(timer, state, options);
 	state.frame = requestAnimationFrame(runner);
 	return timer.instance;

package/package.json

@@ -4,21 +4,20 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.109"
+		"@oscarpalmer/atoms": "^0.115"
 	},
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"@biomejs/biome": "^2.2",
-		"@rollup/plugin-node-resolve": "^16",
-		"@rollup/plugin-typescript": "^12.1",
-		"@types/node": "^24.5",
-		"@vitest/coverage-istanbul": "^3.2",
-		"jsdom": "^27",
-		"rollup": "^4.50",
+		"@types/node": "^25",
+		"@vitest/coverage-istanbul": "^4",
+		"jsdom": "^27.3",
+		"oxfmt": "^0.18",
+		"oxlint": "^1.33",
+		"rolldown": "1.0.0-beta.55",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
-		"vite": "npm:rolldown-vite@latest",
-		"vitest": "^3.2"
+		"vite": "8.0.0-beta.2",
+		"vitest": "^4"
 	},
 	"exports": {
 		"./package.json": "./package.json",
@@ -49,10 +48,10 @@
 		"types"
 	],
 	"keywords": [
-		"timer",
-		"setTimeout",
+		"requestAnimationFrame",
 		"setInterval",
-		"requestAnimationFrame"
+		"setTimeout",
+		"timer"
 	],
 	"license": "MIT",
 	"module": "dist/index.js",
@@ -62,16 +61,14 @@
 		"url": "git+https://github.com/oscarpalmer/timer.git"
 	},
 	"scripts": {
-		"build": "npm run clean && npm run build:js && npm run rollup:build && npx tsc",
-		"build:js": "npx vite build",
+		"build": "npm run clean && npx vite build && npm run rolldown:build && npx tsc",
 		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
-		"rollup:build": "npx rollup -c",
-		"rollup:watch": "npx rollup -c --watch",
+		"rolldown:build": "npx rolldown -c",
+		"rolldown:watch": "npx rolldown -c --watch",
 		"test": "npx vitest --coverage",
-		"types": "npx tsc && npx dts-bundle-generator --config ./dts.config.cts --silent",
 		"watch": "npx vite build --watch"
 	},
 	"type": "module",
 	"types": "types/index.d.ts",
-	"version": "0.37.0"
-}
+	"version": "0.38.1"
+}

package/src/constants.ts

@@ -34,41 +34,47 @@ function calculate(): Promise<number> {
 
 //
 
-export const defaultTimeout = 30_000;
-
 /**
- * A set of all active timers
+ * Buffer value to use when evaluating if a specific time is within a certain range
  */
-export const activeTimers = new Set<Timer>();
+export const BUFFER_INTERVAL = 5;
+
+export const DEFAULT_TIMEOUT = 30_000;
 
 /**
- * Buffer value to use when evaluating if a specific time is within a certain range
+ * Message to show when a when-timer is destroyed
  */
-export const intervalBuffer = 5;
+export const MESSAGE_DESTROYED = 'Timer has already been destroyed';
 
 /**
- * Message to show when a when-timer is destroyed
+ * Message to show when a when-timer is started
  */
-export const destroyedMessage = 'Timer has already been destroyed';
+export const MESSAGE_STARTED = 'Timer has already been started';
 
 /**
- * A set of timers that were paused due to the document being hidden
+ * A set of all active timers
  */
-export const hiddenTimers = new Set<Timer>();
+export const TIMERS_ACTIVE = new Set<Timer>();
 
 /**
- * Message to show when a when-timer is started
+ * A set of timers that were paused due to the document being hidden
  */
-export const startedMessage = 'Timer has already been started';
+export const TIMERS_HIDDEN = new Set<Timer>();
 
 export const TYPE_REPEAT: TimerType = 'repeat';
+
 export const TYPE_WAIT: TimerType = 'wait';
+
 export const TYPE_WHEN: TimerType = 'when';
 
 export const WORK_CONTINUE: WorkHandlerType = 'continue';
+
 export const WORK_PAUSE: WorkHandlerType = 'pause';
+
 export const WORK_RESTART: WorkHandlerType = 'restart';
+
 export const WORK_START: WorkHandlerType = 'start';
+
 export const WORK_STOP: WorkHandlerType = 'stop';
 
 //
@@ -76,8 +82,8 @@ export const WORK_STOP: WorkHandlerType = 'stop';
 /**
  * A calculated average of the refresh rate of the display _(in milliseconds)_
  */
-export let milliseconds = 1000 / 60;
+export let MILLISECONDS = 1000 / 60;
 
 calculate().then(value => {
-	milliseconds = value;
+	MILLISECONDS = value;
 });

package/src/delay.ts

@@ -1,22 +1,21 @@
-import {intervalBuffer, milliseconds} from './constants';
+import {BUFFER_INTERVAL, 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)_
+ * 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, milliseconds);
+		const interval = getValidNumber(time, MILLISECONDS);
 
 		let start: DOMHighResTimeStamp;
 
 		function step(now: DOMHighResTimeStamp) {
 			start ??= now;
 
-			if (
-				interval === milliseconds ||
-				now - start >= interval - intervalBuffer
-			) {
+			if (interval === MILLISECONDS || now - start >= interval - BUFFER_INTERVAL) {
 				resolve();
 			} else {
 				requestAnimationFrame(step);

package/src/get.ts

@@ -1,19 +1,17 @@
 import type {GenericCallback} from '@oscarpalmer/atoms';
 import {noop} from '@oscarpalmer/atoms/function';
-import {defaultTimeout} from './constants';
+import {DEFAULT_TIMEOUT} from './constants';
 
 export function getCallback(value: unknown): GenericCallback {
 	return typeof value === 'function' ? (value as GenericCallback) : noop;
 }
 
 export function getValidTimeout(value: unknown): number {
-	return typeof value === 'number' && value > 0 ? value : defaultTimeout;
+	return typeof value === 'number' && value > 0 ? value : DEFAULT_TIMEOUT;
 }
 
 export function getValidNumber(value: unknown, defaultValue?: number): number {
 	const actualDefault = defaultValue ?? 0;
 
-	return typeof value === 'number' && value > actualDefault
-		? value
-		: actualDefault;
+	return typeof value === 'number' && value > actualDefault ? value : actualDefault;
 }

package/src/global.ts

@@ -1,9 +1,4 @@
-import {
-	activeTimers,
-	hiddenTimers,
-	WORK_CONTINUE,
-	WORK_PAUSE,
-} from './constants';
+import {TIMERS_ACTIVE, TIMERS_HIDDEN, WORK_CONTINUE, WORK_PAUSE} from './constants';
 import type {Timer} from './timer';
 
 declare global {
@@ -14,16 +9,16 @@ declare global {
 if (globalThis._oscarpalmer_timers == null) {
 	Object.defineProperty(globalThis, '_oscarpalmer_timers', {
 		get() {
-			return globalThis._oscarpalmer_timer_debug ? [...activeTimers] : [];
+			return globalThis._oscarpalmer_timer_debug ? [...TIMERS_ACTIVE] : [];
 		},
 	});
 }
 
 /* istanbul ignore next */
 document.addEventListener('visibilitychange', () => {
-	const from = document.hidden ? activeTimers : hiddenTimers;
+	const from = document.hidden ? TIMERS_ACTIVE : TIMERS_HIDDEN;
 	const method = document.hidden ? WORK_PAUSE : WORK_CONTINUE;
-	const to = document.hidden ? hiddenTimers : activeTimers;
+	const to = document.hidden ? TIMERS_HIDDEN : TIMERS_ACTIVE;
 
 	for (const timer of from) {
 		timer[method]();

package/src/is.ts

@@ -9,6 +9,8 @@ function is(names: string[], value: unknown) {
 
 /**
  * Is the value a repeating timer?
+ * @param value Value to check
+ * @returns `true` if the value is a repeating timer
  */
 export function isRepeated(value: unknown): value is Timer {
 	return is([TYPE_REPEAT], value);
@@ -16,6 +18,8 @@ export function isRepeated(value: unknown): value is Timer {
 
 /**
  * Is the value a timer?
+ * @param value Value to check
+ * @returns `true` if the value is a timer
  */
 export function isTimer(value: unknown): value is Timer {
 	return is([TYPE_REPEAT, TYPE_WAIT], value);
@@ -23,6 +27,8 @@ export function isTimer(value: unknown): value is Timer {
 
 /**
  * Is the value a waiting timer?
+ * @param value Value to check
+ * @returns `true` if the value is a waiting timer
  */
 export function isWaited(value: unknown): value is Timer {
 	return is([TYPE_WAIT], value);
@@ -30,6 +36,8 @@ export function isWaited(value: unknown): value is Timer {
 
 /**
  * Is the value a conditional timer?
+ * @param value Value to check
+ * @returns `true` if the value is a conditional timer
  */
 export function isWhen(value: unknown): value is When {
 	return is([TYPE_WHEN], value) && typeof (value as When).then === 'function';

package/src/models.ts

@@ -4,27 +4,27 @@ import type {Timer} from './timer';
  * Options for a repeating timer
  */
 export type RepeatOptions = {
-		/**
-		 * Callback to be called when the timer has stopped, either manually or by completing its work
-		 */
-		onAfter: (finished: boolean) => void;
-		/**
-		 * Callback to be called after the timer has timed out
-		 */
-		onTimeout: () => void;
-		/**
-		 * How many times the timer should repeat
-		 */
-		count: number;
-		/**
-		 * The interval between each repeat
-		 */
-		interval: number;
-		/**
-		 * The timeout for the timer _(any value above `0` will enable the timeout)_
-		 */
-		timeout: number;
-	};
+	/**
+	 * Callback to be called when the timer has stopped, either manually or by completing its work
+	 */
+	onAfter: (finished: boolean) => void;
+	/**
+	 * Callback to be called after the timer has timed out
+	 */
+	onTimeout: () => void;
+	/**
+	 * How many times the timer should repeat
+	 */
+	count: number;
+	/**
+	 * The interval between each repeat
+	 */
+	interval: number;
+	/**
+	 * The timeout for the timer _(any value above `0` will enable the timeout)_
+	 */
+	timeout: number;
+};
 
 export type TimerOptions = {
 	onAfter: ((finished: boolean) => void) | undefined;
@@ -60,19 +60,19 @@ export type TimerType = 'repeat' | 'wait' | 'when';
  * Options for a conditional timer
  */
 export type WhenOptions = {
-		/**
-		 * How many times the timer should check the condition
-		 */
-		count: number;
-		/**
-		 * Then interval between each condtional check
-		 */
-		interval: number;
-		/**
-		 * The timeout for the timer _(any value above `0` will enable the timeout)_
-		 */
-		timeout: number;
-	};
+	/**
+	 * How many times the timer should check the condition
+	 */
+	count: number;
+	/**
+	 * Then interval between each condtional check
+	 */
+	interval: number;
+	/**
+	 * The timeout for the timer _(any value above `0` will enable the timeout)_
+	 */
+	timeout: number;
+};
 
 export type WhenState = {
 	promise: Promise<void>;
@@ -94,9 +94,4 @@ export type WorkHandlerTimer = {
 	type: TimerType;
 };
 
-export type WorkHandlerType =
-	| 'continue'
-	| 'pause'
-	| 'restart'
-	| 'start'
-	| 'stop';
+export type WorkHandlerType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';

package/src/repeat.ts

@@ -1,4 +1,4 @@
-import {milliseconds, TYPE_REPEAT} from './constants';
+import {MILLISECONDS, TYPE_REPEAT} from './constants';
 import {getCallback, getValidNumber} from './get';
 import './global';
 import {type RepeatOptions, TimerTrace} from './models';
@@ -6,11 +6,11 @@ import {Timer} from './timer';
 
 /**
  * Create a repeating timer
+ * @param callback Callback to run on each interval
+ * @param options Timer options
+ * @returns Timer instance
  */
-export function repeat(
-	callback: (index: number) => void,
-	options?: Partial<RepeatOptions>,
-): Timer {
+export function repeat(callback: (index: number) => void, options?: Partial<RepeatOptions>): Timer {
 	return new Timer(
 		TYPE_REPEAT,
 		{
@@ -21,7 +21,7 @@ export function repeat(
 			onAfter: getCallback(options?.onAfter),
 			onError: getCallback(options?.onTimeout),
 			count: getValidNumber(options?.count),
-			interval: getValidNumber(options?.interval, milliseconds),
+			interval: getValidNumber(options?.interval, MILLISECONDS),
 			timeout: getValidNumber(options?.timeout),
 		},
 		true,

package/src/timer.ts

@@ -1,21 +1,10 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import {
-	WORK_CONTINUE,
-	WORK_PAUSE,
-	WORK_RESTART,
-	WORK_START,
-	WORK_STOP,
-} from './constants';
-import type {
-	TimerOptions,
-	TimerState,
-	TimerType,
-	WorkHandlerType,
-} from './models';
+import {WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP} from './constants';
+import type {TimerOptions, TimerState, TimerType, WorkHandlerType} from './models';
 import {stop, work} from './work';
 
 export class Timer {
-	private declare readonly $timer: TimerType;
+	declare private readonly $timer: TimerType;
 
 	protected readonly state: TimerState;
 
@@ -44,9 +33,7 @@ export class Timer {
 	 * Get the timer's origin _(if debugging is enabled)_
 	 */
 	get trace(): string | undefined {
-		return (globalThis._oscarpalmer_timer_debug ?? false)
-			? this.state.trace
-			: undefined;
+		return (globalThis._oscarpalmer_timer_debug ?? false) ? this.state.trace : undefined;
 	}
 
 	constructor(

package/src/wait.ts

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

package/src/when.ts

@@ -1,10 +1,5 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import {
-	destroyedMessage,
-	milliseconds,
-	startedMessage,
-	TYPE_WHEN,
-} from './constants';
+import {MESSAGE_DESTROYED, MILLISECONDS, MESSAGE_STARTED, TYPE_WHEN} from './constants';
 import {getValidNumber, getValidTimeout} from './get';
 import './global';
 import {TimerTrace, type WhenOptions, type WhenState} from './models';
@@ -46,9 +41,7 @@ class When {
 	 * Get the timer's origin _(if debugging is enabled)_
 	 */
 	get trace(): string | undefined {
-		return (globalThis._oscarpalmer_timer_debug ?? false)
-			? this.state.timer?.trace
-			: undefined;
+		return (globalThis._oscarpalmer_timer_debug ?? false) ? this.state.timer?.trace : undefined;
 	}
 
 	constructor(condition: () => boolean, options?: Partial<WhenOptions>) {
@@ -93,7 +86,7 @@ class When {
 					this.destroy();
 				},
 				count: getValidNumber(options?.count),
-				interval: getValidNumber(options?.interval, milliseconds),
+				interval: getValidNumber(options?.interval, MILLISECONDS),
 				timeout: getValidTimeout(options?.timeout),
 			},
 			false,
@@ -133,30 +126,20 @@ class When {
 	}
 
 	/**
-	 * Stops the timer _(if it was running)_
+	 * Start the timer
+	 * @param resolve Optional resolve callback
+	 * @param reject Optional reject callback
+	 * @returns Promise that resolves when the condition is met
 	 */
-	stop(): When {
-		this.state.timer?.stop();
-
-		return this;
-	}
-
-	/**
-	 * Starts the timer and returns a promise that resolves when the condition is met
-	 */
-	// biome-ignore lint/suspicious/noThenProperty: returning a promise-like object, so it's ok ;)
-	then(
-		resolve?: (() => void) | null,
-		reject?: (() => void) | null,
-	): Promise<void> {
+	start(resolve?: (() => void) | null, reject?: (() => void) | null): Promise<void> {
 		const {state} = this;
 
 		if (state.timer == null) {
-			throw new Error(destroyedMessage);
+			throw new Error(MESSAGE_DESTROYED);
 		}
 
 		if (state.started) {
-			throw new Error(startedMessage);
+			throw new Error(MESSAGE_STARTED);
 		}
 
 		state.started = true;
@@ -165,15 +148,36 @@ class When {
 
 		return state.promise.then(resolve ?? noop, reject ?? noop);
 	}
+
+	/**
+	 * Stops the timer _(if it was running)_
+	 */
+	stop(): When {
+		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
+	 */
+	// oxlint-disable-next-line no-thenable: Returning a promise-like object, so it's ok ;)
+	then(resolve?: (() => void) | null, reject?: (() => void) | null): Promise<void> {
+		return this.start(resolve, reject);
+	}
 }
 
 /**
  * Create a conditional timer
+ * @param condition Condition to check
+ * @param options Timer options
+ * @returns Timer instance
  */
-export function when(
-	condition: () => boolean,
-	options?: Partial<WhenOptions>,
-): When {
+export function when(condition: () => boolean, options?: Partial<WhenOptions>): When {
 	return new When(condition, options);
 }