@oscarpalmer/atoms 0.172.3 → 0.173.0

package/dist/index.d.mts

@@ -3739,8 +3739,24 @@ type QueueOptions = {
   maximum?: number;
 };
 type Queued<Value> = {
+  /**
+   * ID of the queued promise _(can be used to remove it from the queue)_
+   */
   readonly id: number;
-  readonly promise: Promise<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;
 };
 /**
  * Create a queue for an asynchronous callback function
@@ -4388,4 +4404,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, ExtendedErr, ExtendedResult, Flow, FlowPromise, FulfilledPromise, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, 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, type Queue, QueueError, type QueueOptions, type Queued, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, UnwrapValue, assert, attempt, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, endsWithArray, equal, error, exists, filter, find, flatten, floor, flow, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getTimedPromise, getUuid, getValue, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, includesArray, indexOf, indexOfArray, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, ExtendedErr, ExtendedResult, Flow, FlowPromise, FulfilledPromise, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, 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, type Queue, QueueError, type QueueOptions, type Queued, type QueuedResult, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, UnwrapValue, assert, attempt, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, endsWithArray, equal, error, exists, filter, find, flatten, floor, flow, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getTimedPromise, getUuid, getValue, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, includesArray, indexOf, indexOfArray, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/index.mjs

@@ -4281,11 +4281,11 @@ var Queue = class {
 			if (this.#paused) {
 				const paused = item;
 				this.#handled.push(() => {
-					handleResult$1(paused, error, result);
+					handleResult$1(paused, error, result, this.#items.length === 0);
 				});
 				break;
 			}
-			handleResult$1(item, error, result);
+			handleResult$1(item, error, result, this.#items.length === 0);
 			item = this.#items.shift();
 		}
 		this.#runners -= 1;
@@ -4311,11 +4311,14 @@ function getOptions(input) {
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
-function handleResult$1(item, error, result) {
+function handleResult$1(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(result);
+	else item.resolve({
+		finished,
+		value: result
+	});
 }
 function queue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);

package/dist/queue.d.mts

@@ -82,8 +82,24 @@ type QueueOptions = {
   maximum?: number;
 };
 type Queued<Value> = {
+  /**
+   * ID of the queued promise _(can be used to remove it from the queue)_
+   */
   readonly id: number;
-  readonly promise: Promise<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;
 };
 /**
  * Create a queue for an asynchronous callback function
@@ -100,4 +116,4 @@ declare function queue<Callback extends GenericAsyncCallback>(callback: Callback
  */
 declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Parameters<Callback>, ReturnType<Callback>>;
 //#endregion
-export { type Queue, QueueError, type QueueOptions, type Queued, queue };
+export { type Queue, QueueError, type QueueOptions, type Queued, type QueuedResult, queue };

package/dist/queue.mjs

@@ -160,11 +160,11 @@ var Queue = class {
 			if (this.#paused) {
 				const paused = item;
 				this.#handled.push(() => {
-					handleResult(paused, error, result);
+					handleResult(paused, error, result, this.#items.length === 0);
 				});
 				break;
 			}
-			handleResult(item, error, result);
+			handleResult(item, error, result, this.#items.length === 0);
 			item = this.#items.shift();
 		}
 		this.#runners -= 1;
