@oscarpalmer/timer 0.43.0 → 0.45.0

package/src/repeat.ts

@@ -1,8 +1,8 @@
 import {TYPE_REPEAT} from './constants';
-import {getCallback, getValidNumber} from './get';
+import {getCallback, getValidNumber} from './misc';
 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,65 @@
 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 {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);
+import type {Timer, TimerName, TimerOptions, TimerState} from './models';
+import {work} from './work';
+
+export function createTimer(
+	name: TimerName,
+	pick: Pick<TimerState, 'callback' | 'trace'>,
+	options: TimerOptions,
+	start: boolean,
+): Timer {
+	const state: TimerState = {
+		...pick,
+		name,
+		options,
+		active: false,
+		destroyed: false,
+		elapsed: 0,
+		frame: undefined,
+		index: 0,
+		paused: false,
+		timer: undefined as never,
+		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,
+		},
+		destroyed: {
+			enumerable: true,
+			value: false,
+		},
+		paused: {
+			enumerable: true,
+			get: () => state.paused,
+		},
+		trace: {
+			enumerable: true,
+			get: () => ((globalThis._oscarpalmer_timer_debug ?? false) ? state.trace : undefined),
+		},
+	});
+
+	state.timer = Object.freeze(instance) as Timer;
+
+	if (start) {
+		state.timer.start();
 	}
 
-	/**
-	 * 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(
-			{
-				instance: this,
-				type: this.$timer,
-			},
-			this.state,
-			this.options,
-		);
-	}
-
-	/**
-	 * Pause the timer _(if it's running)_
-	 */
-	pause(): Timer {
-		return this.#work(WORK_PAUSE);
-	}
-
-	/**
-	 * Restart the timer _(or start it, if it's not running)_
-	 */
-	restart(): Timer {
-		return this.#work(WORK_RESTART);
-	}
-
-	/**
-	 * Start the timer _(if it's not running)_
-	 */
-	start(): Timer {
-		return this.#work(WORK_START);
-	}
-
-	/**
-	 * Stop the timer _(if it's running)_
-	 */
-	stop(): Timer {
-		return this.#work(WORK_STOP);
-	}
-
-	#work(type: WorkHandlerType): Timer {
-		return work(
-			type,
-			{
-				instance: this,
-				type: this.$timer,
-			},
-			this.state,
-			this.options,
-		);
-	}
+	return state.timer;
 }

package/src/wait.ts

@@ -1,8 +1,8 @@
 import {TYPE_WAIT} from './constants';
-import {getCallback, getValidNumber} from './get';
+import {getCallback, getValidNumber} from './misc';
 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};

package/src/when.ts

@@ -1,166 +1,52 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import {MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN} from './constants';
-import {getValidNumber, getValidTimeout} from './get';
+import {MESSAGE_STARTED, TYPE_WHEN, WORK_CONTINUE, WORK_PAUSE, WORK_STOP} from './constants';
+import {getValidNumber, getValidTimeout} from './misc';
 import './global';
