@oscarpalmer/atoms 0.212.0 → 0.214.0

package/dist/plan/run.mjs

@@ -1,23 +1,23 @@
-import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../internal/models/plan.model.mjs";
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../models/plan.model.mjs";
+import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "./is.mjs";
 import { asyncGenerate, generate } from "./generate.mjs";
 import { asyncAttemptRun, attemptRun } from "./result.mjs";
 //#region src/plan/run.ts
 function asyncRun(input, ...parameters) {
 	if (isAsyncPlan(input)) return input.run(...parameters);
-	if (isAsyncGenerator(input)) return asyncGenerate(input, parameters);
+	if (isAsyncGenerator(input)) return asyncGenerate(input, parameters, false);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function run(input, ...parameters) {
 	if (isPlan(input)) return input.run(...parameters);
-	if (isGenerator(input)) return generate(input, parameters);
+	if (isGenerator(input)) return generate(input, parameters, false);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function runAsyncPlan(...parameters) {
-	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters);
+	return asyncGenerate(this[PLAN_SYMBOL], parameters, false);
 }
 function runPlan(...parameters) {
-	return generate(this[PLAN_SYMBOL].generator, parameters);
+	return generate(this[PLAN_SYMBOL], parameters, false);
 }
 asyncRun.attempt = asyncAttemptRun;
 run.async = asyncRun;

package/dist/promise/delay.d.mts

@@ -1,4 +1,4 @@
-import { PromiseOptions } from "./models.mjs";
+import { PromiseOptions } from "../models/promise.model.mjs";
 //#region src/promise/delay.d.ts
 /**
  * Create a delayed promise that resolves after a certain amount of time, or rejects if aborted

package/dist/promise/delay.mjs

@@ -1,5 +1,6 @@
 import { createAborter } from "../internal/aborter.mjs";
-import { LIMITER_WAIT, getLimiter } from "../internal/function/limit.mjs";
+import { LIMITER_WAIT } from "../models/function/limiter.model.mjs";
+import { getLimiter } from "../internal/function/limit.mjs";
 import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/delay.ts

package/dist/promise/helpers.d.mts

@@ -1,5 +1,5 @@
-import { RequiredKeys } from "../models.mjs";
-import { FulfilledPromise, PromiseOptions, PromiseStrategy, PromisesOptions, PromisesValue, RejectedPromise } from "./models.mjs";
+import { RequiredKeys } from "../models/index.mjs";
+import { FulfilledPromise, PromiseOptions, PromiseStrategy, PromisesOptions, PromisesValue, RejectedPromise } from "../models/promise.model.mjs";
 //#region src/promise/helpers.d.ts
 export declare function createPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, "time">;
 export declare function createPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, "strategy">;

package/dist/promise/helpers.mjs

@@ -1,7 +1,7 @@
 import { isPlainObject } from "../internal/is.mjs";
 import { error, ok } from "../internal/result/misc.mjs";
 import { getNumberOrDefault } from "../internal/defaults.mjs";
-import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
+import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "../models/promise.model.mjs";
 //#region src/promise/helpers.ts
 function createPromiseOptions(input) {
 	if (typeof input === "number") return { time: getNumberOrDefault(input, 0) };
@@ -48,7 +48,10 @@ function getStrategyOrDefault(value) {
 * @returns `true` if the value is a fulfilled _Promise_ result, otherwise `false`
 */
 function isFulfilled(value) {
-	return isType(value, PROMISE_TYPE_FULFILLED);
+	return isPromiseResult(value, PROMISE_TYPE_FULFILLED);
+}
+function isPromiseResult(value, type) {
+	return isPlainObject(value) && "status" in value && value.status === type;
 }
 /**
 * Is the value a rejected _Promise_ result?
@@ -57,10 +60,7 @@ function isFulfilled(value) {
 * @returns `true` if the value is a rejected _Promise_ result, otherwise `false`
 */
 function isRejected(value) {
-	return isType(value, PROMISE_TYPE_REJECTED);
-}
-function isType(value, type) {
-	return isPlainObject(value) && "status" in value && value.status === type;
+	return isPromiseResult(value, PROMISE_TYPE_REJECTED);
 }
 //#endregion
 export { createPromiseOptions, createPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };

package/dist/promise/index.d.mts

@@ -1,5 +1,5 @@
-import { PlainObject } from "../models.mjs";
-import { PromiseOptions, PromiseStrategy, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValues } from "./models.mjs";
+import { PlainObject } from "../models/index.mjs";
+import { PromiseOptions, PromiseStrategy, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValues } from "../models/promise.model.mjs";
 //#region src/promise/index.d.ts
 /**
  * Wrap a _Promise_ with safety handlers

package/dist/promise/index.mjs

@@ -1,7 +1,7 @@
 import { isArrayOrPlainObject } from "../internal/is.mjs";
 import { createAborter } from "../internal/aborter.mjs";
 import { asyncAttempt } from "../internal/result/attempt.mjs";
-import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "../models/promise.model.mjs";
 import { createPromiseOptions, createPromisesOptions, getResultsFromPromises } from "./helpers.mjs";
 import { handleResult, settlePromise } from "./misc.mjs";
 import { getTimedPromise } from "./timed.mjs";

package/dist/promise/misc.d.mts

@@ -1,6 +1,6 @@
-import { Result } from "../internal/models/result.model.mjs";
-import { Aborter } from "../internal/aborter.mjs";
-import { CancelablePromise, PromiseParameters } from "./models.mjs";
+import { Aborter } from "../models/aborter.model.mjs";
+import { Result } from "../models/result.model.mjs";
+import { CancelablePromise, PromiseParameters } from "../models/promise.model.mjs";
 import { toPromise } from "../result/misc.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";
 //#region src/promise/misc.d.ts

package/dist/promise/misc.mjs

@@ -1,7 +1,6 @@
 import { error, ok } from "../internal/result/misc.mjs";
 import { toPromise } from "../result/misc.mjs";
-import { PROMISE_MESSAGE_EXPECTATION_RESULT } from "./constants.mjs";
-import { CancelablePromise } from "./models.mjs";
+import { CancelablePromise, PROMISE_MESSAGE_EXPECTATION_RESULT } from "../models/promise.model.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";
 //#region src/promise/misc.ts
 /**
@@ -17,7 +16,8 @@ function handleResult(status, parameters) {
 	const { aborter, complete, data, handlers, index, key, value } = parameters;
 	if (aborter?.signal.aborted ?? false) return;
 	if (!complete && status === "rejected") {
-		settlePromise(handlers.reject, value, aborter);
+		aborter?.cancel();
+		handlers.reject(value);
 		return;
 	}
 	data.result[key] = !complete ? value : status === "fulfilled" ? {
@@ -27,7 +27,10 @@ function handleResult(status, parameters) {
 		status,
 		reason: value
 	};
-	if (index === data.last) settlePromise(handlers.resolve, data.result, aborter);
+	if (index === data.last) {
+		aborter?.cancel();
+		handlers.resolve(data.result);
+	}
 }
 function settlePromise(settler, value, aborter) {
 	aborter?.cancel();

package/dist/promise/models.d.mts

@@ -1,106 +1,2 @@
-import { ArrayOrPlainObject, GenericCallback, Key } from "../models.mjs";
-import { Result } from "../internal/models/result.model.mjs";
-import { Aborter } from "../internal/aborter.mjs";
-import { PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
-//#region src/promise/models.d.ts
-/**
- * A _Promise_ that can be canceled
- */
-export declare class CancelablePromise<Value = void> extends Promise<Value> {
-  #private;
-  constructor(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void);
-  /**
-   * Cancel the _Promise_, rejecting it with an optional reason
-   *
-   * @param reason Optional reason for canceling the _Promise_
-   */
-  cancel(reason?: unknown): void;
-}
-/**
- * A _Promise_ that was fulfilled
- */
-export type FulfilledPromise<Value> = {
-  /**
-   * Status of the _Promise_
-   */
-  status: typeof PROMISE_TYPE_FULFILLED;
-  /**
-   * Value of the _Promise_
-   */
-  value: Awaited<Value>;
-};
-export type PromiseData = {
-  last: number;
-  result: ArrayOrPlainObject;
-};
-export type PromiseHandlers = {
-  resolve(value: unknown[]): void;
-  reject(reason: unknown): void;
-};
-/**
- * Options for a _Promise_-handling function
- */
-export 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 type PromiseParameters = {
-  aborter?: Aborter;
-  complete: boolean;
-  data: PromiseData;
-  handlers: PromiseHandlers;
-  index: number;
-  key: Key;
-  value?: unknown;
-};
-/**
- * _Promise_ handling strategy
- *
- * - `complete`: wait for all _Promises_ to settle, then return the results, as an array of fulfilled and/or rejected results
- * - `first`: rejects on the first rejected _Promise_, and returns an array of values
- */
-export type PromiseStrategy = "complete" | "first";
-/**
- * An error thrown when a promise times out
- */
-export declare class PromiseTimeoutError extends Error {
-  constructor();
-}
-export type PromisesItems<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]>; };
-/**
- * Options for handling multiple _Promises_
- */
-export type PromisesOptions = {
-  /**
-   * AbortSignal for aborting the _Promises_; when aborted, the _Promises_ will reject with the reason of the signal
-   */
-  signal?: AbortSignal;
-  /**
-   * Strategy for handling the _Promises_; defaults to `complete`
-   */
-  strategy?: PromiseStrategy;
-};
-export type PromisesResult<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
-export type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; };
-export type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
-export type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; };
-/**
- * A _Promise_ that was rejected
- */
-export type RejectedPromise = {
-  /**
-   * Status of the _Promise_
-   */
-  status: typeof PROMISE_TYPE_REJECTED;
-  /**
-   * Reason for the rejection
-   */
-  reason: unknown;
-};
-//#endregion
+import { CancelablePromise, FulfilledPromise, PromiseOptions, PromiseStrategy, PromiseTimeoutError, PromisesOptions, RejectedPromise } from "../models/promise.model.mjs";
+export { CancelablePromise, type FulfilledPromise, type PromiseOptions, type PromiseStrategy, PromiseTimeoutError, type PromisesOptions, type RejectedPromise };

