@oscarpalmer/timer 0.43.0 → 0.44.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/timer",
-	"version": "0.43.0",
+	"version": "0.44.0",
 	"description": "A better solution for timeout- and interval-based timers.",
 	"keywords": [
 		"requestAnimationFrame",
@@ -34,6 +34,10 @@
 			"types": "./dist/delay.d.mts",
 			"default": "./dist/delay.mjs"
 		},
+		"./models": {
+			"types": "./dist/models.d.mts",
+			"default": "./dist/models.mjs"
+		},
 		"./repeat": {
 			"types": "./dist/repeat.d.mts",
 			"default": "./dist/repeat.mjs"
@@ -56,13 +60,13 @@
 		"watch": "npx vite build --watch"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.187"
+		"@oscarpalmer/atoms": "^0.193"
 	},
 	"devDependencies": {
-		"@oxlint/plugins": "^1.66",
-		"@types/node": "^25.9",
+		"@oxlint/plugins": "^1.80",
+		"@types/node": "^26.3",
 		"@vitest/coverage-istanbul": "^4.1",
-		"jsdom": "^29.1",
+		"jsdom": "^30",
 		"tsdown": "^0.22",
 		"typescript": "^6",
 		"vite": "npm:@voidzero-dev/vite-plus-core@latest",

package/src/constants.ts

@@ -1,5 +1,4 @@
-import type {TimerType, WorkHandlerType} from './models';
-import type {Timer} from './timer';
+import type {Timer, TimerName, WorkHandlerType} from './models';
 
 /**
  * Buffer value to use when evaluating if a specific time is within a certain range
@@ -28,11 +27,11 @@ export const TIMERS_ACTIVE = new Set<Timer>();
  */
 export const TIMERS_HIDDEN = new Set<Timer>();
 
-export const TYPE_REPEAT: TimerType = 'repeat';
+export const TYPE_REPEAT: TimerName = 'repeat';
 
-export const TYPE_WAIT: TimerType = 'wait';
+export const TYPE_WAIT: TimerName = 'wait';
 
-export const TYPE_WHEN: TimerType = 'when';
+export const TYPE_WHEN: TimerName = 'when';
 
 export const WORK_CONTINUE: WorkHandlerType = 'continue';
 

package/src/delay.ts

@@ -1,2 +1 @@
 export {delay} from '@oscarpalmer/atoms/promise/delay';
-export type {PromiseOptions} from '@oscarpalmer/atoms/promise/models';

package/src/get.ts

@@ -1,5 +1,5 @@
-import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {noop} from '@oscarpalmer/atoms/function';
+import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {DEFAULT_TIMEOUT} from './constants';
 
 export function getCallback(value: unknown): GenericCallback {

package/src/global.ts

@@ -1,5 +1,5 @@
 import {TIMERS_ACTIVE, TIMERS_HIDDEN, WORK_CONTINUE, WORK_PAUSE} from './constants';
-import type {Timer} from './timer';
+import type {Timer} from './models';
 
 declare global {
 	var _oscarpalmer_timer_debug: boolean | undefined;

package/src/index.ts

@@ -1,8 +1,8 @@
 import './global';
 
-export * from './delay';
+export {delay} from './delay';
 export {isRepeated, isTimer, isWaited, isWhen} from './is';
-export * from './repeat';
-export type {Timer} from './timer';
-export * from './wait';
-export * from './when';
+export type {RepeatOptions, Timer, TimerOptions, When, WhenOptions} from './models';
+export {repeat} from './repeat';
+export {wait} from './wait';
+export {when} from './when';

package/src/is.ts

@@ -1,7 +1,6 @@
 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';
+import type {Timer, When} from './models';
 
 function is(names: string[], value: unknown) {
 	return names.includes((value as PlainObject)?.$timer as string);

package/src/models.ts

@@ -1,5 +1,3 @@
-import type {Timer} from './timer';
-
 /**
  * Options for a repeating timer
  */
@@ -26,6 +24,60 @@ export type RepeatOptions = {
 	timeout: number;
 };
 
+export type Timer = {
+	/**
+	 * Is the timer active?
+	 */
+	get active(): boolean;
+
+	/**
+	 * Is the timer destroyed?
+	 */
+	get destroyed(): boolean;
+
+	/**
+	 * Is the timer paused?
+	 */
+	get paused(): boolean;
+
+	/**
+	 * Get the timer's origin _(if debugging is enabled)_
+	 */
+	get trace(): string | undefined;
+
+	/**
+	 * Continue running the timer _(if it's paused)_
+	 */
+	continue(): Timer;
+
+	/**
+	 * Destroy the timer
+	 */
+	destroy(): void;
+
+	/**
+	 * Pause the timer _(if it's running)_
+	 */
+	pause(): Timer;
+
+	/**
+	 * Restart the timer _(or start it, if it's not running)_
+	 */
+	restart(): Timer;
+
+	/**
+	 * Start the timer _(if it's not running)_
+	 */
+	start(): Timer;
+
+	/**
+	 * Stop the timer _(if it's running)_
+	 */
+	stop(): Timer;
+};
+
+export type TimerName = 'repeat' | 'wait' | 'when';
+
 export type TimerOptions = {
 	onAfter: ((finished: boolean) => void) | undefined;
 	onError: (() => void) | undefined;
@@ -54,7 +106,55 @@ export class TimerTrace extends Error {
 	}
 }
 
-export type TimerType = 'repeat' | 'wait' | 'when';
+export type When = {
+	/**
+	 * Is the timer active?
+	 */
+	get active(): boolean;
+
+	/**
+	 * Is the timer destroyed?
+	 */
+	get destroyed(): boolean;
+
+	/**
+	 * Is the timer paused?
+	 */
+	get paused(): boolean;
+
+	/**
+	 * Get the timer's origin _(if debugging is enabled)_
+	 */
+	get trace(): string | undefined;
+
+	/**
+	 * Continues the timer _(if it was paused)_
+	 */
+	continue(): When;
+
+	/**
+	 * Destroys the timer _(and stops it,if it was running)_
+	 */
+	destroy(): void;
+
+	/**
+	 * Pauses the timer _(if it was running)_
+	 */
+	pause(): When;
+
+	/**
+	 * Start the timer
+	 *
+	 * @param resolve Optional resolve callback
+	 * @returns Promise that resolves when the condition is met
+	 */
+	start(resolve?: (() => void) | null): Promise<void>;
+
+	/**
+	 * Stops the timer _(if it was running)_
+	 */
+	stop(): When;
+};
 
 /**
  * Options for a conditional timer
@@ -78,6 +178,7 @@ export type WhenState = {
 	promise: Promise<void>;
 	rejecter?: () => void;
 	resolver?: () => void;
+	result: boolean;
 	started: boolean;
 	timer: Timer;
 };
@@ -91,7 +192,7 @@ export type WorkHandler = (
 
 export type WorkHandlerTimer = {
 	instance: Timer;
-	type: TimerType;
+	name: TimerName;
 };
 
 export type WorkHandlerType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';

package/src/repeat.ts

@@ -1,8 +1,8 @@
 import {TYPE_REPEAT} from './constants';
 import {getCallback, getValidNumber} from './get';
 import './global';
-import {type RepeatOptions, TimerTrace} from './models';
-import {Timer} from './timer';
+import {type RepeatOptions, type Timer, TimerTrace} from './models';
+import {createTimer} from './timer';
 
 /**
  * Create a repeating timer
@@ -12,7 +12,7 @@ import {Timer} from './timer';
  * @returns Timer instance
  */
 export function repeat(callback: (index: number) => void, options?: Partial<RepeatOptions>): Timer {
-	return new Timer(
+	return createTimer(
 		TYPE_REPEAT,
 		{
 			callback: getCallback(callback),
@@ -28,5 +28,3 @@ export function repeat(callback: (index: number) => void, options?: Partial<Repe
 		true,
 	);
 }
-
-export type {RepeatOptions, Timer};

package/src/timer.ts

@@ -1,135 +1,91 @@
 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 type {Timer, TimerName, TimerOptions, TimerState, WorkHandlerType} from './models';
 import {stop, work} from './work';
 
-export class Timer {
-	declare private readonly $timer: TimerType;
-
-	protected readonly state: TimerState;
-
-	/**
-	 * Is the timer active?
-	 */
-	get active(): boolean {
-		return this.state.active;
-	}
-
-	/**
-	 * Is the timer destroyed?
-	 */
-	get destroyed(): boolean {
-		return this.state.destroyed;
-	}
-
-	/**
-	 * Is the timer paused?
-	 */
-	get paused(): boolean {
-		return this.state.paused;
-	}
-
-	/**
-	 * Get the timer's origin _(if debugging is enabled)_
-	 */
-	get trace(): string | undefined {
-		return (globalThis._oscarpalmer_timer_debug ?? false) ? this.state.trace : undefined;
-	}
-
-	constructor(
-		type: TimerType,
-		state: Pick<TimerState, 'callback' | 'trace'>,
-		protected readonly options: TimerOptions,
-		start: boolean,
-	) {
-		Object.defineProperty(this, '$timer', {
-			value: type,
-		});
-
-		this.state = {
-			...state,
-			active: false,
-			destroyed: false,
-			elapsed: 0,
-			frame: undefined,
-			index: 0,
-			paused: false,
-			total: 0,
-		};
-
-		if (start) {
-			this.start();
-		}
-	}
-
-	/**
-	 * Continue running the timer _(if it's paused)_
-	 */
-	continue(): Timer {
-		return this.#work(WORK_CONTINUE);
-	}
-
-	/**
-	 * Destroy the timer
-	 */
-	destroy(): void {
-		this.state.destroyed = true;
-
-		this.options.onAfter = noop;
-		this.options.onError = noop;
-		this.state.callback = noop;
-
-		if (!globalThis._oscarpalmer_timer_debug) {
-			this.state.trace = undefined;
-		}
-
-		stop(
+export function createTimer(
+	name: TimerName,
+	pick: Pick<TimerState, 'callback' | 'trace'>,
+	options: TimerOptions,
+	start: boolean,
+): Timer {
+	function worker(type: WorkHandlerType): Timer {
+		return work(
+			type,
 			{
-				instance: this,
-				type: this.$timer,
+				name,
+				instance: instance as Timer,
 			},
-			this.state,
-			this.options,
+			state,
+			options,
 		);
 	}
 
-	/**
-	 * Pause the timer _(if it's running)_
-	 */
-	pause(): Timer {
-		return this.#work(WORK_PAUSE);
+	const state: TimerState = {
+		...pick,
+		active: false,
+		destroyed: false,
+		elapsed: 0,
+		frame: undefined,
+		index: 0,
+		paused: false,
+		total: 0,
+	};
+
+	const instance = {
+		continue: () => worker(WORK_CONTINUE),
+		destroy: () => destroyTimer(name, instance as Timer, state, options),
+		pause: () => worker(WORK_PAUSE),
+		restart: () => worker(WORK_RESTART),
+		start: () => worker(WORK_START),
+		stop: () => worker(WORK_STOP),
+	};
+
+	Object.defineProperties(instance, {
+		$timer: {
+			enumerable: false,
+			value: name,
+		},
+		active: {
+			enumerable: true,
+			get: () => state.active,
+		},
+		destroyed: {
+			enumerable: true,
+			get: () => state.destroyed,
+		},
+		paused: {
+			enumerable: true,
+			get: () => state.paused,
+		},
+		trace: {
+			enumerable: true,
+			get: () => ((globalThis._oscarpalmer_timer_debug ?? false) ? state.trace : undefined),
+		},
+	});
+
+	if (start) {
+		instance.start();
 	}
 
-	/**
-	 * Restart the timer _(or start it, if it's not running)_
-	 */
-	restart(): Timer {
-		return this.#work(WORK_RESTART);
-	}
+	return Object.freeze(instance) as Timer;
+}
 
-	/**
-	 * Start the timer _(if it's not running)_
-	 */
-	start(): Timer {
-		return this.#work(WORK_START);
-	}
+function destroyTimer(
+	name: TimerName,
+	instance: Timer,
+	state: TimerState,
+	options: TimerOptions,
+): void {
+	state.destroyed = true;
 
-	/**
-	 * Stop the timer _(if it's running)_
-	 */
-	stop(): Timer {
-		return this.#work(WORK_STOP);
-	}
+	options.onAfter = noop;
+	options.onError = noop;
+	state.callback = noop;
 
-	#work(type: WorkHandlerType): Timer {
-		return work(
-			type,
-			{
-				instance: this,
-				type: this.$timer,
-			},
-			this.state,
-			this.options,
-		);
+	if (!globalThis._oscarpalmer_timer_debug) {
+		state.trace = undefined;
 	}
+
+	stop({instance, name}, state, options);
 }

package/src/wait.ts

@@ -1,8 +1,8 @@
 import {TYPE_WAIT} from './constants';
 import {getCallback, getValidNumber} from './get';
 import './global';
-import {TimerTrace} from './models';
-import {Timer} from './timer';
+import {type Timer, TimerTrace} from './models';
+import {createTimer} from './timer';
 
 /**
  * Create a waiting timer
@@ -11,7 +11,7 @@ import {Timer} from './timer';
  * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
  */
 export function wait(callback: () => void, time?: number): Timer {
-	return new Timer(
+	return createTimer(
 		TYPE_WAIT,
 		{
 			callback: getCallback(callback),
@@ -27,5 +27,3 @@ export function wait(callback: () => void, time?: number): Timer {
 		true,
 	);
 }
-
-export type {Timer};