@oscarpalmer/atoms 0.193.1 → 0.194.0

package/dist/string/fuzzy.mjs

@@ -10,10 +10,10 @@ function getHandler(input) {
 		case "string": return (item) => item[input];
 		default:
 			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
-			throw new TypeError(MESSAGE_HANDLER);
+			throw new TypeError(FUZZY_MESSAGE_HANDLER);
 	}
 }
-function getItems(items) {
+function getFuzzyItems(items) {
 	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
 }
 function getFuzzyOptions(input, state) {
@@ -37,22 +37,22 @@ function getFuzzyState(items, input) {
 }
 function getTolerance(input, state) {
 	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
-	return state?.tolerance ?? PROXIMITY_THRESHOLD;
+	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
 }
 function fuzzy(items, configuration) {
-	if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
+	if (!Array.isArray(items)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
 	const state = getFuzzyState(items, configuration);
 	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : getFuzzyOptions(options, state)) };
 	Object.defineProperties(instance, {
 		items: {
+			enumerable: true,
 			get: () => state.items.slice(),
-			set: (items) => {
-				if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
-				state.items = items.slice();
-				state.strings = items.map(state.handler);
-			}
+			set: (value) => setItems(state, value)
 		},
-		strings: { get: () => state.strings.slice() }
+		strings: {
+			enumerable: true,
+			get: () => state.strings.slice()
+		}
 	});
 	return Object.freeze(instance);
 }
@@ -96,14 +96,14 @@ function getScore(haystack, needle) {
 			if (haystackIndex === 0) score += 1;
 			if (previousMatchIndex !== -1) {
 				const gap = haystackIndex - previousMatchIndex - 1;
-				score += Math.max(0, PROXIMITY_THRESHOLD - gap);
+				score += Math.max(0, FUZZY_PROXIMITY_THRESHOLD - gap);
 			}
 			previousMatchIndex = haystackIndex;
 			needleIndex += 1;
 		}
 		if (needleIndex === needleLength) break;
 	}
-	score -= Math.floor(lowerCaseHaystack.length / LENGTH_DIVISOR);
+	score -= Math.floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
 	return Math.max(0, score);
 }
 function search(items, strings, input, options) {
@@ -146,17 +146,22 @@ function search(items, strings, input, options) {
 		for (let index = 0; index < length; index += 1) {
 			const key = keys[index];
 			if (maxScore - key > options.tolerance) break;
-			similar.push(...getItems(scored[key]));
+			similar.push(...getFuzzyItems(scored[key]));
 		}
 	}
-	result.exact = getItems(options.limit == null ? exact : exact.slice(0, options.limit));
+	result.exact = getFuzzyItems(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;
 }
-const LENGTH_DIVISOR = 3;
-const MESSAGE_ARRAY = "Fuzzy requires an array of items";
-const MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
-const PROXIMITY_THRESHOLD = 5;
+function setItems(state, value) {
+	if (!Array.isArray(value)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
+	state.items = value.slice();
+	state.strings = value.map(state.handler);
+}
+const FUZZY_LENGTH_DIVISOR = 3;
+const FUZZY_MESSAGE_ARRAY = "Fuzzy requires an array of items";
+const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
+const FUZZY_PROXIMITY_THRESHOLD = 5;
 //#endregion
 export { fuzzy, fuzzyMatch };

package/dist/string/index.mjs

@@ -37,16 +37,16 @@ function getUuid(html) {
 		crypto.getRandomValues(bytes);
 		bytes[6] = bytes[6] & 15 | 64;
 		bytes[8] = bytes[8] & 63 | 128;
-		const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, ZERO)).join("");
+		const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, STRING_ZERO)).join("");
 		const first = hex.substring(0, 8);