-import {TimerTrace, type WhenOptions, type WhenState} from './models';
-import {Timer} from './timer';
-
-class When {
-	declare private readonly $timer: string;
-
-	private readonly state: WhenState = {
-		promise: undefined as never,
-		rejecter: undefined as never,
-		resolver: undefined as never,
-		started: false,
-		timer: undefined as never,
-	};
-
-	/**
-	 * 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(): string | undefined {
-		return (globalThis._oscarpalmer_timer_debug ?? false) ? this.state.timer?.trace : undefined;
-	}
-
-	constructor(condition: () => boolean, options?: Partial<WhenOptions>) {
-		Object.defineProperty(this, '$timer', {
-			value: TYPE_WHEN,
-		});
-
-		const {state} = this;
-
-		state.promise = new Promise<void>((resolve, reject) => {
-			state.resolver = resolve;
-			state.rejecter = reject;
-		});
-
-		let result = false;
-
-		this.state.timer = new Timer(
-			TYPE_WHEN,
-			{
-				callback(): void {
-					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),
-				timeout: getValidTimeout(options?.timeout),
-			},
-			false,
-		);
+import {
+	TimerTrace,
+	type When,
+	type WhenOptions,
+	type WhenState,
+	type WorkHandlerType,
+} from './models';
+import {createTimer} from './timer';
+
+function onAfter(state: WhenState): void {
+	if (state.result) {
+		state.resolver?.();
+	} else {
+		state.rejecter?.();
 	}
+}
 
-	/**
-	 * Continues the timer _(if it was paused)_
-	 */
-	continue(): When {
-		this.state.timer?.continue();
+function onCallback(condition: () => boolean, state: WhenState): void {
+	try {
+		if (condition()) {
+			state.result = true;
 
-		return this;
+			state.timer.stop();
+		}
+	} catch {
+		state.timer.stop();
 	}
+}
 
-	/**
-	 * Destroys the timer _(and stops it,if it was running)_
-	 */
-	destroy(): void {
-		const {state} = this;
-
-		state.timer?.destroy();
-
-		state.promise = undefined as never;
-		state.resolver = noop;
-		state.rejecter = noop;
-		state.timer = undefined as never;
-	}
+function onWhen(type: WorkHandlerType, instance: When, state: WhenState): When {
+	state.timer?.[type]?.();
 
-	/**
-	 * Pauses the timer _(if it was running)_
-	 */
-	pause(): When {
-		this.state.timer?.pause();
+	return instance;
+}
 
-		return this;
+function startWhen(state: WhenState, resolve?: (() => void) | null): Promise<void> {
+	if (state.started) {
+		throw new Error(MESSAGE_STARTED);
 	}
 
-	/**
-	 * Start the timer
-	 *
-	 * @param resolve Optional resolve callback
-	 * @returns Promise that resolves when the condition is met
-	 */
-	start(resolve?: (() => void) | null): Promise<void> {
-		const {state} = this;
-
-		if (state.timer == null) {
-			throw new Error(MESSAGE_DESTROYED);
-		}
-
-		if (state.started) {
-			throw new Error(MESSAGE_STARTED);
-		}
-
-		state.started = true;
+	state.started = true;
 
-		state.timer.start();
-
-		return state.promise.then(resolve);
-	}
+	state.timer.start();
 
-	/**
-	 * Stops the timer _(if it was running)_
-	 */
-	stop(): When {
-		this.state.timer?.stop();
-
-		return this;
-	}
+	return state.promise.then(resolve);
 }
 
 /**
@@ -170,7 +56,66 @@ class When {
  * @returns Timer instance
  */
 export function when(condition: () => boolean, options?: Partial<WhenOptions>): When {
-	return new When(condition, options);
-}
+	const state: WhenState = {
+		promise: undefined as never,
+		result: false,
+		started: false,
+		timer: undefined as never,
+	};
 
-export type {When};
+	let instance: When;
+
+	state.promise = new Promise<void>((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: never) => startWhen(state, resolve),
+		stop: () => onWhen(WORK_STOP, instance, state),
+	} as When;
+
+	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 : undefined),
+		},
+	});
+
+	return Object.freeze(instance) as When;
+}

package/src/work.ts

