@oscarpalmer/atoms 0.192.0 → 0.193.0

package/dist/index.d.mts

@@ -7636,7 +7636,7 @@ declare function toQuery(parameters: PlainObject): string;
 /**
  * A queue that can be used to manage (a)synchronous tasks with a specific key
  */
-type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
+type KeyedQueue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
   /**
    * Get keys of all active queues
    */
@@ -7685,7 +7685,7 @@ type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, Cal
    * @param signal Optional signal to abort the item
    * @returns Queued item
    */
-  add(key: string, parameters: Tail<CallbackParameters>, signal?: AbortSignal): Queued<CallbackResult>;
+  add(key: string, parameters: Tail<CallbackParameters>, signal?: AbortSignal): Queued<ReturnType<Callback>>;
   /**
    * Clear all items for a specific key _(or all items for all keys, if no key is provided)_
    *
@@ -7698,7 +7698,7 @@ type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, Cal
    * @param key Key to get the queue for
    * @returns Queue for the key, or `undefined` if it doesn't exist
    */
-  get(key: string): Queue<Tail<CallbackParameters>, CallbackResult> | undefined;
+  get(key: string): Queue<Callback, Tail<CallbackParameters>> | undefined;
   /**
    * Pause the queue for a specific key _(or all queues, if no key is provided)_
    *
@@ -7734,7 +7734,7 @@ type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, Cal
 /**
  * A queue that can be used to manage (a)synchronous tasks
  */
-type Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
+type Queue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
   /**
    * Is the queue active?
    */
@@ -7774,7 +7774,7 @@ type Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, Callback
    * @param signal Optional signal to abort the item
    * @returns Queued item
    */
-  add(parameters: CallbackParameters, signal?: AbortSignal): Queued<CallbackResult>;
+  add(parameters: CallbackParameters, signal?: AbortSignal): Queued<ReturnType<Callback>>;
   /**
    * Remove and reject all items in the queue
    */
@@ -7828,17 +7828,7 @@ type Queued<Value> = {
   /**
    * Queued promise
    */
-  readonly promise: Promise<QueuedResult<Value>>;
-};
-type QueuedResult<Value> = {
-  /**
-   * Has the queue finished processing all items?
-   */
-  finished: boolean;
-  /**
-   * Result for the queued promise
-   */
-  value: Value extends Promise<infer Result> ? Result : Value;
+  readonly promise: Promise<Value extends Promise<infer Result> ? Result : Value>;
 };
 type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest : never;
 /**
@@ -7847,17 +7837,29 @@ type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest
  * @param value Value to check
  * @returns `true` if the value is a keyed queue, otherwise `false`
  */
-declare function isKeyedQueue(value: unknown): value is KeyedQueue<unknown[], unknown>;
+declare function isKeyedQueue(value: unknown): value is KeyedQueue<GenericAsyncCallback>;
 /**
  * Is the value a queue?
  *
  * @param value Value to check
  * @returns `true` if the value is a queue, otherwise `false`
  */
-declare function isQueue(value: unknown): value is Queue<unknown[], unknown>;
+declare function isQueue(value: unknown): value is Queue<GenericCallback | GenericAsyncCallback>;
 declare function isQueueInstance<Instance>(name: string, value: unknown): value is Instance;
-declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(callback: Callback, options?: QueueOptions): KeyedQueue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
-declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => void>(callback: Callback, options?: QueueOptions): KeyedQueue<Parameters<Callback>, ReturnType<Callback>>;
+/**
+ * Create a keyed queue for an asynchronous callback function, where each key has its own queue
+ *
+ * @param callback Callback function for queued items
+ * @param options Queue options
+ */
+declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(callback: Callback, options?: QueueOptions): KeyedQueue<Callback, Parameters<Callback>>;
+/**
+ * Create a keyed queue for an asynchronous callback function, where each key has its own queue
+ *
+ * @param callback Callback function for queued items
+ * @param options Queue options
+ */
+declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => void>(callback: Callback, options?: QueueOptions): KeyedQueue<Callback, Parameters<Callback>>;
 /**
  * Create a queue for an asynchronous callback function
  *
@@ -7865,7 +7867,7 @@ declare function keyedQueue<Callback extends (key: string, ...parameters: any[])
  * @param options Queue options
  * @returns Queue instance
  */