-		if (forHTML && NUMERICAL_PREFIX_PATTERN.test(first)) continue;
+		if (forHTML && STRING_NUMERICAL_PREFIX_PATTERN.test(first)) continue;
 		return [
 			first,
 			hex.substring(8, 12),
 			hex.substring(12, 16),
 			hex.substring(16, 20),
 			hex.substring(20, 32)
-		].join(forHTML ? DELIMITER_UUID_HTML : DELIMITER_UUID_DEFAULT);
+		].join(forHTML ? STRING_DELIMITER_UUID_HTML : STRING_DELIMITER_UUID_DEFAULT);
 	}
 }
 /**
@@ -89,9 +89,9 @@ function truncate(value, length, suffix) {
 	const truncatedLength = length - actualSuffixLength;
 	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
 }
-const DELIMITER_UUID_DEFAULT = "-";
-const DELIMITER_UUID_HTML = "_";
-const NUMERICAL_PREFIX_PATTERN = /^\d/;
-const ZERO = "0";
+const STRING_DELIMITER_UUID_DEFAULT = "-";
+const STRING_DELIMITER_UUID_HTML = "_";
+const STRING_NUMERICAL_PREFIX_PATTERN = /^\d/;
+const STRING_ZERO = "0";
 //#endregion
 export { dedent, getString, getUuid, join, parse, trim, truncate, words };

package/dist/string/normalize.mjs

@@ -11,8 +11,8 @@ import { lowerCase } from "./case.mjs";
 function deburr(value) {
 	if (typeof value !== "string") return "";
 	deburrMemoizer ??= memoize((value) => {
-		let deburred = value.normalize(DEBURR_NORMALIZATION).replace(DEBURR_PATTERN_SIMPLE, "");
-		deburred = deburred.replace(DEBURR_PATTERN_CHARACTERS, (_, character) => DEBURR_CHARACTERS[character]);
+		let deburred = value.normalize(NORMALIZE_DEBURR_NORMALIZATION).replace(NORMALIZE_DEBURR_PATTERN_SIMPLE, "");
+		deburred = deburred.replace(NORMALIZE_DEBURR_PATTERN_CHARACTERS, (_, character) => NORMALIZE_DEBURR_CHARACTERS[character]);
 		return deburred;
 	});
 	return deburrMemoizer.run(value);
@@ -56,13 +56,13 @@ function normalizeString(value, options) {
 	if (typeof value !== "string") return "";
 	let result = value;
 	if (options.trim) result = result.trim();
-	if (options.whitespace) result = result.replace(WHITESPACE_PATTERN, WHITESPACE_REPLACEMENT);
+	if (options.whitespace) result = result.replace(NORMALIZE_WHITESPACE_PATTERN, NORMALIZE_WHITESPACE_REPLACEMENT);
 	if (options.deburr) result = deburr(result);
 	if (options.lowerCase) result = lowerCase(result);
-	if (options.special) result = result.replace(SPECIAL_PATTERN, SPECIAL_REPLACEMENT);
-	return result.normalize(NORMALIZATION_NORMALIZATION);
+	if (options.special) result = result.replace(NORMALIZE_SPECIAL_PATTERN, NORMALIZE_SPECIAL_REPLACEMENT);
+	return result.normalize(NORMALIZE_NORMALIZATION_NORMALIZATION);
 }
-const DEBURR_CHARACTERS = {
+const NORMALIZE_DEBURR_CHARACTERS = {
 	Æ: "AE",
 	æ: "ae",
 	Ð: "D",
@@ -94,14 +94,14 @@ const DEBURR_CHARACTERS = {
 	Ŧ: "T",
 	ŧ: "t"
 };
-const DEBURR_NORMALIZATION = "NFD";
-const DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(DEBURR_CHARACTERS).join("|")})`, "g");
-const DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
-const NORMALIZATION_NORMALIZATION = "NFC";
-const SPECIAL_PATTERN = /[\p{P}\p{S}]/gu;
-const SPECIAL_REPLACEMENT = "";
-const WHITESPACE_PATTERN = /\s+/g;
-const WHITESPACE_REPLACEMENT = " ";
+const NORMALIZE_DEBURR_NORMALIZATION = "NFD";
+const NORMALIZE_DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(NORMALIZE_DEBURR_CHARACTERS).join("|")})`, "g");
+const NORMALIZE_DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
+const NORMALIZE_NORMALIZATION_NORMALIZATION = "NFC";
+const NORMALIZE_SPECIAL_PATTERN = /[\p{P}\p{S}]/gu;
+const NORMALIZE_SPECIAL_REPLACEMENT = "";
+const NORMALIZE_WHITESPACE_PATTERN = /\s+/g;
+const NORMALIZE_WHITESPACE_REPLACEMENT = " ";
 let deburrMemoizer;
 //#endregion
 export { deburr, initializeNormalizer, normalize };

package/dist/string/template.mjs

@@ -11,7 +11,7 @@ function getTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
 		ignoreCase: options.ignoreCase === true,
-		pattern: options.pattern instanceof RegExp ? options.pattern : EXPRESSION_VARIABLE
+		pattern: options.pattern instanceof RegExp ? options.pattern : TEMPLATE_EXPRESSION_VARIABLE
 	};
 }
 function handleTemplate(value, pattern, ignoreCase, variables) {
@@ -46,6 +46,6 @@ function template(value, ...parameters) {
 	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
 template.initialize = initializeTemplater;
-const EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
+const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
 //#endregion
 export { initializeTemplater, template };

package/dist/value/clone.mjs

@@ -12,21 +12,21 @@ clone.handlers = getSelfHandlers(clone, {
 clone.deregister = deregisterCloner;
 clone.register = registerCloner;
 function cloneArrayBuffer(value, depth, references) {
-	if (typeof depth === "number" && depth >= MAX_CLONE_DEPTH) return value;
+	if (typeof depth === "number" && depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new ArrayBuffer(value.byteLength);
 	new Uint8Array(cloned).set(new Uint8Array(value));
 	references?.set(value, cloned);
 	return cloned;
 }
 function cloneDataView(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const buffer = cloneArrayBuffer(value.buffer);
 	const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
 	references.set(value, cloned);
 	return cloned;
 }
 function cloneMap(map, depth, references, flat) {
-	if (depth >= MAX_CLONE_DEPTH) return map;
+	if (depth >= CLONE_MAX_DEPTH) return map;
 	const cloned = /* @__PURE__ */ new Map();
 	const entries = map.entries();
 	for (const entry of entries) cloned.set(flat ? entry[0] : cloneValue(entry[0], depth + 1, references, false), flat ? entry[1] : cloneValue(entry[1], depth + 1, references, false));
@@ -34,13 +34,13 @@ function cloneMap(map, depth, references, flat) {
 	return cloned;
 }
 function cloneNode(node, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return node;
+	if (depth >= CLONE_MAX_DEPTH) return node;
 	const cloned = node.cloneNode(true);
 	references.set(node, cloned);
 	return cloned;
 }
 function cloneObject(value, depth, references, flat) {
-	if (flat || depth >= MAX_CLONE_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
+	if (flat || depth >= CLONE_MAX_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
 	const cloned = Array.isArray(value) ? [] : {};
 	const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
 	const { length } = keys;
@@ -52,14 +52,14 @@ function cloneObject(value, depth, references, flat) {
 	return cloned;
 }
 function cloneRegularExpression(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new RegExp(value.source, value.flags);
 	cloned.lastIndex = value.lastIndex;
 	references.set(value, cloned);
 	return cloned;
 }
 function cloneSet(set, depth, references, flat) {
-	if (depth >= MAX_CLONE_DEPTH) return set;
+	if (depth >= CLONE_MAX_DEPTH) return set;
 	const cloned = /* @__PURE__ */ new Set();
 	const values = [...set.values()];
 	const { length } = values;
@@ -68,7 +68,7 @@ function cloneSet(set, depth, references, flat) {
 	return cloned;
 }
 function cloneTypedArray(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new value.constructor(value);
 	references.set(value, cloned);
 	return cloned;
@@ -129,7 +129,7 @@ function registerCloner(constructor, handler) {
 	clone.handlers.register(constructor, handler);
 }
 function tryStructuredClone(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	try {
 		const cloned = structuredClone(value);
 		references.set(value, cloned);
@@ -139,6 +139,6 @@ function tryStructuredClone(value, depth, references) {
 		return value;
 	}
 }
-const MAX_CLONE_DEPTH = 100;
+const CLONE_MAX_DEPTH = 100;
 //#endregion
 export { clone, copy, deregisterCloner, registerCloner };

package/dist/value/smush.mjs

@@ -2,7 +2,7 @@ import { isArrayOrPlainObject } from "../internal/is.mjs";
 import { join } from "../internal/string.mjs";
 //#region src/value/smush.ts
 function flattenObject(value, depth, smushed, prefix) {
-	if (depth >= MAX_DEPTH) return {};
+	if (depth >= SMUSH_MAX_DEPTH) return {};
 	if (smushed.has(value)) return smushed.get(value);
 	const keys = Object.keys(value);
 	const { length } = keys;
@@ -34,6 +34,6 @@ function flattenObject(value, depth, smushed, prefix) {
 function smush(value) {
 	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
 }
-const MAX_DEPTH = 100;
+const SMUSH_MAX_DEPTH = 100;
 //#endregion
 export { smush };

package/package.json

@@ -1,9 +1,18 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.193.1",
+	"version": "0.194.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
+		"array",
+		"color",
 		"helper",
+		"observable",
+		"promise",
+		"query",
+		"queue",
+		"random",
+		"result",
+		"subscription",
 		"utility"
 	],
 	"license": "MIT",
@@ -256,8 +265,8 @@
 		"watch": "npx vite build --watch"
 	},
 	"devDependencies": {
-		"@oxlint/plugins": "^1.79",
-		"@types/node": "^26.2",
+		"@oxlint/plugins": "^1.80",
+		"@types/node": "^26.4",
 		"@vitest/coverage-istanbul": "^4.1",
 		"eslint": "^10.9",
 		"jsdom": "^30",
@@ -268,4 +277,4 @@
 		"vitest": "npm:@voidzero-dev/vite-plus-test@latest"
 	},
 	"packageManager": "npm@11.11.1"
-}
+}