@oscarpalmer/timer 0.23.0 → 0.25.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

@@ -1,18 +1,11 @@
 // src/functions.ts
 import {
-activeTimers,
-beginTypes,
-endOrRestartTypes,
-endTypes,
-milliseconds
+  activeTimers,
+  beginTypes,
+  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/global.mjs

@@ -1,5 +1,5 @@
 // src/global.ts
-import {activeTimers} from "./constants";
+import { activeTimers } from "./constants";
 if (globalThis._oscarpalmer_timers == null) {
   Object.defineProperty(globalThis, "_oscarpalmer_timers", {
     get() {

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();
@@ -321,13 +319,13 @@ class When extends BasicTimer {
 // src/index.ts
 document.addEventListener("visibilitychange", () => {
   if (document.hidden) {
-    for (const timer4 of activeTimers) {
-      hiddenTimers.add(timer4);
-      timer4.pause();
+    for (const timer2 of activeTimers) {
+      hiddenTimers.add(timer2);
+      timer2.pause();
     }
   } else {
-    for (const timer4 of hiddenTimers) {
-      timer4.continue();
+    for (const timer2 of hiddenTimers) {
+      timer2.continue();
     }
     hiddenTimers.clear();
   }

package/dist/index.mjs

@@ -1,8 +1,8 @@
 // src/index.ts
-import {noop} from "@oscarpalmer/atoms/function";
-import {activeTimers, hiddenTimers} from "./constants";
+import { noop } from "@oscarpalmer/atoms/function";
+import { activeTimers, hiddenTimers } from "./constants";
 import"./global";
-import {wait} from "./timer";
+import { wait } from "./timer";
 function delay(time, timeout) {
   return new Promise((resolve, reject) => {
     const delayed = wait(() => {
@@ -18,18 +18,18 @@ function delay(time, timeout) {
     });
   });
 }
-import {isRepeated, isTimer, isWaited, isWhen} from "./is";
-import {repeat, wait as wait2} from "./timer";
-import {when} from "./when";
+import { isRepeated, isTimer, isWaited, isWhen } from "./is";
+import { repeat, wait as wait2 } from "./timer";
+import { when } from "./when";
 document.addEventListener("visibilitychange", () => {
   if (document.hidden) {
-    for (const timer2 of activeTimers) {
-      hiddenTimers.add(timer2);
-      timer2.pause();
+    for (const timer of activeTimers) {
+      hiddenTimers.add(timer);
+      timer.pause();
     }
   } else {
-    for (const timer2 of hiddenTimers) {
-      timer2.continue();
+    for (const timer of hiddenTimers) {
+      timer.continue();
     }
     hiddenTimers.clear();
   }

package/dist/timer.mjs

@@ -1,8 +1,8 @@
 // src/timer.ts
-import {milliseconds} from "./constants";
-import {getOptions, work} from "./functions";
+import { milliseconds } from "./constants";
+import { getOptions, work } from "./functions";
 import {
-TimerTrace
+  TimerTrace
 } from "./models";
 function repeat(callback, options) {
   return timer("repeat", callback, options ?? {}, true);

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";
+import { noop } from "@oscarpalmer/atoms/function";
+import { BasicTimer, timer } from "./timer";
 function when(condition, options) {
+  let result = false;
   const state = {
     started: false,
-    timer: timer2("repeat", () => {
+    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,
@@ -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

@@ -4,14 +4,14 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "0.69.0"
+		"@oscarpalmer/atoms": "0.74.1"
 	},
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"@biomejs/biome": "^1.9.0",
+		"@biomejs/biome": "^1.9.2",
 		"@happy-dom/global-registrator": "^15.7.4",
-		"@types/bun": "^1.1.9",
-		"bun": "^1.1.27",
+		"@types/bun": "^1.1.10",
+		"bun": "^1.1.29",
 		"dts-bundle-generator": "9.5.1",
 		"typescript": "^5.6.2"
 	},
@@ -50,5 +50,5 @@
 	},
 	"type": "module",
 	"types": "types/index.d.cts",
-	"version": "0.23.0"
+	"version": "0.25.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/global.ts

@@ -1,3 +1,4 @@
+import type {Timer} from './timer';
 import {activeTimers} from './constants';
 
 declare global {

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/global.d.ts

@@ -1,5 +1,5 @@
+import type { Timer } from './timer';
 declare global {
     var _oscarpalmer_timer_debug: boolean | undefined;
     var _oscarpalmer_timers: Timer[] | undefined;
 }
-export {};

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;
     /**