@oscarpalmer/atoms 0.133.0 → 0.134.0

package/dist/atoms.full.js

@@ -1974,28 +1974,98 @@ function sum(array, key) {
 var PromiseTimeoutError = class extends Error {
 	constructor() {
 		super(MESSAGE_TIMEOUT);
-		this.name = NAME;
+		this.name = ERROR_NAME$1;
 	}
 };
-/**
-* Create a delayed promise that resolves after a certain amount of time
-* @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
-* @returns A promise that resolves after the delay
-*/
-function delay(time) {
-	return new Promise((resolve) => setTimeout(resolve, getNumberOrDefault$1(time)));
+function delay(options) {
+	const { signal, time } = getPromiseOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	function abort() {
+		clearTimeout(timeout);
+		rejector(signal.reason);
+	}
+	signal?.addEventListener("abort", abort, abortOptions$1);
+	let rejector;
+	let timeout;
+	return new Promise((resolve, reject) => {
+		rejector = reject;
+		timeout = setTimeout(() => {
+			signal?.removeEventListener("abort", abort);
+			resolve();
+		}, time);
+	});
 }
 function getBooleanOrDefault$1(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue;
 }
 function getNumberOrDefault$1(value) {
-	return typeof value === "number" ? value : 0;
+	return typeof value === "number" && value > 0 ? value : 0;
+}
+function getPromiseOptions(input) {
+	if (typeof input === "number") return { time: getNumberOrDefault$1(input) };
+	const options = typeof input === "object" && input !== null ? input : {};
+	return {
+		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
+		time: getNumberOrDefault$1(options.time)
+	};
+}
+function getPromisesOptions(input) {
+	if (typeof input === "boolean") return { eager: input };
+	if (input instanceof AbortSignal) return {
+		eager: false,
+		signal: input
+	};
+	const options = typeof input === "object" && input !== null ? input : {};
+	return {
+		eager: getBooleanOrDefault$1(options.eager, false),
+		signal: options.signal instanceof AbortSignal ? options.signal : void 0
+	};
+}
+function handleResult(status, parameters) {
+	const { data, eager, handlers, index, signal, value } = parameters;
+	if (signal?.aborted ?? false) return;
+	if (eager && status === TYPE_REJECTED) {
+		handlers.reject(value);
+		return;
+	}
+	data.result[index] = eager ? value : status === TYPE_FULFILLED ? {
+		status,
+		value
+	} : {
+		status,
+		reason: value
+	};
+	if (index === data.last) handlers.resolve(data.result);
+}
+/**
+* Is the value a fulfilled promise result?
+* @param value Value to check
+* @returns `true` if the value is a fulfilled promise result, `false` otherwise
+*/
+function isFulfilled(value) {
+	return isType(value, TYPE_FULFILLED);
+}
+/**
+* Is the value a rejected promise result?
+* @param value Value to check
+* @returns `true` if the value is a rejected promise result, `false` otherwise
+*/
+function isRejected(value) {
+	return isType(value, TYPE_REJECTED);
 }
-async function promises(items, eager) {
+function isType(value, type) {
+	return typeof value === "object" && value !== null && value.status === type;
+}
+async function promises(items, options) {
 	const actual = items.filter((item) => item instanceof Promise);
-	if (actual.length === 0) return actual;
-	const isEager = getBooleanOrDefault$1(eager, false);
 	const { length } = actual;
+	const { eager, signal } = getPromisesOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	if (length === 0) return actual;
+	function abort() {
+		handlers.reject(signal.reason);
+	}
+	signal?.addEventListener("abort", abort, abortOptions$1);
 	const data = {
 		last: length - 1,
 		result: []
@@ -2006,34 +2076,48 @@ async function promises(items, eager) {
 			reject,
 			resolve
 		};
-		for (let index = 0; index < length; index += 1) actual[index].then((value) => resolveResult(index, data, handlers, value, isEager)).catch((reason) => rejectResult(index, data, handlers, reason, isEager));
+		for (let index = 0; index < length; index += 1) actual[index].then((value) => handleResult(TYPE_FULFILLED, {
+			data,
+			eager,
+			handlers,
+			index,
+			signal,
+			value
+		})).catch((reason) => handleResult(TYPE_REJECTED, {
+			data,
+			eager,
+			handlers,
+			index,
+			signal,
+			value: reason
+		}));
 	});
 }
-function rejectResult(index, data, handlers, reason, eager) {
-	if (eager) handlers.reject(reason);
-	else {
-		data.result[index] = {
-			status: TYPE_REJECTED,
-			reason
-		};
-		if (index === data.last) handlers.resolve(data.result);
-	}
-}
-function resolveResult(index, data, handlers, value, eager) {
-	data.result[index] = eager ? value : {
-		status: TYPE_FULFILLED,
-		value
-	};
-	if (index === data.last) handlers.resolve(data.result);
-}
-function timed(promise, timeout) {
+function timed(promise, options) {
 	if (!(promise instanceof Promise)) throw new TypeError(MESSAGE_EXPECTATION);
-	if (getNumberOrDefault$1(timeout) <= 0) return promise;
-	return Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new PromiseTimeoutError()), timeout))]);
-}
+	const { signal, time } = getPromiseOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	if (time <= 0) return promise;
+	function abort() {
+		clearTimeout(timeout);
+		rejector(signal.reason);
+	}
+	signal?.addEventListener(EVENT_NAME$1, abort, abortOptions$1);
+	let rejector;
+	let timeout;
+	return Promise.race([promise, new Promise((_, reject) => {
+		rejector = reject;
+		timeout = setTimeout(() => {
+			signal?.removeEventListener(EVENT_NAME$1, abort);
+			reject(new PromiseTimeoutError());
+		}, time);
+	})]);
+}
+const abortOptions$1 = { once: true };
+const ERROR_NAME$1 = "PromiseTimeoutError";
+const EVENT_NAME$1 = "abort";
 const MESSAGE_EXPECTATION = "Timed function expected a Promise";
 const MESSAGE_TIMEOUT = "Promise timed out";