-declare function queue<Callback extends GenericAsyncCallback>(callback: Callback, options?: QueueOptions): Queue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
+declare function queue<Callback extends GenericAsyncCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
 /**
  * Create a queue for a synchronous callback function
  *
@@ -7873,7 +7875,7 @@ declare function queue<Callback extends GenericAsyncCallback>(callback: Callback
  * @param options Queue options
  * @returns Queue instance
  */
-declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Parameters<Callback>, ReturnType<Callback>>;
+declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
 declare namespace queue {
   var keyed: typeof keyedQueue;
 }
@@ -8508,4 +8510,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { AnyResult, ArrayComparison, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayValueSorter, AssertProperty, Asserter, AssignOptions, Assigner, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, Beacon, BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, Events, ExtendedErr, ExtendedResult, Flow, FlowPromise, Frozen, FulfilledPromise, Fuzzy, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, Herald, Key$1 as Key, KeyedQueue, KeyedValue, Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NormalizeOptions, Normalizer, NumericalKeys, NumericalValues, Observable, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, Queue, QueueError, QueueOptions, Queued, QueuedResult, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, type Shaken, Simplify, SizedMap, SizedSet, type Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type TimedLogger, ToString, Transformer, TypedArray, UnionToIntersection, type Unsmushed, Unsubscriber, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isColor, isConstructor, isEmpty, isError, isEvents, isFrozen, isFulfilled, isHerald, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { AnyResult, ArrayComparison, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayValueSorter, AssertProperty, Asserter, AssignOptions, Assigner, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, Beacon, BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, Events, ExtendedErr, ExtendedResult, Flow, FlowPromise, Frozen, FulfilledPromise, Fuzzy, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, Herald, Key$1 as Key, KeyedQueue, KeyedValue, Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NormalizeOptions, Normalizer, NumericalKeys, NumericalValues, Observable, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, Queue, QueueError, QueueOptions, Queued, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, type Shaken, Simplify, SizedMap, SizedSet, type Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type TimedLogger, ToString, Transformer, TypedArray, UnionToIntersection, type Unsmushed, Unsubscriber, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isColor, isConstructor, isEmpty, isError, isEvents, isFrozen, isFulfilled, isHerald, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/index.mjs

@@ -2816,7 +2816,7 @@ function getHandler(input) {
 			throw new TypeError(MESSAGE_HANDLER);
 	}
 }
-function getItems(items) {
+function getItems$1(items) {
 	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
 }
 function getFuzzyOptions(input, state) {
@@ -2949,10 +2949,10 @@ function search(items, strings, input, options) {
 		for (let index = 0; index < length; index += 1) {
 			const key = keys[index];
 			if (maxScore - key > options.tolerance) break;
-			similar.push(...getItems(scored[key]));
+			similar.push(...getItems$1(scored[key]));
 		}
 	}
-	result.exact = getItems(options.limit == null ? exact : exact.slice(0, options.limit));
+	result.exact = getItems$1(options.limit == null ? exact : exact.slice(0, options.limit));
 	if (options.limit == null) result.similar = similar;
 	else result.similar = similar.slice(0, options.limit - result.exact.length);
 	return result;
@@ -5877,6 +5877,12 @@ function createQueue(callback, options, key) {
 function getBooleanOrDefault(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue;
 }
+function getItems(state) {
+	const size = {};
+	const queues = state.queues.entries();
+	for (const [key, queue] of queues) size[key] = queue.size;
+	return size;
+}
 function getOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
 	return {
@@ -5900,7 +5906,7 @@ function getStatus(state, status) {
 	for (const [key, queue] of queues) if (queue[status]) result.push(key);
 	return result;
 }
-function handleQueuedResult(item, error, result, finished) {
+function handleQueuedResult(item, error, result) {
 	item.signal?.removeEventListener(EVENT_NAME, item.abort);
 	if (item.signal?.aborted ?? false) {
 		item.reject();
@@ -5910,10 +5916,7 @@ function handleQueuedResult(item, error, result, finished) {
 		item.reject(result);
 		return;
 	}
-	item.resolve({
-		finished,
-		value: result
-	});
+	item.resolve(result);
 }
 function handleQueues(state, type, key) {
 	if (typeof key === "string") {
@@ -5964,21 +5967,7 @@ function keyedQueue(callback, options) {
 		pause: (key) => {
 			handleQueues(state, HANDLE_PAUSE, key);
 		},
-		remove: (key, id) => {
-			if (key == null) {
-				handleQueues(state, HANDLE_CLEAR);
-				state.queues.clear();
-				return;
-			}
-			const queue = getQueue(state, key);
-			if (queue == null) return;
-			if (typeof id === "number") {
-				queue.remove(id);
-				return;
-			}
-			queue.clear();
-			state.queues.delete(key);
-		},
+		remove: (key, id) => removeQueue(state, key, id),
 		resume: (key) => {
 			handleQueues(state, HANDLE_RESUME, key);
 		}
@@ -6010,12 +5999,7 @@ function keyedQueue(callback, options) {
 		},
 		items: {
 			enumerable: true,
-			get: () => {
-				const size = {};
-				const queues = state.queues.entries();
-				for (const [key, queue] of queues) size[key] = queue.size;
-				return size;
-			}
+			get: () => getItems(state)
 		},
 		keys: {
 			enumerable: true,
@@ -6040,6 +6024,21 @@ function queue(callback, options) {
 	return createQueue(callback, options);
 }
 queue.keyed = keyedQueue;
+function removeQueue(state, key, id) {
+	if (key == null) {
+		handleQueues(state, HANDLE_CLEAR);
+		state.queues.clear();
+		return;
+	}
+	const queue = getQueue(state, key);
+	if (queue == null) return;
+	if (typeof id === "number") {
+		queue.remove(id);
+		return;
+	}
+	queue.clear();
+	state.queues.delete(key);
+}
 async function run(state) {
 	if (state.paused || state.runners >= state.options.concurrency) return;
 	state.runners += 1;
@@ -6059,11 +6058,11 @@ async function run(state) {
 		if (state.paused) {
 			const paused = item;
 			state.handled.push(() => {
-				handleQueuedResult(paused, error, result, state.items.length === 0);
+				handleQueuedResult(paused, error, result);
 			});
 			break;
 		}
-		handleQueuedResult(item, error, result, state.items.length === 0);
+		handleQueuedResult(item, error, result);
 		item = state.items.shift();
 	}
 	state.runners -= 1;

package/dist/queue.d.mts

@@ -3,7 +3,7 @@ import { GenericAsyncCallback, GenericCallback } from "./models.mjs";
 /**
  * A queue that can be used to manage (a)synchronous tasks with a specific key
  */
-type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
+type KeyedQueue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
   /**
    * Get keys of all active queues
    */
@@ -52,7 +52,7 @@ type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, Cal
    * @param signal Optional signal to abort the item
    * @returns Queued item
    */
-  add(key: string, parameters: Tail<CallbackParameters>, signal?: AbortSignal): Queued<CallbackResult>;
+  add(key: string, parameters: Tail<CallbackParameters>, signal?: AbortSignal): Queued<ReturnType<Callback>>;
   /**
    * Clear all items for a specific key _(or all items for all keys, if no key is provided)_
    *
@@ -65,7 +65,7 @@ type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, Cal
    * @param key Key to get the queue for
    * @returns Queue for the key, or `undefined` if it doesn't exist
    */
-  get(key: string): Queue<Tail<CallbackParameters>, CallbackResult> | undefined;
+  get(key: string): Queue<Callback, Tail<CallbackParameters>> | undefined;
   /**
    * Pause the queue for a specific key _(or all queues, if no key is provided)_
    *
@@ -101,7 +101,7 @@ type KeyedQueue<CallbackParameters extends Parameters<GenericAsyncCallback>, Cal
 /**
  * A queue that can be used to manage (a)synchronous tasks
  */
-type Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
+type Queue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
   /**
    * Is the queue active?
    */
@@ -141,7 +141,7 @@ type Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, Callback
    * @param signal Optional signal to abort the item
    * @returns Queued item
    */
-  add(parameters: CallbackParameters, signal?: AbortSignal): Queued<CallbackResult>;
+  add(parameters: CallbackParameters, signal?: AbortSignal): Queued<ReturnType<Callback>>;
   /**
    * Remove and reject all items in the queue
    */
@@ -195,17 +195,7 @@ type Queued<Value> = {
   /**
    * Queued promise
    */
-  readonly promise: Promise<QueuedResult<Value>>;
-};
-type QueuedResult<Value> = {
-  /**
-   * Has the queue finished processing all items?
-   */
-  finished: boolean;
-  /**
-   * Result for the queued promise
-   */
-  value: Value extends Promise<infer Result> ? Result : Value;
+  readonly promise: Promise<Value extends Promise<infer Result> ? Result : Value>;
 };
 type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest : never;
 /**
@@ -214,17 +204,29 @@ type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest
  * @param value Value to check
  * @returns `true` if the value is a keyed queue, otherwise `false`
  */
-declare function isKeyedQueue(value: unknown): value is KeyedQueue<unknown[], unknown>;
+declare function isKeyedQueue(value: unknown): value is KeyedQueue<GenericAsyncCallback>;
 /**
  * Is the value a queue?
  *
  * @param value Value to check
  * @returns `true` if the value is a queue, otherwise `false`
  */
-declare function isQueue(value: unknown): value is Queue<unknown[], unknown>;
+declare function isQueue(value: unknown): value is Queue<GenericCallback | GenericAsyncCallback>;
 declare function isQueueInstance<Instance>(name: string, value: unknown): value is Instance;
-declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(callback: Callback, options?: QueueOptions): KeyedQueue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
-declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => void>(callback: Callback, options?: QueueOptions): KeyedQueue<Parameters<Callback>, ReturnType<Callback>>;
+/**
+ * Create a keyed queue for an asynchronous callback function, where each key has its own queue
+ *
+ * @param callback Callback function for queued items
+ * @param options Queue options
+ */
+declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(callback: Callback, options?: QueueOptions): KeyedQueue<Callback, Parameters<Callback>>;
+/**
+ * Create a keyed queue for an asynchronous callback function, where each key has its own queue
+ *
+ * @param callback Callback function for queued items
+ * @param options Queue options
+ */
+declare function keyedQueue<Callback extends (key: string, ...parameters: any[]) => void>(callback: Callback, options?: QueueOptions): KeyedQueue<Callback, Parameters<Callback>>;
 /**
  * Create a queue for an asynchronous callback function
  *
@@ -232,7 +234,7 @@ declare function keyedQueue<Callback extends (key: string, ...parameters: any[])
  * @param options Queue options
  * @returns Queue instance
  */
-declare function queue<Callback extends GenericAsyncCallback>(callback: Callback, options?: QueueOptions): Queue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
+declare function queue<Callback extends GenericAsyncCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
 /**
  * Create a queue for a synchronous callback function
  *
@@ -240,9 +242,9 @@ declare function queue<Callback extends GenericAsyncCallback>(callback: Callback
  * @param options Queue options
  * @returns Queue instance
  */
-declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Parameters<Callback>, ReturnType<Callback>>;
+declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
 declare namespace queue {
   var keyed: typeof keyedQueue;
 }
 //#endregion
-export { KeyedQueue, Queue, QueueError, QueueOptions, Queued, QueuedResult, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };
+export { KeyedQueue, Queue, QueueError, QueueOptions, Queued, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };

package/dist/queue.mjs

@@ -125,6 +125,12 @@ function createQueue(callback, options, key) {
 function getBooleanOrDefault(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue;
 }
+function getItems(state) {
+	const size = {};
+	const queues = state.queues.entries();
+	for (const [key, queue] of queues) size[key] = queue.size;
+	return size;
+}
 function getOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
 	return {
@@ -148,7 +154,7 @@ function getStatus(state, status) {
 	for (const [key, queue] of queues) if (queue[status]) result.push(key);
 	return result;
 }
-function handleQueuedResult(item, error, result, finished) {
+function handleQueuedResult(item, error, result) {
 	item.signal?.removeEventListener(EVENT_NAME, item.abort);
 	if (item.signal?.aborted ?? false) {
 		item.reject();
@@ -158,10 +164,7 @@ function handleQueuedResult(item, error, result, finished) {
 		item.reject(result);
 		return;
 	}
-	item.resolve({
-		finished,
-		value: result
-	});
+	item.resolve(result);
 }
 function handleQueues(state, type, key) {
 	if (typeof key === "string") {
@@ -212,21 +215,7 @@ function keyedQueue(callback, options) {
 		pause: (key) => {
 			handleQueues(state, HANDLE_PAUSE, key);
 		},
-		remove: (key, id) => {
-			if (key == null) {
-				handleQueues(state, HANDLE_CLEAR);
-				state.queues.clear();
-				return;
-			}
-			const queue = getQueue(state, key);
-			if (queue == null) return;
-			if (typeof id === "number") {
-				queue.remove(id);
-				return;
-			}
-			queue.clear();
-			state.queues.delete(key);
-		},
+		remove: (key, id) => removeQueue(state, key, id),
 		resume: (key) => {
 			handleQueues(state, HANDLE_RESUME, key);
 		}
@@ -258,12 +247,7 @@ function keyedQueue(callback, options) {
 		},
 		items: {
 			enumerable: true,
-			get: () => {
-				const size = {};
-				const queues = state.queues.entries();
-				for (const [key, queue] of queues) size[key] = queue.size;
-				return size;
-			}
+			get: () => getItems(state)
 		},
 		keys: {
 			enumerable: true,
@@ -288,6 +272,21 @@ function queue(callback, options) {
 	return createQueue(callback, options);
 }
 queue.keyed = keyedQueue;
+function removeQueue(state, key, id) {
+	if (key == null) {
+		handleQueues(state, HANDLE_CLEAR);
+		state.queues.clear();
+		return;
+	}
+	const queue = getQueue(state, key);
+	if (queue == null) return;
+	if (typeof id === "number") {
+		queue.remove(id);
+		return;
+	}
+	queue.clear();
+	state.queues.delete(key);
+}
 async function run(state) {
 	if (state.paused || state.runners >= state.options.concurrency) return;
 	state.runners += 1;
@@ -307,11 +306,11 @@ async function run(state) {
 		if (state.paused) {
 			const paused = item;
 			state.handled.push(() => {
-				handleQueuedResult(paused, error, result, state.items.length === 0);
+				handleQueuedResult(paused, error, result);
 			});
 			break;
 		}
-		handleQueuedResult(item, error, result, state.items.length === 0);
+		handleQueuedResult(item, error, result);
 		item = state.items.shift();
 	}
 	state.runners -= 1;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.192.0",
+	"version": "0.193.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"helper",

package/src/queue.ts

@@ -9,8 +9,8 @@ type HandleType = 'clear' | 'pause' | 'resume';
  * A queue that can be used to manage (a)synchronous tasks with a specific key
  */
 export type KeyedQueue<
-	CallbackParameters extends Parameters<GenericAsyncCallback>,
-	CallbackResult,
+	Callback extends GenericCallback | GenericAsyncCallback,
+	CallbackParameters extends unknown[] = Parameters<Callback>,
 > = {
 	/**
 	 * Get keys of all active queues
@@ -74,7 +74,7 @@ export type KeyedQueue<
 		key: string,
 		parameters: Tail<CallbackParameters>,
 		signal?: AbortSignal,
-	): Queued<CallbackResult>;
+	): Queued<ReturnType<Callback>>;
 
 	/**
 	 * Clear all items for a specific key _(or all items for all keys, if no key is provided)_
@@ -89,7 +89,7 @@ export type KeyedQueue<
 	 * @param key Key to get the queue for
 	 * @returns Queue for the key, or `undefined` if it doesn't exist
 	 */
-	get(key: string): Queue<Tail<CallbackParameters>, CallbackResult> | undefined;
+	get(key: string): Queue<Callback, Tail<CallbackParameters>> | undefined;
 
 	/**
 	 * Pause the queue for a specific key _(or all queues, if no key is provided)_
@@ -129,15 +129,18 @@ export type KeyedQueue<
 };
 
 type KeyedQueueState = {
-	callback: GenericAsyncCallback;
+	callback: GenericCallback | GenericAsyncCallback;
 	options: Required<QueueOptions>;
-	queues: Map<string, Queue<Tail<unknown[]>, unknown>>;
+	queues: Map<string, Queue<GenericAsyncCallback, Tail<unknown[]>>>;
 };
 
 /**
  * A queue that can be used to manage (a)synchronous tasks
  */
-export type Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
+export type Queue<
+	Callback extends GenericCallback | GenericAsyncCallback,
+	CallbackParameters extends unknown[] = Parameters<Callback>,
+> = {
 	/**
 	 * Is the queue active?
 	 */
@@ -185,7 +188,7 @@ export type Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, C
 	 * @param signal Optional signal to abort the item
 	 * @returns Queued item
 	 */
-	add(parameters: CallbackParameters, signal?: AbortSignal): Queued<CallbackResult>;
+	add(parameters: CallbackParameters, signal?: AbortSignal): Queued<ReturnType<Callback>>;
 
 	/**
 	 * Remove and reject all items in the queue
@@ -261,7 +264,7 @@ export type Queued<Value> = {
 	/**
 	 * Queued promise
 	 */
-	readonly promise: Promise<QueuedResult<Value>>;
+	readonly promise: Promise<Value extends Promise<infer Result> ? Result : Value>;
 };
 
 type QueuedItem = {
@@ -269,23 +272,12 @@ type QueuedItem = {
 	id: number;
 	key?: string;
 	parameters: unknown[];
-	promise: Promise<QueuedResult<unknown>>;
+	promise: Promise<unknown>;
 	reject: (reason?: unknown) => void;
-	resolve: (value: QueuedResult<unknown>) => void;
+	resolve: (value: unknown) => void;
 	signal?: AbortSignal;
 };
 
-export type QueuedResult<Value> = {
-	/**
-	 * Has the queue finished processing all items?
-	 */
-	finished: boolean;
-	/**
-	 * Result for the queued promise
-	 */
-	value: Value extends Promise<infer Result> ? Result : Value;
-};
-
 type StatusKey = 'active' | 'empty' | 'full' | 'paused';
 
 type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest : never;
@@ -295,10 +287,10 @@ type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest
 // #region Functions
 
 function createQueue(
-	callback: GenericCallback | GenericAsyncCallback,
+	callback: GenericAsyncCallback,
 	options?: QueueOptions,
 	key?: string,
-): Queue<unknown[], unknown> {
+): Queue<never, never> {
 	if (typeof callback !== 'function') {
 		throw new TypeError(MESSAGE_CALLBACK);
 	}
@@ -316,7 +308,7 @@ function createQueue(
 
 	const instance = {
 		add: (parameters: unknown[], signal?: AbortSignal) => {
-			if ((instance as Queue<unknown[], unknown>).full) {
+			if ((instance as Queue<GenericCallback>).full) {
 				throw new QueueError(MESSAGE_MAXIMUM);
 			}
 
@@ -329,9 +321,9 @@ function createQueue(
 			const id = identify(state);
 
 			let rejector: (reason?: unknown) => void;
-			let resolver: (value: QueuedResult<unknown>) => void;
+			let resolver: (value: unknown) => void;
 
-			const promise = new Promise<QueuedResult<unknown>>((resolve, reject) => {
+			const promise = new Promise<unknown>((resolve, reject) => {
 				rejector = reject;
 				resolver = resolve;
 			});
@@ -442,13 +434,25 @@ function createQueue(
 		},
 	});
 
-	return Object.freeze(instance) as Queue<unknown[], unknown>;
+	return Object.freeze(instance) as Queue<GenericCallback>;
 }
 
 function getBooleanOrDefault(value: unknown, defaultValue: boolean): boolean {
 	return typeof value === 'boolean' ? value : defaultValue;
 }
 
+function getItems(state: KeyedQueueState): Record<string, number> {
+	const size: Record<string, number> = {};
+
+	const queues = state.queues.entries();
+
+	for (const [key, queue] of queues) {
+		size[key] = queue.size;
+	}
+
+	return size;
+}
+
 function getOptions(input?: QueueOptions): Required<QueueOptions> {
 	const options = typeof input === 'object' && input != null ? input : {};
 
@@ -459,15 +463,15 @@ function getOptions(input?: QueueOptions): Required<QueueOptions> {
 	};
 }
 
-function getQueue(state: KeyedQueueState, key: string, add: true): Queue<Tail<unknown[]>, unknown>;
+function getQueue(state: KeyedQueueState, key: string, add: true): Queue<GenericCallback>;
 
-function getQueue(state: KeyedQueueState, key: string): Queue<Tail<unknown[]>, unknown> | undefined;
+function getQueue(state: KeyedQueueState, key: string): Queue<GenericCallback> | undefined;
 
 function getQueue(
 	state: KeyedQueueState,
 	key: string,
 	add?: boolean,
-): Queue<Tail<unknown[]>, unknown> | undefined {
+): Queue<GenericCallback> | undefined {
 	if (typeof key !== 'string' || key.trim().length === 0) {
 		throw new TypeError(MESSAGE_KEY);
 	}
@@ -497,12 +501,7 @@ function getStatus(state: KeyedQueueState, status: StatusKey): string[] {
 	return result;
 }
 
-function handleQueuedResult(
-	item: QueuedItem,
-	error: boolean,
-	result: unknown,
-	finished: boolean,
-): void {
+function handleQueuedResult(item: QueuedItem, error: boolean, result: unknown): void {
 	item.signal?.removeEventListener(EVENT_NAME, item.abort!);
 
 	if (item.signal?.aborted ?? false) {
@@ -517,10 +516,7 @@ function handleQueuedResult(
 		return;
 	}
 
-	item.resolve({
-		finished,
-		value: result as never,
-	});
+	item.resolve(result);
 }
 
 function handleQueues(state: KeyedQueueState, type: HandleType, key?: string): void {
@@ -549,7 +545,7 @@ function identify(state: QueueState): number {
  * @param value Value to check
  * @returns `true` if the value is a keyed queue, otherwise `false`
  */
-export function isKeyedQueue(value: unknown): value is KeyedQueue<unknown[], unknown> {
+export function isKeyedQueue(value: unknown): value is KeyedQueue<GenericAsyncCallback> {
 	return isQueueInstance(NAME_KEYED, value);
 }
 
@@ -559,7 +555,7 @@ export function isKeyedQueue(value: unknown): value is KeyedQueue<unknown[], unk
  * @param value Value to check
  * @returns `true` if the value is a queue, otherwise `false`
  */
-export function isQueue(value: unknown): value is Queue<unknown[], unknown> {
+export function isQueue(value: unknown): value is Queue<GenericCallback | GenericAsyncCallback> {
 	return isQueueInstance(NAME_QUEUE, value);
 }
 
@@ -571,20 +567,32 @@ export function isQueueInstance<Instance>(name: string, value: unknown): value i
 	);
 }
 
+/**
+ * Create a keyed queue for an asynchronous callback function, where each key has its own queue
+ *
+ * @param callback Callback function for queued items
+ * @param options Queue options
+ */
 export function keyedQueue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(
 	callback: Callback,
 	options?: QueueOptions,
-): KeyedQueue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
+): KeyedQueue<Callback, Parameters<Callback>>;
 
+/**
+ * Create a keyed queue for an asynchronous callback function, where each key has its own queue
+ *
+ * @param callback Callback function for queued items
+ * @param options Queue options
+ */
 export function keyedQueue<Callback extends (key: string, ...parameters: any[]) => void>(
 	callback: Callback,
 	options?: QueueOptions,
-): KeyedQueue<Parameters<Callback>, ReturnType<Callback>>;
+): KeyedQueue<Callback, Parameters<Callback>>;
 
-export function keyedQueue(
-	callback: GenericCallback | GenericAsyncCallback,
+export function keyedQueue<Callback extends (key: string, ...parameters: any[]) => Promise<void>>(
+	callback: Callback,
 	options?: QueueOptions,
-): KeyedQueue<unknown[], unknown> {
+): KeyedQueue<Callback, Parameters<Callback>> {
 	if (typeof callback !== 'function') {
 		throw new TypeError(MESSAGE_CALLBACK);
 	}
@@ -605,31 +613,7 @@ export function keyedQueue(
 		pause: (key?: string): void => {
 			handleQueues(state, HANDLE_PAUSE, key);
 		},
-		remove: (key?: string, id?: number): void => {
-			if (key == null) {
-				handleQueues(state, HANDLE_CLEAR);
-
-				state.queues.clear();
-
-				return;
-			}
-
-			const queue = getQueue(state, key);
-
-			if (queue == null) {
-				return;
-			}
-
-			if (typeof id === 'number') {
-				queue.remove(id);
-
-				return;
-			}
-
-			queue.clear();
-
-			state.queues.delete(key);
-		},
+		remove: (key?: string, id?: number): void => removeQueue(state, key, id),
 		resume: (key?: string): void => {
 			handleQueues(state, HANDLE_RESUME, key);
 		},
@@ -662,17 +646,7 @@ export function keyedQueue(
 		},
 		items: {
 			enumerable: true,
-			get: () => {
-				const size: Record<string, number> = {};
-
-				const queues = state.queues.entries();
-
-				for (const [key, queue] of queues) {
-					size[key] = queue.size;
-				}
-
-				return size;
-			},
+			get: () => getItems(state),
 		},
 		keys: {
 			enumerable: true,
@@ -692,7 +666,7 @@ export function keyedQueue(
 		},
 	});
 
-	return Object.freeze(instance) as KeyedQueue<unknown[], unknown>;
+	return Object.freeze(instance) as unknown as KeyedQueue<Callback, Parameters<Callback>>;
 }
 
 /**
@@ -705,7 +679,7 @@ export function keyedQueue(
 export function queue<Callback extends GenericAsyncCallback>(
 	callback: Callback,
 	options?: QueueOptions,
-): Queue<Parameters<Callback>, Awaited<ReturnType<Callback>>>;
+): Queue<Callback, Parameters<Callback>>;
 
 /**
  * Create a queue for a synchronous callback function
@@ -717,17 +691,43 @@ export function queue<Callback extends GenericAsyncCallback>(
 export function queue<Callback extends GenericCallback>(
 	callback: Callback,
 	options?: QueueOptions,
-): Queue<Parameters<Callback>, ReturnType<Callback>>;
+): Queue<Callback, Parameters<Callback>>;
 
-export function queue(
-	callback: GenericCallback | GenericAsyncCallback,
+export function queue<Callback extends GenericCallback | GenericAsyncCallback>(
+	callback: Callback,
 	options?: QueueOptions,
-): Queue<unknown[], unknown> {
+): Queue<Callback, Parameters<Callback>> {
 	return createQueue(callback, options);
 }
 
 queue.keyed = keyedQueue;
 
+function removeQueue(state: KeyedQueueState, key?: string, id?: number): void {
+	if (key == null) {
+		handleQueues(state, HANDLE_CLEAR);
+
+		state.queues.clear();
+
+		return;
+	}
+
+	const queue = getQueue(state, key);
+
+	if (queue == null) {
+		return;
+	}
+
+	if (typeof id === 'number') {
+		queue.remove(id);
+
+		return;
+	}
+
+	queue.clear();
+
+	state.queues.delete(key);
+}
+
 async function run(state: QueueState): Promise<void> {
 	if (state.paused || state.runners >= state.options.concurrency) {
 		return;
@@ -757,13 +757,13 @@ async function run(state: QueueState): Promise<void> {
 			const paused = item;
 
 			state.handled.push(() => {
-				handleQueuedResult(paused, error, result, state.items.length === 0);
+				handleQueuedResult(paused, error, result);
 			});
 
 			break;
 		}
 
-		handleQueuedResult(item, error, result, state.items.length === 0);
+		handleQueuedResult(item, error, result);
 
 		item = state.items.shift();
 	}