@envive-ai/react-hooks 0.2.6 → 0.2.7-arthur-1

package/dist/hooks/Search/index.js

@@ -1,44 +1,1428 @@
-import "../../types-D3uOF0Oy.js";
+import "../../types-CtUb63bt.js";
 import "../../events-DyUix-Bn.js";
 import { SearchResultsState, getSearchResultsState } from "../../utils-D_kATUj6.js";
-import { logger_default } from "../../logger-Co0IA3k5.js";
-import { SpiffyWidgets } from "../../models-UHOY0ak5.js";
-import "../../featureGates-D4Me_IZH.js";
-import "../../urlsParser-DLCzibqU.js";
-import "../../graphql-OkhsP4ir.js";
-import "../../utils-C4ci_t0-.js";
-import "../../api-bHEYmSiT.js";
+import { SpiffyWidgets } from "../../models-CWOgrLCm.js";
+import { FeatureGates } from "../../featureGates-KEwAL8p_.js";
+import "../../urlsParser-DxjoLj98.js";
+import "../../graphql-CkxgqsXP.js";
+import "../../utils-DIvMgPe8.js";
+import "../../api-BWSsazAG.js";
+import "../../logger-W3lqg-4b.js";
 import "../../utilityTypes-B2KuRn37.js";
 import "../../variantInfo-BfKlkaWU.js";
-import "../../localStorageContext-DAOJ4be4.js";
-import { orgShortNameAtom } from "../../enviveConfig-BlIkxiAF.js";
+import "../../localStorageContext-BPZ82q-G.js";
+import { orgShortNameAtom } from "../../enviveConfig-DZBohDpc.js";
 import "../../orgAnalyticsConfig-CpBmga08.js";
 import "../../atomStore-DEcDhiLp.js";
-import "../../app-Aqkm_SlS.js";
-import "../../enviveConfigContext-1_EivtCa.js";
-import "../../featureFlagServiceContext-CAPrb4e_.js";
-import { SpiffyMetricsEventName, useAmplitude } from "../../amplitudeContext-DOqL2Vn8.js";
-import "../../chatState-BXBN-12W.js";
+import "../../app-CflxT_xI.js";
+import "../../enviveConfigContext-DrDjCems.js";
+import { useFeatureFlagService } from "../../featureFlagServiceContext-FBM6DdMJ.js";
+import { SpiffyMetricsEventName, useAmplitude } from "../../amplitudeContext-DCk6Va-j.js";
+import "../../chatState-CXA1vF16.js";
 import "../../graphqlConfig-CZGjJ8hP.js";
-import "../../chat-U1IgKNij.js";
+import { amplitudeTrackEventAtom } from "../../chat-BjhQCyW_.js";
 import { autocompleteStateAtom, isFilterOpenAtom } from "../../globalSearch-BQEX-2Ml.js";
 import "../../org-h32_LSEb.js";
 import "../../newOrgConfigAtom-DEUj6H-p.js";
 import { formatFilterDisplayName } from "../../utils-D82gfbgU.js";
-import "../../chatSearch-Bb2SMr9X.js";
+import "../../chatSearch-BsYlFvpv.js";
 import { ProductSorting } from "../../types-DXnG1tV0.js";
 import "../../searchServiceAdapter-Db6jEcJs.js";
-import { addSearchFilterAtom, clearSearchFiltersAtom, createFilterOption, filteredSearchProductsAtom, performSearchAtom, removeSearchFilterAtom, searchAtom, searchFiltersAtom, searchParamsAtom, searchProductSortingAtom, searchSelectedFiltersAtom } from "../../search-yawhMv22.js";
-import "../../graphqlContext-dyWNSWNv.js";
-import "../../useGraphQLConfig-BccQUaeW.js";
-import "../../newOrgConfigContext-6mlrvr1w.js";
-import { useNewOrgConfig } from "../../NewOrgConfig-BfrGpiGk.js";
-import { useDebounce } from "../../useDebounce-ueblXZI-.js";
+import { addSearchFilterAtom, clearSearchFiltersAtom, createFilterOption, filteredSearchProductsAtom, performSearchAtom, removeSearchFilterAtom, searchAtom, searchFiltersAtom, searchParamsAtom, searchProductSortingAtom, searchSelectedFiltersAtom } from "../../search-DkiqkogN.js";
+import "../../amplitudeContext-BItT9HmT.js";
+import "../../graphqlContext-czH0kIZg.js";
+import "../../useGraphQLConfig-7UxACM4n.js";
+import "../../newOrgConfigContext-Bi_dBNe5.js";
+import { useNewOrgConfig } from "../../NewOrgConfig-yptI2imS.js";
 import "../../useIntersection-CZSEBUbv.js";
-import { useTrackComponentVisibleEvent } from "../../TrackComponentVisibleEvent-DwfGqNTx.js";
+import { useTrackComponentVisibleEvent } from "../../TrackComponentVisibleEvent-CXhKOwKQ.js";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { useAtom, useAtomValue, useSetAtom } from "jotai";
+import { atom, useAtom, useAtomValue, useSetAtom } from "jotai";
 
