@oscarpalmer/atoms 0.203.0 → 0.204.0

package/dist/promise/helpers.mjs

@@ -1,3 +1,4 @@
+import { isPlainObject } from "../internal/is.mjs";
 import { getNumberOrDefault } from "../internal/defaults.mjs";
 import { error, ok } from "../internal/result/misc.mjs";
 import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
@@ -8,7 +9,7 @@ function createPromiseOptions(input) {
 		signal: input,
 		time: 0
 	};
-	const options = typeof input === "object" && input !== null ? input : {};
+	const options = isPlainObject(input) ? input : {};
 	return {
 		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
 		time: getNumberOrDefault(options.time, 0)
@@ -20,7 +21,7 @@ function createPromisesOptions(input) {
 		signal: input,
 		strategy: PROMISE_STRATEGY_DEFAULT
 	};
-	const options = typeof input === "object" && input !== null ? input : {};
+	const options = isPlainObject(input) ? input : {};
 	return {
 		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
 		strategy: getStrategyOrDefault(options.strategy)
@@ -59,7 +60,7 @@ function isRejected(value) {
 	return isType(value, PROMISE_TYPE_REJECTED);
 }
 function isType(value, type) {
-	return typeof value === "object" && value !== null && value.status === type;
+	return isPlainObject(value) && "status" in value && value.status === type;
 }
 //#endregion
 export { createPromiseOptions, createPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };

package/dist/promise/index.mjs

@@ -1,5 +1,5 @@
 import { isArrayOrPlainObject } from "../internal/is.mjs";
-import { createAborter } from "../internal/abort.mjs";
+import { createAborter } from "../internal/aborter.mjs";
 import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
 import { createPromiseOptions, createPromisesOptions, getResultsFromPromises } from "./helpers.mjs";
 import { handleResult, settlePromise } from "./misc.mjs";
@@ -75,6 +75,5 @@ async function resultPromises(items, signal) {
 	return promises(items, signal).then(getResultsFromPromises);
 }
 promises.result = resultPromises;
-Object.defineProperty(promises, "result", { value: resultPromises });
 //#endregion
 export { attemptPromise, promises, resultPromises };

package/dist/promise/misc.d.mts

@@ -1,5 +1,5 @@
 import { Result } from "../internal/result/models.mjs";
-import { Aborter } from "../internal/abort.mjs";
+import { Aborter } from "../internal/aborter.mjs";
 import { CancelablePromise, PromiseParameters } from "./models.mjs";
 import { toPromise } from "../result/misc.mjs";
 import { isFulfilled, isRejected } from "./helpers.mjs";

package/dist/promise/models.d.mts

@@ -1,6 +1,6 @@
 import { ArrayOrPlainObject, GenericCallback, Key } from "../models.mjs";
 import { Result } from "../internal/result/models.mjs";
-import { Aborter } from "../internal/abort.mjs";
+import { Aborter } from "../internal/aborter.mjs";
 import { PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
 //#region src/promise/models.d.ts
 /**

package/dist/promise/timed.mjs

@@ -1,4 +1,4 @@
-import { createAborter } from "../internal/abort.mjs";
+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";

package/dist/queue.mjs

@@ -1,4 +1,4 @@
-import { createAborter } from "./internal/abort.mjs";
+import { createAborter } from "./internal/aborter.mjs";
 import { getBooleanOrDefault, getNumberOrDefault } from "./internal/defaults.mjs";
 //#region src/queue.ts
 const QUEUE_NAME_KEYED = "keyedQueue";
@@ -14,83 +14,63 @@ var QueueError = class extends Error {
 	}
 };
 function KeyedQueue(callback, options) {
-	Object.defineProperty(this, QUEUE_SYMBOL, { value: {
+	this[QUEUE_SYMBOL] = {
 		callback,
 		options: createQueueOptions(options),
 		queues: /* @__PURE__ */ new Map()
-	} });
+	};
 }
