@oscarpalmer/timer 0.33.0 → 0.35.0

package/src/global.ts

@@ -1,4 +1,9 @@
-import {activeTimers, hiddenTimers} from './constants';
+import {
+	activeTimers,
+	hiddenTimers,
+	WORK_CONTINUE,
+	WORK_PAUSE,
+} from './constants';
 import type {Timer} from './timer';
 
 declare global {
@@ -15,16 +20,14 @@ if (globalThis._oscarpalmer_timers == null) {
 }
 
 document.addEventListener('visibilitychange', () => {
-	if (document.hidden) {
-		for (const timer of activeTimers) {
-			hiddenTimers.add(timer);
-			timer.pause();
-		}
-	} else {
-		for (const timer of hiddenTimers) {
-			timer.continue();
-		}
+	const from = document.hidden ? activeTimers : hiddenTimers;
+	const method = document.hidden ? WORK_PAUSE : WORK_CONTINUE;
+	const to = document.hidden ? hiddenTimers : activeTimers;
 
-		hiddenTimers.clear();
+	for (const timer of from) {
+		timer[method]();
+		to.add(timer);
 	}
+
+	from.clear();
 });

package/src/is.ts

@@ -1,4 +1,5 @@
 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';
 
@@ -10,26 +11,26 @@ function is(names: string[], value: unknown) {
  * Is the value a repeating timer?
  */
 export function isRepeated(value: unknown): value is Timer {
-	return is(['repeat'], value);
+	return is([TYPE_REPEAT], value);
 }
 
 /**
  * Is the value a timer?
  */
 export function isTimer(value: unknown): value is Timer {
-	return is(['repeat', 'wait'], value);
+	return is([TYPE_REPEAT, TYPE_WAIT], value);
 }
 
 /**
  * Is the value a waiting timer?
  */
 export function isWaited(value: unknown): value is Timer {
-	return is(['wait'], value);
+	return is([TYPE_WAIT], value);
 }
 
 /**
  * Is the value a conditional timer?
  */
 export function isWhen(value: unknown): value is When {
-	return is(['when'], value) && typeof (value as When).then === 'function';
+	return is([TYPE_WHEN], value) && typeof (value as When).then === 'function';
 }

package/src/repeat.ts

@@ -1,4 +1,4 @@
-import {milliseconds} from './constants';
+import {milliseconds, TYPE_REPEAT} from './constants';
 import {getCallback, getValidNumber} from './get';
 import './global';
 import {type RepeatOptions, TimerTrace} from './models';
@@ -12,7 +12,7 @@ export function repeat(
 	options?: Partial<RepeatOptions>,
 ): Timer {
 	return new Timer(
-		'repeat',
+		TYPE_REPEAT,
 		{
 			callback: getCallback(callback),
 			trace: new TimerTrace().stack,

package/src/timer.ts

@@ -1,4 +1,11 @@
 import {noop} from '@oscarpalmer/atoms/function';
+import {
+	WORK_CONTINUE,
+	WORK_PAUSE,
+	WORK_RESTART,
+	WORK_START,
+	WORK_STOP,
+} from './constants';
 import type {
 	TimerOptions,
 	TimerState,
@@ -37,7 +44,7 @@ export class Timer {
 	 * Get the timer's origin _(if debugging is enabled)_
 	 */
 	get trace(): string | undefined {
-		return globalThis._oscarpalmer_timer_debug ?? false
+		return (globalThis._oscarpalmer_timer_debug ?? false)
 			? this.state.trace
 			: undefined;
 	}
@@ -70,7 +77,7 @@ export class Timer {
 	 * Continue running the timer _(if it's paused)_
 	 */
 	continue(): Timer {
-		return this.#work('continue');
+		return this.#work(WORK_CONTINUE);
 	}
 
 	/**
@@ -101,28 +108,28 @@ export class Timer {
 	 * Pause the timer _(if it's running)_
 	 */
 	pause(): Timer {
-		return this.#work('pause');
+		return this.#work(WORK_PAUSE);
 	}
 
 	/**
 	 * Restart the timer _(or start it, if it's not running)_
 	 */
 	restart(): Timer {
-		return this.#work('restart');
+		return this.#work(WORK_RESTART);
 	}
 
 	/**
 	 * Start the timer _(if it's not running)_
 	 */
 	start(): Timer {
-		return this.#work('start');
+		return this.#work(WORK_START);
 	}
 
 	/**
 	 * Stop the timer _(if it's running)_
 	 */
 	stop(): Timer {
-		return this.#work('stop');
+		return this.#work(WORK_STOP);
 	}
 
 	#work(type: WorkHandlerType): Timer {

package/src/wait.ts

@@ -1,4 +1,4 @@
-import {milliseconds} from './constants';
+import {milliseconds, TYPE_WAIT} from './constants';
 import {getCallback, getValidNumber} from './get';
 import './global';
 import {TimerTrace} from './models';
@@ -11,7 +11,7 @@ import {Timer} from './timer';
  */
 export function wait(callback: () => void, time?: number): Timer {
 	return new Timer(
-		'wait',
+		TYPE_WAIT,
 		{
 			callback: getCallback(callback),
 			trace: new TimerTrace().stack,

package/src/when.ts

@@ -1,12 +1,19 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import {destroyedMessage, milliseconds, startedMessage} from './constants';
+import {
+	defaultTimeout,
+	destroyedMessage,
+	milliseconds,
+	startedMessage,
+	TYPE_WHEN,
+} from './constants';
 import {getValidNumber} from './get';
 import './global';
 import {TimerTrace, type WhenOptions, type WhenState} from './models';
 import {Timer} from './timer';
 
 class When {
-	private readonly $timer = 'when';
+	private readonly $timer = TYPE_WHEN;
+
 	private readonly state: WhenState = {
 		promise: undefined as never,
 		rejecter: undefined as never,
@@ -40,7 +47,7 @@ class When {
 	 * Get the timer's origin _(if debugging is enabled)_
 	 */
 	get trace(): string | undefined {
-		return globalThis._oscarpalmer_timer_debug ?? false
+		return (globalThis._oscarpalmer_timer_debug ?? false)
 			? this.state.timer?.trace
 			: undefined;
 	}
@@ -56,7 +63,7 @@ class When {
 		let result = false;
 
 		this.state.timer = new Timer(
-			'when',
+			TYPE_WHEN,
 			{
 				callback(): void {
 					try {
@@ -88,7 +95,7 @@ class When {
 				},
 				count: getValidNumber(options?.count),
 				interval: getValidNumber(options?.interval, milliseconds),
-				timeout: getValidNumber(options?.timeout),
+				timeout: getValidNumber(options?.timeout, defaultTimeout),
 			},
 			false,
 		);

package/src/work.ts

@@ -1,11 +1,13 @@
 import {
 	activeTimers,
-	beginTypes,
-	endOrRestartTypes,
-	endTypes,
 	intervalBuffer,
 	milliseconds,
-	pauseTypes,
+	TYPE_WAIT,
+	WORK_CONTINUE,
+	WORK_PAUSE,
+	WORK_RESTART,
+	WORK_START,
+	WORK_STOP,
 } from './constants';
 import type {
 	TimerOptions,
@@ -15,40 +17,21 @@ import type {
 } from './models';
 import type {Timer} from './timer';
 
-function endOrRestart(
-	type: WorkHandlerType,
-	timer: WorkHandlerTimer,
-	state: TimerState,
-	options: TimerOptions,
-): Timer {
-	cancelAnimationFrame(state.frame as never);
-
-	if (type === 'stop') {
-		options.onAfter?.(false);
-	}
-
-	state.active = false;
-	state.frame = undefined;
-	state.paused = type === 'pause';
-
-	return type === 'restart'
-		? work('start', timer, state, options)
-		: timer.instance;
-}
-
 function finish(
 	timer: WorkHandlerTimer,
 	state: TimerState,
 	options: TimerOptions,
 	success: boolean,
 ): void {
+	cancelAnimationFrame(state.frame as never);
+
 	activeTimers.delete(timer.instance);
 
 	state.active = false;
 	state.elapsed = 0;
 	state.frame = undefined;
 
-	if (timer.type === 'wait') {
+	if (timer.type === TYPE_WAIT) {
 		state.callback();
 	} else {
 		options.onAfter?.(success);
@@ -56,10 +39,23 @@ function finish(
 }
 
 function ignore(type: WorkHandlerType, state: TimerState): boolean {
-	return (
-		(state.destroyed && type !== 'stop') ||
-		(state.active ? beginTypes.has(type) : endTypes.has(type))
-	);
+	if (state.destroyed) {
+		return type !== WORK_STOP;
+	}
+
+	if (state.paused) {
+		return type === WORK_PAUSE || type === WORK_START;
+	}
+
+	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(
@@ -121,7 +117,7 @@ function run(
 }
 
 function setState(type: WorkHandlerType, state: TimerState): void {
-	const pausable = pauseTypes.has(type);
+	const pausable = type === WORK_CONTINUE || type === WORK_PAUSE;
 
 	state.elapsed = pausable ? state.elapsed : 0;
 	state.index = pausable ? state.index : 0;
@@ -129,12 +125,22 @@ function setState(type: WorkHandlerType, state: TimerState): void {
 }
 
 export function stop(
-	timer: WorkHandlerTimer,
-	state: TimerState,
-	options: TimerOptions,
-): void {
-	endOrRestart('stop', timer, state, options);
-}
+		timer: WorkHandlerTimer,
+		state: TimerState,
+		options: TimerOptions,
+	): Timer {
+		cancelAnimationFrame(state.frame as never);
+
+		activeTimers.delete(timer.instance);
+
+		options.onAfter?.(false);
+
+		state.active = !stop;
+		state.frame = undefined;
+		state.paused = false;
+
+		return timer.instance;
+	}
 
 export function work(
 	type: WorkHandlerType,
@@ -148,12 +154,22 @@ export function work(
 
 	setState(type, state);
 
-	if (endOrRestartTypes.has(type)) {
-		return endOrRestart(type, timer, state, options);
+	if (type === WORK_STOP) {
+		return stop(timer, state, options);
+	}
+
+	if (type === WORK_PAUSE || type === WORK_RESTART) {
+		cancelAnimationFrame(state.frame as never);
+
+		state.frame = undefined;
 	}
 
 	state.active = true;
-	state.paused = false;
+	state.paused = type === WORK_PAUSE;
+
+	if (state.paused) {
+		return pause(timer, state);
+	}
 
 	activeTimers.add(timer.instance);
 

package/types/constants.d.cts

@@ -67,14 +67,11 @@ export type TimerState = {
 };
 export type TimerType = "repeat" | "wait" | "when";
 export type WorkHandlerType = "continue" | "pause" | "restart" | "start" | "stop";
+export declare const defaultTimeout = 30000;
 /**
  * A set of all active timers
  */
 export declare const activeTimers: Set<Timer>;
-/**
- * A set of types that allow work to begin
- */
-export declare const beginTypes: Set<WorkHandlerType>;
 /**
  * Buffer value to use when evaluating if a specific time is within a certain range
  */
@@ -83,23 +80,22 @@ export declare const intervalBuffer = 5;
  * Message to show when a when-timer is destroyed
  */
 export declare const destroyedMessage = "Timer has already been destroyed";
-/**
- * A set of types that allow work to end
- */
-export declare const endTypes: Set<WorkHandlerType>;
-/**
- * A set of types that allow work to end or restart
- */
-export declare const endOrRestartTypes: Set<WorkHandlerType>;
 /**
  * A set of timers that were paused due to the document being hidden
  */
 export declare const hiddenTimers: Set<Timer>;
-export declare const pauseTypes: Set<WorkHandlerType>;
 /**
  * Message to show when a when-timer is started
  */
 export declare const startedMessage = "Timer has already been started";
+export declare const TYPE_REPEAT: TimerType;
+export declare const TYPE_WAIT: TimerType;
+export declare const TYPE_WHEN: TimerType;
+export declare const WORK_CONTINUE: WorkHandlerType;
+export declare const WORK_PAUSE: WorkHandlerType;
+export declare const WORK_RESTART: WorkHandlerType;
+export declare const WORK_START: WorkHandlerType;
+export declare const WORK_STOP: WorkHandlerType;
 /**
  * A calculated average of the refresh rate of the display _(in milliseconds)_
  */

package/types/constants.d.ts

@@ -1,13 +1,10 @@
-import type { WorkHandlerType } from './models';
+import type { TimerType, WorkHandlerType } from './models';
 import type { Timer } from './timer';
+export declare const defaultTimeout = 30000;
 /**
  * A set of all active timers
  */
 export declare const activeTimers: Set<Timer>;
-/**
- * A set of types that allow work to begin
- */
-export declare const beginTypes: Set<WorkHandlerType>;
 /**
  * Buffer value to use when evaluating if a specific time is within a certain range
  */
@@ -16,23 +13,22 @@ export declare const intervalBuffer = 5;
  * Message to show when a when-timer is destroyed
  */
 export declare const destroyedMessage = "Timer has already been destroyed";
-/**
- * A set of types that allow work to end
- */
-export declare const endTypes: Set<WorkHandlerType>;
-/**
- * A set of types that allow work to end or restart
- */
-export declare const endOrRestartTypes: Set<WorkHandlerType>;
 /**
  * A set of timers that were paused due to the document being hidden
  */
 export declare const hiddenTimers: Set<Timer>;
-export declare const pauseTypes: Set<WorkHandlerType>;
 /**
  * Message to show when a when-timer is started
  */
 export declare const startedMessage = "Timer has already been started";
+export declare const TYPE_REPEAT: TimerType;
+export declare const TYPE_WAIT: TimerType;
+export declare const TYPE_WHEN: TimerType;
+export declare const WORK_CONTINUE: WorkHandlerType;
+export declare const WORK_PAUSE: WorkHandlerType;
+export declare const WORK_RESTART: WorkHandlerType;
+export declare const WORK_START: WorkHandlerType;
+export declare const WORK_STOP: WorkHandlerType;
 /**
  * A calculated average of the refresh rate of the display _(in milliseconds)_
  */

package/types/get.d.cts

@@ -1,5 +1,8 @@
 // Generated by dts-bundle-generator v9.5.1
 
+/**
+ * A generic callback function
+ */
 export type GenericCallback = (...args: any[]) => any;
 export declare function getCallback(value: unknown): GenericCallback;
 export declare function getValidNumber(value: unknown, defaultValue?: number): number;

package/types/work.d.cts

@@ -71,7 +71,7 @@ export type WorkHandlerTimer = {
 	type: TimerType;
 };
 export type WorkHandlerType = "continue" | "pause" | "restart" | "start" | "stop";
-declare function stop$1(timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): void;
+declare function stop$1(timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): Timer;
 export declare function work(type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): Timer;
 
 export {

package/types/work.d.ts

@@ -1,4 +1,4 @@
 import type { TimerOptions, TimerState, WorkHandlerTimer, WorkHandlerType } from './models';
 import type { Timer } from './timer';
-export declare function stop(timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): void;
+export declare function stop(timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): Timer;
 export declare function work(type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): Timer;