@oscarpalmer/timer 0.43.0 → 0.45.0

package/dist/is.d.mts

@@ -1,6 +1,4 @@
-import { Timer } from "./timer.mjs";
-import { When } from "./when.mjs";
-
+import { Timer, When } from "./models.mjs";
 //#region src/is.d.ts
 /**
  * Is the value a repeating timer?

package/dist/misc.d.mts

@@ -0,0 +1,10 @@
+import { TimerState, TimerStates } from "./models.mjs";
+import { GenericCallback } from "@oscarpalmer/atoms/models";
+//#region src/misc.d.ts
+declare function getCallback(value: unknown): GenericCallback;
+declare function getValidNumber(value: unknown, defaultValue?: number): number;
+declare function getValidTimeout(value: unknown): number;
+declare function onVisibilityChange(): void;
+declare function updateStates(state: TimerState, key?: keyof TimerStates): void;
+//#endregion
+export { getCallback, getValidNumber, getValidTimeout, onVisibilityChange, updateStates };

package/dist/misc.mjs

@@ -0,0 +1,34 @@
+import { DEFAULT_TIMEOUT, STATES, WORK_CONTINUE, WORK_PAUSE } from "./constants.mjs";
+import { work } from "./work.mjs";
+import { noop } from "@oscarpalmer/atoms/function";
+//#region src/misc.ts
+function getCallback(value) {
+	return typeof value === "function" ? value : noop;
+}
+function getValidNumber(value, defaultValue) {
+	const actualDefault = defaultValue ?? 0;
+	return typeof value === "number" && value > actualDefault ? value : actualDefault;
+}
+function getValidTimeout(value) {
+	return typeof value === "number" && value > 0 ? value : DEFAULT_TIMEOUT;
+}
+/* istanbul ignore next */
+function onVisibilityChange() {
+	const from = document.hidden ? STATES.active : STATES.hidden;
+	const type = document.hidden ? WORK_PAUSE : WORK_CONTINUE;
+	for (const stored of from) {
+		const state = stored instanceof WeakRef ? stored.deref() : stored;
+		if (state != null) work(type, state, true);
+	}
+}
+function updateStates(state, key) {
+	STATES.active.delete(state);
+	const hidden = [...STATES.hidden].find((stored) => stored.deref() === state);
+	/* istanbul ignore next */
+	if (hidden != null) STATES.hidden.delete(hidden);
+	if (key != null)
+ /* istanbul ignore next */
+	STATES[key].add(key === "hidden" ? new WeakRef(state) : state);
+}
+//#endregion
+export { getCallback, getValidNumber, getValidTimeout, onVisibilityChange, updateStates };

package/dist/models.d.mts

@@ -1,5 +1,3 @@
-import { Timer } from "./timer.mjs";
-
 //#region src/models.d.ts
 /**
  * Options for a repeating timer
@@ -26,6 +24,53 @@ type RepeatOptions = {
    */
   timeout: number;
 };