package/dist/promise/models.mjs

@@ -1,36 +1,2 @@
-import { PROMISE_ERROR_NAME, PROMISE_MESSAGE_TIMEOUT } from "./constants.mjs";
-//#region src/promise/models.ts
-/**
-* A _Promise_ that can be canceled
-*/
-var CancelablePromise = class extends Promise {
-	#rejector;
-	constructor(executor) {
-		let rejector;
-		super((resolve, reject) => {
-			rejector = reject;
-			executor(resolve, reject);
-		});
-		this.#rejector = rejector;
-	}
-	/**
-	* Cancel the _Promise_, rejecting it with an optional reason
-	*
-	* @param reason Optional reason for canceling the _Promise_
-	*/
-	cancel(reason) {
-		this.#rejector?.(reason);
-		this.#rejector = void 0;
-	}
-};
-/**
-* An error thrown when a promise times out
-*/
-var PromiseTimeoutError = class extends Error {
-	constructor() {
-		super(PROMISE_MESSAGE_TIMEOUT);
-		this.name = PROMISE_ERROR_NAME;
-	}
-};
-//#endregion
+import { CancelablePromise, PromiseTimeoutError } from "../models/promise.model.mjs";
 export { CancelablePromise, PromiseTimeoutError };

package/dist/promise/timed.d.mts

