@oscarpalmer/atoms 0.219.0 → 0.221.0

package/dist/string/fuzzy.mjs

@@ -3,8 +3,7 @@ import { floor } from "../internal/math/misc.mjs";
 import { max } from "../internal/math/aggregate.mjs";
 import { getString } from "../internal/string/misc.mjs";
 import { lowerCase } from "../internal/string/case.mjs";
-import { FUZZY_MESSAGE_ARRAY, FUZZY_MESSAGE_HANDLER, FUZZY_PROPERTY, FUZZY_SYMBOL } from "../models/string/string.fuzzy.model.mjs";
-import { includes } from "./match.mjs";
+import { FUZZY_BOUNDARY_SEPARATOR, FUZZY_MESSAGE_ARRAY, FUZZY_MESSAGE_HANDLER, FUZZY_PROPERTY, FUZZY_SYMBOL } from "../models/string/string.fuzzy.model.mjs";
 //#region src/string/fuzzy.ts
 function Fuzzy(state) {
 	this[FUZZY_SYMBOL] = state;
@@ -14,39 +13,76 @@ Fuzzy.prototype.search = search;
 Object.defineProperties(Fuzzy.prototype, {
 	items: {
 		enumerable: true,
-		get: getFuzzyItems,
-		set: setFuzzyItems
+		get: getItems,
+		set: setItems
 	},
 	strings: {
 		enumerable: true,
-		get: getFuzzyStrings
+		get: getStrings
 	}
 });
-function createFuzzyItems(items) {
-	return items.toSorted((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
+function compareItem(sorter) {
+	return (first, second) => sorter(first.string.original, second.string.original);
 }
-function createFuzzyOptions(input, state) {
-	const options = isPlainObject(input) ? input : {};
-	const limit = typeof input === "number" ? input : options.limit;
+function compareRanked(sorter) {
+	return (first, second) => first.rank - second.rank || first.position - second.position || sorter(first.string.original, second.string.original);
+}
+function createItems(state, items) {
+	state.items.original = items.map((item) => ({
+		data: item,
+		string: createString(state.handler(item))
+	}));
+	state.items.sorted = void 0;
+}
+function createOptions(input, state) {
+	const options = {};
+	const original = isPlainObject(input) ? input : {};
+	const limit = typeof input === "number" ? input : original.limit;
 	if (typeof limit === "number" && !Number.isNaN(limit) && limit >= 1) options.limit = floor(limit);
-	else options.limit = state?.limit;
-	options.tolerance = getTolerance(options.tolerance, state);
+	else options.limit = state?.limit ?? Number.POSITIVE_INFINITY;
+	options.tolerance = getTolerance(original.tolerance, state);
 	return options;
 }
-function createFuzzyState(items, input) {
-	const handler = getHandler(input);
-	const options = createFuzzyOptions(input);
+function createRanked(item, needle, position) {
+	let boundary = position;
+	while (boundary > -1 && !isBoundary(item.string, boundary)) boundary = item.string.lowercase.indexOf(needle, boundary + 1);
+	if (boundary === -1) return {
+		...item,
+		position,
+		rank: 2
+	};
 	return {
+		...item,
+		position: boundary,
+		rank: boundary === 0 ? 0 : 1
+	};
+}
+function createState(items, input) {
+	const handler = getHandler(input);
+	const options = createOptions(input);
+	const sorter = getComparator(input);
+	const state = {
+		compare: {
+			item: compareItem(sorter),
+			ranked: compareRanked(sorter)
+		},
 		handler,
-		items: items.slice(),
+		items: { original: [] },
 		limit: options.limit,
-		strings: items.map(handler),
 		tolerance: options.tolerance
 	};
+	createItems(state, items);
+	return state;
+}
+function createString(original) {
+	return {
+		original,
+		lowercase: lowerCase(original)
+	};
 }
 function fuzzy(items, configuration) {
 	if (!Array.isArray(items)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
-	return new Fuzzy(createFuzzyState(items, configuration));
+	return new Fuzzy(createState(items, configuration));
 }
 /**
 * Does the needle match the haystack in a fuzzy way?
@@ -60,53 +96,117 @@ function fuzzy(items, configuration) {
 function fuzzyMatch(haystack, needle) {
 	if (typeof haystack !== "string" || typeof needle !== "string") return false;
 	const trimmed = needle.trim();
-	if (includes(haystack, trimmed, true)) return true;
-	return getScore(haystack, trimmed) > -1;
+	const lowercaseHaystack = lowerCase(haystack);
+	const lowercaseNeedle = lowerCase(trimmed);
+	if (lowercaseHaystack.includes(lowercaseNeedle)) return true;
+	return getScore({
+		lowercase: lowercaseHaystack,
+		original: haystack
+	}, lowercaseNeedle) > -1;
+}
+function getComparator(input) {
+	if (isPlainObject(input) && typeof input.compare === "function") return input.compare;
+	defaultSorter ??= Intl.Collator().compare;
+	return defaultSorter;
 }
 function getHandler(input) {
 	if (input == null || input === getString) return getString;
 	switch (typeof input) {
-		case "function": return input;
-		case "string": return (item) => item[input];
+		case "function": return (item) => getString(input(item));
+		case "number":
+		case "string":
+		case "symbol": return (item) => getString(item?.[input]);
 		default:
 			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
 			throw new TypeError(FUZZY_MESSAGE_HANDLER);
 	}
 }
-function getFuzzyItems() {
-	return this[FUZZY_SYMBOL].items.slice();
-}
-function getFuzzyStrings() {
-	return this[FUZZY_SYMBOL].strings.slice();
+function getItems() {
+	return this[FUZZY_SYMBOL].items.original.map((item) => item.data);
 }
-function getScore(haystack, needle) {
-	if (!isSubsequence(haystack, needle)) return -1;
-	const lowerCaseHaystack = lowerCase(haystack);
-	const lowerCaseNeedle = lowerCase(needle);
-	const needleLength = lowerCaseNeedle.length;
+function getMatchEnd(haystack, needle, cursor) {
+	const haystackLength = haystack.length;
+	const needleLength = needle.length;
 	let needleIndex = 0;
-	let previousMatchIndex = -1;
-	let score = 0;
-	for (let haystackIndex = 0; haystackIndex < lowerCaseHaystack.length; haystackIndex += 1) {
-		if (lowerCaseHaystack[haystackIndex] === lowerCaseNeedle[needleIndex]) {
-			score += 1;
-			if (haystackIndex === 0) score += 1;
-			if (previousMatchIndex !== -1) {
-				const gap = haystackIndex - previousMatchIndex - 1;
-				score += max([0, 5 - gap]);
+	for (let index = cursor; index < haystackLength; index += 1) if (haystack[index] === needle[needleIndex]) {
+		needleIndex += 1;
+		if (needleIndex === needleLength) return index;
+	}
+	return -1;
+}
+function getResult(state, exact, included, scored, options) {
+	const result = {
+		exact: [],
+		included: [],
+		similar: []
+	};
+	exact.sort(state.compare.item);
+	result.exact = exact.slice(0, options.limit).map((item) => item.data);
+	included.sort(state.compare.ranked);
+	result.included = included.slice(0, options.limit - result.exact.length).map((item) => item.data);
+	const remaining = options.limit - result.exact.length - result.included.length;
+	if (remaining === 0) return result;
+	const keys = Object.keys(scored).map(Number).sort((first, second) => second - first);
+	const keysLength = keys.length;
+	if (keysLength === 0) return result;
+	const maxScore = keys[0];
+	outer: for (let index = 0; index < keysLength; index += 1) {
+		const key = keys[index];
+		if (maxScore - key > options.tolerance) break;
+		const keyed = scored[key];
+		const keyedLength = keyed.length;
+		keyed.sort(state.compare.item);
+		for (let keyedIndex = 0; keyedIndex < keyedLength; keyedIndex += 1) {
+			result.similar.push(keyed[keyedIndex].data);
+			if (result.similar.length >= remaining) break outer;
+		}
+	}
+	return result;
+}
+function getScore(item, needle) {
+	const haystackLength = item.lowercase.length;
+	const needleLength = needle.length;
+	if (needleLength > haystackLength) return -1;
+	let best = -1;
+	let cursor = 0;
+	while (cursor < haystackLength) {
+		const end = getMatchEnd(item.lowercase, needle, cursor);
+		if (end === -1) break;
+		let index = end;
+		let needleIndex = needleLength - 1;
+		let next = -1;
+		let score = 0;
+		let start = end;
+		while (needleIndex >= 0) {
+			if (item.lowercase[index] === needle[needleIndex]) {
+				score += 1;
+				if (next !== -1) score += max([0, 5 - (next - index - 1)]);
+				if (isBoundary(item, index)) score += 2;
+				next = index;
+				start = index;
+				needleIndex -= 1;
 			}
-			previousMatchIndex = haystackIndex;
-			needleIndex += 1;
+			index -= 1;
 		}
-		if (needleIndex === needleLength) break;
+		if (start === 0) score += 1;
+		if (score > best) best = score;
+		cursor = start + 1;
 	}
-	score -= floor(lowerCaseHaystack.length / 3);
-	return max([0, score]);
+	if (best === -1) return -1;
+	return max([0, best - floor(haystackLength / 3)]);
+}
+function getStrings() {
+	return this[FUZZY_SYMBOL].items.original.map((item) => item.string.original);
 }
 function getTolerance(input, state) {
 	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : floor(input);
 	return state?.tolerance ?? 5;
 }
+function isBoundary(string, index) {
+	if (index === 0 || FUZZY_BOUNDARY_SEPARATOR.test(string.lowercase[index - 1])) return true;
+	if (string.original.length !== string.lowercase.length) return false;
+	return string.original[index] !== string.lowercase[index] && string.original[index - 1] === string.lowercase[index - 1];
+}
 /**
 * Is the value a fuzzy searcher?
 *
@@ -118,74 +218,48 @@ function getTolerance(input, state) {
 function isFuzzy(value) {
 	return typeof value === "object" && value !== null && "$fuzzy" in value && value["$fuzzy"] === true;
 }
-function isSubsequence(haystack, needle) {
-	const lowerCaseHaystack = lowerCase(haystack);
-	const lowerCaseNeedle = lowerCase(needle);
-	const haystackLength = lowerCaseHaystack.length;
-	const needleLength = lowerCaseNeedle.length;
-	let needleIndex = 0;
-	for (let haystackIndex = 0; haystackIndex < haystackLength; haystackIndex += 1) {
-		if (lowerCaseHaystack[haystackIndex] === lowerCaseNeedle[needleIndex]) needleIndex += 1;
-		if (needleIndex === needleLength) return true;
-	}
-	return false;
-}
 function search(input, option) {
 	const state = this[FUZZY_SYMBOL];
-	const options = option == null ? state : createFuzzyOptions(option, state);
-	const result = {
-		exact: [],
-		similar: []
-	};
+	const options = option == null ? state : createOptions(option, state);
 	const value = typeof input === "string" ? input.trim() : "";
+	const lowercaseValue = lowerCase(value);
 	if (value.length === 0) {
-		result.exact = state.items.slice(0, options.limit);
-		return result;
+		state.items.sorted ??= state.items.original.toSorted(state.compare.item);
+		return {
+			exact: state.items.sorted.slice(0, options.limit).map((item) => item.data),
+			included: [],
+			similar: []
+		};
 	}
-	let { length } = state.items;
 	const exact = [];
-	const similar = [];
+	const included = [];
 	const scored = {};
+	const { length } = state.items.original;
 	for (let index = 0; index < length; index += 1) {
-		const item = state.items[index];
-		const haystack = state.strings[index];
-		if (includes(haystack, value, true)) {
-			exact.push({
-				item,
-				haystack
-			});
+		const item = state.items.original[index];
+		const { string } = item;
+		if (string.lowercase === lowercaseValue) {
+			exact.push(item);
 			continue;
 		}
-		const score = getScore(haystack, value);
+		const position = string.lowercase.indexOf(lowercaseValue);
+		if (position > -1) {
+			included.push(createRanked(item, lowercaseValue, position));
+			continue;
+		}
+		const score = getScore(string, lowercaseValue);
 		if (score > -1) {
 			scored[score] ??= [];
-			scored[score].push({
-				item,
-				haystack
-			});
+			scored[score].push(item);
 		}
 	}
-	const keys = Object.keys(scored).map(Number).sort((first, second) => second - first);
-	length = keys.length;
-	if (length > 0 && options.tolerance > 0) {
-		const maxScore = keys[0];
-		for (let index = 0; index < length; index += 1) {
-			const key = keys[index];
-			if (maxScore - key > options.tolerance) break;
-			similar.push(...createFuzzyItems(scored[key]));
-		}
-	}
-	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;
+	return getResult(state, exact, included, scored, options);
 }
-function setFuzzyItems(value) {
+function setItems(value) {
 	if (!Array.isArray(value)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
-	const state = this[FUZZY_SYMBOL];
-	state.items = value.slice();
-	state.strings = value.map((item) => state.handler(item));
+	createItems(this[FUZZY_SYMBOL], value);
 }
+let defaultSorter;
 fuzzy.is = isFuzzy;
 fuzzy.match = fuzzyMatch;
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.219.0",
+	"version": "0.221.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",