+KeyedQueue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_KEYED;
+KeyedQueue.prototype.add = addKeyedQueue;
+KeyedQueue.prototype.clear = clearQueues;
+KeyedQueue.prototype.get = getQueue;
+KeyedQueue.prototype.pause = pauseQueues;
+KeyedQueue.prototype.remove = removeQueue;
+KeyedQueue.prototype.resume = resumeQueues;
 Object.defineProperties(KeyedQueue.prototype, {
-	[QUEUE_PROPERTY]: { value: QUEUE_NAME_KEYED },
 	active: {
 		enumerable: true,
-		get() {
-			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_ACTIVE);
-		}
+		get: getActiveQueues
 	},
-	add: { value: addKeyedQueue },
 	autostart: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.autostart;
-		}
+		get: getQueueAutostart
 	},
-	clear: { value: clearQueues },
 	concurrency: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.concurrency;
-		}
+		get: getQueueConcurrency
 	},
 	empty: {
 		enumerable: true,
-		get() {
-			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_EMPTY);
-		}
+		get: getEmptyQueues
 	},
 	full: {
 		enumerable: true,
-		get() {
-			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_FULL);
-		}
+		get: getFullQueues
 	},
-	get: { value: getQueue },
 	items: {
 		enumerable: true,
-		get() {
-			return getQueueItems(this[QUEUE_SYMBOL]);
-		}
+		get: getKeyedQueueItems
 	},
 	keys: {
 		enumerable: true,
-		get() {
-			return [...this[QUEUE_SYMBOL].queues.keys()];
-		}
+		get: getQueueKeys
 	},
 	maximum: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.maximum;
-		}
+		get: getQueueMaximum
 	},
-	pause: { value: pauseQueues },
 	paused: {
 		enumerable: true,
-		get() {
-			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_PAUSED);
-		}
+		get: getPausedQueues
 	},
 	queues: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].queues.size;
-		}
-	},
-	remove: { value: removeQueue },
-	resume: { value: resumeQueues }
+		get: getKeyedQueueSize
+	}
 });
 function Queue(callback, options, key) {
-	Object.defineProperty(this, QUEUE_SYMBOL, { value: {
+	this[QUEUE_SYMBOL] = {
 		callback,
 		key,
 		options,
@@ -99,63 +79,46 @@ function Queue(callback, options, key) {
 		items: [],
 		paused: !options.autostart,
 		runners: 0
-	} });
+	};
 }
+Queue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_QUEUE;
+Queue.prototype.add = addToQueue;
+Queue.prototype.clear = clearQueue;
+Queue.prototype.pause = pauseQueue;
+Queue.prototype.remove = removeQueued;
+Queue.prototype.resume = resumeQueue;
 Object.defineProperties(Queue.prototype, {
-	[QUEUE_PROPERTY]: { value: QUEUE_NAME_QUEUE },
 	active: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].runners > 0;
-		}
+		get: getQueueActive
 	},
-	add: { value: addToQueue },
 	autostart: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.autostart;
-		}
+		get: getQueueAutostart
 	},
-	clear: { value: clearQueue },
 	concurrency: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.concurrency;
-		}
+		get: getQueueConcurrency
 	},
 	empty: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].items.length === 0;
-		}
+		get: getQueueEmpty
 	},
 	full: {
 		enumerable: true,
-		get() {
-			const state = this[QUEUE_SYMBOL];
-			return state.options.maximum > 0 && state.items.length >= state.options.maximum;
-		}
+		get: getQueueFull
 	},
 	maximum: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.maximum;
-		}
+		get: getQueueMaximum
 	},
-	pause: { value: pauseQueue },
 	paused: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].paused;
-		}
+		get: getQueuePaused
 	},
-	remove: { value: removeQueued },
-	resume: { value: resumeQueue },
 	size: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].items.length;
-		}
+		get: getQueueSize
 	}
 });
 function addKeyedQueue(key, parameters, signal) {
@@ -213,6 +176,28 @@ function createQueueOptions(input) {
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
+function getActiveQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_ACTIVE);
+}
+function getEmptyQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_EMPTY);
+}
+function getFullQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_FULL);
+}
+function getPausedQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_PAUSED);
+}
+function getKeyedQueueItems() {
+	const state = this[QUEUE_SYMBOL];
+	const size = {};
+	const queues = state.queues.entries();
+	for (const [key, queue] of queues) size[key] = queue.size;
+	return size;
+}
+function getKeyedQueueSize() {
+	return this[QUEUE_SYMBOL].queues.size;
+}
 function getQueue(key, add) {
 	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(QUEUE_MESSAGE_KEY);
 	const state = this[QUEUE_SYMBOL];
@@ -223,11 +208,33 @@ function getQueue(key, add) {
 	}
 	return queue;
 }
