@oscarpalmer/timer 0.42.0 → 0.44.0

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,17 +1,18 @@
 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
+ *
  * @param callback Callback to run on each interval
  * @param options Timer options
  * @returns Timer instance
  */
 export function repeat(callback: (index: number) => void, options?: Partial<RepeatOptions>): Timer {
-	return new Timer(
+	return createTimer(
 		TYPE_REPEAT,
 		{
 			callback: getCallback(callback),
@@ -27,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,16 +1,17 @@
 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
+ *
  * @param callback Callback to run when the timer has finished
  * @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),
@@ -26,5 +27,3 @@ export function wait(callback: () => void, time?: number): Timer {
 		true,
 	);
 }
-
-export type {Timer};

package/src/when.ts

@@ -1,178 +1,73 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import {MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN} from './constants';
+import {MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN, WORK_CONTINUE} from './constants';
 import {getValidNumber, getValidTimeout} from './get';
 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;
-	}
+import {
+	TimerTrace,
+	type When,
+	type WhenOptions,
+	type WhenState,
+	type WorkHandlerType,
+} from './models';
+import {createTimer} from './timer';
+
+function destroyWhen(state: WhenState): void {
+	state.timer?.destroy();
+
+	state.promise = undefined as never;
+	state.resolver = noop;
+	state.rejecter = noop;
+	state.timer = undefined as never;
+}
 
-	/**
-	 * Get the timer's origin _(if debugging is enabled)_
-	 */
-	get trace(): string | undefined {
-		return (globalThis._oscarpalmer_timer_debug ?? false) ? this.state.timer?.trace : undefined;
+function onAfter(instance: When, state: WhenState): void {
+	if (state.result) {
+		state.resolver?.();
+	} else {
+		state.rejecter?.();
 	}
 
-	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,
-		);
-	}
+	instance.destroy();
+}
 
-	/**
-	 * 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;
+function onError(instance: When, state: WhenState): void {
+	state.rejecter?.();
 
-		state.timer?.destroy();
+	instance.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.timer == null) {
+		throw new Error(MESSAGE_DESTROYED);
 	}
 
-	/**
-	 * Start the timer
-	 * @param resolve Optional resolve callback
-	 * @param reject Optional reject callback
-	 * @returns Promise that resolves when the condition is met
-	 */
-	start(resolve?: (() => void) | null, reject?: (() => 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.timer.start();
-
-		return state.promise.then(resolve ?? noop, reject ?? noop);
+	if (state.started) {
+		throw new Error(MESSAGE_STARTED);
 	}
 
-	/**
-	 * Stops the timer _(if it was running)_
-	 */
-	stop(): When {
-		this.state.timer?.stop();
+	state.started = true;
 
-		return this;
-	}
+	state.timer.start();
 
-	/**
-	 * Start the timer
-	 * @deprecated Use `start()` instead
-	 * @param resolve Optional resolve callback
-	 * @param reject Optional reject callback
-	 * @returns Promise that resolves when the condition is met
-	 */
-	// oxlint-disable-next-line no-thenable: Returning a promise-like object, so it's ok ;)
-	then(resolve?: (() => void) | null, reject?: (() => void) | null): Promise<void> {
-		return this.start(resolve, reject);
-	}
+	return state.promise.then(resolve);
 }
 
 /**
@@ -182,7 +77,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(instance, state),
+			onError: () => onError(instance, state),
+			count: getValidNumber(options?.count),
+			interval: getValidNumber(options?.interval),
+			timeout: getValidTimeout(options?.timeout),
+		},
+		false,
+	);
+
+	instance = {
+		continue: () => onWhen(WORK_CONTINUE, instance, state),
+		destroy: () => destroyWhen(state),
+		pause: () => onWhen('pause', instance, state),
+		start: (resolve?: (() => void) | null) => startWhen(state, resolve),
+		stop: () => onWhen('stop', instance, state),
+	} as When;
+
+	Object.defineProperties(instance, {
+		$timer: {
+			enumerable: false,
+			value: TYPE_WHEN,
+		},
+		active: {
+			enumerable: true,
+			get: () => state.timer?.active ?? false,
+		},
+		destroyed: {
+			enumerable: true,
+			get: () => state.timer == null,
+		},
+		paused: {
+			enumerable: true,
+			get: () => state.timer?.paused ?? false,
+		},
+		trace: {
+			enumerable: true,
+			get: () => ((globalThis._oscarpalmer_timer_debug ?? false) ? state.timer?.trace : undefined),
+		},
+	});
+
+	return Object.freeze(instance) as When;
+}