-const NAME = "PromiseTimeoutError";
 const TYPE_FULFILLED = "fulfilled";
 const TYPE_REJECTED = "rejected";
 var Queue = class {
@@ -2082,23 +2166,30 @@ var Queue = class {
 	/**
 	* Add an item to the queue
 	* @param parameters Parameters to use when item runs
+	* @param signal Optional signal to abort the item
 	* @returns Queued item
 	*/
-	add(...parameters) {
+	add(parameters, signal) {
 		if (this.full) throw new QueueError(MESSAGE_MAXIMUM);
+		const abortSignal = signal instanceof AbortSignal ? signal : void 0;
+		if (abortSignal?.aborted ?? false) throw new Error(abortSignal.reason);
+		const id = this.#identify();
 		let rejector;
 		let resolver;
-		const id = this.#identify();
 		const promise = new Promise((resolve, reject) => {
 			rejector = reject;
 			resolver = resolve;
 		});
+		const aborter = abortSignal == null ? void 0 : () => rejector(abortSignal.reason);
+		signal?.addEventListener(EVENT_NAME, aborter, abortOptions);
 		this.#items.push({
 			id,
 			parameters,
 			promise,
+			abort: aborter,
 			reject: rejector,
-			resolve: resolver
+			resolve: resolver,
+			signal: abortSignal
 		});
 		if (this.#options.autostart) this.#run();
 		return {
@@ -2112,7 +2203,11 @@ var Queue = class {
 	clear() {
 		const items = this.#items.splice(0);
 		const { length } = items;
-		for (let index = 0; index < length; index += 1) items[index].reject(new QueueError(MESSAGE_CLEAR));
+		for (let index = 0; index < length; index += 1) {
+			const { abort, reject, signal } = items[index];
+			reject(new QueueError(MESSAGE_CLEAR));
+			signal?.removeEventListener(EVENT_NAME, abort);
+		}
 	}
 	/**
 	* Pause the queue
@@ -2130,8 +2225,9 @@ var Queue = class {
 	remove(id) {
 		const index = this.#items.findIndex((item) => item.id === id);
 		if (index > -1) {
-			const [item] = this.#items.splice(index, 1);
-			item.reject(new QueueError(MESSAGE_REMOVE));
+			const { abort, reject, signal } = this.#items.splice(index, 1)[0];
+			reject(new QueueError(MESSAGE_REMOVE));
+			signal?.removeEventListener(EVENT_NAME, abort);
 		}
 	}
 	/**
@@ -2159,17 +2255,24 @@ var Queue = class {
 			let handler;
 			let result;
 			try {
-				result = await this.#callback(...item.parameters);
-				handler = item.resolve;
+				if (!(item.signal?.aborted ?? false)) {
+					result = await this.#callback(...item.parameters);
+					handler = item.resolve;
+				}
 			} catch (thrown) {
 				result = thrown;
 				handler = item.reject;
 			}
 			if (this.#paused) {
-				this.#handled.push(() => handler(result));
+				const paused = item;
+				this.#handled.push(() => {
+					paused.signal?.removeEventListener(EVENT_NAME, paused.abort);
+					if (!(paused.signal?.aborted ?? false)) handler(result);
+				});
 				break;
 			}
-			handler(result);
+			item.signal?.removeEventListener(EVENT_NAME, item.abort);
+			if (!(item.signal?.aborted ?? false)) handler(result);
 			item = this.#items.shift();
 		}
 		this.#runners -= 1;
@@ -2199,7 +2302,9 @@ function queue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
 	return new Queue(callback, getOptions(options));
 }
+const abortOptions = { once: true };
 const ERROR_NAME = "QueueError";
+const EVENT_NAME = "abort";
 const MESSAGE_CALLBACK = "A Queue requires a callback function";
 const MESSAGE_CLEAR = "Queue was cleared";
 const MESSAGE_MAXIMUM = "Queue has reached its maximum size";
@@ -3213,4 +3318,4 @@ function unsmush(value) {
 	}
 	return unsmushed;
 }
-export { frame_rate_default as FRAME_RATE_MS, PromiseTimeoutError, QueueError, SizedMap, SizedSet, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, fromQuery, 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, includes, indexOf, insert, isArrayOrPlainObject, isColor, isEmpty, isError, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, memoize, merge, min, noop, ok, parse, partial, pascalCase, promises, push, queue, result, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, titleCase, toMap, toQuery, toRecord, toSet, trim, truncate, unique, unsmush, unwrap, upperCase, words };
+export { frame_rate_default as FRAME_RATE_MS, PromiseTimeoutError, QueueError, SizedMap, SizedSet, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, fromQuery, 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, includes, indexOf, insert, isArrayOrPlainObject, isColor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, memoize, merge, min, noop, ok, parse, partial, pascalCase, promises, push, queue, result, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, titleCase, toMap, toQuery, toRecord, toSet, trim, truncate, unique, unsmush, unwrap, upperCase, words };

package/dist/color/misc/alpha.js

@@ -1,4 +1,4 @@
-import { ALPHA_FULL_HEX_LONG, ALPHA_FULL_VALUE, ALPHA_NONE_HEX, ALPHA_NONE_VALUE, DEFAULT_ALPHA, MAX_HEX, MAX_PERCENT } from "../constants.js";
+import { ALPHA_FULL_HEX_LONG, DEFAULT_ALPHA } from "../constants.js";
 function getAlpha(value) {
 	if (typeof value === "number") return getAlphaFromValue(value);
 	if (typeof value === "string" && value !== ALPHA_FULL_HEX_LONG) return {

package/dist/color/misc/get.js

@@ -1,4 +1,4 @@
-import { HEX_BLACK, HEX_WHITE, MAX_DEGREE, MAX_HEX, MAX_PERCENT, SRGB_LUMINANCE_BLUE, SRGB_LUMINANCE_EXPONENT, SRGB_LUMINANCE_GREEN, SRGB_LUMINANCE_MINIMUM, SRGB_LUMINANCE_MODIFIER, SRGB_LUMINANCE_MULTIPLIER, SRGB_LUMINANCE_OFFSET, SRGB_LUMINANCE_RED, SRGB_LUMINANCE_THRESHOLD } from "../constants.js";
+import { HEX_BLACK, HEX_WHITE, SRGB_LUMINANCE_EXPONENT, SRGB_LUMINANCE_MODIFIER, SRGB_LUMINANCE_MULTIPLIER, SRGB_LUMINANCE_OFFSET } from "../constants.js";
 import { clamp } from "../../internal/number.js";
 import { getState } from "./state.js";
 import { Color } from "../instance.js";

package/dist/color/misc/is.js

@@ -1,4 +1,4 @@
-import { ALPHA_FULL_VALUE, ALPHA_NONE_VALUE, EXPRESSION_HEX_LONG, EXPRESSION_HEX_SHORT, KEYS_HSL, KEYS_HSLA, KEYS_RGB, KEYS_RGBA, LENGTH_LONG, LENGTH_SHORT, MAX_DEGREE, MAX_HEX, MAX_PERCENT } from "../constants.js";
+import { EXPRESSION_HEX_LONG, EXPRESSION_HEX_SHORT, KEYS_HSL, KEYS_HSLA, KEYS_RGB, KEYS_RGBA } from "../constants.js";
 import { between } from "../../internal/number.js";
 function hasKeys(value, keys) {
 	return typeof value === "object" && value !== null && keys.every((key) => key in value);

package/dist/color/misc/state.js

@@ -1,4 +1,4 @@
-import { ALPHA_FULL_VALUE, DEFAULT_HSL, DEFAULT_RGB, HEX_BLACK, KEYS_HSL, KEYS_RGB, LENGTH_LONG } from "../constants.js";
+import { DEFAULT_HSL, DEFAULT_RGB, HEX_BLACK, KEYS_HSL, KEYS_RGB } from "../constants.js";
 import { getAlpha } from "./alpha.js";
 import { isColor, isHexColor, isHslLike, isRgbLike } from "./is.js";
 import { getDegrees, getHexValue, getPercentage } from "./get.js";

package/dist/color/space/hex.js

@@ -1,5 +1,5 @@
 import { join } from "../../internal/string.js";
-import { ALPHA_FULL_HEX_LONG, ALPHA_FULL_HEX_SHORT, EXPRESSION_HEX_LONG, EXPRESSION_PREFIX, HEX_BLACK, LENGTH_LONG, LENGTH_SHORT, MAX_HEX } from "../constants.js";
+import { ALPHA_FULL_HEX_LONG, EXPRESSION_HEX_LONG, EXPRESSION_PREFIX, HEX_BLACK } from "../constants.js";
 import { isHexColor } from "../misc/is.js";
 import { convertRgbToHsla } from "./rgb.js";
 function convertHexToRgba(value) {

package/dist/color/space/hsl.js

@@ -1,4 +1,4 @@
-import { ALPHA_FULL_VALUE, DEFAULT_HSL, MAX_DEGREE, MAX_HEX, MAX_PERCENT } from "../constants.js";
+import { DEFAULT_HSL } from "../constants.js";
 import { getAlphaValue } from "../misc/alpha.js";
 import { isHslLike } from "../misc/is.js";
 import { getDegrees, getHexValue, getPercentage } from "../misc/get.js";

package/dist/color/space/rgb.js

@@ -1,5 +1,5 @@
 import { join } from "../../internal/string.js";
-import { ALPHA_FULL_VALUE, DEFAULT_RGB, MAX_HEX, MAX_PERCENT } from "../constants.js";
+import { DEFAULT_RGB } from "../constants.js";
 import { getAlpha, getAlphaValue } from "../misc/alpha.js";
 import { isRgbLike } from "../misc/is.js";
 import { getHexValue } from "../misc/get.js";

package/dist/index.js

@@ -37,7 +37,7 @@ import { SizedMap, SizedSet } from "./sized.js";
 import { debounce, memoize, throttle } from "./function.js";
 import { logger } from "./logger.js";
 import { average, count, min, round, sum } from "./math.js";
-import { PromiseTimeoutError, delay, promises, timed } from "./promise.js";
+import { PromiseTimeoutError, delay, isFulfilled, isRejected, promises, timed } from "./promise.js";
 import { QueueError, queue } from "./queue.js";
 import { setValue } from "./internal/value/set.js";
 import { fromQuery, toQuery } from "./query.js";
@@ -56,4 +56,4 @@ import { partial } from "./value/partial.js";
 import { smush } from "./value/smush.js";
 import { unsmush } from "./value/unsmush.js";
 import "./value/index.js";
-export { frame_rate_default as FRAME_RATE_MS, PromiseTimeoutError, QueueError, SizedMap, SizedSet, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, fromQuery, 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, includes, indexOf, insert, isArrayOrPlainObject, isColor, isEmpty, isError, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, memoize, merge, min, noop, ok, parse, partial, pascalCase, promises, push, queue, result, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, titleCase, toMap, toQuery, toRecord, toSet, trim, truncate, unique, unsmush, unwrap, upperCase, words };
+export { frame_rate_default as FRAME_RATE_MS, PromiseTimeoutError, QueueError, SizedMap, SizedSet, average, beacon, between, camelCase, capitalize, chunk, clamp, clone, compact, compare, count, createUuid, debounce, delay, diff, endsWith, equal, error, exists, filter, find, flatten, fromQuery, 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, includes, indexOf, insert, isArrayOrPlainObject, isColor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isKey, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, memoize, merge, min, noop, ok, parse, partial, pascalCase, promises, push, queue, result, rgbToHex, rgbToHsl, rgbToHsla, round, setValue, shuffle, smush, snakeCase, sort, splice, startsWith, sum, template, throttle, timed, titleCase, toMap, toQuery, toRecord, toSet, trim, truncate, unique, unsmush, unwrap, upperCase, words };

package/dist/promise.js

@@ -1,28 +1,98 @@
 var PromiseTimeoutError = class extends Error {
 	constructor() {
 		super(MESSAGE_TIMEOUT);
-		this.name = NAME;
+		this.name = ERROR_NAME;
 	}
 };
-/**
-* Create a delayed promise that resolves after a certain amount of time
-* @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
-* @returns A promise that resolves after the delay
-*/
-function delay(time) {
-	return new Promise((resolve) => setTimeout(resolve, getNumberOrDefault(time)));
+function delay(options) {
+	const { signal, time } = getPromiseOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	function abort() {
+		clearTimeout(timeout);
+		rejector(signal.reason);
+	}
+	signal?.addEventListener("abort", abort, abortOptions);
+	let rejector;
+	let timeout;
+	return new Promise((resolve, reject) => {
+		rejector = reject;
+		timeout = setTimeout(() => {
+			signal?.removeEventListener("abort", abort);
+			resolve();
+		}, time);
+	});
 }
 function getBooleanOrDefault(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue;
 }
 function getNumberOrDefault(value) {
-	return typeof value === "number" ? value : 0;
+	return typeof value === "number" && value > 0 ? value : 0;
+}
+function getPromiseOptions(input) {
+	if (typeof input === "number") return { time: getNumberOrDefault(input) };
+	const options = typeof input === "object" && input !== null ? input : {};
+	return {
+		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
+		time: getNumberOrDefault(options.time)
+	};
+}
+function getPromisesOptions(input) {
+	if (typeof input === "boolean") return { eager: input };
+	if (input instanceof AbortSignal) return {
+		eager: false,
+		signal: input
+	};
+	const options = typeof input === "object" && input !== null ? input : {};
+	return {
+		eager: getBooleanOrDefault(options.eager, false),
+		signal: options.signal instanceof AbortSignal ? options.signal : void 0
+	};
+}
+function handleResult(status, parameters) {
+	const { data, eager, handlers, index, signal, value } = parameters;
+	if (signal?.aborted ?? false) return;
+	if (eager && status === TYPE_REJECTED) {
+		handlers.reject(value);
+		return;
+	}
+	data.result[index] = eager ? value : status === TYPE_FULFILLED ? {
+		status,
+		value
+	} : {
+		status,
+		reason: value
+	};
+	if (index === data.last) handlers.resolve(data.result);
 }
-async function promises(items, eager) {
+/**
+* Is the value a fulfilled promise result?
+* @param value Value to check
+* @returns `true` if the value is a fulfilled promise result, `false` otherwise
+*/
+function isFulfilled(value) {
+	return isType(value, TYPE_FULFILLED);
+}
+/**
+* Is the value a rejected promise result?
+* @param value Value to check
+* @returns `true` if the value is a rejected promise result, `false` otherwise
+*/
+function isRejected(value) {
+	return isType(value, TYPE_REJECTED);
+}
+function isType(value, type) {
+	return typeof value === "object" && value !== null && value.status === type;
+}
+async function promises(items, options) {
 	const actual = items.filter((item) => item instanceof Promise);
-	if (actual.length === 0) return actual;
-	const isEager = getBooleanOrDefault(eager, false);
 	const { length } = actual;
+	const { eager, signal } = getPromisesOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	if (length === 0) return actual;
+	function abort() {
+		handlers.reject(signal.reason);
+	}
+	signal?.addEventListener("abort", abort, abortOptions);
 	const data = {
 		last: length - 1,
 		result: []
@@ -33,34 +103,48 @@ async function promises(items, eager) {
 			reject,
 			resolve
 		};
-		for (let index = 0; index < length; index += 1) actual[index].then((value) => resolveResult(index, data, handlers, value, isEager)).catch((reason) => rejectResult(index, data, handlers, reason, isEager));
+		for (let index = 0; index < length; index += 1) actual[index].then((value) => handleResult(TYPE_FULFILLED, {
+			data,
+			eager,
+			handlers,
+			index,
+			signal,
+			value
+		})).catch((reason) => handleResult(TYPE_REJECTED, {
+			data,
+			eager,
+			handlers,
+			index,
+			signal,
+			value: reason
+		}));
 	});
 }
-function rejectResult(index, data, handlers, reason, eager) {
-	if (eager) handlers.reject(reason);
-	else {
-		data.result[index] = {
-			status: TYPE_REJECTED,
-			reason
-		};
-		if (index === data.last) handlers.resolve(data.result);
-	}
-}
-function resolveResult(index, data, handlers, value, eager) {
-	data.result[index] = eager ? value : {
-		status: TYPE_FULFILLED,
-		value
-	};
-	if (index === data.last) handlers.resolve(data.result);
-}
-function timed(promise, timeout) {
+function timed(promise, options) {
 	if (!(promise instanceof Promise)) throw new TypeError(MESSAGE_EXPECTATION);
-	if (getNumberOrDefault(timeout) <= 0) return promise;
-	return Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(new PromiseTimeoutError()), timeout))]);
+	const { signal, time } = getPromiseOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	if (time <= 0) return promise;
+	function abort() {
+		clearTimeout(timeout);
+		rejector(signal.reason);
+	}
+	signal?.addEventListener(EVENT_NAME, abort, abortOptions);
+	let rejector;
+	let timeout;
+	return Promise.race([promise, new Promise((_, reject) => {
+		rejector = reject;
+		timeout = setTimeout(() => {
+			signal?.removeEventListener(EVENT_NAME, abort);
+			reject(new PromiseTimeoutError());
+		}, time);
+	})]);
 }
+var abortOptions = { once: true };
+var ERROR_NAME = "PromiseTimeoutError";
+var EVENT_NAME = "abort";
 var MESSAGE_EXPECTATION = "Timed function expected a Promise";
 var MESSAGE_TIMEOUT = "Promise timed out";
-var NAME = "PromiseTimeoutError";
 var TYPE_FULFILLED = "fulfilled";
 var TYPE_REJECTED = "rejected";
-export { PromiseTimeoutError, delay, promises, timed };
+export { PromiseTimeoutError, delay, isFulfilled, isRejected, promises, timed };

package/dist/queue.js

@@ -44,23 +44,30 @@ var Queue = class {
 	/**
 	* Add an item to the queue
 	* @param parameters Parameters to use when item runs
+	* @param signal Optional signal to abort the item
 	* @returns Queued item
 	*/
-	add(...parameters) {
+	add(parameters, signal) {
 		if (this.full) throw new QueueError(MESSAGE_MAXIMUM);
+		const abortSignal = signal instanceof AbortSignal ? signal : void 0;
+		if (abortSignal?.aborted ?? false) throw new Error(abortSignal.reason);
+		const id = this.#identify();
 		let rejector;
 		let resolver;
-		const id = this.#identify();
 		const promise = new Promise((resolve, reject) => {
 			rejector = reject;
 			resolver = resolve;
 		});
+		const aborter = abortSignal == null ? void 0 : () => rejector(abortSignal.reason);
+		signal?.addEventListener(EVENT_NAME, aborter, abortOptions);
 		this.#items.push({
 			id,
 			parameters,
 			promise,
+			abort: aborter,
 			reject: rejector,
-			resolve: resolver
+			resolve: resolver,
+			signal: abortSignal
 		});
 		if (this.#options.autostart) this.#run();
 		return {
@@ -74,7 +81,11 @@ var Queue = class {
 	clear() {
 		const items = this.#items.splice(0);
 		const { length } = items;
-		for (let index = 0; index < length; index += 1) items[index].reject(new QueueError(MESSAGE_CLEAR));
+		for (let index = 0; index < length; index += 1) {
+			const { abort, reject, signal } = items[index];
+			reject(new QueueError(MESSAGE_CLEAR));
+			signal?.removeEventListener(EVENT_NAME, abort);
+		}
 	}
 	/**
 	* Pause the queue
@@ -92,8 +103,9 @@ var Queue = class {
 	remove(id) {
 		const index = this.#items.findIndex((item) => item.id === id);
 		if (index > -1) {
-			const [item] = this.#items.splice(index, 1);
-			item.reject(new QueueError(MESSAGE_REMOVE));
+			const { abort, reject, signal } = this.#items.splice(index, 1)[0];
+			reject(new QueueError(MESSAGE_REMOVE));
+			signal?.removeEventListener(EVENT_NAME, abort);
 		}
 	}
 	/**
@@ -121,17 +133,24 @@ var Queue = class {
 			let handler;
 			let result;
 			try {
-				result = await this.#callback(...item.parameters);
-				handler = item.resolve;
+				if (!(item.signal?.aborted ?? false)) {
+					result = await this.#callback(...item.parameters);
+					handler = item.resolve;
+				}
 			} catch (thrown) {
 				result = thrown;
 				handler = item.reject;
 			}
 			if (this.#paused) {
-				this.#handled.push(() => handler(result));
+				const paused = item;
+				this.#handled.push(() => {
+					paused.signal?.removeEventListener(EVENT_NAME, paused.abort);
+					if (!(paused.signal?.aborted ?? false)) handler(result);
+				});
 				break;
 			}
-			handler(result);
+			item.signal?.removeEventListener(EVENT_NAME, item.abort);
+			if (!(item.signal?.aborted ?? false)) handler(result);
 			item = this.#items.shift();
 		}
 		this.#runners -= 1;
@@ -161,7 +180,9 @@ function queue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
 	return new Queue(callback, getOptions(options));
 }
+var abortOptions = { once: true };
 var ERROR_NAME = "QueueError";
+var EVENT_NAME = "abort";
 var MESSAGE_CALLBACK = "A Queue requires a callback function";
 var MESSAGE_CLEAR = "Queue was cleared";
 var MESSAGE_MAXIMUM = "Queue has reached its maximum size";

package/package.json

@@ -5,15 +5,15 @@
 	},
 	"description": "Atomic utilities for making your JavaScript better.",
 	"devDependencies": {
-		"@types/node": "^25.2",
+		"@types/node": "^25.3",
 		"@vitest/coverage-istanbul": "^4",
 		"jsdom": "^28.1",
 		"oxfmt": "^0.33",
 		"oxlint": "^1.48",
-		"rolldown": "1.0.0-rc.4",
+		"rolldown": "1.0.0-rc.5",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
-		"vite": "8.0.0-beta.14",
+		"vite": "8.0.0-beta.15",
 		"vitest": "^4"
 	},
 	"exports": {
@@ -120,5 +120,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.133.0"
+	"version": "0.134.0"
 }

package/src/models.ts

@@ -135,6 +135,14 @@ export type PlainObject = Record<PropertyKey, unknown>;
  */
 export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 
+/**
+ * Set required keys for a type
+ */
+export type RequiredKeys<Model extends object, Keys extends keyof Model> = Required<
+	Pick<Model, Keys>
+> &
+	Omit<Model, Keys>;
+
 /**
  * Flattens the type to improve type hints in IDEs
  *

package/src/promise.ts

@@ -1,20 +1,47 @@
 // #region Types
 
+import type {RequiredKeys} from './models';
+
 type Data<Items extends unknown[]> = {
 	last: number;
 	result: Items | PromisesResult<Items>;
 };
 
+type FulfilledPromiseResult<Value> = {
+	status: typeof TYPE_FULFILLED;
+	value: Value;
+};
+
 type Handlers<Items extends unknown[]> = {
 	resolve: (value: Items | PromisesResult<Items>) => void;
 	reject: (reason: unknown) => void;
 };
 
+type Parameters<Items extends unknown[]> = {
+	data: Data<Items>;
+	eager: boolean;
+	handlers: Handlers<Items>;
+	index: number;
+	signal?: AbortSignal;
+	value?: unknown;
+};
+
+type PromiseOptions = {
+	/**
+	 * AbortSignal for aborting the promise; when aborted, the promise will reject with the reason of the signal
+	 */
+	signal?: AbortSignal;
+	/**
+	 * How long to wait for (in milliseconds; defaults to `0`)
+	 */
+	time?: number;
+};
+
 export class PromiseTimeoutError extends Error {
 	constructor() {
 		super(MESSAGE_TIMEOUT);
 
-		this.name = NAME;
+		this.name = ERROR_NAME;
 	}
 }
 
@@ -22,31 +49,67 @@ type Promises<Items extends unknown[]> = {
 	[K in keyof Items]: Promise<Items[K]>;
 };
 
+type PromisesOptions = {
+	eager?: boolean;
+	signal?: AbortSignal;
+};
+
 type PromisesResult<Items extends unknown[]> = {
-	[K in keyof Items]: ResolvedResult<Items[K]> | RejectedResult;
+	[K in keyof Items]: PromisesResultItem<Items[K]>;
 };
 
-type RejectedResult = {
+type PromisesResultItem<Value> = FulfilledPromiseResult<Value> | RejectedPromiseResult;
+
+type RejectedPromiseResult = {
 	status: typeof TYPE_REJECTED;
 	reason: unknown;
 };
 
-type ResolvedResult<Value> = {
-	status: typeof TYPE_FULFILLED;
-	value: Value;
-};
-
 // #endregion
 
 // #region Functions
 
+/**
+ * Create a delayed promise that resolves after a certain amount of time, or rejects if aborted
+ * @param options Options for the delay
+ * @returns A delayed promise
+ */
+export function delay(options?: PromiseOptions): Promise<void>;
+
 /**
  * Create a delayed promise that resolves after a certain amount of time
- * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
- * @returns A promise that resolves after the delay
+ * @param time How long to wait for _(in milliseconds; defaults to `0`)_
+ * @returns A delayed promise
  */
-export function delay(time?: number): Promise<void> {
-	return new Promise(resolve => setTimeout(resolve, getNumberOrDefault(time)));
+export function delay(time?: number): Promise<void>;
+
+export function delay(options?: unknown): Promise<void> {
+	const {signal, time} = getPromiseOptions(options);
+
+	if (signal?.aborted ?? false) {
+		return Promise.reject(signal!.reason);
+	}
+
+	function abort(): void {
+		clearTimeout(timeout);
+
+		rejector(signal!.reason);
+	}
+
+	signal?.addEventListener('abort', abort, abortOptions);
+
+	let rejector: (reason: unknown) => void;
+	let timeout: ReturnType<typeof setTimeout>;
+
+	return new Promise((resolve, reject) => {
+		rejector = reject;
+
+		timeout = setTimeout(() => {
+			signal?.removeEventListener('abort', abort);
+
+			resolve();
+		}, time);
+	});
 }
 
 function getBooleanOrDefault(value: unknown, defaultValue: boolean): boolean {
@@ -54,9 +117,105 @@ function getBooleanOrDefault(value: unknown, defaultValue: boolean): boolean {
 }
 
 function getNumberOrDefault(value: unknown): number {
-	return typeof value === 'number' ? value : 0;
+	return typeof value === 'number' && value > 0 ? value : 0;
+}
+
+function getPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, 'time'> {
+	if (typeof input === 'number') {
+		return {
+			time: getNumberOrDefault(input),
+		};
+	}
+
+	const options = typeof input === 'object' && input !== null ? (input as PromiseOptions) : {};
+
+	return {
+		signal: options.signal instanceof AbortSignal ? options.signal : undefined,
+		time: getNumberOrDefault(options.time),
+	};
+}
+
+function getPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, 'eager'> {
+	if (typeof input === 'boolean') {
+		return {eager: input};
+	}
+
+	if (input instanceof AbortSignal) {
+		return {eager: false, signal: input};
+	}
+
+	const options = typeof input === 'object' && input !== null ? (input as PromisesOptions) : {};
+
+	return {
+		eager: getBooleanOrDefault(options.eager, false),
+		signal: options.signal instanceof AbortSignal ? options.signal : undefined,
+	};
+}
+
+function handleResult<Items extends unknown[]>(
+	status: string,
+	parameters: Parameters<Items>,
+): void {
+	const {data, eager, handlers, index, signal, value} = parameters;
+
+	if (signal?.aborted ?? false) {
+		return;
+	}
+
+	if (eager && status === TYPE_REJECTED) {
+		handlers.reject(value);
+
+		return;
+	}
+
+	(data.result as unknown[])[index] = eager
+		? value
+		: status === TYPE_FULFILLED
+			? {status, value}
+			: {status, reason: value};
+
+	if (index === data.last) {
+		handlers.resolve(data.result as Items | PromisesResult<Items>);
+	}
 }
 
+/**
+ * Is the value a fulfilled promise result?
+ * @param value Value to check
+ * @returns `true` if the value is a fulfilled promise result, `false` otherwise
+ */
+export function isFulfilled<Value>(value: unknown): value is FulfilledPromiseResult<Value> {
+	return isType(value, TYPE_FULFILLED);
+}
+
+/**
+ * Is the value a rejected promise result?
+ * @param value Value to check
+ * @returns `true` if the value is a rejected promise result, `false` otherwise
+ */
+export function isRejected(value: unknown): value is RejectedPromiseResult {
+	return isType(value, TYPE_REJECTED);
+}
+
+function isType(value: unknown, type: string): boolean {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		(value as PromisesResultItem<unknown>).status === type
+	);
+}
+
+/**
+ * ---
+ * @param items List of promises
+ * @param options Options for handling the promises
+ * @return List of results
+ */
+export async function promises<Items extends unknown[], Options extends PromisesOptions>(
+	items: Promises<Items>,
+	options?: Options,
+): Promise<Options['eager'] extends true ? Items : PromisesResult<Items>>;
+
 /**
  * Handle a list of promises, returning their results in an ordered array. If any promise in the list is rejected, the whole function will reject
  * @param items List of promises
@@ -71,25 +230,36 @@ export async function promises<Items extends unknown[]>(
 /**
  * Handle a list of promises, returning their results in an ordered array of rejected and resolved results
  * @param items List of promises
+ * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
  * @return List of results
  */
 export async function promises<Items extends unknown[]>(
 	items: Promises<Items>,
+	signal?: AbortSignal,
 ): Promise<PromisesResult<Items>>;
 
 export async function promises<Items extends unknown[]>(
 	items: Promises<Items>,
-	eager?: unknown,
+	options?: unknown,
 ): Promise<Items | PromisesResult<Items>> {
 	const actual = items.filter(item => item instanceof Promise);
+	const {length} = actual;
+
+	const {eager, signal} = getPromisesOptions(options);
 
-	if (actual.length === 0) {
+	if (signal?.aborted ?? false) {
+		return Promise.reject(signal!.reason);
+	}
+
+	if (length === 0) {
 		return actual as unknown as Items | PromisesResult<Items>;
 	}
 
-	const isEager = getBooleanOrDefault(eager, false);
+	function abort(): void {
+		handlers.reject(signal!.reason);
+	}
 
-	const {length} = actual;
+	signal?.addEventListener('abort', abort, abortOptions);
 
 	const data: Data<Items> = {
 		last: length - 1,
@@ -103,58 +273,55 @@ export async function promises<Items extends unknown[]>(
 
 		for (let index = 0; index < length; index += 1) {
 			void actual[index]
-				.then(value => resolveResult(index, data, handlers, value, isEager))
-				.catch(reason => rejectResult(index, data, handlers, reason, isEager));
+				.then(value => handleResult(TYPE_FULFILLED, {data, eager, handlers, index, signal, value}))
+				.catch(reason =>
+					handleResult(TYPE_REJECTED, {data, eager, handlers, index, signal, value: reason}),
+				);
 		}
 	});
 }
 
-function rejectResult<Items extends unknown[]>(
-	index: number,
-	data: Data<Items>,
-	handlers: Handlers<Items>,
-	reason: unknown,
-	eager: boolean,
-) {
-	if (eager) {
-		handlers.reject(reason);
-	} else {
-		data.result[index] = {status: TYPE_REJECTED, reason};
-
-		if (index === data.last) {
-			handlers.resolve(data.result as Items | PromisesResult<Items>);
-		}
-	}
-}
+export function timed(promise: Promise<unknown>, options: PromiseOptions): Promise<unknown>;
 
-function resolveResult<Items extends unknown[]>(
-	index: number,
-	data: Data<Items>,
-	handlers: Handlers<Items>,
-	value: unknown,
-	eager: boolean,
-) {
-	(data.result as unknown[])[index] = eager ? value : {status: TYPE_FULFILLED, value};
+export function timed(promise: Promise<unknown>, time: number): Promise<unknown>;
 
-	if (index === data.last) {
-		handlers.resolve(data.result as Items | PromisesResult<Items>);
-	}
-}
-
-export function timed(promise: Promise<unknown>, timeout: number): Promise<unknown> {
+export function timed(promise: Promise<unknown>, options: unknown): Promise<unknown> {
 	if (!(promise instanceof Promise)) {
 		throw new TypeError(MESSAGE_EXPECTATION);
 	}
 
-	const time = getNumberOrDefault(timeout);
+	const {signal, time} = getPromiseOptions(options);
+
+	if (signal?.aborted ?? false) {
+		return Promise.reject(signal!.reason);
+	}
 
 	if (time <= 0) {
 		return promise;
 	}
 
+	function abort(): void {
+		clearTimeout(timeout);
+
+		rejector(signal!.reason);
+	}
+
+	signal?.addEventListener(EVENT_NAME, abort, abortOptions);
+
+	let rejector: (reason: unknown) => void;
+	let timeout: ReturnType<typeof setTimeout>;
+
 	return Promise.race([
 		promise,
-		new Promise((_, reject) => setTimeout(() => reject(new PromiseTimeoutError()), timeout)),
+		new Promise((_, reject) => {
+			rejector = reject;
+
+			timeout = setTimeout(() => {
+				signal?.removeEventListener(EVENT_NAME, abort);
+
+				reject(new PromiseTimeoutError());
+			}, time);
+		}),
 	]);
 }
 
@@ -162,12 +329,16 @@ export function timed(promise: Promise<unknown>, timeout: number): Promise<unkno
 
 // #region Variables
 
+const abortOptions = {once: true};
+
+const ERROR_NAME = 'PromiseTimeoutError';
+
+const EVENT_NAME = 'abort';
+
 const MESSAGE_EXPECTATION = 'Timed function expected a Promise';
 
 const MESSAGE_TIMEOUT = 'Promise timed out';
 
-const NAME = 'PromiseTimeoutError';
-
 const TYPE_FULFILLED = 'fulfilled';
 
 const TYPE_REJECTED = 'rejected';

package/src/queue.ts

@@ -62,29 +62,42 @@ class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, Callbac
 	/**
 	 * Add an item to the queue
 	 * @param parameters Parameters to use when item runs
+	 * @param signal Optional signal to abort the item
 	 * @returns Queued item
 	 */
-	add(...parameters: CallbackParameters): Queued<CallbackResult> {
+	add(parameters: CallbackParameters, signal?: AbortSignal): Queued<CallbackResult> {
 		if (this.full) {
 			throw new QueueError(MESSAGE_MAXIMUM);
 		}
 
-		let rejector: (reason?: unknown) => void;
-		let resolver: (value: CallbackResult) => void;
+		const abortSignal = signal instanceof AbortSignal ? signal : undefined;
+
+		if (abortSignal?.aborted ?? false) {
+			throw new Error(abortSignal!.reason);
+		}
 
 		const id = this.#identify();
 
+		let rejector: (reason?: unknown) => void;
+		let resolver: (value: CallbackResult) => void;
+
 		const promise = new Promise<CallbackResult>((resolve, reject) => {
 			rejector = reject;
 			resolver = resolve;
 		});
 
+		const aborter = abortSignal == null ? undefined : () => rejector(abortSignal.reason);
+
+		signal?.addEventListener(EVENT_NAME, aborter!, abortOptions);
+
 		this.#items.push({
 			id,
 			parameters,
 			promise,
+			abort: aborter,
 			reject: rejector!,
 			resolve: resolver!,
+			signal: abortSignal,
 		});
 
 		if (this.#options.autostart) {
@@ -102,7 +115,11 @@ class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, Callbac
 		const {length} = items;
 
 		for (let index = 0; index < length; index += 1) {
-			items[index].reject(new QueueError(MESSAGE_CLEAR));
+			const {abort, reject, signal} = items[index];
+
+			reject(new QueueError(MESSAGE_CLEAR));
+
+			signal?.removeEventListener(EVENT_NAME, abort!);
 		}
 	}
 
@@ -124,9 +141,11 @@ class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, Callbac
 		const index = this.#items.findIndex(item => item.id === id);
 
 		if (index > -1) {
-			const [item] = this.#items.splice(index, 1);
+			const {abort, reject, signal} = this.#items.splice(index, 1)[0];
+
+			reject(new QueueError(MESSAGE_REMOVE));
 
-			item.reject(new QueueError(MESSAGE_REMOVE));
+			signal?.removeEventListener(EVENT_NAME, abort!);
 		}
 	}
 
@@ -172,20 +191,34 @@ class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, Callbac
 			let result: unknown | CallbackResult;
 
 			try {
-				result = await this.#callback(...item.parameters);
-				handler = item.resolve;
+				if (!(item.signal?.aborted ?? false)) {
+					result = await this.#callback(...item.parameters);
+					handler = item.resolve;
+				}
 			} catch (thrown) {
 				result = thrown;
 				handler = item.reject;
 			}
 
 			if (this.#paused) {
-				this.#handled.push(() => handler(result));
+				const paused = item;
+
+				this.#handled.push(() => {
+					paused.signal?.removeEventListener(EVENT_NAME, paused.abort!);
+
+					if (!(paused.signal?.aborted ?? false)) {
+						handler(result);
+					}
+				});
 
 				break;
 			}
 
-			handler(result);
+			item.signal?.removeEventListener(EVENT_NAME, item.abort!);
+
+			if (!(item.signal?.aborted ?? false)) {
+				handler!(result as CallbackResult);
+			}
 
 			item = this.#items.shift();
 		}
@@ -223,11 +256,13 @@ type Queued<Value> = {
 };
 
 type QueuedItem<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
+	abort?: () => void;
 	id: number;
 	parameters: CallbackParameters;
 	promise: Promise<CallbackResult>;
 	reject: (reason?: unknown) => void;
 	resolve: (value: CallbackResult) => void;
+	signal?: AbortSignal;
 };
 
 // #endregion
@@ -289,8 +324,12 @@ function queue(
 
 // #region Variables
 
+const abortOptions = {once: true};
+
 const ERROR_NAME = 'QueueError';
 
+const EVENT_NAME = 'abort';
+
 const MESSAGE_CALLBACK = 'A Queue requires a callback function';
 
 const MESSAGE_CLEAR = 'Queue was cleared';

package/types/models.d.ts

@@ -78,6 +78,10 @@ export type PlainObject = Record<PropertyKey, unknown>;
  * _(Thanks, type-fest!)_
  */
 export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+ * Set required keys for a type
+ */
+export type RequiredKeys<Model extends object, Keys extends keyof Model> = Required<Pick<Model, Keys>> & Omit<Model, Keys>;
 /**
  * Flattens the type to improve type hints in IDEs
  *

package/types/promise.d.ts

@@ -1,26 +1,66 @@
+type FulfilledPromiseResult<Value> = {
+    status: typeof TYPE_FULFILLED;
+    value: Value;
+};
+type PromiseOptions = {
+    /**
+     * AbortSignal for aborting the promise; when aborted, the promise will reject with the reason of the signal
+     */
+    signal?: AbortSignal;
+    /**
+     * How long to wait for (in milliseconds; defaults to `0`)
+     */
+    time?: number;
+};
 export declare class PromiseTimeoutError extends Error {
     constructor();
 }
 type Promises<Items extends unknown[]> = {
     [K in keyof Items]: Promise<Items[K]>;
 };
+type PromisesOptions = {
+    eager?: boolean;
+    signal?: AbortSignal;
+};
 type PromisesResult<Items extends unknown[]> = {
-    [K in keyof Items]: ResolvedResult<Items[K]> | RejectedResult;
+    [K in keyof Items]: PromisesResultItem<Items[K]>;
 };
-type RejectedResult = {
+type PromisesResultItem<Value> = FulfilledPromiseResult<Value> | RejectedPromiseResult;
+type RejectedPromiseResult = {
     status: typeof TYPE_REJECTED;
     reason: unknown;
 };
-type ResolvedResult<Value> = {
-    status: typeof TYPE_FULFILLED;
-    value: Value;
-};
+/**
+ * Create a delayed promise that resolves after a certain amount of time, or rejects if aborted
+ * @param options Options for the delay
+ * @returns A delayed promise
+ */
+export declare function delay(options?: PromiseOptions): Promise<void>;
 /**
  * Create a delayed promise that resolves after a certain amount of time
- * @param time How long to wait for _(in milliseconds; defaults to screen refresh rate)_
- * @returns A promise that resolves after the delay
+ * @param time How long to wait for _(in milliseconds; defaults to `0`)_
+ * @returns A delayed promise
  */
 export declare function delay(time?: number): Promise<void>;
+/**
+ * Is the value a fulfilled promise result?
+ * @param value Value to check
+ * @returns `true` if the value is a fulfilled promise result, `false` otherwise
+ */
+export declare function isFulfilled<Value>(value: unknown): value is FulfilledPromiseResult<Value>;
+/**
+ * Is the value a rejected promise result?
+ * @param value Value to check
+ * @returns `true` if the value is a rejected promise result, `false` otherwise
+ */
+export declare function isRejected(value: unknown): value is RejectedPromiseResult;
+/**
+ * ---
+ * @param items List of promises
+ * @param options Options for handling the promises
+ * @return List of results
+ */
+export declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: Promises<Items>, options?: Options): Promise<Options['eager'] extends true ? Items : PromisesResult<Items>>;
 /**
  * Handle a list of promises, returning their results in an ordered array. If any promise in the list is rejected, the whole function will reject
  * @param items List of promises
@@ -31,10 +71,12 @@ export declare function promises<Items extends unknown[]>(items: Promises<Items>
 /**
  * Handle a list of promises, returning their results in an ordered array of rejected and resolved results
  * @param items List of promises
+ * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
  * @return List of results
  */
-export declare function promises<Items extends unknown[]>(items: Promises<Items>): Promise<PromisesResult<Items>>;
-export declare function timed(promise: Promise<unknown>, timeout: number): Promise<unknown>;
+export declare function promises<Items extends unknown[]>(items: Promises<Items>, signal?: AbortSignal): Promise<PromisesResult<Items>>;
+export declare function timed(promise: Promise<unknown>, options: PromiseOptions): Promise<unknown>;
+export declare function timed(promise: Promise<unknown>, time: number): Promise<unknown>;
 declare const TYPE_FULFILLED = "fulfilled";
 declare const TYPE_REJECTED = "rejected";
 export {};

package/types/queue.d.ts

@@ -25,9 +25,10 @@ declare class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>,
     /**
      * Add an item to the queue
      * @param parameters Parameters to use when item runs
+     * @param signal Optional signal to abort the item
      * @returns Queued item
      */
-    add(...parameters: CallbackParameters): Queued<CallbackResult>;
+    add(parameters: CallbackParameters, signal?: AbortSignal): Queued<CallbackResult>;
     /**
      * Remove and reject all items in the queue
      */