@oscarpalmer/timer 0.41.3 → 0.42.0

package/dist/models.d.mts

@@ -0,0 +1,82 @@
+import { Timer } from "./timer.mjs";
+
+//#region src/models.d.ts
+/**
+ * Options for a repeating timer
+ */
+type RepeatOptions = {
+  /**
+   * Callback to be called when the timer has stopped, either manually or by completing its work
+   */
+  onAfter: (finished: boolean) => void;
+  /**
+   * Callback to be called after the timer has timed out
+   */
+  onTimeout: () => void;
+  /**
+   * How many times the timer should repeat
+   */
+  count: number;
+  /**
+   * The interval between each repeat
+   */
+  interval: number;
+  /**
+   * The timeout for the timer _(any value above `0` will enable the timeout)_
+   */
+  timeout: number;
+};
+type TimerOptions = {
+  onAfter: ((finished: boolean) => void) | undefined;
+  onError: (() => void) | undefined;
+  count: number;
+  interval: number;
+  timeout: number;
+};
+type TimerState = {
+  active: boolean;
+  callback: () => void;
+  destroyed: boolean;
+  elapsed: number;
+  frame: number | undefined;
+  index: number;
+  paused: boolean;
+  total: number;
+  trace: string | undefined;
+};
+declare class TimerTrace extends Error {
+  constructor();
+}
+type TimerType = 'repeat' | 'wait' | 'when';
+/**
+ * Options for a conditional timer
+ */
+type WhenOptions = {
+  /**
+   * How many times the timer should check the condition
+   */
+  count: number;
+  /**
+   * Then interval between each condtional check
+   */
+  interval: number;
+  /**
+   * The timeout for the timer _(any value above `0` will enable the timeout)_
+   */
+  timeout: number;
+};
+type WhenState = {
+  promise: Promise<void>;
+  rejecter?: () => void;
+  resolver?: () => void;
+  started: boolean;
+  timer: Timer;
+};
+type WorkHandler = (type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions) => Timer;
+type WorkHandlerTimer = {
+  instance: Timer;
+  type: TimerType;
+};
+type WorkHandlerType = 'continue' | 'pause' | 'restart' | 'start' | 'stop';
+//#endregion
+export { RepeatOptions, TimerOptions, TimerState, TimerTrace, TimerType, WhenOptions, WhenState, WorkHandler, WorkHandlerTimer, WorkHandlerType };

package/dist/{models.js → models.mjs}

@@ -1,7 +1,9 @@
+//#region src/models.ts
 var TimerTrace = class extends Error {
 	constructor() {
 		super();
 		this.name = "TimerTrace";
 	}
 };
+//#endregion
 export { TimerTrace };

package/dist/repeat.d.mts

@@ -0,0 +1,12 @@
+import { Timer } from "./timer.mjs";
+import { RepeatOptions } from "./models.mjs";
+//#region src/repeat.d.ts
+/**
+ * Create a repeating timer
+ * @param callback Callback to run on each interval
+ * @param options Timer options
+ * @returns Timer instance
+ */
+declare function repeat(callback: (index: number) => void, options?: Partial<RepeatOptions>): Timer;
+//#endregion
+export { type RepeatOptions, type Timer, repeat };

package/dist/{repeat.js → repeat.mjs}

