@oscarpalmer/timer 0.25.0 → 0.27.0

package/dist/when.cjs

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _function = require("@oscarpalmer/atoms/function");
+const timer = require("./timer.cjs");
+const destroyedMessage = "Timer has already been destroyed";
+const startedMessage = "Timer has already been started";
+class When extends timer.BasicTimer {
+  get active() {
+    var _a;
+    return ((_a = this.state.timer) == null ? void 0 : _a.active) ?? false;
+  }
+  get destroyed() {
+    return this.state.timer == null;
+  }
+  get paused() {
+    var _a;
+    return ((_a = this.state.timer) == null ? void 0 : _a.paused) ?? false;
+  }
+  get trace() {
+    var _a;
+    return (_a = this.state.timer) == null ? void 0 : _a.trace;
+  }
+  constructor(state) {
+    super("when", state);
+  }
+  /**
+   * Continues the timer _(if it was paused)_
+   */
+  continue() {
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.continue();
+    return this;
+  }
+  /**
+   * Destroys the timer _(and stops it,if it was running)_
+   */
+  destroy() {
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.destroy();
+    this.state.promise = void 0;
+    this.state.resolver = _function.noop;
+    this.state.rejecter = _function.noop;
+    this.state.timer = void 0;
+  }
+  /**
+   * Pauses the timer _(if it was running)_
+   */
+  pause() {
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.pause();
+    return this;
+  }
+  /**
+   * Stops the timer _(if it was running)_
+   */
+  stop() {
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.stop();
+    return this;
+  }
+  /**
+   * 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, reject) {
+    var _a;
+    if (this.state.timer == null || ((_a = this.state) == null ? void 0 : _a.started)) {
+      throw new Error(
+        this.state.timer == null ? destroyedMessage : startedMessage
+      );
+    }
+    this.state.started = true;
+    this.state.timer.start();
+    return this.state.promise.then(resolve ?? _function.noop, reject ?? _function.noop);
+  }
+}
+function when(condition, options) {
+  let result = false;
+  const state = {
+    started: false,
+    timer: timer.timer(
+      "repeat",
+      () => {
+        if (condition()) {
+          result = true;
+          state.timer.stop();
+        }
+      },
+      {
+        afterCallback() {
+          var _a, _b;
+          if (!state.timer.paused) {
+            if (result) {
+              (_a = state.resolver) == null ? void 0 : _a.call(state);
+            } else {
+              (_b = state.rejecter) == null ? void 0 : _b.call(state);
+            }
+            instance.destroy();
+          }
+        },
+        errorCallback() {
+          var _a;
+          (_a = state.rejecter) == null ? void 0 : _a.call(state);
+          instance.destroy();
+        },
+        count: options == null ? void 0 : options.count,
+        interval: options == null ? void 0 : options.interval,
+        timeout: options == null ? void 0 : options.timeout
+      },
+      false
+    )
+  };
+  const promise = new Promise((resolve, reject) => {
+    state.resolver = resolve;
+    state.rejecter = reject;
+  });
+  state.promise = promise;
+  const instance = new When(state);
+  return instance;
+}
+exports.When = When;
+exports.when = when;

package/dist/when.js

@@ -1,213 +1,112 @@
-// node_modules/@oscarpalmer/atoms/dist/js/function.mjs
-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 getOptions(options, isRepeated) {
-  return {
-    afterCallback: options.afterCallback,
-    count: getValueOrDefault(options.count, isRepeated ? Number.POSITIVE_INFINITY : 1),
-    errorCallback: options.errorCallback,
-    interval: getValueOrDefault(options.interval, milliseconds, milliseconds),
-    timeout: getValueOrDefault(options.timeout, isRepeated ? Number.POSITIVE_INFINITY : 30000)
-  };
-}
-function getValueOrDefault(value, defaultValue, minimum) {
-  return typeof value === "number" && value > (minimum ?? 0) ? value : defaultValue;
-}
-function work(type, timer, state, options) {
-  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 (endOrRestartTypes.has(type)) {
-    const isStop = type === "stop";
-    activeTimers.delete(timer);
-    cancelAnimationFrame(state.frame);
-    if (isStop) {
-      options.afterCallback?.(false);
-    }
-    state.active = false;
-    state.frame = undefined;
-    state.paused = !isStop;
-    if (isStop) {
-      state.elapsed = undefined;
-      state.index = undefined;
-    }
-    return type === "restart" ? work("start", timer, state, options) : timer;
-  }
-  state.active = true;
-  state.paused = false;
-  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 : milliseconds)) - elapsed;
-  let current;
-  let start;
-  function finish(finished, error) {
-    activeTimers.delete(timer);
-    state.active = false;
-    state.elapsed = undefined;
-    state.frame = undefined;
-    state.index = undefined;
-    if (error) {
-      options.errorCallback?.();
-    }
-    options.afterCallback?.(finished);
-  }
-  function step(timestamp) {
-    if (!state.active) {
-      return;
-    }
-    current ??= timestamp;
-    start ??= timestamp;
-    const time = timestamp - current;
-    state.elapsed = elapsed + (current - start);
-    const finished = time - elapsed >= total;
-    if (timestamp - start >= timeout - elapsed) {
-      finish(finished, !finished);
-      return;
-    }
-    if (finished || time >= minimum) {
-      if (state.active) {
-        state.callback(isRepeated ? index : undefined);
-      }
-      index += 1;
-      state.index = index;
-      if (!finished && index < count) {
-        current = null;
-      } else {
-        finish(true, false);
-        return;
-      }
-    }
-    state.frame = requestAnimationFrame(step);
-  }
-  activeTimers.add(timer);
-  state.frame = requestAnimationFrame(step);
-  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";
-  const options = getOptions(partial, isRepeated);
-  const instance = new Timer(type, {
-    callback,
-    isRepeated,
-    active: false,
-    destroyed: false,
-    minimum: options.interval - options.interval % milliseconds / 2,
-    paused: false,
-    trace: new TimerTrace
-  }, options);
-  if (start) {
-    instance.start();
-  }
-  return instance;
-}
-class BasicTimer {
-  constructor(type, state) {
-    this.$timer = type;
-    this.state = state;
-  }
-}
-
-class Timer extends BasicTimer {
+import { noop } from "@oscarpalmer/atoms/function";
+import { BasicTimer, timer } from "./timer.js";
+const destroyedMessage = "Timer has already been destroyed";
+const startedMessage = "Timer has already been started";
+class When extends BasicTimer {
   get active() {
-    return this.state.active;
+    var _a;
+    return ((_a = this.state.timer) == null ? void 0 : _a.active) ?? false;
   }
   get destroyed() {
-    return this.state.destroyed;
+    return this.state.timer == null;
   }
   get paused() {
-    return this.state.paused;
+    var _a;
+    return ((_a = this.state.timer) == null ? void 0 : _a.paused) ?? false;
   }
   get trace() {
-    return globalThis._oscarpalmer_timer_debug ? this.state.trace : undefined;
+    var _a;
+    return (_a = this.state.timer) == null ? void 0 : _a.trace;
   }
-  constructor(type, state, options) {
-    super(type, state);
-    this.options = options;
+  constructor(state) {
+    super("when", state);
   }
+  /**
+   * Continues the timer _(if it was paused)_
+   */
   continue() {
-    return work("continue", this, this.state, this.options);
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.continue();
+    return this;
   }
+  /**
+   * Destroys the timer _(and stops it,if it was running)_
+   */
   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;
-    }
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.destroy();
+    this.state.promise = void 0;
+    this.state.resolver = noop;
+    this.state.rejecter = noop;
+    this.state.timer = void 0;
   }