@@ -1,5 +1,5 @@
-import { RequiredKeys } from "../models.mjs";
-import { PromiseOptions } from "./models.mjs";
+import { RequiredKeys } from "../models/index.mjs";
+import { PromiseOptions } from "../models/promise.model.mjs";
 //#region src/promise/timed.d.ts
 export declare function getTimedPromise<Value>(promise: Promise<Value>, time: number, signal?: AbortSignal): Promise<Value>;
 /**

package/dist/promise/timed.mjs

@@ -1,7 +1,7 @@
 import { createAborter } from "../internal/aborter.mjs";
-import { LIMITER_WAIT, getLimiter } from "../internal/function/limit.mjs";
-import { PROMISE_MESSAGE_EXPECTATION_TIMED } from "./constants.mjs";
-import { PromiseTimeoutError } from "./models.mjs";
+import { LIMITER_WAIT } from "../models/function/limiter.model.mjs";
+import { getLimiter } from "../internal/function/limit.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_TIMED, PromiseTimeoutError } from "../models/promise.model.mjs";
 import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/timed.ts

package/dist/query.d.mts

@@ -1,4 +1,4 @@
-import { PlainObject } from "./models.mjs";
+import { PlainObject } from "./models/index.mjs";
 //#region src/query.d.ts
 /**
  * Convert a query string to a plain _(nested)_ object

package/dist/query.mjs

@@ -2,6 +2,7 @@ import { isPlainObject } from "./internal/is.mjs";
 import { getString, ignoreKey, join, tryDecode, tryEncode } from "./internal/string/misc.mjs";
 import { getNumber } from "./internal/number.mjs";
 import { setValue } from "./internal/value/set.mjs";
+import { QUERY_EXPRESSION_ARRAY_SUFFIX, QUERY_EXPRESSION_BOOLEAN, QUERY_TRUE, QUERY_TYPES } from "./models/query.model.mjs";
 //#region src/query.ts
 /**
 * Convert a query string to a plain _(nested)_ object
@@ -11,7 +12,7 @@ import { setValue } from "./internal/value/set.mjs";
 */
 function fromQuery(query) {
 	if (typeof query !== "string" || query.trim().length === 0) return {};
-	const parts = query.split(QUERY_AMPERSAND).map((part) => part.split(QUERY_EQUAL).map(tryDecode)).sort(([first], [second]) => first.localeCompare(second));
+	const parts = query.split("&").map((part) => part.split("=").map(tryDecode)).sort(([first], [second]) => first.localeCompare(second));
 	const { length } = parts;
 	const parameters = {};
 	let position = 0;
@@ -41,9 +42,9 @@ function getParts(value, fromArray, prefix) {
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		const val = value[key];
-		const fullKey = join([prefix, fromArray ? void 0 : key], QUERY_DOT);
+		const fullKey = join([prefix, fromArray ? void 0 : key], ".");
 		const encodedKey = getString(tryEncode(fullKey));
-		const prefixedKey = fromArray ? join([encodedKey, index], QUERY_DOT) : encodedKey;
+		const prefixedKey = fromArray ? join([encodedKey, index], ".") : encodedKey;
 		if (Array.isArray(val)) parts.push(...getParts(val, true, fullKey));
 		else if (isPlainObject(val)) parts.push(...getParts(val, false, fullKey));
 		else if (isDecodable(val)) parts.push(`${prefixedKey}=${getString(tryEncode(val))}`);
@@ -70,18 +71,7 @@ function isDecodable(value) {
 * @returns Query string representation of the object
 */
 function toQuery(parameters) {
-	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), QUERY_AMPERSAND) : "";
+	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), "&") : "";
 }
