@oscarpalmer/timer 0.23.0 → 0.24.0

package/dist/functions.js

@@ -11,13 +11,6 @@ var hiddenTimers = new Set;
 var milliseconds = 1000 / 60;
 
 // src/functions.ts
-function destroyWhen(state) {
-  state.timer?.destroy();
-  state.promise = undefined;
-  state.rejecter = undefined;
-  state.resolver = undefined;
-  state.timer = undefined;
-}
 function getOptions(options, isRepeated) {
   return {
     afterCallback: options.afterCallback,
@@ -107,6 +100,5 @@ function work(type, timer, state, options) {
 export {
   work,
   getValueOrDefault,
-  getOptions,
-  destroyWhen
+  getOptions
 };

package/dist/functions.mjs

@@ -6,13 +6,6 @@ endOrRestartTypes,
 endTypes,
 milliseconds
 } from "./constants";
-function destroyWhen(state) {
-  state.timer?.destroy();
-  state.promise = undefined;
-  state.rejecter = undefined;
-  state.resolver = undefined;
-  state.timer = undefined;
-}
 function getOptions(options, isRepeated) {
   return {
     afterCallback: options.afterCallback,
@@ -102,6 +95,5 @@ function work(type, timer, state, options) {
 export {
   work,
   getValueOrDefault,
-  getOptions,
-  destroyWhen
+  getOptions
 };

package/dist/index.js

@@ -24,13 +24,6 @@ if (globalThis._oscarpalmer_timers == null) {
 }
 
 // src/functions.ts
-function destroyWhen(state) {
-  state.timer?.destroy();
-  state.promise = undefined;
-  state.rejecter = undefined;
-  state.resolver = undefined;
-  state.timer = undefined;
-}
 function getOptions(options, isRepeated) {
   return {
     afterCallback: options.afterCallback,
@@ -239,26 +232,28 @@ function isWhen(value) {
 }
 // src/when.ts
 function when(condition, options) {
+  let result = false;
   const state = {
     started: false,
     timer: timer("repeat", () => {
       if (condition()) {
+        result = true;
         state.timer.stop();
       }
     }, {
       afterCallback() {
         if (!state.timer.paused) {
-          if (condition()) {
+          if (result) {
             state.resolver?.();
           } else {
             state.rejecter?.();
           }
-          destroyWhen(state);
+          instance.destroy();
         }
       },
       errorCallback() {
         state.rejecter?.();
-        destroyWhen(state);
+        instance.destroy();
       },
       count: options?.count,
       interval: options?.interval,
@@ -270,8 +265,11 @@ function when(condition, options) {
     state.rejecter = reject;
   });
   state.promise = promise;
-  return new When(state);
+  const instance = new When(state);
+  return instance;
 }
+var destroyedMessage = "Timer has already been destroyed";
+var startedMessage = "Timer has already been started";
 
 class When extends BasicTimer {
   get active() {
@@ -294,9 +292,11 @@ class When extends BasicTimer {
     return this;
   }
   destroy() {
-    if (this.state.timer != null) {
-      this.state.timer.destroy();
-    }
+    this.state.timer?.destroy();
+    this.state.promise = undefined;
+    this.state.resolver = noop;
+    this.state.rejecter = noop;
+    this.state.timer = undefined;
   }
   pause() {
     this.state.timer?.pause();
@@ -307,10 +307,8 @@ class When extends BasicTimer {
     return this;
   }
   then(resolve, reject) {
-    if (this.state.timer == null || this.state.started) {
-      return new Promise(() => {
-        (reject ?? noop)();
-      });
+    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();

package/dist/when.js

@@ -15,13 +15,6 @@ var hiddenTimers = new Set;
 var milliseconds = 1000 / 60;
 
 // src/functions.ts
-function destroyWhen(state) {
-  state.timer?.destroy();
-  state.promise = undefined;
-  state.rejecter = undefined;
-  state.resolver = undefined;
-  state.timer = undefined;
-}
 function getOptions(options, isRepeated) {
   return {
     afterCallback: options.afterCallback,
@@ -188,26 +181,28 @@ class Timer extends BasicTimer {
 
 // src/when.ts
 function when(condition, options) {
+  let result = false;
   const state = {
     started: false,
     timer: timer("repeat", () => {
       if (condition()) {
+        result = true;
         state.timer.stop();
       }
     }, {
       afterCallback() {
         if (!state.timer.paused) {
-          if (condition()) {
+          if (result) {
             state.resolver?.();
           } else {
             state.rejecter?.();
           }
-          destroyWhen(state);
+          instance.destroy();
         }
       },
       errorCallback() {
         state.rejecter?.();
-        destroyWhen(state);
+        instance.destroy();
       },
       count: options?.count,
       interval: options?.interval,
@@ -219,8 +214,11 @@ function when(condition, options) {
     state.rejecter = reject;
   });
   state.promise = promise;
-  return new When(state);
+  const instance = new When(state);
+  return instance;
 }
+var destroyedMessage = "Timer has already been destroyed";
+var startedMessage = "Timer has already been started";
 
 class When extends BasicTimer {
   get active() {
@@ -243,9 +241,11 @@ class When extends BasicTimer {
     return this;
   }
   destroy() {
-    if (this.state.timer != null) {
-      this.state.timer.destroy();
-    }
+    this.state.timer?.destroy();
+    this.state.promise = undefined;
+    this.state.resolver = noop;
+    this.state.rejecter = noop;
+    this.state.timer = undefined;
   }
   pause() {
     this.state.timer?.pause();
@@ -256,10 +256,8 @@ class When extends BasicTimer {
     return this;
   }
   then(resolve, reject) {
-    if (this.state.timer == null || this.state.started) {
-      return new Promise(() => {
-        (reject ?? noop)();
-      });
+    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();

package/dist/when.mjs

@@ -1,28 +1,29 @@
 // src/when.ts
 import {noop} from "@oscarpalmer/atoms/function";
-import {destroyWhen} from "./functions";
 import {BasicTimer, timer as timer2} from "./timer";
 function when(condition, options) {
+  let result = false;
   const state = {
     started: false,
     timer: timer2("repeat", () => {
       if (condition()) {
+        result = true;
         state.timer.stop();
       }
     }, {
       afterCallback() {
         if (!state.timer.paused) {
-          if (condition()) {
+          if (result) {
             state.resolver?.();
           } else {
             state.rejecter?.();
           }
-          destroyWhen(state);
+          instance.destroy();
         }
       },
       errorCallback() {
         state.rejecter?.();
-        destroyWhen(state);
+        instance.destroy();
       },
       count: options?.count,
       interval: options?.interval,
@@ -34,8 +35,11 @@ function when(condition, options) {
     state.rejecter = reject;
   });
   state.promise = promise;
-  return new When(state);
+  const instance = new When(state);
+  return instance;
 }
+var destroyedMessage = "Timer has already been destroyed";
+var startedMessage = "Timer has already been started";
 
 class When extends BasicTimer {
   get active() {
@@ -58,9 +62,11 @@ class When extends BasicTimer {
     return this;
   }
   destroy() {
-    if (this.state.timer != null) {
-      this.state.timer.destroy();
-    }
+    this.state.timer?.destroy();
+    this.state.promise = undefined;
+    this.state.resolver = noop;
+    this.state.rejecter = noop;
+    this.state.timer = undefined;
   }
   pause() {
     this.state.timer?.pause();
@@ -71,10 +77,8 @@ class When extends BasicTimer {
     return this;
   }
   then(resolve, reject) {
-    if (this.state.timer == null || this.state.started) {
-      return new Promise(() => {
-        (reject ?? noop)();
-      });
+    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();

package/package.json

@@ -50,5 +50,5 @@
 	},
 	"type": "module",
 	"types": "types/index.d.cts",
-	"version": "0.23.0"
+	"version": "0.24.0"
 }

package/src/functions.ts

@@ -8,15 +8,6 @@ import {
 import type {TimerOptions, TimerState, WhenState, WorkType} from './models';
 import type {Timer} from './timer';
 
-export function destroyWhen(state: WhenState): void {
-	state.timer?.destroy();
-
-	state.promise = undefined as never;
-	state.rejecter = undefined;
-	state.resolver = undefined;
-	state.timer = undefined as never;
-}
-
 export function getOptions(
 	options: Partial<TimerOptions>,
 	isRepeated: boolean,

package/src/when.ts

@@ -1,8 +1,10 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import {destroyWhen} from './functions';
 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 ?? false;
@@ -34,12 +36,15 @@ export class When extends BasicTimer<WhenState> {
 	}
 
 	/**
-	 * Destroys the timer _
+	 * Destroys the timer _(and stops it,if it was running)_
 	 */
 	destroy(): void {
-		if (this.state.timer != null) {
-			this.state.timer.destroy();
-		}
+		this.state.timer?.destroy();
+
+		this.state.promise = undefined as never;
+		this.state.resolver = noop;
+		this.state.rejecter = noop;
+		this.state.timer = undefined as never;
 	}
 
 	/**
@@ -68,10 +73,10 @@ export class When extends BasicTimer<WhenState> {
 		resolve?: (() => void) | null,
 		reject?: (() => void) | null,
 	): Promise<void> {
-		if (this.state.timer == null || this.state.started) {
-			return new Promise(() => {
-				(reject ?? noop)();
-			});
+		if (this.state.timer == null || this.state?.started) {
+			throw new Error(
+				this.state.timer == null ? destroyedMessage : startedMessage,
+			);
 		}
 
 		this.state.started = true;
@@ -90,31 +95,35 @@ export function when(
 	condition: () => boolean,
 	options?: Partial<WhenOptions>,
 ): When {
+	let result = false;
+
 	const state: WhenState = {
 		started: false,
 		timer: timer(
 			'repeat',
 			() => {
 				if (condition()) {
+					result = true;
+
 					state.timer.stop();
 				}
 			},
 			{
 				afterCallback() {
 					if (!state.timer.paused) {
-						if (condition()) {
+						if (result) {
 							state.resolver?.();
 						} else {
 							state.rejecter?.();
 						}
 
-						destroyWhen(state);
+						instance.destroy();
 					}
 				},
 				errorCallback() {
 					state.rejecter?.();
 
-					destroyWhen(state);
+					instance.destroy();
 				},
 				count: options?.count,
 				interval: options?.interval,
@@ -131,5 +140,7 @@ export function when(
 
 	state.promise = promise;
 
-	return new When(state);
+	const instance = new When(state);
+
+	return instance;
 }

package/types/functions.d.ts

@@ -1,6 +1,5 @@
-import type { TimerOptions, TimerState, WhenState, WorkType } from './models';
+import type { TimerOptions, TimerState, WorkType } from './models';
 import type { Timer } from './timer';
-export declare function destroyWhen(state: WhenState): void;
 export declare function getOptions(options: Partial<TimerOptions>, isRepeated: boolean): TimerOptions;
 export declare function getValueOrDefault(value: unknown, defaultValue: number, minimum?: number): number;
 export declare function work(type: WorkType, timer: Timer, state: TimerState, options: TimerOptions): Timer;

package/types/index.d.cts

@@ -156,7 +156,7 @@ export declare class When extends BasicTimer<WhenState> {
 	 */
 	continue(): When;
 	/**
-	 * Destroys the timer _
+	 * Destroys the timer _(and stops it,if it was running)_
 	 */
 	destroy(): void;
 	/**

package/types/when.d.ts

@@ -11,7 +11,7 @@ export declare class When extends BasicTimer<WhenState> {
      */
     continue(): When;
     /**
-     * Destroys the timer _
+     * Destroys the timer _(and stops it,if it was running)_
      */
     destroy(): void;
     /**