@oscarpalmer/timer 0.22.0 → 0.23.0

package/dist/when.js

@@ -4,10 +4,24 @@ function noop() {
 
 // src/constants.ts
 var activeTimers = new Set;
+var beginTypes = new Set(["continue", "start"]);
+var endTypes = new Set(["pause", "stop"]);
+var endOrRestartTypes = new Set([
+  "pause",
+  "restart",
+  "stop"
+]);
 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,
@@ -21,12 +35,12 @@ function getValueOrDefault(value, defaultValue, minimum) {
   return typeof value === "number" && value > (minimum ?? 0) ? value : defaultValue;
 }
 function work(type, timer, state, options) {
-  if (["continue", "start"].includes(type) && state.active || ["pause", "stop"].includes(type) && !state.active) {
+  if (state.destroyed && type !== "stop" || beginTypes.has(type) && state.active || endTypes.has(type) && !state.active) {
     return timer;
   }
   const { count, interval, timeout } = options;
   const { isRepeated, minimum } = state;
-  if (["pause", "restart", "stop"].includes(type)) {
+  if (endOrRestartTypes.has(type)) {
     const isStop = type === "stop";
     activeTimers.delete(timer);
     cancelAnimationFrame(state.frame);
@@ -95,6 +109,14 @@ function work(type, timer, state, options) {
   return timer;
 }
 
+// src/models.ts
+class TimerTrace extends Error {
+  constructor() {
+    super();
+    this.name = "TimerTrace";
+  }
+}
+
 // src/timer.ts
 function timer(type, callback, partial, start) {
   const isRepeated = type === "repeat";
@@ -103,6 +125,7 @@ function timer(type, callback, partial, start) {
     callback,
     isRepeated,
     active: false,
+    destroyed: false,
     minimum: options.interval - options.interval % milliseconds / 2,
     paused: false,
     trace: new TimerTrace
@@ -123,6 +146,9 @@ class Timer extends BasicTimer {
   get active() {
     return this.state.active;
   }
+  get destroyed() {
+    return this.state.destroyed;
+  }
   get paused() {
     return this.state.paused;
   }
@@ -136,6 +162,16 @@ class Timer extends BasicTimer {
   continue() {
     return work("continue", this, this.state, this.options);
   }
+  destroy() {
+    if (!this.state.destroyed) {
+      this.state.destroyed = true;
+      this.stop();
+      this.options.afterCallback = undefined;
+      this.options.errorCallback = undefined;
+      this.state.callback = undefined;
+      this.state.trace = undefined;
+    }
+  }
   pause() {
     return work("pause", this, this.state, this.options);
   }
@@ -150,72 +186,82 @@ class Timer extends BasicTimer {
   }
 }
 
-class TimerTrace extends Error {
-  constructor() {
-    super();
-    this.name = "TimerTrace";
-  }
-}
-
 // src/when.ts
 function when(condition, options) {
-  const repeated = timer("repeat", () => {
-    if (condition()) {
-      repeated.stop();
-      state.resolver?.();
-    }
-  }, {
-    afterCallback() {
-      if (!repeated.paused) {
-        if (condition()) {
-          state.resolver?.();
-        } else {
-          state.rejecter?.();
-        }
+  const state = {
+    started: false,
+    timer: timer("repeat", () => {
+      if (condition()) {
+        state.timer.stop();
       }
-    },
-    errorCallback() {
-      state.rejecter?.();
-    },
-    count: options?.count,
-    interval: options?.interval,
-    timeout: options?.timeout
-  }, false);
-  const state = {};
-  state.promise = new Promise((resolve, reject) => {
+    }, {
+      afterCallback() {
+        if (!state.timer.paused) {
+          if (condition()) {
+            state.resolver?.();
+          } else {
+            state.rejecter?.();
+          }
+          destroyWhen(state);
+        }
+      },
+      errorCallback() {
+        state.rejecter?.();
+        destroyWhen(state);
+      },
+      count: options?.count,
+      interval: options?.interval,
+      timeout: options?.timeout
+    }, false)
+  };
+  const promise = new Promise((resolve, reject) => {
     state.resolver = resolve;
     state.rejecter = reject;
   });
-  state.timer = repeated;
+  state.promise = promise;
   return new When(state);
 }
 
 class When extends BasicTimer {
   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) {
     super("when", state);
   }
   continue() {
-    this.state.timer.continue();
+    this.state.timer?.continue();
     return this;
   }
+  destroy() {
+    if (this.state.timer != null) {
+      this.state.timer.destroy();
+    }
+  }
   pause() {
-    this.state.timer.pause();
+    this.state.timer?.pause();
     return this;
   }
   stop() {
-    if (this.state.timer.active) {
-      this.state.timer.stop();
-      this.state.rejecter?.();
-    }
+    this.state.timer?.stop();
     return this;
   }
   then(resolve, reject) {
+    if (this.state.timer == null || this.state.started) {
+      return new Promise(() => {
+        (reject ?? noop)();
+      });
+    }
+    this.state.started = true;
     this.state.timer.start();
     return this.state.promise.then(resolve ?? noop, reject ?? noop);
   }

package/dist/when.mjs

@@ -1,64 +1,82 @@
 // src/when.ts
 import {noop} from "@oscarpalmer/atoms/function";
+import {destroyWhen} from "./functions";
 import {BasicTimer, timer as timer2} from "./timer";
 function when(condition, options) {
-  const repeated = timer2("repeat", () => {
-    if (condition()) {
-      repeated.stop();
-      state.resolver?.();
-    }
-  }, {
-    afterCallback() {
-      if (!repeated.paused) {
-        if (condition()) {
-          state.resolver?.();
-        } else {
-          state.rejecter?.();
-        }
+  const state = {
+    started: false,
+    timer: timer2("repeat", () => {
+      if (condition()) {
+        state.timer.stop();
       }
-    },
-    errorCallback() {
-      state.rejecter?.();
-    },
-    count: options?.count,
-    interval: options?.interval,
-    timeout: options?.timeout
-  }, false);
-  const state = {};
-  state.promise = new Promise((resolve, reject) => {
+    }, {
+      afterCallback() {
+        if (!state.timer.paused) {
+          if (condition()) {
+            state.resolver?.();
+          } else {
+            state.rejecter?.();
+          }
+          destroyWhen(state);
+        }
+      },
+      errorCallback() {
+        state.rejecter?.();
+        destroyWhen(state);
+      },
+      count: options?.count,
+      interval: options?.interval,
+      timeout: options?.timeout
+    }, false)
+  };
+  const promise = new Promise((resolve, reject) => {
     state.resolver = resolve;
     state.rejecter = reject;
   });
-  state.timer = repeated;
+  state.promise = promise;
   return new When(state);
 }
 
 class When extends BasicTimer {
   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) {
     super("when", state);
   }
   continue() {
-    this.state.timer.continue();
+    this.state.timer?.continue();
     return this;
   }
+  destroy() {
+    if (this.state.timer != null) {
+      this.state.timer.destroy();
+    }
+  }
   pause() {
-    this.state.timer.pause();
+    this.state.timer?.pause();
     return this;
   }
   stop() {
-    if (this.state.timer.active) {
-      this.state.timer.stop();
-      this.state.rejecter?.();
-    }
+    this.state.timer?.stop();
     return this;
   }
   then(resolve, reject) {
+    if (this.state.timer == null || this.state.started) {
+      return new Promise(() => {
+        (reject ?? noop)();
+      });
+    }
+    this.state.started = true;
     this.state.timer.start();
     return this.state.promise.then(resolve ?? noop, reject ?? noop);
   }

package/package.json

@@ -8,19 +8,19 @@
 	},
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"@biomejs/biome": "^1.8.3",
-		"@happy-dom/global-registrator": "^14.12.3",
-		"@types/bun": "^1.1.6",
-		"bun": "^1.1.21",
+		"@biomejs/biome": "^1.9.0",
+		"@happy-dom/global-registrator": "^15.7.4",
+		"@types/bun": "^1.1.9",
+		"bun": "^1.1.27",
 		"dts-bundle-generator": "9.5.1",
-		"typescript": "^5.5.4"
+		"typescript": "^5.6.2"
 	},
 	"exports": {
 		".": {
 			"bun": "./src/index.ts",
 			"import": {
 				"types": "./types/index.d.ts",
-				"default": "./dist/timer.mjs"
+				"default": "./dist/index.mjs"
 			},
 			"require": {
 				"types": "./types/index.d.cts",
@@ -46,9 +46,9 @@
 		"types": "bun run types:cjs && bun run types:esm",
 		"types:cjs": "bunx dts-bundle-generator --out-file ./types/index.d.cts --external-inlines '@oscarpalmer/atoms' --no-check --silent ./src/index.ts",
 		"types:esm": "bunx tsc -p ./tsconfig.json",
-		"watch": "bun build ./src/index.ts --outfile ./dist/timer.js --watch"
+		"watch": "bun build ./src/index.ts --outfile ./dist/index.js --watch"
 	},
 	"type": "module",
 	"types": "types/index.d.cts",
-	"version": "0.22.0"
+	"version": "0.23.0"
 }

package/src/constants.ts

@@ -1,3 +1,4 @@
+import type {WorkType} from './models';
 import type {Timer} from './timer';
 
 /**
@@ -5,6 +6,25 @@ import type {Timer} from './timer';
  */
 export const activeTimers = new Set<Timer>();
 
+/**
+ * A set of types that allow work to begin
+ */
+export const beginTypes = new Set<WorkType>(['continue', 'start']);
+
+/**
+ * A set of types that allow work to end
+ */
+export const endTypes = new Set<WorkType>(['pause', 'stop']);
+
+/**
+ * A set of types that allow work to end or restart
+ */
+export const endOrRestartTypes = new Set<WorkType>([
+	'pause',
+	'restart',
+	'stop',
+]);
+
 /**
  * A set of timers that were paused due to the document being hidden
  */

package/src/functions.ts

@@ -1,7 +1,22 @@
-import {activeTimers, milliseconds} from './constants';
-import type {TimerOptions, TimerState, WorkType} from './models';
+import {
+	activeTimers,
+	beginTypes,
+	endOrRestartTypes,
+	endTypes,
+	milliseconds,
+} from './constants';
+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,
@@ -38,8 +53,9 @@ export function work(
 	options: TimerOptions,
 ): Timer {
 	if (
-		(['continue', 'start'].includes(type) && state.active) ||
-		(['pause', 'stop'].includes(type) && !state.active)
+		(state.destroyed && type !== 'stop') ||
+		(beginTypes.has(type) && state.active) ||
+		(endTypes.has(type) && !state.active)
 	) {
 		return timer;
 	}
@@ -47,7 +63,7 @@ export function work(
 	const {count, interval, timeout} = options;
 	const {isRepeated, minimum} = state;
 
-	if (['pause', 'restart', 'stop'].includes(type)) {
+	if (endOrRestartTypes.has(type)) {
 		const isStop = type === 'stop';
 
 		activeTimers.delete(timer);

package/src/index.ts

@@ -8,11 +8,22 @@ import {wait} from './timer';
  */
 export function delay(time: number, timeout?: number): Promise<void> {
 	return new Promise((resolve, reject) => {
-		wait(resolve ?? noop, {
-			timeout,
-			errorCallback: reject ?? noop,
-			interval: time,
-		});
+		const delayed = wait(
+			() => {
+				delayed.destroy();
+
+				(resolve ?? noop)();
+			},
+			{
+				timeout,
+				errorCallback: () => {
+					delayed.destroy();
+
+					(reject ?? noop)();
+				},
+				interval: time,
+			},
+		);
 	});
 }
 
@@ -34,4 +45,3 @@ document.addEventListener('visibilitychange', () => {
 export {isRepeated, isTimer, isWaited, isWhen} from './is';
 export {repeat, wait, type Timer} from './timer';
 export {when, type When} from './when';
-

package/src/models.ts

@@ -52,6 +52,7 @@ export type TimerOptions = {} & RepeatOptions;
 export type TimerState = {
 	active: boolean;
 	callback: AnyCallback;
+	destroyed: boolean;
 	count?: number;
 	elapsed?: number;
 	frame?: number;
@@ -59,9 +60,17 @@ export type TimerState = {
 	isRepeated: boolean;
 	minimum: number;
 	paused: boolean;
-	trace: unknown;
+	trace: TimerTrace;
 };
 
+export class TimerTrace extends Error {
+	constructor() {
+		super();
+
+		this.name = 'TimerTrace';
+	}
+}
+
 export type WaitOptions = {} & BaseOptions & OptionsWithError;
 
 export type WhenOptions = {} & OptionsWithCount;
@@ -70,6 +79,7 @@ export type WhenState = {
 	promise: Promise<void>;
 	rejecter?: () => void;
 	resolver?: () => void;
+	started: boolean;
 	timer: Timer;
 };
 

package/src/timer.ts

@@ -1,12 +1,13 @@
 import {milliseconds} from './constants';
 import {getOptions, work} from './functions';
-import type {
-	AnyCallback,
-	IndexedCallback,
-	RepeatOptions,
-	TimerOptions,
-	TimerState,
-	WaitOptions,
+import {
+	TimerTrace,
+	type AnyCallback,
+	type IndexedCallback,
+	type RepeatOptions,
+	type TimerOptions,
+	type TimerState,
+	type WaitOptions,
 } from './models';
 
 export abstract class BasicTimer<State> {
@@ -23,10 +24,20 @@ export abstract class BasicTimer<State> {
 	 */
 	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;
 }
 
 /**
@@ -39,13 +50,14 @@ export class Timer extends BasicTimer<TimerState> {
 		return this.state.active;
 	}
 
+	get destroyed() {
+		return this.state.destroyed;
+	}
+
 	get paused() {
 		return this.state.paused;
 	}
 
-	/**
-	 * Gets the traced location of the timer
-	 */
 	get trace() {
 		return globalThis._oscarpalmer_timer_debug ? this.state.trace : undefined;
 	}
@@ -67,6 +79,23 @@ export class Timer extends BasicTimer<TimerState> {
 		return work('continue', this, this.state, this.options);
 	}
 
+	/**
+	 * Destroys the timer _(after stopping it, if it was running)_
+	 */
+	destroy(): void {
+		if (!this.state.destroyed) {
+			this.state.destroyed = true;
+
+			this.stop();
+
+			this.options.afterCallback = undefined;
+			this.options.errorCallback = undefined;
+
+			this.state.callback = undefined as never;
+			this.state.trace = undefined as never;
+		}
+	}
+
 	/**
 	 * Pauses the timer _(if it was running)_
 	 */
@@ -96,14 +125,6 @@ export class Timer extends BasicTimer<TimerState> {
 	}
 }
 
-class TimerTrace extends Error {
-	constructor() {
-		super();
-
-		this.name = 'TimerTrace';
-	}
-}
-
 /**
  * Creates a timer which:
  * - calls a callback after a certain amount of time...
@@ -135,6 +156,7 @@ export function timer(
 			callback,
 			isRepeated,
 			active: false,
+			destroyed: false,
 			minimum: options.interval - (options.interval % milliseconds) / 2,
 			paused: false,
 			trace: new TimerTrace(),