+type Timer = {
+  /**
+   * Is the timer active?
+   */
+  get active(): boolean;
+  /**
+   * Is the timer destroyed?
+   *
+   * @deprecated Timers take care of their own cleanup; this always returns `false`
+   */
+  get destroyed(): boolean;
+  /**
+   * Is the timer paused?
+   */
+  get paused(): boolean;
+  /**
+   * Get the timer's origin _(if debugging is enabled)_
+   */
+  get trace(): string | undefined;
+  /**
+   * Continue running the timer _(if it's paused)_
+   */
+  continue(): Timer;
+  /**
+   * Destroy the timer
+   *
+   * @deprecated Timers take care of their own cleanup
+   */
+  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;
+};
+type TimerName = 'repeat' | 'wait' | 'when';
 type TimerOptions = {
   onAfter: ((finished: boolean) => void) | undefined;
   onError: (() => void) | undefined;
@@ -38,16 +83,73 @@ type TimerState = {
   callback: () => void;
   destroyed: boolean;
   elapsed: number;
-  frame: number | undefined;
+  frame?: number;
   index: number;
+  name: TimerName;
+  options: TimerOptions;
   paused: boolean;
+  timer: Timer;
   total: number;
-  trace: string | undefined;
+  trace?: string;
+};
+type TimerStates = {
+  /**
+   * A set of all active timers
+   */
+  active: Set<TimerState>;
+  /**
+   * A set of timers that were paused due to the document being hidden
+   */
+  hidden: Set<WeakRef<TimerState>>;
 };
 declare class TimerTrace extends Error {
   constructor();
 }
-type TimerType = 'repeat' | 'wait' | 'when';
+type When = {
+  /**
+   * Is the timer active?
+   */
+  get active(): boolean;
+  /**
+   * Is the timer destroyed?
+   *
+   * @deprecated Timers take care of their own cleanup; this always returns `false`
+   */
+  get destroyed(): boolean;
+  /**
+   * Is the timer paused?
+   */
+  get paused(): boolean;
+  /**
+   * Get the timer's origin _(if debugging is enabled)_
+   */
+  get trace(): string | undefined;
+  /**
+   * Continues the timer _(if it was paused)_
+   */
+  continue(): When;
+  /**
+   * Destroys the timer _(and stops it,if it was running)_
+   *
+   * @deprecated Timers take care of their own cleanup
+   */
+  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;
+};
 /**
  * Options for a conditional timer
  */
@@ -69,14 +171,15 @@ type WhenState = {
   promise: Promise<void>;
   rejecter?: () => void;
   resolver?: () => void;
+  result: boolean;
   started: boolean;
   timer: Timer;
 };
 type WorkHandler = (type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions) => Timer;
 type WorkHandlerTimer = {
   instance: Timer;
-  type: TimerType;
+  name: TimerName;
 };
 type WorkHandlerType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';
 //#endregion
-export { RepeatOptions, TimerOptions, TimerState, TimerTrace, TimerType, WhenOptions, WhenState, WorkHandler, WorkHandlerTimer, WorkHandlerType };
+export { RepeatOptions, Timer, TimerName, TimerOptions, TimerState, TimerStates, TimerTrace, When, WhenOptions, WhenState, WorkHandler, WorkHandlerTimer, WorkHandlerType };

package/dist/repeat.d.mts

@@ -1,5 +1,5 @@
-import { Timer } from "./timer.mjs";
-import { RepeatOptions } from "./models.mjs";
+import { RepeatOptions, Timer } from "./models.mjs";
+import "./global.mjs";
 //#region src/repeat.d.ts
 /**
  * Create a repeating timer
@@ -10,4 +10,4 @@ import { RepeatOptions } from "./models.mjs";
  */
 declare function repeat(callback: (index: number) => void, options?: Partial<RepeatOptions>): Timer;
 //#endregion
-export { type RepeatOptions, type Timer, repeat };
+export { repeat };

package/dist/repeat.mjs

@@ -1,8 +1,8 @@
 import { TYPE_REPEAT } from "./constants.mjs";
-import { getCallback, getValidNumber } from "./get.mjs";
+import { getCallback, getValidNumber } from "./misc.mjs";
 import "./global.mjs";
 import { TimerTrace } from "./models.mjs";
-import { Timer } from "./timer.mjs";
+import { createTimer } from "./timer.mjs";
 //#region src/repeat.ts
 /**
 * Create a repeating timer
@@ -12,7 +12,7 @@ import { Timer } from "./timer.mjs";
 * @returns Timer instance
 */
 function repeat(callback, options) {
-	return new Timer(TYPE_REPEAT, {
+	return createTimer(TYPE_REPEAT, {
 		callback: getCallback(callback),
 		trace: new TimerTrace().stack
 	}, {

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

@@ -1,98 +1,54 @@
 import { WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.mjs";
-import { stop, work } from "./work.mjs";
+import { 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) {
-		return work(type, {
-			instance: this,
-			type: this.$timer
-		}, this.state, this.options);
-	}
-};
+function createTimer(name, pick, options, start) {
+	const state = {
+		...pick,
+		name,
+		options,
+		active: false,
+		destroyed: false,
+		elapsed: 0,
+		frame: void 0,
+		index: 0,
+		paused: false,
+		timer: void 0,
+		total: 0
+	};
+	const instance = {
+		continue: () => work(WORK_CONTINUE, state),
+		destroy: noop,
+		pause: () => work(WORK_PAUSE, state),
+		restart: () => work(WORK_RESTART, state),
+		start: () => work(WORK_START, state),
+		stop: () => work(WORK_STOP, state)
+	};
+	Object.defineProperties(instance, {
+		$timer: {
+			enumerable: false,
+			value: name
+		},
+		active: {
+			enumerable: true,
+			get: () => state.active
+		},
+		destroyed: {
+			enumerable: true,
+			value: false
+		},
+		paused: {
+			enumerable: true,
+			get: () => state.paused
+		},
+		trace: {
+			enumerable: true,
+			get: () => globalThis._oscarpalmer_timer_debug ?? false ? state.trace : void 0
+		}
+	});
+	state.timer = Object.freeze(instance);
+	if (start) state.timer.start();
+	return state.timer;
+}
 //#endregion
-export { Timer };
+export { createTimer };

package/dist/wait.d.mts

@@ -1,4 +1,5 @@
-import { Timer } from "./timer.mjs";
+import { Timer } from "./models.mjs";
+import "./global.mjs";
 //#region src/wait.d.ts
 /**
  * Create a waiting timer
@@ -8,4 +9,4 @@ import { Timer } from "./timer.mjs";
  */
 declare function wait(callback: () => void, time?: number): Timer;
 //#endregion
-export { type Timer, wait };
+export { wait };

package/dist/wait.mjs

@@ -1,8 +1,8 @@
 import { TYPE_WAIT } from "./constants.mjs";
-import { getCallback, getValidNumber } from "./get.mjs";
+import { getCallback, getValidNumber } from "./misc.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
@@ -11,7 +11,7 @@ import { Timer } from "./timer.mjs";
 * @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,49 +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
-   * @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
@@ -52,4 +9,4 @@ declare class When {
  */
 declare function when(condition: () => boolean, options?: Partial<WhenOptions>): When;
 //#endregion
-export { type When, when };
+export { when };