@oscarpalmer/timer 0.24.0 → 0.26.0

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,50 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "0.69.0"
+		"@oscarpalmer/atoms": "0.75.0"
 	},
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
-		"@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.6.2"
+		"@biomejs/biome": "^1.9",
+		"@types/node": "^22.7",
+		"@vitest/coverage-istanbul": "^2.1",
+		"dts-bundle-generator": "^9.5",
+		"happy-dom": "^15.7",
+		"typescript": "^5.6",
+		"vite": "^5.4",
+		"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 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"
+		"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.24.0"
+	"version": "0.26.0"
 }

package/src/constants.ts

@@ -1,5 +1,5 @@
-import type {WorkType} from './models';
-import type {Timer} from './timer';
+import type {WorkType} from '~/models';
+import type {Timer} from '~/timer';
 
 /**
  * A set of all active timers

package/src/functions.ts

@@ -4,9 +4,9 @@ import {
 	endOrRestartTypes,
 	endTypes,
 	milliseconds,
-} from './constants';
-import type {TimerOptions, TimerState, WhenState, WorkType} from './models';
-import type {Timer} from './timer';
+} from '~/constants';
+import type {TimerOptions, TimerState, WorkType} from '~/models';
+import type {Timer} from '~/timer';
 
 export function getOptions(
 	options: Partial<TimerOptions>,

package/src/global.ts

@@ -1,4 +1,5 @@
-import {activeTimers} from './constants';
+import type {Timer} from '~/timer';
+import {activeTimers} from '~/constants';
 
 declare global {
 	var _oscarpalmer_timer_debug: boolean | undefined;

package/src/index.ts

@@ -1,7 +1,7 @@
+import {activeTimers, hiddenTimers} from '~/constants';
+import '~/global';
 import {noop} from '@oscarpalmer/atoms/function';
-import {activeTimers, hiddenTimers} from './constants';
-import './global';
-import {wait} from './timer';
+import {wait} from '~/timer';
 
 /**
  * Creates a delayed promise that resolves after a certain amount of time _(or rejects when timed out)_
@@ -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/is.ts

@@ -1,6 +1,6 @@
 import type {PlainObject} from '@oscarpalmer/atoms/models';
-import type {Timer} from './timer';
-import type {When} from './when';
+import type {Timer} from '~/timer';
+import type {When} from '~/when';
 
 function is(pattern: RegExp, value: unknown) {
 	return pattern.test((value as PlainObject)?.$timer as string);

package/src/models.ts

@@ -1,4 +1,4 @@
-import type {Timer} from './timer';
+import type {Timer} from '~/timer';
 
 /**
  * Callback that runs after the timer has finished (or is stopped)

package/src/timer.ts

@@ -1,5 +1,5 @@
-import {milliseconds} from './constants';
-import {getOptions, work} from './functions';
+import {milliseconds} from '~/constants';
+import {getOptions, work} from '~/functions';
 import {
 	TimerTrace,
 	type AnyCallback,
@@ -8,7 +8,7 @@ import {
 	type TimerOptions,
 	type TimerState,
 	type WaitOptions,
-} from './models';
+} from '~/models';
 
 export abstract class BasicTimer<State> {
 	protected declare readonly $timer: string;

package/src/when.ts

@@ -1,6 +1,6 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import type {WhenOptions, WhenState} from './models';
-import {BasicTimer, timer} from './timer';
+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';

package/types/constants.d.cts

@@ -0,0 +1,138 @@
+// Generated by dts-bundle-generator v9.5.1
+
+declare abstract class BasicTimer<State> {
+	protected readonly $timer: string;
+	protected readonly state: State;
+	constructor(type: "repeat" | "wait" | "when", state: State);
+	/**
+	 * Is the timer running?
+	 */
+	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;
+}
+declare class Timer extends BasicTimer<TimerState> {
+	private readonly options;
+	get active(): boolean;
+	get destroyed(): boolean;
+	get paused(): boolean;
+	get trace(): TimerTrace | undefined;
+	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
+	/**
+	 * Continues the timer _(if it was paused)_
+	 */
+	continue(): Timer;
+	/**
+	 * Destroys the timer _(after stopping it, if it was running)_
+	 */
+	destroy(): void;
+	/**
+	 * Pauses the timer _(if it was running)_
+	 */
+	pause(): Timer;
+	/**
+	 * Restarts the timer _(if it was running)_
+	 */
+	restart(): Timer;
+	/**
+	 * Starts the timer _(if it was stopped)_
+	 */
+	start(): Timer;
+	/**
+	 * Stops the timer _(if it was running)_
+	 */
+	stop(): Timer;
+}
+/**
+ * Callback that runs after the timer has finished (or is stopped)
+ * - `finished` is `true` if the timer was allowed to finish, and `false` if it was stopped
+ */
+export type AfterCallback = (finished: boolean) => void;
+export type AnyCallback = (() => void) | IndexedCallback;
+/**
+ * Callback that runs for each iteration of the timer
+ */
+export type IndexedCallback = (index: number) => void;
+export type BaseOptions = {
+	/**
+	 * Interval between each callback
+	 */
+	interval: number;
+	/**
+	 * Maximum amount of time the timer may run for
+	 */
+	timeout: number;
+};
+export type OptionsWithCount = {
+	/**
+	 * How many times the timer should repeat
+	 */
+	count: number;
+} & BaseOptions;
+export type OptionsWithError = {
+	/**
+	 * Callback to run when an error occurs _(usually a timeout)_
+	 */
+	errorCallback?: () => void;
+};
+export type RepeatOptions = {
+	/**
+	 * Callback to run after the timer has finished (or is stopped)
+	 * - `finished` is `true` if the timer was allowed to finish, and `false` if it was stopped
+	 */
+	afterCallback?: AfterCallback;
+} & OptionsWithCount & OptionsWithError;
+export type TimerOptions = {} & RepeatOptions;
+export type TimerState = {
+	active: boolean;
+	callback: AnyCallback;
+	destroyed: boolean;
+	count?: number;
+	elapsed?: number;
+	frame?: number;
+	index?: number;
+	isRepeated: boolean;
+	minimum: number;
+	paused: boolean;
+	trace: TimerTrace;
+};
+declare class TimerTrace extends Error {
+	constructor();
+}
+export type WorkType = "continue" | "pause" | "restart" | "start" | "stop";
+/**
+ * A set of all active timers
+ */
+export declare const activeTimers: Set<Timer>;
+/**
+ * A set of types that allow work to begin
+ */
+export declare const beginTypes: Set<WorkType>;
+/**
+ * A set of types that allow work to end
+ */
+export declare const endTypes: Set<WorkType>;
+/**
+ * A set of types that allow work to end or restart
+ */
+export declare const endOrRestartTypes: Set<WorkType>;
+/**
+ * A set of timers that were paused due to the document being hidden
+ */
+export declare const hiddenTimers: Set<Timer>;
+/**
+ * Milliseconds in a frame, probably ;-)
+ */
+export declare const milliseconds: number;
+
+export {};

package/types/constants.d.ts

@@ -1,5 +1,5 @@
-import type { WorkType } from './models';
-import type { Timer } from './timer';
+import type { WorkType } from '~/models';
+import type { Timer } from '~/timer';
 /**
  * A set of all active timers
  */