@oscarpalmer/timer 0.41.4 → 0.43.0

package/{types/is.d.ts → dist/is.d.mts}

@@ -1,26 +1,30 @@
-import type { Timer } from './timer';
-import type { When } from './when';
+import { Timer } from "./timer.mjs";
+import { When } from "./when.mjs";
+
+//#region src/is.d.ts
 /**
  * Is the value a repeating timer?
  * @param value Value to check
  * @returns `true` if the value is a repeating timer
  */
-export declare function isRepeated(value: unknown): value is Timer;
+declare function isRepeated(value: unknown): value is Timer;
 /**
  * Is the value a timer?
  * @param value Value to check
  * @returns `true` if the value is a timer
  */
-export declare function isTimer(value: unknown): value is Timer;
+declare function isTimer(value: unknown): value is Timer;
 /**
  * Is the value a waiting timer?
  * @param value Value to check
  * @returns `true` if the value is a waiting timer
  */
-export declare function isWaited(value: unknown): value is Timer;
+declare function isWaited(value: unknown): value is Timer;
 /**
  * Is the value a conditional timer?
  * @param value Value to check
  * @returns `true` if the value is a conditional timer
  */
-export declare function isWhen(value: unknown): value is When;
+declare function isWhen(value: unknown): value is When;
+//#endregion
+export { isRepeated, isTimer, isWaited, isWhen };

package/dist/{is.js → is.mjs}

@@ -1,4 +1,5 @@
-import { TYPE_REPEAT, TYPE_WAIT } from "./constants.js";
+import { TYPE_REPEAT, TYPE_WAIT } from "./constants.mjs";
+//#region src/is.ts
 function is(names, value) {
 	return names.includes(value?.$timer);
 }
