@oscarpalmer/timer 0.33.0 → 0.35.0

package/dist/when.js

@@ -1,136 +1,94 @@
-import { noop } from '@oscarpalmer/atoms/function';
-import { milliseconds, destroyedMessage, startedMessage } from './constants.js';
-import { getValidNumber } from './get.js';
-import './global.js';
-import { TimerTrace } from './models.js';
-import { Timer } from './timer.js';
-
-class When {
-  $timer = "when";
-  state = {
-    promise: void 0,
-    rejecter: void 0,
-    resolver: void 0,
-    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) {
-    const { state } = this;
-    state.promise = new Promise((resolve, reject) => {
-      state.resolver = resolve;
-      state.rejecter = reject;
-    });
-    let result = false;
-    this.state.timer = new Timer(
-      "when",
-      {
-        callback() {
-          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
-    );
-  }
-  /**
-   * 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();
-    state.promise = void 0;
-    state.resolver = noop;
-    state.rejecter = noop;
-    state.timer = void 0;
-  }
-  /**
-   * Pauses the timer _(if it was running)_
-   */
-  pause() {
-    this.state.timer?.pause();
-    return this;
-  }
-  /**
-   * Stops the timer _(if it was running)_
-   */
-  stop() {
-    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, 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);
-  }
-}
+import { TYPE_WHEN, defaultTimeout, destroyedMessage, milliseconds, startedMessage } from "./constants.js";
+import { getValidNumber } 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,
+		resolver: void 0,
+		started: false,
+		timer: void 0
+	};
+	get active() {
+		return this.state.timer?.active ?? false;
+	}
+	get destroyed() {
+		return this.state.timer == null;
+	}
+	get paused() {
+		return this.state.timer?.paused ?? false;
+	}
+	get trace() {
+		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.timer?.trace : void 0;
+	}
+	constructor(condition, options) {
+		const { state } = this;
+		state.promise = new Promise((resolve, reject) => {
+			state.resolver = resolve;
+			state.rejecter = reject;
+		});
+		let result = false;
+		this.state.timer = new Timer(TYPE_WHEN, {
+			callback() {
+				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, defaultTimeout)
+		}, false);
+	}
+	continue() {
+		this.state.timer?.continue();
+		return this;
+	}
+	destroy() {
+		const { state } = this;
+		state.timer?.destroy();
+		state.promise = void 0;
+		state.resolver = noop;
+		state.rejecter = noop;
+		state.timer = void 0;
+	}
+	pause() {
+		this.state.timer?.pause();
+		return this;
+	}
+	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);
+	}
+};
 function when(condition, options) {
-  return new When(condition, options);
+	return new When(condition, options);
 }
-
 export { when };

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 last;
-  return function step(now) {
-    if (!state.active) {
-      return;
-    }
-    last ??= 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 === constants.milliseconds || state.elapsed >= options.interval - constants.intervalBuffer) {
-      if (options.count > -1) {
-        state.callback(state.index);
-      }
-      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 last;
-  return function step(now) {
-    if (!state.active) {
-      return;
-    }
-    last ??= 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);
-      }
-      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,21 +4,22 @@
 		"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": "^24",
+		"@types/node": "^24.3",
 		"@vitest/coverage-istanbul": "^3.2",
 		"dts-bundle-generator": "^9.5",
 		"glob": "^11",
 		"jsdom": "^26.1",
+		"rollup": "^4.49",
 		"tslib": "^2.8",
-		"typescript": "^5.8",
-		"vite": "^6.3",
+		"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.33.0"
+	"version": "0.35.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> {
@@ -32,16 +32,15 @@ function calculate(): Promise<number> {
 	});
 }
 
+//
+
+export const defaultTimeout = 30_000;
+
 /**
  * A set of all active timers
  */
 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 +51,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/get.ts

@@ -6,7 +6,9 @@ export function getCallback(value: unknown): GenericCallback {
 }
 
 export function getValidNumber(value: unknown, defaultValue?: number): number {
-	return typeof value === 'number' && value > (defaultValue ?? 0)
-		? value
-		: defaultValue ?? 0;
+	return typeof value === 'number'
+		? value > 0
+			? value
+			: 0
+		: (defaultValue ?? 0);
 }