-function getQueueItems(state) {
-	const size = {};
-	const queues = state.queues.entries();
-	for (const [key, queue] of queues) size[key] = queue.size;
-	return size;
+function getQueueActive() {
+	return this[QUEUE_SYMBOL].runners > 0;
+}
+function getQueueAutostart() {
+	return this[QUEUE_SYMBOL].options.autostart === true;
+}
+function getQueueConcurrency() {
+	return this[QUEUE_SYMBOL].options.concurrency;
+}
+function getQueueEmpty() {
+	return this[QUEUE_SYMBOL].items.length === 0;
+}
+function getQueueFull() {
+	const state = this[QUEUE_SYMBOL];
+	return state.options.maximum > 0 && state.items.length >= state.options.maximum;
+}
+function getQueueKeys() {
+	return [...this[QUEUE_SYMBOL].queues.keys()];
+}
+function getQueueMaximum() {
+	return this[QUEUE_SYMBOL].options.maximum;
+}
+function getQueuePaused() {
+	return this[QUEUE_SYMBOL].paused === true;
+}
+function getQueueSize() {
+	return this[QUEUE_SYMBOL].items.length;
 }
 function getStatus(state, status) {
 	const queues = state.queues.entries();
@@ -373,6 +380,5 @@ const QUEUE_STATUS_FULL = "full";
 const QUEUE_STATUS_PAUSED = "paused";
 const QUEUE_SYMBOL = Symbol(QUEUE_PROPERTY);
 queue.keyed = keyedQueue;
-Object.defineProperty(queue, "keyed", { value: keyedQueue });
 //#endregion
 export { QueueError, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };

package/dist/result/index.mjs

@@ -18,6 +18,5 @@ function attempt(callback, err) {
 	}
 }
 attempt.async = asyncAttempt;
-Object.defineProperty(attempt, "async", { value: asyncAttempt });
 //#endregion
 export { asyncAttempt, attempt };

package/dist/result/match.mjs

@@ -23,6 +23,5 @@ function matchResult(result, first, error) {
 }
 const MATCH_MESSAGE = "`result.match` expected a Result or a function that returns a Result";
 matchResult.async = asyncMatchResult;
-Object.defineProperty(matchResult, "async", { value: asyncMatchResult });
 //#endregion
 export { asyncMatchResult, matchResult };

package/dist/result/work/flow.mjs

@@ -23,6 +23,5 @@ function attemptFlow(...fns) {
 	});
 }
 attemptFlow.async = attemptAsyncFlow;
-Object.defineProperty(attemptFlow, "async", { value: attemptAsyncFlow });
 //#endregion
 export { attemptAsyncFlow, attemptFlow };

package/dist/result/work/pipe.mjs

@@ -19,6 +19,5 @@ function attemptPipe(initial, first, ...seconds) {
 	});
 }
 attemptPipe.async = attemptAsyncPipe;
-Object.defineProperty(attemptPipe, "async", { value: attemptAsyncPipe });
 //#endregion
 export { attemptAsyncPipe, attemptPipe };

package/dist/string/fuzzy.mjs

@@ -6,27 +6,24 @@ import { includes } from "./match.mjs";
 const FUZZY_PROPERTY = "$fuzzy";
 const FUZZY_SYMBOL = Symbol(FUZZY_PROPERTY);
 function Fuzzy(state) {
-	Object.defineProperty(this, FUZZY_SYMBOL, { value: state });
+	this[FUZZY_SYMBOL] = state;
 }
+Fuzzy.prototype[FUZZY_PROPERTY] = true;
+Fuzzy.prototype.search = search;
 Object.defineProperties(Fuzzy.prototype, {
-	[FUZZY_PROPERTY]: { value: true },
 	items: {
 		enumerable: true,
-		get() {
-			return this[FUZZY_SYMBOL].items.slice();
-		},
-		set(value) {
-			setItems(this[FUZZY_SYMBOL], value);
-		}
+		get: getFuzzyItems,
+		set: setFuzzyItems
 	},
-	search: { value: search },
 	strings: {
 		enumerable: true,
-		get() {
-			return this[FUZZY_SYMBOL].strings.slice();
-		}
+		get: getFuzzyStrings
 	}
 });
