@oscarpalmer/atoms 0.150.0 → 0.152.0

package/dist/atoms.full.js

@@ -1,27 +1,3 @@
-function calculate() {
-	return new Promise((resolve) => {
-		const values = [];
-		let last;
-		function step(now) {
-			if (last != null) values.push(now - last);
-			last = now;
-			if (values.length >= TOTAL) resolve(values.sort().slice(TRIM_PART, -TRIM_PART).reduce((first, second) => first + second, 0) / (values.length - TRIM_TOTAL));
-			else requestAnimationFrame(step);
-		}
-		requestAnimationFrame(step);
-	});
-}
-const TOTAL = 10;
-const TRIM_PART = 2;
-const TRIM_TOTAL = 4;
-let FRAME_RATE_MS = 1e3 / 60;
-/**
-* A calculated average of the refresh rate of the display _(in milliseconds)_
-*/
-calculate().then((value) => {
-	FRAME_RATE_MS = value;
-});
-var frame_rate_default = FRAME_RATE_MS;
 function getArrayCallback(value) {
 	switch (typeof value) {
 		case "function": return value;
@@ -701,44 +677,40 @@ function unique(array, key) {
 	if (!Array.isArray(array)) return [];
 	return array.length > 1 ? findValues("unique", array, [key, void 0]).matched : array;
 }
-function getLimiter(callback, throttler, time) {
-	const interval = typeof time === "number" && time >= frame_rate_default ? time : frame_rate_default;
-	function step(now, parameters) {
-		if (interval === frame_rate_default || now - timestamp >= interval) {
-			if (throttler) timestamp = now;
-			callback(...parameters);
-		} else frame = requestAnimationFrame((next) => {
-			step(next, parameters);
-		});
+function getInterval(value) {
+	return typeof value === "number" && value > 0 ? value : 0;
+}
+function getTimer(type, callback, time) {
+	const interval = getInterval(time);
+	function run(now) {
+		start ??= now;
+		if (interval === 0 || now - start >= interval - OFFSET) {
+			if (throttle) start = now;
+			callback(...args);
+		} else frame = requestAnimationFrame(run);
 	}
+	const throttle = type === TIMER_THROTTLE;
+	let args;
 	let frame;
-	let timestamp;
-	const limiter = (...parameters) => {
-		limiter.cancel();
-		frame = requestAnimationFrame((now) => {
-			timestamp ??= now - frame_rate_default;
-			step(now, parameters);
-		});
+	let start;
+	const timer = (...parameters) => {
+		timer.cancel();
+		args = parameters;
+		frame = requestAnimationFrame(run);
 	};
-	limiter.cancel = () => {
-		if (frame != null) {
-			cancelAnimationFrame(frame);
-			frame = void 0;
-		}
+	timer.cancel = () => {
+		cancelAnimationFrame(frame);
 	};
-	return limiter;
+	return timer;
 }
+const OFFSET = 5;
+const TIMER_DEBOUNCE = "debounce";
+const TIMER_THROTTLE = "throttle";
+const TIMER_WAIT = "wait";
 /**
-* Debounce a function, ensuring it is only called after `time` milliseconds have passed
-*
-* On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
-* @param callback Callback to debounce
-* @param time Time in milliseconds to wait before calling the callback _(defaults to match frame rate)_
-* @returns Debounced callback with a `cancel` method
+* A function that does nothing, which can be useful, I guess…
 */
-function debounce(callback, time) {
-	return getLimiter(callback, false, time);
-}
+function noop() {}
 /**
 * Is the number between a minimum and maximum value?
 * @param value Value to check
@@ -946,13 +918,24 @@ function memoize(callback, options) {
 }
 const DEFAULT_CACHE_SIZE = 1024;
 /**
+* Debounce a function, ensuring it is only called after `time` milliseconds have passed
+*
+* On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
+* @param callback Callback to debounce
+* @param time Time in milliseconds to wait before calling the callback _(defaults to match frame rate)_
+* @returns Debounced callback with a `cancel` method
+*/
+function debounce(callback, time) {
+	return getTimer(TIMER_DEBOUNCE, callback, time);
+}
+/**
 * Throttle a function, ensuring it is only called once every `time` milliseconds
 * @param callback Callback to throttle
 * @param time Time in milliseconds to wait before calling the callback again _(defaults to match frame rate)_
 * @returns Throttled callback with a `cancel` method
 */
 function throttle(callback, time) {
-	return getLimiter(callback, true, time);
+	return getTimer(TIMER_THROTTLE, callback, time);
 }
 function _isResult(value, okValue) {
 	if (!isPlainObject(value)) return false;
@@ -1053,10 +1036,6 @@ const MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
 const MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
 const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_FLOW_ARRAY, TypeError);
 const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_PIPE_ARRAY, TypeError);
-/**
-* A function that does nothing, which can be useful, I guess…
-*/
-function noop() {}
 function equal(first, second, options) {
 	return equalValue(first, second, getEqualOptions(options));
 }
@@ -3147,23 +3126,19 @@ async function toResult(value) {
 }
 async function getTimedPromise(promise, time, signal) {
 	function abort() {
-		cancelAnimationFrame(frame);
+		timer.cancel();
 		rejector(signal.reason);
 	}
-	function run(now) {
-		start ??= now;
-		if (time === 0 || now - start >= time - 5) settlePromise(abort, rejector, new PromiseTimeoutError(), signal);
-		else frame = requestAnimationFrame(run);
-	}
 	signal?.addEventListener(PROMISE_EVENT_NAME, abort, PROMISE_ABORT_OPTIONS);
-	let frame;
+	const timer = getTimer(TIMER_WAIT, () => {
+		settlePromise(abort, rejector, new PromiseTimeoutError(), signal);
+	}, time);
 	let rejector;
-	let start;
 	return Promise.race([promise, new Promise((_, reject) => {
 		rejector = reject;
-		frame = requestAnimationFrame(run);
+		timer();
 	})]).then((value) => {
-		cancelAnimationFrame(frame);
+		timer.cancel();
 		signal?.removeEventListener(PROMISE_EVENT_NAME, abort);
 		return value;
 	});
@@ -3178,24 +3153,20 @@ function delay(options) {
 	const { signal, time } = getPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
 	function abort() {
-		cancelAnimationFrame(frame);
+		timer.cancel();
 		rejector(signal.reason);
 	}
-	function run(now) {
-		start ??= now;
-		if (now - start >= time - 5) settlePromise(abort, resolver, void 0, signal);
-		else frame = requestAnimationFrame(run);
-	}
+	const timer = getTimer(TIMER_WAIT, () => {
+		settlePromise(abort, resolver, void 0, signal);
+	}, time);
 	signal?.addEventListener("abort", abort, PROMISE_ABORT_OPTIONS);
-	let frame;
 	let rejector;
 	let resolver;
-	let start;
 	return new Promise((resolve, reject) => {
 		rejector = reject;
 		resolver = resolve;
 		if (time === 0) settlePromise(abort, resolve, void 0, signal);
-		else frame = requestAnimationFrame(run);
+		else timer();
 	});
 }
 async function attemptPromise(value, options) {
@@ -3725,4 +3696,4 @@ var SizedSet = class extends Set {
 		}
 	}
 };
-export { CancelablePromise, frame_rate_default as FRAME_RATE_MS, PromiseTimeoutError, QueueError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PromiseTimeoutError, QueueError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };

package/dist/function/index.js

@@ -0,0 +1,24 @@
+import { noop } from "../internal/function/misc.js";
+import { TIMER_DEBOUNCE, TIMER_THROTTLE, getTimer } from "../internal/function/timer.js";
+import { memoize } from "./memoize.js";
+/**
+* Debounce a function, ensuring it is only called after `time` milliseconds have passed
+*
+* On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
+* @param callback Callback to debounce
+* @param time Time in milliseconds to wait before calling the callback _(defaults to match frame rate)_
+* @returns Debounced callback with a `cancel` method
+*/
+function debounce(callback, time) {
+	return getTimer(TIMER_DEBOUNCE, callback, time);
+}
+/**
+* Throttle a function, ensuring it is only called once every `time` milliseconds
+* @param callback Callback to throttle
+* @param time Time in milliseconds to wait before calling the callback again _(defaults to match frame rate)_
+* @returns Throttled callback with a `cancel` method
+*/
+function throttle(callback, time) {
+	return getTimer(TIMER_THROTTLE, callback, time);
+}
+export { debounce, memoize, noop, throttle };

package/dist/index.js

@@ -36,11 +36,9 @@ import { rgbToHex, rgbToHsl, rgbToHsla } from "./color/space/rgb.js";
 import { getNormalizedHex, hexToHsl, hexToHsla, hexToRgb, hexToRgba } from "./color/space/hex.js";
 import { hslToHex, hslToRgb, hslToRgba } from "./color/space/hsl.js";
 import { getColor } from "./color/index.js";
-import frame_rate_default from "./internal/frame-rate.js";
-import { debounce } from "./function/debounce.js";
 import { SizedMap } from "./sized/map.js";
 import { memoize } from "./function/memoize.js";
-import { throttle } from "./function/throttle.js";
+import { debounce, throttle } from "./function/index.js";
 import { isError, isOk, isResult } from "./internal/result.js";
 import { flow, pipe } from "./function/work.js";
 import { equal } from "./internal/value/equal.js";
@@ -72,4 +70,4 @@ import { QueueError, queue } from "./queue.js";
 import { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomHex, getRandomItem, getRandomItems } from "./random.js";
 import { attempt } from "./result/index.js";
 import { SizedSet } from "./sized/set.js";
-export { CancelablePromise, frame_rate_default as FRAME_RATE_MS, PromiseTimeoutError, QueueError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, fromQuery, toPromise as fromResult, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toPromise, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PromiseTimeoutError, QueueError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, fromQuery, toPromise as fromResult, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, times, titleCase, toMap, toPromise, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, unique, unsmush, unwrap, update, upperCase, words };

package/dist/internal/function/timer.js

@@ -0,0 +1,31 @@
+function getInterval(value) {
+	return typeof value === "number" && value > 0 ? value : 0;
+}
+function getTimer(type, callback, time) {
+	const interval = getInterval(time);
+	function run(now) {
+		start ??= now;
+		if (interval === 0 || now - start >= interval - OFFSET) {
+			if (throttle) start = now;
+			callback(...args);
+		} else frame = requestAnimationFrame(run);
+	}
+	const throttle = type === TIMER_THROTTLE;
+	let args;
+	let frame;
+	let start;
+	const timer = (...parameters) => {
+		timer.cancel();
+		args = parameters;
+		frame = requestAnimationFrame(run);
+	};
+	timer.cancel = () => {
+		cancelAnimationFrame(frame);
+	};
+	return timer;
+}
+var OFFSET = 5;
+const TIMER_DEBOUNCE = "debounce";
+const TIMER_THROTTLE = "throttle";
+const TIMER_WAIT = "wait";
+export { TIMER_DEBOUNCE, TIMER_THROTTLE, TIMER_WAIT, getTimer };

package/dist/promise/delay.js

@@ -1,3 +1,4 @@
+import { TIMER_WAIT, getTimer } from "../internal/function/timer.js";
 import { PROMISE_ABORT_OPTIONS } from "./models.js";
 import { getPromiseOptions } from "./helpers.js";
 import { settlePromise } from "./misc.js";
@@ -5,24 +6,20 @@ function delay(options) {
 	const { signal, time } = getPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
 	function abort() {
-		cancelAnimationFrame(frame);
+		timer.cancel();
 		rejector(signal.reason);
 	}
-	function run(now) {
-		start ??= now;
-		if (now - start >= time - 5) settlePromise(abort, resolver, void 0, signal);
-		else frame = requestAnimationFrame(run);
-	}
+	const timer = getTimer(TIMER_WAIT, () => {
+		settlePromise(abort, resolver, void 0, signal);
+	}, time);
 	signal?.addEventListener("abort", abort, PROMISE_ABORT_OPTIONS);
-	let frame;
 	let rejector;
 	let resolver;
-	let start;
 	return new Promise((resolve, reject) => {
 		rejector = reject;
 		resolver = resolve;
 		if (time === 0) settlePromise(abort, resolve, void 0, signal);
-		else frame = requestAnimationFrame(run);
+		else timer();
 	});
 }
 export { delay };

package/dist/promise/timed.js

@@ -1,25 +1,22 @@
+import { TIMER_WAIT, getTimer } from "../internal/function/timer.js";
 import { PROMISE_ABORT_OPTIONS, PROMISE_EVENT_NAME, PROMISE_MESSAGE_EXPECTATION_TIMED, PromiseTimeoutError } from "./models.js";
 import { getPromiseOptions } from "./helpers.js";
 import { settlePromise } from "./misc.js";
 async function getTimedPromise(promise, time, signal) {
 	function abort() {
-		cancelAnimationFrame(frame);
+		timer.cancel();
 		rejector(signal.reason);
 	}
-	function run(now) {
-		start ??= now;
-		if (time === 0 || now - start >= time - 5) settlePromise(abort, rejector, new PromiseTimeoutError(), signal);
-		else frame = requestAnimationFrame(run);
-	}
 	signal?.addEventListener(PROMISE_EVENT_NAME, abort, PROMISE_ABORT_OPTIONS);
-	let frame;
+	const timer = getTimer(TIMER_WAIT, () => {
+		settlePromise(abort, rejector, new PromiseTimeoutError(), signal);
+	}, time);
 	let rejector;
-	let start;
 	return Promise.race([promise, new Promise((_, reject) => {
 		rejector = reject;
-		frame = requestAnimationFrame(run);
+		timer();
 	})]).then((value) => {
-		cancelAnimationFrame(frame);
+		timer.cancel();
 		signal?.removeEventListener(PROMISE_EVENT_NAME, abort);
 		return value;
 	});

package/package.json

@@ -50,26 +50,10 @@
 			"types": "./types/color/index.d.ts",
 			"default": "./dist/color/index.js"
 		},
-		"./frame-rate": {
-			"types": "./types/internal/frame-rate.d.ts",
-			"default": "./dist/internal/frame-rate.js"
-		},
-		"./function/debounce": {
-			"types": "./types/function/debounce.d.ts",
-			"default": "./dist/function/debounce.js"
-		},
-		"./function/memoize": {
+		"./function": {
 			"types": "./types/function/memoize.d.ts",
 			"default": "./dist/function/memoize.js"
 		},
-		"./function/misc": {
-			"types": "./types/function/misc.d.ts",
-			"default": "./dist/function/misc.js"
-		},
-		"./function/throttle": {
-			"types": "./types/function/throttle.d.ts",
-			"default": "./dist/function/throttle.js"
-		},
 		"./function/work": {
 			"types": "./types/function/work.d.ts",
 			"default": "./dist/function/work.js"
@@ -192,5 +176,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.150.0"
+	"version": "0.152.0"
 }

package/src/function/index.ts

@@ -0,0 +1,41 @@
+import {getTimer, TIMER_DEBOUNCE, TIMER_THROTTLE} from '../internal/function/timer';
+import type {CancelableCallback, GenericCallback} from '../models';
+
+// #region Functions
+
+/**
+ * Debounce a function, ensuring it is only called after `time` milliseconds have passed
+ *
+ * On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
+ * @param callback Callback to debounce
+ * @param time Time in milliseconds to wait before calling the callback _(defaults to match frame rate)_
+ * @returns Debounced callback with a `cancel` method
+ */
+export function debounce<Callback extends GenericCallback>(
+	callback: Callback,
+	time?: number,
+): CancelableCallback<Callback> {
+	return getTimer(TIMER_DEBOUNCE, callback, time);
+}
+
+/**
+ * Throttle a function, ensuring it is only called once every `time` milliseconds
+ * @param callback Callback to throttle
+ * @param time Time in milliseconds to wait before calling the callback again _(defaults to match frame rate)_
+ * @returns Throttled callback with a `cancel` method
+ */
+export function throttle<Callback extends GenericCallback>(
+	callback: Callback,
+	time?: number,
+): CancelableCallback<Callback> {
+	return getTimer(TIMER_THROTTLE, callback, time);
+}
+
+// #endregion
+
+// #region Exports
+
+export {noop} from '../internal/function/misc';
+export {memoize, type Memoized, type MemoizedOptions} from './memoize';
+
+// #endregion

package/src/index.ts

@@ -1,14 +1,10 @@
-import FRAME_RATE_MS from './internal/frame-rate';
-
 export * from './array/group-by';
 export * from './array/misc';
 export * from './array/to-map';
 export * from './array/to-record';
 export * from './array/unique';
 
-export * from './function/debounce';
-export * from './function/memoize';
-export * from './function/throttle';
+export * from './function/index';
 export * from './function/work';
 
 export * from './internal/function/misc';
@@ -45,5 +41,3 @@ export * from './random';
 export * from './result/index';
 export * from './sized/map';
 export * from './sized/set';
-
-export {FRAME_RATE_MS};

package/src/internal/function/timer.ts

@@ -0,0 +1,68 @@
+import type {CancelableCallback, GenericCallback} from '../../models';
+
+// #region Types
+
+type TimerType = 'debounce' | 'throttle' | 'wait';
+
+// #endregion
+
+// #region Functions
+
+function getInterval(value: unknown): number {
+	return typeof value === 'number' && value > 0 ? value : 0;
+}
+
+export function getTimer<Callback extends GenericCallback>(
+	type: TimerType,
+	callback: Callback,
+	time?: number,
+): CancelableCallback<Callback> {
+	const interval = getInterval(time);
+
+	function run(now: DOMHighResTimeStamp): void {
+		start ??= now;
+
+		if (interval === 0 || now - start >= interval - OFFSET) {
+			if (throttle) {
+				start = now;
+			}
+
+			callback(...args);
+		} else {
+			frame = requestAnimationFrame(run);
+		}
+	}
+
+	const throttle = type === TIMER_THROTTLE;
+
+	let args: Parameters<Callback>;
+	let frame: DOMHighResTimeStamp | undefined;
+	let start: DOMHighResTimeStamp;
+
+	const timer = (...parameters: Parameters<Callback>): void => {
+		timer.cancel();
+
+		args = parameters;
+		frame = requestAnimationFrame(run);
+	};
+
+	timer.cancel = (): void => {
+		cancelAnimationFrame(frame!);
+	};
+
+	return timer as CancelableCallback<Callback>;
+}
+
+// #endregion
+
+// #region Variables
+
+const OFFSET = 5;
+
+export const TIMER_DEBOUNCE: TimerType = 'debounce';
+
+export const TIMER_THROTTLE: TimerType = 'throttle';
+
+export const TIMER_WAIT: TimerType = 'wait';
+
+// #endregion

package/src/promise/delay.ts

@@ -1,3 +1,4 @@
+import {getTimer, TIMER_WAIT} from '../internal/function/timer';
 import {getPromiseOptions} from './helpers';
 import {settlePromise} from './misc';
 import {PROMISE_ABORT_OPTIONS, type PromiseOptions} from './models';
@@ -26,27 +27,23 @@ export function delay(options?: unknown): Promise<void> {
 	}
 
 	function abort(): void {
-		cancelAnimationFrame(frame);
+		timer.cancel();
 
 		rejector(signal!.reason);
 	}
 
-	function run(now: DOMHighResTimeStamp): void {
-		start ??= now;
-
-		if (now - start >= time - 5) {
+	const timer = getTimer(
+		TIMER_WAIT,
+		() => {
 			settlePromise(abort, resolver, undefined, signal);
-		} else {
-			frame = requestAnimationFrame(run);
-		}
-	}
+		},
+		time,
+	);
 
 	signal?.addEventListener('abort', abort, PROMISE_ABORT_OPTIONS);
 
-	let frame: DOMHighResTimeStamp;
 	let rejector: (reason: unknown) => void;
 	let resolver: () => void;
-	let start: DOMHighResTimeStamp;
 
 	return new Promise((resolve, reject) => {
 		rejector = reject;
@@ -55,7 +52,7 @@ export function delay(options?: unknown): Promise<void> {
 		if (time === 0) {
 			settlePromise(abort, resolve, undefined, signal);
 		} else {
-			frame = requestAnimationFrame(run);
+			timer();
 		}
 	});
 }

package/src/promise/timed.ts

@@ -1,3 +1,4 @@
+import {getTimer, TIMER_WAIT} from '../internal/function/timer';
 import type {RequiredKeys} from '../models';
 import {getPromiseOptions} from './helpers';
 import {settlePromise} from './misc';
@@ -17,36 +18,32 @@ export async function getTimedPromise<Value>(
 	signal?: AbortSignal,
 ): Promise<Value> {
 	function abort(): void {
-		cancelAnimationFrame(frame);
+		timer.cancel();
 
 		rejector(signal!.reason);
 	}
 
-	function run(now: DOMHighResTimeStamp): void {
-		start ??= now;
+	signal?.addEventListener(PROMISE_EVENT_NAME, abort, PROMISE_ABORT_OPTIONS);
 
-		if (time === 0 || now - start >= time - 5) {
+	const timer = getTimer(
+		TIMER_WAIT,
+		() => {
 			settlePromise(abort, rejector, new PromiseTimeoutError(), signal);
-		} else {
-			frame = requestAnimationFrame(run);
-		}
-	}
-
-	signal?.addEventListener(PROMISE_EVENT_NAME, abort, PROMISE_ABORT_OPTIONS);
+		},
+		time,
+	);
 
-	let frame: DOMHighResTimeStamp;
 	let rejector: (reason: unknown) => void;
-	let start: DOMHighResTimeStamp;
 
 	return Promise.race<Value>([
 		promise,
 		new Promise((_, reject) => {
 			rejector = reject;
 
-			frame = requestAnimationFrame(run);
+			timer();
 		}),
 	]).then(value => {
-		cancelAnimationFrame(frame);
+		timer.cancel();
 
 		signal?.removeEventListener(PROMISE_EVENT_NAME, abort);
 

package/types/function/{debounce.d.ts → index.d.ts}

@@ -8,3 +8,12 @@ import type { CancelableCallback, GenericCallback } from '../models';
  * @returns Debounced callback with a `cancel` method
  */
 export declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
+/**
+ * Throttle a function, ensuring it is only called once every `time` milliseconds
+ * @param callback Callback to throttle
+ * @param time Time in milliseconds to wait before calling the callback again _(defaults to match frame rate)_
+ * @returns Throttled callback with a `cancel` method
+ */
+export declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
+export { noop } from '../internal/function/misc';
+export { memoize, type Memoized, type MemoizedOptions } from './memoize';

package/types/index.d.ts

@@ -1,12 +1,9 @@
-import FRAME_RATE_MS from './internal/frame-rate';
 export * from './array/group-by';
 export * from './array/misc';
 export * from './array/to-map';
 export * from './array/to-record';
 export * from './array/unique';
-export * from './function/debounce';
-export * from './function/memoize';
-export * from './function/throttle';
+export * from './function/index';
 export * from './function/work';
 export * from './internal/function/misc';
 export * from './internal/string';
@@ -39,4 +36,3 @@ export * from './random';
 export * from './result/index';
 export * from './sized/map';
 export * from './sized/set';
-export { FRAME_RATE_MS };

package/types/internal/function/timer.d.ts

@@ -0,0 +1,7 @@
+import type { CancelableCallback, GenericCallback } from '../../models';
+type TimerType = 'debounce' | 'throttle' | 'wait';
+export declare function getTimer<Callback extends GenericCallback>(type: TimerType, callback: Callback, time?: number): CancelableCallback<Callback>;
+export declare const TIMER_DEBOUNCE: TimerType;
+export declare const TIMER_THROTTLE: TimerType;
+export declare const TIMER_WAIT: TimerType;
+export {};

package/dist/function/debounce.js

@@ -1,13 +0,0 @@
-import { getLimiter } from "../internal/function/limiter.js";
-/**
-* Debounce a function, ensuring it is only called after `time` milliseconds have passed
-*
-* On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
-* @param callback Callback to debounce
-* @param time Time in milliseconds to wait before calling the callback _(defaults to match frame rate)_
-* @returns Debounced callback with a `cancel` method
-*/
-function debounce(callback, time) {
-	return getLimiter(callback, false, time);
-}
-export { debounce };

package/dist/function/misc.js

@@ -1,2 +0,0 @@
-import { noop } from "../internal/function/misc.js";
-export { noop };

package/dist/function/throttle.js

@@ -1,11 +0,0 @@
-import { getLimiter } from "../internal/function/limiter.js";
-/**
-* Throttle a function, ensuring it is only called once every `time` milliseconds
-* @param callback Callback to throttle
-* @param time Time in milliseconds to wait before calling the callback again _(defaults to match frame rate)_
-* @returns Throttled callback with a `cancel` method
-*/
-function throttle(callback, time) {
-	return getLimiter(callback, true, time);
-}
-export { throttle };

package/dist/internal/frame-rate.js

@@ -1,25 +0,0 @@
-function calculate() {
-	return new Promise((resolve) => {
-		const values = [];
-		let last;
-		function step(now) {
-			if (last != null) values.push(now - last);
-			last = now;
-			if (values.length >= TOTAL) resolve(values.sort().slice(TRIM_PART, -TRIM_PART).reduce((first, second) => first + second, 0) / (values.length - TRIM_TOTAL));
-			else requestAnimationFrame(step);
-		}
-		requestAnimationFrame(step);
-	});
-}
-var TOTAL = 10;
-var TRIM_PART = 2;
-var TRIM_TOTAL = 4;
-var FRAME_RATE_MS = 1e3 / 60;
-/**
-* A calculated average of the refresh rate of the display _(in milliseconds)_
-*/
-calculate().then((value) => {
-	FRAME_RATE_MS = value;
-});
-var frame_rate_default = FRAME_RATE_MS;
-export { frame_rate_default as default };

package/dist/internal/function/limiter.js

@@ -1,29 +0,0 @@
-import frame_rate_default from "../frame-rate.js";
-function getLimiter(callback, throttler, time) {
-	const interval = typeof time === "number" && time >= frame_rate_default ? time : frame_rate_default;
-	function step(now, parameters) {
-		if (interval === frame_rate_default || now - timestamp >= interval) {
-			if (throttler) timestamp = now;
-			callback(...parameters);
-		} else frame = requestAnimationFrame((next) => {
-			step(next, parameters);
-		});
-	}
-	let frame;
-	let timestamp;
-	const limiter = (...parameters) => {
-		limiter.cancel();
-		frame = requestAnimationFrame((now) => {
-			timestamp ??= now - frame_rate_default;
-			step(now, parameters);
-		});
-	};
-	limiter.cancel = () => {
-		if (frame != null) {
-			cancelAnimationFrame(frame);
-			frame = void 0;
-		}
-	};
-	return limiter;
-}
-export { getLimiter };

package/src/function/debounce.ts

@@ -1,21 +0,0 @@
-import {getLimiter} from '../internal/function/limiter';
-import type {CancelableCallback, GenericCallback} from '../models';
-
-// #region Functions
-
-/**
- * Debounce a function, ensuring it is only called after `time` milliseconds have passed
- *
- * On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
- * @param callback Callback to debounce
- * @param time Time in milliseconds to wait before calling the callback _(defaults to match frame rate)_
- * @returns Debounced callback with a `cancel` method
- */
-export function debounce<Callback extends GenericCallback>(
-	callback: Callback,
-	time?: number,
-): CancelableCallback<Callback> {
-	return getLimiter(callback, false, time);
-}
-
-// #endregion

package/src/function/misc.ts

@@ -1 +0,0 @@
-export {noop} from '../internal/function/misc';

package/src/function/throttle.ts

@@ -1,19 +0,0 @@
-import {getLimiter} from '../internal/function/limiter';
-import type {CancelableCallback, GenericCallback} from '../models';
-
-// #region Functions
-
-/**
- * Throttle a function, ensuring it is only called once every `time` milliseconds
- * @param callback Callback to throttle
- * @param time Time in milliseconds to wait before calling the callback again _(defaults to match frame rate)_
- * @returns Throttled callback with a `cancel` method
- */
-export function throttle<Callback extends GenericCallback>(
-	callback: Callback,
-	time?: number,
-): CancelableCallback<Callback> {
-	return getLimiter(callback, true, time);
-}
-
-// #endregion

package/src/internal/frame-rate.ts

@@ -1,63 +0,0 @@
-// #region Functions
-
-function calculate(): Promise<number> {
-	return new Promise(resolve => {
-		const values: number[] = [];
-
-		let last: DOMHighResTimeStamp;
-
-		function step(now: DOMHighResTimeStamp): void {
-			if (last != null) {
-				values.push(now - last);
-			}
-
-			last = now;
-
-			if (values.length >= TOTAL) {
-				const median =
-					values
-						.sort()
-						.slice(TRIM_PART, -TRIM_PART)
-						.reduce((first, second) => first + second, 0) /
-					(values.length - TRIM_TOTAL);
-
-				resolve(median);
-			} else {
-				requestAnimationFrame(step);
-			}
-		}
-
-		requestAnimationFrame(step);
-	});
-}
-
-// #endregion
-
-// #region Variables
-
-const TOTAL = 10;
-
-const TRIM_PART = 2;
-
-const TRIM_TOTAL = 4;
-
-let FRAME_RATE_MS = 1000 / 60;
-
-// #endregion
-
-// #region Initialization
-
-/**
- * A calculated average of the refresh rate of the display _(in milliseconds)_
- */
-calculate().then(value => {
-	FRAME_RATE_MS = value;
-});
-
-// #endregion
-
-// #region Exports
-
-export default FRAME_RATE_MS;
-
-// #endregion

package/src/internal/function/limiter.ts

@@ -1,52 +0,0 @@
-import type {CancelableCallback} from '../../models';
-import type {GenericCallback} from '../../models';
-import FRAME_RATE_MS from '../frame-rate';
-
-// #region Functions
-
-export function getLimiter<Callback extends GenericCallback>(
-	callback: Callback,
-	throttler: boolean,
-	time?: number,
-): CancelableCallback<Callback> {
-	const interval = typeof time === 'number' && time >= FRAME_RATE_MS ? time : FRAME_RATE_MS;
-
-	function step(now: DOMHighResTimeStamp, parameters: Parameters<Callback>): void {
-		if (interval === FRAME_RATE_MS || now - timestamp >= interval) {
-			if (throttler) {
-				timestamp = now;
-			}
-
-			callback(...parameters);
-		} else {
-			frame = requestAnimationFrame(next => {
-				step(next, parameters);
-			});
-		}
-	}
-
-	let frame: DOMHighResTimeStamp | undefined;
-	let timestamp: DOMHighResTimeStamp;
-
-	const limiter = (...parameters: Parameters<Callback>): void => {
-		limiter.cancel();
-
-		frame = requestAnimationFrame(now => {
-			timestamp ??= now - FRAME_RATE_MS;
-
-			step(now, parameters);
-		});
-	};
-
-	limiter.cancel = (): void => {
-		if (frame != null) {
-			cancelAnimationFrame(frame);
-
-			frame = undefined;
-		}
-	};
-
-	return limiter as CancelableCallback<Callback>;
-}
-
-// #endregion

package/types/function/misc.d.ts

@@ -1 +0,0 @@
-export { noop } from '../internal/function/misc';

package/types/function/throttle.d.ts

@@ -1,8 +0,0 @@
-import type { CancelableCallback, GenericCallback } from '../models';
-/**
- * Throttle a function, ensuring it is only called once every `time` milliseconds
- * @param callback Callback to throttle
- * @param time Time in milliseconds to wait before calling the callback again _(defaults to match frame rate)_
- * @returns Throttled callback with a `cancel` method
- */
-export declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;

package/types/internal/frame-rate.d.ts

@@ -1,2 +0,0 @@
-declare let FRAME_RATE_MS: number;
-export default FRAME_RATE_MS;

package/types/internal/function/limiter.d.ts

@@ -1,3 +0,0 @@
-import type { CancelableCallback } from '../../models';
-import type { GenericCallback } from '../../models';
-export declare function getLimiter<Callback extends GenericCallback>(callback: Callback, throttler: boolean, time?: number): CancelableCallback<Callback>;