@oscarpalmer/timer 0.25.0 → 0.26.0

package/types/timer.d.cts

@@ -0,0 +1,142 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export declare abstract class BasicTimer<State> {
+	protected readonly $timer: string;
+	protected readonly state: State;
+	constructor(type: "repeat" | "wait" | "when", state: State);
+	/**
+	 * Is the timer running?
+	 */
+	abstract readonly active: boolean;
+	/**
+	 * Is the timer destroyed?
+	 */
+	abstract readonly destroyed: boolean;
+	/**
+	 * Is the timer paused?
+	 */
+	abstract readonly paused: boolean;
+	/**
+	 * Gets the traced location of the timer
+	 */
+	abstract readonly trace: TimerTrace | undefined;
+}
+/**
+ * A timer that can be started, stopped, and restarted as neeeded
+ */
+export declare class Timer extends BasicTimer<TimerState> {
+	private readonly options;
+	get active(): boolean;
+	get destroyed(): boolean;
+	get paused(): boolean;
+	get trace(): TimerTrace | undefined;
+	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
+	/**
+	 * Continues the timer _(if it was paused)_
+	 */
+	continue(): Timer;
+	/**
+	 * Destroys the timer _(after stopping it, if it was running)_
+	 */
+	destroy(): void;
+	/**
+	 * Pauses the timer _(if it was running)_
+	 */
+	pause(): Timer;
+	/**
+	 * Restarts the timer _(if it was running)_
+	 */
+	restart(): Timer;
+	/**
+	 * Starts the timer _(if it was stopped)_
+	 */
+	start(): Timer;
+	/**
+	 * Stops the timer _(if it was running)_
+	 */
+	stop(): Timer;
+}
+/**
+ * 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`
+ */
+export declare function repeat(callback: IndexedCallback, options?: Partial<RepeatOptions>): Timer;
+export declare function timer(type: "repeat" | "wait", callback: AnyCallback, partial: Partial<TimerOptions>, start: boolean): Timer;
+/**
+ * Creates a timer which calls a callback after a certain amount of time
+ */
+export declare function wait(callback: () => void): Timer;
+/**
+ * Creates a timer which calls a callback after a certain amount of time
+ */
+export declare function wait(callback: () => void, time: number): Timer;
+/**
+ * Creates a timer which calls a callback after a certain amount of time
+ * - `options.interval` defaults to `1000/60` _(1 frame)_
+ * - `options.timeout` defaults to `30_000` _(30 seconds)_
+ */
+export declare function wait(callback: () => void, options: Partial<WaitOptions>): 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
+ */
+export type AfterCallback = (finished: boolean) => void;
+export type AnyCallback = (() => void) | IndexedCallback;
+/**
+ * Callback that runs for each iteration of the timer
+ */
+export type IndexedCallback = (index: number) => void;
+export type BaseOptions = {
+	/**
+	 * Interval between each callback
+	 */
+	interval: number;
+	/**
+	 * Maximum amount of time the timer may run for
+	 */
+	timeout: number;
+};
+export type OptionsWithCount = {
+	/**
+	 * How many times the timer should repeat
+	 */
+	count: number;
+} & BaseOptions;
+export type OptionsWithError = {
+	/**
+	 * Callback to run when an error occurs _(usually a timeout)_
+	 */
+	errorCallback?: () => void;
+};
+export type RepeatOptions = {
+	/**
+	 * Callback to run after the timer has finished (or is stopped)
+	 * - `finished` is `true` if the timer was allowed to finish, and `false` if it was stopped
+	 */
+	afterCallback?: AfterCallback;
+} & OptionsWithCount & OptionsWithError;
+export type TimerOptions = {} & RepeatOptions;
+export type TimerState = {
+	active: boolean;
+	callback: AnyCallback;
+	destroyed: boolean;
+	count?: number;
+	elapsed?: number;
+	frame?: number;
+	index?: number;
+	isRepeated: boolean;
+	minimum: number;
+	paused: boolean;
+	trace: TimerTrace;
+};
+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 { TimerTrace, 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;

package/types/when.d.cts

@@ -0,0 +1,153 @@
+// Generated by dts-bundle-generator v9.5.1
+
+declare abstract class BasicTimer<State> {
+	protected readonly $timer: string;
+	protected readonly state: State;
+	constructor(type: "repeat" | "wait" | "when", state: State);
+	/**
+	 * Is the timer running?
+	 */
+	abstract readonly active: boolean;
+	/**
+	 * Is the timer destroyed?
+	 */
+	abstract readonly destroyed: boolean;
+	/**
+	 * Is the timer paused?
+	 */
+	abstract readonly paused: boolean;
+	/**
+	 * Gets the traced location of the timer
+	 */
+	abstract readonly trace: TimerTrace | undefined;
+}
+declare class Timer extends BasicTimer<TimerState> {
+	private readonly options;
+	get active(): boolean;
+	get destroyed(): boolean;
+	get paused(): boolean;
+	get trace(): TimerTrace | undefined;
+	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
+	/**
+	 * Continues the timer _(if it was paused)_
+	 */
+	continue(): Timer;
+	/**
+	 * Destroys the timer _(after stopping it, if it was running)_
+	 */
+	destroy(): void;
+	/**
+	 * Pauses the timer _(if it was running)_
+	 */
+	pause(): Timer;
+	/**
+	 * Restarts the timer _(if it was running)_
+	 */
+	restart(): Timer;
+	/**
+	 * Starts the timer _(if it was stopped)_
+	 */
+	start(): Timer;
+	/**
+	 * Stops the timer _(if it was running)_
+	 */
+	stop(): 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
+ */
+export type AfterCallback = (finished: boolean) => void;
+export type AnyCallback = (() => void) | IndexedCallback;
+/**
+ * Callback that runs for each iteration of the timer
+ */
+export type IndexedCallback = (index: number) => void;
+export type BaseOptions = {
+	/**
+	 * Interval between each callback
+	 */
+	interval: number;
+	/**
+	 * Maximum amount of time the timer may run for
+	 */
+	timeout: number;
+};
+export type OptionsWithCount = {
+	/**
+	 * How many times the timer should repeat
+	 */
+	count: number;
+} & BaseOptions;
+export type OptionsWithError = {
+	/**
+	 * Callback to run when an error occurs _(usually a timeout)_
+	 */
+	errorCallback?: () => void;
+};
+export type RepeatOptions = {
+	/**
+	 * Callback to run after the timer has finished (or is stopped)
+	 * - `finished` is `true` if the timer was allowed to finish, and `false` if it was stopped
+	 */
+	afterCallback?: AfterCallback;
+} & OptionsWithCount & OptionsWithError;
+export type TimerOptions = {} & RepeatOptions;
+export type TimerState = {
+	active: boolean;
+	callback: AnyCallback;
+	destroyed: boolean;
+	count?: number;
+	elapsed?: number;
+	frame?: number;
+	index?: number;
+	isRepeated: boolean;
+	minimum: number;
+	paused: boolean;
+	trace: TimerTrace;
+};
+declare class TimerTrace extends Error {
+	constructor();
+}
+export type WhenOptions = {} & OptionsWithCount;
+export type WhenState = {
+	promise: Promise<void>;
+	rejecter?: () => void;
+	resolver?: () => void;
+	started: boolean;
+	timer: Timer;
+};
+export declare class When extends BasicTimer<WhenState> {
+	get active(): boolean;
+	get destroyed(): boolean;
+	get paused(): boolean;
+	get trace(): TimerTrace | undefined;
+	constructor(state: WhenState);
+	/**
+	 * 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;
+	/**
+	 * Stops the timer _(if it was running)_
+	 */
+	stop(): When;
+	/**
+	 * Starts the timer and returns a promise that resolves when the condition is met
+	 */
+	then(resolve?: (() => void) | null, reject?: (() => void) | null): Promise<void>;
+}
+/**
+ * - Creates a promise that resolves when a condition is met
+ * - If the condition is never met in a timely manner, the promise will reject
+ */
+export declare function when(condition: () => boolean, options?: Partial<WhenOptions>): When;
+
+export {};

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(): import("~/models").TimerTrace | undefined;
     constructor(state: WhenState);
     /**
      * Continues the timer _(if it was paused)_

package/dist/constants.mjs

@@ -1,19 +0,0 @@
-// src/constants.ts
-var activeTimers = new Set;
-var beginTypes = new Set(["continue", "start"]);
-var endTypes = new Set(["pause", "stop"]);
-var endOrRestartTypes = new Set([
-  "pause",
-  "restart",
-  "stop"
-]);
-var hiddenTimers = new Set;
-var milliseconds = 1000 / 60;
-export {
-  milliseconds,
-  hiddenTimers,
-  endTypes,
-  endOrRestartTypes,
-  beginTypes,
-  activeTimers
-};

package/dist/global.mjs

@@ -1,9 +0,0 @@
-// src/global.ts
-import { activeTimers } from "./constants";
-if (globalThis._oscarpalmer_timers == null) {
-  Object.defineProperty(globalThis, "_oscarpalmer_timers", {
-    get() {
-      return globalThis._oscarpalmer_timer_debug ? [...activeTimers] : [];
-    }
-  });
-}

package/dist/index.mjs

@@ -1,46 +0,0 @@
-// src/index.ts
-import { noop } from "@oscarpalmer/atoms/function";
-import { activeTimers, hiddenTimers } from "./constants";
-import"./global";
-import { wait } from "./timer";
-function delay(time, timeout) {
-  return new Promise((resolve, reject) => {
-    const delayed = wait(() => {
-      delayed.destroy();
-      (resolve ?? noop)();
-    }, {
-      timeout,
-      errorCallback: () => {
-        delayed.destroy();
-        (reject ?? noop)();
-      },
-      interval: time
-    });
-  });
-}
-import { isRepeated, isTimer, isWaited, isWhen } from "./is";
-import { repeat, wait as wait2 } from "./timer";
-import { when } from "./when";
-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();
-  }
-});
-export {
-  when,
-  wait2 as wait,
-  repeat,
-  isWhen,
-  isWaited,
-  isTimer,
-  isRepeated,
-  delay
-};

package/dist/timer.mjs

@@ -1,89 +0,0 @@
-// src/timer.ts
-import { milliseconds } from "./constants";
-import { getOptions, work } from "./functions";
-import {
-  TimerTrace
-} from "./models";
-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
-  }, options);
-  if (start) {
-    instance.start();
-  }
-  return instance;
-}
-function wait(callback, options) {
-  return timer("wait", callback, options == null || typeof options === "number" ? {
-    interval: options
-  } : options, true);
-}
-
-class BasicTimer {
-  constructor(type, state) {
-    this.$timer = type;
-    this.state = state;
-  }
-}
-
-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;
-  }
-  continue() {
-    return work("continue", this, this.state, this.options);
-  }
-  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;
-    }
-  }
-  pause() {
-    return work("pause", this, this.state, this.options);
-  }
-  restart() {
-    return work("restart", this, this.state, this.options);
-  }
-  start() {
-    return work("start", this, this.state, this.options);
-  }
-  stop() {
-    return work("stop", this, this.state, this.options);
-  }
-}
-export {
-  wait,
-  timer,
-  repeat,
-  Timer,
-  BasicTimer
-};

package/dist/when.mjs

@@ -1,91 +0,0 @@
-// src/when.ts
-import { noop } from "@oscarpalmer/atoms/function";
-import { BasicTimer, timer } from "./timer";
-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;
-}
-var destroyedMessage = "Timer has already been destroyed";
-var 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);
-  }
-  continue() {
-    this.state.timer?.continue();
-    return this;
-  }
-  destroy() {
-    this.state.timer?.destroy();
-    this.state.promise = undefined;
-    this.state.resolver = noop;
-    this.state.rejecter = noop;
-    this.state.timer = undefined;
-  }
-  pause() {
-    this.state.timer?.pause();
-    return this;
-  }
-  stop() {
-    this.state.timer?.stop();
-    return this;
-  }
-  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);
-  }
-}
-export {
-  when,
-  When
-};