-const QUERY_AMPERSAND = "&";
-const QUERY_DOT = ".";
-const QUERY_EQUAL = "=";
-const QUERY_EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
-const QUERY_EXPRESSION_BOOLEAN = /^(false|true)$/;
-const QUERY_TRUE = "true";
-const QUERY_TYPES = /* @__PURE__ */ new Set([
-	"boolean",
-	"number",
-	"string"
-]);
 //#endregion
 export { fromQuery, toQuery };

package/dist/queue.d.mts

@@ -1,203 +1,8 @@
-import { GenericAsyncCallback, GenericCallback } from "./models.mjs";
+import { GenericAsyncCallback, GenericCallback } from "./models/index.mjs";
+import { KeyedQueue, Queue, QueueOptions, Queued } from "./models/queue.model.mjs";
 //#region src/queue.d.ts
-/**
- * A queue that can be used to manage (a)synchronous tasks with a specific key
- */
-export type KeyedQueue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
-  /**
-   * Get keys of all active queues
-   */
-  get active(): string[];
-  /**
-   * Does the queue automatically start when the first item is added?
-   */
-  get autostart(): boolean;
-  /**
-   * Maximum number of runners to process the queue concurrently
-   */
-  get concurrency(): number;
-  /**
-   * Get keys of all empty queues
-   */
-  get empty(): string[];
-  /**
-   * Get keys of all full queues
-   */
-  get full(): string[];
-  /**
-   * Number of items in all queues
-   */
-  get items(): Record<string, number>;
-  /**
-   * Keys of all queues
-   */
-  get keys(): string[];
-  /**
-   * Maximum number of items allowed in the queue
-   */
-  get maximum(): number;
-  /**
-   * Are all queues paused?
-   */
-  get paused(): string[];
-  /**
-   * Number of queues
-   */
-  get queues(): number;
-  /**
-   * Queue an item for a specific key
-   *
-   * @param key Key to queue the item for
-   * @param parameters Parameters to use when item runs
-   * @param signal Optional signal to abort the item
-   * @returns Queued item
-   */
-  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)_
-   *
-   * @param key Optional key to clear the queue for
-   */
-  clear(key?: string): void;
-  /**
-   * Get the queue for a specific key
-   *
-   * @param key Key to get the queue for
-   * @returns Queue for the key, or `undefined` if it doesn't exist
-   */
-  get(key: string): Queue<Callback, Tail<CallbackParameters>> | undefined;
-  /**
-   * Pause the queue for a specific key _(or all queues, if no key is provided)_
-   *
-   * @param key Optional key to pause the queue for
-   */
-  pause(key?: string): void;
-  /**
-   * Remove a specific item for a specific key
-   *
-   * @param key Key to remove the item for
-   * @param id ID of the item to remove
-   */
-  remove(key: string, id: number): void;
-  /**
-   * Remove a queue and its items for a specific key
-   *
-   * _(To remove all items for a specific key, use `clear()` instead)_
-   *
-   * @param key Key to remove the queue for
-   */
-  remove(key: string): void;
-  /**
-   * Remove all queues and their items
-   */
-  remove(): void;
-  /**
-   * Resume the queue for a specific key _(or all queues, if no key is provided)_
-   *
-   * @param key Optional key to resume the queue for
-   */
-  resume(key?: string): void;
-};
-/**
- * A queue that can be used to manage (a)synchronous tasks
- */
-export type Queue<Callback extends GenericCallback | GenericAsyncCallback, CallbackParameters extends unknown[] = Parameters<Callback>> = {
-  /**
-   * Is the queue active?
-   */
-  get active(): boolean;
-  /**
-   * Does the queue automatically start when the first item is added?
-   */
-  get autostart(): boolean;
-  /**
-   * Maximum number of runners to process the queue concurrently
-   */
-  get concurrency(): number;
-  /**
-   * Is the queue empty?
-   */
-  get empty(): boolean;
-  /**
-   * Is the queue full?
-   */
-  get full(): boolean;
-  /**
-   * Maximum number of items allowed in the queue
-   */
-  get maximum(): number;
-  /**
-   * Is the queue paused?
-   */
-  get paused(): boolean;
-  /**
-   * Number of items in the queue
-   */
-  get size(): number;
-  /**
-   * 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, signal?: AbortSignal): Queued<ReturnType<Callback>>;
-  /**
-   * Remove and reject all items in the queue
-   */
-  clear(): void;
-  /**
-   * Pause the queue
-   *
-   * - Currently running items will not be stopped
-   * - New added items will not run until the queue is resumed
-   */
-  pause(): void;
-  /**
-   * Remove and reject a specific item in the queue
-   *
-   * @param id ID of queued item
-   */
-  remove(id: number): void;
-  /**
-   * Resume the queue
-   */
-  resume(): void;
-};
-/**
- * An error thrown by the Queue when an operation fails
- */
-export declare class QueueError extends Error {
-  constructor(message: string);
-}
-export type QueueOptions = {
-  /**
-   * Automatically start processing the queue when the first item is added _(defaults to `true`)_
-   */
-  autostart?: boolean;
-  /**
-   * Number of runners to process the queue concurrently _(defaults to `1`)_
-   */
-  concurrency?: number;
-  /**
-   * Maximum number of items allowed in the queue _(defaults to `0`, which means no limit)_
-   */
-  maximum?: number;
-};
-/**
- * A queued item
- */
-export type Queued<Value> = {
-  /**
-   * ID of the queued item _(can be used to remove it from the queue)_
-   */
-  readonly id: number;
-  /**
-   * Queued promise
-   */
-  readonly promise: Promise<Value extends Promise<infer Result> ? Result : Value>;
-};
-type Tail<Values extends any[]> = Values extends [infer _, ...infer Rest] ? Rest : never;
+declare function KeyedQueue(this: any, callback: GenericAsyncCallback, options: Required<QueueOptions>): void;
+declare function Queue(this: any, callback: GenericAsyncCallback, options: Required<QueueOptions>, key?: string): void;
 /**
  * Is the value keyed queue?
  *
@@ -250,4 +55,5 @@ export declare function queue<Callback extends GenericCallback>(callback: Callba
 export declare namespace queue {
   export var keyed: typeof keyedQueue;
 }
-//#endregion
+//#endregion
+export type { KeyedQueue, Queue, QueueOptions, Queued };

package/dist/queue.mjs

@@ -2,19 +2,8 @@ import { createAborter } from "./internal/aborter.mjs";
 import { min } from "./internal/math/aggregate.mjs";
 import { asyncAttempt } from "./internal/result/attempt.mjs";
 import { getBooleanOrDefault, getNumberOrDefault } from "./internal/defaults.mjs";
+import { QUEUE_HANDLE_CLEAR, QUEUE_HANDLE_PAUSE, QUEUE_HANDLE_RESUME, QUEUE_MESSAGE_CALLBACK, QUEUE_MESSAGE_CLEAR, QUEUE_MESSAGE_KEY, QUEUE_MESSAGE_MAXIMUM, QUEUE_MESSAGE_REMOVE, QUEUE_NAME_KEYED, QUEUE_NAME_QUEUE, QUEUE_PROPERTY, QUEUE_STATUS_ACTIVE, QUEUE_STATUS_EMPTY, QUEUE_STATUS_FULL, QUEUE_STATUS_PAUSED, QUEUE_SYMBOL, QueueError } from "./models/queue.model.mjs";
 //#region src/queue.ts
-const QUEUE_NAME_KEYED = "keyedQueue";
-const QUEUE_NAME_QUEUE = "queue";
-const QUEUE_PROPERTY = "$queue";
-/**
-* An error thrown by the Queue when an operation fails
-*/
-var QueueError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = QUEUE_ERROR_NAME;
-	}
-};
 function KeyedQueue(callback, options) {
 	this[QUEUE_SYMBOL] = {
 		callback,
@@ -158,9 +147,9 @@ function clearQueue() {
 	const items = this[QUEUE_SYMBOL].items.splice(0);
 	const { length } = items;
 	for (let index = 0; index < length; index += 1) {
-		const { aborter, reject } = items[index];
-		aborter?.cancel();
-		reject(new QueueError(QUEUE_MESSAGE_CLEAR));
+		const item = items[index];
+		item.aborter?.cancel();
+		item.reject(new QueueError(QUEUE_MESSAGE_CLEAR));
 	}
 }
 function clearQueues(key) {
@@ -287,7 +276,7 @@ function isQueue(value) {
 	return isQueueInstance(QUEUE_NAME_QUEUE, value);
 }
 function isQueueInstance(name, value) {
-	return typeof value === "object" && value != null && QUEUE_PROPERTY in value && value[QUEUE_PROPERTY] === name;
+	return typeof value === "object" && value != null && "$queue" in value && value["$queue"] === name;
 }
 function keyedQueue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
@@ -322,9 +311,9 @@ function removeQueued(id) {
 	const state = this[QUEUE_SYMBOL];
 	const index = state.items.findIndex((item) => item.id === id);
 	if (index > -1) {
-		const { aborter, reject } = state.items.splice(index, 1)[0];
-		aborter?.cancel();
-		reject(new QueueError(QUEUE_MESSAGE_REMOVE));
+		const item = state.items.splice(index, 1)[0];
+		item.aborter?.cancel();
+		item.reject(new QueueError(QUEUE_MESSAGE_REMOVE));
 	}
 }
 function resumeQueue() {
@@ -370,20 +359,6 @@ async function run(state) {
 	}
 	state.runners -= 1;
 }
-const QUEUE_ERROR_NAME = "QueueError";
-const QUEUE_HANDLE_CLEAR = "clear";
-const QUEUE_HANDLE_PAUSE = "pause";
-const QUEUE_HANDLE_RESUME = "resume";
-const QUEUE_MESSAGE_CALLBACK = "A Queue requires a callback function";
-const QUEUE_MESSAGE_CLEAR = "Queue was cleared";
-const QUEUE_MESSAGE_KEY = "Key must be a non-empty string";
-const QUEUE_MESSAGE_MAXIMUM = "Queue has reached its maximum size";
-const QUEUE_MESSAGE_REMOVE = "Item removed from queue";
-const QUEUE_STATUS_ACTIVE = "active";
-const QUEUE_STATUS_EMPTY = "empty";
-const QUEUE_STATUS_FULL = "full";
-const QUEUE_STATUS_PAUSED = "paused";
-const QUEUE_SYMBOL = Symbol(QUEUE_PROPERTY);
 queue.keyed = keyedQueue;
 //#endregion
-export { QueueError, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };
+export { isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };