@oscarpalmer/timer 0.47.0 → 0.49.0

package/src/models.ts

@@ -1,3 +1,5 @@
+// #region Types
+
 /**
  * Options for a repeating timer
  */
@@ -32,7 +34,7 @@ export type Timer = {
 
 	/**
 	 * Is the timer destroyed?
-	 * 
+	 *
 	 * @deprecated Timers take care of their own cleanup; this always returns `false`
 	 */
 	get destroyed(): boolean;
@@ -54,7 +56,7 @@ export type Timer = {
 
 	/**
 	 * Destroy the timer
-	 * 
+	 *
 	 * @deprecated Timers take care of their own cleanup
 	 */
 	destroy(): void;
@@ -133,7 +135,7 @@ export type When = {
 
 	/**
 	 * Is the timer destroyed?
-	 * 
+	 *
 	 * @deprecated Timers take care of their own cleanup; this always returns `false`
 	 */
 	get destroyed(): boolean;
@@ -155,7 +157,7 @@ export type When = {
 
 	/**
 	 * Destroys the timer _(and stops it,if it was running)_
-	 * 
+	 *
 	 * @deprecated Timers take care of their own cleanup
 	 */
 	destroy(): void;
@@ -198,6 +200,7 @@ export type WhenOptions = {
 };
 
 export type WhenState = {
+	name: TimerName;
 	promise: Promise<void>;
 	rejecter?: () => void;
 	resolver?: () => void;
@@ -219,3 +222,5 @@ export type WorkHandlerTimer = {
 };
 
 export type WorkHandlerType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';
+
+// #endregion

package/src/repeat.ts

@@ -4,6 +4,8 @@ import './global';
 import {type RepeatOptions, type Timer, TimerTrace} from './models';
 import {createTimer} from './timer';
 
+// #region Functions
+
 /**
  * Create a repeating timer
  *
@@ -28,3 +30,5 @@ export function repeat(callback: (index: number) => void, options?: Partial<Repe
 		true,
 	);
 }
+
+// #endregion

package/src/timer.ts

@@ -1,65 +1,124 @@
-import {noop} from '@oscarpalmer/atoms/function';
-import {WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP} from './constants';
+import {SYMBOL, WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP} from './constants';
 import type {Timer, TimerName, TimerOptions, TimerState} from './models';
 import {work} from './work';
 
-export function createTimer(
+// #region Types
+
+type InternalTimer = {
+	[SYMBOL]: TimerState;
+} & Timer;
+
+// #endregion
+
+// #region Instances
+
+function Timer(
+	this: any,
 	name: TimerName,
-	pick: Pick<TimerState, 'callback' | 'trace'>,
+	state: 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 && !state.paused,
+) {
+	Object.defineProperty(this, SYMBOL, {
+		value: {
+			...state,
+			name,
+			options,
+			active: false,
+			destroyed: false,
+			elapsed: 0,
+			frame: undefined,
+			index: 0,
+			paused: false,
+			timer: undefined as never,
+			total: 0,
 		},
-		destroyed: {
-			enumerable: true,
-			value: false,
+	});
+
+	if (start) {
+		startTimer.call(this);
+	}
+}
+
+Object.defineProperties(Timer.prototype, {
+	active: {
+		enumerable: true,
+		get() {
+			return isActiveTimer.call(this);
 		},
-		paused: {
-			enumerable: true,
-			get: () => state.paused,
+	},
+	continue: {
+		value: continueTimer,
+	},
+	pause: {
+		value: pauseTimer,
+	},
+	paused: {
+		enumerable: true,
+		get() {
+			return isPausedTimer.call(this);
 		},
-		trace: {
-			enumerable: true,
-			get: () => ((globalThis._oscarpalmer_timer_debug ?? false) ? state.trace : undefined),
+	},
+	restart: {
+		value: restartTimer,
+	},
+	start: {
+		value: startTimer,
+	},
+	stop: {
+		value: stopTimer,
+	},
+	trace: {
+		get() {
+			return getTimerTrace.call(this);
 		},
-	});
+	},
+});
 
-	state.timer = Object.freeze(instance) as Timer;
+// #endregion
 
-	if (start) {
-		state.timer.start();
-	}
+// #region Functions
+
+function continueTimer(this: InternalTimer): Timer {
+	return work(WORK_CONTINUE, this[SYMBOL]);
+}
+
+export function createTimer(
+	name: TimerName,
+	state: Pick<TimerState, 'callback' | 'trace'>,
+	options: TimerOptions,
+	start: boolean,
+): Timer {
+	// @ts-expect-error All good, no worries :-)
+	return new Timer(name, state, options, start);
+}
+
+function getTimerTrace(this: InternalTimer): string | undefined {
+	return (globalThis._oscarpalmer_timer_debug ?? false) ? this[SYMBOL].trace : undefined;
+}
+
+function isActiveTimer(this: InternalTimer): boolean {
+	return this[SYMBOL].active && !this[SYMBOL].paused;
+}
 
-	return state.timer;
+function isPausedTimer(this: InternalTimer): boolean {
+	return this[SYMBOL].paused;
 }
+
+function pauseTimer(this: InternalTimer): Timer {
+	return work(WORK_PAUSE, this[SYMBOL]);
+}
+
+function restartTimer(this: InternalTimer): Timer {
+	return work(WORK_RESTART, this[SYMBOL]);
+}
+
+function startTimer(this: InternalTimer): Timer {
+	return work(WORK_START, this[SYMBOL]);
+}
+
+function stopTimer(this: InternalTimer): Timer {
+	return work(WORK_STOP, this[SYMBOL]);
+}
+
+// #endregion

package/src/wait.ts

@@ -4,6 +4,8 @@ import './global';
 import {type Timer, TimerTrace} from './models';
 import {createTimer} from './timer';
 
+// #region Functions
+
 /**
  * Create a waiting timer
  *
@@ -28,3 +30,5 @@ export function wait(callback: () => void, time?: number): Timer {
 		true,
 	);
 }
+
+// #endregion

package/src/when.ts

@@ -1,7 +1,13 @@
-import {noop} from '@oscarpalmer/atoms/function';
-import {MESSAGE_STARTED, TYPE_WHEN, WORK_CONTINUE, WORK_PAUSE, WORK_STOP} from './constants';
-import {getValidNumber, getValidTimeout} from './misc';
+import {
+	MESSAGE_STARTED,
+	SYMBOL,
+	TYPE_WHEN,
+	WORK_CONTINUE,
+	WORK_PAUSE,
+	WORK_STOP,
+} from './constants';
 import './global';
+import {getValidNumber, getValidTimeout} from './misc';
 import {
 	TimerTrace,
 	type When,
@@ -11,6 +17,110 @@ import {
 } from './models';
 import {createTimer} from './timer';
 
+// #region Types
+
+type InternalWhen = {
+	[SYMBOL]: WhenState;
+} & When;
+
+// #endregion
+
+// #region Instances
+
+function When(this: any, condition: () => boolean, options: WhenOptions) {
+	const state: WhenState = {
+		name: TYPE_WHEN,
+		promise: undefined as never,
+		result: false,
+		started: false,
+		timer: undefined as never,
+	};
+
+	Object.defineProperty(this, SYMBOL, {
+		value: state,
+	});
+
+	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,
+		},
+		{
+			...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);
+		},
+	},
+});
+
+// #endregion
+
+// #region Functions
+
+function continueWhen(this: InternalWhen): When {
+	return onWhen(WORK_CONTINUE, this, this[SYMBOL]);
+}
+
+function getWhenOptions(input: unknown): WhenOptions {
+	const options =
+		typeof input === 'object' && input !== null ? (input as Partial<WhenOptions>) : {};
+
+	return {
+		count: getValidNumber(options?.count),
+		interval: getValidNumber(options?.interval),
+		timeout: getValidTimeout(options?.timeout),
+	};
+}
+
+function getWhenTrace(this: InternalWhen): string | undefined {
+	return (globalThis._oscarpalmer_timer_debug ?? false) ? this[SYMBOL].timer?.trace : undefined;
+}
+
+function isActiveWhen(this: InternalWhen): boolean {
+	return this[SYMBOL].timer.active;
+}
+
+function isPausedWhen(this: InternalWhen): boolean {
+	return this[SYMBOL].timer.paused;
+}
+
 function onAfter(state: WhenState): void {
 	if (state.result) {
 		state.resolver?.();
@@ -37,7 +147,13 @@ function onWhen(type: WorkHandlerType, instance: When, state: WhenState): When {
 	return instance;
 }
 
-function startWhen(state: WhenState, resolve?: (() => void) | null): Promise<void> {
+function pauseWhen(this: InternalWhen): When {
+	return onWhen(WORK_PAUSE, this, this[SYMBOL]);
+}
+
+function startWhen(this: InternalWhen, resolve?: (() => void) | null): Promise<void> {
+	const state = this[SYMBOL];
+
 	if (state.started) {
 		throw new Error(MESSAGE_STARTED);
 	}
@@ -49,6 +165,10 @@ function startWhen(state: WhenState, resolve?: (() => void) | null): Promise<voi
 	return state.promise.then(resolve);
 }
 
+function stopWhen(this: InternalWhen): When {
+	return onWhen(WORK_STOP, this, this[SYMBOL]);
+}
+
 /**
  * Create a conditional timer
  * @param condition Condition to check
@@ -56,66 +176,8 @@ function startWhen(state: WhenState, resolve?: (() => void) | null): Promise<voi
  * @returns Timer instance
  */
 export function when(condition: () => boolean, options?: Partial<WhenOptions>): When {
-	const state: WhenState = {
-		promise: undefined as never,
-		result: false,
-		started: false,
-		timer: undefined as never,
-	};
-
-	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;
+	// @ts-expect-error All good, no worries :-)
+	return new When(condition, getWhenOptions(options));
 }
+
+// #endregion

package/src/work.ts

@@ -7,13 +7,15 @@ import {
 	WORK_START,
 	WORK_STOP,
 } from './constants';
-import {updateStates} from './misc';
+import {startTimer, stopTimer, updateStates} from './misc';
 import type {Timer, TimerState, WorkHandlerType} from './models';
 
+// #region Functions
+
 function finish(state: TimerState, success: boolean): void {
 	updateStates(state);
 
-	cancelAnimationFrame(state.frame as never);
+	stopTimer(state.frame as never);
 
 	state.active = false;
 	state.elapsed = 0;
@@ -34,14 +36,16 @@ function ignore(type: WorkHandlerType, state: TimerState): boolean {
 	return state.active && (type === WORK_CONTINUE || type === WORK_START);
 }
 
-function run(state: TimerState): (now: DOMHighResTimeStamp) => void {
-	let last: DOMHighResTimeStamp | undefined;
+function run(state: TimerState): () => void {
+	let last: number | undefined;
 
-	return function step(now: DOMHighResTimeStamp): void {
+	return function step(): void {
 		if (!state.active) {
 			return;
 		}
 
+		const now = performance.now();
+
 		last ??= now;
 
 		const difference = now - last;
@@ -77,7 +81,7 @@ function run(state: TimerState): (now: DOMHighResTimeStamp) => void {
 			}
 		}
 
-		state.frame = requestAnimationFrame(step);
+		state.frame = startTimer(step);
 	};
 }
 
@@ -92,7 +96,7 @@ function setState(type: WorkHandlerType, state: TimerState): void {
 export function stop(state: TimerState): Timer {
 	updateStates(state);
 
-	cancelAnimationFrame(state.frame as never);
+	stopTimer(state.frame as never);
 
 	state.options.onAfter?.(false);
 
@@ -115,7 +119,7 @@ export function work(type: WorkHandlerType, state: TimerState, hide?: boolean):
 	}
 
 	if (type === WORK_PAUSE || type === WORK_RESTART) {
-		cancelAnimationFrame(state.frame as never);
+		stopTimer(state.frame as never);
 
 		state.frame = undefined;
 	}
@@ -131,7 +135,9 @@ export function work(type: WorkHandlerType, state: TimerState, hide?: boolean):
 
 	const runner = run(state);
 
-	state.frame = requestAnimationFrame(runner);
+	state.frame = startTimer(runner);
 
 	return state.timer;
 }
+
+// #endregion