@@ -1,5 +1,4 @@
 import {
-	TIMERS_ACTIVE,
 	BUFFER_INTERVAL,
 	TYPE_WAIT,
 	WORK_CONTINUE,
@@ -8,35 +7,26 @@ import {
 	WORK_START,
 	WORK_STOP,
 } from './constants';
-import type {TimerOptions, TimerState, WorkHandlerTimer, WorkHandlerType} from './models';
-import type {Timer} from './timer';
-
-function finish(
-	timer: WorkHandlerTimer,
-	state: TimerState,
-	options: TimerOptions,
-	success: boolean,
-): void {
-	cancelAnimationFrame(state.frame as never);
+import {updateStates} from './misc';
+import type {Timer, TimerState, WorkHandlerType} from './models';
+
+function finish(state: TimerState, success: boolean): void {
+	updateStates(state);
 
-	TIMERS_ACTIVE.delete(timer.instance);
+	cancelAnimationFrame(state.frame as never);
 
 	state.active = false;
 	state.elapsed = 0;
 	state.frame = undefined;
 
-	if (timer.type === TYPE_WAIT) {
+	if (state.name === TYPE_WAIT) {
 		state.callback();
 	} else {
-		options.onAfter?.(success);
+		state.options.onAfter?.(success);
 	}
 }
 
 function ignore(type: WorkHandlerType, state: TimerState): boolean {
-	if (state.destroyed) {
-		return type !== WORK_STOP;
-	}
-
 	if (state.paused) {
 		return type === WORK_PAUSE || type === WORK_START;
 	}
@@ -44,19 +34,7 @@ function ignore(type: WorkHandlerType, state: TimerState): boolean {
 	return state.active && type === WORK_START;
 }
 
-function pause(timer: WorkHandlerTimer, state: TimerState): Timer {
-	cancelAnimationFrame(state.frame as never);
-
-	state.frame = undefined;
-
-	return timer.instance;
-}
-
-function run(
-	timer: WorkHandlerTimer,
-	state: TimerState,
-	options: TimerOptions,
-): (now: DOMHighResTimeStamp) => void {
+function run(state: TimerState): (now: DOMHighResTimeStamp) => void {
 	let last: DOMHighResTimeStamp | undefined;
 	let start: DOMHighResTimeStamp | undefined;
 
@@ -75,16 +53,16 @@ function run(
 
 		last = now;
 
-		if (options.timeout > 0 && state.total >= options.timeout) {
-			options.onError?.();
+		if (state.options.timeout > 0 && state.total >= state.options.timeout) {
+			state.options.onError?.();
 
-			finish(timer, state, options, false);
+			finish(state, false);
 
 			return;
 		}
 
-		if (options.interval === 0 || state.elapsed >= options.interval - BUFFER_INTERVAL) {
-			if (options.count > -1) {
+		if (state.options.interval === 0 || state.elapsed >= state.options.interval - BUFFER_INTERVAL) {
+			if (state.options.count > -1) {
 				(state.callback as (index: number) => void)(state.index);
 			}
 
@@ -93,8 +71,11 @@ function run(
 			state.elapsed = 0;
 			state.index += 1;
 
-			if (options.count === -1 || (options.count > 0 && state.index >= options.count)) {
-				finish(timer, state, options, true);
+			if (
+				state.options.count === -1 ||
+				(state.options.count > 0 && state.index >= state.options.count)
+			) {
+				finish(state, true);
 
 				return;
 			}
@@ -112,34 +93,29 @@ function setState(type: WorkHandlerType, state: TimerState): void {
 	state.total = pausable ? state.total : 0;
 }
 
-export function stop(timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): Timer {
-	cancelAnimationFrame(state.frame as never);
+export function stop(state: TimerState): Timer {
+	updateStates(state);
 
-	TIMERS_ACTIVE.delete(timer.instance);
+	cancelAnimationFrame(state.frame as never);
 
-	options.onAfter?.(false);
+	state.options.onAfter?.(false);
 
-	state.active = !stop;
+	state.active = false;
 	state.frame = undefined;
 	state.paused = false;
 
-	return timer.instance;
+	return state.timer;
 }
 
-export function work(
-	type: WorkHandlerType,
-	timer: WorkHandlerTimer,
-	state: TimerState,
-	options: TimerOptions,
-): Timer {
+export function work(type: WorkHandlerType, state: TimerState, hide?: boolean): Timer {
 	if (ignore(type, state)) {
-		return timer.instance;
+		return state.timer;
 	}
 
 	setState(type, state);
 
 	if (type === WORK_STOP) {
-		return stop(timer, state, options);
+		return stop(state);
 	}
 
 	if (type === WORK_PAUSE || type === WORK_RESTART) {
@@ -151,15 +127,15 @@ export function work(
 	state.active = true;
 	state.paused = type === WORK_PAUSE;
 
+	updateStates(state, state.paused ? ((hide ?? false) ? 'hidden' : undefined) : 'active');
+
 	if (state.paused) {
-		return pause(timer, state);
+		return state.timer;
 	}
 
-	TIMERS_ACTIVE.add(timer.instance);
-
-	const runner = run(timer, state, options);
+	const runner = run(state);
 
 	state.frame = requestAnimationFrame(runner);
 
-	return timer.instance;
+	return state.timer;
 }

package/dist/delay.d.mts

@@ -1,3 +0,0 @@
-import { delay } from "@oscarpalmer/atoms/promise/delay";
-import { PromiseOptions } from "@oscarpalmer/atoms/promise/models";
-export { type PromiseOptions, delay };

package/dist/delay.mjs

@@ -1,2 +0,0 @@
-import { delay } from "@oscarpalmer/atoms/promise/delay";
-export { delay };