@oscarpalmer/timer 0.44.0 → 0.46.0

package/src/when.ts

@@ -1,6 +1,6 @@
 import {noop} from '@oscarpalmer/atoms/function';
-import {MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN, WORK_CONTINUE} from './constants';
-import {getValidNumber, getValidTimeout} from './get';
+import {MESSAGE_STARTED, TYPE_WHEN, WORK_CONTINUE, WORK_PAUSE, WORK_STOP} from './constants';
+import {getValidNumber, getValidTimeout} from './misc';
 import './global';
 import {
 	TimerTrace,
@@ -11,23 +11,12 @@ import {
 } from './models';
 import {createTimer} from './timer';
 
-function destroyWhen(state: WhenState): void {
-	state.timer?.destroy();
-
-	state.promise = undefined as never;
-	state.resolver = noop;
-	state.rejecter = noop;
-	state.timer = undefined as never;
-}
-
-function onAfter(instance: When, state: WhenState): void {
+function onAfter(state: WhenState): void {
 	if (state.result) {
 		state.resolver?.();
 	} else {
 		state.rejecter?.();
 	}
-
-	instance.destroy();
 }
 
 function onCallback(condition: () => boolean, state: WhenState): void {
@@ -42,12 +31,6 @@ function onCallback(condition: () => boolean, state: WhenState): void {
 	}
 }
 
-function onError(instance: When, state: WhenState): void {
-	state.rejecter?.();
-
-	instance.destroy();
-}
-
 function onWhen(type: WorkHandlerType, instance: When, state: WhenState): When {
 	state.timer?.[type]?.();
 
@@ -55,10 +38,6 @@ function onWhen(type: WorkHandlerType, instance: When, state: WhenState): When {
 }
 
 function startWhen(state: WhenState, resolve?: (() => void) | null): Promise<void> {
-	if (state.timer == null) {
-		throw new Error(MESSAGE_DESTROYED);
-	}
-
 	if (state.started) {
 		throw new Error(MESSAGE_STARTED);
 	}
@@ -98,8 +77,8 @@ export function when(condition: () => boolean, options?: Partial<WhenOptions>):
 			trace: new TimerTrace().stack,
 		},
 		{
-			onAfter: () => onAfter(instance, state),
-			onError: () => onError(instance, state),
+			onAfter: () => onAfter(state),
+			onError: () => state.rejecter?.(),
 			count: getValidNumber(options?.count),
 			interval: getValidNumber(options?.interval),
 			timeout: getValidTimeout(options?.timeout),
@@ -109,10 +88,10 @@ export function when(condition: () => boolean, options?: Partial<WhenOptions>):
 
 	instance = {
 		continue: () => onWhen(WORK_CONTINUE, instance, state),
-		destroy: () => destroyWhen(state),
-		pause: () => onWhen('pause', instance, state),
-		start: (resolve?: (() => void) | null) => startWhen(state, resolve),
-		stop: () => onWhen('stop', instance, state),
+		destroy: noop,
+		pause: () => onWhen(WORK_PAUSE, instance, state),
+		start: (resolve: never) => startWhen(state, resolve),
+		stop: () => onWhen(WORK_STOP, instance, state),
 	} as When;
 
 	Object.defineProperties(instance, {
@@ -122,15 +101,15 @@ export function when(condition: () => boolean, options?: Partial<WhenOptions>):
 		},
 		active: {
 			enumerable: true,
-			get: () => state.timer?.active ?? false,
+			get: () => state.timer.active,
 		},
 		destroyed: {
 			enumerable: true,
-			get: () => state.timer == null,
+			value: false,
 		},
 		paused: {
 			enumerable: true,
-			get: () => state.timer?.paused ?? false,
+			get: () => state.timer.paused,
 		},
 		trace: {
 			enumerable: true,

package/src/work.ts

@@ -1,6 +1,5 @@
 import {
 	BUFFER_INTERVAL,
-	TIMERS_ACTIVE,
 	TYPE_WAIT,
 	WORK_CONTINUE,
 	WORK_PAUSE,
@@ -8,56 +7,35 @@ import {
 	WORK_START,
 	WORK_STOP,
 } from './constants';
-import type {Timer, TimerOptions, TimerState, WorkHandlerTimer, WorkHandlerType} from './models';
-
-function finish(
-	timer: WorkHandlerTimer,
-	state: TimerState,
-	options: TimerOptions,
-	success: boolean,
-): void {
-	cancelAnimationFrame(state.frame as never);
+import {updateStates} from './misc';
+import type {Timer, TimerState, WorkHandlerType} from './models';
+
+function finish(state: TimerState, success: boolean): void {
+	updateStates(state);
 
-	TIMERS_ACTIVE.delete(timer.instance);
+	cancelAnimationFrame(state.frame as never);
 
 	state.active = false;
 	state.elapsed = 0;
 	state.frame = undefined;
 
-	if (timer.name === TYPE_WAIT) {
+	if (state.name === TYPE_WAIT) {
 		state.callback();
 	} else {
-		options.onAfter?.(success);
+		state.options.onAfter?.(success);
 	}
 }
 
 function ignore(type: WorkHandlerType, state: TimerState): boolean {
-	if (state.destroyed) {
-		return type !== WORK_STOP;
-	}
-
 	if (state.paused) {
 		return type === WORK_PAUSE || type === WORK_START;
 	}
 
-	return state.active && type === WORK_START;
+	return state.active && (type === WORK_CONTINUE || type === WORK_START);
 }
 
-function pause(timer: WorkHandlerTimer, state: TimerState): Timer {
-	cancelAnimationFrame(state.frame as never);
-
-	state.frame = undefined;
-
-	return timer.instance;
-}
-
-function run(
-	timer: WorkHandlerTimer,
-	state: TimerState,
-	options: TimerOptions,
-): (now: DOMHighResTimeStamp) => void {
+function run(state: TimerState): (now: DOMHighResTimeStamp) => void {
 	let last: DOMHighResTimeStamp | undefined;
-	let start: DOMHighResTimeStamp | undefined;
 
 	return function step(now: DOMHighResTimeStamp): void {
 		if (!state.active) {
@@ -65,7 +43,6 @@ function run(
 		}
 
 		last ??= now;
-		start ??= now;
 
 		const difference = now - last;
 
@@ -74,26 +51,27 @@ function run(
 
 		last = now;
 
-		if (options.timeout > 0 && state.total >= options.timeout) {
-			options.onError?.();
+		if (state.options.timeout > 0 && state.total >= state.options.timeout) {
+			state.options.onError?.();
 
-			finish(timer, state, options, false);
+			finish(state, false);
 
 			return;
 		}
 
-		if (options.interval === 0 || state.elapsed >= options.interval - BUFFER_INTERVAL) {
-			if (options.count > -1) {
+		if (state.options.interval === 0 || state.elapsed >= state.options.interval - BUFFER_INTERVAL) {
+			if (state.options.count > -1) {
 				(state.callback as (index: number) => void)(state.index);
 			}
 
-			start = now;
-
 			state.elapsed = 0;
 			state.index += 1;
 
-			if (options.count === -1 || (options.count > 0 && state.index >= options.count)) {
-				finish(timer, state, options, true);
+			if (
+				state.options.count === -1 ||
+				(state.options.count > 0 && state.index >= state.options.count)
+			) {
+				finish(state, true);
 
 				return;
 			}
@@ -111,34 +89,29 @@ function setState(type: WorkHandlerType, state: TimerState): void {
 	state.total = pausable ? state.total : 0;
 }
 
-export function stop(timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): Timer {
-	cancelAnimationFrame(state.frame as never);
+export function stop(state: TimerState): Timer {
+	updateStates(state);
 
-	TIMERS_ACTIVE.delete(timer.instance);
+	cancelAnimationFrame(state.frame as never);
 
-	options.onAfter?.(false);
+	state.options.onAfter?.(false);
 
-	state.active = !stop;
+	state.active = false;
 	state.frame = undefined;
 	state.paused = false;
 
-	return timer.instance;
+	return state.timer;
 }
 
-export function work(
-	type: WorkHandlerType,
-	timer: WorkHandlerTimer,
-	state: TimerState,
-	options: TimerOptions,
-): Timer {
+export function work(type: WorkHandlerType, state: TimerState, hide?: boolean): Timer {
 	if (ignore(type, state)) {
-		return timer.instance;
+		return state.timer;
 	}
 
 	setState(type, state);
 
 	if (type === WORK_STOP) {
-		return stop(timer, state, options);
+		return stop(state);
 	}
 
 	if (type === WORK_PAUSE || type === WORK_RESTART) {
@@ -150,15 +123,15 @@ export function work(
 	state.active = true;
 	state.paused = type === WORK_PAUSE;
 
+	updateStates(state, state.paused ? hide : false);
+
 	if (state.paused) {
-		return pause(timer, state);
+		return state.timer;
 	}
 
-	TIMERS_ACTIVE.add(timer.instance);
-
-	const runner = run(timer, state, options);
+	const runner = run(state);
 
 	state.frame = requestAnimationFrame(runner);
 
-	return timer.instance;
+	return state.timer;
 }

package/dist/delay.d.mts

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

package/dist/delay.mjs

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

package/dist/get.mjs

@@ -1,15 +0,0 @@
-import { DEFAULT_TIMEOUT } from "./constants.mjs";
-import { noop } from "@oscarpalmer/atoms/function";
-//#region src/get.ts
-function getCallback(value) {
-	return typeof value === "function" ? value : noop;
-}
-function getValidTimeout(value) {
-	return typeof value === "number" && value > 0 ? value : DEFAULT_TIMEOUT;
-}
-function getValidNumber(value, defaultValue) {
-	const actualDefault = defaultValue ?? 0;
-	return typeof value === "number" && value > actualDefault ? value : actualDefault;
-}
-//#endregion
-export { getCallback, getValidNumber, getValidTimeout };

package/src/delay.ts

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

package/src/get.ts

@@ -1,17 +0,0 @@
-import {noop} from '@oscarpalmer/atoms/function';
-import type {GenericCallback} from '@oscarpalmer/atoms/models';
-import {DEFAULT_TIMEOUT} from './constants';
-
-export function getCallback(value: unknown): GenericCallback {
-	return typeof value === 'function' ? (value as GenericCallback) : noop;
-}
-
-export function getValidTimeout(value: unknown): number {
-	return typeof value === 'number' && value > 0 ? value : DEFAULT_TIMEOUT;
-}
-
-export function getValidNumber(value: unknown, defaultValue?: number): number {
-	const actualDefault = defaultValue ?? 0;
-
-	return typeof value === 'number' && value > actualDefault ? value : actualDefault;
-}