@@ -190,11 +190,14 @@ function getOptions(input) {
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
-function handleResult(item, error, result) {
+function handleResult(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(result);
+	else item.resolve({
+		finished,
+		value: result
+	});
 }
 function queue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.172.3",
+	"version": "0.173.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"helper",
@@ -229,8 +229,10 @@
 		"watch": "npx vite build --watch"
 	},
 	"devDependencies": {
+		"@oxlint/plugins": "^1.59",
 		"@types/node": "^25.5",
 		"@vitest/coverage-istanbul": "^4.1",
+		"eslint": "^10.2",
 		"jsdom": "^29.0",
 		"tsdown": "^0.21",
 		"typescript": "^5.9",

package/plugin/get-string.js

@@ -0,0 +1,66 @@
+/**
+ * @param {import('estree').CallExpression & import('eslint').Rule.NodeParentExtension} node
+ * @returns {boolean}
+ */
+function isStringify(node) {
+	const {callee} = node;
+
+	if (callee.name === stringName) {
+		return true;
+	}
+
+	const {property} = callee;
+
+	if (
+		callee.type !== memberExpression ||
+		property == null ||
+		property.type !== identifierExpression ||
+		property.name !== toStringName
+	) {
+		return false;
+	}
+
+	// TODO: check .toString usage
+
+	return false;
+}
+
+const message = "Prefer 'getString' (@oscarpalmer/atoms) instead of 'toString' and 'String'";
+
+const selectors = [
+	`[callee.name="${stringName}"]`,
+];
+
+export default {
+	message,
+	selectors,
+	name: 'string.getString',
+	value: {
+		createOnce(context) {
+			return {
+				CallExpression(node) {
+					if (isStringify(node)) {
+						context.report({
+							message,
+							node,
+						});
+					}
+				},
+			};
+		},
+		meta: {
+			docs: {
+				description: message,
+			},
+			type: 'suggestion',
+		},
+	},
+};
+
+const identifierExpression = 'Identifier';
+
+const memberExpression = 'MemberExpression';
+
+const stringName = 'String';
+
+const toStringName = 'toString';

package/plugin/helpers.js

@@ -25,7 +25,7 @@
  * @param {string|undefined} prefix
  * @returns {string}
  */
-function getMethodNames(methods, prefix) {
+function getMethods(methods, prefix) {
 	const array = [...methods];
 	const {length} = array;
 
@@ -38,6 +38,8 @@ function getMethodNames(methods, prefix) {
 
 		if (index === 0) {
 			names = `'${name}'`;
+		} else if (length === 2) {
+			names += ` and '${name}'`;
 		} else {
 			names += index === length - 1 ? `, and '${name}'` : `, '${name}'`;
 		}
@@ -47,24 +49,31 @@ function getMethodNames(methods, prefix) {
 }
 
 /**
- * @param {Name} name
+ * @param {string} type
+ * @param {string} name
  * @param {Set<string>} methods
- * @param {Validator} validator
- * @param {string|undefined} prefix
+ * @param {boolean|undefined} isStatic
+ * @param {boolean|undefined} isGlobal
  * @returns {Plugin}
  */
-export function getPlugin(name, methods, validator, prefix) {
-	const message = `Prefer using '${name.short}' (@oscarpalmer/atoms) instead of ${getMethodNames(methods, prefix)}`;
+export function getPlugin(type, name, methods, isStatic, isGlobal) {
+	const globalMethod = isGlobal ?? false;
+	const staticMethod = isStatic ?? false;
+
+	const fullName = `${type}.${name}`;
+	const prefix = globalMethod ? undefined : staticMethod ? objects[type] : prefixes[type];
+
+	const message = `Prefer using '${name}' (@oscarpalmer/atoms) instead of ${getMethods(methods, prefix)}`;
 
 	return {
 		message,
-		name: name.full,
-		selectors: getSelectors(methods),
+		name: fullName,
+		selectors: getSelectors(type, methods, staticMethod, globalMethod),
 		value: {
-			create(context) {
+			createOnce(context) {
 				return {
 					CallExpression(node) {
-						if (validator(context, node, methods)) {
+						if (isCall(type, context, node, methods, staticMethod, globalMethod)) {
 							context.report({
 								message,
 								node,
@@ -84,20 +93,31 @@ export function getPlugin(name, methods, validator, prefix) {
 }
 
 /**
+ * @param {string} type
  * @param {Set<string>} methods
+ * @param {boolean} isStatic
+ * @param {boolean} isGlobal
  * @returns {string[]}
  */
-function getSelectors(methods) {
+function getSelectors(type, methods, isStatic, isGlobal) {
 	const array = [...methods];
 	const {length} = array;
 
+	const origin = isGlobal
+		? ''
+		: isStatic
+			? `[callee.object.type="${identifierExpression}"][callee.object.name="${objects[type]}"]`
+			: `[callee.object.type="${typeExpressions[type]}"]`;
+
 	const selectors = [];
 
 	for (let index = 0; index < length; index += 1) {
 		const method = array[index];
 
 		selectors.push(
-			`CallExpression[callee.type="${memberExpression}"][callee.object.type="${arrayExpression}"][callee.property.type="${identifierType}"][callee.property.name="${method}"]`,
+			isGlobal
+				? `CallExpression[callee.name="${method}"]`
+				: `CallExpression[callee.type="${memberExpression}"]${origin}[callee.property.type="${identifierExpression}"][callee.property.name="${method}"]`,
 		);
 	}
 
@@ -105,29 +125,106 @@ function getSelectors(methods) {
 }
 
 /**
+ * @param {string} type
  * @param {import('eslint').Rule.RuleContext} context
  * @param {import('estree').CallExpression & import('eslint').Rule.NodeParentExtension} node
  * @param {Set<string>} methods
+ * @param {boolean} isStatic
+ * @param {boolean} isGlobal
  * @returns {boolean}
  */
-export function isArrayMethod(context, node, methods) {
+function isCall(type, context, node, methods, isStatic, isGlobal) {
 	const {callee} = node;
 
-	if (callee.type !== memberExpression) {
+	if (isGlobal) {
+		return methods.has(callee.name);
+	}
+
+	if (callee.type !== memberExpression || !methods.has(callee.property.name)) {
 		return false;
 	}
 
-	const {object, property} = callee;
+	return isStatic
+		? isStaticMethod(type, context, node, methods)
+		: isInstanceMethod(type, context, node, methods);
+}
 
-	return (
-		object.type === arrayExpression &&
-		property.type === identifierType &&
-		methods.has(property.name)
-	);
+/**
+ * @param {string} type
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {import('estree').CallExpression & import('eslint').Rule.NodeParentExtension} node
+ * @param {Set<string>} methods
+ * @returns {boolean}
+ */
+function isInstanceMethod(type, context, node, methods) {
+	const {object, property} = node.callee;
+
+	if (object.type === literalExpression) {
+		return isLiteralMethod(type, context, node, methods);
+	}
+
+	if (object.type !== typeExpressions[type]) {
+		return property.type === identifierExpression && isLiteralMethod(type, context, node, methods);
+	}
+
+	return property.type === identifierExpression;
+}
+
+/**
+ * @param {string} type
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {import('estree').CallExpression & import('eslint').Rule.NodeParentExtension} node
+ * @param {Set<string>} methods
+ * @returns {boolean}
+ */
+function isLiteralMethod(type, context, node, methods) {
+	// TODO: check literal value
+
+	return false;
+}
+
+/**
+ * @param {string} type
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {import('estree').CallExpression & import('eslint').Rule.NodeParentExtension} node
+ * @param {Set<string>} methods
+ * @returns {boolean}
+ */
+function isStaticMethod(type, context, node, methods) {
+	const {object, property} = node.callee;
+
+	if (object.type !== identifierExpression || object.name !== objects[type]) {
+		return false;
+	}
+
+	return property.type === identifierExpression;
 }
 
 const arrayExpression = 'ArrayExpression';
 
+const identifierExpression = 'Identifier';
+
+const literalExpression = 'Literal';
+
 const memberExpression = 'MemberExpression';
 
-const identifierType = 'Identifier';
+const objectExpression = 'ObjectExpression';
+
+const objects = {
+	array: 'Array',
+	math: 'Math',
+	promise: 'Promise',
+	string: 'String',
+	value: 'Object',
+};
+
+const prefixes = {
+	array: 'Array.prototype',
+	string: 'String.prototype',
+};
+
+const typeExpressions = {
+	array: arrayExpression,
+	string: literalExpression,
+	value: objectExpression,
+};

package/plugin/index.js

@@ -1,16 +1,60 @@
+import {eslintCompatPlugin} from '@oxlint/plugins';
 import {groupBy} from '../dist/array/group-by.mjs';
-import array from './array.js';
+import pkg from '../package.json' with {type: 'json'};
+import getStringPlugin from './get-string.js';
+import {getPlugin} from './helpers.js';
+import tryCatchPlugin from './try-catch.js';
+
+export const arrayPlugins = [
+	getPlugin('array', 'exists', new Set(['includes'])),
+	getPlugin('array', 'filter', new Set(['filter'])),
+	getPlugin('array', 'find', new Set(['find'])),
+	getPlugin('array', 'flatten', new Set(['flat'])),
+	getPlugin('array', 'indexOf', new Set(['findIndex', 'indexOf'])),
+	getPlugin('array', 'push', new Set(['push'])),
+	getPlugin('array', 'slice', new Set(['slice'])),
+	getPlugin('array', 'sort', new Set(['sort'])),
+	getPlugin('array', 'splice', new Set(['splice'])),
+	getPlugin('array', 'times', new Set(['from']), true),
+];
+
+export const mathPlugins = [
+	getPlugin('math', 'floor', new Set(['floor']), true),
+	getPlugin('math', 'max', new Set(['max']), true),
+	getPlugin('math', 'min', new Set(['min']), true),
+	getPlugin('math', 'round', new Set(['round']), true),
+];
+
+export const miscPlugins = [
+	tryCatchPlugin,
+	getPlugin('number', 'getNumber', new Set(['Number']), true, true),
+	getPlugin('promise', 'promises', new Set(['all', 'allSettled']), true),
+	getPlugin('value', 'clone', new Set(['structuredClone']), true, true),
+	getPlugin('value', 'equal', new Set(['is']), true),
+];
+
+export const stringPlugins = [
+	getStringPlugin,
+	getPlugin('string', 'endsWith', new Set(['endsWith'])),
+	getPlugin('string', 'includes', new Set(['includes'])),
+	getPlugin('string', 'lowerCase', new Set(['toLowerCase'])),
+	getPlugin('string', 'startsWith', new Set(['startsWith'])),
+	getPlugin('string', 'upperCase', new Set(['toUpperCase'])),
+];
 
 /**
  * @typedef {import('eslint').Linter.Config} ESLintConfig
  */
-export default {
+export default eslintCompatPlugin({
 	configs: {},
 	meta: {
 		name: '@oscarpalmer/atoms',
-		version: '1.0.0',
+		version: pkg.version,
 	},
 	rules: {
-		...groupBy(array, 'name', 'value'),
+		...groupBy(arrayPlugins, 'name', 'value'),
+		...groupBy(mathPlugins, 'name', 'value'),
+		...groupBy(miscPlugins, 'name', 'value'),
+		...groupBy(stringPlugins, 'name', 'value'),
 	},
-};
+});

package/plugin/rules.js

@@ -0,0 +1,32 @@
+/**
+ * @type {Record<string, 'warn'>}
+ */
+const rules = {
+	'@oscarpalmer/atoms/array.exists': 'warn',
+	'@oscarpalmer/atoms/array.filter': 'warn',
+	'@oscarpalmer/atoms/array.find': 'warn',
+	'@oscarpalmer/atoms/array.flatten': 'warn',
+	'@oscarpalmer/atoms/array.indexOf': 'warn',
+	'@oscarpalmer/atoms/array.push': 'warn',
+	'@oscarpalmer/atoms/array.slice': 'warn',
+	'@oscarpalmer/atoms/array.sort': 'warn',
+	'@oscarpalmer/atoms/array.splice': 'warn',
+	'@oscarpalmer/atoms/array.times': 'warn',
+	'@oscarpalmer/atoms/attempt': 'warn',
+	'@oscarpalmer/atoms/math.floor': 'warn',
+	'@oscarpalmer/atoms/math.max': 'warn',
+	'@oscarpalmer/atoms/math.min': 'warn',
+	'@oscarpalmer/atoms/math.round': 'warn',
+	'@oscarpalmer/atoms/number.getNumber': 'warn',
+	'@oscarpalmer/atoms/promise.promises': 'warn',
+	'@oscarpalmer/atoms/string.endsWith': 'warn',
+	'@oscarpalmer/atoms/string.getString': 'warn',
+	'@oscarpalmer/atoms/string.includes': 'warn',
+	'@oscarpalmer/atoms/string.lowerCase': 'warn',
+	'@oscarpalmer/atoms/string.startsWith': 'warn',
+	'@oscarpalmer/atoms/string.upperCase': 'warn',
+	'@oscarpalmer/atoms/value.clone': 'warn',
+	'@oscarpalmer/atoms/value.equal': 'warn',
+};
+
+export default rules;

package/plugin/try-catch.js

@@ -0,0 +1,47 @@
+/**
+ * @param {import('estree').CallExpression & import('eslint').Rule.NodeParentExtension} node
+ * @returns {boolean}
+ */
+function isTryCatch(node) {
+	if (node.parent == null) {
+		return false;
+	}
+
+	if (node.parent.type === statement) {
+		return true;
+	}
+
+	return isTryCatch(node.parent);
+}
+
+const message = "Prefer 'attempt' (@oscarpalmer/atoms) instead of try-catch blocks";
+
+const selector = 'TryStatement > BlockStatement';
+
+export default {
+	message,
+	name: 'attempt',
+	selectors: [selector],
+	value: {
+		createOnce(context) {
+			return {
+				CallExpression(node) {
+					if (isTryCatch(node)) {
+						context.report({
+							message,
+							node,
+						});
+					}
+				},
+			};
+		},
+		meta: {
+			docs: {
+				description: message,
+			},
+			type: 'suggestion',
+		},
+	},
+};
+
+const statement = 'TryStatement';

package/src/queue.ts

@@ -100,9 +100,9 @@ class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, Callbac
 		const id = this.#identify();
 
 		let rejector: (reason?: unknown) => void;
-		let resolver: (value: CallbackResult) => void;
+		let resolver: (value: QueuedResult<CallbackResult>) => void;
 
-		const promise = new Promise<CallbackResult>((resolve, reject) => {
+		const promise = new Promise<QueuedResult<CallbackResult>>((resolve, reject) => {
 			rejector = reject;
 			resolver = resolve;
 		});
@@ -225,13 +225,13 @@ class Queue<CallbackParameters extends Parameters<GenericAsyncCallback>, Callbac
 				const paused = item;
 
 				this.#handled.push(() => {
-					handleResult(paused, error, result);
+					handleResult(paused, error, result, this.#items.length === 0);
 				});
 
 				break;
 			}
 
-			handleResult(item, error, result);
+			handleResult(item, error, result, this.#items.length === 0);
 
 			item = this.#items.shift();
 		}
@@ -264,20 +264,37 @@ type QueueOptions = {
 };
 
 type Queued<Value> = {
+	/**
+	 * ID of the queued promise _(can be used to remove it from the queue)_
+	 */
 	readonly id: number;
-	readonly promise: Promise<Value>;
+	/**
+	 * Queued promise
+	 */
+	readonly promise: Promise<QueuedResult<Value>>;
 };
 
 type QueuedItem<CallbackParameters extends Parameters<GenericAsyncCallback>, CallbackResult> = {
 	abort?: () => void;
 	id: number;
 	parameters: CallbackParameters;
-	promise: Promise<CallbackResult>;
+	promise: Promise<QueuedResult<CallbackResult>>;
 	reject: (reason?: unknown) => void;
-	resolve: (value: CallbackResult) => void;
+	resolve: (value: QueuedResult<CallbackResult>) => void;
 	signal?: AbortSignal;
 };
 
+type QueuedResult<Value> = {
+	/**
+	 * Has the queue finished processing all items?
+	 */
+	finished: boolean;
+	/**
+	 * Result for the queued promise
+	 */
+	value: Value;
+};
+
 // #endregion
 
 // #region Functions
@@ -304,6 +321,7 @@ function handleResult<CallbackParameters extends Parameters<GenericAsyncCallback
 	item: QueuedItem<CallbackParameters, CallbackResult>,
 	error: boolean,
 	result: unknown,
+	finished: boolean,
 ): void {
 	item.signal?.removeEventListener(EVENT_NAME, item.abort!);
 
@@ -313,7 +331,10 @@ function handleResult<CallbackParameters extends Parameters<GenericAsyncCallback
 		if (error) {
 			item.reject(result);
 		} else {
-			item.resolve(result as CallbackResult);
+			item.resolve({
+				finished,
+				value: result as CallbackResult,
+			});
 		}
 	}
 }
@@ -373,6 +394,6 @@ const MESSAGE_REMOVE = 'Item removed from queue';
 
 // #region Exports
 
-export {queue, QueueError, type Queue, type Queued, type QueueOptions};
+export {queue, QueueError, type Queue, type Queued, type QueueOptions, type QueuedResult};
 
 // #endregion

package/plugin/array.js

@@ -1,22 +0,0 @@
-import {getPlugin, isArrayMethod} from './helpers.js';
-
-export default [
-	getPlugin(
-		{
-			full: 'array.exists',
-			short: 'exists',
-		},
-		new Set(['includes']),
-		isArrayMethod,
-		'Array.prototype',
-	),
-	getPlugin(
-		{
-			full: 'array.sort',
-			short: 'sort',
-		},
-		new Set(['sort']),
-		isArrayMethod,
-		'Array.prototype',
-	),
-];