@@ -1,8 +1,9 @@
-import { TYPE_REPEAT } from "./constants.js";
-import { getCallback, getValidNumber } from "./get.js";
-import "./global.js";
-import { TimerTrace } from "./models.js";
-import { Timer } from "./timer.js";
+import { TYPE_REPEAT } from "./constants.mjs";
+import { getCallback, getValidNumber } from "./get.mjs";
+import "./global.mjs";
+import { TimerTrace } from "./models.mjs";
+import { Timer } from "./timer.mjs";
+//#region src/repeat.ts
 /**
 * Create a repeating timer
 * @param callback Callback to run on each interval
@@ -21,4 +22,5 @@ function repeat(callback, options) {
 		timeout: getValidNumber(options?.timeout)
 	}, true);
 }
+//#endregion
 export { repeat };

package/dist/timer.d.mts

@@ -0,0 +1,52 @@
+import { TimerOptions, TimerState, TimerType } 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;
+}
+//#endregion
+export { Timer };

package/dist/{timer.js → timer.mjs}

@@ -1,6 +1,7 @@
-import { WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.js";
-import { stop, work } from "./work.js";
+import { WORK_CONTINUE, WORK_PAUSE, WORK_RESTART, WORK_START, WORK_STOP } from "./constants.mjs";
+import { stop, work } from "./work.mjs";
 import { noop } from "@oscarpalmer/atoms/function";
+//#region src/timer.ts
 var Timer = class {
 	state;
 	/**
@@ -93,4 +94,5 @@ var Timer = class {
 		}, this.state, this.options);
 	}
 };
+//#endregion
 export { Timer };

package/{types/wait.d.ts → dist/wait.d.mts}

@@ -1,9 +1,10 @@
-import './global';
-import { Timer } from './timer';
+import { Timer } from "./timer.mjs";
+//#region src/wait.d.ts
 /**
  * Create a waiting timer
  * @param callback Callback to run when the timer has finished
  * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
  */
-export declare function wait(callback: () => void, time?: number): Timer;
-export type { Timer };
+declare function wait(callback: () => void, time?: number): Timer;
+//#endregion
+export { type Timer, wait };

package/dist/{wait.js → wait.mjs}

@@ -1,8 +1,9 @@
-import { TYPE_WAIT } from "./constants.js";
-import { getCallback, getValidNumber } from "./get.js";
-import "./global.js";
-import { TimerTrace } from "./models.js";
-import { Timer } from "./timer.js";
+import { TYPE_WAIT } from "./constants.mjs";
+import { getCallback, getValidNumber } from "./get.mjs";
+import "./global.mjs";
+import { TimerTrace } from "./models.mjs";
+import { Timer } from "./timer.mjs";
+//#region src/wait.ts
 /**
 * Create a waiting timer
 * @param callback Callback to run when the timer has finished
@@ -20,4 +21,5 @@ function wait(callback, time) {
 		timeout: 0
 	}, true);
 }
+//#endregion
 export { wait };

package/dist/when.d.mts

@@ -0,0 +1,63 @@
+import { WhenOptions } from "./models.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
+   * @param reject Optional reject callback
+   * @returns Promise that resolves when the condition is met
+   */
+  start(resolve?: (() => void) | null, reject?: (() => void) | null): Promise<void>;
+  /**
+   * Stops the timer _(if it was running)_
+   */
+  stop(): When;
+  /**
+   * Start the timer
+   * @deprecated Use `start()` instead
+   * @param resolve Optional resolve callback
+   * @param reject Optional reject callback
+   * @returns Promise that resolves when the condition is met
+   */
+  then(resolve?: (() => void) | null, reject?: (() => void) | null): Promise<void>;
+}
+/**
+ * Create a conditional timer
+ * @param condition Condition to check
+ * @param options Timer options
+ * @returns Timer instance
+ */
+declare function when(condition: () => boolean, options?: Partial<WhenOptions>): When;
+//#endregion
+export { type When, when };

package/dist/{when.js → when.mjs}

@@ -1,9 +1,10 @@
-import { MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN } from "./constants.js";
-import { getValidNumber, getValidTimeout } from "./get.js";
-import "./global.js";
-import { TimerTrace } from "./models.js";
-import { Timer } from "./timer.js";
+import { MESSAGE_DESTROYED, MESSAGE_STARTED, TYPE_WHEN } from "./constants.mjs";
+import { getValidNumber, getValidTimeout } from "./get.mjs";
+import "./global.mjs";
+import { TimerTrace } from "./models.mjs";
+import { Timer } from "./timer.mjs";
 import { noop } from "@oscarpalmer/atoms/function";
