@oscarpalmer/atoms 0.46.0 → 0.47.1

package/dist/js/index.js

@@ -875,6 +875,12 @@ var timer = function(type, callback, partial) {
     active: false
   };
   const instance = Object.create({
+    continue() {
+      return work2("continue", this, state, options, isRepeated2);
+    },
+    pause() {
+      return work2("pause", this, state, options, isRepeated2);
+    },
     restart() {
       return work2("restart", this, state, options, isRepeated2);
     },
@@ -925,6 +931,12 @@ function when(condition, options) {
     rejecter = reject;
   });
   const instance = Object.create({
+    continue() {
+      repeated.continue();
+    },
+    pause() {
+      repeated.pause();
+    },
     stop() {
       if (repeated.active) {
         repeated.stop();
@@ -951,29 +963,37 @@ function when(condition, options) {
   return instance;
 }
 var work2 = function(type, timer2, state, options, isRepeated2) {
-  if (type === "start" && state.active || type === "stop" && !state.active) {
+  if (["continue", "start"].includes(type) && state.active || ["pause", "stop"].includes(type) && !state.active) {
     return timer2;
   }
   const { count, interval, timeout } = options;
-  if (typeof state.frame === "number") {
+  if (["pause", "stop"].includes(type)) {
+    activeTimers.delete(timer2);
     cancelAnimationFrame(state.frame);
     options.afterCallback?.(false);
-  }
-  if (type === "stop") {
-    activeTimers.delete(timer2);
     state.active = false;
     state.frame = undefined;
+    if (type === "stop") {
+      state.elapsed = undefined;
+      state.index = undefined;
+    }
     return timer2;
   }
   state.active = true;
   const canTimeout = timeout > 0 && timeout < Number.POSITIVE_INFINITY;
-  const total = count === Number.POSITIVE_INFINITY ? timeout : count * (interval > 0 ? interval : 17);
+  const elapsed = type === "continue" ? +(state.elapsed ?? 0) : 0;
+  let index = type === "continue" ? +(state.index ?? 0) : 0;
+  state.elapsed = elapsed;
+  state.index = index;
+  const total = (count === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : (count - index) * (interval > 0 ? interval : 62.5)) - elapsed;
   let current;
   let start;
-  let index = 0;
   function finish(finished, error) {
+    activeTimers.delete(timer2);
     state.active = false;
+    state.elapsed = undefined;
     state.frame = undefined;
+    state.index = undefined;
     if (error) {
       options.errorCallback?.();
     }
@@ -985,15 +1005,17 @@ var work2 = function(type, timer2, state, options, isRepeated2) {
     }
     current ??= timestamp;
     start ??= timestamp;
-    const elapsed = timestamp - current;
-    const finished = elapsed >= total;
-    if (finished || elapsed - 2 < interval && interval < elapsed + 2) {
+    const time2 = timestamp - current;
+    state.elapsed = elapsed + (current - start);
+    const finished = time2 - elapsed >= total;
+    if (finished || time2 - 2 < interval && interval < time2 + 2) {
       if (state.active) {
         state.callback(isRepeated2 ? index : undefined);
       }
       index += 1;
+      state.index = index;
       switch (true) {
-        case (canTimeout && !finished && timestamp - start >= timeout):
+        case (canTimeout && !finished && timestamp - start >= timeout - elapsed):
           finish(false, true);
           return;
         case (!finished && index < count):
@@ -1016,11 +1038,11 @@ document.addEventListener("visibilitychange", () => {
   if (document.hidden) {
     for (const timer2 of activeTimers) {
       hiddenTimers.add(timer2);
-      timer2.stop();
+      timer2.pause();
     }
   } else {
     for (const timer2 of hiddenTimers) {
-      timer2.start();
+      timer2.continue();
     }
     hiddenTimers.clear();
   }

package/dist/js/timer.js

@@ -34,6 +34,12 @@ var timer = function(type, callback, partial) {
     active: false
   };
   const instance = Object.create({
+    continue() {
+      return work("continue", this, state, options, isRepeated2);
+    },
+    pause() {
+      return work("pause", this, state, options, isRepeated2);
+    },
     restart() {
       return work("restart", this, state, options, isRepeated2);
     },
@@ -84,6 +90,12 @@ function when(condition, options) {
     rejecter = reject;
   });
   const instance = Object.create({
+    continue() {
+      repeated.continue();
+    },
+    pause() {
+      repeated.pause();
+    },
     stop() {
       if (repeated.active) {
         repeated.stop();
@@ -110,29 +122,37 @@ function when(condition, options) {
   return instance;
 }
 var work = function(type, timer2, state, options, isRepeated2) {
-  if (type === "start" && state.active || type === "stop" && !state.active) {
+  if (["continue", "start"].includes(type) && state.active || ["pause", "stop"].includes(type) && !state.active) {
     return timer2;
   }
   const { count, interval, timeout } = options;
-  if (typeof state.frame === "number") {
+  if (["pause", "stop"].includes(type)) {
+    activeTimers.delete(timer2);
     cancelAnimationFrame(state.frame);
     options.afterCallback?.(false);
-  }
-  if (type === "stop") {
-    activeTimers.delete(timer2);
     state.active = false;
     state.frame = undefined;
+    if (type === "stop") {
+      state.elapsed = undefined;
+      state.index = undefined;
+    }
     return timer2;
   }
   state.active = true;
   const canTimeout = timeout > 0 && timeout < Number.POSITIVE_INFINITY;
-  const total = count === Number.POSITIVE_INFINITY ? timeout : count * (interval > 0 ? interval : 17);
+  const elapsed = type === "continue" ? +(state.elapsed ?? 0) : 0;
+  let index = type === "continue" ? +(state.index ?? 0) : 0;
+  state.elapsed = elapsed;
+  state.index = index;
+  const total = (count === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : (count - index) * (interval > 0 ? interval : 62.5)) - elapsed;
   let current;
   let start;
-  let index = 0;
   function finish(finished, error) {
+    activeTimers.delete(timer2);
     state.active = false;
+    state.elapsed = undefined;
     state.frame = undefined;
+    state.index = undefined;
     if (error) {
       options.errorCallback?.();
     }
@@ -144,15 +164,17 @@ var work = function(type, timer2, state, options, isRepeated2) {
     }
     current ??= timestamp;
     start ??= timestamp;
-    const elapsed = timestamp - current;
-    const finished = elapsed >= total;
-    if (finished || elapsed - 2 < interval && interval < elapsed + 2) {
+    const time = timestamp - current;
+    state.elapsed = elapsed + (current - start);
+    const finished = time - elapsed >= total;
+    if (finished || time - 2 < interval && interval < time + 2) {
       if (state.active) {
         state.callback(isRepeated2 ? index : undefined);
       }
       index += 1;
+      state.index = index;
       switch (true) {
-        case (canTimeout && !finished && timestamp - start >= timeout):
+        case (canTimeout && !finished && timestamp - start >= timeout - elapsed):
           finish(false, true);
           return;
         case (!finished && index < count):
@@ -175,11 +197,11 @@ document.addEventListener("visibilitychange", () => {
   if (document.hidden) {
     for (const timer2 of activeTimers) {
       hiddenTimers.add(timer2);
-      timer2.stop();
+      timer2.pause();
     }
   } else {
     for (const timer2 of hiddenTimers) {
-      timer2.start();
+      timer2.continue();
     }
     hiddenTimers.clear();
   }

package/dist/js/timer.mjs

@@ -34,6 +34,12 @@ var timer = function(type, callback, partial) {
     active: false
   };
   const instance = Object.create({
+    continue() {
+      return work("continue", this, state, options, isRepeated2);
+    },
+    pause() {
+      return work("pause", this, state, options, isRepeated2);
+    },
     restart() {
       return work("restart", this, state, options, isRepeated2);
     },
@@ -84,6 +90,12 @@ function when(condition, options) {
     rejecter = reject;
   });
   const instance = Object.create({
+    continue() {
+      repeated.continue();
+    },
+    pause() {
+      repeated.pause();
+    },
     stop() {
       if (repeated.active) {
         repeated.stop();
@@ -110,29 +122,37 @@ function when(condition, options) {
   return instance;
 }
 var work = function(type, timer2, state, options, isRepeated2) {
-  if (type === "start" && state.active || type === "stop" && !state.active) {
+  if (["continue", "start"].includes(type) && state.active || ["pause", "stop"].includes(type) && !state.active) {
     return timer2;
   }
   const { count, interval, timeout } = options;
-  if (typeof state.frame === "number") {
+  if (["pause", "stop"].includes(type)) {
+    activeTimers.delete(timer2);
     cancelAnimationFrame(state.frame);
     options.afterCallback?.(false);
-  }
-  if (type === "stop") {
-    activeTimers.delete(timer2);
     state.active = false;
     state.frame = undefined;
+    if (type === "stop") {
+      state.elapsed = undefined;
+      state.index = undefined;
+    }
     return timer2;
   }
   state.active = true;
   const canTimeout = timeout > 0 && timeout < Number.POSITIVE_INFINITY;
-  const total = count === Number.POSITIVE_INFINITY ? timeout : count * (interval > 0 ? interval : 17);
+  const elapsed = type === "continue" ? +(state.elapsed ?? 0) : 0;
+  let index = type === "continue" ? +(state.index ?? 0) : 0;
+  state.elapsed = elapsed;
+  state.index = index;
+  const total = (count === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : (count - index) * (interval > 0 ? interval : 62.5)) - elapsed;
   let current;
   let start;
-  let index = 0;
   function finish(finished, error) {
+    activeTimers.delete(timer2);
     state.active = false;
+    state.elapsed = undefined;
     state.frame = undefined;
+    state.index = undefined;
     if (error) {
       options.errorCallback?.();
     }
@@ -144,15 +164,17 @@ var work = function(type, timer2, state, options, isRepeated2) {
     }
     current ??= timestamp;
     start ??= timestamp;
-    const elapsed = timestamp - current;
-    const finished = elapsed >= total;
-    if (finished || elapsed - 2 < interval && interval < elapsed + 2) {
+    const time = timestamp - current;
+    state.elapsed = elapsed + (current - start);
+    const finished = time - elapsed >= total;
+    if (finished || time - 2 < interval && interval < time + 2) {
       if (state.active) {
         state.callback(isRepeated2 ? index : undefined);
       }
       index += 1;
+      state.index = index;
       switch (true) {
-        case (canTimeout && !finished && timestamp - start >= timeout):
+        case (canTimeout && !finished && timestamp - start >= timeout - elapsed):
           finish(false, true);
           return;
         case (!finished && index < count):
@@ -175,11 +197,11 @@ document.addEventListener("visibilitychange", () => {
   if (document.hidden) {
     for (const timer2 of activeTimers) {
       hiddenTimers.add(timer2);
-      timer2.stop();
+      timer2.pause();
     }
   } else {
     for (const timer2 of hiddenTimers) {
-      timer2.start();
+      timer2.continue();
     }
     hiddenTimers.clear();
   }

package/package.json

@@ -9,7 +9,7 @@
 	"description": "Sweet little atomic goodies…",
 	"devDependencies": {
 		"@biomejs/biome": "^1.7",
-		"@happy-dom/global-registrator": "^14.11",
+		"@happy-dom/global-registrator": "^14.12",
 		"bun": "^1.1",
 		"sass": "^1.77",
 		"typescript": "^5.4"
@@ -105,11 +105,7 @@
 		},
 		"./package.json": "./package.json"
 	},
-	"files": [
-		"dist",
-		"src",
-		"types"
-	],
+	"files": ["dist", "src", "types"],
 	"keywords": [],
 	"license": "MIT",
 	"main": "./dist/js/index.js",
@@ -131,5 +127,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.46.0"
+	"version": "0.47.1"
 }

package/src/js/timer.ts

@@ -24,6 +24,13 @@ type BaseOptions = {
 	timeout: number;
 };
 
+type BaseTimer = {
+	/**
+	 * Is the timer running?
+	 */
+	get active(): boolean;
+};
+
 type OptionsWithCount = {
 	/**
 	 * How many times the timer should repeat
@@ -50,7 +57,10 @@ type RepeatOptions = {
 type State = {
 	active: boolean;
 	callback: AnyCallback;
+	count?: number;
+	elapsed?: number;
 	frame?: number;
+	index?: number;
 };
 
 /**
@@ -58,22 +68,26 @@ type State = {
  */
 export type Timer = {
 	/**
-	 * Is the timer running?
+	 * Continues the timer _(if it was paused)_
 	 */
-	get active(): boolean;
+	continue(): Timer;
+	/**
+	 * Pauses the timer _(if it was running)_
+	 */
+	pause(): Timer;
 	/**
-	 * Restarts the timer
+	 * Restarts the timer _(if it was running)_
 	 */
 	restart(): Timer;
 	/**
-	 * Starts the timer
+	 * Starts the timer _(if it was stopped)_
 	 */
 	start(): Timer;
 	/**
-	 * Stops the timer
+	 * Stops the timer _(if it was running)_
 	 */
 	stop(): Timer;
-};
+} & BaseTimer;
 
 type TimerOptions = {} & RepeatOptions;
 
@@ -81,13 +95,17 @@ type WaitOptions = {} & BaseOptions & OptionsWithError;
 
 export type When = {
 	/**
-	 * Is the timer running?
+	 * Continues the timer _(if it was paused)_
 	 */
-	get active(): boolean;
+	continue(): Timer;
 	/**
-	 * Stops the timer
+	 * Pauses the timer _(if it was running)_
 	 */
-	stop(): void;
+	pause(): Timer;
+	/**
+	 * Stops the timer _(if it was running)_
+	 */
+	stop(): Timer;
 	/**
 	 * Starts the timer and returns a promise that resolves when the condition is met
 	 */
@@ -95,11 +113,11 @@ export type When = {
 		resolve?: (() => void) | null,
 		reject?: (() => void) | null,
 	): Promise<void>;
-};
+} & BaseTimer;
 
 type WhenOptions = {} & OptionsWithCount;
 
-type WorkType = 'restart' | 'start' | 'stop';
+type WorkType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';
 
 const activeTimers = new Set<Timer>();
 const hiddenTimers = new Set<Timer>();
@@ -183,6 +201,12 @@ function timer(
 	};
 
 	const instance = Object.create({
+		continue() {
+			return work('continue', this as Timer, state, options, isRepeated);
+		},
+		pause() {
+			return work('pause', this as Timer, state, options, isRepeated);
+		},
 		restart() {
 			return work('restart', this as Timer, state, options, isRepeated);
 		},
@@ -280,6 +304,12 @@ export function when(
 	});
 
 	const instance = Object.create({
+		continue() {
+			repeated.continue();
+		},
+		pause() {
+			repeated.pause();
+		},
 		stop() {
 			if (repeated.active) {
 				repeated.stop();
@@ -319,46 +349,57 @@ function work(
 	isRepeated: boolean,
 ): Timer {
 	if (
-		(type === 'start' && state.active) ||
-		(type === 'stop' && !state.active)
+		(['continue', 'start'].includes(type) && state.active) ||
+		(['pause', 'stop'].includes(type) && !state.active)
 	) {
 		return timer;
 	}
 
 	const {count, interval, timeout} = options;
 
-	if (typeof state.frame === 'number') {
-		cancelAnimationFrame(state.frame);
+	if (['pause', 'stop'].includes(type)) {
+		activeTimers.delete(timer);
 
-		options.afterCallback?.(false);
-	}
+		cancelAnimationFrame(state.frame as never);
 
-	if (type === 'stop') {
-		activeTimers.delete(timer);
+		options.afterCallback?.(false);
 
 		state.active = false;
 		state.frame = undefined;
 
+		if (type === 'stop') {
+			state.elapsed = undefined;
+			state.index = undefined;
+		}
+
 		return timer;
 	}
 
 	state.active = true;
 
 	const canTimeout = timeout > 0 && timeout < Number.POSITIVE_INFINITY;
+	const elapsed = type === 'continue' ? +(state.elapsed ?? 0) : 0;
+
+	let index = type === 'continue' ? +(state.index ?? 0) : 0;
+
+	state.elapsed = elapsed;
+	state.index = index;
 
 	const total =
-		count === Number.POSITIVE_INFINITY
-			? timeout
-			: count * (interval > 0 ? interval : 17);
+		(count === Number.POSITIVE_INFINITY
+			? Number.POSITIVE_INFINITY
+			: (count - index) * (interval > 0 ? interval : 1000 / 16)) - elapsed;
 
 	let current: DOMHighResTimeStamp | null;
 	let start: DOMHighResTimeStamp | null;
 
-	let index = 0;
-
 	function finish(finished: boolean, error: boolean) {
+		activeTimers.delete(timer);
+
 		state.active = false;
+		state.elapsed = undefined;
 		state.frame = undefined;
+		state.index = undefined;
 
 		if (error) {
 			options.errorCallback?.();
@@ -375,18 +416,23 @@ function work(
 		current ??= timestamp;
 		start ??= timestamp;
 
-		const elapsed = timestamp - current;
-		const finished = elapsed >= total;
+		const time = timestamp - current;
+
+		state.elapsed = elapsed + (current - start);
 
-		if (finished || (elapsed - 2 < interval && interval < elapsed + 2)) {
+		const finished = time - elapsed >= total;
+
+		if (finished || (time - 2 < interval && interval < time + 2)) {
 			if (state.active) {
 				state.callback((isRepeated ? index : undefined) as never);
 			}
 
 			index += 1;
 
+			state.index = index;
+
 			switch (true) {
-				case canTimeout && !finished && timestamp - start >= timeout:
+				case canTimeout && !finished && timestamp - start >= timeout - elapsed:
 					finish(false, true);
 					return;
 
@@ -414,11 +460,11 @@ document.addEventListener('visibilitychange', () => {
 	if (document.hidden) {
 		for (const timer of activeTimers) {
 			hiddenTimers.add(timer);
-			timer.stop();
+			timer.pause();
 		}
 	} else {
 		for (const timer of hiddenTimers) {
-			timer.start();
+			timer.continue();
 		}
 
 		hiddenTimers.clear();

package/types/timer.d.ts

@@ -17,6 +17,12 @@ type BaseOptions = {
      */
     timeout: number;
 };
+type BaseTimer = {
+    /**
+     * Is the timer running?
+     */
+    get active(): boolean;
+};
 type OptionsWithCount = {
     /**
      * How many times the timer should repeat
@@ -41,37 +47,45 @@ type RepeatOptions = {
  */
 export type Timer = {
     /**
-     * Is the timer running?
+     * Continues the timer _(if it was paused)_
      */
-    get active(): boolean;
+    continue(): Timer;
+    /**
+     * Pauses the timer _(if it was running)_
+     */
+    pause(): Timer;
     /**
-     * Restarts the timer
+     * Restarts the timer _(if it was running)_
      */
     restart(): Timer;
     /**
-     * Starts the timer
+     * Starts the timer _(if it was stopped)_
      */
     start(): Timer;
     /**
-     * Stops the timer
+     * Stops the timer _(if it was running)_
      */
     stop(): Timer;
-};
+} & BaseTimer;
 type WaitOptions = {} & BaseOptions & OptionsWithError;
 export type When = {
     /**
-     * Is the timer running?
+     * Continues the timer _(if it was paused)_
      */
-    get active(): boolean;
+    continue(): Timer;
     /**
-     * Stops the timer
+     * Pauses the timer _(if it was running)_
      */
-    stop(): void;
+    pause(): Timer;
+    /**
+     * Stops the timer _(if it was running)_
+     */
+    stop(): Timer;
     /**
      * Starts the timer and returns a promise that resolves when the condition is met
      */
     then(resolve?: (() => void) | null, reject?: (() => void) | null): Promise<void>;
-};
+} & BaseTimer;
 type WhenOptions = {} & OptionsWithCount;
 /**
  * Is the value a repeating timer?