@oscarpalmer/timer 0.26.0 → 0.27.1

package/dist/index.cjs

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _function = require("@oscarpalmer/atoms/function");
 const constants = require("./constants.cjs");
 require("./global.cjs");
-const _function = require("@oscarpalmer/atoms/function");
 const timer = require("./timer.cjs");
 const is = require("./is.cjs");
 const when = require("./when.cjs");

package/dist/index.js

@@ -1,6 +1,6 @@
+import { noop } from "@oscarpalmer/atoms/function";
 import { activeTimers, hiddenTimers } from "./constants.js";
 import "./global.js";
-import { noop } from "@oscarpalmer/atoms/function";
 import { wait } from "./timer.js";
 import { repeat } from "./timer.js";
 import { isRepeated, isTimer, isWaited, isWhen } from "./is.js";

package/dist/timer.cjs

@@ -85,7 +85,7 @@ function timer(type, callback, partial, start) {
       destroyed: false,
       minimum: options.interval - options.interval % constants.milliseconds / 2,
       paused: false,
-      trace: new models.TimerTrace()
+      trace: new models.TimerTrace().stack
     },
     options
   );

package/dist/timer.iife.js

@@ -0,0 +1,429 @@
+var Timer = (function (exports) {
+  'use strict';
+
+  function noop() {
+  }
+
+  /**
+   * A set of all active timers
+   */
+  const activeTimers = new Set();
+  /**
+   * A set of types that allow work to begin
+   */
+  const beginTypes = new Set(['continue', 'start']);
+  /**
+   * A set of types that allow work to end
+   */
+  const endTypes = new Set(['pause', 'stop']);
+  /**
+   * A set of types that allow work to end or restart
+   */
+  const endOrRestartTypes = new Set([
+      'pause',
+      'restart',
+      'stop',
+  ]);
+  /**
+   * A set of timers that were paused due to the document being hidden
+   */
+  const hiddenTimers = new Set();
+  /**
+   * Milliseconds in a frame, probably ;-)
+   */
+  const milliseconds = 1_000 / 60;
+
+  if (globalThis._oscarpalmer_timers == null) {
+      Object.defineProperty(globalThis, '_oscarpalmer_timers', {
+          get() {
+              return globalThis._oscarpalmer_timer_debug ? [...activeTimers] : [];
+          },
+      });
+  }
+
+  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 : 30_000),
+      };
+  }
+  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;
+  }
+
+  class TimerTrace extends Error {
+      constructor() {
+          super();
+          this.name = 'TimerTrace';
+      }
+  }
+
+  class BasicTimer {
+      constructor(type, state) {
+          this.$timer = type;
+          this.state = state;
+      }
+  }
+  /**
+   * A timer that can be started, stopped, and restarted as neeeded
+   */
+  class Timer extends BasicTimer {
+      get active() {
+          return this.state.active;
+      }
+      get destroyed() {
+          return this.state.destroyed;
+      }
+      get paused() {
+          return this.state.paused;
+      }
+      get trace() {
+          return globalThis._oscarpalmer_timer_debug ? this.state.trace : undefined;
+      }
+      constructor(type, state, options) {
+          super(type, state);
+          this.options = options;
+      }
+      /**
+       * Continues the timer _(if it was paused)_
+       */
+      continue() {
+          return work('continue', this, this.state, this.options);
+      }
+      /**
+       * Destroys the timer _(after stopping 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;
+          }
+      }
+      /**
+       * Pauses the timer _(if it was running)_
+       */
+      pause() {
+          return work('pause', this, this.state, this.options);
+      }
+      /**
+       * Restarts the timer _(if it was running)_
+       */
+      restart() {
+          return work('restart', this, this.state, this.options);
+      }
+      /**
+       * Starts the timer _(if it was stopped)_
+       */
+      start() {
+          return work('start', this, this.state, this.options);
+      }
+      /**
+       * Stops the timer _(if it was running)_
+       */
+      stop() {
+          return work('stop', this, this.state, this.options);
+      }
+  }
+  /**
+   * Creates a timer which:
+   * - calls a callback after a certain amount of time...
+   * - ... and repeats it a certain amount of times
+   * ---
+   * - `options.count` defaults to `Infinity`
+   * - `options.interval` defaults to `1000/60` _(1 frame)_
+   * - `options.timeout` defaults to `Infinity`
+   */
+  function repeat(callback, options) {
+      return timer('repeat', callback, options ?? {}, true);
+  }
+  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().stack,
+      }, options);
+      if (start) {
+          instance.start();
+      }
+      return instance;
+  }
+  function wait(callback, options) {
+      return timer('wait', callback, options == null || typeof options === 'number'
+          ? {
+              interval: options,
+          }
+          : options, true);
+  }
+
+  function is(pattern, value) {
+      return pattern.test(value?.$timer);
+  }
+  /**
+   * Is the value a repeating timer?
+   */
+  function isRepeated(value) {
+      return is(/^repeat$/, value);
+  }
+  /**
+   * Is the value a timer?
+   */
+  function isTimer(value) {
+      return is(/^repeat|wait$/, value);
+  }
+  /**
+   * Is the value a waiting timer?
+   */
+  function isWaited(value) {
+      return is(/^wait$/, value);
+  }
+  /**
+   * Is the value a conditional timer?
+   */
+  function isWhen(value) {
+      return is(/^when$/, value) && typeof value.then === 'function';
+  }
+
+  const destroyedMessage = 'Timer has already been destroyed';
+  const 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);
+      }
+      /**
+       * Continues the timer _(if it was paused)_
+       */
+      continue() {
+          this.state.timer?.continue();
+          return this;
+      }
+      /**
+       * Destroys the timer _(and stops it,if it was running)_
+       */
+      destroy() {
+          this.state.timer?.destroy();
+          this.state.promise = undefined;
+          this.state.resolver = noop;
+          this.state.rejecter = noop;
+          this.state.timer = undefined;
+      }
+      /**
+       * Pauses the timer _(if it was running)_
+       */
+      pause() {
+          this.state.timer?.pause();
+          return this;
+      }
+      /**
+       * Stops the timer _(if it was running)_
+       */
+      stop() {
+          this.state.timer?.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) {
+          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);
+      }
+  }
+  /**
+   * - Creates a promise that resolves when a condition is met
+   * - If the condition is never met in a timely manner, the promise will reject
+   */
+  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();
+                  }
+              },
+              errorCallback() {
+                  state.rejecter?.();
+                  instance.destroy();
+              },
+              count: options?.count,
+              interval: options?.interval,
+              timeout: 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;
+  }
+
+  /**
+   * Creates a delayed promise that resolves after a certain amount of time _(or rejects when timed out)_
+   */
+  function delay(time, timeout) {
+      return new Promise((resolve, reject) => {
+          const delayed = wait(() => {
+              delayed.destroy();
+              (resolve ?? noop)();
+          }, {
+              timeout,
+              errorCallback: () => {
+                  delayed.destroy();
+                  (reject ?? noop)();
+              },
+              interval: time,
+          });
+      });
+  }
+  document.addEventListener('visibilitychange', () => {
+      if (document.hidden) {
+          for (const timer of activeTimers) {
+              hiddenTimers.add(timer);
+              timer.pause();
+          }
+      }
+      else {
+          for (const timer of hiddenTimers) {
+              timer.continue();
+          }
+          hiddenTimers.clear();
+      }
+  });
+
+  exports.delay = delay;
+  exports.isRepeated = isRepeated;
+  exports.isTimer = isTimer;
+  exports.isWaited = isWaited;
+  exports.isWhen = isWhen;
+  exports.repeat = repeat;
+  exports.wait = wait;
+  exports.when = when;
+
+  return exports;
+
+})({});