+//#region src/when.ts
 var When = class {
 	state = {
 		promise: void 0,
@@ -137,4 +138,5 @@ var When = class {
 function when(condition, options) {
 	return new When(condition, options);
 }
+//#endregion
 export { when };

package/dist/work.d.mts

@@ -0,0 +1,8 @@
+import { Timer } from "./timer.mjs";
+import { TimerOptions, TimerState, WorkHandlerTimer, WorkHandlerType } from "./models.mjs";
+
+//#region src/work.d.ts
+declare function stop(timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): Timer;
+declare function work(type: WorkHandlerType, timer: WorkHandlerTimer, state: TimerState, options: TimerOptions): Timer;
+//#endregion
+export { stop, work };

package/dist/{work.js → work.mjs}

@@ -1,4 +1,5 @@
-import { TIMERS_ACTIVE, WORK_PAUSE, WORK_STOP } from "./constants.js";
+import { TIMERS_ACTIVE, WORK_PAUSE, WORK_STOP } from "./constants.mjs";
+//#region src/work.ts
 function finish(timer, state, options, success) {
 	cancelAnimationFrame(state.frame);
 	TIMERS_ACTIVE.delete(timer.instance);
@@ -78,4 +79,5 @@ function work(type, timer, state, options) {
 	state.frame = requestAnimationFrame(runner);
 	return timer.instance;
 }
+//#endregion
 export { stop, work };

package/package.json

@@ -1,75 +1,72 @@
 {
+	"name": "@oscarpalmer/timer",
+	"version": "0.42.0",
+	"description": "A better solution for timeout- and interval-based timers.",
+	"keywords": [
+		"requestAnimationFrame",
+		"setInterval",
+		"setTimeout",
+		"timer"
+	],
+	"license": "MIT",
 	"author": {
 		"name": "Oscar Palmér",
 		"url": "https://oscarpalmer.se"
 	},
-	"dependencies": {
-		"@oscarpalmer/atoms": "^0.152"
-	},
-	"description": "A better solution for timeout- and interval-based timers.",
-	"devDependencies": {
-		"@types/node": "^25.3",
-		"@vitest/coverage-istanbul": "^4",
-		"dts-bundle-generator": "^9.5",
-		"jsdom": "^28.1",
-		"oxfmt": "^0.36",
-		"oxlint": "^1.51",
-		"rolldown": "1.0.0-rc.6",
-		"tslib": "^2.8",
-		"typescript": "^5.9",
-		"vite": "8.0.0-beta.16",
-		"vitest": "^4"
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/oscarpalmer/timer.git"
 	},
+	"files": [
+		"dist",
+		"src"
+	],
+	"type": "module",
+	"module": "dist/index.mjs",
+	"types": "dist/index.d.mts",
 	"exports": {
 		"./package.json": "./package.json",
 		".": {
-			"types": "./types/index.d.ts",
-			"default": "./dist/index.js"
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
 		},
 		"./delay": {
-			"types": "./types/delay.d.ts",
-			"default": "./dist/delay.js"
+			"types": "./dist/delay.d.mts",
+			"default": "./dist/delay.mjs"
 		},
 		"./repeat": {
-			"types": "./types/repeat.d.ts",
-			"default": "./dist/repeat.js"
+			"types": "./dist/repeat.d.mts",
+			"default": "./dist/repeat.mjs"
 		},
 		"./wait": {
-			"types": "./types/wait.d.ts",
-			"default": "./dist/wait.js"
+			"types": "./dist/wait.d.mts",
+			"default": "./dist/wait.mjs"
 		},
 		"./when": {
-			"types": "./types/when.d.ts",
-			"default": "./dist/when.js"
+			"types": "./dist/when.d.mts",
+			"default": "./dist/when.mjs"
 		}
 	},
-	"files": [
-		"dist",
-		"src",
-		"types"
-	],
-	"keywords": [
-		"requestAnimationFrame",
-		"setInterval",
-		"setTimeout",
-		"timer"
-	],
-	"license": "MIT",
-	"module": "dist/index.js",
-	"name": "@oscarpalmer/timer",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/oscarpalmer/timer.git"
-	},
 	"scripts": {
-		"build": "npm run clean && npx vite build && npm run rolldown:build && npx tsc && npx dts-bundle-generator --config ./dts.config.ts --silent",
-		"clean": "rm -rf ./dist && rm -rf ./types && rm -f ./tsconfig.tsbuildinfo",
-		"rolldown:build": "npx rolldown -c",
-		"rolldown:watch": "npx rolldown -c ./rolldown.config.js --watch",
-		"test": "npx vitest --coverage",
+		"build": "npx vp pack && npm run tsdown:build",
+		"tsdown:build": "npx tsdown -c ./tsdown.config.ts",
+		"tsdown:watch": "npx tsdown -c ./tsdown.config.ts --watch",
+		"test": "npx vp test run --coverage",
+		"test:leak": "npx vp test run --detect-async-leaks --coverage",
 		"watch": "npx vite build --watch"
 	},
-	"type": "module",
-	"types": "types/index.d.ts",
-	"version": "0.41.3"
+	"dependencies": {
+		"@oscarpalmer/atoms": "^0.165"
+	},
+	"devDependencies": {
+		"@types/node": "^25.5",
+		"@vitest/coverage-istanbul": "^4.1",
+		"jsdom": "^28.1",
+		"tsdown": "^0.21",
+		"typescript": "^5.9",
+		"vite": "npm:@voidzero-dev/vite-plus-core@latest",
+		"vite-plus": "latest",
+		"vitest": "npm:@voidzero-dev/vite-plus-test@latest"
+	},
+	"packageManager": "npm@11.11.1"
 }

package/src/delay.ts

@@ -1 +1,2 @@
-export {delay, type PromiseOptions} from '@oscarpalmer/atoms/promise';
+export {delay} from '@oscarpalmer/atoms/promise/delay';
+export type {PromiseOptions} from '@oscarpalmer/atoms/promise/models';

package/src/get.ts

@@ -1,4 +1,4 @@
-import type {GenericCallback} from '@oscarpalmer/atoms';
+import type {GenericCallback} from '@oscarpalmer/atoms/models';
 import {noop} from '@oscarpalmer/atoms/function';
 import {DEFAULT_TIMEOUT} from './constants';
 

package/src/is.ts

@@ -1,4 +1,4 @@
-import type {PlainObject} from '@oscarpalmer/atoms';
+import type {PlainObject} from '@oscarpalmer/atoms/models';
 import {TYPE_REPEAT, TYPE_WAIT, TYPE_WHEN} from './constants';
 import type {Timer} from './timer';
 import type {When} from './when';

package/dist/delay.js

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

package/dist/index.js

@@ -1,7 +0,0 @@
-import { delay } from "./delay.js";
-import "./global.js";
-import { isRepeated, isTimer, isWaited, isWhen } from "./is.js";
-import { repeat } from "./repeat.js";
-import { wait } from "./wait.js";
-import { when } from "./when.js";
-export { delay, isRepeated, isTimer, isWaited, isWhen, repeat, wait, when };

package/types/constants.d.ts

@@ -1,31 +0,0 @@
-import type { TimerType, WorkHandlerType } from './models';
-import type { Timer } from './timer';
-/**
- * Buffer value to use when evaluating if a specific time is within a certain range
- */
-export declare const BUFFER_INTERVAL = 5;
-export declare const DEFAULT_TIMEOUT = 30000;
-/**
- * Message to show when a when-timer is destroyed
- */
-export declare const MESSAGE_DESTROYED = "Timer has already been destroyed";
-/**
- * Message to show when a when-timer is started
- */
-export declare const MESSAGE_STARTED = "Timer has already been started";
-/**
- * A set of all active timers
- */
-export declare const TIMERS_ACTIVE: Set<Timer>;
-/**
- * A set of timers that were paused due to the document being hidden
- */
-export declare const TIMERS_HIDDEN: Set<Timer>;
-export declare const TYPE_REPEAT: TimerType;
-export declare const TYPE_WAIT: TimerType;
-export declare const TYPE_WHEN: TimerType;
-export declare const WORK_CONTINUE: WorkHandlerType;
-export declare const WORK_PAUSE: WorkHandlerType;
-export declare const WORK_RESTART: WorkHandlerType;
-export declare const WORK_START: WorkHandlerType;
-export declare const WORK_STOP: WorkHandlerType;

package/types/delay.d.ts

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

package/types/get.d.ts

@@ -1,4 +0,0 @@
-import type { GenericCallback } from '@oscarpalmer/atoms';
-export declare function getCallback(value: unknown): GenericCallback;
-export declare function getValidTimeout(value: unknown): number;
-export declare function getValidNumber(value: unknown, defaultValue?: number): number;

package/types/global.d.ts

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