@@ -32,6 +33,7 @@ function isWaited(value) {
 * @returns `true` if the value is a conditional timer
 */
 function isWhen(value) {
-	return is(["when"], value) && typeof value.then === "function";
+	return is(["when"], value) && typeof value.start === "function";
 }
+//#endregion
 export { isRepeated, isTimer, isWaited, isWhen };

package/dist/models.d.mts

@@ -0,0 +1,82 @@
+import { Timer } from "./timer.mjs";
+
+//#region src/models.d.ts
+/**
+ * Options for a repeating timer
+ */
+type RepeatOptions = {
+  /**
+   * Callback to be called when the timer has stopped, either manually or by completing its work
+   */
+  onAfter: (finished: boolean) => void;
+  /**
+   * Callback to be called after the timer has timed out
+   */
+  onTimeout: () => void;
+  /**
+   * How many times the timer should repeat
+   */
+  count: number;
+  /**
+   * The interval between each repeat
+   */
+  interval: number;
+  /**
+   * The timeout for the timer _(any value above `0` will enable the timeout)_
+   */
+  timeout: number;
+};
+type TimerOptions = {
+  onAfter: ((finished: boolean) => void) | undefined;
+  onError: (() => void) | undefined;
+  count: number;
+  interval: number;
+  timeout: number;
+};
+type TimerState = {
+  active: boolean;
+  callback: () => void;
+  destroyed: boolean;
+  elapsed: number;
+  frame: number | undefined;
+  index: number;
+  paused: boolean;
+  total: number;
+  trace: string | undefined;
+};
+declare class TimerTrace extends Error {
+  constructor();
+}
+type TimerType = 'repeat' | 'wait' | 'when';
+/**
+ * Options for a conditional timer
+ */
+type WhenOptions = {
+  /**
+   * How many times the timer should check the condition
+   */
+  count: number;
+  /**
+   * Then interval between each condtional check
+   */
+  interval: number;
+  /**
+   * The timeout for the timer _(any value above `0` will enable the timeout)_
+   */
+  timeout: number;
+};
+type WhenState = {
+  promise: Promise<void>;
+  rejecter?: () => void;
+  resolver?: () => void;
+  started: boolean;
+  timer: Timer;
+};
+type WorkHandler = (type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions) => Timer;
+type WorkHandlerTimer = {
+  instance: Timer;
+  type: TimerType;
+};
+type WorkHandlerType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';
+//#endregion
+export { RepeatOptions, TimerOptions, TimerState, TimerTrace, TimerType, WhenOptions, WhenState, WorkHandler, WorkHandlerTimer, WorkHandlerType };

package/dist/{models.js → models.mjs}

@@ -1,7 +1,9 @@
+//#region src/models.ts
 var TimerTrace = class extends Error {
 	constructor() {
 		super();
 		this.name = "TimerTrace";
 	}
 };
+//#endregion
 export { TimerTrace };

package/dist/repeat.d.mts

@@ -0,0 +1,13 @@
+import { Timer } from "./timer.mjs";
+import { RepeatOptions } from "./models.mjs";
+//#region src/repeat.d.ts
+/**
+ * Create a repeating timer
+ *
+ * @param callback Callback to run on each interval
+ * @param options Timer options
+ * @returns Timer instance
+ */
+declare function repeat(callback: (index: number) => void, options?: Partial<RepeatOptions>): Timer;
+//#endregion
+export { type RepeatOptions, type Timer, repeat };

package/dist/{repeat.js → repeat.mjs}

@@ -1,10 +1,12 @@
-import { TYPE_REPEAT } from "./constants.js";
-import { getCallback, getValidNumber } from "./get.js";
-import "./global.js";
-import { TimerTrace } from "./models.js";
-import { Timer } from "./timer.js";
+import { TYPE_REPEAT } from "./constants.mjs";
+import { getCallback, getValidNumber } from "./get.mjs";
+import "./global.mjs";
+import { TimerTrace } from "./models.mjs";
+import { Timer } from "./timer.mjs";
+//#region src/repeat.ts
 /**
 * Create a repeating timer
+*
 * @param callback Callback to run on each interval
 * @param options Timer options
 * @returns Timer instance
@@ -21,4 +23,5 @@ function repeat(callback, options) {
 		timeout: getValidNumber(options?.timeout)
 	}, true);
 }
+//#endregion
 export { repeat };

package/dist/timer.d.mts

@@ -0,0 +1,52 @@
+import { TimerOptions, TimerState, TimerType } from "./models.mjs";
+
+//#region src/timer.d.ts
+declare class Timer {
+  #private;
+  protected readonly options: TimerOptions;
+  private readonly $timer;
+  protected readonly state: TimerState;
+  /**
+   * Is the timer active?
+   */
+  get active(): boolean;
+  /**
+   * Is the timer destroyed?
+   */
+  get destroyed(): boolean;
+  /**
+   * Is the timer paused?
+   */
+  get paused(): boolean;
+  /**
+   * Get the timer's origin _(if debugging is enabled)_
+   */
+  get trace(): string | undefined;
+  constructor(type: TimerType, state: Pick<TimerState, 'callback' | 'trace'>, options: TimerOptions, start: boolean);
+  /**
+   * Continue running the timer _(if it's paused)_
+   */
+  continue(): Timer;
+  /**
+   * Destroy the timer
+   */
+  destroy(): void;
+  /**
+   * Pause the timer _(if it's running)_
+   */
+  pause(): Timer;
+  /**
+   * Restart the timer _(or start it, if it's not running)_
+   */
+  restart(): Timer;
+  /**
+   * Start the timer _(if it's not running)_
+   */
+  start(): Timer;
+  /**
+   * Stop the timer _(if it's running)_
+   */
+  stop(): Timer;
+}
+//#endregion
+export { Timer };

package/dist/{timer.js → timer.mjs}

