@oscarpalmer/timer 0.47.0 → 0.49.0

package/dist/models.d.mts

@@ -2,7 +2,7 @@
 /**
  * Options for a repeating timer
  */
-type RepeatOptions = {
+export type RepeatOptions = {
   /**
    * Callback to be called when the timer has stopped, either manually or by completing its work
    */
@@ -24,7 +24,7 @@ type RepeatOptions = {
    */
   timeout: number;
 };
-type Timer = {
+export type Timer = {
   /**
    * Is the timer active?
    */
@@ -70,15 +70,15 @@ type Timer = {
    */
   stop(): Timer;
 };
-type TimerName = 'repeat' | 'wait' | 'when';
-type TimerOptions = {
+export type TimerName = 'repeat' | 'wait' | 'when';
+export type TimerOptions = {
   onAfter: ((finished: boolean) => void) | undefined;
   onError: (() => void) | undefined;
   count: number;
   interval: number;
   timeout: number;
 };
-type TimerState = {
+export type TimerState = {
   active: boolean;
   callback: () => void;
   destroyed: boolean;
@@ -93,7 +93,7 @@ type TimerState = {
   total: number;
   trace?: string;
 };
-type TimerStates = {
+export type TimerStates = {
   /**
    * A set of all active timers
    */
@@ -103,10 +103,10 @@ type TimerStates = {
    */
   hidden: Set<WeakRef<TimerState>>;
 };
-declare class TimerTrace extends Error {
+export declare class TimerTrace extends Error {
   constructor();
 }
-type When = {
+export type When = {
   /**
    * Is the timer active?
    */
@@ -154,7 +154,7 @@ type When = {
 /**
  * Options for a conditional timer
  */
-type WhenOptions = {
+export type WhenOptions = {
   /**
    * How many times the timer should check the condition
    */
@@ -168,7 +168,8 @@ type WhenOptions = {
    */
   timeout: number;
 };
-type WhenState = {
+export type WhenState = {
+  name: TimerName;
   promise: Promise<void>;
   rejecter?: () => void;
   resolver?: () => void;
@@ -176,11 +177,10 @@ type WhenState = {
   started: boolean;
   timer: Timer;
 };
-type WorkHandler = (type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions) => Timer;
-type WorkHandlerTimer = {
+export type WorkHandler = (type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions) => Timer;
+export type WorkHandlerTimer = {
   instance: Timer;
   name: TimerName;
 };
-type WorkHandlerType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';
-//#endregion
-export { RepeatOptions, Timer, TimerName, TimerOptions, TimerState, TimerStates, TimerTrace, When, WhenOptions, WhenState, WorkHandler, WorkHandlerTimer, WorkHandlerType };
+export type WorkHandlerType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';
+//#endregion

package/dist/repeat.d.mts

@@ -8,6 +8,5 @@ import "./global.mjs";
  * @param options Timer options
  * @returns Repeating timer
  */
-declare function repeat(callback: (index: number) => void, options?: Partial<RepeatOptions>): Timer;
-//#endregion
-export { repeat };
+export declare function repeat(callback: (index: number) => void, options?: Partial<RepeatOptions>): Timer;
+//#endregion

package/dist/timer.d.mts

@@ -1,5 +1,5 @@
 import { Timer, TimerName, TimerOptions, TimerState } from "./models.mjs";
 //#region src/timer.d.ts
-declare function createTimer(name: TimerName, pick: Pick<TimerState, 'callback' | 'trace'>, options: TimerOptions, start: boolean): Timer;
-//#endregion
-export { createTimer };
+declare function Timer(this: any, name: TimerName, state: Pick<TimerState, 'callback' | 'trace'>, options: TimerOptions, start: boolean): void;
+export declare function createTimer(name: TimerName, state: Pick<TimerState, 'callback' | 'trace'>, options: TimerOptions, start: boolean): Timer;
+//#endregion

package/dist/timer.mjs

@@ -1,10 +1,9 @@
-import { WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.mjs";
+import { SYMBOL, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.mjs";
 import { work } from "./work.mjs";
-import { noop } from "@oscarpalmer/atoms/function";
 //#region src/timer.ts
-function createTimer(name, pick, options, start) {
-	const state = {
-		...pick,
+function Timer(name, state, options, start) {
+	Object.defineProperty(this, SYMBOL, { value: {
+		...state,
 		name,
 		options,
 		active: false,
@@ -15,40 +14,57 @@ function createTimer(name, pick, options, start) {
 		paused: false,
 		timer: void 0,
 		total: 0
-	};
-	const instance = {
-		continue: () => work(WORK_CONTINUE, state),
-		destroy: noop,
-		pause: () => work(WORK_PAUSE, state),
-		restart: () => work(WORK_RESTART, state),
-		start: () => work(WORK_START, state),
-		stop: () => work(WORK_STOP, state)
-	};
-	Object.defineProperties(instance, {
-		$timer: {
-			enumerable: false,
-			value: name
-		},
-		active: {
-			enumerable: true,
-			get: () => state.active && !state.paused
-		},
-		destroyed: {
-			enumerable: true,
-			value: false
-		},
-		paused: {
-			enumerable: true,
-			get: () => state.paused
-		},
-		trace: {
-			enumerable: true,
-			get: () => globalThis._oscarpalmer_timer_debug ?? false ? state.trace : void 0
+	} });
+	if (start) startTimer.call(this);
+}
+Object.defineProperties(Timer.prototype, {
+	active: {
+		enumerable: true,
+		get() {
+			return isActiveTimer.call(this);
+		}
+	},
+	continue: { value: continueTimer },
+	pause: { value: pauseTimer },
+	paused: {
+		enumerable: true,
+		get() {
+			return isPausedTimer.call(this);
 		}
-	});
-	state.timer = Object.freeze(instance);
-	if (start) state.timer.start();
-	return state.timer;
+	},
+	restart: { value: restartTimer },
+	start: { value: startTimer },
+	stop: { value: stopTimer },
+	trace: { get() {
+		return getTimerTrace.call(this);
+	} }
+});
+function continueTimer() {
+	return work(WORK_CONTINUE, this[SYMBOL]);
+}
+function createTimer(name, state, options, start) {
+	return new Timer(name, state, options, start);
+}
+function getTimerTrace() {
+	return globalThis._oscarpalmer_timer_debug ?? false ? this[SYMBOL].trace : void 0;
+}
+function isActiveTimer() {
+	return this[SYMBOL].active && !this[SYMBOL].paused;
+}
+function isPausedTimer() {
+	return this[SYMBOL].paused;
+}
+function pauseTimer() {
+	return work(WORK_PAUSE, this[SYMBOL]);
+}
+function restartTimer() {
+	return work(WORK_RESTART, this[SYMBOL]);
+}
+function startTimer() {
+	return work(WORK_START, this[SYMBOL]);
+}
+function stopTimer() {
+	return work(WORK_STOP, this[SYMBOL]);
 }
 //#endregion
 export { createTimer };

package/dist/wait.d.mts

@@ -8,6 +8,5 @@ import "./global.mjs";
  * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
  * @returns Waiting timer
  */
-declare function wait(callback: () => void, time?: number): Timer;
-//#endregion
-export { wait };
+export declare function wait(callback: () => void, time?: number): Timer;
+//#endregion

package/dist/when.d.mts

@@ -1,12 +1,12 @@
 import { When, WhenOptions } from "./models.mjs";
 import "./global.mjs";
 //#region src/when.d.ts
+declare function When(this: any, condition: () => boolean, options: WhenOptions): void;
 /**
  * Create a conditional timer
  * @param condition Condition to check
  * @param options Timer options
  * @returns Timer instance
  */
-declare function when(condition: () => boolean, options?: Partial<WhenOptions>): When;
-//#endregion
-export { when };
+export declare function when(condition: () => boolean, options?: Partial<WhenOptions>): When;
+//#endregion

package/dist/when.mjs

@@ -1,10 +1,66 @@
-import { MESSAGE_STARTED, TYPE_WHEN, WORK_CONTINUE, WORK_PAUSE, WORK_STOP } from "./constants.mjs";
+import { MESSAGE_STARTED, SYMBOL, TYPE_WHEN, WORK_CONTINUE, WORK_PAUSE, WORK_STOP } from "./constants.mjs";
 import { getValidNumber, getValidTimeout } from "./misc.mjs";
 import "./global.mjs";
 import { TimerTrace } from "./models.mjs";
 import { createTimer } from "./timer.mjs";
-import { noop } from "@oscarpalmer/atoms/function";
 //#region src/when.ts
+function When(condition, options) {
+	const state = {
+		name: TYPE_WHEN,
+		promise: void 0,
+		result: false,
+		started: false,
+		timer: void 0
+	};
+	Object.defineProperty(this, SYMBOL, { value: state });
+	state.promise = new Promise((resolve, reject) => {
+		state.resolver = resolve;
+		state.rejecter = reject;
+	});
+	state.timer = createTimer(TYPE_WHEN, {
+		callback: () => onCallback(condition, state),
+		trace: new TimerTrace().stack
+	}, {
+		...options,
+		onAfter: () => onAfter(state),
+		onError: () => state.rejecter?.()
+	}, false);
+}
+Object.defineProperties(When.prototype, {
+	active: { get() {
+		return isActiveWhen.call(this);
+	} },
+	continue: { value: continueWhen },
+	pause: { value: pauseWhen },
+	paused: { get() {
+		return isPausedWhen.call(this);
+	} },
+	start: { value: startWhen },
+	stop: { value: stopWhen },
+	trace: { get() {
+		return getWhenTrace.call(this);
+	} }
+});
+function continueWhen() {
+	return onWhen(WORK_CONTINUE, this, this[SYMBOL]);
+}
+function getWhenOptions(input) {
+	const options = typeof input === "object" && input !== null ? input : {};
+	return {
+		count: getValidNumber(options?.count),
+		interval: getValidNumber(options?.interval),
+		timeout: getValidTimeout(options?.timeout)
+	};
+}
+function getWhenTrace() {
+	return globalThis._oscarpalmer_timer_debug ?? false ? this[SYMBOL].timer?.trace : void 0;
+}
+function isActiveWhen() {
+	return this[SYMBOL].timer.active;
+}
+function isPausedWhen() {
+	return this[SYMBOL].timer.paused;
+}
 function onAfter(state) {
 	if (state.result) state.resolver?.();
 	else state.rejecter?.();
@@ -23,12 +79,19 @@ function onWhen(type, instance, state) {
 	state.timer?.[type]?.();
 	return instance;
 }
-function startWhen(state, resolve) {
+function pauseWhen() {
+	return onWhen(WORK_PAUSE, this, this[SYMBOL]);
+}
+function startWhen(resolve) {
+	const state = this[SYMBOL];
 	if (state.started) throw new Error(MESSAGE_STARTED);
 	state.started = true;
 	state.timer.start();
 	return state.promise.then(resolve);
 }
+function stopWhen() {
+	return onWhen(WORK_STOP, this, this[SYMBOL]);
+}
 /**
 * Create a conditional timer
 * @param condition Condition to check
@@ -36,57 +99,7 @@ function startWhen(state, resolve) {
 * @returns Timer instance
 */
 function when(condition, options) {
-	const state = {
-		promise: void 0,
-		result: false,
-		started: false,
-		timer: void 0
-	};
-	let instance;
-	state.promise = new Promise((resolve, reject) => {
-		state.resolver = resolve;
-		state.rejecter = reject;
-	});
-	state.timer = createTimer(TYPE_WHEN, {
-		callback: () => onCallback(condition, state),
-		trace: new TimerTrace().stack
-	}, {
-		onAfter: () => onAfter(state),
-		onError: () => state.rejecter?.(),
-		count: getValidNumber(options?.count),
-		interval: getValidNumber(options?.interval),
-		timeout: getValidTimeout(options?.timeout)
-	}, false);
-	instance = {
-		continue: () => onWhen(WORK_CONTINUE, instance, state),
-		destroy: noop,
-		pause: () => onWhen(WORK_PAUSE, instance, state),
-		start: (resolve) => startWhen(state, resolve),
-		stop: () => onWhen(WORK_STOP, instance, state)
-	};
-	Object.defineProperties(instance, {
-		$timer: {
-			enumerable: false,
-			value: TYPE_WHEN
-		},
-		active: {
-			enumerable: true,
-			get: () => state.timer.active
-		},
-		destroyed: {
-			enumerable: true,
-			value: false
-		},
-		paused: {
-			enumerable: true,
-			get: () => state.timer.paused
-		},
-		trace: {
-			enumerable: true,
-			get: () => globalThis._oscarpalmer_timer_debug ?? false ? state.timer?.trace : void 0
-		}
-	});
-	return Object.freeze(instance);
+	return new When(condition, getWhenOptions(options));
 }
 //#endregion
 export { when };

package/dist/work.d.mts

@@ -1,6 +1,5 @@
 import { Timer, TimerState, WorkHandlerType } from "./models.mjs";
 //#region src/work.d.ts
-declare function stop(state: TimerState): Timer;
-declare function work(type: WorkHandlerType, state: TimerState, hide?: boolean): Timer;
-//#endregion
-export { stop, work };
+export declare function stop(state: TimerState): Timer;
+export declare function work(type: WorkHandlerType, state: TimerState, hide?: boolean): Timer;
+//#endregion

package/dist/work.mjs

@@ -1,9 +1,9 @@
 import { WORK_PAUSE } from "./constants.mjs";
-import { updateStates } from "./misc.mjs";
+import { startTimer, stopTimer, updateStates } from "./misc.mjs";
 //#region src/work.ts
 function finish(state, success) {
 	updateStates(state);
-	cancelAnimationFrame(state.frame);
+	stopTimer(state.frame);
 	state.active = false;
 	state.elapsed = 0;
 	state.frame = void 0;
@@ -16,8 +16,9 @@ function ignore(type, state) {
 }
 function run(state) {
 	let last;
-	return function step(now) {
+	return function step() {
 		if (!state.active) return;
+		const now = performance.now();
 		last ??= now;
 		const difference = now - last;
 		state.elapsed += difference;
@@ -37,7 +38,7 @@ function run(state) {
 				return;
 			}
 		}
-		state.frame = requestAnimationFrame(step);
+		state.frame = startTimer(step);
 	};
 }
 function setState(type, state) {
@@ -48,7 +49,7 @@ function setState(type, state) {
 }
 function stop(state) {
 	updateStates(state);
-	cancelAnimationFrame(state.frame);
+	stopTimer(state.frame);
 	state.options.onAfter?.(false);
 	state.active = false;
 	state.frame = void 0;
@@ -60,7 +61,7 @@ function work(type, state, hide) {
 	setState(type, state);
 	if (type === "stop") return stop(state);
 	if (type === "pause" || type === "restart") {
-		cancelAnimationFrame(state.frame);
+		stopTimer(state.frame);
 		state.frame = void 0;
 	}
 	state.active = true;
@@ -68,7 +69,7 @@ function work(type, state, hide) {
 	updateStates(state, state.paused ? hide : false);
 	if (state.paused) return state.timer;
 	const runner = run(state);
-	state.frame = requestAnimationFrame(runner);
+	state.frame = startTimer(runner);
 	return state.timer;
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/timer",
-	"version": "0.47.0",
+	"version": "0.49.0",
 	"description": "A better solution for timeout- and interval-based timers.",
 	"keywords": [
 		"requestAnimationFrame",
@@ -60,14 +60,14 @@
 		"watch": "npx vite build --watch"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.195"
+		"@oscarpalmer/atoms": "^0.203"
 	},
 	"devDependencies": {
-		"@oxlint/plugins": "^1.80",
-		"@types/node": "^26.4",
+		"@oxlint/plugins": "^1.82",
+		"@types/node": "^26.5",
 		"@vitest/coverage-istanbul": "^4.1",
 		"jsdom": "^30",
-		"tsdown": "^0.22",
+		"tsdown": "^0.23",
 		"typescript": "^6",
 		"vite": "npm:@voidzero-dev/vite-plus-core@latest",
 		"vite-plus": "latest",

package/src/constants.ts

@@ -1,5 +1,7 @@
 import type {TimerName, TimerStates, WorkHandlerType} from './models';
 
+// #region Variables
+
 /**
  * Buffer value to use when evaluating if a specific time is within a certain range
  */
@@ -7,6 +9,8 @@ export const BUFFER_INTERVAL = 5;
 
 export const DEFAULT_TIMEOUT = 30_000;
 
+export const GLOBAL_NAME = '_oscarpalmer_timers';
+
 /**
  * Message to show when a when-timer is started
  */
@@ -17,6 +21,8 @@ export const STATES: TimerStates = {
 	hidden: new Set(),
 };
 
+export const SYMBOL = Symbol('timer');
+
 export const TYPE_REPEAT: TimerName = 'repeat';
 
 export const TYPE_WAIT: TimerName = 'wait';
@@ -32,3 +38,5 @@ export const WORK_RESTART: WorkHandlerType = 'restart';
 export const WORK_START: WorkHandlerType = 'start';
 
 export const WORK_STOP: WorkHandlerType = 'stop';
+
+// #endregion

package/src/global.ts

@@ -1,7 +1,9 @@
-import {STATES} from './constants';
+import {GLOBAL_NAME, STATES} from './constants';
 import {onVisibilityChange} from './misc';
 import type {Timer} from './models';
 
+// #region Types
+
 declare global {
 	var _oscarpalmer_timer_debug: boolean | undefined;
 	/**
@@ -10,10 +12,24 @@ declare global {
 	var _oscarpalmer_timers: Timer[] | undefined;
 }
 
-Object.defineProperty(globalThis, '_oscarpalmer_timers', {
-	get() {
-		return globalThis._oscarpalmer_timer_debug ? [...STATES.active].map(state => state.timer) : [];
-	},
-});
+// #endregion
+
+// #region Initialization
+
+/* istanbul ignore next */
+if (!(GLOBAL_NAME in globalThis)) {
+	Object.defineProperty(globalThis, GLOBAL_NAME, {
+		get() {
+			return globalThis._oscarpalmer_timer_debug
+				? [...STATES.active].map(state => state.timer)
+				: [];
+		},
+	});
+}
+
+/* istanbul ignore next */
+if ('document' in globalThis) {
+	document.addEventListener('visibilitychange', onVisibilityChange);
+}
 
-document.addEventListener('visibilitychange', onVisibilityChange);
+// #endregion

package/src/is.ts

@@ -1,47 +1,55 @@
-import type {PlainObject} from '@oscarpalmer/atoms/models';
-import {TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN} from './constants';
+import {SYMBOL, TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN} from './constants';
 import type {Timer, When} from './models';
 
-function is(names: string[], value: unknown) {
-	return names.includes((value as PlainObject)?.$timer as string);
+// #region Functions
+
+function isInstance(names: string[], value: unknown) {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		SYMBOL in value &&
+		names.includes((value as any)[SYMBOL].name as string)
+	);
 }
 
 /**
  * Is the value a repeating timer?
- * 
+ *
  * @param value Value to check
  * @returns `true` if the value is a repeating timer, otherwise `false`
  */
 export function isRepeated(value: unknown): value is Timer {
-	return is([TYPE_REPEAT], value);
+	return isInstance([TYPE_REPEAT], value);
 }
 
 /**
  * Is the value a timer?
- * 
+ *
  * @param value Value to check
  * @returns `true` if the value is a timer, otherwise `false`
  */
 export function isTimer(value: unknown): value is Timer {
-	return is([TYPE_REPEAT, TYPE_WAIT], value);
+	return isInstance([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, otherwise `false`
  */
 export function isWaited(value: unknown): value is Timer {
-	return is([TYPE_WAIT], value);
+	return isInstance([TYPE_WAIT], value);
 }
 
 /**
  * Is the value a conditional timer?
- * 
+ *
  * @param value Value to check
  * @returns `true` if the value is a conditional timer, otherwise `false`
  */
 export function isWhen(value: unknown): value is When {
-	return is([TYPE_WHEN], value) && typeof (value as When).start === 'function';
+	return isInstance([TYPE_WHEN], value) && typeof (value as When).start === 'function';
 }
+
+// #endregion

package/src/misc.ts

@@ -4,6 +4,8 @@ import {DEFAULT_TIMEOUT, STATES, WORK_CONTINUE, WORK_PAUSE} from './constants';
 import type {TimerState} from './models';
 import {work} from './work';
 
+// #region Functions
+
 export function getCallback(value: unknown): GenericCallback {
 	return typeof value === 'function' ? (value as GenericCallback) : noop;
 }
@@ -53,3 +55,16 @@ export function updateStates(state: TimerState, hide?: boolean): void {
 		STATES.active.add(state);
 	}
 }
+
+// #endregion
+
+// #region Variables
+
+/* istanbul ignore next */
+export const startTimer =
+	'requestAnimationFrame' in globalThis ? requestAnimationFrame : setTimeout;
+
+/* istanbul ignore next */
+export const stopTimer = 'cancelAnimationFrame' in globalThis ? cancelAnimationFrame : clearTimeout;
+
+// #endregion