+  /**
+   * Pauses the timer _(if it was running)_
+   */
   pause() {
-    return work("pause", this, this.state, this.options);
-  }
-  restart() {
-    return work("restart", this, this.state, this.options);
-  }
-  start() {
-    return work("start", this, this.state, this.options);
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.pause();
+    return this;
   }
+  /**
+   * Stops the timer _(if it was running)_
+   */
   stop() {
-    return work("stop", this, this.state, this.options);
+    var _a;
+    (_a = this.state.timer) == null ? void 0 : _a.stop();
+    return this;
+  }
+  /**
+   * 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, reject) {
+    var _a;
+    if (this.state.timer == null || ((_a = this.state) == null ? void 0 : _a.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);
   }
 }
-
-// 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 (result) {
-            state.resolver?.();
-          } else {
-            state.rejecter?.();
-          }
-          instance.destroy();
+    timer: timer(
+      "repeat",
+      () => {
+        if (condition()) {
+          result = true;
+          state.timer.stop();
         }
       },
-      errorCallback() {
-        state.rejecter?.();
-        instance.destroy();
+      {
+        afterCallback() {
+          var _a, _b;
+          if (!state.timer.paused) {
+            if (result) {
+              (_a = state.resolver) == null ? void 0 : _a.call(state);
+            } else {
+              (_b = state.rejecter) == null ? void 0 : _b.call(state);
+            }
+            instance.destroy();
+          }
+        },
+        errorCallback() {
+          var _a;
+          (_a = state.rejecter) == null ? void 0 : _a.call(state);
+          instance.destroy();
+        },
+        count: options == null ? void 0 : options.count,
+        interval: options == null ? void 0 : options.interval,
+        timeout: options == null ? void 0 : options.timeout
       },
-      count: options?.count,
-      interval: options?.interval,
-      timeout: options?.timeout
-    }, false)
+      false
+    )
   };
   const promise = new Promise((resolve, reject) => {
     state.resolver = resolve;
@@ -217,54 +116,7 @@ function when(condition, options) {
   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() {
-    return this.state.timer?.active ?? false;
-  }
-  get destroyed() {
-    return this.state.timer == null;
-  }
-  get paused() {
-    return this.state.timer?.paused ?? false;
-  }
-  get trace() {
-    return this.state.timer?.trace;
-  }
-  constructor(state) {
-    super("when", state);
-  }
-  continue() {
-    this.state.timer?.continue();
-    return this;
-  }
-  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();
-    return this;
-  }
-  stop() {
-    this.state.timer?.stop();
-    return this;
-  }
-  then(resolve, reject) {
-    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);
-  }
-}
 export {
-  when,
-  When
+  When,
+  when
 };

package/package.json

@@ -4,51 +4,54 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "0.74.1"
+		"@oscarpalmer/atoms": "0.81.0"
 	},
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"@biomejs/biome": "^1.9.2",
-		"@happy-dom/global-registrator": "^15.7.4",
-		"@types/bun": "^1.1.10",
-		"bun": "^1.1.29",
-		"dts-bundle-generator": "9.5.1",
-		"typescript": "^5.6.2"
+		"@biomejs/biome": "^1.9",
+		"@rollup/plugin-node-resolve": "^16",
+		"@rollup/plugin-typescript": "^12.1",
+		"@types/node": "^22.10",
+		"@vitest/coverage-istanbul": "^2.1",
+		"dts-bundle-generator": "^9.5",
+		"happy-dom": "^16.5",
+		"tslib": "^2.8",
+		"typescript": "^5.7",
+		"vite": "^6",
+		"vitest": "^2.1"
 	},
 	"exports": {
 		".": {
-			"bun": "./src/index.ts",
 			"import": {
 				"types": "./types/index.d.ts",
-				"default": "./dist/index.mjs"
+				"default": "./dist/index.js"
 			},
 			"require": {
 				"types": "./types/index.d.cts",
-				"default": "./dist/index.js"
+				"default": "./dist/index.cjs"
 			}
 		}
 	},
 	"files": ["dist", "src", "types"],
 	"keywords": ["timer", "setTimeout", "setInterval", "requestAnimationFrame"],
 	"license": "MIT",
-	"main": "dist/index.js",
-	"module": "dist/index.mjs",
+	"main": "dist/index.cjs",
+	"module": "dist/index.js",
 	"name": "@oscarpalmer/timer",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/oscarpalmer/timer.git"
 	},
 	"scripts": {
-		"build": "bun run clean && bun run build:js && bun run types",
-		"build:js": "bunx bun ./.bun.ts && bunx bun ./.bun.ts --mjs",
+		"build": "npm run clean && npm run build:js && npm run rollup && npm run types",
+		"build:js": "npx vite build",
 		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
-		"test": "bun test",
-		"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/index.js --watch"
+		"rollup": "npx rollup -c",
+		"test": "npx vitest --coverage",
+		"types": "npx tsc && npx dts-bundle-generator --config ./dts.config.ts",
+		"watch": "npx vite build --watch"
 	},
 	"type": "module",
 	"types": "types/index.d.cts",
-	"version": "0.25.0"
+	"version": "0.27.0"
 }

package/src/functions.ts

@@ -5,7 +5,7 @@ import {
 	endTypes,
 	milliseconds,
 } from './constants';
-import type {TimerOptions, TimerState, WhenState, WorkType} from './models';
+import type {TimerOptions, TimerState, WorkType} from './models';
 import type {Timer} from './timer';
 
 export function getOptions(

package/src/index.ts

@@ -45,3 +45,4 @@ 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

@@ -60,7 +60,7 @@ export type TimerState = {
 	isRepeated: boolean;
 	minimum: number;
 	paused: boolean;
-	trace: TimerTrace;
+	trace?: string;
 };
 
 export class TimerTrace extends Error {

package/src/timer.ts

@@ -1,12 +1,12 @@
 import {milliseconds} from './constants';
 import {getOptions, work} from './functions';
 import {
-	TimerTrace,
 	type AnyCallback,
 	type IndexedCallback,
 	type RepeatOptions,
 	type TimerOptions,
 	type TimerState,
+	TimerTrace,
 	type WaitOptions,
 } from './models';
 
@@ -37,7 +37,7 @@ export abstract class BasicTimer<State> {
 	/**
 	 * Gets the traced location of the timer
 	 */
-	abstract readonly trace: TimerTrace | undefined;
+	abstract readonly trace: string | undefined;
 }
 
 /**
@@ -159,7 +159,7 @@ export function timer(
 			destroyed: false,
 			minimum: options.interval - (options.interval % milliseconds) / 2,
 			paused: false,
-			trace: new TimerTrace(),
+			trace: new TimerTrace().stack,
 		},
 		options,
 	);