package/dist/timer.js

@@ -83,7 +83,7 @@ function timer(type, callback, partial, start) {
       destroyed: false,
       minimum: options.interval - options.interval % milliseconds / 2,
       paused: false,
-      trace: new TimerTrace()
+      trace: new TimerTrace().stack
     },
     options
   );

package/package.json

@@ -4,17 +4,21 @@
 		"url": "https://oscarpalmer.se"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "0.75.0"
+		"@oscarpalmer/atoms": "0.81.0"
 	},
 	"description": "A better solution for timeout- and interval-based timers.",
 	"devDependencies": {
 		"@biomejs/biome": "^1.9",
-		"@types/node": "^22.7",
+		"@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": "^15.7",
-		"typescript": "^5.6",
-		"vite": "^5.4",
+		"glob": "^11",
+		"happy-dom": "^16.5",
+		"tslib": "^2.8",
+		"typescript": "^5.7",
+		"vite": "^6",
 		"vitest": "^2.1"
 	},
 	"exports": {
@@ -40,14 +44,15 @@
 		"url": "git+https://github.com/oscarpalmer/timer.git"
 	},
 	"scripts": {
-		"build": "npm run clean && npm run build:js && npm run types",
+		"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",
+		"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.26.0"
+	"version": "0.27.1"
 }

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

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)
@@ -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,14 +1,14 @@
-import {milliseconds} from '~/constants';
-import {getOptions, work} from '~/functions';
+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';
+} from './models';
 
 export abstract class BasicTimer<State> {
 	protected declare readonly $timer: string;
@@ -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,
 	);

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

