@oscarpalmer/timer 0.24.0 → 0.26.0

package/types/functions.d.cts

@@ -0,0 +1,117 @@
+// 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 WorkType = "continue" | "pause" | "restart" | "start" | "stop";
+export declare function getOptions(options: Partial<TimerOptions>, isRepeated: boolean): TimerOptions;
+export declare function getValueOrDefault(value: unknown, defaultValue: number, minimum?: number): number;
+export declare function work(type: WorkType, timer: Timer, state: TimerState, options: TimerOptions): Timer;
+
+export {};

package/types/functions.d.ts

@@ -1,5 +1,5 @@
-import type { TimerOptions, TimerState, WorkType } from './models';
-import type { Timer } from './timer';
+import type { TimerOptions, TimerState, WorkType } from '~/models';
+import type { Timer } from '~/timer';
 export declare function getOptions(options: Partial<TimerOptions>, isRepeated: boolean): TimerOptions;
 export declare function getValueOrDefault(value: unknown, defaultValue: number, minimum?: number): number;
 export declare function work(type: WorkType, timer: Timer, state: TimerState, options: TimerOptions): Timer;

package/types/global.d.cts

@@ -0,0 +1,3 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export {};

package/types/global.d.ts

@@ -1,5 +1,5 @@
+import type { Timer } from '~/timer';
 declare global {
     var _oscarpalmer_timer_debug: boolean | undefined;
     var _oscarpalmer_timers: Timer[] | undefined;
 }
-export {};

package/types/index.d.cts

@@ -1,70 +1,5 @@
 // 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;
-	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 type WhenOptions = {} & OptionsWithCount;
-export type WhenState = {
-	promise: Promise<void>;
-	rejecter?: () => void;
-	resolver?: () => void;
-	started: boolean;
-	timer: Timer$1;
-};
 declare abstract class BasicTimer<State> {
 	protected readonly $timer: string;
 	protected readonly state: State;
@@ -89,7 +24,7 @@ declare abstract class BasicTimer<State> {
 /**
  * A timer that can be started, stopped, and restarted as neeeded
  */
-declare class Timer$1 extends BasicTimer<TimerState> {
+export declare class Timer extends BasicTimer<TimerState> {
 	private readonly options;
 	get active(): boolean;
 	get destroyed(): boolean;
@@ -99,7 +34,7 @@ declare class Timer$1 extends BasicTimer<TimerState> {
 	/**
 	 * Continues the timer _(if it was paused)_
 	 */
-	continue(): Timer$1;
+	continue(): Timer;
 	/**
 	 * Destroys the timer _(after stopping it, if it was running)_
 	 */
@@ -107,19 +42,19 @@ declare class Timer$1 extends BasicTimer<TimerState> {
 	/**
 	 * Pauses the timer _(if it was running)_
 	 */
-	pause(): Timer$1;
+	pause(): Timer;
 	/**
 	 * Restarts the timer _(if it was running)_
 	 */
-	restart(): Timer$1;
+	restart(): Timer;
 	/**
 	 * Starts the timer _(if it was stopped)_
 	 */
-	start(): Timer$1;
+	start(): Timer;
 	/**
 	 * Stops the timer _(if it was running)_
 	 */
-	stop(): Timer$1;
+	stop(): Timer;
 }
 /**
  * Creates a timer which:
@@ -130,21 +65,86 @@ declare class Timer$1 extends BasicTimer<TimerState> {
  * - `options.interval` defaults to `1000/60` _(1 frame)_
  * - `options.timeout` defaults to `Infinity`
  */
-export declare function repeat(callback: IndexedCallback, options?: Partial<RepeatOptions>): Timer$1;
+export declare function repeat(callback: IndexedCallback, options?: Partial<RepeatOptions>): Timer;
 /**
  * Creates a timer which calls a callback after a certain amount of time
  */
-export declare function wait(callback: () => void): Timer$1;
+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$1;
+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$1;
+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 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;
@@ -180,15 +180,15 @@ export declare function when(condition: () => boolean, options?: Partial<WhenOpt
 /**
  * Is the value a repeating timer?
  */
-export declare function isRepeated(value: unknown): value is Timer$1;
+export declare function isRepeated(value: unknown): value is Timer;
 /**
  * Is the value a timer?
  */
-export declare function isTimer(value: unknown): value is Timer$1;
+export declare function isTimer(value: unknown): value is Timer;
 /**
  * Is the value a waiting timer?
  */
-export declare function isWaited(value: unknown): value is Timer$1;
+export declare function isWaited(value: unknown): value is Timer;
 /**
  * Is the value a conditional timer?
  */
@@ -198,8 +198,4 @@ export declare function isWhen(value: unknown): value is When;
  */
 export declare function delay(time: number, timeout?: number): Promise<void>;
 
-export {
-	Timer$1 as Timer,
-};
-
 export {};

package/types/index.d.ts

@@ -1,4 +1,4 @@
-import './global';
+import '~/global';
 /**
  * Creates a delayed promise that resolves after a certain amount of time _(or rejects when timed out)_
  */

package/types/is.d.cts

@@ -0,0 +1,163 @@
+// 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 WhenState = {
+	promise: Promise<void>;
+	rejecter?: () => void;
+	resolver?: () => void;
+	started: boolean;
+	timer: Timer;
+};
+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>;
+}
+/**
+ * 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;
+
+export {};

package/types/is.d.ts

@@ -1,5 +1,5 @@
-import type { Timer } from './timer';
-import type { When } from './when';
+import type { Timer } from '~/timer';
+import type { When } from '~/when';
 /**
  * Is the value a repeating timer?
  */

package/types/models.d.cts

@@ -0,0 +1,123 @@
+// 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;
+};
+export declare class TimerTrace extends Error {
+	constructor();
+}
+export type WaitOptions = {} & BaseOptions & OptionsWithError;
+export type WhenOptions = {} & OptionsWithCount;
+export type WhenState = {
+	promise: Promise<void>;
+	rejecter?: () => void;
+	resolver?: () => void;
+	started: boolean;
+	timer: Timer;
+};
+export type WorkType = "continue" | "pause" | "restart" | "start" | "stop";
+
+export {};

package/types/models.d.ts

@@ -1,4 +1,4 @@
-import type { Timer } from './timer';
+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