@oscarpalmer/atoms 0.189.0 → 0.190.0

package/dist/queue.mjs

@@ -1,345 +1,6 @@
 import { getNumberOrDefault } from "./internal/number.mjs";
 //#region src/queue.ts
 /**
-* A queue that can be used to manage (a)synchronous tasks with a specific key
-*/
-var KeyedQueue = class {
-	#callback;
-	#options;
-	#queues = /* @__PURE__ */ new Map();
-	/**
-	* Get keys of all active queues
-	*/
-	get active() {
-		return this.#getStatus(STATUS_ACTIVE);
-	}
-	/**
-	* Does the queue automatically start when the first item is added?
-	*/
-	get autostart() {
-		return this.#options.autostart;
-	}
-	/**
-	* Maximum number of runners to process the queue concurrently
-	*/
-	get concurrency() {
-		return this.#options.concurrency;
-	}
-	/**
-	* Get keys of all empty queues
-	*/
-	get empty() {
-		return this.#getStatus(STATUS_EMPTY);
-	}
-	/**
-	* Get keys of all full queues
-	*/
-	get full() {
-		return this.#getStatus(STATUS_FULL);
-	}
-	/**
-	* Number of items in all queues
-	*/
-	get items() {
-		const size = {};
-		const queues = this.#queues.entries();
-		for (const [key, queue] of queues) size[key] = queue.size;
-		return size;
-	}
-	/**
-	* Keys of all queues
-	*/
-	get keys() {
-		return [...this.#queues.keys()];
-	}
-	/**
-	* Maximum number of items allowed in the queue
-	*/
-	get maximum() {
-		return this.#options.maximum;
-	}
-	/**
-	* Are all queues paused?
-	*/
-	get paused() {
-		return this.#getStatus(STATUS_PAUSED);
-	}
-	/**
-	* Number of queues
-	*/
-	get queues() {
-		return this.#queues.size;
-	}
-	constructor(callback, options) {
-		this.#callback = callback;
-		this.#options = options;
-	}
-	/**
-	* 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, parameters, signal) {
-		return this.#getQueue(key, true).add(parameters, signal);
-	}
-	/**
-	* 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) {
-		this.#handleQueues(HANDLE_CLEAR, key);
-	}
-	/**
-	* 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) {
-		return this.#getQueue(key);
-	}
-	/**
-	* 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) {
-		this.#handleQueues(HANDLE_PAUSE, key);
-	}
-	remove(key, id) {
-		if (key == null) {
-			this.#handleQueues(HANDLE_CLEAR);
-			this.#queues.clear();
-			return;
-		}
-		const queue = this.#getQueue(key);
-		if (queue == null) return;
-		if (typeof id === "number") {
-			queue.remove(id);
-			return;
-		}
-		queue.clear();
-		this.#queues.delete(key);
-	}
-	/**
-	* 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) {
-		this.#handleQueues(HANDLE_RESUME, key);
-	}
-	#getQueue(key, add) {
-		if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(MESSAGE_KEY);
-		let queue = this.#queues.get(key);
-		if (queue == null && add === true) {
-			queue = new Queue(this.#callback, this.#options, key);
-			this.#queues.set(key, queue);
-		}
-		return queue;
-	}
-	#getStatus(status) {
-		const queues = this.#queues.entries();
-		const result = [];
-		for (const [key, queue] of queues) if (queue[status]) result.push(key);
-		return result;
-	}
-	#handleQueues(type, key) {
-		if (typeof key === "string") {
-			this.#getQueue(key)?.[type]();
-			return;
-		}
-		const queues = this.#queues.values();
-		for (const queue of queues) queue[type]();
-	}
-};
-/**
-* A queue that can be used to manage (a)synchronous tasks
-*/
-var Queue = class {
-	#callback;
-	#handled = [];
-	#id = 0;
-	#items = [];
-	#key;
-	#options;
-	#paused;
-	#runners = 0;
-	/**
-	* Is the queue active?
-	*/
-	get active() {
-		return this.#runners > 0;
-	}
-	/**
-	* Does the queue automatically start when the first item is added?
-	*/
-	get autostart() {
-		return this.#options.autostart;
-	}
-	/**
-	* Maximum number of runners to process the queue concurrently
-	*/
-	get concurrency() {
-		return this.#options.concurrency;
-	}
-	/**
-	* Is the queue empty?
-	*/
-	get empty() {
-		return this.#items.length === 0;
-	}
-	/**
-	* Is the queue full?
-	*/
-	get full() {
-		return this.#options.maximum > 0 && this.#items.length >= this.#options.maximum;
-	}
-	/**
-	* Maximum number of items allowed in the queue
-	*/
-	get maximum() {
-		return this.#options.maximum;
-	}
-	/**
-	* Is the queue paused?
-	*/
-	get paused() {
-		return this.#paused;
-	}
-	/**
-	* Number of items in the queue
-	*/
-	get size() {
-		return this.#items.length;
-	}
-	constructor(callback, options, key) {
-		this.#callback = callback;
-		this.#key = key;
-		this.#options = options;
-		this.#paused = !options.autostart;
-	}
-	/**
-	* 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, 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 promise = new Promise((resolve, reject) => {
-			rejector = reject;
-			resolver = resolve;
-		});
-		const aborter = abortSignal == null ? void 0 : () => rejector(abortSignal.reason);
-		signal?.addEventListener(EVENT_NAME, aborter, EVENT_OPTIONS);
-		this.#items.push({
-			id,
-			parameters,
-			promise,
-			abort: aborter,
-			key: this.#key,
-			reject: rejector,
-			resolve: resolver,
-			signal: abortSignal
-		});
-		if (this.#options.autostart) this.#run();
-		return {
-			id,
-			promise
-		};
-	}
-	/**
-	* Remove and reject all items in the queue
-	*/
-	clear() {
-		const items = this.#items.splice(0);
-		const { length } = items;
-		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
-	*
-	* - Currently running items will not be stopped
-	* - New added items will not run until the queue is resumed
-	*/
-	pause() {
-		this.#paused = true;
-	}
-	/**
-	* Remove and reject a specific item in the queue
-	*
-	* @param id ID of queued item
-	*/
-	remove(id) {
-		const index = this.#items.findIndex((item) => item.id === id);
-		if (index > -1) {
-			const { abort, reject, signal } = this.#items.splice(index, 1)[0];
-			reject(new QueueError(MESSAGE_REMOVE));
-			signal?.removeEventListener(EVENT_NAME, abort);
-		}
-	}
-	/**
-	* Resume the queue
-	*/
-	resume() {
-		if (this.#paused) {
-			const handled = this.#handled.splice(0);
-			const { length } = handled;
-			for (let index = 0; index < length; index += 1) handled[index]();
-		}
-		this.#paused = false;
-		const length = Math.min(this.#options.concurrency, this.#items.length);
-		for (let index = 0; index < length; index += 1) this.#run();
-	}
-	#identify() {
-		this.#id += 1;
-		return this.#id;
-	}
-	async #run() {
-		if (this.#paused || this.#runners >= this.#options.concurrency) return;
-		this.#runners += 1;
-		let item = this.#items.shift();
-		while (item != null) {
-			let error = false;
-			let result;
-			try {
-				if (!(item.signal?.aborted ?? false)) {
-					const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
-					result = await this.#callback(...parameters);
-				}
-			} catch (thrown) {
-				error = true;
-				result = thrown;
-			}
-			if (this.#paused) {
-				const paused = item;
-				this.#handled.push(() => {
-					handleQueuedResult(paused, error, result, this.#items.length === 0);
-				});
-				break;
-			}
-			handleQueuedResult(item, error, result, this.#items.length === 0);
-			item = this.#items.shift();
-		}
-		this.#runners -= 1;
-	}
-};
-/**
 * An error thrown by the Queue when an operation fails
 */
 var QueueError = class extends Error {
@@ -348,6 +9,119 @@ var QueueError = class extends Error {
 		this.name = ERROR_NAME;
 	}
 };
+function createQueue(callback, options, key) {
+	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
+	const state = {
+		callback,
+		key,
+		handled: [],
+		id: 0,
+		items: [],
+		options: getOptions(options),
+		paused: !getBooleanOrDefault(options?.autostart, true),
+		runners: 0
+	};
+	const instance = {
+		add: (parameters, signal) => {
+			if (instance.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 = identify(state);
+			let rejector;
+			let resolver;
+			const promise = new Promise((resolve, reject) => {
+				rejector = reject;
+				resolver = resolve;
+			});
+			const aborter = abortSignal == null ? void 0 : () => rejector(abortSignal.reason);
+			signal?.addEventListener(EVENT_NAME, aborter, EVENT_OPTIONS);
+			state.items.push({
+				id,
+				parameters,
+				promise,
+				abort: aborter,
+				key: state.key,
+				reject: rejector,
+				resolve: resolver,
+				signal: abortSignal
+			});
+			if (state.options.autostart) run(state);
+			return {
+				id,
+				promise
+			};
+		},
+		clear: () => {
+			const items = state.items.splice(0);
+			const { length } = items;
+			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: () => {
+			state.paused = true;
+		},
+		remove: (id) => {
+			const index = state.items.findIndex((item) => item.id === id);
+			if (index > -1) {
+				const { abort, reject, signal } = state.items.splice(index, 1)[0];
+				reject(new QueueError(MESSAGE_REMOVE));
+				signal?.removeEventListener(EVENT_NAME, abort);
+			}
+		},
+		resume: () => {
+			if (state.paused) {
+				const handled = state.handled.splice(0);
+				const { length } = handled;
+				for (let index = 0; index < length; index += 1) handled[index]();
+			}
+			state.paused = false;
+			const length = Math.min(state.options.concurrency, state.items.length);
+			for (let index = 0; index < length; index += 1) run(state);
+		}
+	};
+	Object.defineProperties(instance, {
+		[KEY_QUEUE]: {
+			enumerable: false,
+			value: NAME_QUEUE
+		},
+		active: {
+			enumerable: true,
+			get: () => state.runners > 0
+		},
+		autostart: {
+			enumerable: true,
+			get: () => state.options.autostart
+		},
+		concurrency: {
+			enumerable: true,
+			get: () => state.options.concurrency
+		},
+		empty: {
+			enumerable: true,
+			get: () => state.items.length === 0
+		},
+		full: {
+			enumerable: true,
+			get: () => state.options.maximum > 0 && state.items.length >= state.options.maximum
+		},
+		maximum: {
+			enumerable: true,
+			get: () => state.options.maximum
+		},
+		paused: {
+			enumerable: true,
+			get: () => state.paused
+		},
+		size: {
+			enumerable: true,
+			get: () => state.items.length
+		}
+	});
+	return Object.freeze(instance);
+}
 function getBooleanOrDefault(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue;
 }
@@ -359,27 +133,193 @@ function getOptions(input) {
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
+function getQueue(state, key, add) {
+	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(MESSAGE_KEY);
+	let queue = state.queues.get(key);
+	if (queue == null && add === true) {
+		queue = createQueue(state.callback, state.options, key);
+		state.queues.set(key, queue);
+	}
+	return queue;
+}
+function getStatus(state, status) {
+	const queues = state.queues.entries();
+	const result = [];
+	for (const [key, queue] of queues) if (queue[status]) result.push(key);
+	return result;
+}
 function handleQueuedResult(item, error, result, finished) {
 	item.signal?.removeEventListener(EVENT_NAME, item.abort);
-	if (item.signal?.aborted ?? false) item.reject();
-	else if (error) item.reject(result);
-	else item.resolve({
+	if (item.signal?.aborted ?? false) {
+		item.reject();
+		return;
+	}
+	if (error) {
+		item.reject(result);
+		return;
+	}
+	item.resolve({
 		finished,
 		value: result
 	});
 }
+function handleQueues(state, type, key) {
+	if (typeof key === "string") {
+		getQueue(state, key)?.[type]();
+		return;
+	}
+	const queues = state.queues.values();
+	for (const queue of queues) queue[type]();
+}
+function identify(state) {
+	state.id += 1;
+	return state.id;
+}
+/**
+* Is the value keyed queue?
+*
+* @param value Value to check
+* @returns `true` if the value is a keyed queue, otherwise `false`
+*/
+function isKeyedQueue(value) {
+	return isQueueInstance(NAME_KEYED, value);
+}
+/**
+* Is the value a queue?
+*
+* @param value Value to check
+* @returns `true` if the value is a queue, otherwise `false`
+*/
+function isQueue(value) {
+	return isQueueInstance(NAME_QUEUE, value);
+}
+function isQueueInstance(name, value) {
+	return typeof value === "object" && value != null && value[KEY_QUEUE] === name;
+}
 function keyedQueue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
-	return new KeyedQueue(callback, getOptions(options));
+	const state = {
+		callback,
+		options: getOptions(options),
+		queues: /* @__PURE__ */ new Map()
+	};
+	const instance = {
+		add: (key, parameters, signal) => getQueue(state, key, true).add(parameters, signal),
+		clear: (key) => {
+			handleQueues(state, HANDLE_CLEAR, key);
+		},
+		get: (key) => getQueue(state, key),
+		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);
+		},
+		resume: (key) => {
+			handleQueues(state, HANDLE_RESUME, key);
+		}
+	};
+	Object.defineProperties(instance, {
+		[KEY_QUEUE]: {
+			enumerable: false,
+			value: NAME_KEYED
+		},
+		active: {
+			enumerable: true,
+			get: () => getStatus(state, STATUS_ACTIVE)
+		},
+		autostart: {
+			enumerable: true,
+			get: () => state.options.autostart
+		},
+		concurrency: {
+			enumerable: true,
+			get: () => state.options.concurrency
+		},
+		empty: {
+			enumerable: true,
+			get: () => getStatus(state, STATUS_EMPTY)
+		},
+		full: {
+			enumerable: true,
+			get: () => getStatus(state, STATUS_FULL)
+		},
+		items: {
+			enumerable: true,
+			get: () => {
+				const size = {};
+				const queues = state.queues.entries();
+				for (const [key, queue] of queues) size[key] = queue.size;
+				return size;
+			}
+		},
+		keys: {
+			enumerable: true,
+			get: () => [...state.queues.keys()]
+		},
+		maximum: {
+			enumerable: true,
+			get: () => state.options.maximum
+		},
+		paused: {
+			enumerable: true,
+			get: () => getStatus(state, STATUS_PAUSED)
+		},
+		queues: {
+			enumerable: true,
+			get: () => state.queues.size
+		}
+	});
+	return Object.freeze(instance);
 }
 function queue(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
-	return new Queue(callback, getOptions(options));
+	return createQueue(callback, options);
 }
 queue.keyed = keyedQueue;
+async function run(state) {
+	if (state.paused || state.runners >= state.options.concurrency) return;
+	state.runners += 1;
+	let item = state.items.shift();
+	while (item != null) {
+		let error = false;
+		let result;
+		try {
+			if (!(item.signal?.aborted ?? false)) {
+				const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
+				result = await state.callback(...parameters);
+			}
+		} catch (thrown) {
+			error = true;
+			result = thrown;
+		}
+		if (state.paused) {
+			const paused = item;
+			state.handled.push(() => {
+				handleQueuedResult(paused, error, result, state.items.length === 0);
+			});
+			break;
+		}
+		handleQueuedResult(item, error, result, state.items.length === 0);
+		item = state.items.shift();
+	}
+	state.runners -= 1;
+}
 const ERROR_NAME = "QueueError";
 const EVENT_NAME = "abort";
 const EVENT_OPTIONS = { once: true };
+const KEY_QUEUE = "$queue";
 const HANDLE_CLEAR = "clear";
 const HANDLE_PAUSE = "pause";
 const HANDLE_RESUME = "resume";
@@ -388,9 +328,11 @@ const MESSAGE_CLEAR = "Queue was cleared";
 const MESSAGE_KEY = "Key must be a non-empty string";
 const MESSAGE_MAXIMUM = "Queue has reached its maximum size";
 const MESSAGE_REMOVE = "Item removed from queue";
+const NAME_KEYED = "keyedQueue";
+const NAME_QUEUE = "queue";
 const STATUS_ACTIVE = "active";
 const STATUS_EMPTY = "empty";
 const STATUS_FULL = "full";
 const STATUS_PAUSED = "paused";
 //#endregion
-export { keyedQueue, queue };
+export { QueueError, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };

package/dist/string/fuzzy.d.mts

@@ -3,8 +3,7 @@ import { PlainObject } from "../models.mjs";
 /**
  * Fuzzy searcher for an array of items
  */
-declare class Fuzzy<Item> {
-  #private;
+type Fuzzy<Item> = {
   /**
    * Get items currently being searched through
    *
@@ -23,7 +22,6 @@ declare class Fuzzy<Item> {
    * @returns Stringified items
    */
   get strings(): string[];
-  constructor(state: FuzzyState<Item>);
   /**
    * Search for items matching the given value
    *
@@ -40,7 +38,7 @@ declare class Fuzzy<Item> {
    * @returns Search results, with exact matches _(ordered)_ and similar matches _(ordered by relevance)_
    */
   search(value: string, limit: number): FuzzyResult<Item>;
-}
+};
 type FuzzyConfiguration<Item> = {
   /**
    * Handler to stringify items
@@ -87,13 +85,6 @@ type FuzzyResult<Item> = {
  * Options for fuzzy searching
  */
 type FuzzySearchOptions = FuzzyOptions;
-type FuzzyState<Item> = {
-  handler: (item: Item) => string;
-  items: Item[];
-  limit?: number;
-  strings: string[];
-  tolerance: number;
-};
 /**
  * Create a fuzzy searcher for an array of items
  *
@@ -126,8 +117,8 @@ declare namespace fuzzy {
  *
  * @param haystack Haystack to search through
  * @param needle Needle to search for
- * @returns `true` if the needle matches the haystack in a fuzzy way, `false` otherwise
+ * @returns `true` if the needle matches the haystack in a fuzzy way, otherwise `false`
  */
 declare function fuzzyMatch(haystack: string, needle: string): boolean;
 //#endregion
-export { FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, fuzzy, fuzzyMatch };
+export { Fuzzy, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, fuzzy, fuzzyMatch };