@oscarpalmer/timer 0.32.0 → 0.34.0

package/dist/work.cjs

@@ -1,87 +1,82 @@
-'use strict';
-
-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;
-}
+const require_constants = require("./constants.cjs");
 function finish(timer, state, options, success) {
-  constants.activeTimers.delete(timer.instance);
-  state.active = false;
-  state.elapsed = 0;
-  state.frame = void 0;
-  if (timer.type === "wait") {
-    state.callback();
-  } else {
-    options.onAfter?.(success);
-  }
+	cancelAnimationFrame(state.frame);
+	require_constants.activeTimers.delete(timer.instance);
+	state.active = false;
+	state.elapsed = 0;
+	state.frame = void 0;
+	if (timer.type === require_constants.TYPE_WAIT) state.callback();
+	else options.onAfter?.(success);
 }
 function ignore(type, state) {
-  return state.destroyed && type !== "stop" || (state.active ? constants.beginTypes.has(type) : constants.endTypes.has(type));
+	if (state.destroyed) return type !== require_constants.WORK_STOP;
+	if (state.paused) return type === require_constants.WORK_PAUSE || type === require_constants.WORK_START;
+	return state.active && type === require_constants.WORK_START;
+}
+function pause(timer, state) {
+	cancelAnimationFrame(state.frame);
+	state.frame = void 0;
+	return timer.instance;
 }
 function run(timer, state, options) {
-  let start;
-  return function step(now) {
-    if (!state.active) {
-      return;
-    }
-    start ??= now;
-    const difference = now - start;
-    state.elapsed += difference;
-    state.total += difference;
-    if (options.timeout > 0 && state.total >= options.timeout) {
-      options.onError?.();
-      finish(timer, state, options, false);
-      return;
-    }
-    if (options.interval === constants.milliseconds || state.elapsed >= options.interval - constants.intervalBuffer) {
-      if (options.count > -1) {
-        state.callback(state.index);
-      }
-      start = now;
-      state.elapsed = 0;
-      state.index += 1;
-      if (options.count === -1 || options.count > 0 && state.index >= options.count) {
-        finish(timer, state, options, true);
-        return;
-      }
-    }
-    state.frame = requestAnimationFrame(step);
-  };
+	let last;
+	let start;
+	return function step(now) {
+		if (!state.active) return;
+		last ??= now;
+		start ??= now;
+		const difference = now - last;
+		state.elapsed += difference;
+		state.total += difference;
+		last = now;
+		if (options.timeout > 0 && state.total >= options.timeout) {
+			options.onError?.();
+			finish(timer, state, options, false);
+			return;
+		}
+		if (options.interval === require_constants.milliseconds || state.elapsed >= options.interval - require_constants.intervalBuffer) {
+			if (options.count > -1) state.callback(state.index);
+			start = now;
+			state.elapsed = 0;
+			state.index += 1;
+			if (options.count === -1 || options.count > 0 && state.index >= options.count) {
+				finish(timer, state, options, true);
+				return;
+			}
+		}
+		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;
+	const pausable = type === require_constants.WORK_CONTINUE || type === require_constants.WORK_PAUSE;
+	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);
+	cancelAnimationFrame(state.frame);
+	require_constants.activeTimers.delete(timer.instance);
+	options.onAfter?.(false);
+	state.active = !stop;
+	state.frame = void 0;
+	state.paused = false;
+	return timer.instance;
 }
 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);
-  const runner = run(timer, state, options);
-  state.frame = requestAnimationFrame(runner);
-  return timer.instance;
+	if (ignore(type, state)) return timer.instance;
+	setState(type, state);
+	if (type === require_constants.WORK_STOP) return stop(timer, state, options);
+	if (type === require_constants.WORK_PAUSE || type === require_constants.WORK_RESTART) {
+		cancelAnimationFrame(state.frame);
+		state.frame = void 0;
+	}
+	state.active = true;
+	state.paused = type === require_constants.WORK_PAUSE;
+	if (state.paused) return pause(timer, state);
+	require_constants.activeTimers.add(timer.instance);
+	const runner = run(timer, state, options);
+	state.frame = requestAnimationFrame(runner);
+	return timer.instance;
 }
-
 exports.stop = stop;
 exports.work = work;

package/dist/work.js

@@ -1,82 +1,81 @@
-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;
-}
+import { TYPE_WAIT, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP, activeTimers, intervalBuffer, milliseconds } from "./constants.js";
 function finish(timer, state, options, success) {
-  activeTimers.delete(timer.instance);
-  state.active = false;
-  state.elapsed = 0;
-  state.frame = void 0;
-  if (timer.type === "wait") {
-    state.callback();
-  } else {
-    options.onAfter?.(success);
-  }
+	cancelAnimationFrame(state.frame);
+	activeTimers.delete(timer.instance);
+	state.active = false;
+	state.elapsed = 0;
+	state.frame = void 0;
+	if (timer.type === TYPE_WAIT) state.callback();
+	else options.onAfter?.(success);
 }
 function ignore(type, state) {
-  return state.destroyed && type !== "stop" || (state.active ? beginTypes.has(type) : endTypes.has(type));
+	if (state.destroyed) return type !== WORK_STOP;
+	if (state.paused) return type === WORK_PAUSE || type === WORK_START;
+	return state.active && type === WORK_START;
+}
+function pause(timer, state) {
+	cancelAnimationFrame(state.frame);
+	state.frame = void 0;
+	return timer.instance;
 }
 function run(timer, state, options) {
-  let start;
-  return function step(now) {
-    if (!state.active) {
-      return;
-    }
-    start ??= now;
-    const difference = now - start;
-    state.elapsed += difference;
-    state.total += difference;
-    if (options.timeout > 0 && state.total >= options.timeout) {
-      options.onError?.();
-      finish(timer, state, options, false);
-      return;
-    }
-    if (options.interval === milliseconds || state.elapsed >= options.interval - intervalBuffer) {
-      if (options.count > -1) {
-        state.callback(state.index);
-      }
-      start = now;
-      state.elapsed = 0;
-      state.index += 1;
-      if (options.count === -1 || options.count > 0 && state.index >= options.count) {
-        finish(timer, state, options, true);
-        return;
-      }
-    }
-    state.frame = requestAnimationFrame(step);
-  };
+	let last;
+	let start;
+	return function step(now) {
+		if (!state.active) return;
+		last ??= now;
+		start ??= now;
+		const difference = now - last;
+		state.elapsed += difference;
+		state.total += difference;
+		last = now;
+		if (options.timeout > 0 && state.total >= options.timeout) {
+			options.onError?.();
+			finish(timer, state, options, false);
+			return;
+		}
+		if (options.interval === milliseconds || state.elapsed >= options.interval - intervalBuffer) {
+			if (options.count > -1) state.callback(state.index);
+			start = now;
+			state.elapsed = 0;
+			state.index += 1;
+			if (options.count === -1 || options.count > 0 && state.index >= options.count) {
+				finish(timer, state, options, true);
+				return;
+			}
+		}
+		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;
+	const pausable = type === WORK_CONTINUE || type === WORK_PAUSE;
+	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);
+	cancelAnimationFrame(state.frame);
+	activeTimers.delete(timer.instance);
+	options.onAfter?.(false);
+	state.active = !stop;
+	state.frame = void 0;
+	state.paused = false;
+	return timer.instance;
 }
 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);
-  const runner = run(timer, state, options);
-  state.frame = requestAnimationFrame(runner);
-  return timer.instance;
+	if (ignore(type, state)) return timer.instance;
+	setState(type, state);
+	if (type === WORK_STOP) return stop(timer, state, options);
+	if (type === WORK_PAUSE || type === WORK_RESTART) {
+		cancelAnimationFrame(state.frame);
+		state.frame = void 0;
+	}
+	state.active = true;
+	state.paused = type === WORK_PAUSE;
+	if (state.paused) return pause(timer, state);
+	activeTimers.add(timer.instance);
+	const runner = run(timer, state, options);
+	state.frame = requestAnimationFrame(runner);
+	return timer.instance;
 }
-
 export { stop, work };

package/package.json

@@ -4,22 +4,23 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.99"
+		"@oscarpalmer/atoms": "^0.106"
 	},
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"@biomejs/biome": "^1.9",
+		"@biomejs/biome": "^2.2",
 		"@rollup/plugin-node-resolve": "^16",
 		"@rollup/plugin-typescript": "^12.1",
-		"@types/node": "^22.15",
-		"@vitest/coverage-istanbul": "^3.1",
+		"@types/node": "^24.3",
+		"@vitest/coverage-istanbul": "^3.2",
 		"dts-bundle-generator": "^9.5",
 		"glob": "^11",
 		"jsdom": "^26.1",
+		"rollup": "^4.47",
 		"tslib": "^2.8",
-		"typescript": "^5.8",
-		"vite": "^6.3",
-		"vitest": "^3.1"
+		"typescript": "^5.9",
+		"vite": "npm:rolldown-vite@latest",
+		"vitest": "^3.2"
 	},
 	"exports": {
 		".": {
@@ -94,5 +95,5 @@
 	},
 	"type": "module",
 	"types": "types/index.d.cts",
-	"version": "0.32.0"
+	"version": "0.34.0"
 }

package/src/constants.ts

@@ -1,4 +1,4 @@
-import type {WorkHandlerType} from './models';
+import type {TimerType, WorkHandlerType} from './models';
 import type {Timer} from './timer';
 
 function calculate(): Promise<number> {
@@ -37,11 +37,6 @@ function calculate(): Promise<number> {
  */
 export const activeTimers = new Set<Timer>();
 
-/**
- * A set of types that allow work to begin
- */
-export const beginTypes = new Set<WorkHandlerType>(['continue', 'start']);
-
 /**
  * Buffer value to use when evaluating if a specific time is within a certain range
  */
@@ -52,32 +47,26 @@ export const intervalBuffer = 5;
  */
 export const destroyedMessage = 'Timer has already been destroyed';
 
-/**
- * A set of types that allow work to end
- */
-export const endTypes = new Set<WorkHandlerType>(['pause', 'stop']);
-
-/**
- * A set of types that allow work to end or restart
- */
-export const endOrRestartTypes = new Set<WorkHandlerType>([
-	'pause',
-	'restart',
-	'stop',
-]);
-
 /**
  * A set of timers that were paused due to the document being hidden
  */
 export const hiddenTimers = new Set<Timer>();
 
-export const pauseTypes = new Set<WorkHandlerType>(['continue', 'pause']);
-
 /**
  * Message to show when a when-timer is started
  */
 export const startedMessage = 'Timer has already been started';
 
+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';
+
 //
 
 /**

package/src/global.ts

@@ -1,4 +1,9 @@
-import {activeTimers, hiddenTimers} from './constants';
+import {
+	activeTimers,
+	hiddenTimers,
+	WORK_CONTINUE,
+	WORK_PAUSE,
+} from './constants';
 import type {Timer} from './timer';
 
 declare global {
@@ -15,16 +20,14 @@ if (globalThis._oscarpalmer_timers == null) {
 }
 
 document.addEventListener('visibilitychange', () => {
-	if (document.hidden) {
-		for (const timer of activeTimers) {
-			hiddenTimers.add(timer);
-			timer.pause();
-		}
-	} else {
-		for (const timer of hiddenTimers) {
-			timer.continue();
-		}
+	const from = document.hidden ? activeTimers : hiddenTimers;
+	const method = document.hidden ? WORK_PAUSE : WORK_CONTINUE;
+	const to = document.hidden ? hiddenTimers : activeTimers;
 
-		hiddenTimers.clear();
+	for (const timer of from) {
+		timer[method]();
+		to.add(timer);
 	}
+
+	from.clear();
 });

package/src/is.ts

@@ -1,4 +1,5 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
+import {TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN} from './constants';
 import type {Timer} from './timer';
 import type {When} from './when';
 
@@ -10,26 +11,26 @@ function is(names: string[], value: unknown) {
  * Is the value a repeating timer?
  */
 export function isRepeated(value: unknown): value is Timer {
-	return is(['repeat'], value);
+	return is([TYPE_REPEAT], value);
 }
 
 /**
  * Is the value a timer?
  */
 export function isTimer(value: unknown): value is Timer {
-	return is(['repeat', 'wait'], value);
+	return is([TYPE_REPEAT, TYPE_WAIT], value);
 }
 
 /**
  * Is the value a waiting timer?
  */
 export function isWaited(value: unknown): value is Timer {
-	return is(['wait'], value);
+	return is([TYPE_WAIT], value);
 }
 
 /**
  * Is the value a conditional timer?
  */
 export function isWhen(value: unknown): value is When {
-	return is(['when'], value) && typeof (value as When).then === 'function';
+	return is([TYPE_WHEN], value) && typeof (value as When).then === 'function';
 }

package/src/repeat.ts

@@ -1,4 +1,4 @@
-import {milliseconds} from './constants';
+import {milliseconds, TYPE_REPEAT} from './constants';
 import {getCallback, getValidNumber} from './get';
 import './global';
 import {type RepeatOptions, TimerTrace} from './models';
@@ -12,7 +12,7 @@ export function repeat(
 	options?: Partial<RepeatOptions>,
 ): Timer {
 	return new Timer(
-		'repeat',
+		TYPE_REPEAT,
 		{
 			callback: getCallback(callback),
 			trace: new TimerTrace().stack,

package/src/timer.ts

@@ -1,4 +1,11 @@
 import {noop} from '@oscarpalmer/atoms/function';
+import {
+	WORK_CONTINUE,
+	WORK_PAUSE,
+	WORK_RESTART,
+	WORK_START,
+	WORK_STOP,
+} from './constants';
 import type {
 	TimerOptions,
 	TimerState,
@@ -37,7 +44,7 @@ export class Timer {
 	 * Get the timer's origin _(if debugging is enabled)_
 	 */
 	get trace(): string | undefined {
-		return globalThis._oscarpalmer_timer_debug ?? false
+		return (globalThis._oscarpalmer_timer_debug ?? false)
 			? this.state.trace
 			: undefined;
 	}
@@ -70,7 +77,7 @@ export class Timer {
 	 * Continue running the timer _(if it's paused)_
 	 */
 	continue(): Timer {
-		return this.#work('continue');
+		return this.#work(WORK_CONTINUE);
 	}
 
 	/**
@@ -101,28 +108,28 @@ export class Timer {
 	 * Pause the timer _(if it's running)_
 	 */
 	pause(): Timer {
-		return this.#work('pause');
+		return this.#work(WORK_PAUSE);
 	}
 
 	/**
 	 * Restart the timer _(or start it, if it's not running)_
 	 */
 	restart(): Timer {
-		return this.#work('restart');
+		return this.#work(WORK_RESTART);
 	}
 
 	/**
 	 * Start the timer _(if it's not running)_
 	 */
 	start(): Timer {
-		return this.#work('start');
+		return this.#work(WORK_START);
 	}
 
 	/**
 	 * Stop the timer _(if it's running)_
 	 */
 	stop(): Timer {
-		return this.#work('stop');
+		return this.#work(WORK_STOP);
 	}
 
 	#work(type: WorkHandlerType): Timer {

package/src/wait.ts

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

package/src/when.ts

@@ -1,12 +1,17 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import {destroyedMessage, milliseconds, startedMessage} from './constants';
+import {
+	destroyedMessage,
+	milliseconds,
+	startedMessage,
+	TYPE_WHEN,
+} from './constants';
 import {getValidNumber} from './get';
 import './global';
 import {TimerTrace, type WhenOptions, type WhenState} from './models';
 import {Timer} from './timer';
 
 class When {
-	private readonly $timer = 'when';
+	private readonly $timer = TYPE_WHEN;
 	private readonly state: WhenState = {
 		promise: undefined as never,
 		rejecter: undefined as never,
@@ -40,7 +45,7 @@ class When {
 	 * Get the timer's origin _(if debugging is enabled)_
 	 */
 	get trace(): string | undefined {
-		return globalThis._oscarpalmer_timer_debug ?? false
+		return (globalThis._oscarpalmer_timer_debug ?? false)
 			? this.state.timer?.trace
 			: undefined;
 	}
@@ -56,7 +61,7 @@ class When {
 		let result = false;
 
 		this.state.timer = new Timer(
-			'when',
+			TYPE_WHEN,
 			{
 				callback(): void {
 					try {