@oscarpalmer/timer 0.20.0 → 0.21.1

package/types/index.d.cts

@@ -0,0 +1,184 @@
+// Generated by dts-bundle-generator v9.5.1
+
+/**
+ * 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;
+	count?: number;
+	elapsed?: number;
+	frame?: number;
+	index?: number;
+	isRepeated: boolean;
+	minimum: number;
+	paused: boolean;
+	trace: unknown;
+};
+export type WaitOptions = {} & BaseOptions & OptionsWithError;
+export type WhenOptions = {} & OptionsWithCount;
+export type WhenState = {
+	promise: Promise<void>;
+	rejecter?: () => void;
+	resolver?: () => void;
+	timer: Timer$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 paused?
+	 */
+	abstract readonly paused: boolean;
+}
+/**
+ * A timer that can be started, stopped, and restarted as neeeded
+ */
+declare class Timer$1 extends BasicTimer<TimerState> {
+	private readonly options;
+	get active(): boolean;
+	get paused(): boolean;
+	/**
+	 * Gets the traced location of the timer
+	 */
+	get trace(): unknown;
+	constructor(type: "repeat" | "wait", state: TimerState, options: TimerOptions);
+	/**
+	 * Continues the timer _(if it was paused)_
+	 */
+	continue(): Timer$1;
+	/**
+	 * Pauses the timer _(if it was running)_
+	 */
+	pause(): Timer$1;
+	/**
+	 * Restarts the timer _(if it was running)_
+	 */
+	restart(): Timer$1;
+	/**
+	 * Starts the timer _(if it was stopped)_
+	 */
+	start(): Timer$1;
+	/**
+	 * Stops the timer _(if it was running)_
+	 */
+	stop(): Timer$1;
+}
+/**
+ * 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$1;
+/**
+ * Creates a timer which calls a callback after a certain amount of time
+ */
+export declare function wait(callback: () => void): Timer$1;
+/**
+ * Creates a timer which calls a callback after a certain amount of time
+ */
+export declare function wait(callback: () => void, time: number): Timer$1;
+/**
+ * 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$1;
+export declare class When extends BasicTimer<WhenState> {
+	get active(): boolean;
+	get paused(): boolean;
+	constructor(state: WhenState);
+	/**
+	 * Continues the timer _(if it was paused)_
+	 */
+	continue(): When;
+	/**
+	 * 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;
+/**
+ * Is the value a repeating timer?
+ */
+export declare function isRepeated(value: unknown): value is Timer$1;
+/**
+ * Is the value a timer?
+ */
+export declare function isTimer(value: unknown): value is Timer$1;
+/**
+ * Is the value a waiting timer?
+ */
+export declare function isWaited(value: unknown): value is Timer$1;
+/**
+ * Is the value a conditional timer?
+ */
+export declare function isWhen(value: unknown): value is When;
+/**
+ * Creates a delayed promise that resolves after a certain amount of time _(or rejects when timed out)_
+ */
+export declare function delay(time: number, timeout?: number): Promise<void>;
+
+export {
+	Timer$1 as Timer,
+};
+
+export {};

package/types/index.d.ts

@@ -1,30 +1,8 @@
-export type AfterCallback = (finished: boolean) => void;
-type IndexedCallback = (index: number) => void;
-export declare class Timer {
-    private readonly _configuration;
-    private readonly _state;
-    get active(): boolean;
-    get finished(): boolean;
-    /**
-     * @param {Callback} callback
-     * @param {number} time
-     * @param {number} count
-     * @param {AfterCallback=} afterCallback
-     */
-    constructor(callback: IndexedCallback, time?: number, count?: number, afterCallback?: AfterCallback);
-    restart(): Timer;
-    start(): Timer;
-    stop(): Timer;
-}
+import './global';
 /**
- * Creates and starts a new repeated timer
+ * Creates a delayed promise that resolves after a certain amount of time _(or rejects when timed out)_
  */
-export declare function repeat(callback: IndexedCallback, count: number): Timer;
-export declare function repeat(callback: IndexedCallback, count: number, afterCallback: AfterCallback): Timer;
-export declare function repeat(callback: IndexedCallback, count: number, time: number): Timer;
-export declare function repeat(callback: IndexedCallback, count: number, time: number, afterCallback: AfterCallback): Timer;
-/**
- * Creates and starts a new waited timer
- */
-export declare function wait(callback: IndexedCallback, time?: number): Timer;
-export {};
+export declare function delay(time: number, timeout?: number): Promise<void>;
+export { isRepeated, isTimer, isWaited, isWhen } from './is';
+export { repeat, wait, type Timer } from './timer';
+export { when, type When } from './when';

package/types/is.d.ts

@@ -0,0 +1,18 @@
+import type { Timer } from './timer';
+import type { When } from './when';
+/**
+ * Is the value a repeating timer?
+ */
+export declare function isRepeated(value: unknown): value is Timer;
+/**
+ * Is the value a timer?
+ */
+export declare function isTimer(value: unknown): value is Timer;
+/**
+ * Is the value a waiting timer?
+ */
+export declare function isWaited(value: unknown): value is Timer;
+/**
+ * Is the value a conditional timer?
+ */
+export declare function isWhen(value: unknown): value is When;

package/types/models.d.ts

@@ -0,0 +1,62 @@
+import type { Timer } from './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;
+    count?: number;
+    elapsed?: number;
+    frame?: number;
+    index?: number;
+    isRepeated: boolean;
+    minimum: number;
+    paused: boolean;
+    trace: unknown;
+};
+export type WaitOptions = {} & BaseOptions & OptionsWithError;
+export type WhenOptions = {} & OptionsWithCount;
+export type WhenState = {
+    promise: Promise<void>;
+    rejecter?: () => void;
+    resolver?: () => void;
+    timer: Timer;
+};
+export type WorkType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';

package/types/timer.d.ts

@@ -0,0 +1,72 @@
+import type { AnyCallback, IndexedCallback, RepeatOptions, TimerOptions, TimerState, WaitOptions } from './models';
+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 paused?
+     */
+    abstract readonly paused: boolean;
+}
+/**
+ * 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 paused(): boolean;
+    /**
+     * Gets the traced location of the timer
+     */
+    get trace(): unknown;
+    constructor(type: 'repeat' | 'wait', state: TimerState, options: TimerOptions);
+    /**
+     * Continues the timer _(if it was paused)_
+     */
+    continue(): Timer;
+    /**
+     * 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;

package/types/when.d.ts

@@ -0,0 +1,28 @@
+import type { WhenOptions, WhenState } from './models';
+import { BasicTimer } from './timer';
+export declare class When extends BasicTimer<WhenState> {
+    get active(): boolean;
+    get paused(): boolean;
+    constructor(state: WhenState);
+    /**
+     * Continues the timer _(if it was paused)_
+     */
+    continue(): When;
+    /**
+     * 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;