@oscarpalmer/timer 0.42.0 → 0.44.0

package/dist/timer.d.mts

@@ -1,52 +1,5 @@
-import { TimerOptions, TimerState, TimerType } from "./models.mjs";
-
+import { Timer, TimerName, TimerOptions, TimerState } 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;
-}
+declare function createTimer(name: TimerName, pick: Pick<TimerState, 'callback' | 'trace'>, options: TimerOptions, start: boolean): Timer;
 //#endregion
-export { Timer };
+export { createTimer };

package/dist/timer.mjs

@@ -2,97 +2,66 @@ import { WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "
 import { stop, work } from "./work.mjs";
 import { noop } from "@oscarpalmer/atoms/function";
 //#region src/timer.ts
-var Timer = class {
-	state;
-	/**
-	* Is the timer active?
-	*/
-	get active() {
-		return this.state.active;
-	}
-	/**
-	* Is the timer destroyed?
-	*/
-	get destroyed() {
-		return this.state.destroyed;
-	}
-	/**
-	* Is the timer paused?
-	*/
-	get paused() {
-		return this.state.paused;
-	}
-	/**
-	* Get the timer's origin _(if debugging is enabled)_
-	*/
-	get trace() {
-		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.trace : void 0;
-	}
-	constructor(type, state, options, start) {
-		this.options = options;
-		Object.defineProperty(this, "$timer", { value: type });
-		this.state = {
-			...state,
-			active: false,
-			destroyed: false,
-			elapsed: 0,
-			frame: void 0,
-			index: 0,
-			paused: false,
-			total: 0
-		};
-		if (start) this.start();
-	}
-	/**
-	* Continue running the timer _(if it's paused)_
-	*/
-	continue() {
-		return this.#work(WORK_CONTINUE);
-	}
-	/**
-	* Destroy the timer
-	*/
-	destroy() {
-		this.state.destroyed = true;
-		this.options.onAfter = noop;
-		this.options.onError = noop;
-		this.state.callback = noop;
-		if (!globalThis._oscarpalmer_timer_debug) this.state.trace = void 0;
-		stop({
-			instance: this,
-			type: this.$timer
-		}, this.state, this.options);
-	}
-	/**
-	* Pause the timer _(if it's running)_
-	*/
-	pause() {
-		return this.#work(WORK_PAUSE);
-	}
-	/**
-	* Restart the timer _(or start it, if it's not running)_
-	*/
-	restart() {
-		return this.#work(WORK_RESTART);
-	}
-	/**
-	* Start the timer _(if it's not running)_
-	*/
-	start() {
-		return this.#work(WORK_START);
-	}
-	/**
-	* Stop the timer _(if it's running)_
-	*/
-	stop() {
-		return this.#work(WORK_STOP);
-	}
-	#work(type) {
+function createTimer(name, pick, options, start) {
+	function worker(type) {
 		return work(type, {
-			instance: this,
-			type: this.$timer
-		}, this.state, this.options);
+			name,
+			instance
+		}, state, options);
 	}
-};
+	const state = {
+		...pick,
+		active: false,
+		destroyed: false,
+		elapsed: 0,
+		frame: void 0,
+		index: 0,
+		paused: false,
+		total: 0
+	};
+	const instance = {
+		continue: () => worker(WORK_CONTINUE),
+		destroy: () => destroyTimer(name, instance, state, options),
+		pause: () => worker(WORK_PAUSE),
+		restart: () => worker(WORK_RESTART),
+		start: () => worker(WORK_START),
+		stop: () => worker(WORK_STOP)
+	};
+	Object.defineProperties(instance, {
+		$timer: {
+			enumerable: false,
+			value: name
+		},
+		active: {
+			enumerable: true,
+			get: () => state.active
+		},
+		destroyed: {
+			enumerable: true,
+			get: () => state.destroyed
+		},
+		paused: {
+			enumerable: true,
+			get: () => state.paused
+		},
+		trace: {
+			enumerable: true,
+			get: () => globalThis._oscarpalmer_timer_debug ?? false ? state.trace : void 0
+		}
+	});
+	if (start) instance.start();
+	return Object.freeze(instance);
+}
+function destroyTimer(name, instance, state, options) {
+	state.destroyed = true;
+	options.onAfter = noop;
+	options.onError = noop;
+	state.callback = noop;
+	if (!globalThis._oscarpalmer_timer_debug) state.trace = void 0;
+	stop({
+		instance,
+		name
+	}, state, options);
+}
 //#endregion