+function createFuzzyItems(items) {
+	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
+}
 function createFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
 	const limit = typeof input === "number" ? input : options.limit;
@@ -75,8 +72,11 @@ function getHandler(input) {
 			throw new TypeError(FUZZY_MESSAGE_HANDLER);
 	}
 }
-function getFuzzyItems(items) {
-	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
+function getFuzzyItems() {
+	return this[FUZZY_SYMBOL].items.slice();
+}
+function getFuzzyStrings() {
+	return this[FUZZY_SYMBOL].strings.slice();
 }
 function getScore(haystack, needle) {
 	if (!isSubsequence(haystack, needle)) return -1;
@@ -171,16 +171,17 @@ function search(input, option) {
 		for (let index = 0; index < length; index += 1) {
 			const key = keys[index];
 			if (maxScore - key > options.tolerance) break;
-			similar.push(...getFuzzyItems(scored[key]));
+			similar.push(...createFuzzyItems(scored[key]));
 		}
 	}
-	result.exact = getFuzzyItems(options.limit == null ? exact : exact.slice(0, options.limit));
+	result.exact = createFuzzyItems(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;
 }
-function setItems(state, value) {
+function setFuzzyItems(value) {
 	if (!Array.isArray(value)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
+	const state = this[FUZZY_SYMBOL];
 	state.items = value.slice();
 	state.strings = value.map(state.handler);
 }
@@ -190,9 +191,5 @@ const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify ite
 const FUZZY_PROXIMITY_THRESHOLD = 5;
 fuzzy.is = isFuzzy;
 fuzzy.match = fuzzyMatch;
-Object.defineProperties(fuzzy, {
-	is: { value: isFuzzy },
-	match: { value: fuzzyMatch }
-});
 //#endregion
 export { fuzzy, fuzzyMatch, isFuzzy };

package/dist/string/normalize.mjs

@@ -3,9 +3,9 @@ import { memoize } from "../internal/function/memoize.mjs";
 import { lowerCase } from "../internal/string/case.mjs";
 //#region src/string/normalize.ts
 function Normalizer(options) {
-	Object.defineProperty(this, NORMALIZE_SYMBOL, { value: options });
+	this[NORMALIZE_SYMBOL] = options;
 }
-Object.defineProperties(Normalizer.prototype, { normalize: { value: normalizeString } });
+Normalizer.prototype.normalize = normalizeString;
 function createNormalizeOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -108,6 +108,5 @@ const NORMALIZE_WHITESPACE_PATTERN = /\s+/g;
 const NORMALIZE_WHITESPACE_REPLACEMENT = " ";
 let deburrMemoizer;
 normalize.initialize = initializeNormalizer;
-Object.defineProperty(normalize, "initialize", { value: initializeNormalizer });
 //#endregion
 export { deburr, initializeNormalizer, normalize };

package/dist/string/template.mjs

@@ -3,9 +3,9 @@ import { getString, interpolate } from "../internal/string/misc.mjs";
 import { getValue } from "../internal/value/get.mjs";
 //#region src/string/template.ts
 function Templater(options) {
-	Object.defineProperty(this, TEMPLATE_SYMBOL, { value: options });
+	this[TEMPLATE_SYMBOL] = options;
 }
-Object.defineProperties(Templater.prototype, { render: { value: render } });
+Templater.prototype.render = render;
 function createTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -54,6 +54,5 @@ function template(value, ...parameters) {
 const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
 const TEMPLATE_SYMBOL = Symbol("template");
 template.initialize = initializeTemplater;
-Object.defineProperty(template, "initialize", { value: initializeTemplater });
 //#endregion
 export { initializeTemplater, template };

package/dist/value/clone.d.mts

@@ -51,7 +51,7 @@ export declare namespace clone {
   var deregister: typeof deregisterCloner;
   var handlers: {
     base: {
-      handlers: WeakMap<Constructor, string | GenericCallback>;
+      handlers: WeakMap<WeakKey, string | GenericCallback>;
       options: {
         callback: GenericCallback;
         method?: string;

package/dist/value/clone.mjs

@@ -3,13 +3,11 @@ import { createValueHandler } from "../internal/value/handlers.mjs";
 //#region src/value/clone.ts
 const CLONE_NAME = "clone";
 function Cloner(options) {
-	Object.defineProperty(this, CLONE_SYMBOL, { value: options });
+	this[CLONE_SYMBOL] = options;
 }
-Object.defineProperties(Cloner.prototype, {
-	clone: { value: cloneFromCloner },
-	deregister: { value: deregisterCloner },
-	register: { value: registerCloner }
-});
+Cloner.prototype.clone = cloneFromCloner;
+Cloner.prototype.deregister = deregisterCloner;
+Cloner.prototype.register = registerCloner;
 function clone(value, options) {
 	return cloneAny(value, { copy: false }, 0, options);
 }
@@ -193,11 +191,5 @@ clone.deregister = deregisterCloner;
 clone.handlers = cloneHandler;
 clone.initialize = initializeCloner;
 clone.register = registerCloner;
-Object.defineProperties(clone, {
-	deregister: { value: deregisterCloner },
-	handler: { value: cloneHandler },
-	initialize: { value: initializeCloner },
-	register: { value: registerCloner }
-});
 //#endregion
 export { clone, copy, deregisterCloner, initializeCloner, registerCloner };

package/dist/value/freeze.mjs

@@ -78,9 +78,5 @@ function isFrozen(value) {
 const frozenValues = /* @__PURE__ */ new WeakSet();
 freeze.flat = flatFreeze;
 freeze.is = isFrozen;
-Object.defineProperties(freeze, {
-	flat: { value: flatFreeze },
-	is: { value: isFrozen }
-});
 //#endregion
 export { flatFreeze, freeze, isFrozen };

package/dist/value/merge.mjs

@@ -1,16 +1,16 @@
 import { isArrayOrPlainObject } from "../internal/is.mjs";
 //#region src/value/merge.ts
 function Assigner(options) {
-	Object.defineProperty(this, MERGE_SYMBOL_ASSIGN, { value: {
+	this[MERGE_SYMBOL_ASSIGN] = {
 		...options,
 		assignValues: true
-	} });
+	};
 }
-Object.defineProperties(Assigner.prototype, { assign: { value: assignFromAssigner } });
+Assigner.prototype.assign = assignFromAssigner;
 function Merger(options) {
-	Object.defineProperty(this, MERGE_SYMBOL_MERGE, { value: options });
+	this[MERGE_SYMBOL_MERGE] = options;
 }
-Object.defineProperties(Merger.prototype, { merge: { value: mergeFromMerger } });
+Merger.prototype.merge = mergeFromMerger;
 /**
 * Assign values from one or more objects to the first one
 *
@@ -114,7 +114,5 @@ const MERGE_SYMBOL_ASSIGN = Symbol("assign");
 const MERGE_SYMBOL_MERGE = Symbol("merge");
 assign.initialize = initializeAssigner;
 merge.initialize = initializeMerger;
-Object.defineProperty(assign, "initialize", { value: initializeAssigner });
-Object.defineProperty(merge, "initialize", { value: initializeMerger });
 //#endregion
 export { assign, initializeAssigner, initializeMerger, merge };

package/dist/value/transform.mjs

@@ -1,7 +1,7 @@
 import { isNonPlainObject } from "../internal/is.mjs";
 //#region src/value/transform.ts
 function Transformer(transformer) {
-	Object.defineProperty(this, TRANSFORM_SYMBOL, { value: transformer });
+	this[TRANSFORM_SYMBOL] = transformer;
 }
 Object.defineProperties(Transformer.prototype, { transform: { value: transformValue } });
 function getTransformHandler(input) {
@@ -39,6 +39,5 @@ function transformValue(value) {
 }
 const TRANSFORM_SYMBOL = Symbol("transform");
 transform.initialize = initializeTransformer;
-Object.defineProperty(transform, "initialize", { value: initializeTransformer });
 //#endregion
 export { initializeTransformer, transform };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.203.0",
+	"version": "0.204.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",
@@ -278,7 +278,7 @@
 		"watch": "npx vite build --watch"
 	},
 	"devDependencies": {
-		"@oxlint/plugins": "^1.82",
+		"@oxlint/plugins": "^1.83",
 		"@types/node": "^26.5",
 		"@vitest/coverage-istanbul": "^4.1",
 		"eslint": "^10.10",