+//#region node_modules/fuse.js/dist/fuse.mjs
+/**
+* Fuse.js v7.1.0 - Lightweight fuzzy-search (http://fusejs.io)
+*
+* Copyright (c) 2025 Kiro Risk (http://kiro.me)
+* All Rights Reserved. Apache Software License 2.0
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*/
+function isArray(value) {
+	return !Array.isArray ? getTag(value) === "[object Array]" : Array.isArray(value);
+}
+const INFINITY = Infinity;
+function baseToString(value) {
+	if (typeof value == "string") return value;
+	let result = value + "";
+	return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+function toString(value) {
+	return value == null ? "" : baseToString(value);
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function isNumber(value) {
+	return typeof value === "number";
+}
+function isBoolean(value) {
+	return value === true || value === false || isObjectLike(value) && getTag(value) == "[object Boolean]";
+}
+function isObject(value) {
+	return typeof value === "object";
+}
+function isObjectLike(value) {
+	return isObject(value) && value !== null;
+}
+function isDefined(value) {
+	return value !== void 0 && value !== null;
+}
+function isBlank(value) {
+	return !value.trim().length;
+}
+function getTag(value) {
+	return value == null ? value === void 0 ? "[object Undefined]" : "[object Null]" : Object.prototype.toString.call(value);
+}
+const INCORRECT_INDEX_TYPE = "Incorrect 'index' type";
+const LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) => `Invalid value for key ${key}`;
+const PATTERN_LENGTH_TOO_LARGE = (max) => `Pattern length exceeds max of ${max}.`;
+const MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;
+const INVALID_KEY_WEIGHT_VALUE = (key) => `Property 'weight' in key '${key}' must be a positive integer`;
+const hasOwn = Object.prototype.hasOwnProperty;
+var KeyStore = class {
+	constructor(keys) {
+		this._keys = [];
+		this._keyMap = {};
+		let totalWeight = 0;
+		keys.forEach((key) => {
+			let obj = createKey(key);
+			this._keys.push(obj);
+			this._keyMap[obj.id] = obj;
+			totalWeight += obj.weight;
+		});
+		this._keys.forEach((key) => {
+			key.weight /= totalWeight;
+		});
+	}
+	get(keyId) {
+		return this._keyMap[keyId];
+	}
+	keys() {
+		return this._keys;
+	}
+	toJSON() {
+		return JSON.stringify(this._keys);
+	}
+};
+function createKey(key) {
+	let path = null;
+	let id = null;
+	let src = null;
+	let weight = 1;
+	let getFn = null;
+	if (isString(key) || isArray(key)) {
+		src = key;
+		path = createKeyPath(key);
+		id = createKeyId(key);
+	} else {
+		if (!hasOwn.call(key, "name")) throw new Error(MISSING_KEY_PROPERTY("name"));
+		const name = key.name;
+		src = name;
+		if (hasOwn.call(key, "weight")) {
+			weight = key.weight;
+			if (weight <= 0) throw new Error(INVALID_KEY_WEIGHT_VALUE(name));
+		}
+		path = createKeyPath(name);
+		id = createKeyId(name);
+		getFn = key.getFn;
+	}
+	return {
+		path,
+		id,
+		weight,
+		src,
+		getFn
+	};
+}
+function createKeyPath(key) {
+	return isArray(key) ? key : key.split(".");
+}
+function createKeyId(key) {
+	return isArray(key) ? key.join(".") : key;
+}
+function get(obj, path) {
+	let list = [];
+	let arr = false;
+	const deepGet = (obj$1, path$1, index) => {
+		if (!isDefined(obj$1)) return;
+		if (!path$1[index]) list.push(obj$1);
+		else {
+			let key = path$1[index];
+			const value = obj$1[key];
+			if (!isDefined(value)) return;
+			if (index === path$1.length - 1 && (isString(value) || isNumber(value) || isBoolean(value))) list.push(toString(value));
+			else if (isArray(value)) {
+				arr = true;
+				for (let i = 0, len = value.length; i < len; i += 1) deepGet(value[i], path$1, index + 1);
+			} else if (path$1.length) deepGet(value, path$1, index + 1);
+		}
+	};
+	deepGet(obj, isString(path) ? path.split(".") : path, 0);
+	return arr ? list : list[0];
+}
+const MatchOptions = {
+	includeMatches: false,
+	findAllMatches: false,
+	minMatchCharLength: 1
+};
+const BasicOptions = {
+	isCaseSensitive: false,
+	ignoreDiacritics: false,
+	includeScore: false,
+	keys: [],
+	shouldSort: true,
+	sortFn: (a, b) => a.score === b.score ? a.idx < b.idx ? -1 : 1 : a.score < b.score ? -1 : 1
+};
+const FuzzyOptions = {
+	location: 0,
+	threshold: .6,
+	distance: 100
+};
+const AdvancedOptions = {
+	useExtendedSearch: false,
+	getFn: get,
+	ignoreLocation: false,
+	ignoreFieldNorm: false,
+	fieldNormWeight: 1
+};
+var Config = {
+	...BasicOptions,
+	...MatchOptions,
+	...FuzzyOptions,
+	...AdvancedOptions
+};
+const SPACE = /[^ ]+/g;
+function norm(weight = 1, mantissa = 3) {
+	const cache = /* @__PURE__ */ new Map();
+	const m = Math.pow(10, mantissa);
+	return {
+		get(value) {
+			const numTokens = value.match(SPACE).length;
+			if (cache.has(numTokens)) return cache.get(numTokens);
+			const norm$1 = 1 / Math.pow(numTokens, .5 * weight);
+			const n = parseFloat(Math.round(norm$1 * m) / m);
+			cache.set(numTokens, n);
+			return n;
+		},
+		clear() {
+			cache.clear();
+		}
+	};
+}
+var FuseIndex = class {
+	constructor({ getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
+		this.norm = norm(fieldNormWeight, 3);
+		this.getFn = getFn;
+		this.isCreated = false;
+		this.setIndexRecords();
+	}
+	setSources(docs = []) {
+		this.docs = docs;
+	}
+	setIndexRecords(records = []) {
+		this.records = records;
+	}
+	setKeys(keys = []) {
+		this.keys = keys;
+		this._keysMap = {};
+		keys.forEach((key, idx) => {
+			this._keysMap[key.id] = idx;
+		});
+	}
+	create() {
+		if (this.isCreated || !this.docs.length) return;
+		this.isCreated = true;
+		if (isString(this.docs[0])) this.docs.forEach((doc, docIndex) => {
+			this._addString(doc, docIndex);
+		});
+		else this.docs.forEach((doc, docIndex) => {
+			this._addObject(doc, docIndex);
+		});
+		this.norm.clear();
+	}
+	add(doc) {
+		const idx = this.size();
+		if (isString(doc)) this._addString(doc, idx);
+		else this._addObject(doc, idx);
+	}
+	removeAt(idx) {
+		this.records.splice(idx, 1);
+		for (let i = idx, len = this.size(); i < len; i += 1) this.records[i].i -= 1;
+	}
+	getValueForItemAtKeyId(item, keyId) {
+		return item[this._keysMap[keyId]];
+	}
+	size() {
+		return this.records.length;
+	}
+	_addString(doc, docIndex) {
+		if (!isDefined(doc) || isBlank(doc)) return;
+		let record = {
+			v: doc,
+			i: docIndex,
+			n: this.norm.get(doc)
+		};
+		this.records.push(record);
+	}
+	_addObject(doc, docIndex) {
+		let record = {
+			i: docIndex,
+			$: {}
+		};
+		this.keys.forEach((key, keyIndex) => {
+			let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);
+			if (!isDefined(value)) return;
+			if (isArray(value)) {
+				let subRecords = [];
+				const stack = [{
+					nestedArrIndex: -1,
+					value
+				}];
+				while (stack.length) {
+					const { nestedArrIndex, value: value$1 } = stack.pop();
+					if (!isDefined(value$1)) continue;
+					if (isString(value$1) && !isBlank(value$1)) {
+						let subRecord = {
+							v: value$1,
+							i: nestedArrIndex,
+							n: this.norm.get(value$1)
+						};
+						subRecords.push(subRecord);
+					} else if (isArray(value$1)) value$1.forEach((item, k) => {
+						stack.push({
+							nestedArrIndex: k,
+							value: item
+						});
+					});
+				}
+				record.$[keyIndex] = subRecords;
+			} else if (isString(value) && !isBlank(value)) {
+				let subRecord = {
+					v: value,
+					n: this.norm.get(value)
+				};
+				record.$[keyIndex] = subRecord;
+			}
+		});
+		this.records.push(record);
+	}
+	toJSON() {
+		return {
+			keys: this.keys,
+			records: this.records
+		};
+	}
+};
+function createIndex(keys, docs, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
+	const myIndex = new FuseIndex({
+		getFn,
+		fieldNormWeight
+	});
+	myIndex.setKeys(keys.map(createKey));
+	myIndex.setSources(docs);
+	myIndex.create();
+	return myIndex;
+}
+function parseIndex(data, { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}) {
+	const { keys, records } = data;
+	const myIndex = new FuseIndex({
+		getFn,
+		fieldNormWeight
+	});
+	myIndex.setKeys(keys);
+	myIndex.setIndexRecords(records);
+	return myIndex;
+}
+function computeScore$1(pattern, { errors = 0, currentLocation = 0, expectedLocation = 0, distance = Config.distance, ignoreLocation = Config.ignoreLocation } = {}) {
+	const accuracy = errors / pattern.length;
+	if (ignoreLocation) return accuracy;
+	const proximity = Math.abs(expectedLocation - currentLocation);
+	if (!distance) return proximity ? 1 : accuracy;
+	return accuracy + proximity / distance;
+}
+function convertMaskToIndices(matchmask = [], minMatchCharLength = Config.minMatchCharLength) {
+	let indices = [];
+	let start = -1;
+	let end = -1;
+	let i = 0;
+	for (let len = matchmask.length; i < len; i += 1) {
+		let match = matchmask[i];
+		if (match && start === -1) start = i;
+		else if (!match && start !== -1) {
+			end = i - 1;
+			if (end - start + 1 >= minMatchCharLength) indices.push([start, end]);
+			start = -1;
+		}
+	}
+	if (matchmask[i - 1] && i - start >= minMatchCharLength) indices.push([start, i - 1]);
+	return indices;
+}
+const MAX_BITS = 32;
+function search(text, pattern, patternAlphabet, { location = Config.location, distance = Config.distance, threshold = Config.threshold, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, includeMatches = Config.includeMatches, ignoreLocation = Config.ignoreLocation } = {}) {
+	if (pattern.length > MAX_BITS) throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS));
+	const patternLen = pattern.length;
+	const textLen = text.length;
+	const expectedLocation = Math.max(0, Math.min(location, textLen));
+	let currentThreshold = threshold;
+	let bestLocation = expectedLocation;
+	const computeMatches = minMatchCharLength > 1 || includeMatches;
+	const matchMask = computeMatches ? Array(textLen) : [];
+	let index;
+	while ((index = text.indexOf(pattern, bestLocation)) > -1) {
+		let score = computeScore$1(pattern, {
+			currentLocation: index,
+			expectedLocation,
+			distance,
+			ignoreLocation
+		});
+		currentThreshold = Math.min(score, currentThreshold);
+		bestLocation = index + patternLen;
+		if (computeMatches) {
+			let i = 0;
+			while (i < patternLen) {
+				matchMask[index + i] = 1;
+				i += 1;
+			}
+		}
+	}
+	bestLocation = -1;
+	let lastBitArr = [];
+	let finalScore = 1;
+	let binMax = patternLen + textLen;
+	const mask = 1 << patternLen - 1;
+	for (let i = 0; i < patternLen; i += 1) {
+		let binMin = 0;
+		let binMid = binMax;
+		while (binMin < binMid) {
+			if (computeScore$1(pattern, {
+				errors: i,
+				currentLocation: expectedLocation + binMid,
+				expectedLocation,
+				distance,
+				ignoreLocation
+			}) <= currentThreshold) binMin = binMid;
+			else binMax = binMid;
+			binMid = Math.floor((binMax - binMin) / 2 + binMin);
+		}
+		binMax = binMid;
+		let start = Math.max(1, expectedLocation - binMid + 1);
+		let finish = findAllMatches ? textLen : Math.min(expectedLocation + binMid, textLen) + patternLen;
+		let bitArr = Array(finish + 2);
+		bitArr[finish + 1] = (1 << i) - 1;
+		for (let j = finish; j >= start; j -= 1) {
+			let currentLocation = j - 1;
+			let charMatch = patternAlphabet[text.charAt(currentLocation)];
+			if (computeMatches) matchMask[currentLocation] = +!!charMatch;
+			bitArr[j] = (bitArr[j + 1] << 1 | 1) & charMatch;
+			if (i) bitArr[j] |= (lastBitArr[j + 1] | lastBitArr[j]) << 1 | 1 | lastBitArr[j + 1];
+			if (bitArr[j] & mask) {
+				finalScore = computeScore$1(pattern, {
+					errors: i,
+					currentLocation,
+					expectedLocation,
+					distance,
+					ignoreLocation
+				});
+				if (finalScore <= currentThreshold) {
+					currentThreshold = finalScore;
+					bestLocation = currentLocation;
+					if (bestLocation <= expectedLocation) break;
+					start = Math.max(1, 2 * expectedLocation - bestLocation);
+				}
+			}
+		}
+		if (computeScore$1(pattern, {
+			errors: i + 1,
+			currentLocation: expectedLocation,
+			expectedLocation,
+			distance,
+			ignoreLocation
+		}) > currentThreshold) break;
+		lastBitArr = bitArr;
+	}
+	const result = {
+		isMatch: bestLocation >= 0,
+		score: Math.max(.001, finalScore)
+	};
+	if (computeMatches) {
+		const indices = convertMaskToIndices(matchMask, minMatchCharLength);
+		if (!indices.length) result.isMatch = false;
+		else if (includeMatches) result.indices = indices;
+	}
+	return result;
+}
+function createPatternAlphabet(pattern) {
+	let mask = {};
+	for (let i = 0, len = pattern.length; i < len; i += 1) {
+		const char = pattern.charAt(i);
+		mask[char] = (mask[char] || 0) | 1 << len - i - 1;
+	}
+	return mask;
+}
+const stripDiacritics = String.prototype.normalize ? ((str) => str.normalize("NFD").replace(/[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08D3-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ABE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DF9\u1DFB-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]/g, "")) : ((str) => str);
+var BitapSearch = class {
+	constructor(pattern, { location = Config.location, threshold = Config.threshold, distance = Config.distance, includeMatches = Config.includeMatches, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, isCaseSensitive = Config.isCaseSensitive, ignoreDiacritics = Config.ignoreDiacritics, ignoreLocation = Config.ignoreLocation } = {}) {
+		this.options = {
+			location,
+			threshold,
+			distance,
+			includeMatches,
+			findAllMatches,
+			minMatchCharLength,
+			isCaseSensitive,
+			ignoreDiacritics,
+			ignoreLocation
+		};
+		pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
+		pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
+		this.pattern = pattern;
+		this.chunks = [];
+		if (!this.pattern.length) return;
+		const addChunk = (pattern$1, startIndex) => {
+			this.chunks.push({
+				pattern: pattern$1,
+				alphabet: createPatternAlphabet(pattern$1),
+				startIndex
+			});
+		};
+		const len = this.pattern.length;
+		if (len > MAX_BITS) {
+			let i = 0;
+			const remainder = len % MAX_BITS;
+			const end = len - remainder;
+			while (i < end) {
+				addChunk(this.pattern.substr(i, MAX_BITS), i);
+				i += MAX_BITS;
+			}
+			if (remainder) {
+				const startIndex = len - MAX_BITS;
+				addChunk(this.pattern.substr(startIndex), startIndex);
+			}
+		} else addChunk(this.pattern, 0);
+	}
+	searchIn(text) {
+		const { isCaseSensitive, ignoreDiacritics, includeMatches } = this.options;
+		text = isCaseSensitive ? text : text.toLowerCase();
+		text = ignoreDiacritics ? stripDiacritics(text) : text;
+		if (this.pattern === text) {
+			let result$1 = {
+				isMatch: true,
+				score: 0
+			};
+			if (includeMatches) result$1.indices = [[0, text.length - 1]];
+			return result$1;
+		}
+		const { location, distance, threshold, findAllMatches, minMatchCharLength, ignoreLocation } = this.options;
+		let allIndices = [];
+		let totalScore = 0;
+		let hasMatches = false;
+		this.chunks.forEach(({ pattern, alphabet, startIndex }) => {
+			const { isMatch, score, indices } = search(text, pattern, alphabet, {
+				location: location + startIndex,
+				distance,
+				threshold,
+				findAllMatches,
+				minMatchCharLength,
+				includeMatches,
+				ignoreLocation
+			});
+			if (isMatch) hasMatches = true;
+			totalScore += score;
+			if (isMatch && indices) allIndices = [...allIndices, ...indices];
+		});
+		let result = {
+			isMatch: hasMatches,
+			score: hasMatches ? totalScore / this.chunks.length : 1
+		};
+		if (hasMatches && includeMatches) result.indices = allIndices;
+		return result;
+	}
+};
+var BaseMatch = class {
+	constructor(pattern) {
+		this.pattern = pattern;
+	}
+	static isMultiMatch(pattern) {
+		return getMatch(pattern, this.multiRegex);
+	}
+	static isSingleMatch(pattern) {
+		return getMatch(pattern, this.singleRegex);
+	}
+	search() {}
+};
+function getMatch(pattern, exp) {
+	const matches = pattern.match(exp);
+	return matches ? matches[1] : null;
+}
+var ExactMatch = class extends BaseMatch {
+	constructor(pattern) {
+		super(pattern);
+	}
+	static get type() {
+		return "exact";
+	}
+	static get multiRegex() {
+		return /^="(.*)"$/;
+	}
+	static get singleRegex() {
+		return /^=(.*)$/;
+	}
+	search(text) {
+		const isMatch = text === this.pattern;
+		return {
+			isMatch,
+			score: isMatch ? 0 : 1,
+			indices: [0, this.pattern.length - 1]
+		};
+	}
+};
+var InverseExactMatch = class extends BaseMatch {
+	constructor(pattern) {
+		super(pattern);
+	}
+	static get type() {
+		return "inverse-exact";
+	}
+	static get multiRegex() {
+		return /^!"(.*)"$/;
+	}
+	static get singleRegex() {
+		return /^!(.*)$/;
+	}
+	search(text) {
+		const isMatch = text.indexOf(this.pattern) === -1;
+		return {
+			isMatch,
+			score: isMatch ? 0 : 1,
+			indices: [0, text.length - 1]
+		};
+	}
+};
+var PrefixExactMatch = class extends BaseMatch {
+	constructor(pattern) {
+		super(pattern);
+	}
+	static get type() {
+		return "prefix-exact";
+	}
+	static get multiRegex() {
+		return /^\^"(.*)"$/;
+	}
+	static get singleRegex() {
+		return /^\^(.*)$/;
+	}
+	search(text) {
+		const isMatch = text.startsWith(this.pattern);
+		return {
+			isMatch,
+			score: isMatch ? 0 : 1,
+			indices: [0, this.pattern.length - 1]
+		};
+	}
+};
+var InversePrefixExactMatch = class extends BaseMatch {
+	constructor(pattern) {
+		super(pattern);
+	}
+	static get type() {
+		return "inverse-prefix-exact";
+	}
+	static get multiRegex() {
+		return /^!\^"(.*)"$/;
+	}
+	static get singleRegex() {
+		return /^!\^(.*)$/;
+	}
+	search(text) {
+		const isMatch = !text.startsWith(this.pattern);
+		return {
+			isMatch,
+			score: isMatch ? 0 : 1,
+			indices: [0, text.length - 1]
+		};
+	}
+};
+var SuffixExactMatch = class extends BaseMatch {
+	constructor(pattern) {
+		super(pattern);
+	}
+	static get type() {
+		return "suffix-exact";
+	}
+	static get multiRegex() {
+		return /^"(.*)"\$$/;
+	}
+	static get singleRegex() {
+		return /^(.*)\$$/;
+	}
+	search(text) {
+		const isMatch = text.endsWith(this.pattern);
+		return {
+			isMatch,
+			score: isMatch ? 0 : 1,
+			indices: [text.length - this.pattern.length, text.length - 1]
+		};
+	}
+};
+var InverseSuffixExactMatch = class extends BaseMatch {
+	constructor(pattern) {
+		super(pattern);
+	}
+	static get type() {
+		return "inverse-suffix-exact";
+	}
+	static get multiRegex() {
+		return /^!"(.*)"\$$/;
+	}
+	static get singleRegex() {
+		return /^!(.*)\$$/;
+	}
+	search(text) {
+		const isMatch = !text.endsWith(this.pattern);
+		return {
+			isMatch,
+			score: isMatch ? 0 : 1,
+			indices: [0, text.length - 1]
+		};
+	}
+};
+var FuzzyMatch = class extends BaseMatch {
+	constructor(pattern, { location = Config.location, threshold = Config.threshold, distance = Config.distance, includeMatches = Config.includeMatches, findAllMatches = Config.findAllMatches, minMatchCharLength = Config.minMatchCharLength, isCaseSensitive = Config.isCaseSensitive, ignoreDiacritics = Config.ignoreDiacritics, ignoreLocation = Config.ignoreLocation } = {}) {
+		super(pattern);
+		this._bitapSearch = new BitapSearch(pattern, {
+			location,
+			threshold,
+			distance,
+			includeMatches,
+			findAllMatches,
+			minMatchCharLength,
+			isCaseSensitive,
+			ignoreDiacritics,
+			ignoreLocation
+		});
+	}
+	static get type() {
+		return "fuzzy";
+	}
+	static get multiRegex() {
+		return /^"(.*)"$/;
+	}
+	static get singleRegex() {
+		return /^(.*)$/;
+	}
+	search(text) {
+		return this._bitapSearch.searchIn(text);
+	}
+};
+var IncludeMatch = class extends BaseMatch {
+	constructor(pattern) {
+		super(pattern);
+	}
+	static get type() {
+		return "include";
+	}
+	static get multiRegex() {
+		return /^'"(.*)"$/;
+	}
+	static get singleRegex() {
+		return /^'(.*)$/;
+	}
+	search(text) {
+		let location = 0;
+		let index;
+		const indices = [];
+		const patternLen = this.pattern.length;
+		while ((index = text.indexOf(this.pattern, location)) > -1) {
+			location = index + patternLen;
+			indices.push([index, location - 1]);
+		}
+		const isMatch = !!indices.length;
+		return {
+			isMatch,
+			score: isMatch ? 0 : 1,
+			indices
+		};
+	}
+};
+const searchers = [
+	ExactMatch,
+	IncludeMatch,
+	PrefixExactMatch,
+	InversePrefixExactMatch,
+	InverseSuffixExactMatch,
+	SuffixExactMatch,
+	InverseExactMatch,
+	FuzzyMatch
+];
+const searchersLen = searchers.length;
+const SPACE_RE = / +(?=(?:[^\"]*\"[^\"]*\")*[^\"]*$)/;
+const OR_TOKEN = "|";
+function parseQuery(pattern, options = {}) {
+	return pattern.split(OR_TOKEN).map((item) => {
+		let query = item.trim().split(SPACE_RE).filter((item$1) => item$1 && !!item$1.trim());
+		let results = [];
+		for (let i = 0, len = query.length; i < len; i += 1) {
+			const queryItem = query[i];
+			let found = false;
+			let idx = -1;
+			while (!found && ++idx < searchersLen) {
+				const searcher = searchers[idx];
+				let token = searcher.isMultiMatch(queryItem);
+				if (token) {
+					results.push(new searcher(token, options));
+					found = true;
+				}
+			}
+			if (found) continue;
+			idx = -1;
+			while (++idx < searchersLen) {
+				const searcher = searchers[idx];
+				let token = searcher.isSingleMatch(queryItem);
+				if (token) {
+					results.push(new searcher(token, options));
+					break;
+				}
+			}
+		}
+		return results;
+	});
+}
+const MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]);
+/**
+* Command-like searching
+* ======================
+*
+* Given multiple search terms delimited by spaces.e.g. `^jscript .python$ ruby !java`,
+* search in a given text.
+*
+* Search syntax:
+*
+* | Token       | Match type                 | Description                            |
+* | ----------- | -------------------------- | -------------------------------------- |
+* | `jscript`   | fuzzy-match                | Items that fuzzy match `jscript`       |
+* | `=scheme`   | exact-match                | Items that are `scheme`                |
+* | `'python`   | include-match              | Items that include `python`            |
+* | `!ruby`     | inverse-exact-match        | Items that do not include `ruby`       |
+* | `^java`     | prefix-exact-match         | Items that start with `java`           |
+* | `!^earlang` | inverse-prefix-exact-match | Items that do not start with `earlang` |
+* | `.js$`      | suffix-exact-match         | Items that end with `.js`              |
+* | `!.go$`     | inverse-suffix-exact-match | Items that do not end with `.go`       |
+*
+* A single pipe character acts as an OR operator. For example, the following
+* query matches entries that start with `core` and end with either`go`, `rb`,
+* or`py`.
+*
+* ```
+* ^core go$ | rb$ | py$
+* ```
+*/
+var ExtendedSearch = class {
+	constructor(pattern, { isCaseSensitive = Config.isCaseSensitive, ignoreDiacritics = Config.ignoreDiacritics, includeMatches = Config.includeMatches, minMatchCharLength = Config.minMatchCharLength, ignoreLocation = Config.ignoreLocation, findAllMatches = Config.findAllMatches, location = Config.location, threshold = Config.threshold, distance = Config.distance } = {}) {
+		this.query = null;
+		this.options = {
+			isCaseSensitive,
+			ignoreDiacritics,
+			includeMatches,
+			minMatchCharLength,
+			findAllMatches,
+			ignoreLocation,
+			location,
+			threshold,
+			distance
+		};
+		pattern = isCaseSensitive ? pattern : pattern.toLowerCase();
+		pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;
+		this.pattern = pattern;
+		this.query = parseQuery(this.pattern, this.options);
+	}
+	static condition(_, options) {
+		return options.useExtendedSearch;
+	}
+	searchIn(text) {
+		const query = this.query;
+		if (!query) return {
+			isMatch: false,
+			score: 1
+		};
+		const { includeMatches, isCaseSensitive, ignoreDiacritics } = this.options;
+		text = isCaseSensitive ? text : text.toLowerCase();
+		text = ignoreDiacritics ? stripDiacritics(text) : text;
+		let numMatches = 0;
+		let allIndices = [];
+		let totalScore = 0;
+		for (let i = 0, qLen = query.length; i < qLen; i += 1) {
+			const searchers$1 = query[i];
+			allIndices.length = 0;
+			numMatches = 0;
+			for (let j = 0, pLen = searchers$1.length; j < pLen; j += 1) {
+				const searcher = searchers$1[j];
+				const { isMatch, indices, score } = searcher.search(text);
+				if (isMatch) {
+					numMatches += 1;
+					totalScore += score;
+					if (includeMatches) {
+						const type = searcher.constructor.type;
+						if (MultiMatchSet.has(type)) allIndices = [...allIndices, ...indices];
+						else allIndices.push(indices);
+					}
+				} else {
+					totalScore = 0;
+					numMatches = 0;
+					allIndices.length = 0;
+					break;
+				}
+			}
+			if (numMatches) {
+				let result = {
+					isMatch: true,
+					score: totalScore / numMatches
+				};
+				if (includeMatches) result.indices = allIndices;
+				return result;
+			}
+		}
+		return {
+			isMatch: false,
+			score: 1
+		};
+	}
+};
+const registeredSearchers = [];
+function register(...args) {
+	registeredSearchers.push(...args);
+}
+function createSearcher(pattern, options) {
+	for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {
+		let searcherClass = registeredSearchers[i];
+		if (searcherClass.condition(pattern, options)) return new searcherClass(pattern, options);
+	}
+	return new BitapSearch(pattern, options);
+}
+const LogicalOperator = {
+	AND: "$and",
+	OR: "$or"
+};
+const KeyType = {
+	PATH: "$path",
+	PATTERN: "$val"
+};
+const isExpression = (query) => !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);
+const isPath = (query) => !!query[KeyType.PATH];
+const isLeaf = (query) => !isArray(query) && isObject(query) && !isExpression(query);
+const convertToExplicit = (query) => ({ [LogicalOperator.AND]: Object.keys(query).map((key) => ({ [key]: query[key] })) });
+function parse(query, options, { auto = true } = {}) {
+	const next = (query$1) => {
+		let keys = Object.keys(query$1);
+		const isQueryPath = isPath(query$1);
+		if (!isQueryPath && keys.length > 1 && !isExpression(query$1)) return next(convertToExplicit(query$1));
+		if (isLeaf(query$1)) {
+			const key = isQueryPath ? query$1[KeyType.PATH] : keys[0];
+			const pattern = isQueryPath ? query$1[KeyType.PATTERN] : query$1[key];
+			if (!isString(pattern)) throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key));
+			const obj = {
+				keyId: createKeyId(key),
+				pattern
+			};
+			if (auto) obj.searcher = createSearcher(pattern, options);
+			return obj;
+		}
+		let node = {
+			children: [],
+			operator: keys[0]
+		};
+		keys.forEach((key) => {
+			const value = query$1[key];
+			if (isArray(value)) value.forEach((item) => {
+				node.children.push(next(item));
+			});
+		});
+		return node;
+	};
+	if (!isExpression(query)) query = convertToExplicit(query);
+	return next(query);
+}
+function computeScore(results, { ignoreFieldNorm = Config.ignoreFieldNorm }) {
+	results.forEach((result) => {
+		let totalScore = 1;
+		result.matches.forEach(({ key, norm: norm$1, score }) => {
+			const weight = key ? key.weight : null;
+			totalScore *= Math.pow(score === 0 && weight ? Number.EPSILON : score, (weight || 1) * (ignoreFieldNorm ? 1 : norm$1));
+		});
+		result.score = totalScore;
+	});
+}
+function transformMatches(result, data) {
+	const matches = result.matches;
+	data.matches = [];
+	if (!isDefined(matches)) return;
+	matches.forEach((match) => {
+		if (!isDefined(match.indices) || !match.indices.length) return;
+		const { indices, value } = match;
+		let obj = {
+			indices,
+			value
+		};
+		if (match.key) obj.key = match.key.src;
+		if (match.idx > -1) obj.refIndex = match.idx;
+		data.matches.push(obj);
+	});
+}
+function transformScore(result, data) {
+	data.score = result.score;
+}
+function format(results, docs, { includeMatches = Config.includeMatches, includeScore = Config.includeScore } = {}) {
+	const transformers = [];
+	if (includeMatches) transformers.push(transformMatches);
+	if (includeScore) transformers.push(transformScore);
+	return results.map((result) => {
+		const { idx } = result;
+		const data = {
+			item: docs[idx],
+			refIndex: idx
+		};
+		if (transformers.length) transformers.forEach((transformer) => {
+			transformer(result, data);
+		});
+		return data;
+	});
+}
+var Fuse = class {
+	constructor(docs, options = {}, index) {
+		this.options = {
+			...Config,
+			...options
+		};
+		if (this.options.useExtendedSearch && false);
+		this._keyStore = new KeyStore(this.options.keys);
+		this.setCollection(docs, index);
+	}
+	setCollection(docs, index) {
+		this._docs = docs;
+		if (index && !(index instanceof FuseIndex)) throw new Error(INCORRECT_INDEX_TYPE);
+		this._myIndex = index || createIndex(this.options.keys, this._docs, {
+			getFn: this.options.getFn,
+			fieldNormWeight: this.options.fieldNormWeight
+		});
+	}
+	add(doc) {
+		if (!isDefined(doc)) return;
+		this._docs.push(doc);
+		this._myIndex.add(doc);
+	}
+	remove(predicate = () => false) {
+		const results = [];
+		for (let i = 0, len = this._docs.length; i < len; i += 1) {
+			const doc = this._docs[i];
+			if (predicate(doc, i)) {
+				this.removeAt(i);
+				i -= 1;
+				len -= 1;
+				results.push(doc);
+			}
+		}
+		return results;
+	}
+	removeAt(idx) {
+		this._docs.splice(idx, 1);
+		this._myIndex.removeAt(idx);
+	}
+	getIndex() {
+		return this._myIndex;
+	}
+	search(query, { limit = -1 } = {}) {
+		const { includeMatches, includeScore, shouldSort, sortFn, ignoreFieldNorm } = this.options;
+		let results = isString(query) ? isString(this._docs[0]) ? this._searchStringList(query) : this._searchObjectList(query) : this._searchLogical(query);
+		computeScore(results, { ignoreFieldNorm });
+		if (shouldSort) results.sort(sortFn);
+		if (isNumber(limit) && limit > -1) results = results.slice(0, limit);
+		return format(results, this._docs, {
+			includeMatches,
+			includeScore
+		});
+	}
+	_searchStringList(query) {
+		const searcher = createSearcher(query, this.options);
+		const { records } = this._myIndex;
+		const results = [];
+		records.forEach(({ v: text, i: idx, n: norm$1 }) => {
+			if (!isDefined(text)) return;
+			const { isMatch, score, indices } = searcher.searchIn(text);
+			if (isMatch) results.push({
+				item: text,
+				idx,
+				matches: [{
+					score,
+					value: text,
+					norm: norm$1,
+					indices
+				}]
+			});
+		});
+		return results;
+	}
+	_searchLogical(query) {
+		const expression = parse(query, this.options);
+		const evaluate = (node, item, idx) => {
+			if (!node.children) {
+				const { keyId, searcher } = node;
+				const matches = this._findMatches({
+					key: this._keyStore.get(keyId),
+					value: this._myIndex.getValueForItemAtKeyId(item, keyId),
+					searcher
+				});
+				if (matches && matches.length) return [{
+					idx,
+					item,
+					matches
+				}];
+				return [];
+			}
+			const res = [];
+			for (let i = 0, len = node.children.length; i < len; i += 1) {
+				const child = node.children[i];
+				const result = evaluate(child, item, idx);
+				if (result.length) res.push(...result);
+				else if (node.operator === LogicalOperator.AND) return [];
+			}
+			return res;
+		};
+		const records = this._myIndex.records;
+		const resultMap = {};
+		const results = [];
+		records.forEach(({ $: item, i: idx }) => {
+			if (isDefined(item)) {
+				let expResults = evaluate(expression, item, idx);
+				if (expResults.length) {
+					if (!resultMap[idx]) {
+						resultMap[idx] = {
+							idx,
+							item,
+							matches: []
+						};
+						results.push(resultMap[idx]);
+					}
+					expResults.forEach(({ matches }) => {
+						resultMap[idx].matches.push(...matches);
+					});
+				}
+			}
+		});
+		return results;
+	}
+	_searchObjectList(query) {
+		const searcher = createSearcher(query, this.options);
+		const { keys, records } = this._myIndex;
+		const results = [];
+		records.forEach(({ $: item, i: idx }) => {
+			if (!isDefined(item)) return;
+			let matches = [];
+			keys.forEach((key, keyIndex) => {
+				matches.push(...this._findMatches({
+					key,
+					value: item[keyIndex],
+					searcher
+				}));
+			});
+			if (matches.length) results.push({
+				idx,
+				item,
+				matches
+			});
+		});
+		return results;
+	}
+	_findMatches({ key, value, searcher }) {
+		if (!isDefined(value)) return [];
+		let matches = [];
+		if (isArray(value)) value.forEach(({ v: text, i: idx, n: norm$1 }) => {
+			if (!isDefined(text)) return;
+			const { isMatch, score, indices } = searcher.searchIn(text);
+			if (isMatch) matches.push({
+				score,
+				key,
+				value: text,
+				idx,
+				norm: norm$1,
+				indices
+			});
+		});
+		else {
+			const { v: text, n: norm$1 } = value;
+			const { isMatch, score, indices } = searcher.searchIn(text);
+			if (isMatch) matches.push({
+				score,
+				key,
+				value: text,
+				norm: norm$1,
+				indices
+			});
+		}
+		return matches;
+	}
+};
+Fuse.version = "7.1.0";
+Fuse.createIndex = createIndex;
+Fuse.parseIndex = parseIndex;
+Fuse.config = Config;
+Fuse.parseQuery = parse;
+register(ExtendedSearch);
+
+//#endregion
+//#region src/hooks/Search/useSearchInput.ts
+const useSearchInput = ({ initialSearchText = "", searchOrigin, onSearchSubmit }) => {
+	const track = useAtomValue(amplitudeTrackEventAtom);
+	const [searchText, setSearchText] = useState(initialSearchText);
+	const [hasText, setHasText] = useState(initialSearchText.trim().length > 0);
+	const [isFocused, setIsFocused] = useState(false);
+	const [focusedIndex, setFocusedIndex] = useState(-1);
+	const [focusedOptionId, setFocusedOptionId] = useState(void 0);
+	const globalAutocompleteResults = useAtomValue(autocompleteStateAtom).results;
+	const isAutocompleteEnabled = globalAutocompleteResults.length > 0;
+	const isSelectingAutocomplete = useRef(false);
+	const shouldShowAutocomplete = hasText && isFocused && isAutocompleteEnabled;
+	const autocompleteResultsLimit = 5;
+	const fuseOptions = useMemo(() => ({
+		includeScore: true,
+		includeMatches: true,
+		threshold: .3,
+		location: 0,
+		distance: 4,
+		minMatchCharLength: 1,
+		keys: [],
+		useExtendedSearch: false,
+		ignoreLocation: false
+	}), []);
+	const fuse = useMemo(() => {
+		if (!globalAutocompleteResults.length) return null;
+		return new Fuse(globalAutocompleteResults, fuseOptions);
+	}, [globalAutocompleteResults, fuseOptions]);
+	const autocompleteResults = useMemo(() => {
+		if (!isAutocompleteEnabled || !fuse) return [];
+		if (!searchText.trim()) return [];
+		return fuse.search(searchText).slice(0, autocompleteResultsLimit).map((result) => result.item);
+	}, [
+		isAutocompleteEnabled,
+		fuse,
+		searchText,
+		autocompleteResultsLimit
+	]);
+	const handleSearchInputChange = useCallback((newValue) => {
+		if (newValue !== searchText) setIsFocused(true);
+		if (newValue.length === 1) track?.({
+			eventName: SpiffyMetricsEventName.SearchInputStarted,
+			eventProps: { searchOrigin }
+		});
+		setSearchText(newValue);
+		setHasText(newValue.trim().length > 0);
+		setFocusedIndex(-1);
+		setFocusedOptionId(void 0);
+	}, [
+		searchOrigin,
+		searchText,
+		track
+	]);
+	const handleSearchInputFocus = useCallback(() => {
+		setIsFocused(true);
+	}, []);
+	const handleSearchInputBlur = useCallback(() => {
+		setTimeout(() => {
+			if (!isSelectingAutocomplete.current) {
+				setIsFocused(false);
+				setFocusedIndex(-1);
+				setFocusedOptionId(void 0);
+			}
+		}, 150);
+	}, []);
+	const handleSubmitSearch = useCallback(() => {
+		setIsFocused(false);
+		if (searchText.trim() && onSearchSubmit) {
+			track?.({
+				eventName: SpiffyMetricsEventName.SearchQuerySubmitted,
+				eventProps: {
+					searchOrigin,
+					queryText: searchText.trim()
+				},
+				alsoSendToGoogleAnalytics: true
+			});
+			onSearchSubmit(searchText.trim());
+		}
+	}, [
+		searchText,
+		onSearchSubmit,
+		searchOrigin,
+		track
+	]);
+	const handleAutocompleteSelect = useCallback((suggestion, rankPosition) => {
+		isSelectingAutocomplete.current = true;
+		setSearchText(suggestion);
+		setHasText(suggestion.trim().length > 0);
+		setIsFocused(false);
+		track?.({
+			eventName: SpiffyMetricsEventName.SearchInputStarted,
+			eventProps: { searchOrigin }
+		});
+		if (onSearchSubmit) onSearchSubmit(suggestion.trim());
+		setTimeout(() => {
+			isSelectingAutocomplete.current = false;
+		}, 100);
+	}, [
+		onSearchSubmit,
+		searchOrigin,
+		track
+	]);
+	const handleKeyDown = useCallback((event) => {
+		if (event.key === "ArrowDown") {
+			event.preventDefault();
+			const newIndex = (focusedIndex + 1) % autocompleteResults.length;
+			setFocusedIndex(newIndex);
+			setFocusedOptionId(`option-${newIndex}`);
+		} else if (event.key === "ArrowUp") {
+			event.preventDefault();
+			const newIndex = (focusedIndex - 1 + autocompleteResults.length) % autocompleteResults.length;
+			setFocusedIndex(newIndex);
+			setFocusedOptionId(`option-${newIndex}`);
+		} else if (event.key === "Enter") if (focusedIndex === -1) {
+			event.preventDefault();
+			handleSubmitSearch();
+		} else {
+			event.preventDefault();
+			const suggestionText = autocompleteResults[focusedIndex];
+			handleAutocompleteSelect(suggestionText, focusedIndex);
+		}
+		else if (event.key === "Escape") {
+			event.preventDefault();
+			setFocusedIndex(-1);
+			setFocusedOptionId(void 0);
+		}
+	}, [
+		autocompleteResults,
+		focusedIndex,
+		handleAutocompleteSelect,
+		handleSubmitSearch
+	]);
+	const setSearchTextUtility = useCallback((text) => {
+		setSearchText(text);
+		setHasText(text.trim().length > 0);
+	}, []);
+	const resetSearch = useCallback(() => {
+		setSearchText("");
+		setHasText(false);
+		setIsFocused(false);
+		setFocusedIndex(-1);
+		setFocusedOptionId(void 0);
+	}, []);
+	return {
+		searchText,
+		hasText,
+		isFocused,
+		focusedIndex,
+		focusedOptionId,
+		autocompleteResults,
+		shouldShowAutocomplete,
+		handleSearchInputChange,
+		handleSearchInputFocus,
+		handleSearchInputBlur,
+		handleKeyDown,
+		handleAutocompleteSelect,
+		handleSubmitSearch,
+		setSearchText: setSearchTextUtility,
+		resetSearch
+	};
+};
+
+//#endregion
+//#region src/atoms/search/productRetrievalAdapter.ts
+let productRetrievalFunction = null;
+const getProductRetrievalFunction = () => {
+	if (!productRetrievalFunction) throw new Error("Product retrieval function not initialized. Make sure ProductRetrievalProvider is mounted.");
+	return productRetrievalFunction;
+};
+
+//#endregion
+//#region src/atoms/search/productRetrievalAPI.ts
+const productRetrievalAtom = atom({
+	data: null,
+	loading: false,
+	error: null,
+	lastProductIds: null
+});
+const performProductRetrievalAtom = atom(null, async (get$1, set, params) => {
+	if (get$1(productRetrievalAtom).loading) return;
+	set(productRetrievalAtom, {
+		data: null,
+		loading: true,
+		error: null,
+		lastProductIds: params.productIds
+	});
+	try {
+		const result = await getProductRetrievalFunction()(params);
+		set(productRetrievalAtom, {
+			data: result,
+			loading: false,
+			error: null,
+			lastProductIds: params.productIds
+		});
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : "An unknown error occurred";
+		set(productRetrievalAtom, {
+			data: null,
+			loading: false,
+			error: errorMessage,
+			lastProductIds: params.productIds
+		});
+	}
+});
+const retrievedProductsAtom = atom((get$1) => {
+	return get$1(productRetrievalAtom).data?.products || [];
+});
+const productRetrievalLoadingAtom = atom((get$1) => {
+	return get$1(productRetrievalAtom).loading;
+});
+const productRetrievalErrorAtom = atom((get$1) => {
+	return get$1(productRetrievalAtom).error;
+});
+
+//#endregion
+//#region src/hooks/Search/useRecommendedProducts.ts
+/**
+* A hook to get recommended products.
+* It checks the `IsRecommendedProductsEnabled` feature gate and triggers fetching if needed.
+* If the gate is enabled, it returns the list of recommended products.
+* If the gate is disabled, it returns an empty array.
+*
+* @returns The list of recommended products or an empty array.
+*/
+const useRecommendedProducts = () => {
+	const { featureFlagService } = useFeatureFlagService();
+	const isEnabled = featureFlagService?.isFeatureGateEnabled(FeatureGates.IsRecommendedProductsEnabled);
+	const recommendedProducts = useAtomValue(retrievedProductsAtom);
+	const performProductRetrieval = useSetAtom(performProductRetrievalAtom);
+	const { lastProductIds } = useAtomValue(productRetrievalAtom);
+	const orgUIConfig = useNewOrgConfig();
+	useEffect(() => {
+		const recommendedProductIds = orgUIConfig.frontendConfig?.uiConfigs?.searchConfig ? orgUIConfig.frontendConfig?.uiConfigs?.searchConfig.recommendedProducts : [];
+		if (isEnabled && recommendedProductIds && recommendedProductIds.length > 0 && !lastProductIds) performProductRetrieval({ productIds: recommendedProductIds });
+	}, [
+		isEnabled,
+		performProductRetrieval,
+		lastProductIds,
+		orgUIConfig
+	]);
+	return isEnabled ? recommendedProducts : [];
+};
+
+//#endregion
 //#region src/hooks/Search/useSearch.tsx
 const useSearch = () => {
 	const config = useNewOrgConfig();
@@ -46,7 +1430,6 @@ const useSearch = () => {
 	const { data: searchData, loading: isLoadingSearch } = useAtomValue(searchAtom);
 	const productList = useAtomValue(filteredSearchProductsAtom);
 	const performSearch = useSetAtom(performSearchAtom);
-	const [{ results: autocompleteResults, isLoading: isLoadingAutocomplete }, setAutocompleteState] = useAtom(autocompleteStateAtom);
 	const [{ query }] = useAtom(searchParamsAtom);
 	const [isFilterOpen, setIsFilterOpen] = useAtom(isFilterOpenAtom);
 	const [selectedFilterOptions] = useAtom(searchSelectedFiltersAtom);
@@ -55,12 +1438,26 @@ const useSearch = () => {
 	const [productSorting, setProductSorting] = useAtom(searchProductSortingAtom);
 	const clearFilters = useSetAtom(clearSearchFiltersAtom);
 	const searchFilters = useAtomValue(searchFiltersAtom);
-	const [isDirty, setIsDirty] = useState(true);
-	const [focusedIndex, setFocusedIndex] = useState(-1);
-	const [focusedOptionId, setFocusedOptionId] = useState(void 0);
-	const [searchText, setSearchText] = useState(query || "");
+	const recommendedProducts = useRecommendedProducts();
 	const searchResultsRef = useRef(null);
-	const debouncedSearchText = useDebounce(searchText, 200);
+	const scrollToTop = useCallback(() => {
+		const container = searchResultsRef.current;
+		if (container) container.scrollTo({
+			top: 0,
+			behavior: "smooth"
+		});
+		else window.scrollTo({
+			top: 0,
+			behavior: "smooth"
+		});
+	}, []);
+	const { searchText, focusedIndex, focusedOptionId, autocompleteResults, shouldShowAutocomplete, handleSearchInputChange, handleSearchInputFocus, handleSearchInputBlur, handleKeyDown, handleAutocompleteSelect, handleSubmitSearch, setSearchText } = useSearchInput({
+		initialSearchText: query || "",
+		searchOrigin: SpiffyWidgets.SearchResults,
+		onSearchSubmit: (searchQuery) => {
+			performSearch({ query: searchQuery });
+		}
+	});
 	const searchResultsState = getSearchResultsState(isLoadingSearch, searchData);
 	const dynamicFilters = searchData?.filters || [];
 	const safeProductCardConfig = config?.frontendConfig?.uiConfigs?.productCardConfig || {
@@ -120,76 +1517,16 @@ const useSearch = () => {
 			}
 		});
 		addFilter(createFilterOption("dynamic", filter, dynamicFilterDisplayName));
+		scrollToTop();
 	}, [
 		addFilter,
 		searchText,
-		trackEvent
+		scrollToTop
 	]);
 	const handleRemoveFilter = useCallback((filter) => {
 		removeFilter(filter.id);
-	}, [removeFilter]);
-	const handleSubmitSearch = useCallback(async () => {
-		if (searchText.trim()) {
-			trackEvent({
-				eventName: SpiffyMetricsEventName.SearchQuerySubmitted,
-				eventProps: {
-					searchOrigin: SpiffyWidgets.SearchResults,
-					queryText: searchText.trim()
-				},
-				alsoSendToGoogleAnalytics: true
-			});
-			const url = new URL(window.location.href);
-			url.searchParams.set("esq", searchText.trim());
-			window.history.pushState({}, "", url);
-			performSearch({ query: searchText.trim() });
-		}
-	}, [
-		performSearch,
-		searchText,
-		trackEvent
-	]);
-	const handleAutocompleteSelect = useCallback((suggestion) => {
-		setSearchText(suggestion);
-		handleSubmitSearch();
-	}, [handleSubmitSearch, setSearchText]);
-	const handleKeyDown = useCallback((event) => {
-		if (event.key === "ArrowDown") {
-			event.preventDefault();
-			const newIndex = (focusedIndex + 1) % autocompleteResults.length;
-			setFocusedIndex(newIndex);
-			setFocusedOptionId(`option-${newIndex}`);
-		} else if (event.key === "ArrowUp") {
-			event.preventDefault();
-			const newIndex = (focusedIndex - 1 + autocompleteResults.length) % autocompleteResults.length;
-			setFocusedIndex(newIndex);
-			setFocusedOptionId(`option-${newIndex}`);
-		} else if (event.key === "Enter") if (focusedIndex === -1) {
-			event.preventDefault();
-			handleSubmitSearch();
-		} else {
-			event.preventDefault();
-			const suggestionText = autocompleteResults[focusedIndex];
-			handleAutocompleteSelect(suggestionText);
-		}
-		else if (event.key === "Escape") {
-			event.preventDefault();
-			setFocusedIndex(-1);
-			setFocusedOptionId(void 0);
-		}
-	}, [
-		autocompleteResults,
-		focusedIndex,
-		handleAutocompleteSelect,
-		handleSubmitSearch
-	]);
-	const handleSearchInputChange = (newValue) => {
-		if (newValue.length === 1) trackEvent({
-			eventName: SpiffyMetricsEventName.SearchInputStarted,
-			eventProps: { searchOrigin: SpiffyWidgets.SearchResults }
-		});
-		setSearchText(newValue);
-		setIsDirty(true);
-	};
+		scrollToTop();
+	}, [removeFilter, scrollToTop]);
 	const handleSelectFilterItem = useCallback(({ filterId, filterItemId, isSelected, displayName }) => {
 		if (filterId === "sort") {
 			const newSort = filterItemId;
@@ -201,8 +1538,11 @@ const useSearch = () => {
 				}
 			});
 			setProductSorting(newSort);
-		} else if (!isSelected) removeFilter(`${filterId}:${filterItemId}`);
-		else {
+			scrollToTop();
+		} else if (!isSelected) {
+			removeFilter(`${filterId}:${filterItemId}`);
+			scrollToTop();
+		} else {
 			trackEvent({
 				eventName: SpiffyMetricsEventName.SearchFilterClicked,
 				eventProps: {
@@ -213,78 +1553,44 @@ const useSearch = () => {
 				}
 			});
 			addFilter(createFilterOption(filterId, filterItemId, displayName));
+			scrollToTop();
 		}
 	}, [
 		addFilter,
 		removeFilter,
 		setProductSorting,
 		searchText,
-		trackEvent
+		scrollToTop
 	]);
 	const handleClearAllFilters = useCallback(() => {
 		setProductSorting(ProductSorting.FEATURED);
 		clearFilters();
-	}, [setProductSorting, clearFilters]);
+		scrollToTop();
+	}, [
+		setProductSorting,
+		clearFilters,
+		scrollToTop
+	]);
 	useTrackComponentVisibleEvent(SpiffyWidgets.SearchResults, searchResultsRef, {}, SpiffyMetricsEventName.SearchComponentVisible);
 	useEffect(() => {
-		if (searchResultsState === SearchResultsState.NoResults || searchResultsState === SearchResultsState.Results) trackEvent({
+		if (searchResultsState === SearchResultsState.Results || searchResultsState === SearchResultsState.NoResults) trackEvent({
 			eventName: SpiffyMetricsEventName.SearchResultsViewed,
 			eventProps: {
 				queryText: searchText,
 				resultsCount: productList.length
 			}
 		});
-	}, [
-		productList.length,
-		searchResultsState,
-		trackEvent
-	]);
-	useEffect(() => {
-		if (query && query !== searchText) setSearchText(query);
-	}, [query]);
-	useEffect(() => {
-		const esq = new URLSearchParams(window.location.search).get("esq");
-		if (esq) {
-			setSearchText(esq);
-			performSearch({ query: esq });
-		}
-	}, [performSearch]);
-	const fetchAutocompleteSuggestions = (_query) => {
-		return Promise.resolve([]);
-	};
+	}, [productList.length, searchResultsState]);
 	useEffect(() => {
-		if (fetchAutocompleteSuggestions === void 0) return;
-		if (!isDirty || debouncedSearchText.length <= 2) {
-			setAutocompleteState({
-				results: [],
-				isLoading: false
-			});
-			return;
+		if (query && query !== searchText) {
+			const esq = new URLSearchParams(window.location.search).get("esq");
+			setSearchText(query);
+			performSearch({ query: esq ?? query });
 		}
-		setAutocompleteState((prev) => ({
-			...prev,
-			isLoading: true
-		}));
-		const fetchData = async () => {
-			try {
-				const results = await fetchAutocompleteSuggestions?.(debouncedSearchText);
-				setAutocompleteState({
-					results: results ?? [],
-					isLoading: false
-				});
-			} catch (error) {
-				logger_default.logError("Failed to fetch autocomplete suggestions:", error);
-				setAutocompleteState({
-					results: [],
-					isLoading: false
-				});
-			}
-		};
-		fetchData();
 	}, [
-		debouncedSearchText,
-		isDirty,
-		setAutocompleteState
+		performSearch,
+		query,
+		setSearchText
 	]);
 	return {
 		searchData,
@@ -292,16 +1598,17 @@ const useSearch = () => {
 		merchantShortName: safeMerchantShortName,
 		productCardConfig: safeProductCardConfig,
 		productList,
+		recommendedProducts,
 		autocompleteResults,
 		searchFilters: filters,
 		availableDynamicFilters,
 		selectedFilterOptions,
 		searchText,
+		query: query || "",
 		searchResultsState,
-		isLoadingAutocomplete,
 		isLoadingSearch,
 		isFilterOpen,
-		isDirty,
+		shouldShowAutocomplete,
 		focusedIndex,
 		focusedOptionId,
 		filterButtonText,
@@ -309,6 +1616,8 @@ const useSearch = () => {
 		onSubmitSearch: handleSubmitSearch,
 		onAutocompleteSelect: handleAutocompleteSelect,
 		onKeyDown: handleKeyDown,
+		onSearchInputFocus: handleSearchInputFocus,
+		onSearchInputBlur: handleSearchInputBlur,
 		onToggleDynamicFilter: handleToggleDynamicFilter,
 		onSelectFilterItem: handleSelectFilterItem,
 		onRemoveFilter: handleRemoveFilter,
@@ -320,4 +1629,4 @@ const useSearch = () => {
 
 //#endregion
 export { useSearch };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":["handleSelectFilterItem: SelectFilterItem"],"sources":["../../../src/hooks/Search/useSearch.tsx"],"sourcesContent":["import { useAtom, useAtomValue, useSetAtom } from \"jotai\";\nimport { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\nimport { useDebounce } from \"src/hooks/Debounce/useDebounce\";\nimport {\n  addSearchFilterAtom,\n  clearSearchFiltersAtom,\n  createFilterOption,\n  filteredSearchProductsAtom,\n  performSearchAtom,\n  removeSearchFilterAtom,\n  searchAtom,\n  searchFiltersAtom,\n  searchParamsAtom,\n  searchProductSortingAtom,\n  searchSelectedFiltersAtom,\n  SelectedFilterOption,\n} from \"src/atoms/search\";\nimport {\n  autocompleteStateAtom,\n  isFilterOpenAtom,\n} from \"src/atoms/globalSearch/globalSearch\";\nimport { formatFilterDisplayName } from \"src/atoms/search/utils\";\nimport { ProductSorting } from \"src/atoms/search/types\";\nimport {\n  SpiffyMetricsEventName,\n  useAmplitude,\n} from \"src/contexts/amplitudeContext/amplitudeContext\";\nimport { SpiffyWidgets } from \"src/application/models/spiffyWidgets\";\nimport { ProductCardConfig } from \"src/contexts/types\";\nimport Logger from \"src/application/logging/logger\";\nimport { SearchResult } from \"src/application/models/api/search\";\nimport { SearchResponseProduct } from \"@spiffy-ai/commerce-api-client\";\nimport {\n  SearchFilterDatum,\n  SelectFilterItem,\n} from \"src/types/search-filter-types\";\nimport { getSearchResultsState, SearchResultsState } from \"../utils\";\nimport { orgShortNameAtom } from \"src/atoms/envive/enviveConfig\";\nimport { useNewOrgConfig } from \"../NewOrgConfig\";\nimport { useTrackComponentVisibleEvent } from \"../TrackComponentVisibleEvent\";\n\nexport interface SearchResultsHocProps {\n  // Data\n  searchData: SearchResult | null;\n  searchResponseId: string;\n  merchantShortName: string;\n  productCardConfig: ProductCardConfig;\n  productList: SearchResponseProduct[];\n  autocompleteResults: string[];\n  searchFilters: SearchFilterDatum[];\n  availableDynamicFilters: { name: string; displayName: string }[];\n  selectedFilterOptions: SelectedFilterOption[];\n\n  // State\n  searchText: string;\n  searchResultsState: SearchResultsState;\n  isLoadingAutocomplete: boolean;\n  isLoadingSearch: boolean;\n  isFilterOpen: boolean;\n  isDirty: boolean;\n  focusedIndex: number;\n  focusedOptionId: string | undefined;\n\n  // UI\n  filterButtonText: string;\n\n  // Event Handlers\n  onSearchInputChange: (value: string) => void;\n  onSubmitSearch: () => void;\n  onAutocompleteSelect: (suggestion: string) => void;\n  onKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;\n  onToggleDynamicFilter: ({\n    filter,\n    dynamicFilterDisplayName,\n  }: {\n    filter: string;\n    dynamicFilterDisplayName: string;\n  }) => void;\n  onSelectFilterItem: SelectFilterItem;\n  onRemoveFilter: (filter: SelectedFilterOption) => void;\n  onClearAllFilters: () => void;\n  setIsFilterOpen: (isFilterOpen: boolean) => void;\n\n  // Refs\n  searchResultsRef: React.RefObject<HTMLDivElement>;\n}\n\nexport const useSearch = (): SearchResultsHocProps => {\n  // Atoms\n  const config = useNewOrgConfig();\n  const orgShortName = useAtomValue(orgShortNameAtom);\n  const { data: searchData, loading: isLoadingSearch } =\n    useAtomValue(searchAtom);\n  const productList = useAtomValue(filteredSearchProductsAtom);\n  const performSearch = useSetAtom(performSearchAtom);\n  const [\n    { results: autocompleteResults, isLoading: isLoadingAutocomplete },\n    setAutocompleteState,\n  ] = useAtom(autocompleteStateAtom);\n  const [{ query }] = useAtom(searchParamsAtom);\n  const [isFilterOpen, setIsFilterOpen] = useAtom(isFilterOpenAtom);\n  const [selectedFilterOptions] = useAtom(searchSelectedFiltersAtom);\n  const addFilter = useSetAtom(addSearchFilterAtom);\n  const removeFilter = useSetAtom(removeSearchFilterAtom);\n  const [productSorting, setProductSorting] = useAtom(searchProductSortingAtom);\n  const clearFilters = useSetAtom(clearSearchFiltersAtom);\n  const searchFilters = useAtomValue(searchFiltersAtom);\n\n  // State\n  const [isDirty, setIsDirty] = useState(true);\n  const [focusedIndex, setFocusedIndex] = useState(-1);\n  const [focusedOptionId, setFocusedOptionId] = useState<string | undefined>(\n    undefined\n  );\n  const [searchText, setSearchText] = useState(query || \"\");\n\n  // Refs\n  const searchResultsRef = useRef<HTMLDivElement>(null);\n\n  // Derived State\n  const debouncedSearchText = useDebounce(searchText, 200);\n  const searchResultsState = getSearchResultsState(isLoadingSearch, searchData);\n\n  const dynamicFilters = searchData?.filters || [];\n\n  // Provide fallback values when orgUIConfig is not yet available\n  const safeProductCardConfig = config?.frontendConfig?.uiConfigs\n    ?.productCardConfig || {\n    variant: \"minimal\",\n    hoverVariant: \"none\",\n    layoutVariant: \"square\",\n  };\n  const safeMerchantShortName = orgShortName || \"\";\n\n  const availableDynamicFilters = useMemo(() => {\n    return dynamicFilters\n      .filter(\n        (dynamicFilterName) =>\n          !selectedFilterOptions.some(\n            (option) => option.id === `dynamic:${dynamicFilterName}`\n          )\n      )\n      .map((dynamicFilterName) => ({\n        name: dynamicFilterName,\n        displayName: formatFilterDisplayName(dynamicFilterName),\n      }));\n  }, [dynamicFilters, selectedFilterOptions]);\n\n  const filters = useMemo(() => {\n    const sortOptions = [\n      {\n        filterItemId: String(ProductSorting.FEATURED),\n        displayName: \"Relevance\",\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.FEATURED,\n      },\n      {\n        filterItemId: String(ProductSorting.PRICE_ASC),\n        displayName: \"Price: Low to High\",\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.PRICE_ASC,\n      },\n      {\n        filterItemId: String(ProductSorting.PRICE_DESC),\n        displayName: \"Price: High to Low\",\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.PRICE_DESC,\n      },\n    ];\n\n    return [\n      { filterId: \"sort\", displayName: \"SORT\", items: sortOptions },\n      ...searchFilters,\n    ] as SearchFilterDatum[];\n  }, [productSorting, searchFilters]);\n\n  const filterButtonText = useMemo(() => {\n    const selectedCount = filters.reduce((acc: number, filter) => {\n      if (filter.filterId === \"sort\") {\n        return acc;\n      }\n      return acc + filter.items.filter((item) => item.isSelected).length;\n    }, 0);\n    if (selectedCount === 0) {\n      return \"Filter & Sort\";\n    }\n    return `Filter & Sort (${selectedCount})`;\n  }, [filters]);\n\n  // Callbacks\n  const { trackEvent } = useAmplitude();\n\n  const handleToggleDynamicFilter = useCallback(\n    ({\n      filter,\n      dynamicFilterDisplayName,\n    }: {\n      filter: string;\n      dynamicFilterDisplayName: string;\n    }) => {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchFilterClicked,\n        eventProps: {\n          filterType: \"Dynamic\",\n          filterValue: filter,\n          queryText: searchText,\n        },\n      });\n      addFilter(\n        createFilterOption(\"dynamic\", filter, dynamicFilterDisplayName)\n      );\n    },\n    [addFilter, searchText, trackEvent]\n  );\n\n  const handleRemoveFilter = useCallback(\n    (filter: SelectedFilterOption) => {\n      removeFilter(filter.id);\n    },\n    [removeFilter]\n  );\n\n  const handleSubmitSearch = useCallback(async () => {\n    if (searchText.trim()) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchQuerySubmitted,\n        eventProps: {\n          searchOrigin: SpiffyWidgets.SearchResults,\n          queryText: searchText.trim(),\n        },\n        alsoSendToGoogleAnalytics: true,\n      });\n      const url = new URL(window.location.href);\n      url.searchParams.set(\"esq\", searchText.trim());\n      window.history.pushState({}, \"\", url);\n      performSearch({ query: searchText.trim() });\n    }\n  }, [performSearch, searchText, trackEvent]);\n\n  const handleAutocompleteSelect = useCallback(\n    (suggestion: string) => {\n      setSearchText(suggestion);\n      handleSubmitSearch();\n    },\n    [handleSubmitSearch, setSearchText]\n  );\n\n  const handleKeyDown = useCallback(\n    (event: React.KeyboardEvent<HTMLInputElement>) => {\n      if (event.key === \"ArrowDown\") {\n        event.preventDefault();\n        const newIndex = (focusedIndex + 1) % autocompleteResults.length;\n        setFocusedIndex(newIndex);\n        setFocusedOptionId(`option-${newIndex}`);\n      } else if (event.key === \"ArrowUp\") {\n        event.preventDefault();\n        const newIndex =\n          (focusedIndex - 1 + autocompleteResults.length) %\n          autocompleteResults.length;\n        setFocusedIndex(newIndex);\n        setFocusedOptionId(`option-${newIndex}`);\n      } else if (event.key === \"Enter\") {\n        if (focusedIndex === -1) {\n          event.preventDefault();\n          handleSubmitSearch();\n        } else {\n          event.preventDefault();\n          const suggestionText = autocompleteResults[focusedIndex];\n          handleAutocompleteSelect(suggestionText);\n        }\n      } else if (event.key === \"Escape\") {\n        event.preventDefault();\n        setFocusedIndex(-1);\n        setFocusedOptionId(undefined);\n      }\n    },\n    [\n      autocompleteResults,\n      focusedIndex,\n      handleAutocompleteSelect,\n      handleSubmitSearch,\n    ]\n  );\n\n  const handleSearchInputChange = (newValue: string) => {\n    if (newValue.length === 1) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchInputStarted,\n        eventProps: {\n          searchOrigin: SpiffyWidgets.SearchResults,\n        },\n      });\n    }\n    setSearchText(newValue);\n    setIsDirty(true);\n  };\n\n  const handleSelectFilterItem: SelectFilterItem = useCallback(\n    ({\n      filterId,\n      filterItemId,\n      isSelected,\n      displayName,\n    }: {\n      filterId: string;\n      filterItemId: string;\n      isSelected: boolean;\n      displayName: string;\n    }) => {\n      if (filterId === \"sort\") {\n        const newSort = filterItemId as ProductSorting;\n        trackEvent({\n          eventName: SpiffyMetricsEventName.SearchSortClicked,\n          eventProps: {\n            sortType: newSort,\n            queryText: searchText,\n          },\n        });\n        setProductSorting(newSort);\n      } else if (!isSelected) {\n        removeFilter(`${filterId}:${filterItemId}`);\n      } else {\n        trackEvent({\n          eventName: SpiffyMetricsEventName.SearchFilterClicked,\n          eventProps: {\n            filterType: \"Static\",\n            filterCategory: filterId,\n            filterValue: filterItemId,\n            queryText: searchText,\n          },\n        });\n        addFilter(createFilterOption(filterId, filterItemId, displayName));\n      }\n    },\n    [addFilter, removeFilter, setProductSorting, searchText, trackEvent]\n  );\n\n  const handleClearAllFilters = useCallback(() => {\n    setProductSorting(ProductSorting.FEATURED);\n    clearFilters();\n  }, [setProductSorting, clearFilters]);\n\n  // Side Effects\n  useTrackComponentVisibleEvent(\n    SpiffyWidgets.SearchResults,\n    searchResultsRef,\n    {},\n    SpiffyMetricsEventName.SearchComponentVisible\n  );\n\n  useEffect(() => {\n    if (searchResultsState === SearchResultsState.NoResults || searchResultsState === SearchResultsState.Results) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchResultsViewed,\n        eventProps: {\n          queryText: searchText,\n          resultsCount: productList.length,\n        },\n      });\n    }\n  }, [productList.length, searchResultsState, trackEvent]);\n\n  useEffect(() => {\n    if (query && query !== searchText) {\n      setSearchText(query);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [query]);\n\n  useEffect(() => {\n    const esq = new URLSearchParams(window.location.search).get(\"esq\");\n    if (esq) {\n      setSearchText(esq);\n      performSearch({ query: esq });\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [performSearch]);\n\n  const fetchAutocompleteSuggestions = (_query: string) => {\n    // TODO: implement autocomplete suggestions\n    return Promise.resolve([]);\n  };\n\n  useEffect(() => {\n    if (fetchAutocompleteSuggestions === undefined) {\n      return;\n    }\n\n    if (!isDirty || debouncedSearchText.length <= 2) {\n      setAutocompleteState({ results: [], isLoading: false });\n      return;\n    }\n\n    setAutocompleteState((prev) => ({ ...prev, isLoading: true }));\n\n    const fetchData = async () => {\n      try {\n        const results = await fetchAutocompleteSuggestions?.(\n          debouncedSearchText\n        );\n        setAutocompleteState({ results: results ?? [], isLoading: false });\n      } catch (error) {\n        Logger.logError(\"Failed to fetch autocomplete suggestions:\", error);\n        setAutocompleteState({ results: [], isLoading: false });\n      }\n    };\n\n    fetchData();\n  }, [debouncedSearchText, isDirty, setAutocompleteState]);\n\n  return {\n    searchData,\n    searchResponseId: searchData?.searchResponseId ?? \"\",\n    merchantShortName: safeMerchantShortName,\n    productCardConfig: safeProductCardConfig,\n    productList,\n    autocompleteResults,\n    searchFilters: filters,\n    availableDynamicFilters,\n    selectedFilterOptions,\n    searchText,\n    searchResultsState,\n    isLoadingAutocomplete,\n    isLoadingSearch,\n    isFilterOpen,\n    isDirty,\n    focusedIndex,\n    focusedOptionId,\n    filterButtonText,\n    onSearchInputChange: handleSearchInputChange,\n    onSubmitSearch: handleSubmitSearch,\n    onAutocompleteSelect: handleAutocompleteSelect,\n    onKeyDown: handleKeyDown,\n    onToggleDynamicFilter: handleToggleDynamicFilter,\n    onSelectFilterItem: handleSelectFilterItem,\n    onRemoveFilter: handleRemoveFilter,\n    onClearAllFilters: handleClearAllFilters,\n    setIsFilterOpen,\n    searchResultsRef,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuFA,MAAa,kBAAyC;CAEpD,MAAM,SAAS,iBAAiB;CAChC,MAAM,eAAe,aAAa,iBAAiB;CACnD,MAAM,EAAE,MAAM,YAAY,SAAS,oBACjC,aAAa,WAAW;CAC1B,MAAM,cAAc,aAAa,2BAA2B;CAC5D,MAAM,gBAAgB,WAAW,kBAAkB;CACnD,MAAM,CACJ,EAAE,SAAS,qBAAqB,WAAW,yBAC3C,wBACE,QAAQ,sBAAsB;CAClC,MAAM,CAAC,EAAE,WAAW,QAAQ,iBAAiB;CAC7C,MAAM,CAAC,cAAc,mBAAmB,QAAQ,iBAAiB;CACjE,MAAM,CAAC,yBAAyB,QAAQ,0BAA0B;CAClE,MAAM,YAAY,WAAW,oBAAoB;CACjD,MAAM,eAAe,WAAW,uBAAuB;CACvD,MAAM,CAAC,gBAAgB,qBAAqB,QAAQ,yBAAyB;CAC7E,MAAM,eAAe,WAAW,uBAAuB;CACvD,MAAM,gBAAgB,aAAa,kBAAkB;CAGrD,MAAM,CAAC,SAAS,cAAc,SAAS,KAAK;CAC5C,MAAM,CAAC,cAAc,mBAAmB,SAAS,GAAG;CACpD,MAAM,CAAC,iBAAiB,sBAAsB,SAC5C,OACD;CACD,MAAM,CAAC,YAAY,iBAAiB,SAAS,SAAS,GAAG;CAGzD,MAAM,mBAAmB,OAAuB,KAAK;CAGrD,MAAM,sBAAsB,YAAY,YAAY,IAAI;CACxD,MAAM,qBAAqB,sBAAsB,iBAAiB,WAAW;CAE7E,MAAM,iBAAiB,YAAY,WAAW,EAAE;CAGhD,MAAM,wBAAwB,QAAQ,gBAAgB,WAClD,qBAAqB;EACvB,SAAS;EACT,cAAc;EACd,eAAe;EAChB;CACD,MAAM,wBAAwB,gBAAgB;CAE9C,MAAM,0BAA0B,cAAc;AAC5C,SAAO,eACJ,QACE,sBACC,CAAC,sBAAsB,MACpB,WAAW,OAAO,OAAO,WAAW,oBACtC,CACJ,CACA,KAAK,uBAAuB;GAC3B,MAAM;GACN,aAAa,wBAAwB,kBAAkB;GACxD,EAAE;IACJ,CAAC,gBAAgB,sBAAsB,CAAC;CAE3C,MAAM,UAAU,cAAc;AAsB5B,SAAO,CACL;GAAE,UAAU;GAAQ,aAAa;GAAQ,OAtBvB;IAClB;KACE,cAAc,OAAO,eAAe,SAAS;KAC7C,aAAa;KACb,cAAc;KACd,YAAY,mBAAmB,eAAe;KAC/C;IACD;KACE,cAAc,OAAO,eAAe,UAAU;KAC9C,aAAa;KACb,cAAc;KACd,YAAY,mBAAmB,eAAe;KAC/C;IACD;KACE,cAAc,OAAO,eAAe,WAAW;KAC/C,aAAa;KACb,cAAc;KACd,YAAY,mBAAmB,eAAe;KAC/C;IACF;GAG8D,EAC7D,GAAG,cACJ;IACA,CAAC,gBAAgB,cAAc,CAAC;CAEnC,MAAM,mBAAmB,cAAc;EACrC,MAAM,gBAAgB,QAAQ,QAAQ,KAAa,WAAW;AAC5D,OAAI,OAAO,aAAa,OACtB,QAAO;AAET,UAAO,MAAM,OAAO,MAAM,QAAQ,SAAS,KAAK,WAAW,CAAC;KAC3D,EAAE;AACL,MAAI,kBAAkB,EACpB,QAAO;AAET,SAAO,kBAAkB,cAAc;IACtC,CAAC,QAAQ,CAAC;CAGb,MAAM,EAAE,eAAe,cAAc;CAErC,MAAM,4BAA4B,aAC/B,EACC,QACA,+BAII;AACJ,aAAW;GACT,WAAW,uBAAuB;GAClC,YAAY;IACV,YAAY;IACZ,aAAa;IACb,WAAW;IACZ;GACF,CAAC;AACF,YACE,mBAAmB,WAAW,QAAQ,yBAAyB,CAChE;IAEH;EAAC;EAAW;EAAY;EAAW,CACpC;CAED,MAAM,qBAAqB,aACxB,WAAiC;AAChC,eAAa,OAAO,GAAG;IAEzB,CAAC,aAAa,CACf;CAED,MAAM,qBAAqB,YAAY,YAAY;AACjD,MAAI,WAAW,MAAM,EAAE;AACrB,cAAW;IACT,WAAW,uBAAuB;IAClC,YAAY;KACV,cAAc,cAAc;KAC5B,WAAW,WAAW,MAAM;KAC7B;IACD,2BAA2B;IAC5B,CAAC;GACF,MAAM,MAAM,IAAI,IAAI,OAAO,SAAS,KAAK;AACzC,OAAI,aAAa,IAAI,OAAO,WAAW,MAAM,CAAC;AAC9C,UAAO,QAAQ,UAAU,EAAE,EAAE,IAAI,IAAI;AACrC,iBAAc,EAAE,OAAO,WAAW,MAAM,EAAE,CAAC;;IAE5C;EAAC;EAAe;EAAY;EAAW,CAAC;CAE3C,MAAM,2BAA2B,aAC9B,eAAuB;AACtB,gBAAc,WAAW;AACzB,sBAAoB;IAEtB,CAAC,oBAAoB,cAAc,CACpC;CAED,MAAM,gBAAgB,aACnB,UAAiD;AAChD,MAAI,MAAM,QAAQ,aAAa;AAC7B,SAAM,gBAAgB;GACtB,MAAM,YAAY,eAAe,KAAK,oBAAoB;AAC1D,mBAAgB,SAAS;AACzB,sBAAmB,UAAU,WAAW;aAC/B,MAAM,QAAQ,WAAW;AAClC,SAAM,gBAAgB;GACtB,MAAM,YACH,eAAe,IAAI,oBAAoB,UACxC,oBAAoB;AACtB,mBAAgB,SAAS;AACzB,sBAAmB,UAAU,WAAW;aAC/B,MAAM,QAAQ,QACvB,KAAI,iBAAiB,IAAI;AACvB,SAAM,gBAAgB;AACtB,uBAAoB;SACf;AACL,SAAM,gBAAgB;GACtB,MAAM,iBAAiB,oBAAoB;AAC3C,4BAAyB,eAAe;;WAEjC,MAAM,QAAQ,UAAU;AACjC,SAAM,gBAAgB;AACtB,mBAAgB,GAAG;AACnB,sBAAmB,OAAU;;IAGjC;EACE;EACA;EACA;EACA;EACD,CACF;CAED,MAAM,2BAA2B,aAAqB;AACpD,MAAI,SAAS,WAAW,EACtB,YAAW;GACT,WAAW,uBAAuB;GAClC,YAAY,EACV,cAAc,cAAc,eAC7B;GACF,CAAC;AAEJ,gBAAc,SAAS;AACvB,aAAW,KAAK;;CAGlB,MAAMA,yBAA2C,aAC9C,EACC,UACA,cACA,YACA,kBAMI;AACJ,MAAI,aAAa,QAAQ;GACvB,MAAM,UAAU;AAChB,cAAW;IACT,WAAW,uBAAuB;IAClC,YAAY;KACV,UAAU;KACV,WAAW;KACZ;IACF,CAAC;AACF,qBAAkB,QAAQ;aACjB,CAAC,WACV,cAAa,GAAG,SAAS,GAAG,eAAe;OACtC;AACL,cAAW;IACT,WAAW,uBAAuB;IAClC,YAAY;KACV,YAAY;KACZ,gBAAgB;KAChB,aAAa;KACb,WAAW;KACZ;IACF,CAAC;AACF,aAAU,mBAAmB,UAAU,cAAc,YAAY,CAAC;;IAGtE;EAAC;EAAW;EAAc;EAAmB;EAAY;EAAW,CACrE;CAED,MAAM,wBAAwB,kBAAkB;AAC9C,oBAAkB,eAAe,SAAS;AAC1C,gBAAc;IACb,CAAC,mBAAmB,aAAa,CAAC;AAGrC,+BACE,cAAc,eACd,kBACA,EAAE,EACF,uBAAuB,uBACxB;AAED,iBAAgB;AACd,MAAI,uBAAuB,mBAAmB,aAAa,uBAAuB,mBAAmB,QACnG,YAAW;GACT,WAAW,uBAAuB;GAClC,YAAY;IACV,WAAW;IACX,cAAc,YAAY;IAC3B;GACF,CAAC;IAEH;EAAC,YAAY;EAAQ;EAAoB;EAAW,CAAC;AAExD,iBAAgB;AACd,MAAI,SAAS,UAAU,WACrB,eAAc,MAAM;IAGrB,CAAC,MAAM,CAAC;AAEX,iBAAgB;EACd,MAAM,MAAM,IAAI,gBAAgB,OAAO,SAAS,OAAO,CAAC,IAAI,MAAM;AAClE,MAAI,KAAK;AACP,iBAAc,IAAI;AAClB,iBAAc,EAAE,OAAO,KAAK,CAAC;;IAG9B,CAAC,cAAc,CAAC;CAEnB,MAAM,gCAAgC,WAAmB;AAEvD,SAAO,QAAQ,QAAQ,EAAE,CAAC;;AAG5B,iBAAgB;AACd,MAAI,iCAAiC,OACnC;AAGF,MAAI,CAAC,WAAW,oBAAoB,UAAU,GAAG;AAC/C,wBAAqB;IAAE,SAAS,EAAE;IAAE,WAAW;IAAO,CAAC;AACvD;;AAGF,wBAAsB,UAAU;GAAE,GAAG;GAAM,WAAW;GAAM,EAAE;EAE9D,MAAM,YAAY,YAAY;AAC5B,OAAI;IACF,MAAM,UAAU,MAAM,+BACpB,oBACD;AACD,yBAAqB;KAAE,SAAS,WAAW,EAAE;KAAE,WAAW;KAAO,CAAC;YAC3D,OAAO;AACd,mBAAO,SAAS,6CAA6C,MAAM;AACnE,yBAAqB;KAAE,SAAS,EAAE;KAAE,WAAW;KAAO,CAAC;;;AAI3D,aAAW;IACV;EAAC;EAAqB;EAAS;EAAqB,CAAC;AAExD,QAAO;EACL;EACA,kBAAkB,YAAY,oBAAoB;EAClD,mBAAmB;EACnB,mBAAmB;EACnB;EACA;EACA,eAAe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,qBAAqB;EACrB,gBAAgB;EAChB,sBAAsB;EACtB,WAAW;EACX,uBAAuB;EACvB,oBAAoB;EACpB,gBAAgB;EAChB,mBAAmB;EACnB;EACA;EACD"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","names":["obj","path","norm","value","pattern","result","item","searchers","query","productRetrievalFunction:\n  | ((params: ProductRetrievalParams) => Promise<ProductRetrievalResult>)\n  | null","get","error: unknown","handleSelectFilterItem: SelectFilterItem"],"sources":["../../../node_modules/fuse.js/dist/fuse.mjs","../../../src/hooks/Search/useSearchInput.ts","../../../src/atoms/search/productRetrievalAdapter.ts","../../../src/atoms/search/productRetrievalAPI.ts","../../../src/hooks/Search/useRecommendedProducts.ts","../../../src/hooks/Search/useSearch.tsx"],"sourcesContent":["/**\n * Fuse.js v7.1.0 - Lightweight fuzzy-search (http://fusejs.io)\n *\n * Copyright (c) 2025 Kiro Risk (http://kiro.me)\n * All Rights Reserved. Apache Software License 2.0\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n */\n\nfunction isArray(value) {\n  return !Array.isArray\n    ? getTag(value) === '[object Array]'\n    : Array.isArray(value)\n}\n\n// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/baseToString.js\nconst INFINITY = 1 / 0;\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value\n  }\n  let result = value + '';\n  return result == '0' && 1 / value == -INFINITY ? '-0' : result\n}\n\nfunction toString(value) {\n  return value == null ? '' : baseToString(value)\n}\n\nfunction isString(value) {\n  return typeof value === 'string'\n}\n\nfunction isNumber(value) {\n  return typeof value === 'number'\n}\n\n// Adapted from: https://github.com/lodash/lodash/blob/master/isBoolean.js\nfunction isBoolean(value) {\n  return (\n    value === true ||\n    value === false ||\n    (isObjectLike(value) && getTag(value) == '[object Boolean]')\n  )\n}\n\nfunction isObject(value) {\n  return typeof value === 'object'\n}\n\n// Checks if `value` is object-like.\nfunction isObjectLike(value) {\n  return isObject(value) && value !== null\n}\n\nfunction isDefined(value) {\n  return value !== undefined && value !== null\n}\n\nfunction isBlank(value) {\n  return !value.trim().length\n}\n\n// Gets the `toStringTag` of `value`.\n// Adapted from: https://github.com/lodash/lodash/blob/master/.internal/getTag.js\nfunction getTag(value) {\n  return value == null\n    ? value === undefined\n      ? '[object Undefined]'\n      : '[object Null]'\n    : Object.prototype.toString.call(value)\n}\n\nconst EXTENDED_SEARCH_UNAVAILABLE = 'Extended search is not available';\n\nconst INCORRECT_INDEX_TYPE = \"Incorrect 'index' type\";\n\nconst LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY = (key) =>\n  `Invalid value for key ${key}`;\n\nconst PATTERN_LENGTH_TOO_LARGE = (max) =>\n  `Pattern length exceeds max of ${max}.`;\n\nconst MISSING_KEY_PROPERTY = (name) => `Missing ${name} property in key`;\n\nconst INVALID_KEY_WEIGHT_VALUE = (key) =>\n  `Property 'weight' in key '${key}' must be a positive integer`;\n\nconst hasOwn = Object.prototype.hasOwnProperty;\n\nclass KeyStore {\n  constructor(keys) {\n    this._keys = [];\n    this._keyMap = {};\n\n    let totalWeight = 0;\n\n    keys.forEach((key) => {\n      let obj = createKey(key);\n\n      this._keys.push(obj);\n      this._keyMap[obj.id] = obj;\n\n      totalWeight += obj.weight;\n    });\n\n    // Normalize weights so that their sum is equal to 1\n    this._keys.forEach((key) => {\n      key.weight /= totalWeight;\n    });\n  }\n  get(keyId) {\n    return this._keyMap[keyId]\n  }\n  keys() {\n    return this._keys\n  }\n  toJSON() {\n    return JSON.stringify(this._keys)\n  }\n}\n\nfunction createKey(key) {\n  let path = null;\n  let id = null;\n  let src = null;\n  let weight = 1;\n  let getFn = null;\n\n  if (isString(key) || isArray(key)) {\n    src = key;\n    path = createKeyPath(key);\n    id = createKeyId(key);\n  } else {\n    if (!hasOwn.call(key, 'name')) {\n      throw new Error(MISSING_KEY_PROPERTY('name'))\n    }\n\n    const name = key.name;\n    src = name;\n\n    if (hasOwn.call(key, 'weight')) {\n      weight = key.weight;\n\n      if (weight <= 0) {\n        throw new Error(INVALID_KEY_WEIGHT_VALUE(name))\n      }\n    }\n\n    path = createKeyPath(name);\n    id = createKeyId(name);\n    getFn = key.getFn;\n  }\n\n  return { path, id, weight, src, getFn }\n}\n\nfunction createKeyPath(key) {\n  return isArray(key) ? key : key.split('.')\n}\n\nfunction createKeyId(key) {\n  return isArray(key) ? key.join('.') : key\n}\n\nfunction get(obj, path) {\n  let list = [];\n  let arr = false;\n\n  const deepGet = (obj, path, index) => {\n    if (!isDefined(obj)) {\n      return\n    }\n    if (!path[index]) {\n      // If there's no path left, we've arrived at the object we care about.\n      list.push(obj);\n    } else {\n      let key = path[index];\n\n      const value = obj[key];\n\n      if (!isDefined(value)) {\n        return\n      }\n\n      // If we're at the last value in the path, and if it's a string/number/bool,\n      // add it to the list\n      if (\n        index === path.length - 1 &&\n        (isString(value) || isNumber(value) || isBoolean(value))\n      ) {\n        list.push(toString(value));\n      } else if (isArray(value)) {\n        arr = true;\n        // Search each item in the array.\n        for (let i = 0, len = value.length; i < len; i += 1) {\n          deepGet(value[i], path, index + 1);\n        }\n      } else if (path.length) {\n        // An object. Recurse further.\n        deepGet(value, path, index + 1);\n      }\n    }\n  };\n\n  // Backwards compatibility (since path used to be a string)\n  deepGet(obj, isString(path) ? path.split('.') : path, 0);\n\n  return arr ? list : list[0]\n}\n\nconst MatchOptions = {\n  // Whether the matches should be included in the result set. When `true`, each record in the result\n  // set will include the indices of the matched characters.\n  // These can consequently be used for highlighting purposes.\n  includeMatches: false,\n  // When `true`, the matching function will continue to the end of a search pattern even if\n  // a perfect match has already been located in the string.\n  findAllMatches: false,\n  // Minimum number of characters that must be matched before a result is considered a match\n  minMatchCharLength: 1\n};\n\nconst BasicOptions = {\n  // When `true`, the algorithm continues searching to the end of the input even if a perfect\n  // match is found before the end of the same input.\n  isCaseSensitive: false,\n  // When `true`, the algorithm will ignore diacritics (accents) in comparisons\n  ignoreDiacritics: false,\n  // When true, the matching function will continue to the end of a search pattern even if\n  includeScore: false,\n  // List of properties that will be searched. This also supports nested properties.\n  keys: [],\n  // Whether to sort the result list, by score\n  shouldSort: true,\n  // Default sort function: sort by ascending score, ascending index\n  sortFn: (a, b) =>\n    a.score === b.score ? (a.idx < b.idx ? -1 : 1) : a.score < b.score ? -1 : 1\n};\n\nconst FuzzyOptions = {\n  // Approximately where in the text is the pattern expected to be found?\n  location: 0,\n  // At what point does the match algorithm give up. A threshold of '0.0' requires a perfect match\n  // (of both letters and location), a threshold of '1.0' would match anything.\n  threshold: 0.6,\n  // Determines how close the match must be to the fuzzy location (specified above).\n  // An exact letter match which is 'distance' characters away from the fuzzy location\n  // would score as a complete mismatch. A distance of '0' requires the match be at\n  // the exact location specified, a threshold of '1000' would require a perfect match\n  // to be within 800 characters of the fuzzy location to be found using a 0.8 threshold.\n  distance: 100\n};\n\nconst AdvancedOptions = {\n  // When `true`, it enables the use of unix-like search commands\n  useExtendedSearch: false,\n  // The get function to use when fetching an object's properties.\n  // The default will search nested paths *ie foo.bar.baz*\n  getFn: get,\n  // When `true`, search will ignore `location` and `distance`, so it won't matter\n  // where in the string the pattern appears.\n  // More info: https://fusejs.io/concepts/scoring-theory.html#fuzziness-score\n  ignoreLocation: false,\n  // When `true`, the calculation for the relevance score (used for sorting) will\n  // ignore the field-length norm.\n  // More info: https://fusejs.io/concepts/scoring-theory.html#field-length-norm\n  ignoreFieldNorm: false,\n  // The weight to determine how much field length norm effects scoring.\n  fieldNormWeight: 1\n};\n\nvar Config = {\n  ...BasicOptions,\n  ...MatchOptions,\n  ...FuzzyOptions,\n  ...AdvancedOptions\n};\n\nconst SPACE = /[^ ]+/g;\n\n// Field-length norm: the shorter the field, the higher the weight.\n// Set to 3 decimals to reduce index size.\nfunction norm(weight = 1, mantissa = 3) {\n  const cache = new Map();\n  const m = Math.pow(10, mantissa);\n\n  return {\n    get(value) {\n      const numTokens = value.match(SPACE).length;\n\n      if (cache.has(numTokens)) {\n        return cache.get(numTokens)\n      }\n\n      // Default function is 1/sqrt(x), weight makes that variable\n      const norm = 1 / Math.pow(numTokens, 0.5 * weight);\n\n      // In place of `toFixed(mantissa)`, for faster computation\n      const n = parseFloat(Math.round(norm * m) / m);\n\n      cache.set(numTokens, n);\n\n      return n\n    },\n    clear() {\n      cache.clear();\n    }\n  }\n}\n\nclass FuseIndex {\n  constructor({\n    getFn = Config.getFn,\n    fieldNormWeight = Config.fieldNormWeight\n  } = {}) {\n    this.norm = norm(fieldNormWeight, 3);\n    this.getFn = getFn;\n    this.isCreated = false;\n\n    this.setIndexRecords();\n  }\n  setSources(docs = []) {\n    this.docs = docs;\n  }\n  setIndexRecords(records = []) {\n    this.records = records;\n  }\n  setKeys(keys = []) {\n    this.keys = keys;\n    this._keysMap = {};\n    keys.forEach((key, idx) => {\n      this._keysMap[key.id] = idx;\n    });\n  }\n  create() {\n    if (this.isCreated || !this.docs.length) {\n      return\n    }\n\n    this.isCreated = true;\n\n    // List is Array<String>\n    if (isString(this.docs[0])) {\n      this.docs.forEach((doc, docIndex) => {\n        this._addString(doc, docIndex);\n      });\n    } else {\n      // List is Array<Object>\n      this.docs.forEach((doc, docIndex) => {\n        this._addObject(doc, docIndex);\n      });\n    }\n\n    this.norm.clear();\n  }\n  // Adds a doc to the end of the index\n  add(doc) {\n    const idx = this.size();\n\n    if (isString(doc)) {\n      this._addString(doc, idx);\n    } else {\n      this._addObject(doc, idx);\n    }\n  }\n  // Removes the doc at the specified index of the index\n  removeAt(idx) {\n    this.records.splice(idx, 1);\n\n    // Change ref index of every subsquent doc\n    for (let i = idx, len = this.size(); i < len; i += 1) {\n      this.records[i].i -= 1;\n    }\n  }\n  getValueForItemAtKeyId(item, keyId) {\n    return item[this._keysMap[keyId]]\n  }\n  size() {\n    return this.records.length\n  }\n  _addString(doc, docIndex) {\n    if (!isDefined(doc) || isBlank(doc)) {\n      return\n    }\n\n    let record = {\n      v: doc,\n      i: docIndex,\n      n: this.norm.get(doc)\n    };\n\n    this.records.push(record);\n  }\n  _addObject(doc, docIndex) {\n    let record = { i: docIndex, $: {} };\n\n    // Iterate over every key (i.e, path), and fetch the value at that key\n    this.keys.forEach((key, keyIndex) => {\n      let value = key.getFn ? key.getFn(doc) : this.getFn(doc, key.path);\n\n      if (!isDefined(value)) {\n        return\n      }\n\n      if (isArray(value)) {\n        let subRecords = [];\n        const stack = [{ nestedArrIndex: -1, value }];\n\n        while (stack.length) {\n          const { nestedArrIndex, value } = stack.pop();\n\n          if (!isDefined(value)) {\n            continue\n          }\n\n          if (isString(value) && !isBlank(value)) {\n            let subRecord = {\n              v: value,\n              i: nestedArrIndex,\n              n: this.norm.get(value)\n            };\n\n            subRecords.push(subRecord);\n          } else if (isArray(value)) {\n            value.forEach((item, k) => {\n              stack.push({\n                nestedArrIndex: k,\n                value: item\n              });\n            });\n          } else ;\n        }\n        record.$[keyIndex] = subRecords;\n      } else if (isString(value) && !isBlank(value)) {\n        let subRecord = {\n          v: value,\n          n: this.norm.get(value)\n        };\n\n        record.$[keyIndex] = subRecord;\n      }\n    });\n\n    this.records.push(record);\n  }\n  toJSON() {\n    return {\n      keys: this.keys,\n      records: this.records\n    }\n  }\n}\n\nfunction createIndex(\n  keys,\n  docs,\n  { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}\n) {\n  const myIndex = new FuseIndex({ getFn, fieldNormWeight });\n  myIndex.setKeys(keys.map(createKey));\n  myIndex.setSources(docs);\n  myIndex.create();\n  return myIndex\n}\n\nfunction parseIndex(\n  data,\n  { getFn = Config.getFn, fieldNormWeight = Config.fieldNormWeight } = {}\n) {\n  const { keys, records } = data;\n  const myIndex = new FuseIndex({ getFn, fieldNormWeight });\n  myIndex.setKeys(keys);\n  myIndex.setIndexRecords(records);\n  return myIndex\n}\n\nfunction computeScore$1(\n  pattern,\n  {\n    errors = 0,\n    currentLocation = 0,\n    expectedLocation = 0,\n    distance = Config.distance,\n    ignoreLocation = Config.ignoreLocation\n  } = {}\n) {\n  const accuracy = errors / pattern.length;\n\n  if (ignoreLocation) {\n    return accuracy\n  }\n\n  const proximity = Math.abs(expectedLocation - currentLocation);\n\n  if (!distance) {\n    // Dodge divide by zero error.\n    return proximity ? 1.0 : accuracy\n  }\n\n  return accuracy + proximity / distance\n}\n\nfunction convertMaskToIndices(\n  matchmask = [],\n  minMatchCharLength = Config.minMatchCharLength\n) {\n  let indices = [];\n  let start = -1;\n  let end = -1;\n  let i = 0;\n\n  for (let len = matchmask.length; i < len; i += 1) {\n    let match = matchmask[i];\n    if (match && start === -1) {\n      start = i;\n    } else if (!match && start !== -1) {\n      end = i - 1;\n      if (end - start + 1 >= minMatchCharLength) {\n        indices.push([start, end]);\n      }\n      start = -1;\n    }\n  }\n\n  // (i-1 - start) + 1 => i - start\n  if (matchmask[i - 1] && i - start >= minMatchCharLength) {\n    indices.push([start, i - 1]);\n  }\n\n  return indices\n}\n\n// Machine word size\nconst MAX_BITS = 32;\n\nfunction search(\n  text,\n  pattern,\n  patternAlphabet,\n  {\n    location = Config.location,\n    distance = Config.distance,\n    threshold = Config.threshold,\n    findAllMatches = Config.findAllMatches,\n    minMatchCharLength = Config.minMatchCharLength,\n    includeMatches = Config.includeMatches,\n    ignoreLocation = Config.ignoreLocation\n  } = {}\n) {\n  if (pattern.length > MAX_BITS) {\n    throw new Error(PATTERN_LENGTH_TOO_LARGE(MAX_BITS))\n  }\n\n  const patternLen = pattern.length;\n  // Set starting location at beginning text and initialize the alphabet.\n  const textLen = text.length;\n  // Handle the case when location > text.length\n  const expectedLocation = Math.max(0, Math.min(location, textLen));\n  // Highest score beyond which we give up.\n  let currentThreshold = threshold;\n  // Is there a nearby exact match? (speedup)\n  let bestLocation = expectedLocation;\n\n  // Performance: only computer matches when the minMatchCharLength > 1\n  // OR if `includeMatches` is true.\n  const computeMatches = minMatchCharLength > 1 || includeMatches;\n  // A mask of the matches, used for building the indices\n  const matchMask = computeMatches ? Array(textLen) : [];\n\n  let index;\n\n  // Get all exact matches, here for speed up\n  while ((index = text.indexOf(pattern, bestLocation)) > -1) {\n    let score = computeScore$1(pattern, {\n      currentLocation: index,\n      expectedLocation,\n      distance,\n      ignoreLocation\n    });\n\n    currentThreshold = Math.min(score, currentThreshold);\n    bestLocation = index + patternLen;\n\n    if (computeMatches) {\n      let i = 0;\n      while (i < patternLen) {\n        matchMask[index + i] = 1;\n        i += 1;\n      }\n    }\n  }\n\n  // Reset the best location\n  bestLocation = -1;\n\n  let lastBitArr = [];\n  let finalScore = 1;\n  let binMax = patternLen + textLen;\n\n  const mask = 1 << (patternLen - 1);\n\n  for (let i = 0; i < patternLen; i += 1) {\n    // Scan for the best match; each iteration allows for one more error.\n    // Run a binary search to determine how far from the match location we can stray\n    // at this error level.\n    let binMin = 0;\n    let binMid = binMax;\n\n    while (binMin < binMid) {\n      const score = computeScore$1(pattern, {\n        errors: i,\n        currentLocation: expectedLocation + binMid,\n        expectedLocation,\n        distance,\n        ignoreLocation\n      });\n\n      if (score <= currentThreshold) {\n        binMin = binMid;\n      } else {\n        binMax = binMid;\n      }\n\n      binMid = Math.floor((binMax - binMin) / 2 + binMin);\n    }\n\n    // Use the result from this iteration as the maximum for the next.\n    binMax = binMid;\n\n    let start = Math.max(1, expectedLocation - binMid + 1);\n    let finish = findAllMatches\n      ? textLen\n      : Math.min(expectedLocation + binMid, textLen) + patternLen;\n\n    // Initialize the bit array\n    let bitArr = Array(finish + 2);\n\n    bitArr[finish + 1] = (1 << i) - 1;\n\n    for (let j = finish; j >= start; j -= 1) {\n      let currentLocation = j - 1;\n      let charMatch = patternAlphabet[text.charAt(currentLocation)];\n\n      if (computeMatches) {\n        // Speed up: quick bool to int conversion (i.e, `charMatch ? 1 : 0`)\n        matchMask[currentLocation] = +!!charMatch;\n      }\n\n      // First pass: exact match\n      bitArr[j] = ((bitArr[j + 1] << 1) | 1) & charMatch;\n\n      // Subsequent passes: fuzzy match\n      if (i) {\n        bitArr[j] |=\n          ((lastBitArr[j + 1] | lastBitArr[j]) << 1) | 1 | lastBitArr[j + 1];\n      }\n\n      if (bitArr[j] & mask) {\n        finalScore = computeScore$1(pattern, {\n          errors: i,\n          currentLocation,\n          expectedLocation,\n          distance,\n          ignoreLocation\n        });\n\n        // This match will almost certainly be better than any existing match.\n        // But check anyway.\n        if (finalScore <= currentThreshold) {\n          // Indeed it is\n          currentThreshold = finalScore;\n          bestLocation = currentLocation;\n\n          // Already passed `loc`, downhill from here on in.\n          if (bestLocation <= expectedLocation) {\n            break\n          }\n\n          // When passing `bestLocation`, don't exceed our current distance from `expectedLocation`.\n          start = Math.max(1, 2 * expectedLocation - bestLocation);\n        }\n      }\n    }\n\n    // No hope for a (better) match at greater error levels.\n    const score = computeScore$1(pattern, {\n      errors: i + 1,\n      currentLocation: expectedLocation,\n      expectedLocation,\n      distance,\n      ignoreLocation\n    });\n\n    if (score > currentThreshold) {\n      break\n    }\n\n    lastBitArr = bitArr;\n  }\n\n  const result = {\n    isMatch: bestLocation >= 0,\n    // Count exact matches (those with a score of 0) to be \"almost\" exact\n    score: Math.max(0.001, finalScore)\n  };\n\n  if (computeMatches) {\n    const indices = convertMaskToIndices(matchMask, minMatchCharLength);\n    if (!indices.length) {\n      result.isMatch = false;\n    } else if (includeMatches) {\n      result.indices = indices;\n    }\n  }\n\n  return result\n}\n\nfunction createPatternAlphabet(pattern) {\n  let mask = {};\n\n  for (let i = 0, len = pattern.length; i < len; i += 1) {\n    const char = pattern.charAt(i);\n    mask[char] = (mask[char] || 0) | (1 << (len - i - 1));\n  }\n\n  return mask\n}\n\nconst stripDiacritics = String.prototype.normalize\n    ? ((str) => str.normalize('NFD').replace(/[\\u0300-\\u036F\\u0483-\\u0489\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u065F\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07EB-\\u07F3\\u07FD\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0859-\\u085B\\u08D3-\\u08E1\\u08E3-\\u0903\\u093A-\\u093C\\u093E-\\u094F\\u0951-\\u0957\\u0962\\u0963\\u0981-\\u0983\\u09BC\\u09BE-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CD\\u09D7\\u09E2\\u09E3\\u09FE\\u0A01-\\u0A03\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A70\\u0A71\\u0A75\\u0A81-\\u0A83\\u0ABC\\u0ABE-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AE2\\u0AE3\\u0AFA-\\u0AFF\\u0B01-\\u0B03\\u0B3C\\u0B3E-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B62\\u0B63\\u0B82\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD7\\u0C00-\\u0C04\\u0C3E-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0C81-\\u0C83\\u0CBC\\u0CBE-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CE2\\u0CE3\\u0D00-\\u0D03\\u0D3B\\u0D3C\\u0D3E-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4D\\u0D57\\u0D62\\u0D63\\u0D82\\u0D83\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DF2\\u0DF3\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0EB1\\u0EB4-\\u0EB9\\u0EBB\\u0EBC\\u0EC8-\\u0ECD\\u0F18\\u0F19\\u0F35\\u0F37\\u0F39\\u0F3E\\u0F3F\\u0F71-\\u0F84\\u0F86\\u0F87\\u0F8D-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102B-\\u103E\\u1056-\\u1059\\u105E-\\u1060\\u1062-\\u1064\\u1067-\\u106D\\u1071-\\u1074\\u1082-\\u108D\\u108F\\u109A-\\u109D\\u135D-\\u135F\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B4-\\u17D3\\u17DD\\u180B-\\u180D\\u1885\\u1886\\u18A9\\u1920-\\u192B\\u1930-\\u193B\\u1A17-\\u1A1B\\u1A55-\\u1A5E\\u1A60-\\u1A7C\\u1A7F\\u1AB0-\\u1ABE\\u1B00-\\u1B04\\u1B34-\\u1B44\\u1B6B-\\u1B73\\u1B80-\\u1B82\\u1BA1-\\u1BAD\\u1BE6-\\u1BF3\\u1C24-\\u1C37\\u1CD0-\\u1CD2\\u1CD4-\\u1CE8\\u1CED\\u1CF2-\\u1CF4\\u1CF7-\\u1CF9\\u1DC0-\\u1DF9\\u1DFB-\\u1DFF\\u20D0-\\u20F0\\u2CEF-\\u2CF1\\u2D7F\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA66F-\\uA672\\uA674-\\uA67D\\uA69E\\uA69F\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA823-\\uA827\\uA880\\uA881\\uA8B4-\\uA8C5\\uA8E0-\\uA8F1\\uA8FF\\uA926-\\uA92D\\uA947-\\uA953\\uA980-\\uA983\\uA9B3-\\uA9C0\\uA9E5\\uAA29-\\uAA36\\uAA43\\uAA4C\\uAA4D\\uAA7B-\\uAA7D\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uAAEB-\\uAAEF\\uAAF5\\uAAF6\\uABE3-\\uABEA\\uABEC\\uABED\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE2F]/g, ''))\n    : ((str) => str);\n\nclass BitapSearch {\n  constructor(\n    pattern,\n    {\n      location = Config.location,\n      threshold = Config.threshold,\n      distance = Config.distance,\n      includeMatches = Config.includeMatches,\n      findAllMatches = Config.findAllMatches,\n      minMatchCharLength = Config.minMatchCharLength,\n      isCaseSensitive = Config.isCaseSensitive,\n      ignoreDiacritics = Config.ignoreDiacritics,\n      ignoreLocation = Config.ignoreLocation\n    } = {}\n  ) {\n    this.options = {\n      location,\n      threshold,\n      distance,\n      includeMatches,\n      findAllMatches,\n      minMatchCharLength,\n      isCaseSensitive,\n      ignoreDiacritics,\n      ignoreLocation\n    };\n\n    pattern = isCaseSensitive ? pattern : pattern.toLowerCase();\n    pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;\n    this.pattern = pattern;\n\n    this.chunks = [];\n\n    if (!this.pattern.length) {\n      return\n    }\n\n    const addChunk = (pattern, startIndex) => {\n      this.chunks.push({\n        pattern,\n        alphabet: createPatternAlphabet(pattern),\n        startIndex\n      });\n    };\n\n    const len = this.pattern.length;\n\n    if (len > MAX_BITS) {\n      let i = 0;\n      const remainder = len % MAX_BITS;\n      const end = len - remainder;\n\n      while (i < end) {\n        addChunk(this.pattern.substr(i, MAX_BITS), i);\n        i += MAX_BITS;\n      }\n\n      if (remainder) {\n        const startIndex = len - MAX_BITS;\n        addChunk(this.pattern.substr(startIndex), startIndex);\n      }\n    } else {\n      addChunk(this.pattern, 0);\n    }\n  }\n\n  searchIn(text) {\n    const { isCaseSensitive, ignoreDiacritics, includeMatches } = this.options;\n\n    text = isCaseSensitive ? text : text.toLowerCase();\n    text = ignoreDiacritics ? stripDiacritics(text) : text;\n\n    // Exact match\n    if (this.pattern === text) {\n      let result = {\n        isMatch: true,\n        score: 0\n      };\n\n      if (includeMatches) {\n        result.indices = [[0, text.length - 1]];\n      }\n\n      return result\n    }\n\n    // Otherwise, use Bitap algorithm\n    const {\n      location,\n      distance,\n      threshold,\n      findAllMatches,\n      minMatchCharLength,\n      ignoreLocation\n    } = this.options;\n\n    let allIndices = [];\n    let totalScore = 0;\n    let hasMatches = false;\n\n    this.chunks.forEach(({ pattern, alphabet, startIndex }) => {\n      const { isMatch, score, indices } = search(text, pattern, alphabet, {\n        location: location + startIndex,\n        distance,\n        threshold,\n        findAllMatches,\n        minMatchCharLength,\n        includeMatches,\n        ignoreLocation\n      });\n\n      if (isMatch) {\n        hasMatches = true;\n      }\n\n      totalScore += score;\n\n      if (isMatch && indices) {\n        allIndices = [...allIndices, ...indices];\n      }\n    });\n\n    let result = {\n      isMatch: hasMatches,\n      score: hasMatches ? totalScore / this.chunks.length : 1\n    };\n\n    if (hasMatches && includeMatches) {\n      result.indices = allIndices;\n    }\n\n    return result\n  }\n}\n\nclass BaseMatch {\n  constructor(pattern) {\n    this.pattern = pattern;\n  }\n  static isMultiMatch(pattern) {\n    return getMatch(pattern, this.multiRegex)\n  }\n  static isSingleMatch(pattern) {\n    return getMatch(pattern, this.singleRegex)\n  }\n  search(/*text*/) {}\n}\n\nfunction getMatch(pattern, exp) {\n  const matches = pattern.match(exp);\n  return matches ? matches[1] : null\n}\n\n// Token: 'file\n\nclass ExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'exact'\n  }\n  static get multiRegex() {\n    return /^=\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^=(.*)$/\n  }\n  search(text) {\n    const isMatch = text === this.pattern;\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, this.pattern.length - 1]\n    }\n  }\n}\n\n// Token: !fire\n\nclass InverseExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'inverse-exact'\n  }\n  static get multiRegex() {\n    return /^!\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^!(.*)$/\n  }\n  search(text) {\n    const index = text.indexOf(this.pattern);\n    const isMatch = index === -1;\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, text.length - 1]\n    }\n  }\n}\n\n// Token: ^file\n\nclass PrefixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'prefix-exact'\n  }\n  static get multiRegex() {\n    return /^\\^\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^\\^(.*)$/\n  }\n  search(text) {\n    const isMatch = text.startsWith(this.pattern);\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, this.pattern.length - 1]\n    }\n  }\n}\n\n// Token: !^fire\n\nclass InversePrefixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'inverse-prefix-exact'\n  }\n  static get multiRegex() {\n    return /^!\\^\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^!\\^(.*)$/\n  }\n  search(text) {\n    const isMatch = !text.startsWith(this.pattern);\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, text.length - 1]\n    }\n  }\n}\n\n// Token: .file$\n\nclass SuffixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'suffix-exact'\n  }\n  static get multiRegex() {\n    return /^\"(.*)\"\\$$/\n  }\n  static get singleRegex() {\n    return /^(.*)\\$$/\n  }\n  search(text) {\n    const isMatch = text.endsWith(this.pattern);\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [text.length - this.pattern.length, text.length - 1]\n    }\n  }\n}\n\n// Token: !.file$\n\nclass InverseSuffixExactMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'inverse-suffix-exact'\n  }\n  static get multiRegex() {\n    return /^!\"(.*)\"\\$$/\n  }\n  static get singleRegex() {\n    return /^!(.*)\\$$/\n  }\n  search(text) {\n    const isMatch = !text.endsWith(this.pattern);\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices: [0, text.length - 1]\n    }\n  }\n}\n\nclass FuzzyMatch extends BaseMatch {\n  constructor(\n    pattern,\n    {\n      location = Config.location,\n      threshold = Config.threshold,\n      distance = Config.distance,\n      includeMatches = Config.includeMatches,\n      findAllMatches = Config.findAllMatches,\n      minMatchCharLength = Config.minMatchCharLength,\n      isCaseSensitive = Config.isCaseSensitive,\n      ignoreDiacritics = Config.ignoreDiacritics,\n      ignoreLocation = Config.ignoreLocation\n    } = {}\n  ) {\n    super(pattern);\n    this._bitapSearch = new BitapSearch(pattern, {\n      location,\n      threshold,\n      distance,\n      includeMatches,\n      findAllMatches,\n      minMatchCharLength,\n      isCaseSensitive,\n      ignoreDiacritics,\n      ignoreLocation\n    });\n  }\n  static get type() {\n    return 'fuzzy'\n  }\n  static get multiRegex() {\n    return /^\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^(.*)$/\n  }\n  search(text) {\n    return this._bitapSearch.searchIn(text)\n  }\n}\n\n// Token: 'file\n\nclass IncludeMatch extends BaseMatch {\n  constructor(pattern) {\n    super(pattern);\n  }\n  static get type() {\n    return 'include'\n  }\n  static get multiRegex() {\n    return /^'\"(.*)\"$/\n  }\n  static get singleRegex() {\n    return /^'(.*)$/\n  }\n  search(text) {\n    let location = 0;\n    let index;\n\n    const indices = [];\n    const patternLen = this.pattern.length;\n\n    // Get all exact matches\n    while ((index = text.indexOf(this.pattern, location)) > -1) {\n      location = index + patternLen;\n      indices.push([index, location - 1]);\n    }\n\n    const isMatch = !!indices.length;\n\n    return {\n      isMatch,\n      score: isMatch ? 0 : 1,\n      indices\n    }\n  }\n}\n\n// ❗Order is important. DO NOT CHANGE.\nconst searchers = [\n  ExactMatch,\n  IncludeMatch,\n  PrefixExactMatch,\n  InversePrefixExactMatch,\n  InverseSuffixExactMatch,\n  SuffixExactMatch,\n  InverseExactMatch,\n  FuzzyMatch\n];\n\nconst searchersLen = searchers.length;\n\n// Regex to split by spaces, but keep anything in quotes together\nconst SPACE_RE = / +(?=(?:[^\\\"]*\\\"[^\\\"]*\\\")*[^\\\"]*$)/;\nconst OR_TOKEN = '|';\n\n// Return a 2D array representation of the query, for simpler parsing.\n// Example:\n// \"^core go$ | rb$ | py$ xy$\" => [[\"^core\", \"go$\"], [\"rb$\"], [\"py$\", \"xy$\"]]\nfunction parseQuery(pattern, options = {}) {\n  return pattern.split(OR_TOKEN).map((item) => {\n    let query = item\n      .trim()\n      .split(SPACE_RE)\n      .filter((item) => item && !!item.trim());\n\n    let results = [];\n    for (let i = 0, len = query.length; i < len; i += 1) {\n      const queryItem = query[i];\n\n      // 1. Handle multiple query match (i.e, once that are quoted, like `\"hello world\"`)\n      let found = false;\n      let idx = -1;\n      while (!found && ++idx < searchersLen) {\n        const searcher = searchers[idx];\n        let token = searcher.isMultiMatch(queryItem);\n        if (token) {\n          results.push(new searcher(token, options));\n          found = true;\n        }\n      }\n\n      if (found) {\n        continue\n      }\n\n      // 2. Handle single query matches (i.e, once that are *not* quoted)\n      idx = -1;\n      while (++idx < searchersLen) {\n        const searcher = searchers[idx];\n        let token = searcher.isSingleMatch(queryItem);\n        if (token) {\n          results.push(new searcher(token, options));\n          break\n        }\n      }\n    }\n\n    return results\n  })\n}\n\n// These extended matchers can return an array of matches, as opposed\n// to a singl match\nconst MultiMatchSet = new Set([FuzzyMatch.type, IncludeMatch.type]);\n\n/**\n * Command-like searching\n * ======================\n *\n * Given multiple search terms delimited by spaces.e.g. `^jscript .python$ ruby !java`,\n * search in a given text.\n *\n * Search syntax:\n *\n * | Token       | Match type                 | Description                            |\n * | ----------- | -------------------------- | -------------------------------------- |\n * | `jscript`   | fuzzy-match                | Items that fuzzy match `jscript`       |\n * | `=scheme`   | exact-match                | Items that are `scheme`                |\n * | `'python`   | include-match              | Items that include `python`            |\n * | `!ruby`     | inverse-exact-match        | Items that do not include `ruby`       |\n * | `^java`     | prefix-exact-match         | Items that start with `java`           |\n * | `!^earlang` | inverse-prefix-exact-match | Items that do not start with `earlang` |\n * | `.js$`      | suffix-exact-match         | Items that end with `.js`              |\n * | `!.go$`     | inverse-suffix-exact-match | Items that do not end with `.go`       |\n *\n * A single pipe character acts as an OR operator. For example, the following\n * query matches entries that start with `core` and end with either`go`, `rb`,\n * or`py`.\n *\n * ```\n * ^core go$ | rb$ | py$\n * ```\n */\nclass ExtendedSearch {\n  constructor(\n    pattern,\n    {\n      isCaseSensitive = Config.isCaseSensitive,\n      ignoreDiacritics = Config.ignoreDiacritics,\n      includeMatches = Config.includeMatches,\n      minMatchCharLength = Config.minMatchCharLength,\n      ignoreLocation = Config.ignoreLocation,\n      findAllMatches = Config.findAllMatches,\n      location = Config.location,\n      threshold = Config.threshold,\n      distance = Config.distance\n    } = {}\n  ) {\n    this.query = null;\n    this.options = {\n      isCaseSensitive,\n      ignoreDiacritics,\n      includeMatches,\n      minMatchCharLength,\n      findAllMatches,\n      ignoreLocation,\n      location,\n      threshold,\n      distance\n    };\n\n    pattern = isCaseSensitive ? pattern : pattern.toLowerCase();\n    pattern = ignoreDiacritics ? stripDiacritics(pattern) : pattern;\n    this.pattern = pattern;\n    this.query = parseQuery(this.pattern, this.options);\n  }\n\n  static condition(_, options) {\n    return options.useExtendedSearch\n  }\n\n  searchIn(text) {\n    const query = this.query;\n\n    if (!query) {\n      return {\n        isMatch: false,\n        score: 1\n      }\n    }\n\n    const { includeMatches, isCaseSensitive, ignoreDiacritics } = this.options;\n\n    text = isCaseSensitive ? text : text.toLowerCase();\n    text = ignoreDiacritics ? stripDiacritics(text) : text;\n\n    let numMatches = 0;\n    let allIndices = [];\n    let totalScore = 0;\n\n    // ORs\n    for (let i = 0, qLen = query.length; i < qLen; i += 1) {\n      const searchers = query[i];\n\n      // Reset indices\n      allIndices.length = 0;\n      numMatches = 0;\n\n      // ANDs\n      for (let j = 0, pLen = searchers.length; j < pLen; j += 1) {\n        const searcher = searchers[j];\n        const { isMatch, indices, score } = searcher.search(text);\n\n        if (isMatch) {\n          numMatches += 1;\n          totalScore += score;\n          if (includeMatches) {\n            const type = searcher.constructor.type;\n            if (MultiMatchSet.has(type)) {\n              allIndices = [...allIndices, ...indices];\n            } else {\n              allIndices.push(indices);\n            }\n          }\n        } else {\n          totalScore = 0;\n          numMatches = 0;\n          allIndices.length = 0;\n          break\n        }\n      }\n\n      // OR condition, so if TRUE, return\n      if (numMatches) {\n        let result = {\n          isMatch: true,\n          score: totalScore / numMatches\n        };\n\n        if (includeMatches) {\n          result.indices = allIndices;\n        }\n\n        return result\n      }\n    }\n\n    // Nothing was matched\n    return {\n      isMatch: false,\n      score: 1\n    }\n  }\n}\n\nconst registeredSearchers = [];\n\nfunction register(...args) {\n  registeredSearchers.push(...args);\n}\n\nfunction createSearcher(pattern, options) {\n  for (let i = 0, len = registeredSearchers.length; i < len; i += 1) {\n    let searcherClass = registeredSearchers[i];\n    if (searcherClass.condition(pattern, options)) {\n      return new searcherClass(pattern, options)\n    }\n  }\n\n  return new BitapSearch(pattern, options)\n}\n\nconst LogicalOperator = {\n  AND: '$and',\n  OR: '$or'\n};\n\nconst KeyType = {\n  PATH: '$path',\n  PATTERN: '$val'\n};\n\nconst isExpression = (query) =>\n  !!(query[LogicalOperator.AND] || query[LogicalOperator.OR]);\n\nconst isPath = (query) => !!query[KeyType.PATH];\n\nconst isLeaf = (query) =>\n  !isArray(query) && isObject(query) && !isExpression(query);\n\nconst convertToExplicit = (query) => ({\n  [LogicalOperator.AND]: Object.keys(query).map((key) => ({\n    [key]: query[key]\n  }))\n});\n\n// When `auto` is `true`, the parse function will infer and initialize and add\n// the appropriate `Searcher` instance\nfunction parse(query, options, { auto = true } = {}) {\n  const next = (query) => {\n    let keys = Object.keys(query);\n\n    const isQueryPath = isPath(query);\n\n    if (!isQueryPath && keys.length > 1 && !isExpression(query)) {\n      return next(convertToExplicit(query))\n    }\n\n    if (isLeaf(query)) {\n      const key = isQueryPath ? query[KeyType.PATH] : keys[0];\n\n      const pattern = isQueryPath ? query[KeyType.PATTERN] : query[key];\n\n      if (!isString(pattern)) {\n        throw new Error(LOGICAL_SEARCH_INVALID_QUERY_FOR_KEY(key))\n      }\n\n      const obj = {\n        keyId: createKeyId(key),\n        pattern\n      };\n\n      if (auto) {\n        obj.searcher = createSearcher(pattern, options);\n      }\n\n      return obj\n    }\n\n    let node = {\n      children: [],\n      operator: keys[0]\n    };\n\n    keys.forEach((key) => {\n      const value = query[key];\n\n      if (isArray(value)) {\n        value.forEach((item) => {\n          node.children.push(next(item));\n        });\n      }\n    });\n\n    return node\n  };\n\n  if (!isExpression(query)) {\n    query = convertToExplicit(query);\n  }\n\n  return next(query)\n}\n\n// Practical scoring function\nfunction computeScore(\n  results,\n  { ignoreFieldNorm = Config.ignoreFieldNorm }\n) {\n  results.forEach((result) => {\n    let totalScore = 1;\n\n    result.matches.forEach(({ key, norm, score }) => {\n      const weight = key ? key.weight : null;\n\n      totalScore *= Math.pow(\n        score === 0 && weight ? Number.EPSILON : score,\n        (weight || 1) * (ignoreFieldNorm ? 1 : norm)\n      );\n    });\n\n    result.score = totalScore;\n  });\n}\n\nfunction transformMatches(result, data) {\n  const matches = result.matches;\n  data.matches = [];\n\n  if (!isDefined(matches)) {\n    return\n  }\n\n  matches.forEach((match) => {\n    if (!isDefined(match.indices) || !match.indices.length) {\n      return\n    }\n\n    const { indices, value } = match;\n\n    let obj = {\n      indices,\n      value\n    };\n\n    if (match.key) {\n      obj.key = match.key.src;\n    }\n\n    if (match.idx > -1) {\n      obj.refIndex = match.idx;\n    }\n\n    data.matches.push(obj);\n  });\n}\n\nfunction transformScore(result, data) {\n  data.score = result.score;\n}\n\nfunction format(\n  results,\n  docs,\n  {\n    includeMatches = Config.includeMatches,\n    includeScore = Config.includeScore\n  } = {}\n) {\n  const transformers = [];\n\n  if (includeMatches) transformers.push(transformMatches);\n  if (includeScore) transformers.push(transformScore);\n\n  return results.map((result) => {\n    const { idx } = result;\n\n    const data = {\n      item: docs[idx],\n      refIndex: idx\n    };\n\n    if (transformers.length) {\n      transformers.forEach((transformer) => {\n        transformer(result, data);\n      });\n    }\n\n    return data\n  })\n}\n\nclass Fuse {\n  constructor(docs, options = {}, index) {\n    this.options = { ...Config, ...options };\n\n    if (\n      this.options.useExtendedSearch &&\n      !true\n    ) {\n      throw new Error(EXTENDED_SEARCH_UNAVAILABLE)\n    }\n\n    this._keyStore = new KeyStore(this.options.keys);\n\n    this.setCollection(docs, index);\n  }\n\n  setCollection(docs, index) {\n    this._docs = docs;\n\n    if (index && !(index instanceof FuseIndex)) {\n      throw new Error(INCORRECT_INDEX_TYPE)\n    }\n\n    this._myIndex =\n      index ||\n      createIndex(this.options.keys, this._docs, {\n        getFn: this.options.getFn,\n        fieldNormWeight: this.options.fieldNormWeight\n      });\n  }\n\n  add(doc) {\n    if (!isDefined(doc)) {\n      return\n    }\n\n    this._docs.push(doc);\n    this._myIndex.add(doc);\n  }\n\n  remove(predicate = (/* doc, idx */) => false) {\n    const results = [];\n\n    for (let i = 0, len = this._docs.length; i < len; i += 1) {\n      const doc = this._docs[i];\n      if (predicate(doc, i)) {\n        this.removeAt(i);\n        i -= 1;\n        len -= 1;\n\n        results.push(doc);\n      }\n    }\n\n    return results\n  }\n\n  removeAt(idx) {\n    this._docs.splice(idx, 1);\n    this._myIndex.removeAt(idx);\n  }\n\n  getIndex() {\n    return this._myIndex\n  }\n\n  search(query, { limit = -1 } = {}) {\n    const {\n      includeMatches,\n      includeScore,\n      shouldSort,\n      sortFn,\n      ignoreFieldNorm\n    } = this.options;\n\n    let results = isString(query)\n      ? isString(this._docs[0])\n        ? this._searchStringList(query)\n        : this._searchObjectList(query)\n      : this._searchLogical(query);\n\n    computeScore(results, { ignoreFieldNorm });\n\n    if (shouldSort) {\n      results.sort(sortFn);\n    }\n\n    if (isNumber(limit) && limit > -1) {\n      results = results.slice(0, limit);\n    }\n\n    return format(results, this._docs, {\n      includeMatches,\n      includeScore\n    })\n  }\n\n  _searchStringList(query) {\n    const searcher = createSearcher(query, this.options);\n    const { records } = this._myIndex;\n    const results = [];\n\n    // Iterate over every string in the index\n    records.forEach(({ v: text, i: idx, n: norm }) => {\n      if (!isDefined(text)) {\n        return\n      }\n\n      const { isMatch, score, indices } = searcher.searchIn(text);\n\n      if (isMatch) {\n        results.push({\n          item: text,\n          idx,\n          matches: [{ score, value: text, norm, indices }]\n        });\n      }\n    });\n\n    return results\n  }\n\n  _searchLogical(query) {\n\n    const expression = parse(query, this.options);\n\n    const evaluate = (node, item, idx) => {\n      if (!node.children) {\n        const { keyId, searcher } = node;\n\n        const matches = this._findMatches({\n          key: this._keyStore.get(keyId),\n          value: this._myIndex.getValueForItemAtKeyId(item, keyId),\n          searcher\n        });\n\n        if (matches && matches.length) {\n          return [\n            {\n              idx,\n              item,\n              matches\n            }\n          ]\n        }\n\n        return []\n      }\n\n      const res = [];\n      for (let i = 0, len = node.children.length; i < len; i += 1) {\n        const child = node.children[i];\n        const result = evaluate(child, item, idx);\n        if (result.length) {\n          res.push(...result);\n        } else if (node.operator === LogicalOperator.AND) {\n          return []\n        }\n      }\n      return res\n    };\n\n    const records = this._myIndex.records;\n    const resultMap = {};\n    const results = [];\n\n    records.forEach(({ $: item, i: idx }) => {\n      if (isDefined(item)) {\n        let expResults = evaluate(expression, item, idx);\n\n        if (expResults.length) {\n          // Dedupe when adding\n          if (!resultMap[idx]) {\n            resultMap[idx] = { idx, item, matches: [] };\n            results.push(resultMap[idx]);\n          }\n          expResults.forEach(({ matches }) => {\n            resultMap[idx].matches.push(...matches);\n          });\n        }\n      }\n    });\n\n    return results\n  }\n\n  _searchObjectList(query) {\n    const searcher = createSearcher(query, this.options);\n    const { keys, records } = this._myIndex;\n    const results = [];\n\n    // List is Array<Object>\n    records.forEach(({ $: item, i: idx }) => {\n      if (!isDefined(item)) {\n        return\n      }\n\n      let matches = [];\n\n      // Iterate over every key (i.e, path), and fetch the value at that key\n      keys.forEach((key, keyIndex) => {\n        matches.push(\n          ...this._findMatches({\n            key,\n            value: item[keyIndex],\n            searcher\n          })\n        );\n      });\n\n      if (matches.length) {\n        results.push({\n          idx,\n          item,\n          matches\n        });\n      }\n    });\n\n    return results\n  }\n  _findMatches({ key, value, searcher }) {\n    if (!isDefined(value)) {\n      return []\n    }\n\n    let matches = [];\n\n    if (isArray(value)) {\n      value.forEach(({ v: text, i: idx, n: norm }) => {\n        if (!isDefined(text)) {\n          return\n        }\n\n        const { isMatch, score, indices } = searcher.searchIn(text);\n\n        if (isMatch) {\n          matches.push({\n            score,\n            key,\n            value: text,\n            idx,\n            norm,\n            indices\n          });\n        }\n      });\n    } else {\n      const { v: text, n: norm } = value;\n\n      const { isMatch, score, indices } = searcher.searchIn(text);\n\n      if (isMatch) {\n        matches.push({ score, key, value: text, norm, indices });\n      }\n    }\n\n    return matches\n  }\n}\n\nFuse.version = '7.1.0';\nFuse.createIndex = createIndex;\nFuse.parseIndex = parseIndex;\nFuse.config = Config;\n\n{\n  Fuse.parseQuery = parse;\n}\n\n{\n  register(ExtendedSearch);\n}\n\nexport { Fuse as default };\n","import { useState, useCallback, useRef, useMemo } from \"react\";\nimport { useAtomValue } from \"jotai\";\nimport Fuse from \"fuse.js\";\n\nimport { autocompleteStateAtom } from \"src/atoms/globalSearch\";\nimport { amplitudeTrackEventAtom } from \"src/atoms/amplitude/amplitudeTrackEventAtom\";\nimport { SpiffyMetricsEventName } from \"src/contexts/amplitudeContext\";\nimport { SpiffyWidgets } from \"src/application/models/spiffyWidgets\";\n\nexport interface UseSearchInputProps {\n  initialSearchText?: string;\n  searchOrigin: SpiffyWidgets;\n  onSearchSubmit?: (query: string) => void;\n}\n\nexport interface UseSearchInputReturn {\n  // State\n  searchText: string;\n  hasText: boolean;\n  isFocused: boolean;\n  focusedIndex: number;\n  focusedOptionId: string | undefined;\n  autocompleteResults: string[];\n  shouldShowAutocomplete: boolean;\n  \n  // Handlers\n  handleSearchInputChange: (value: string) => void;\n  handleSearchInputFocus: () => void;\n  handleSearchInputBlur: () => void;\n  handleKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;\n  handleAutocompleteSelect: (suggestion: string, rankPosition?: number) => void;\n  handleSubmitSearch: () => void;\n  \n  // Utilities\n  setSearchText: (text: string) => void;\n  resetSearch: () => void;\n}\n\nexport const useSearchInput = ({\n  initialSearchText = \"\",\n  searchOrigin,\n  onSearchSubmit,\n}: UseSearchInputProps): UseSearchInputReturn => {\n  const track = useAtomValue(amplitudeTrackEventAtom);\n\n  // State\n  const [searchText, setSearchText] = useState(initialSearchText);\n  const [hasText, setHasText] = useState(initialSearchText.trim().length > 0);\n  const [isFocused, setIsFocused] = useState(false);\n  const [focusedIndex, setFocusedIndex] = useState(-1);\n  const [focusedOptionId, setFocusedOptionId] = useState<string | undefined>(\n    undefined\n  );\n  const autocompleteState = useAtomValue(autocompleteStateAtom);\n  const globalAutocompleteResults = autocompleteState.results;\n  const isAutocompleteEnabled = globalAutocompleteResults.length > 0;\n\n  // Refs\n  const isSelectingAutocomplete = useRef(false);\n\n  // Computed\n  const shouldShowAutocomplete = hasText && isFocused && isAutocompleteEnabled;\n\n  const autocompleteResultsLimit = 5;\n\n  // Configure Fuse.js for fuzzy search with custom scoring\n  const fuseOptions = useMemo(\n    () => ({\n      includeScore: true,\n      includeMatches: true,\n      // Fuzzy matching threshold (0.0 = perfect match, 1.0 = match anything)\n      threshold: 0.3,\n      // Location where match is expected (0 = beginning)\n      location: 0,\n      // Distance from location where match can be found - smaller for prefix preference\n      distance: 4,\n      // Minimum character length before fuzzy matching starts\n      minMatchCharLength: 1,\n      // Keys to search (we're searching strings directly, so no keys needed)\n      keys: [],\n      // Use extended search for exact matches and prefix matching\n      useExtendedSearch: false,\n      // Don't ignore location - this helps prioritize matches at the beginning\n      ignoreLocation: false,\n    }),\n    []\n  );\n\n  const fuse = useMemo(() => {\n    if (!globalAutocompleteResults.length) return null;\n    return new Fuse(globalAutocompleteResults, fuseOptions);\n  }, [globalAutocompleteResults, fuseOptions]);\n\n  // Autocomplete fuzzy search using Fuse.js\n  const autocompleteResults = useMemo(() => {\n    if (!isAutocompleteEnabled || !fuse) {\n      return [];\n    }\n\n    if (!searchText.trim()) {\n      return [];\n    }\n\n    const fuseResults = fuse.search(searchText);\n\n    // Use only Fuse.js scoring (results are already sorted by relevance)\n    return fuseResults\n      .slice(0, autocompleteResultsLimit)\n      .map((result) => result.item);\n  }, [isAutocompleteEnabled, fuse, searchText, autocompleteResultsLimit]);\n\n  // Handlers\n  const handleSearchInputChange = useCallback(\n    (newValue: string) => {\n      // If the user is changing text, they must be interacting with the input\n      // So we can safely assume they're focused\n      if (newValue !== searchText) {\n        setIsFocused(true);\n      }\n\n      if (newValue.length === 1) {\n        track?.({\n          eventName: SpiffyMetricsEventName.SearchInputStarted,\n          eventProps: {\n            searchOrigin,\n          },\n        });\n      }\n      setSearchText(newValue);\n      setHasText(newValue.trim().length > 0);\n      setFocusedIndex(-1);\n      setFocusedOptionId(undefined);\n    },\n    [searchOrigin, searchText, track]\n  );\n\n  const handleSearchInputFocus = useCallback(() => {\n    setIsFocused(true);\n  }, []);\n\n  const handleSearchInputBlur = useCallback(() => {\n    setTimeout(() => {\n      if (!isSelectingAutocomplete.current) {\n        setIsFocused(false);\n        setFocusedIndex(-1);\n        setFocusedOptionId(undefined);\n      }\n    }, 150);\n  }, []);\n\n  const handleSubmitSearch = useCallback(() => {\n    setIsFocused(false);\n    if (searchText.trim() && onSearchSubmit) {\n      track?.({\n        eventName: SpiffyMetricsEventName.SearchQuerySubmitted,\n        eventProps: {\n          searchOrigin,\n          queryText: searchText.trim(),\n        },\n        alsoSendToGoogleAnalytics: true,\n      });\n      onSearchSubmit(searchText.trim());\n    }\n  }, [searchText, onSearchSubmit, searchOrigin, track]);\n\n  const handleAutocompleteSelect = useCallback(\n    (suggestion: string, rankPosition?: number) => {\n      isSelectingAutocomplete.current = true;\n      setSearchText(suggestion);\n      setHasText(suggestion.trim().length > 0);\n      setIsFocused(false);\n\n      track?.({\n        eventName: SpiffyMetricsEventName.SearchInputStarted,\n        eventProps: {\n          searchOrigin,\n        },\n      });\n\n      if (onSearchSubmit) {\n        onSearchSubmit(suggestion.trim());\n      }\n\n      setTimeout(() => {\n        isSelectingAutocomplete.current = false;\n      }, 100);\n    },\n    [onSearchSubmit, searchOrigin, track]\n  );\n\n  const handleKeyDown = useCallback(\n    (event: React.KeyboardEvent<HTMLInputElement>) => {\n      if (event.key === \"ArrowDown\") {\n        event.preventDefault();\n        const newIndex = (focusedIndex + 1) % autocompleteResults.length;\n        setFocusedIndex(newIndex);\n        setFocusedOptionId(`option-${newIndex}`);\n      } else if (event.key === \"ArrowUp\") {\n        event.preventDefault();\n        const newIndex =\n          (focusedIndex - 1 + autocompleteResults.length) %\n          autocompleteResults.length;\n        setFocusedIndex(newIndex);\n        setFocusedOptionId(`option-${newIndex}`);\n      } else if (event.key === \"Enter\") {\n        if (focusedIndex === -1) {\n          event.preventDefault();\n          handleSubmitSearch();\n        } else {\n          event.preventDefault();\n          const suggestionText = autocompleteResults[focusedIndex];\n          handleAutocompleteSelect(suggestionText, focusedIndex);\n        }\n      } else if (event.key === \"Escape\") {\n        event.preventDefault();\n        setFocusedIndex(-1);\n        setFocusedOptionId(undefined);\n      }\n    },\n    [\n      autocompleteResults,\n      focusedIndex,\n      handleAutocompleteSelect,\n      handleSubmitSearch,\n    ]\n  );\n\n  const setSearchTextUtility = useCallback((text: string) => {\n    setSearchText(text);\n    setHasText(text.trim().length > 0);\n  }, []);\n\n  const resetSearch = useCallback(() => {\n    setSearchText(\"\");\n    setHasText(false);\n    setIsFocused(false);\n    setFocusedIndex(-1);\n    setFocusedOptionId(undefined);\n  }, []);\n\n  return {\n    // State\n    searchText,\n    hasText,\n    isFocused,\n    focusedIndex,\n    focusedOptionId,\n    autocompleteResults,\n    shouldShowAutocomplete,\n\n    // Handlers\n    handleSearchInputChange,\n    handleSearchInputFocus,\n    handleSearchInputBlur,\n    handleKeyDown,\n    handleAutocompleteSelect,\n    handleSubmitSearch,\n\n    // Utilities\n    setSearchText: setSearchTextUtility,\n    resetSearch,\n  };\n};","import { ProductRetrievalParams, ProductRetrievalResult } from \"./types\";\n\n// This will be set by the ProductRetrievalProvider when it initializes\nlet productRetrievalFunction:\n  | ((params: ProductRetrievalParams) => Promise<ProductRetrievalResult>)\n  | null = null;\n\nexport const setProductRetrievalFunction = (\n  fn: (params: ProductRetrievalParams) => Promise<ProductRetrievalResult>\n) => {\n  productRetrievalFunction = fn;\n};\n\nexport const getProductRetrievalFunction = () => {\n  if (!productRetrievalFunction) {\n    throw new Error(\n      \"Product retrieval function not initialized. Make sure ProductRetrievalProvider is mounted.\"\n    );\n  }\n  return productRetrievalFunction;\n};\n\nexport const clearProductRetrievalFunction = () => {\n  productRetrievalFunction = null;\n};","\nimport { atom } from \"jotai\";\nimport { getProductRetrievalFunction } from \"./productRetrievalAdapter\";\nimport { ProductRetrievalParams, ProductRetrievalResult } from \"./types\";\n\ninterface ProductRetrievalState {\n  data: ProductRetrievalResult | null;\n  loading: boolean;\n  error: string | null;\n  lastProductIds: string[] | null;\n}\n\nexport const productRetrievalAtom = atom<ProductRetrievalState>({\n  data: null,\n  loading: false,\n  error: null,\n  lastProductIds: null,\n});\n\nexport const performProductRetrievalAtom = atom(\n  null,\n  async (get, set, params: ProductRetrievalParams) => {\n    const currentState = get(productRetrievalAtom);\n\n    if (currentState.loading) {\n      return; // Prevent concurrent retrievals\n    }\n\n    set(productRetrievalAtom, {\n      data: null,\n      loading: true,\n      error: null,\n      lastProductIds: params.productIds,\n    });\n\n    try {\n      const retrieveProducts = getProductRetrievalFunction();\n      const result = await retrieveProducts(params);\n      set(productRetrievalAtom, {\n        data: result,\n        loading: false,\n        error: null,\n        lastProductIds: params.productIds,\n      });\n    } catch (error: unknown) {\n      const errorMessage =\n        error instanceof Error ? error.message : \"An unknown error occurred\";\n      set(productRetrievalAtom, {\n        data: null,\n        loading: false,\n        error: errorMessage,\n        lastProductIds: params.productIds,\n      });\n    }\n  }\n);\n\n// Get just the products array (already normalized by service)\nexport const retrievedProductsAtom = atom((get) => {\n  const retrievalData = get(productRetrievalAtom).data;\n  return retrievalData?.products || [];\n});\n\nexport const productRetrievalLoadingAtom = atom((get) => {\n  return get(productRetrievalAtom).loading;\n});\n\nexport const productRetrievalErrorAtom = atom((get) => {\n  return get(productRetrievalAtom).error;\n});","import { useAtomValue, useSetAtom } from \"jotai\";\nimport { useEffect } from \"react\";\nimport { useFeatureFlagService } from \"src/contexts/featureFlagServiceContext/featureFlagServiceContext\";\nimport {\n  retrievedProductsAtom,\n  performProductRetrievalAtom,\n  productRetrievalAtom,\n} from \"src/atoms/search/productRetrievalAPI\";\nimport { useNewOrgConfig } from \"../NewOrgConfig\";\nimport { SearchResponseProductAttributes } from \"src/application/models/api/response\";\nimport { FeatureGates } from \"src/application/models\";\n\n/**\n * A hook to get recommended products.\n * It checks the `IsRecommendedProductsEnabled` feature gate and triggers fetching if needed.\n * If the gate is enabled, it returns the list of recommended products.\n * If the gate is disabled, it returns an empty array.\n *\n * @returns The list of recommended products or an empty array.\n */\nexport const useRecommendedProducts =\n  (): SearchResponseProductAttributes[\"attributes\"][] => {\n    const { featureFlagService } = useFeatureFlagService();\n    const isEnabled = featureFlagService?.isFeatureGateEnabled(\n      FeatureGates.IsRecommendedProductsEnabled\n    );\n    const recommendedProducts = useAtomValue(retrievedProductsAtom);\n    const performProductRetrieval = useSetAtom(performProductRetrievalAtom);\n    const { lastProductIds } = useAtomValue(productRetrievalAtom);\n    const orgUIConfig = useNewOrgConfig();\n\n    useEffect(() => {\n      const recommendedProductIds = orgUIConfig.frontendConfig?.uiConfigs?.searchConfig\n        ? orgUIConfig.frontendConfig?.uiConfigs?.searchConfig.recommendedProducts\n        : [];\n      // Fetch only if the feature is enabled, there are IDs to fetch, and we haven't already fetched them.\n      if (\n        isEnabled &&\n        recommendedProductIds &&\n        recommendedProductIds.length > 0 &&\n        !lastProductIds\n      ) {\n        performProductRetrieval({ productIds: recommendedProductIds });\n      }\n    }, [isEnabled, performProductRetrieval, lastProductIds, orgUIConfig]);\n\n    return isEnabled ? recommendedProducts : [];\n  };","import { useAtom, useAtomValue, useSetAtom } from \"jotai\";\nimport { useCallback, useEffect, useMemo, useRef } from \"react\";\n\nimport {\n  addSearchFilterAtom,\n  clearSearchFiltersAtom,\n  createFilterOption,\n  filteredSearchProductsAtom,\n  performSearchAtom,\n  removeSearchFilterAtom,\n  searchAtom,\n  searchFiltersAtom,\n  searchParamsAtom,\n  searchProductSortingAtom,\n  searchSelectedFiltersAtom,\n  SelectedFilterOption,\n} from \"src/atoms/search\";\nimport {\n  isFilterOpenAtom,\n} from \"src/atoms/globalSearch/globalSearch\";\nimport { formatFilterDisplayName } from \"src/atoms/search/utils\";\nimport { ProductSorting } from \"src/atoms/search/types\";\nimport {\n  SpiffyMetricsEventName,\n  useAmplitude,\n} from \"src/contexts/amplitudeContext/amplitudeContext\";\nimport { SpiffyWidgets } from \"src/application/models/spiffyWidgets\";\nimport { ProductCardConfig } from \"src/contexts/types\";\nimport { SearchResult } from \"src/application/models/api/search\";\nimport { SearchResponseProduct } from \"@spiffy-ai/commerce-api-client\";\nimport {\n  SearchFilterDatum,\n  SelectFilterItem,\n} from \"src/types/search-filter-types\";\nimport { getSearchResultsState, SearchResultsState } from \"../utils\";\nimport { orgShortNameAtom } from \"src/atoms/envive/enviveConfig\";\nimport { useTrackComponentVisibleEvent } from \"../TrackComponentVisibleEvent\";\nimport { amplitudeTrackEventAtom } from \"src/atoms/amplitude/amplitudeTrackEventAtom\";\nimport { newOrgConfigAtom } from \"src/atoms/org\";\nimport { retrievedProductsAtom } from \"src/atoms/search/productRetrievalAPI\";\nimport { useSearchInput } from \"./useSearchInput\";\nimport { SearchResponseProductAttributes } from \"src/application/models\";\nimport { useNewOrgConfig } from \"../NewOrgConfig\";\nimport { useRecommendedProducts } from \"./useRecommendedProducts\";\n\nexport interface SearchResultsHocProps {\n  // Data\n  searchData: SearchResult | null;\n  searchResponseId: string;\n  merchantShortName: string;\n  productCardConfig: ProductCardConfig;\n  productList: SearchResponseProduct[];\n  autocompleteResults: string[];\n  searchFilters: SearchFilterDatum[];\n  availableDynamicFilters: { name: string; displayName: string }[];\n  selectedFilterOptions: SelectedFilterOption[];\n  recommendedProducts: SearchResponseProductAttributes['attributes'][];\n\n  // State\n  searchText: string;\n  query: string;\n  searchResultsState: SearchResultsState;\n  isLoadingSearch: boolean;\n  isFilterOpen: boolean;\n  shouldShowAutocomplete: boolean;\n  focusedIndex: number;\n  focusedOptionId: string | undefined;\n\n  // UI\n  filterButtonText: string;\n\n  // Event Handlers\n  onSearchInputChange: (value: string) => void;\n  onSubmitSearch: () => void;\n  onAutocompleteSelect: (suggestion: string) => void;\n  onKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void;\n  onSearchInputFocus: () => void;\n  onSearchInputBlur: () => void;\n  onToggleDynamicFilter: ({ filter, dynamicFilterDisplayName }: { filter: string; dynamicFilterDisplayName: string }) => void;\n  onSelectFilterItem: SelectFilterItem;\n  onRemoveFilter: (filter: SelectedFilterOption) => void;\n  onClearAllFilters: () => void;\n  setIsFilterOpen: (isFilterOpen: boolean) => void;\n\n  // Refs\n  searchResultsRef: React.RefObject<HTMLDivElement>;\n}\n\nexport const useSearch = (): SearchResultsHocProps => {\n  // Atoms\n  const config = useNewOrgConfig();\n  const orgShortName = useAtomValue(orgShortNameAtom);\n  const { data: searchData, loading: isLoadingSearch } =\n    useAtomValue(searchAtom);\n  const productList = useAtomValue(filteredSearchProductsAtom);\n  const performSearch = useSetAtom(performSearchAtom);\n  const [{ query }] = useAtom(searchParamsAtom);\n  const [isFilterOpen, setIsFilterOpen] = useAtom(isFilterOpenAtom);\n  const [selectedFilterOptions] = useAtom(searchSelectedFiltersAtom);\n  const addFilter = useSetAtom(addSearchFilterAtom);\n  const removeFilter = useSetAtom(removeSearchFilterAtom);\n  const [productSorting, setProductSorting] = useAtom(searchProductSortingAtom);\n  const clearFilters = useSetAtom(clearSearchFiltersAtom);\n  const searchFilters = useAtomValue(searchFiltersAtom);\n  const recommendedProducts = useRecommendedProducts();\n\n  // Refs\n  const searchResultsRef = useRef<HTMLDivElement>(null);\n  \n  // Utilities\n  const scrollToTop = useCallback(() => {\n    const container = searchResultsRef.current;\n    if (container) {\n      container.scrollTo({ top: 0, behavior: 'smooth' });\n    } else {\n      window.scrollTo({ top: 0, behavior: 'smooth' });\n    }\n  }, []);\n  \n  // Search Input Hook\n  const searchInput = useSearchInput({\n    initialSearchText: query || '',\n    searchOrigin: SpiffyWidgets.SearchResults,\n    onSearchSubmit: (searchQuery) => {\n      performSearch({ query: searchQuery });\n    },\n  });\n  \n  const {\n    searchText,\n    focusedIndex,\n    focusedOptionId,\n    autocompleteResults,\n    shouldShowAutocomplete,\n    handleSearchInputChange,\n    handleSearchInputFocus,\n    handleSearchInputBlur,\n    handleKeyDown,\n    handleAutocompleteSelect,\n    handleSubmitSearch,\n    setSearchText,\n  } = searchInput;\n  const searchResultsState = getSearchResultsState(isLoadingSearch, searchData);\n\n  const dynamicFilters = searchData?.filters || [];\n\n  // Provide fallback values when orgUIConfig is not yet available\n  const safeProductCardConfig = config?.frontendConfig?.uiConfigs\n    ?.productCardConfig || {\n    variant: \"minimal\",\n    hoverVariant: \"none\",\n    layoutVariant: \"square\",\n  };\n  const safeMerchantShortName = orgShortName || \"\";\n\n  const availableDynamicFilters = useMemo(() => {\n    return dynamicFilters\n      .filter(\n        (dynamicFilterName) =>\n          !selectedFilterOptions.some((option) => option.id === `dynamic:${dynamicFilterName}`),\n      )\n      .map((dynamicFilterName) => ({\n        name: dynamicFilterName,\n        displayName: formatFilterDisplayName(dynamicFilterName),\n      }));\n  }, [dynamicFilters, selectedFilterOptions]);\n\n  const filters = useMemo(() => {\n    const sortOptions = [\n      {\n        filterItemId: String(ProductSorting.FEATURED),\n        displayName: 'Relevance',\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.FEATURED,\n      },\n      {\n        filterItemId: String(ProductSorting.PRICE_ASC),\n        displayName: 'Price: Low to High',\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.PRICE_ASC,\n      },\n      {\n        filterItemId: String(ProductSorting.PRICE_DESC),\n        displayName: 'Price: High to Low',\n        productCount: 0,\n        isSelected: productSorting === ProductSorting.PRICE_DESC,\n      },\n    ];\n\n    return [{ filterId: 'sort', displayName: 'SORT', items: sortOptions }, ...searchFilters] as SearchFilterDatum[];\n  }, [productSorting, searchFilters]);\n\n  const filterButtonText = useMemo(() => {\n    const selectedCount = filters.reduce((acc: number, filter) => {\n      if (filter.filterId === 'sort') {\n        return acc;\n      }\n      return acc + filter.items.filter((item) => item.isSelected).length;\n    }, 0);\n    if (selectedCount === 0) {\n      return 'Filter & Sort';\n    }\n    return `Filter & Sort (${selectedCount})`;\n  }, [filters]);\n\n  // Callbacks\n  const { trackEvent } = useAmplitude();\n\n\n  const handleToggleDynamicFilter = useCallback(\n    ({ filter, dynamicFilterDisplayName }: { filter: string; dynamicFilterDisplayName: string }) => {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchFilterClicked,\n        eventProps: {\n          filterType: 'Dynamic',\n          filterValue: filter,\n          queryText: searchText,\n        },\n      });\n      addFilter(createFilterOption('dynamic', filter, dynamicFilterDisplayName));\n      scrollToTop();\n    },\n    [addFilter, searchText, scrollToTop],\n  );\n\n  const handleRemoveFilter = useCallback(\n    (filter: SelectedFilterOption) => {\n      removeFilter(filter.id);\n      scrollToTop();\n    },\n    [removeFilter, scrollToTop],\n  );\n\n\n  const handleSelectFilterItem: SelectFilterItem = useCallback(\n    ({\n      filterId,\n      filterItemId,\n      isSelected,\n      displayName,\n    }: {\n      filterId: string;\n      filterItemId: string;\n      isSelected: boolean;\n      displayName: string;\n    }) => {\n      if (filterId === 'sort') {\n        const newSort = filterItemId as ProductSorting;\n        trackEvent({\n          eventName: SpiffyMetricsEventName.SearchSortClicked,\n          eventProps: {\n            sortType: newSort,\n            queryText: searchText,\n          },\n        });\n        setProductSorting(newSort);\n        scrollToTop();\n      } else if (!isSelected) {\n        removeFilter(`${filterId}:${filterItemId}`);\n        scrollToTop();\n      } else {\n        trackEvent({\n          eventName: SpiffyMetricsEventName.SearchFilterClicked,\n          eventProps: {\n            filterType: 'Static',\n            filterCategory: filterId,\n            filterValue: filterItemId,\n            queryText: searchText,\n          },\n        });\n        addFilter(createFilterOption(filterId, filterItemId, displayName));\n        scrollToTop();\n      }\n    },\n    [addFilter, removeFilter, setProductSorting, searchText, scrollToTop],\n  );\n\n\n  const handleClearAllFilters = useCallback(() => {\n    setProductSorting(ProductSorting.FEATURED);\n    clearFilters();\n    scrollToTop();\n  }, [setProductSorting, clearFilters, scrollToTop]);\n\n  // Side Effects\n  useTrackComponentVisibleEvent(\n    SpiffyWidgets.SearchResults,\n    searchResultsRef,\n    {},\n    SpiffyMetricsEventName.SearchComponentVisible,\n  );\n\n  useEffect(() => {\n    if (searchResultsState === SearchResultsState.Results || searchResultsState === SearchResultsState.NoResults) {\n      trackEvent({\n        eventName: SpiffyMetricsEventName.SearchResultsViewed,\n        eventProps: {\n          queryText: searchText,\n          resultsCount: productList.length,\n        },\n      });\n    }\n  }, [productList.length, searchResultsState]);\n\n  // This is the single source of truth for the search text triggering a search\n  useEffect(() => {\n    if (query && query !== searchText) {\n      const esq = new URLSearchParams(window.location.search).get('esq');\n      setSearchText(query);\n      performSearch({ query: esq ?? query });\n    }\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [performSearch, query, setSearchText]);\n\n  return {\n    searchData,\n    searchResponseId: searchData?.searchResponseId ?? '',\n    merchantShortName: safeMerchantShortName,\n    productCardConfig: safeProductCardConfig,\n    productList,\n    recommendedProducts,\n    autocompleteResults,\n    searchFilters: filters,\n    availableDynamicFilters,\n    selectedFilterOptions,\n    searchText,\n    query: query || '',\n    searchResultsState,\n    isLoadingSearch,\n    isFilterOpen,\n    shouldShowAutocomplete,\n    focusedIndex,\n    focusedOptionId,\n    filterButtonText,\n    onSearchInputChange: handleSearchInputChange,\n    onSubmitSearch: handleSubmitSearch,\n    onAutocompleteSelect: handleAutocompleteSelect,\n    onKeyDown: handleKeyDown,\n    onSearchInputFocus: handleSearchInputFocus,\n    onSearchInputBlur: handleSearchInputBlur,\n    onToggleDynamicFilter: handleToggleDynamicFilter,\n    onSelectFilterItem: handleSelectFilterItem,\n    onRemoveFilter: handleRemoveFilter,\n    onClearAllFilters: handleClearAllFilters,\n    setIsFilterOpen,\n    searchResultsRef,\n  };\n};"],"x_google_ignoreList":[0],"mappings":"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"}