@@ -1,6 +1,7 @@
-import { WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.js";
-import { stop, work } from "./work.js";
+import { WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.mjs";
+import { stop, work } from "./work.mjs";
 import { noop } from "@oscarpalmer/atoms/function";
+//#region src/timer.ts
 var Timer = class {
 	state;
 	/**
@@ -93,4 +94,5 @@ var Timer = class {
 		}, this.state, this.options);
 	}
 };
+//#endregion
 export { Timer };

package/{types/wait.d.ts → dist/wait.d.mts}

@@ -1,9 +1,11 @@
-import './global';
-import { Timer } from './timer';
+import { Timer } from "./timer.mjs";
+//#region src/wait.d.ts
 /**
  * Create a waiting timer
+ *
  * @param callback Callback to run when the timer has finished
  * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
  */
-export declare function wait(callback: () => void, time?: number): Timer;
-export type { Timer };
+declare function wait(callback: () => void, time?: number): Timer;
+//#endregion
+export { type Timer, wait };

package/dist/{wait.js → wait.mjs}

@@ -1,10 +1,12 @@
-import { TYPE_WAIT } from "./constants.js";
-import { getCallback, getValidNumber } from "./get.js";
-import "./global.js";
-import { TimerTrace } from "./models.js";
-import { Timer } from "./timer.js";
+import { TYPE_WAIT } from "./constants.mjs";
+import { getCallback, getValidNumber } from "./get.mjs";
+import "./global.mjs";
+import { TimerTrace } from "./models.mjs";
+import { Timer } from "./timer.mjs";
+//#region src/wait.ts
 /**
 * Create a waiting timer
+*
 * @param callback Callback to run when the timer has finished
 * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
 */
@@ -20,4 +22,5 @@ function wait(callback, time) {
 		timeout: 0
 	}, true);
 }
+//#endregion
 export { wait };

package/dist/when.d.mts

@@ -0,0 +1,55 @@
+import { WhenOptions } from "./models.mjs";
+//#region src/when.d.ts
+declare class When {
+  private readonly $timer;
+  private readonly state;
+  /**
+   * Is the timer active?
+   */
+  get active(): boolean;
+  /**
+   * Is the timer destroyed?
+   */
+  get destroyed(): boolean;
+  /**
+   * Is the timer paused?
+   */
+  get paused(): boolean;
+  /**
+   * Get the timer's origin _(if debugging is enabled)_
+   */
+  get trace(): string | undefined;
+  constructor(condition: () => boolean, options?: Partial<WhenOptions>);
+  /**
+   * Continues the timer _(if it was paused)_
+   */
+  continue(): When;
+  /**
+   * Destroys the timer _(and stops it,if it was running)_
+   */
+  destroy(): void;
+  /**
+   * Pauses the timer _(if it was running)_
+   */
+  pause(): When;
+  /**
+   * Start the timer
+   *
+   * @param resolve Optional resolve callback
+   * @returns Promise that resolves when the condition is met
+   */
+  start(resolve?: (() => void) | null): Promise<void>;
+  /**
+   * Stops the timer _(if it was running)_
+   */
+  stop(): When;
+}
+/**
+ * Create a conditional timer
+ * @param condition Condition to check
+ * @param options Timer options
+ * @returns Timer instance
+ */
+declare function when(condition: () => boolean, options?: Partial<WhenOptions>): When;
+//#endregion
+export { type When, when };

package/dist/{when.js → when.mjs}

@@ -1,9 +1,10 @@
-import { MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN } from "./constants.js";
-import { getValidNumber, getValidTimeout } from "./get.js";
-import "./global.js";
-import { TimerTrace } from "./models.js";
-import { Timer } from "./timer.js";
+import { MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN } from "./constants.mjs";
+import { getValidNumber, getValidTimeout } from "./get.mjs";
+import "./global.mjs";
+import { TimerTrace } from "./models.mjs";
+import { Timer } from "./timer.mjs";
 import { noop } from "@oscarpalmer/atoms/function";
+//#region src/when.ts
 var When = class {
 	state = {
 		promise: void 0,
@@ -98,17 +99,17 @@ var When = class {
 	}
 	/**
 	* Start the timer
+	*
 	* @param resolve Optional resolve callback
-	* @param reject Optional reject callback
 	* @returns Promise that resolves when the condition is met
 	*/
-	start(resolve, reject) {
+	start(resolve) {
 		const { state } = this;
 		if (state.timer == null) throw new Error(MESSAGE_DESTROYED);
 		if (state.started) throw new Error(MESSAGE_STARTED);
 		state.started = true;
 		state.timer.start();
-		return state.promise.then(resolve ?? noop, reject ?? noop);
+		return state.promise.then(resolve);
 	}
 	/**
 	* Stops the timer _(if it was running)_
@@ -117,16 +118,6 @@ var When = class {
 		this.state.timer?.stop();
 		return this;
 	}
-	/**
-	* Start the timer
-	* @deprecated Use `start()` instead
-	* @param resolve Optional resolve callback
-	* @param reject Optional reject callback
-	* @returns Promise that resolves when the condition is met
-	*/
-	then(resolve, reject) {
-		return this.start(resolve, reject);
-	}
 };
 /**
 * Create a conditional timer
@@ -137,4 +128,5 @@ var When = class {
 function when(condition, options) {
 	return new When(condition, options);
 }
+//#endregion
 export { when };

package/dist/work.d.mts

@@ -0,0 +1,8 @@
+import { Timer } from "./timer.mjs";
+import { TimerOptions, TimerState, WorkHandlerTimer, WorkHandlerType } from "./models.mjs";
+
+//#region src/work.d.ts
+declare function stop(timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): Timer;
+declare function work(type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): Timer;
+//#endregion
+export { stop, work };

package/dist/{work.js → work.mjs}

@@ -1,4 +1,5 @@
-import { TIMERS_ACTIVE, WORK_PAUSE, WORK_STOP } from "./constants.js";
+import { TIMERS_ACTIVE, WORK_PAUSE, WORK_STOP } from "./constants.mjs";
+//#region src/work.ts
 function finish(timer, state, options, success) {
 	cancelAnimationFrame(state.frame);
 	TIMERS_ACTIVE.delete(timer.instance);
@@ -78,4 +79,5 @@ function work(type, timer, state, options) {
 	state.frame = requestAnimationFrame(runner);
 	return timer.instance;
 }
+//#endregion
 export { stop, work };

package/package.json

@@ -1,75 +1,73 @@
 {
+	"name": "@oscarpalmer/timer",
+	"version": "0.43.0",
+	"description": "A better solution for timeout- and interval-based timers.",
+	"keywords": [
+		"requestAnimationFrame",
+		"setInterval",
+		"setTimeout",
+		"timer"
+	],
+	"license": "MIT",
 	"author": {
 		"name": "Oscar Palmér",
 		"url": "https://oscarpalmer.se"
 	},
-	"dependencies": {
-		"@oscarpalmer/atoms": "^0.152"
-	},
-	"description": "A better solution for timeout- and interval-based timers.",
-	"devDependencies": {
-		"@types/node": "^25.3",
-		"@vitest/coverage-istanbul": "^4",
-		"dts-bundle-generator": "^9.5",
-		"jsdom": "^28.1",
-		"oxfmt": "^0.36",
-		"oxlint": "^1.51",
-		"rolldown": "1.0.0-rc.6",
-		"tslib": "^2.8",
-		"typescript": "^5.9",
-		"vite": "8.0.0-beta.16",
-		"vitest": "^4"
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/oscarpalmer/timer.git"
 	},
+	"files": [
+		"dist",
+		"src"
+	],
+	"type": "module",
+	"module": "dist/index.mjs",
+	"types": "dist/index.d.mts",
 	"exports": {
 		"./package.json": "./package.json",
 		".": {
-			"types": "./types/index.d.ts",
-			"default": "./dist/index.js"
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
 		},
 		"./delay": {
-			"types": "./types/delay.d.ts",
-			"default": "./dist/delay.js"
+			"types": "./dist/delay.d.mts",
+			"default": "./dist/delay.mjs"
 		},
 		"./repeat": {
-			"types": "./types/repeat.d.ts",
-			"default": "./dist/repeat.js"
+			"types": "./dist/repeat.d.mts",
+			"default": "./dist/repeat.mjs"
 		},
 		"./wait": {
-			"types": "./types/wait.d.ts",
-			"default": "./dist/wait.js"
+			"types": "./dist/wait.d.mts",
+			"default": "./dist/wait.mjs"
 		},
 		"./when": {
-			"types": "./types/when.d.ts",
-			"default": "./dist/when.js"
+			"types": "./dist/when.d.mts",
+			"default": "./dist/when.mjs"
 		}
 	},
-	"files": [
-		"dist",
-		"src",
-		"types"
-	],
-	"keywords": [
-		"requestAnimationFrame",
-		"setInterval",
-		"setTimeout",
-		"timer"
-	],
-	"license": "MIT",
-	"module": "dist/index.js",
-	"name": "@oscarpalmer/timer",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/oscarpalmer/timer.git"
-	},
 	"scripts": {
-		"build": "npm run clean && npx vite build && npm run rolldown:build && npx tsc && npx dts-bundle-generator --config ./dts.config.ts --silent",
-		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
-		"rolldown:build": "npx rolldown -c",
-		"rolldown:watch": "npx rolldown -c ./rolldown.config.js --watch",
-		"test": "npx vitest --coverage",
+		"build": "npx vp pack && npm run tsdown:build",
+		"tsdown:build": "npx tsdown -c ./tsdown.config.ts",
+		"tsdown:watch": "npx tsdown -c ./tsdown.config.ts --watch",
+		"test": "npx vp test run --coverage",
+		"test:leak": "npx vp test run --detect-async-leaks --coverage",
 		"watch": "npx vite build --watch"
 	},
-	"type": "module",
-	"types": "types/index.d.ts",
-	"version": "0.41.4"
+	"dependencies": {
+		"@oscarpalmer/atoms": "^0.187"
+	},
+	"devDependencies": {
+		"@oxlint/plugins": "^1.66",
+		"@types/node": "^25.9",
+		"@vitest/coverage-istanbul": "^4.1",
+		"jsdom": "^29.1",
+		"tsdown": "^0.22",
+		"typescript": "^6",
+		"vite": "npm:@voidzero-dev/vite-plus-core@latest",
+		"vite-plus": "latest",
+		"vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+	},
+	"packageManager": "npm@11.11.1"
 }

package/src/delay.ts

@@ -1 +1,2 @@
-export {delay, type PromiseOptions} from '@oscarpalmer/atoms/promise';
+export {delay} from '@oscarpalmer/atoms/promise/delay';
+export type {PromiseOptions} from '@oscarpalmer/atoms/promise/models';

package/src/get.ts

@@ -1,4 +1,4 @@
-import type {GenericCallback} from '@oscarpalmer/atoms';
+import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {noop} from '@oscarpalmer/atoms/function';
 import {DEFAULT_TIMEOUT} from './constants';
 

package/src/is.ts

@@ -1,4 +1,4 @@
-import type {PlainObject} from '@oscarpalmer/atoms';
+import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN} from './constants';
 import type {Timer} from './timer';
 import type {When} from './when';
@@ -40,5 +40,5 @@ export function isWaited(value: unknown): value is Timer {
  * @returns `true` if the value is a conditional timer
  */
 export function isWhen(value: unknown): value is When {
-	return is([TYPE_WHEN], value) && typeof (value as When).then === 'function';
+	return is([TYPE_WHEN], value) && typeof (value as When).start === 'function';
 }

package/src/repeat.ts

@@ -6,6 +6,7 @@ import {Timer} from './timer';
 
 /**
  * Create a repeating timer
+ *
  * @param callback Callback to run on each interval
  * @param options Timer options
  * @returns Timer instance

package/src/wait.ts

@@ -6,6 +6,7 @@ import {Timer} from './timer';
 
 /**
  * Create a waiting timer
+ *
  * @param callback Callback to run when the timer has finished
  * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
  */

package/src/when.ts

@@ -131,11 +131,11 @@ class When {
 
 	/**
 	 * Start the timer
+	 *
 	 * @param resolve Optional resolve callback
-	 * @param reject Optional reject callback
 	 * @returns Promise that resolves when the condition is met
 	 */
-	start(resolve?: (() => void) | null, reject?: (() => void) | null): Promise<void> {
+	start(resolve?: (() => void) | null): Promise<void> {
 		const {state} = this;
 
 		if (state.timer == null) {
@@ -150,7 +150,7 @@ class When {
 
 		state.timer.start();
 
-		return state.promise.then(resolve ?? noop, reject ?? noop);
+		return state.promise.then(resolve);
 	}
 
 	/**
@@ -161,18 +161,6 @@ class When {
 
 		return this;
 	}
-
-	/**
-	 * Start the timer
-	 * @deprecated Use `start()` instead
-	 * @param resolve Optional resolve callback
-	 * @param reject Optional reject callback
-	 * @returns Promise that resolves when the condition is met
-	 */
-	// oxlint-disable-next-line no-thenable: Returning a promise-like object, so it's ok ;)
-	then(resolve?: (() => void) | null, reject?: (() => void) | null): Promise<void> {
-		return this.start(resolve, reject);
-	}
 }
 
 /**

package/dist/delay.js

@@ -1,2 +0,0 @@
-import { delay } from "@oscarpalmer/atoms/promise";
-export { delay };

package/dist/index.js

@@ -1,7 +0,0 @@
-import { delay } from "./delay.js";
-import "./global.js";
-import { isRepeated, isTimer, isWaited, isWhen } from "./is.js";
-import { repeat } from "./repeat.js";
-import { wait } from "./wait.js";
-import { when } from "./when.js";
-export { delay, isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };