@oscarpalmer/atoms 0.151.0 → 0.152.0

package/dist/atoms.full.js

@@ -677,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 > 0 ? time : 0;
-	function step(now, parameters) {
-		if (interval === 0 || 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;
-			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
@@ -922,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;
@@ -1029,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));
 }
@@ -3123,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;
 	});
@@ -3154,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) {

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,10 +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 { 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";

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.151.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

@@ -4,9 +4,7 @@ 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';

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

@@ -3,9 +3,7 @@ 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';

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/function/limiter.js

@@ -1,28 +0,0 @@
-function getLimiter(callback, throttler, time) {
-	const interval = typeof time === "number" && time > 0 ? time : 0;
-	function step(now, parameters) {
-		if (interval === 0 || 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;
-			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/function/limiter.ts

@@ -1,51 +0,0 @@
-import type {CancelableCallback} from '../../models';
-import type {GenericCallback} from '../../models';
-
-// #region Functions
-
-export function getLimiter<Callback extends GenericCallback>(
-	callback: Callback,
-	throttler: boolean,
-	time?: number,
-): CancelableCallback<Callback> {
-	const interval = typeof time === 'number' && time > 0 ? time : 0;;
-
-	function step(now: DOMHighResTimeStamp, parameters: Parameters<Callback>): void {
-		if (interval === 0 || 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;
-
-			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/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>;