@@ -19,14 +19,14 @@ declare abstract class BasicTimer<State> {
 	/**
 	 * Gets the traced location of the timer
 	 */
-	abstract readonly trace: TimerTrace | undefined;
+	abstract readonly trace: string | undefined;
 }
 declare class Timer extends BasicTimer<TimerState> {
 	private readonly options;
 	get active(): boolean;
 	get destroyed(): boolean;
 	get paused(): boolean;
-	get trace(): TimerTrace | undefined;
+	get trace(): string | undefined;
 	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
 	/**
 	 * Continues the timer _(if it was paused)_
@@ -104,11 +104,8 @@ export type TimerState = {
 	isRepeated: boolean;
 	minimum: number;
 	paused: boolean;
-	trace: TimerTrace;
+	trace?: string;
 };
-declare class TimerTrace extends Error {
-	constructor();
-}
 export type WorkType = "continue" | "pause" | "restart" | "start" | "stop";
 /**
  * A set of all active timers

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

package/types/functions.d.cts

@@ -19,14 +19,14 @@ declare abstract class BasicTimer<State> {
 	/**
 	 * Gets the traced location of the timer
 	 */
-	abstract readonly trace: TimerTrace | undefined;
+	abstract readonly trace: string | undefined;
 }
 declare class Timer extends BasicTimer<TimerState> {
 	private readonly options;
 	get active(): boolean;
 	get destroyed(): boolean;
 	get paused(): boolean;
-	get trace(): TimerTrace | undefined;
+	get trace(): string | undefined;
 	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
 	/**
 	 * Continues the timer _(if it was paused)_
@@ -104,11 +104,8 @@ export type TimerState = {
 	isRepeated: boolean;
 	minimum: number;
 	paused: boolean;
-	trace: TimerTrace;
+	trace?: string;
 };
-declare class TimerTrace extends Error {
-	constructor();
-}
 export type WorkType = "continue" | "pause" | "restart" | "start" | "stop";
 export declare function getOptions(options: Partial<TimerOptions>, isRepeated: boolean): TimerOptions;
 export declare function getValueOrDefault(value: unknown, defaultValue: number, minimum?: number): number;

package/types/functions.d.ts

@@ -1,5 +1,5 @@
-import type { TimerOptions, TimerState, WorkType } from '~/models';
-import type { Timer } from '~/timer';
+import type { TimerOptions, TimerState, WorkType } from './models';
+import type { Timer } from './timer';
 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,4 +1,4 @@
-import type { Timer } from '~/timer';
+import type { Timer } from './timer';
 declare global {
     var _oscarpalmer_timer_debug: boolean | undefined;
     var _oscarpalmer_timers: Timer[] | undefined;

package/types/index.d.cts

@@ -19,7 +19,7 @@ declare abstract class BasicTimer<State> {
 	/**
 	 * Gets the traced location of the timer
 	 */
-	abstract readonly trace: TimerTrace | undefined;
+	abstract readonly trace: string | undefined;
 }
 /**
  * A timer that can be started, stopped, and restarted as neeeded
@@ -29,7 +29,7 @@ export declare class Timer extends BasicTimer<TimerState> {
 	get active(): boolean;
 	get destroyed(): boolean;
 	get paused(): boolean;
-	get trace(): TimerTrace | undefined;
+	get trace(): string | undefined;
 	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
 	/**
 	 * Continues the timer _(if it was paused)_
@@ -131,11 +131,8 @@ export type TimerState = {
 	isRepeated: boolean;
 	minimum: number;
 	paused: boolean;
-	trace: TimerTrace;
+	trace?: string;
 };
-declare class TimerTrace extends Error {
-	constructor();
-}
 export type WaitOptions = {} & BaseOptions & OptionsWithError;
 export type WhenOptions = {} & OptionsWithCount;
 export type WhenState = {
@@ -149,7 +146,7 @@ export declare class When extends BasicTimer<WhenState> {
 	get active(): boolean;
 	get destroyed(): boolean;
 	get paused(): boolean;
-	get trace(): TimerTrace | undefined;
+	get trace(): string | undefined;
 	constructor(state: WhenState);
 	/**
 	 * Continues the timer _(if it was paused)_

package/types/index.d.ts

@@ -1,4 +1,4 @@
-import '~/global';
+import './global';
 /**
  * Creates a delayed promise that resolves after a certain amount of time _(or rejects when timed out)_
  */

package/types/is.d.cts

@@ -19,14 +19,14 @@ declare abstract class BasicTimer<State> {
 	/**
 	 * Gets the traced location of the timer
 	 */
-	abstract readonly trace: TimerTrace | undefined;
+	abstract readonly trace: string | undefined;
 }
 declare class Timer extends BasicTimer<TimerState> {
 	private readonly options;
 	get active(): boolean;
 	get destroyed(): boolean;
 	get paused(): boolean;
-	get trace(): TimerTrace | undefined;
+	get trace(): string | undefined;
 	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
 	/**
 	 * Continues the timer _(if it was paused)_
@@ -104,11 +104,8 @@ export type TimerState = {
 	isRepeated: boolean;
 	minimum: number;
 	paused: boolean;
-	trace: TimerTrace;
+	trace?: string;
 };
-declare class TimerTrace extends Error {
-	constructor();
-}
 export type WhenState = {
 	promise: Promise<void>;
 	rejecter?: () => void;
@@ -120,7 +117,7 @@ declare class When extends BasicTimer<WhenState> {
 	get active(): boolean;
 	get destroyed(): boolean;
 	get paused(): boolean;
-	get trace(): TimerTrace | undefined;
+	get trace(): string | undefined;
 	constructor(state: WhenState);
 	/**
 	 * Continues the timer _(if it was paused)_

package/types/is.d.ts

@@ -1,5 +1,5 @@
-import type { Timer } from '~/timer';
-import type { When } from '~/when';
+import type { Timer } from './timer';
+import type { When } from './when';
 /**
  * Is the value a repeating timer?
  */

package/types/models.d.cts

@@ -19,14 +19,14 @@ declare abstract class BasicTimer<State> {
 	/**
 	 * Gets the traced location of the timer
 	 */
-	abstract readonly trace: TimerTrace | undefined;
+	abstract readonly trace: string | undefined;
 }
 declare class Timer extends BasicTimer<TimerState> {
 	private readonly options;
 	get active(): boolean;
 	get destroyed(): boolean;
 	get paused(): boolean;
-	get trace(): TimerTrace | undefined;
+	get trace(): string | undefined;
 	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
 	/**
 	 * Continues the timer _(if it was paused)_
@@ -104,7 +104,7 @@ export type TimerState = {
 	isRepeated: boolean;
 	minimum: number;
 	paused: boolean;
-	trace: TimerTrace;
+	trace?: string;
 };
 export declare class TimerTrace extends Error {
 	constructor();

package/types/models.d.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)
  * - `finished` is `true` if the timer was allowed to finish, and `false` if it was stopped
@@ -50,7 +50,7 @@ export type TimerState = {
     isRepeated: boolean;
     minimum: number;
     paused: boolean;
-    trace: TimerTrace;
+    trace?: string;
 };
 export declare class TimerTrace extends Error {
     constructor();

package/types/timer.d.cts

@@ -19,7 +19,7 @@ export declare abstract class BasicTimer<State> {
 	/**
 	 * Gets the traced location of the timer
 	 */
-	abstract readonly trace: TimerTrace | undefined;
+	abstract readonly trace: string | undefined;
 }
 /**
  * A timer that can be started, stopped, and restarted as neeeded
@@ -29,7 +29,7 @@ export declare class Timer extends BasicTimer<TimerState> {
 	get active(): boolean;
 	get destroyed(): boolean;
 	get paused(): boolean;
-	get trace(): TimerTrace | undefined;
+	get trace(): string | undefined;
 	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
 	/**
 	 * Continues the timer _(if it was paused)_
@@ -132,11 +132,8 @@ export type TimerState = {
 	isRepeated: boolean;
 	minimum: number;
 	paused: boolean;
-	trace: TimerTrace;
+	trace?: string;
 };
-declare class TimerTrace extends Error {
-	constructor();
-}
 export type WaitOptions = {} & BaseOptions & OptionsWithError;
 
 export {};

package/types/timer.d.ts

@@ -1,4 +1,4 @@
-import { TimerTrace, type AnyCallback, type IndexedCallback, type RepeatOptions, type TimerOptions, type TimerState, type WaitOptions } from '~/models';
+import { type AnyCallback, type IndexedCallback, type RepeatOptions, type TimerOptions, type TimerState, type WaitOptions } from './models';
 export declare abstract class BasicTimer<State> {
     protected readonly $timer: string;
     protected readonly state: State;
@@ -18,7 +18,7 @@ export declare abstract class BasicTimer<State> {
     /**
      * Gets the traced location of the timer
      */
-    abstract readonly trace: TimerTrace | undefined;
+    abstract readonly trace: string | undefined;
 }
 /**
  * A timer that can be started, stopped, and restarted as neeeded
@@ -28,7 +28,7 @@ export declare class Timer extends BasicTimer<TimerState> {
     get active(): boolean;
     get destroyed(): boolean;
     get paused(): boolean;
-    get trace(): TimerTrace | undefined;
+    get trace(): string | undefined;
     constructor(type: 'repeat' | 'wait', state: TimerState, options: TimerOptions);
     /**
      * Continues the timer _(if it was paused)_

package/types/when.d.cts

@@ -19,14 +19,14 @@ declare abstract class BasicTimer<State> {
 	/**
 	 * Gets the traced location of the timer
 	 */
-	abstract readonly trace: TimerTrace | undefined;
+	abstract readonly trace: string | undefined;
 }
 declare class Timer extends BasicTimer<TimerState> {
 	private readonly options;
 	get active(): boolean;
 	get destroyed(): boolean;
 	get paused(): boolean;
-	get trace(): TimerTrace | undefined;
+	get trace(): string | undefined;
 	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
 	/**
 	 * Continues the timer _(if it was paused)_
@@ -104,11 +104,8 @@ export type TimerState = {
 	isRepeated: boolean;
 	minimum: number;
 	paused: boolean;
-	trace: TimerTrace;
+	trace?: string;
 };
-declare class TimerTrace extends Error {
-	constructor();
-}
 export type WhenOptions = {} & OptionsWithCount;
 export type WhenState = {
 	promise: Promise<void>;
@@ -121,7 +118,7 @@ export declare class When extends BasicTimer<WhenState> {
 	get active(): boolean;
 	get destroyed(): boolean;
 	get paused(): boolean;
-	get trace(): TimerTrace | undefined;
+	get trace(): string | undefined;
 	constructor(state: WhenState);
 	/**
 	 * Continues the timer _(if it was paused)_

package/types/when.d.ts

@@ -1,10 +1,10 @@
-import type { WhenOptions, WhenState } from '~/models';
-import { BasicTimer } from '~/timer';
+import type { WhenOptions, WhenState } from './models';
+import { BasicTimer } from './timer';
 export declare class When extends BasicTimer<WhenState> {
     get active(): boolean;
     get destroyed(): boolean;
     get paused(): boolean;
-    get trace(): import("~/models").TimerTrace | undefined;
+    get trace(): string | undefined;
     constructor(state: WhenState);
     /**
      * Continues the timer _(if it was paused)_