@oscarpalmer/timer 0.22.1 → 0.24.0

package/src/when.ts

@@ -2,13 +2,24 @@ import {noop} from '@oscarpalmer/atoms/function';
 import type {WhenOptions, WhenState} from './models';
 import {BasicTimer, timer} from './timer';
 
+const destroyedMessage = 'Timer has already been destroyed';
+const startedMessage = 'Timer has already been started';
+
 export class When extends BasicTimer<WhenState> {
 	get active() {
-		return this.state.timer.active;
+		return this.state.timer?.active ?? false;
+	}
+
+	get destroyed() {
+		return this.state.timer == null;
 	}
 
 	get paused() {
-		return this.state.timer.paused;
+		return this.state.timer?.paused ?? false;
+	}
+
+	get trace() {
+		return this.state.timer?.trace;
 	}
 
 	constructor(state: WhenState) {
@@ -19,16 +30,28 @@ export class When extends BasicTimer<WhenState> {
 	 * Continues the timer _(if it was paused)_
 	 */
 	continue(): When {
-		this.state.timer.continue();
+		this.state.timer?.continue();
 
 		return this;
 	}
 
+	/**
+	 * Destroys the timer _(and stops it,if it was running)_
+	 */
+	destroy(): void {
+		this.state.timer?.destroy();
+
+		this.state.promise = undefined as never;
+		this.state.resolver = noop;
+		this.state.rejecter = noop;
+		this.state.timer = undefined as never;
+	}
+
 	/**
 	 * Pauses the timer _(if it was running)_
 	 */
 	pause(): When {
-		this.state.timer.pause();
+		this.state.timer?.pause();
 
 		return this;
 	}
@@ -37,11 +60,7 @@ export class When extends BasicTimer<WhenState> {
 	 * Stops the timer _(if it was running)_
 	 */
 	stop(): When {
-		if (this.state.timer.active) {
-			this.state.timer.stop();
-
-			this.state.rejecter?.();
-		}
+		this.state.timer?.stop();
 
 		return this;
 	}
@@ -49,12 +68,19 @@ export class When extends BasicTimer<WhenState> {
 	/**
 	 * Starts the timer and returns a promise that resolves when the condition is met
 	 */
-
 	// biome-ignore lint/suspicious/noThenProperty: returning a promise-like object, so it's ok ;)
 	then(
 		resolve?: (() => void) | null,
 		reject?: (() => void) | null,
 	): Promise<void> {
+		if (this.state.timer == null || this.state?.started) {
+			throw new Error(
+				this.state.timer == null ? destroyedMessage : startedMessage,
+			);
+		}
+
+		this.state.started = true;
+
 		this.state.timer.start();
 
 		return this.state.promise.then(resolve ?? noop, reject ?? noop);
@@ -69,43 +95,52 @@ export function when(
 	condition: () => boolean,
 	options?: Partial<WhenOptions>,
 ): When {
-	const repeated = timer(
-		'repeat',
-		() => {
-			if (condition()) {
-				repeated.stop();
-
-				state.resolver?.();
-			}
-		},
-		{
-			afterCallback() {
-				if (!repeated.paused) {
-					if (condition()) {
-						state.resolver?.();
-					} else {
-						state.rejecter?.();
-					}
+	let result = false;
+
+	const state: WhenState = {
+		started: false,
+		timer: timer(
+			'repeat',
+			() => {
+				if (condition()) {
+					result = true;
+
+					state.timer.stop();
 				}
 			},
-			errorCallback() {
-				state.rejecter?.();
+			{
+				afterCallback() {
+					if (!state.timer.paused) {
+						if (result) {
+							state.resolver?.();
+						} else {
+							state.rejecter?.();
+						}
+
+						instance.destroy();
+					}
+				},
+				errorCallback() {
+					state.rejecter?.();
+
+					instance.destroy();
+				},
+				count: options?.count,
+				interval: options?.interval,
+				timeout: options?.timeout,
 			},
-			count: options?.count,
-			interval: options?.interval,
-			timeout: options?.timeout,
-		},
-		false,
-	);
+			false,
+		),
+	} as never;
 
-	const state: WhenState = {} as never;
-
-	state.promise = new Promise((resolve, reject) => {
+	const promise = new Promise<void>((resolve, reject) => {
 		state.resolver = resolve;
 		state.rejecter = reject;
 	});
 
-	state.timer = repeated;
+	state.promise = promise;
+
+	const instance = new When(state);
 
-	return new When(state);
+	return instance;
 }

package/types/constants.d.ts

@@ -1,8 +1,21 @@
+import type { WorkType } from './models';
 import type { Timer } from './timer';
 /**
  * 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<WorkType>;
+/**
+ * A set of types that allow work to end
+ */
+export declare const endTypes: Set<WorkType>;
+/**
+ * A set of types that allow work to end or restart
+ */
+export declare const endOrRestartTypes: Set<WorkType>;
 /**
  * A set of timers that were paused due to the document being hidden
  */

package/types/index.d.cts

@@ -43,6 +43,7 @@ export type TimerOptions = {} & RepeatOptions;
 export type TimerState = {
 	active: boolean;
 	callback: AnyCallback;
+	destroyed: boolean;
 	count?: number;
 	elapsed?: number;
 	frame?: number;
@@ -50,14 +51,18 @@ export type TimerState = {
 	isRepeated: boolean;
 	minimum: number;
 	paused: boolean;
-	trace: unknown;
+	trace: TimerTrace;
 };
+declare class TimerTrace extends Error {
+	constructor();
+}
 export type WaitOptions = {} & BaseOptions & OptionsWithError;
 export type WhenOptions = {} & OptionsWithCount;
 export type WhenState = {
 	promise: Promise<void>;
 	rejecter?: () => void;
 	resolver?: () => void;
+	started: boolean;
 	timer: Timer$1;
 };
 declare abstract class BasicTimer<State> {
@@ -68,10 +73,18 @@ declare abstract class BasicTimer<State> {
 	 * Is the timer running?
 	 */
 	abstract readonly active: boolean;
+	/**
+	 * Is the timer destroyed?
+	 */
+	abstract readonly destroyed: boolean;
 	/**
 	 * Is the timer paused?
 	 */
 	abstract readonly paused: boolean;
+	/**
+	 * Gets the traced location of the timer
+	 */
+	abstract readonly trace: TimerTrace | undefined;
 }
 /**
  * A timer that can be started, stopped, and restarted as neeeded
@@ -79,16 +92,18 @@ declare abstract class BasicTimer<State> {
 declare class Timer$1 extends BasicTimer<TimerState> {
 	private readonly options;
 	get active(): boolean;
+	get destroyed(): boolean;
 	get paused(): boolean;
-	/**
-	 * Gets the traced location of the timer
-	 */
-	get trace(): unknown;
+	get trace(): TimerTrace | undefined;
 	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
 	/**
 	 * Continues the timer _(if it was paused)_
 	 */
 	continue(): Timer$1;
+	/**
+	 * Destroys the timer _(after stopping it, if it was running)_
+	 */
+	destroy(): void;
 	/**
 	 * Pauses the timer _(if it was running)_
 	 */
@@ -132,12 +147,18 @@ export declare function wait(callback: () => void, time: number): Timer$1;
 export declare function wait(callback: () => void, options: Partial<WaitOptions>): Timer$1;
 export declare class When extends BasicTimer<WhenState> {
 	get active(): boolean;
+	get destroyed(): boolean;
 	get paused(): boolean;
+	get trace(): TimerTrace | undefined;
 	constructor(state: WhenState);
 	/**
 	 * 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)_
 	 */

package/types/models.d.ts

@@ -42,6 +42,7 @@ export type TimerOptions = {} & RepeatOptions;
 export type TimerState = {
     active: boolean;
     callback: AnyCallback;
+    destroyed: boolean;
     count?: number;
     elapsed?: number;
     frame?: number;
@@ -49,14 +50,18 @@ export type TimerState = {
     isRepeated: boolean;
     minimum: number;
     paused: boolean;
-    trace: unknown;
+    trace: TimerTrace;
 };
+export declare class TimerTrace extends Error {
+    constructor();
+}
 export type WaitOptions = {} & BaseOptions & OptionsWithError;
 export type WhenOptions = {} & OptionsWithCount;
 export type WhenState = {
     promise: Promise<void>;
     rejecter?: () => void;
     resolver?: () => void;
+    started: boolean;
     timer: Timer;
 };
 export type WorkType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';

package/types/timer.d.ts

@@ -1,4 +1,4 @@
-import type { AnyCallback, IndexedCallback, RepeatOptions, TimerOptions, TimerState, WaitOptions } from './models';
+import { TimerTrace, type AnyCallback, type IndexedCallback, type RepeatOptions, type TimerOptions, type TimerState, type WaitOptions } from './models';
 export declare abstract class BasicTimer<State> {
     protected readonly $timer: string;
     protected readonly state: State;
@@ -7,10 +7,18 @@ export declare abstract class BasicTimer<State> {
      * Is the timer running?
      */
     abstract readonly active: boolean;
+    /**
+     * Is the timer destroyed?
+     */
+    abstract readonly destroyed: boolean;
     /**
      * Is the timer paused?
      */
     abstract readonly paused: boolean;
+    /**
+     * Gets the traced location of the timer
+     */
+    abstract readonly trace: TimerTrace | undefined;
 }
 /**
  * A timer that can be started, stopped, and restarted as neeeded
@@ -18,16 +26,18 @@ export declare abstract class BasicTimer<State> {
 export declare class Timer extends BasicTimer<TimerState> {
     private readonly options;
     get active(): boolean;
+    get destroyed(): boolean;
     get paused(): boolean;
-    /**
-     * Gets the traced location of the timer
-     */
-    get trace(): unknown;
+    get trace(): TimerTrace | undefined;
     constructor(type: 'repeat' | 'wait', state: TimerState, options: TimerOptions);
     /**
      * Continues the timer _(if it was paused)_
      */
     continue(): Timer;
+    /**
+     * Destroys the timer _(after stopping it, if it was running)_
+     */
+    destroy(): void;
     /**
      * Pauses the timer _(if it was running)_
      */

package/types/when.d.ts

@@ -2,12 +2,18 @@ import type { WhenOptions, WhenState } from './models';
 import { BasicTimer } from './timer';
 export declare class When extends BasicTimer<WhenState> {
     get active(): boolean;
+    get destroyed(): boolean;
     get paused(): boolean;
+    get trace(): import("./models").TimerTrace | undefined;
     constructor(state: WhenState);
     /**
      * 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)_
      */