-export { Timer };
+export { createTimer };

package/dist/wait.d.mts

@@ -1,10 +1,12 @@
-import { Timer } from "./timer.mjs";
+import { Timer } from "./models.mjs";
+import "./global.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)_
  */
 declare function wait(callback: () => void, time?: number): Timer;
 //#endregion
-export { type Timer, wait };
+export { wait };

package/dist/wait.mjs

@@ -2,15 +2,16 @@ 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";
+import { createTimer } 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)_
 */
 function wait(callback, time) {
-	return new Timer(TYPE_WAIT, {
+	return createTimer(TYPE_WAIT, {
 		callback: getCallback(callback),
 		trace: new TimerTrace().stack
 	}, {

package/dist/when.d.mts

@@ -1,57 +1,6 @@
-import { WhenOptions } from "./models.mjs";
+import { When, WhenOptions } from "./models.mjs";
+import "./global.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
-   * @param reject Optional reject callback
-   * @returns Promise that resolves when the condition is met
-   */
-  start(resolve?: (() => void) | null, reject?: (() => void) | null): Promise<void>;
-  /**
-   * Stops the timer _(if it was running)_
-   */
-  stop(): When;
-  /**
-   * 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?: (() => void) | null, reject?: (() => void) | null): Promise<void>;
-}
 /**
  * Create a conditional timer
  * @param condition Condition to check
@@ -60,4 +9,4 @@ declare class When {
  */
 declare function when(condition: () => boolean, options?: Partial<WhenOptions>): When;
 //#endregion
-export { type When, when };
+export { when };

package/dist/when.mjs

@@ -1,134 +1,47 @@
-import { MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN } from "./constants.mjs";
+import { MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN, WORK_CONTINUE } from "./constants.mjs";
 import { getValidNumber, getValidTimeout } from "./get.mjs";
 import "./global.mjs";
 import { TimerTrace } from "./models.mjs";
-import { Timer } from "./timer.mjs";
+import { createTimer } from "./timer.mjs";
 import { noop } from "@oscarpalmer/atoms/function";
 //#region src/when.ts
-var When = class {
-	state = {
-		promise: void 0,
-		rejecter: void 0,
-		resolver: void 0,
-		started: false,
-		timer: void 0
-	};
-	/**
-	* Is the timer active?
-	*/
-	get active() {
-		return this.state.timer?.active ?? false;
-	}
-	/**
-	* Is the timer destroyed?
-	*/
-	get destroyed() {
-		return this.state.timer == null;
-	}
-	/**
-	* Is the timer paused?
-	*/
-	get paused() {
-		return this.state.timer?.paused ?? false;
-	}
-	/**
-	* Get the timer's origin _(if debugging is enabled)_
-	*/
-	get trace() {
-		return globalThis._oscarpalmer_timer_debug ?? false ? this.state.timer?.trace : void 0;
-	}
-	constructor(condition, options) {
-		Object.defineProperty(this, "$timer", { value: TYPE_WHEN });
-		const { state } = this;
-		state.promise = new Promise((resolve, reject) => {
-			state.resolver = resolve;
-			state.rejecter = reject;
-		});
-		let result = false;
-		this.state.timer = new Timer(TYPE_WHEN, {
-			callback() {
-				try {
-					if (condition()) {
-						result = true;
-						state.timer.stop();
-					}
-				} catch {
-					state.timer.stop();
-				}
-			},
-			trace: new TimerTrace().stack
-		}, {
-			onAfter: () => {
-				if (result) state.resolver?.();
-				else state.rejecter?.();
-				this.destroy();
-			},
-			onError: () => {
-				state.rejecter?.();
-				this.destroy();
-			},
-			count: getValidNumber(options?.count),
-			interval: getValidNumber(options?.interval),
-			timeout: getValidTimeout(options?.timeout)
-		}, false);
-	}
-	/**
-	* 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() {
-		const { state } = this;
-		state.timer?.destroy();
-		state.promise = void 0;
-		state.resolver = noop;
-		state.rejecter = noop;
-		state.timer = void 0;
-	}
-	/**
-	* Pauses the timer _(if it was running)_
-	*/
-	pause() {
-		this.state.timer?.pause();
-		return this;
-	}
-	/**
-	* 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) {
-		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);
-	}
-	/**
-	* Stops the timer _(if it was running)_
-	*/
-	stop() {
-		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);
+function destroyWhen(state) {
+	state.timer?.destroy();
+	state.promise = void 0;
+	state.resolver = noop;
+	state.rejecter = noop;
+	state.timer = void 0;
+}
+function onAfter(instance, state) {
+	if (state.result) state.resolver?.();
+	else state.rejecter?.();
+	instance.destroy();
+}
+function onCallback(condition, state) {
+	try {
+		if (condition()) {
+			state.result = true;
+			state.timer.stop();
+		}
+	} catch {
+		state.timer.stop();
 	}
-};
+}
+function onError(instance, state) {
+	state.rejecter?.();
+	instance.destroy();
+}
+function onWhen(type, instance, state) {
+	state.timer?.[type]?.();
+	return instance;
+}
+function startWhen(state, resolve) {
+	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);
+}
 /**
 * Create a conditional timer
 * @param condition Condition to check
@@ -136,7 +49,57 @@ var When = class {
 * @returns Timer instance
 */
 function when(condition, options) {
-	return new When(condition, options);
+	const state = {
+		promise: void 0,
+		result: false,
+		started: false,
+		timer: void 0
+	};
+	let instance;
+	state.promise = new Promise((resolve, reject) => {
+		state.resolver = resolve;
+		state.rejecter = reject;
+	});
+	state.timer = createTimer(TYPE_WHEN, {
+		callback: () => onCallback(condition, state),
+		trace: new TimerTrace().stack
+	}, {
+		onAfter: () => onAfter(instance, state),
+		onError: () => onError(instance, state),
+		count: getValidNumber(options?.count),
+		interval: getValidNumber(options?.interval),
+		timeout: getValidTimeout(options?.timeout)
+	}, false);
+	instance = {
+		continue: () => onWhen(WORK_CONTINUE, instance, state),
+		destroy: () => destroyWhen(state),
+		pause: () => onWhen("pause", instance, state),
+		start: (resolve) => startWhen(state, resolve),
+		stop: () => onWhen("stop", instance, state)
+	};
+	Object.defineProperties(instance, {
+		$timer: {
+			enumerable: false,
+			value: TYPE_WHEN
+		},
+		active: {
+			enumerable: true,
+			get: () => state.timer?.active ?? false
+		},
+		destroyed: {
+			enumerable: true,
+			get: () => state.timer == null
+		},
+		paused: {
+			enumerable: true,
+			get: () => state.timer?.paused ?? false
+		},
+		trace: {
+			enumerable: true,
+			get: () => globalThis._oscarpalmer_timer_debug ?? false ? state.timer?.trace : void 0
+		}
+	});
+	return Object.freeze(instance);
 }
 //#endregion
 export { when };

package/dist/work.d.mts

@@ -1,6 +1,4 @@
-import { Timer } from "./timer.mjs";
-import { TimerOptions, TimerState, WorkHandlerTimer, WorkHandlerType } from "./models.mjs";
-
+import { Timer, 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;

package/dist/work.mjs

@@ -6,7 +6,7 @@ function finish(timer, state, options, success) {
 	state.active = false;
 	state.elapsed = 0;
 	state.frame = void 0;
-	if (timer.type === "wait") state.callback();
+	if (timer.name === "wait") state.callback();
 	else options.onAfter?.(success);
 }
 function ignore(type, state) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/timer",
-	"version": "0.42.0",
+	"version": "0.44.0",
 	"description": "A better solution for timeout- and interval-based timers.",
 	"keywords": [
 		"requestAnimationFrame",
@@ -34,6 +34,10 @@
 			"types": "./dist/delay.d.mts",
 			"default": "./dist/delay.mjs"
 		},
+		"./models": {
+			"types": "./dist/models.d.mts",
+			"default": "./dist/models.mjs"
+		},
 		"./repeat": {
 			"types": "./dist/repeat.d.mts",
 			"default": "./dist/repeat.mjs"
@@ -56,14 +60,15 @@
 		"watch": "npx vite build --watch"
 	},
 	"dependencies": {
-		"@oscarpalmer/atoms": "^0.165"
+		"@oscarpalmer/atoms": "^0.193"
 	},
 	"devDependencies": {
-		"@types/node": "^25.5",
+		"@oxlint/plugins": "^1.80",
+		"@types/node": "^26.3",
 		"@vitest/coverage-istanbul": "^4.1",
-		"jsdom": "^28.1",
-		"tsdown": "^0.21",
-		"typescript": "^5.9",
+		"jsdom": "^30",
+		"tsdown": "^0.22",
+		"typescript": "^6",
 		"vite": "npm:@voidzero-dev/vite-plus-core@latest",
 		"vite-plus": "latest",
 		"vitest": "npm:@voidzero-dev/vite-plus-test@latest"

package/src/constants.ts

@@ -1,5 +1,4 @@
-import type {TimerType, WorkHandlerType} from './models';
-import type {Timer} from './timer';
+import type {Timer, TimerName, WorkHandlerType} from './models';
 
 /**
  * Buffer value to use when evaluating if a specific time is within a certain range
@@ -28,11 +27,11 @@ export const TIMERS_ACTIVE = new Set<Timer>();
  */
 export const TIMERS_HIDDEN = new Set<Timer>();
 
-export const TYPE_REPEAT: TimerType = 'repeat';
+export const TYPE_REPEAT: TimerName = 'repeat';
 
-export const TYPE_WAIT: TimerType = 'wait';
+export const TYPE_WAIT: TimerName = 'wait';
 
-export const TYPE_WHEN: TimerType = 'when';
+export const TYPE_WHEN: TimerName = 'when';
 
 export const WORK_CONTINUE: WorkHandlerType = 'continue';
 

package/src/delay.ts

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

package/src/get.ts

@@ -1,5 +1,5 @@
-import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {noop} from '@oscarpalmer/atoms/function';
+import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {DEFAULT_TIMEOUT} from './constants';
 
 export function getCallback(value: unknown): GenericCallback {

package/src/global.ts

@@ -1,5 +1,5 @@
 import {TIMERS_ACTIVE, TIMERS_HIDDEN, WORK_CONTINUE, WORK_PAUSE} from './constants';
-import type {Timer} from './timer';
+import type {Timer} from './models';
 
 declare global {
 	var _oscarpalmer_timer_debug: boolean | undefined;

package/src/index.ts

@@ -1,8 +1,8 @@
 import './global';
 
-export * from './delay';
+export {delay} from './delay';
 export {isRepeated, isTimer, isWaited, isWhen} from './is';
-export * from './repeat';
-export type {Timer} from './timer';
-export * from './wait';
-export * from './when';
+export type {RepeatOptions, Timer, TimerOptions, When, WhenOptions} from './models';
+export {repeat} from './repeat';
+export {wait} from './wait';
+export {when} from './when';

package/src/is.ts

@@ -1,7 +1,6 @@
 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';
+import type {Timer, When} from './models';
 
 function is(names: string[], value: unknown) {
 	return names.includes((value as PlainObject)?.$timer as string);
@@ -40,5 +39,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';
 }