@envive-ai/react-hooks 0.1.4 → 0.1.6

package/dist/utils-C9ZSCx12.js

@@ -0,0 +1,888 @@
+import { MessageRole, MessageType, isBaseEcommerceEvent, isGA4EcommerceEvent, isLegacyUAEcommerceEvent } from "./models-UZ6HszfZ.js";
+import { logger_default } from "./api-DjeZXxl_.js";
+import { SpiffyMetricsEventName } from "./amplitudeContext-hY3caPC6.js";
+import { PLPAttributeCategory, ResponseCategory, UserEventCategory } from "@spiffy-ai/commerce-api-client";
+import { createPortal } from "react-dom";
+
+//#region src/application/utils/analyticsUtils.ts
+const NORMALIZED_ADD_TO_CART_EVENT_NAMES = ["addtocart", "addedtocart"];
+const CHECK_DATA_LAYER_INTERVAL_MS = 500;
+const CHECK_DATA_LAYER_MAX_ATTEMPTS = 10;
+/**
+* Checks if a Google Analytics event is an add_to_cart event.
+*
+* @param event The event name to check.
+*
+* @returns True if the event is an add_to_cart event, false otherwise.
+*/
+const isAddToCartEvent = (event) => {
+	const normalizedEvent = event.replace(/[-_]/g, "").toLowerCase();
+	return NORMALIZED_ADD_TO_CART_EVENT_NAMES.some((name) => normalizedEvent.includes(name));
+};
+/**
+* Tracks an add_to_cart event in Amplitude.
+*
+* @param event The event to track.
+*/
+const handleAddToCartEvent = (event, track) => {
+	let eventProps;
+	if (isLegacyUAEcommerceEvent(event)) eventProps = {
+		items: event.ecommerce.add.products.map((product) => ({
+			item_name: product.name,
+			item_category: product.category,
+			price: product.price,
+			quantity: product.quantity
+		})),
+		currency: event.ecommerce.add.currencyCode,
+		event_format_version: "legacy_universal_analytics"
+	};
+	else if (isGA4EcommerceEvent(event)) eventProps = {
+		items: event.ecommerce.items.map((item) => ({
+			item_name: item.item_name,
+			item_category: item.item_category,
+			price: item.price,
+			quantity: item.quantity
+		})),
+		currency: event.ecommerce.currency,
+		event_format_version: "google_analytics_4"
+	};
+	else eventProps = {
+		event_properties: { ...event },
+		event_format_version: "unknown"
+	};
+	track(SpiffyMetricsEventName.AddToCartClicked, { eventProps });
+};
+/**
+* Wraps the window.dataLayer.push method to intercept add_to_cart events and send them to Amplitude.
+* This function runs on an interval until the dataLayer is available.
+*/
+const initDataLayerWrapper = (track) => {
+	let attempts = 0;
+	const checkAndInitialize = () => {
+		if (!window.dataLayer || !window.dataLayer.push) {
+			attempts += 1;
+			if (attempts >= CHECK_DATA_LAYER_MAX_ATTEMPTS) {
+				logger_default.logDebug(`[spiffy-ai] dataLayer not available after ${CHECK_DATA_LAYER_MAX_ATTEMPTS} attempts`);
+				return;
+			}
+			setTimeout(checkAndInitialize, CHECK_DATA_LAYER_INTERVAL_MS);
+			return;
+		}
+		logger_default.logDebug("[spiffy-ai] dataLayer is available, wrapping push function...");
+		const originalPush = window.dataLayer.push;
+		window.dataLayer.push = (...args) => {
+			if (isBaseEcommerceEvent(args[0]) && isAddToCartEvent(args[0].event)) handleAddToCartEvent(args[0], track);
+			return originalPush.apply(window.dataLayer, args);
+		};
+	};
+	checkAndInitialize();
+};
+const initAmplitude = (track) => {
+	track(SpiffyMetricsEventName.BundleLoaded);
+};
+
+//#endregion
+//#region src/application/utils/coreContextToApiContext.ts
+const coreContextToApiContext = (context) => ({
+	chat_id: context.chatId,
+	org_id: context.orgId,
+	user_id: context.userId,
+	org_short_name: context.orgShortName,
+	source: context.source,
+	env: context.env
+});
+
+//#endregion
+//#region src/application/utils/coreUserEventToApiUserEvent.ts
+const coreUserEventToApiUserEvent = (data) => {
+	if (data.category === UserEventCategory.PdpVisit || data.category === UserEventCategory.AddToCart) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			product_id: data.attributes.productId,
+			parent_product_id: data.attributes.parentProductId,
+			url: data.attributes.url
+		}
+	};
+	if (data.category === UserEventCategory.PlpVisit) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			category: PLPAttributeCategory.Id,
+			attributes: { id: data.attributes.attributes.id }
+		}
+	};
+	if (data.category === UserEventCategory.QueryTyped) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: { query: data.attributes.query }
+	};
+	if (data.category === UserEventCategory.Search) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			search_term: data.attributes.searchTerm,
+			selected_filters: data.attributes.selectedFilters
+		}
+	};
+	if (data.category === UserEventCategory.SuggestionClicked) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: { suggestion_id: data.attributes.suggestionId }
+	};
+	if (data.category === UserEventCategory.PageVisit) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			url: data.attributes.url,
+			page_visit_category: data.attributes.pageVisitCategory
+		}
+	};
+	if (data.category === UserEventCategory.FormSubmitted) return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category,
+		attributes: {
+			filled_schema: { ...data.attributes.filledSchema },
+			form_response_id: data.attributes.formResponseId,
+			form_type: data.attributes.formType
+		}
+	};
+	return {
+		event_id: data.eventId,
+		created_at: data.createdAt,
+		category: data.category
+	};
+};
+
+//#endregion
+//#region src/application/utils/divideArray.ts
+const divideArray = (array, size) => {
+	const rows = [];
+	for (let i = 0; i < size; i += 1) rows.push(array.filter((_, index) => index % size === i));
+	return rows;
+};
+
+//#endregion
+//#region src/application/utils/mutationHelper.ts
+const compareTokens = (original, comparison) => {
+	const originalTokens = new Set(original.split(" "));
+	const comparisonTokens = new Set(comparison.split(" "));
+	return [...originalTokens].filter((token) => !comparisonTokens.has(token));
+};
+var MutationHelper = class {
+	static fireClassChange(record, node, fn) {
+		if (node && record.oldValue !== node?.classList.value) fn(node?.classList);
+	}
+	static fireClassAdded(record, node, classMap) {
+		if (node && record.oldValue) compareTokens(node?.classList.value, record.oldValue).forEach((className) => classMap.get(className)?.());
+	}
+	static fireClassRemoved(record, node, classMap) {
+		if (node && record.oldValue) compareTokens(record.oldValue, node?.classList.value).forEach((className) => classMap.get(className)?.());
+	}
+	static fireSubtreeChange(nodes, fn) {
+		nodes.length && fn?.(nodes);
+	}
+	static isClass(mutation) {
+		return mutation.type === "attributes" && mutation.attributeName === "class";
+	}
+	static isChildList(mutation) {
+		return mutation.type === "childList";
+	}
+};
+
+//#endregion
+//#region src/application/utils/elementObserver.ts
+/**
+* The `ElementObserver` class monitors all changes related to the specific element it is responsible for.
+* It is automatically instantiated by the `useElementObserver` hook, which manages all instances of this class.
+*
+* How it works:
+*
+* Each instance of `ElementObserver` holds several pieces of information related to the node it is monitoring,
+* such as the node's selector and its `MutationObserver`. This class is responsible for translating raw node
+* changes into a more user-friendly format. For example, when the node is added to the DOM, the `ElementObserver`
+* is notified by the `DOMObserver`, which triggers the `onAdd` callback function on the respective `useElementObserver`
+* instance.
+*
+* Instances of `ElementObserver` are fully managed by the `useElementObserver` hook, requiring no additional configuration.
+* When the hook is destroyed, its corresponding `ElementObserver` instance is automatically removed.
+*
+*/
+var ElementObserver = class {
+	constructor(selector) {
+		this.selector = selector;
+		this.mutation = null;
+		this.node = null;
+		this.eventListeners = /* @__PURE__ */ new Map();
+		this.classAdded = /* @__PURE__ */ new Map();
+		this.classRemoved = /* @__PURE__ */ new Map();
+		this.nodeDisplay = "block";
+		this.addFn = () => {};
+		this.removeFn = () => {};
+		this.changeFn = () => {};
+		this.classChangeFn = () => {};
+		this.addChildFn = void 0;
+		this.removeChildFn = void 0;
+		this.resetFn = () => {};
+	}
+	handleAttributes(mutationRecord) {
+		mutationRecord.filter(MutationHelper.isClass).forEach((mutation) => {
+			MutationHelper.fireClassChange(mutation, this.node, this.classChangeFn);
+			MutationHelper.fireClassAdded(mutation, this.node, this.classAdded);
+			MutationHelper.fireClassRemoved(mutation, this.node, this.classRemoved);
+		});
+	}
+	handleChildList(mutationRecord) {
+		if (!this.addChildFn && !this.removeChildFn) return;
+		mutationRecord.filter(MutationHelper.isChildList).forEach((mutation) => {
+			MutationHelper.fireSubtreeChange(mutation.addedNodes, this.addChildFn);
+			MutationHelper.fireSubtreeChange(mutation.removedNodes, this.removeChildFn);
+		});
+	}
+	addInitialListeners() {
+		this.eventListeners.forEach((v, k) => this.node?.addEventListener(k, v));
+	}
+	clearEventListeners() {
+		this.eventListeners.forEach((v, k) => this.node?.removeEventListener(k, v));
+		this.eventListeners.clear();
+	}
+	renew(newNode) {
+		if (newNode) {
+			this.destroy();
+			this.watch(newNode);
+		}
+	}
+	getSelector() {
+		return this.selector;
+	}
+	getNode() {
+		return this.node;
+	}
+	synchronize() {
+		const parsedNode = this.getSelector().parse();
+		if (this.getNode() !== parsedNode) {
+			this.renew(parsedNode);
+			return;
+		}
+		if (!this.getNode() && parsedNode) {
+			this.watch(parsedNode);
+			return;
+		}
+		if (this.getNode() && !parsedNode) this.destroy();
+	}
+	init() {
+		const node = this.getSelector().parse();
+		if (node) this.watch(node);
+	}
+	watch(node) {
+		if (!this.mutation) {
+			this.mutation = new MutationObserver((mutationRecord) => {
+				this.handleAttributes(mutationRecord);
+				this.handleChildList(mutationRecord);
+				this.changeFn(this.node);
+			});
+			this.mutation.observe(node, {
+				childList: true,
+				subtree: true,
+				attributes: true,
+				attributeOldValue: true
+			});
+			this.node = node;
+			this.addFn(this.node);
+			this.addInitialListeners();
+		}
+	}
+	destroy() {
+		this.resetFn();
+		this.removeFn(this.node);
+		this.mutation?.disconnect();
+		this.clearEventListeners();
+		this.classAdded.clear();
+		this.classRemoved.clear();
+		this.mutation = null;
+		this.node = null;
+	}
+	render(fn) {
+		if (this.node) return createPortal(fn(), this.node);
+	}
+	fire(event) {
+		if (this.node) this.node.dispatchEvent(new MouseEvent(event, {
+			bubbles: true,
+			cancelable: true,
+			view: window
+		}));
+	}
+	show() {
+		const display = this.node?.style.display;
+		if (this.node && display === "none") this.node.style.display = this.nodeDisplay || "block";
+	}
+	hide() {
+		const display = this.node?.style.display;
+		if (this.node && display !== "none") {
+			this.nodeDisplay = display || "block";
+			this.node.style.display = "none";
+		}
+	}
+	registerEvent(event, fn) {
+		if (this.node) {
+			const previousFn = this.eventListeners.get(event);
+			if (previousFn) this.node.removeEventListener(event, previousFn);
+			this.node.addEventListener(event, fn);
+		}
+		this.eventListeners.set(event, fn);
+	}
+	registerOnReset(fn) {
+		this.resetFn = fn;
+	}
+	registerOnChange(fn) {
+		this.changeFn = fn;
+	}
+	registerOnAdd(fn) {
+		this.addFn = fn;
+	}
+	registerOnRemove(fn) {
+		this.removeFn = fn;
+	}
+	registerOnclassChange(fn) {
+		this.classChangeFn = fn;
+	}
+	registerOnAddChild(fn) {
+		this.addChildFn = fn;
+	}
+	registerOnRemoveChild(fn) {
+		this.removeChildFn = fn;
+	}
+	registerOnClassAdded(className, fn) {
+		this.classAdded.set(className, fn);
+	}
+	registerOnClassRemoved(className, fn) {
+		this.classRemoved.set(className, fn);
+	}
+};
+
+//#endregion
+//#region src/application/utils/domObserver.ts
+/**
+* This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are
+* added or removed from the DOM and notifies the observers for each observable element
+* when they are ready to be watched.
+*
+* How that works:
+*
+* When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.
+* All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`
+* iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.
+*
+* If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.
+*
+* The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all
+* individual element observers and release any associated resources.
+*
+* There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.
+*
+*/
+var DOMObserver = class {
+	static {
+		this.listeners = /* @__PURE__ */ new Map();
+	}
+	static notifyAdition(records, nodeMapping) {
+		records.forEach((record) => record.addedNodes.forEach((node) => {
+			nodeMapping.get(node)?.watch(node);
+			nodeMapping.delete(node);
+		}));
+	}
+	static notifyRemoval(records, nodeMapping) {
+		records.forEach((record) => record.removedNodes.forEach((node) => {
+			nodeMapping.get(node)?.destroy();
+			nodeMapping.delete(node);
+		}));
+	}
+	static notifyChildrenChanges(nodeMapping) {
+		Array.from(nodeMapping.values()).forEach((observer) => observer.synchronize());
+	}
+	static mapNodeInstancesToListeners() {
+		const nodeMapping = /* @__PURE__ */ new Map();
+		this.listeners.forEach((observer) => {
+			const node = observer.getNode() || observer.getSelector()?.parse();
+			if (node) nodeMapping.set(node, observer);
+		});
+		return nodeMapping;
+	}
+	static add(selector) {
+		const node = selector.getPattern();
+		let elementObserver = this.listeners.get(node);
+		if (elementObserver) return elementObserver;
+		elementObserver = new ElementObserver(selector);
+		this.listeners.set(node, elementObserver);
+		return elementObserver;
+	}
+	static remove(selector) {
+		const node = selector.getPattern();
+		this.listeners.get(node)?.destroy();
+		this.listeners.delete(node);
+	}
+	static observe() {
+		if (!this.documentObserver) {
+			this.documentObserver = new MutationObserver((mutations) => {
+				const nodeMapping = this.mapNodeInstancesToListeners();
+				this.notifyAdition(mutations, nodeMapping);
+				this.notifyRemoval(mutations, nodeMapping);
+				this.notifyChildrenChanges(nodeMapping);
+			});
+			this.documentObserver.observe(document.body, {
+				childList: true,
+				subtree: true
+			});
+		}
+	}
+	static destroy() {
+		this.documentObserver?.disconnect();
+		this.listeners.forEach((listener) => listener.destroy());
+		this.listeners.clear();
+		this.documentObserver = null;
+	}
+};
+
+//#endregion
+//#region src/application/utils/imageFilter.ts
+const getRecentProductImageUrls = (lastMessages, currentProductId) => {
+	const productMessages = lastMessages.filter((message) => message.type === MessageType.Product && message.metadata?.imageUrl).map((m) => m);
+	return [...productMessages.filter((m) => m.metadata?.id === currentProductId), ...productMessages.filter((m) => m.metadata?.id !== currentProductId)].map((m) => m.metadata.imageUrl);
+};
+
+//#endregion
+//#region src/application/utils/merchantUtils.ts
+const prepareMerchantPage = () => {
+	let metaViewport = document.querySelector("meta[name='viewport']");
+	if (metaViewport) {
+		const content = metaViewport.getAttribute("content");
+		if (!content?.includes("maximum-scale=1")) metaViewport.setAttribute("content", `${content}, maximum-scale=1`);
+		return;
+	}
+	metaViewport = document.createElement("meta");
+	metaViewport.setAttribute("name", "viewport");
+	metaViewport.setAttribute("content", "width=device-width, initial-scale=1, maximum-scale=1");
+	document.head.appendChild(metaViewport);
+};
+
+//#endregion
+//#region src/application/utils/messageFromFormSubmittedEvent.ts
+const messageFromFormSubmittedEvent = (event, formResponseAttributes) => {
+	if (event.category !== UserEventCategory.FormSubmitted) return;
+	const formStringContents = Object.entries(formResponseAttributes.schema.properties).map(([key, value]) => `${value.title}: ${event.attributes.filledSchema[key]}`).join("\n");
+	return {
+		id: event.eventId,
+		role: MessageRole.User,
+		type: MessageType.QueryTyped,
+		createdAt: event.createdAt,
+		metadata: { content: formStringContents }
+	};
+};
+
+//#endregion
+//#region src/application/utils/messageFromQueryEvent.ts
+/**
+* Transforms a query UserEvent object into a Message object for presentation.
+*
+* @param event The user event object received from the server
+*
+* @returns A Message if the event is a query event, otherwise undefined
+*/
+const messageFromQueryEvent = (event) => {
+	if (event.category === UserEventCategory.QueryTyped) return {
+		id: event.eventId,
+		role: MessageRole.User,
+		type: MessageType.QueryTyped,
+		createdAt: event.createdAt,
+		metadata: { content: event.attributes.query }
+	};
+	if (event.category === UserEventCategory.Search) return {
+		id: event.eventId,
+		role: MessageRole.User,
+		type: MessageType.Search,
+		createdAt: event.createdAt,
+		metadata: {
+			searchTerm: event.attributes.searchTerm || "",
+			selectedFilters: event.attributes.selectedFilters || []
+		}
+	};
+};
+
+//#endregion
+//#region src/application/utils/messageFromResponse.ts
+/**
+* Transforms a server Response object into a Message object for presentation.
+*
+* @param response The response object received from the server containing model generated content
+*
+* @returns A Message if the response contains known attributes, undefined otherwise
+*/
+const messageFromResponse = (response) => {
+	if (response == null) return;
+	if (response.category === ResponseCategory.Text) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		type: MessageType.Text,
+		role: MessageRole.Assistant,
+		metadata: { content: response.attributes.content }
+	};
+	if (response.category === ResponseCategory.Product) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.Product,
+		metadata: { ...response.attributes }
+	};
+	if (response.category === ResponseCategory.Review) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		type: MessageType.Review,
+		role: MessageRole.Assistant,
+		metadata: {
+			review: response.attributes.review,
+			reviewer: response.attributes.reviewer,
+			stars: response.attributes.stars,
+			title: response.attributes.title,
+			richInformation: response.attributes.richInformation
+		}
+	};
+	if (response.category === ResponseCategory.Separator) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		type: MessageType.Separator,
+		role: MessageRole.Assistant
+	};
+	if (response.category === ResponseCategory.Page) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.Page,
+		metadata: { ...response.attributes }
+	};
+	if (response.category === ResponseCategory.ProductSearch) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.ProductSearch,
+		metadata: { ...response.attributes }
+	};
+	if (response.category === ResponseCategory.ProductSearchFilter) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.ProductSearchFilter,
+		metadata: { ...response.attributes }
+	};
+	if (response.category === ResponseCategory.Form) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.Form,
+		metadata: {
+			formType: response.attributes.formCategory?.formType,
+			fields: Object.entries(response.attributes.schema.properties).map(([key, value]) => ({
+				key,
+				title: value.title,
+				type: value.type,
+				format: value.format,
+				required: response.attributes.schema.required.includes(key)
+			}))
+		}
+	};
+	if (response.category === ResponseCategory.Order) return {
+		id: response.id,
+		createdAt: response.createdAt,
+		role: MessageRole.Assistant,
+		type: MessageType.Order,
+		metadata: { ...response.attributes }
+	};
+};
+
+//#endregion
+//#region src/application/utils/messageFromSuggestionEvent.ts
+/**
+* Transforms a UserEvent object into a Message object for presentation.
+*
+* @param event The UserEvent object received from the server
+* @param suggestions A list of generated suggestions to match the event to
+*
+* @returns A Message if the event is a suggestion click event, undefined otherwise
+*/
+const messageFromSuggestionEvent = (event, suggestions) => {
+	if (event.category === UserEventCategory.SuggestionClicked) {
+		const { suggestionId } = event.attributes;
+		return {
+			id: event.eventId,
+			role: MessageRole.User,
+			type: MessageType.SuggestionClicked,
+			createdAt: event.createdAt,
+			metadata: {
+				suggestionId,
+				suggestionContent: suggestions.find((s) => s.id === suggestionId)?.content ?? ""
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/application/utils/nextMessageRequestToApiRequest.ts
+const messageRequestToCommerceMessageRequest = (data) => ({
+	context: {
+		chat_id: data.context.chatId,
+		org_id: data.context.orgId,
+		org_short_name: data.context.orgShortName,
+		user_id: data.context.userId,
+		source: data.context.source,
+		env: data.context.env
+	},
+	id: data.id,
+	feature_flags: data.featureFlags,
+	user_events: data.userEvents?.map((userEvent) => coreUserEventToApiUserEvent(userEvent)),
+	generation_params: {
+		model: data.generationParams?.model,
+		max_tokens: data.generationParams?.maxTokens,
+		stop: data.generationParams?.stop,
+		stream: data.generationParams?.stream,
+		temperature: data.generationParams?.temperature,
+		top_p: data.generationParams?.topP,
+		num_suggestions: data.generationParams?.numSuggestions,
+		response_system_prompt: data.generationParams?.responseSystemPrompt,
+		suggestion_system_prompt: data.generationParams?.suggestionSystemPrompt,
+		response_caching: data.generationParams?.responseCaching
+	}
+});
+
+//#endregion
+//#region src/application/utils/nodeSelector.ts
+var NodeSelector = class {
+	constructor(pattern) {
+		this.pattern = pattern;
+		this.root = document;
+	}
+	getPattern() {
+		return this.pattern;
+	}
+	setRoot(root) {
+		this.root = root;
+	}
+	getRoot() {
+		return this.root;
+	}
+};
+var QuerySelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot().querySelector(this.getPattern());
+	}
+};
+var IDSelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot().getElementById(this.getPattern());
+	}
+};
+var XpathSelector = class extends NodeSelector {
+	parse() {
+		return this.getRoot()?.evaluate(this.getPattern(), this.getRoot(), null, XPathResult.FIRST_ORDERED_NODE_TYPE, null)?.singleNodeValue;
+	}
+};
+var ChainSelector = class extends NodeSelector {
+	parse() {
+		let selectorIndex = 0;
+		const selectors = this.getPattern().split("@");
+		const lastIndex = selectors.length - 1;
+		const parseChain = (pattern, prevNode) => {
+			const selector = SelectorFactory.parse(pattern);
+			if (prevNode) selector.setRoot(prevNode);
+			const currentNode = selector.parse();
+			if (selectorIndex === lastIndex) return currentNode;
+			let node = currentNode || document;
+			if (currentNode?.shadowRoot) node = currentNode.shadowRoot;
+			if (currentNode?.contentWindow) node = currentNode.contentWindow?.document;
+			return parseChain(selectors[++selectorIndex].trim(), node);
+		};
+		return parseChain(selectors[selectorIndex].trim());
+	}
+};
+var Empty = class extends NodeSelector {
+	constructor() {
+		super("");
+	}
+	parse() {
+		return null;
+	}
+};
+var SelectorFactory = class {
+	static parse(composedSelector) {
+		if (!composedSelector) return new Empty();
+		const split = composedSelector.split("|");
+		const type = split[0];
+		const selector = split[1];
+		switch (type) {
+			case "id": return this.id(selector);
+			case "query": return this.query(selector);
+			case "xpath": return this.xpath(selector);
+			default: return new Empty();
+		}
+	}
+	static check(selector) {
+		return selector ?? new Empty();
+	}
+	static chain(pattern) {
+		return pattern ? new ChainSelector(pattern) : new Empty();
+	}
+	static id(pattern) {
+		return pattern ? new IDSelector(pattern) : new Empty();
+	}
+	static query(pattern) {
+		return pattern ? new QuerySelector(pattern) : new Empty();
+	}
+	static xpath(pattern) {
+		return pattern ? new XpathSelector(pattern) : new Empty();
+	}
+};
+
+//#endregion
+//#region src/application/utils/overrides.ts
+function isPlainObject(x) {
+	return !!x && typeof x === "object" && !Array.isArray(x) && !(x instanceof Date) && !(x instanceof RegExp);
+}
+function isReplace(x) {
+	return !!x && typeof x === "object" && "$replace" in x;
+}
+function isDelete(x) {
+	return !!x && typeof x === "object" && x.$delete === true;
+}
+function isPrimitiveValue(x) {
+	const t = typeof x;
+	return x === null || t === "string" || t === "number" || t === "boolean" || t === "bigint" || t === "symbol" || t === "undefined";
+}
+function isArrayOfPrimitives(arr) {
+	if (arr.length === 0) return false;
+	for (let i = 0; i < arr.length; i += 1) {
+		const v = arr[i];
+		if (v !== void 0 && !isPrimitiveValue(v)) return false;
+	}
+	return true;
+}
+function mergeAny(baseAny, patchAny, opts) {
+	if (isReplace(patchAny)) return patchAny.$replace;
+	if (isDelete(patchAny)) return void 0;
+	if (Array.isArray(baseAny)) {
+		if (Array.isArray(patchAny)) {
+			const baseArr = baseAny;
+			const patchArr = patchAny;
+			if (opts.arrayStrategy === "replace" || isArrayOfPrimitives(baseArr) || isArrayOfPrimitives(patchArr)) return patchAny;
+			const out = baseArr.slice();
+			const max = Math.max(out.length, patchArr.length);
+			for (let i = 0; i < max; i += 1) {
+				const pVal = patchArr[i];
+				if (pVal !== void 0) out[i] = mergeAny(out[i], pVal, opts);
+			}
+			return out;
+		}
+		return baseAny;
+	}
+	if (isPlainObject(baseAny) && isPlainObject(patchAny)) {
+		const baseObj = baseAny;
+		const patchObj = patchAny;
+		const out = { ...baseObj };
+		for (const key of Object.keys(patchObj)) {
+			const pVal = patchObj[key];
+			if (pVal === void 0) {} else if (opts.nullDeletes && pVal === null) delete out[key];
+			else if (isReplace(pVal)) out[key] = pVal.$replace;
+			else if (isDelete(pVal)) delete out[key];
+			else out[key] = mergeAny(baseObj?.[key], pVal, opts);
+		}
+		return out;
+	}
+	return patchAny ?? baseAny;
+}
+function applyOverrides(base, patch, opts = {}) {
+	const { arrayStrategy = "mergeByIndex", nullDeletes = false } = opts;
+	if (isReplace(patch)) return patch.$replace;
+	if (isDelete(patch)) return void 0;
+	if (Array.isArray(base)) {
+		if (isReplace(patch)) return patch.$replace;
+		if (Array.isArray(patch)) {
+			if (arrayStrategy === "replace") return patch;
+			const out = base.slice();
+			const max = Math.max(out.length, patch.length);
+			for (let i = 0; i < max; i += 1) {
+				const pVal = patch[i];
+				if (pVal !== void 0) out[i] = mergeAny(out[i], pVal, opts);
+			}
+			return out;
+		}
+		return base;
+	}
+	if (isPlainObject(base) && isPlainObject(patch)) {
+		const out = { ...base };
+		const patchObj = patch;
+		for (const key of Object.keys(patchObj)) {
+			const pVal = patchObj[key];
+			if (pVal === void 0) {} else if (nullDeletes && pVal === null) delete out[key];
+			else if (isReplace(pVal)) out[key] = pVal.$replace;
+			else if (isDelete(pVal)) delete out[key];
+			else {
+				const bVal = base[key];
+				out[key] = mergeAny(bVal, pVal, opts);
+			}
+		}
+		return out;
+	}
+	return patch ?? base;
+}
+
+//#endregion
+//#region src/application/utils/stringUtils.ts
+var StringUtils = class StringUtils {
+	static isNullOrEmpty(value) {
+		const valueTrimmed = value?.trim();
+		return value === void 0 || valueTrimmed === "";
+	}
+	static trimToNull(value) {
+		const valueTrimmed = value?.trim();
+		return StringUtils.isNullOrEmpty(valueTrimmed) ? void 0 : valueTrimmed;
+	}
+	static capitalize(type) {
+		if (type === void 0) return "";
+		return type.charAt(0).toUpperCase() + type.substring(1);
+	}
+	/**
+	* Finds the first pattern in an array that matches a given URL.
+	* Patterns can include a single wildcard '*' which matches any sequence of characters.
+	*
+	* @param patterns
+	* @param urlToTest
+	* @returns
+	*/
+	static findMatchingPattern(patterns, urlToTest) {
+		if (!urlToTest) return;
+		for (const pattern of patterns) if (urlToTest.pathname !== "/") {
+			const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+			if ((/* @__PURE__ */ new RegExp(`^${regexPattern}$`)).test(urlToTest.pathname)) return pattern;
+		} else if (pattern.startsWith(urlToTest.hostname)) return pattern;
+	}
+};
+
+//#endregion
+//#region src/application/utils/supportedEventRequestToApiRequest.ts
+const coreSupportedEventRequestToApiRequest = (coreSupportedEventRequest) => ({
+	id: coreSupportedEventRequest.id,
+	user_event: coreUserEventToApiUserEvent(coreSupportedEventRequest.userEvent),
+	context: coreContextToApiContext(coreSupportedEventRequest.context)
+});
+
+//#endregion
+//#region src/application/utils/validation.ts
+const validateEmail = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+
+//#endregion
+export { DOMObserver, ElementObserver, MutationHelper, NodeSelector, SelectorFactory, StringUtils, applyOverrides, coreContextToApiContext, coreSupportedEventRequestToApiRequest, coreUserEventToApiUserEvent, divideArray, getRecentProductImageUrls, initAmplitude, initDataLayerWrapper, messageFromFormSubmittedEvent, messageFromQueryEvent, messageFromResponse, messageFromSuggestionEvent, messageRequestToCommerceMessageRequest, prepareMerchantPage, validateEmail };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"utils-C9ZSCx12.js","names":["eventProps: Record<string, unknown>","node: Node | null | undefined","out: Record<string, unknown>"],"sources":["../src/application/utils/analyticsUtils.ts","../src/application/utils/coreContextToApiContext.ts","../src/application/utils/coreUserEventToApiUserEvent.ts","../src/application/utils/divideArray.ts","../src/application/utils/mutationHelper.ts","../src/application/utils/elementObserver.ts","../src/application/utils/domObserver.ts","../src/application/utils/imageFilter.ts","../src/application/utils/merchantUtils.ts","../src/application/utils/messageFromFormSubmittedEvent.ts","../src/application/utils/messageFromQueryEvent.ts","../src/application/utils/messageFromResponse.ts","../src/application/utils/messageFromSuggestionEvent.ts","../src/application/utils/nextMessageRequestToApiRequest.ts","../src/application/utils/nodeSelector.ts","../src/application/utils/overrides.ts","../src/application/utils/stringUtils.ts","../src/application/utils/supportedEventRequestToApiRequest.ts","../src/application/utils/validation.ts"],"sourcesContent":["import Logger from \"src/application/logging/logger\";\nimport {\n  isLegacyUAEcommerceEvent,\n  isGA4EcommerceEvent,\n  isBaseEcommerceEvent,\n  BaseEcommerceEvent,\n} from \"src/application/models\";\nimport { SpiffyMetricsEventName } from \"src/contexts/amplitudeContext\";\n\ndeclare global {\n  interface Window {\n    dataLayer: any[];\n  }\n}\n\nconst NORMALIZED_ADD_TO_CART_EVENT_NAMES = [\"addtocart\", \"addedtocart\"];\nconst CHECK_DATA_LAYER_INTERVAL_MS = 500;\nconst CHECK_DATA_LAYER_MAX_ATTEMPTS = 10;\n\n/**\n * Checks if a Google Analytics event is an add_to_cart event.\n *\n * @param event The event name to check.\n *\n * @returns True if the event is an add_to_cart event, false otherwise.\n */\nconst isAddToCartEvent = (event: string): boolean => {\n  const normalizedEvent = event.replace(/[-_]/g, \"\").toLowerCase();\n  return NORMALIZED_ADD_TO_CART_EVENT_NAMES.some((name) =>\n    normalizedEvent.includes(name)\n  );\n};\n\n/**\n * Tracks an add_to_cart event in Amplitude.\n *\n * @param event The event to track.\n */\nconst handleAddToCartEvent = (\n  event: BaseEcommerceEvent,\n  track: (\n    eventName: SpiffyMetricsEventName,\n    eventProps?: Record<string, unknown>\n  ) => void\n) => {\n  let eventProps: Record<string, unknown>;\n\n  if (isLegacyUAEcommerceEvent(event)) {\n    eventProps = {\n      items: event.ecommerce.add.products.map((product) => ({\n        item_name: product.name,\n        item_category: product.category,\n        price: product.price,\n        quantity: product.quantity,\n      })),\n      currency: event.ecommerce.add.currencyCode,\n      event_format_version: \"legacy_universal_analytics\",\n    };\n  } else if (isGA4EcommerceEvent(event)) {\n    eventProps = {\n      items: event.ecommerce.items.map((item) => ({\n        item_name: item.item_name,\n        item_category: item.item_category,\n        price: item.price,\n        quantity: item.quantity,\n      })),\n      currency: event.ecommerce.currency,\n      event_format_version: \"google_analytics_4\",\n    };\n  } else {\n    eventProps = {\n      event_properties: { ...event },\n      event_format_version: \"unknown\",\n    };\n  }\n\n  track(SpiffyMetricsEventName.AddToCartClicked, {\n    eventProps,\n  });\n};\n\n/**\n * Wraps the window.dataLayer.push method to intercept add_to_cart events and send them to Amplitude.\n * This function runs on an interval until the dataLayer is available.\n */\nexport const initDataLayerWrapper = (\n  track: (\n    eventName: SpiffyMetricsEventName,\n    eventProps?: Record<string, unknown>\n  ) => void\n) => {\n  let attempts = 0;\n\n  // currently, our bundle is always loaded after GTM has initialized GA/dataLayer\n  // we'll need this check here if/when we load spiffy before/outside of GTM\n  const checkAndInitialize = () => {\n    if (!window.dataLayer || !(window.dataLayer as any).push) {\n      attempts += 1;\n\n      if (attempts >= CHECK_DATA_LAYER_MAX_ATTEMPTS) {\n        Logger.logDebug(\n          `[spiffy-ai] dataLayer not available after ${CHECK_DATA_LAYER_MAX_ATTEMPTS} attempts`\n        );\n        return;\n      }\n\n      setTimeout(checkAndInitialize, CHECK_DATA_LAYER_INTERVAL_MS);\n      return;\n    }\n\n    Logger.logDebug(\n      \"[spiffy-ai] dataLayer is available, wrapping push function...\"\n    );\n    const originalPush = window.dataLayer.push;\n    window.dataLayer.push = (...args: unknown[]) => {\n      if (\n        isBaseEcommerceEvent(args[0]) &&\n        isAddToCartEvent((args[0] as any).event)\n      ) {\n        handleAddToCartEvent(args[0] as BaseEcommerceEvent, track);\n      }\n\n      // IMPORTANT: call the original push method so that the event is still logged to GA\n      return originalPush.apply(window.dataLayer, args);\n    };\n  };\n\n  checkAndInitialize();\n};\n\nexport const initAmplitude = (\n  track: (\n    eventName: SpiffyMetricsEventName,\n    eventProps?: Record<string, unknown>\n  ) => void\n) => {\n  // This function might not be needed anymore if Amplitude is initialized via context.\n  // For now, we'll keep it and pass the track function.\n  // If it's truly redundant, it can be removed later.\n  track(SpiffyMetricsEventName.BundleLoaded); // Example usage, adjust as needed\n};\n","import { Context as ApiContext } from '@spiffy-ai/commerce-api-client';\nimport { Context as CoreContext } from '../models';\n\nexport const coreContextToApiContext = (context: CoreContext): ApiContext => ({\n  chat_id: context.chatId,\n  org_id: context.orgId,\n  user_id: context.userId,\n  org_short_name: context.orgShortName,\n  source: context.source,\n  env: context.env,\n});\n","import {\n  UserEvent as ApiUserEvent,\n  PLPAttributeCategory,\n  PLPIdAttributes,\n  UserEventCategory,\n} from '@spiffy-ai/commerce-api-client';\nimport { UserEvent as CoreUserEvent } from '../models';\n\nexport const coreUserEventToApiUserEvent = (data: CoreUserEvent): ApiUserEvent => {\n  if (\n    data.category === UserEventCategory.PdpVisit ||\n    data.category === UserEventCategory.AddToCart\n  ) {\n    return {\n      event_id: data.eventId,\n      created_at: data.createdAt,\n      category: data.category,\n      attributes: {\n        product_id: data.attributes.productId,\n        parent_product_id: data.attributes.parentProductId,\n        url: data.attributes.url,\n      },\n    };\n  }\n\n  if (data.category === UserEventCategory.PlpVisit) {\n    return {\n      event_id: data.eventId,\n      created_at: data.createdAt,\n      category: data.category,\n      attributes: {\n        category: PLPAttributeCategory.Id,\n        attributes: {\n          // we're only handling id attributes for now\n          id: (data.attributes.attributes as PLPIdAttributes).id,\n        },\n      },\n    };\n  }\n\n  if (data.category === UserEventCategory.QueryTyped) {\n    return {\n      event_id: data.eventId,\n      created_at: data.createdAt,\n      category: data.category,\n      attributes: {\n        query: data.attributes.query,\n      },\n    };\n  }\n\n  if (data.category === UserEventCategory.Search) {\n    return {\n      event_id: data.eventId,\n      created_at: data.createdAt,\n      category: data.category,\n      attributes: {\n        search_term: data.attributes.searchTerm,\n        selected_filters: data.attributes.selectedFilters,\n      },\n    };\n  }\n\n  if (data.category === UserEventCategory.SuggestionClicked) {\n    return {\n      event_id: data.eventId,\n      created_at: data.createdAt,\n      category: data.category,\n      attributes: {\n        suggestion_id: data.attributes.suggestionId,\n      },\n    };\n  }\n\n  if (data.category === UserEventCategory.PageVisit) {\n    return {\n      event_id: data.eventId,\n      created_at: data.createdAt,\n      category: data.category,\n      attributes: {\n        url: data.attributes.url,\n        page_visit_category: data.attributes.pageVisitCategory,\n      },\n    };\n  }\n\n  if (data.category === UserEventCategory.FormSubmitted) {\n    return {\n      event_id: data.eventId,\n      created_at: data.createdAt,\n      category: data.category,\n      attributes: {\n        filled_schema: { ...data.attributes.filledSchema },\n        form_response_id: data.attributes.formResponseId,\n        form_type: data.attributes.formType,\n      },\n    };\n  }\n\n  // This is the default app_loaded event, when we start to use app_unloaded we need to handle it here\n  return {\n    event_id: data.eventId,\n    created_at: data.createdAt,\n    category: data.category,\n  };\n};\n","export const divideArray = <T>(array: T[], size: number) => {\n  const rows = [];\n  for (let i = 0; i < size; i += 1) {\n    rows.push(array.filter((_: T, index: number) => index % size === i));\n  }\n  return rows;\n};\n","const compareTokens = (original: string, comparison: string) => {\n  const originalTokens = new Set(original.split(' '));\n  const comparisonTokens = new Set(comparison.split(' '));\n  return [...originalTokens].filter((token) => !comparisonTokens.has(token));\n};\n\nexport class MutationHelper {\n  static fireClassChange(\n    record: MutationRecord,\n    node: HTMLElement | null,\n    fn: (classes: DOMTokenList) => void,\n  ) {\n    if (node && record.oldValue !== node?.classList.value) {\n      fn(node?.classList);\n    }\n  }\n\n  static fireClassAdded(\n    record: MutationRecord,\n    node: HTMLElement | null,\n    classMap: Map<string, () => void>,\n  ) {\n    if (node && record.oldValue) {\n      const tokens = compareTokens(node?.classList.value, record.oldValue);\n      tokens.forEach((className) => classMap.get(className)?.());\n    }\n  }\n\n  static fireClassRemoved(\n    record: MutationRecord,\n    node: HTMLElement | null,\n    classMap: Map<string, () => void>,\n  ) {\n    if (node && record.oldValue) {\n      const tokens = compareTokens(record.oldValue, node?.classList.value);\n      tokens.forEach((className) => classMap.get(className)?.());\n    }\n  }\n\n  static fireSubtreeChange(nodes: NodeList, fn?: (nodes: NodeList) => void) {\n    nodes.length && fn?.(nodes);\n  }\n\n  static isClass(mutation: MutationRecord) {\n    return mutation.type === 'attributes' && mutation.attributeName === 'class';\n  }\n\n  static isChildList(mutation: MutationRecord) {\n    return mutation.type === 'childList';\n  }\n}\n","import { ReactElement } from 'react';\nimport { createPortal } from 'react-dom';\nimport { MouseEventTypes } from './mouseEventTypes';\nimport { MutationHelper } from './mutationHelper';\nimport { NodeSelector } from './nodeSelector';\n\n/**\n * The `ElementObserver` class monitors all changes related to the specific element it is responsible for.\n * It is automatically instantiated by the `useElementObserver` hook, which manages all instances of this class.\n *\n * How it works:\n *\n * Each instance of `ElementObserver` holds several pieces of information related to the node it is monitoring,\n * such as the node's selector and its `MutationObserver`. This class is responsible for translating raw node\n * changes into a more user-friendly format. For example, when the node is added to the DOM, the `ElementObserver`\n * is notified by the `DOMObserver`, which triggers the `onAdd` callback function on the respective `useElementObserver`\n * instance.\n *\n * Instances of `ElementObserver` are fully managed by the `useElementObserver` hook, requiring no additional configuration.\n * When the hook is destroyed, its corresponding `ElementObserver` instance is automatically removed.\n *\n */\nexport class ElementObserver {\n  private mutation: MutationObserver | null;\n\n  private node: HTMLElement | null;\n\n  private selector: NodeSelector;\n\n  private eventListeners: Map<keyof HTMLElementEventMap, EventListenerOrEventListenerObject>;\n\n  private classAdded: Map<string, () => void>;\n\n  private classRemoved: Map<string, () => void>;\n\n  private nodeDisplay: string;\n\n  private addFn: (el: HTMLElement | null) => void;\n\n  private removeFn: (el: HTMLElement | null) => void;\n\n  private changeFn: (el: HTMLElement | null) => void;\n\n  private classChangeFn: (classes?: DOMTokenList) => void;\n\n  private addChildFn?: () => void;\n\n  private removeChildFn?: () => void;\n\n  private resetFn: () => void;\n\n  constructor(selector: NodeSelector) {\n    this.selector = selector;\n    this.mutation = null;\n    this.node = null;\n    this.eventListeners = new Map();\n    this.classAdded = new Map();\n    this.classRemoved = new Map();\n    this.nodeDisplay = 'block';\n    this.addFn = () => {};\n    this.removeFn = () => {};\n    this.changeFn = () => {};\n    this.classChangeFn = () => {};\n    this.addChildFn = undefined;\n    this.removeChildFn = undefined;\n    this.resetFn = () => {};\n  }\n\n  private handleAttributes(mutationRecord: MutationRecord[]) {\n    mutationRecord.filter(MutationHelper.isClass).forEach((mutation) => {\n      MutationHelper.fireClassChange(mutation, this.node, this.classChangeFn);\n      MutationHelper.fireClassAdded(mutation, this.node, this.classAdded);\n      MutationHelper.fireClassRemoved(mutation, this.node, this.classRemoved);\n    });\n  }\n\n  private handleChildList(mutationRecord: MutationRecord[]) {\n    if (!this.addChildFn && !this.removeChildFn) {\n      return;\n    }\n\n    mutationRecord.filter(MutationHelper.isChildList).forEach((mutation) => {\n      MutationHelper.fireSubtreeChange(mutation.addedNodes, this.addChildFn);\n      MutationHelper.fireSubtreeChange(mutation.removedNodes, this.removeChildFn);\n    });\n  }\n\n  private addInitialListeners() {\n    this.eventListeners.forEach((v, k) => this.node?.addEventListener(k, v));\n  }\n\n  private clearEventListeners() {\n    this.eventListeners.forEach((v, k) => this.node?.removeEventListener(k, v));\n    this.eventListeners.clear();\n  }\n\n  private renew(newNode: Node | null) {\n    if (newNode) {\n      this.destroy();\n      this.watch(newNode);\n    }\n  }\n\n  getSelector() {\n    return this.selector;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  synchronize() {\n    const parsedNode = this.getSelector().parse();\n\n    if (this.getNode() !== parsedNode) {\n      this.renew(parsedNode);\n      return;\n    }\n\n    if (!this.getNode() && parsedNode) {\n      this.watch(parsedNode);\n      return;\n    }\n\n    if (this.getNode() && !parsedNode) {\n      this.destroy();\n    }\n  }\n\n  init() {\n    const node = this.getSelector().parse();\n    if (node) {\n      this.watch(node);\n    }\n  }\n\n  watch(node: Node) {\n    if (!this.mutation) {\n      this.mutation = new MutationObserver((mutationRecord) => {\n        this.handleAttributes(mutationRecord);\n        this.handleChildList(mutationRecord);\n        this.changeFn(this.node);\n      });\n      this.mutation.observe(node, {\n        childList: true,\n        subtree: true,\n        attributes: true,\n        attributeOldValue: true,\n      });\n      this.node = node as HTMLElement;\n      this.addFn(this.node);\n      this.addInitialListeners();\n    }\n  }\n\n  destroy() {\n    this.resetFn();\n    this.removeFn(this.node);\n    this.mutation?.disconnect();\n    this.clearEventListeners();\n    this.classAdded.clear();\n    this.classRemoved.clear();\n    this.mutation = null;\n    this.node = null;\n  }\n\n  render(fn: () => ReactElement) {\n    if (this.node) {\n      return createPortal(fn(), this.node);\n    }\n  }\n\n  fire(event: MouseEventTypes) {\n    if (this.node) {\n      this.node.dispatchEvent(\n        new MouseEvent(event, {\n          bubbles: true,\n          cancelable: true,\n          view: window,\n        }),\n      );\n    }\n  }\n\n  show() {\n    const display = this.node?.style.display;\n    if (this.node && display === 'none') {\n      this.node.style.display = this.nodeDisplay || 'block';\n    }\n  }\n\n  hide() {\n    const display = this.node?.style.display;\n    if (this.node && display !== 'none') {\n      this.nodeDisplay = display || 'block';\n      this.node.style.display = 'none';\n    }\n  }\n\n  registerEvent(event: keyof HTMLElementEventMap, fn: EventListenerOrEventListenerObject) {\n    if (this.node) {\n      const previousFn = this.eventListeners.get(event);\n      if (previousFn) {\n        this.node.removeEventListener(event, previousFn);\n      }\n      this.node.addEventListener(event, fn);\n    }\n    this.eventListeners.set(event, fn);\n  }\n\n  registerOnReset(fn: () => void) {\n    this.resetFn = fn;\n  }\n\n  registerOnChange(fn: (el: HTMLElement | null) => void) {\n    this.changeFn = fn;\n  }\n\n  registerOnAdd(fn: (el: HTMLElement | null) => void) {\n    this.addFn = fn;\n  }\n\n  registerOnRemove(fn: (el: HTMLElement | null) => void) {\n    this.removeFn = fn;\n  }\n\n  registerOnclassChange(fn: (classes?: DOMTokenList) => void) {\n    this.classChangeFn = fn;\n  }\n\n  registerOnAddChild(fn: (classes?: DOMTokenList) => void) {\n    this.addChildFn = fn;\n  }\n\n  registerOnRemoveChild(fn: (classes?: DOMTokenList) => void) {\n    this.removeChildFn = fn;\n  }\n\n  registerOnClassAdded(className: string, fn: () => void) {\n    this.classAdded.set(className, fn);\n  }\n\n  registerOnClassRemoved(className: string, fn: () => void) {\n    this.classRemoved.set(className, fn);\n  }\n}\n","import { ElementObserver } from './elementObserver';\nimport { NodeSelector } from './nodeSelector';\n\n/**\n * This class manages a `MutationObserver` for the `document.body`. It monitors nodes that are\n * added or removed from the DOM and notifies the observers for each observable element\n * when they are ready to be watched.\n *\n * How that works:\n *\n * When the `observe` function is called, it attaches a `MutationObserver` to the `document.body` element.\n * All changes to `document.body` are tracked by this observer. When changes are detected, the `MutationObserver`\n * iterates through all added and removed nodes and checks if each node exists in the main map of observable elements.\n *\n * If a match is found, it notifies the corresponding `ElementObserver` instance to start monitoring changes for that element.\n *\n * The primary `MutationObserver` remains active until the `destroy` function is called. Calling `destroy` will disconnect all\n * individual element observers and release any associated resources.\n *\n * There is no need to explicitly call the `observe` function. It is automatically invoked when a `useElementObserver` hook is instantiated.\n *\n */\nexport class DOMObserver {\n  private static documentObserver: MutationObserver | null;\n  private static listeners: Map<string, ElementObserver> = new Map();\n\n  private static notifyAdition(records: MutationRecord[], nodeMapping: Map<Node, ElementObserver>) {\n    records.forEach((record) =>\n      record.addedNodes.forEach((node) => {\n        nodeMapping.get(node)?.watch(node);\n        nodeMapping.delete(node);\n      }),\n    );\n  }\n\n  private static notifyRemoval(records: MutationRecord[], nodeMapping: Map<Node, ElementObserver>) {\n    records.forEach((record) =>\n      record.removedNodes.forEach((node) => {\n        nodeMapping.get(node)?.destroy();\n        nodeMapping.delete(node);\n      }),\n    );\n  }\n\n  private static notifyChildrenChanges(nodeMapping: Map<Node, ElementObserver>) {\n    Array.from(nodeMapping.values()).forEach((observer) => observer.synchronize());\n  }\n\n  private static mapNodeInstancesToListeners(): Map<Node, ElementObserver> {\n    const nodeMapping = new Map<Node, ElementObserver>();\n    this.listeners.forEach((observer) => {\n      const node = observer.getNode() || observer.getSelector()?.parse();\n      if (node) {\n        nodeMapping.set(node, observer);\n      }\n    });\n    return nodeMapping;\n  }\n\n  static add(selector: NodeSelector): ElementObserver {\n    const node = selector.getPattern();\n    let elementObserver = this.listeners.get(node);\n    if (elementObserver) {\n      return elementObserver;\n    }\n\n    elementObserver = new ElementObserver(selector);\n    this.listeners.set(node, elementObserver);\n    return elementObserver;\n  }\n\n  static remove(selector: NodeSelector) {\n    const node = selector.getPattern();\n    this.listeners.get(node)?.destroy();\n    this.listeners.delete(node);\n  }\n\n  static observe() {\n    if (!this.documentObserver) {\n      this.documentObserver = new MutationObserver((mutations) => {\n        const nodeMapping = this.mapNodeInstancesToListeners();\n        this.notifyAdition(mutations, nodeMapping);\n        this.notifyRemoval(mutations, nodeMapping);\n        this.notifyChildrenChanges(nodeMapping);\n      });\n      this.documentObserver.observe(document.body, { childList: true, subtree: true });\n    }\n  }\n\n  static destroy() {\n    this.documentObserver?.disconnect();\n    this.listeners.forEach((listener) => listener.destroy());\n    this.listeners.clear();\n    this.documentObserver = null;\n  }\n}\n","import { Message, MessageType, ProductMessageMetadata } from 'src/application/models';\n\nexport const getRecentProductImageUrls = (lastMessages: Message[], currentProductId: string | undefined) => {\n  const productMessages = lastMessages\n    .filter((message) => message.type === MessageType.Product && message.metadata?.imageUrl)\n    .map((m) => m as ProductMessageMetadata);\n  // put added product image at the top of the list\n  return [\n    ...productMessages.filter((m) => m.metadata?.id === currentProductId),\n    ...productMessages.filter((m) => m.metadata?.id !== currentProductId),\n  ].map((m) => m.metadata!.imageUrl!);\n};\n","export const prepareMerchantPage = () => {\n  let metaViewport = document.querySelector(\"meta[name='viewport']\");\n  if (metaViewport) {\n    const content = metaViewport.getAttribute(\"content\")\n    const hasMaximumScale = content?.includes(\"maximum-scale=1\")\n    if (!hasMaximumScale) {\n      metaViewport.setAttribute(\"content\", `${content}, maximum-scale=1`)\n    }\n    return\n  }\n\n  metaViewport = document.createElement(\"meta\");\n  metaViewport.setAttribute(\"name\", \"viewport\")\n  metaViewport.setAttribute(\"content\", \"width=device-width, initial-scale=1, maximum-scale=1\")\n  document.head.appendChild(metaViewport);\n}\n","import { UserEventCategory } from '@spiffy-ai/commerce-api-client';\nimport {\n  FormResponseAttributes,\n  Message,\n  MessageRole,\n  MessageType,\n  UserEvent,\n} from 'src/application/models';\n\nexport const messageFromFormSubmittedEvent = (\n  event: UserEvent,\n  formResponseAttributes: FormResponseAttributes['attributes'],\n): Message | undefined => {\n  if (event.category !== UserEventCategory.FormSubmitted) {\n    return undefined;\n  }\n\n  const formStringContents = Object.entries(formResponseAttributes.schema.properties)\n    .map(([key, value]) => `${value.title}: ${event.attributes.filledSchema[key]}`)\n    .join('\\n');\n\n  return {\n    id: event.eventId,\n    role: MessageRole.User,\n    type: MessageType.QueryTyped,\n    createdAt: event.createdAt,\n    metadata: {\n      content: formStringContents,\n    },\n  };\n};\n","import { UserEventCategory } from '@spiffy-ai/commerce-api-client';\nimport { Message, MessageRole, MessageType, UserEvent } from 'src/application/models';\n\n/**\n * Transforms a query UserEvent object into a Message object for presentation.\n *\n * @param event The user event object received from the server\n *\n * @returns A Message if the event is a query event, otherwise undefined\n */\nexport const messageFromQueryEvent = (event: UserEvent): Message | undefined => {\n  if (event.category === UserEventCategory.QueryTyped) {\n    return {\n      id: event.eventId,\n      role: MessageRole.User,\n      type: MessageType.QueryTyped,\n      createdAt: event.createdAt,\n      metadata: {\n        content: event.attributes.query,\n      },\n    };\n  }\n\n  if (event.category === UserEventCategory.Search) {\n    return {\n      id: event.eventId,\n      role: MessageRole.User,\n      type: MessageType.Search,\n      createdAt: event.createdAt,\n      metadata: {\n        searchTerm: event.attributes.searchTerm || '',\n        selectedFilters: event.attributes.selectedFilters || [],\n      },\n    };\n  }\n\n  return undefined;\n};\n","import { ResponseCategory } from '@spiffy-ai/commerce-api-client';\nimport { Message, MessageRole, MessageType, Response } from 'src/application/models';\n\n/**\n * Transforms a server Response object into a Message object for presentation.\n *\n * @param response The response object received from the server containing model generated content\n *\n * @returns A Message if the response contains known attributes, undefined otherwise\n */\nexport const messageFromResponse = (response?: Response): Message | undefined => {\n  if (response == null) {\n    return undefined;\n  }\n\n  if (response.category === ResponseCategory.Text) {\n    return {\n      id: response.id,\n      createdAt: response.createdAt,\n      type: MessageType.Text,\n      role: MessageRole.Assistant,\n      metadata: {\n        content: response.attributes.content,\n      },\n    };\n  }\n\n  if (response.category === ResponseCategory.Product) {\n    return {\n      id: response.id,\n      createdAt: response.createdAt,\n      role: MessageRole.Assistant,\n      type: MessageType.Product,\n      metadata: {\n        ...response.attributes,\n      },\n    };\n  }\n\n  if (response.category === ResponseCategory.Review) {\n    return {\n      id: response.id,\n      createdAt: response.createdAt,\n      type: MessageType.Review,\n      role: MessageRole.Assistant,\n      metadata: {\n        review: response.attributes.review,\n        reviewer: response.attributes.reviewer,\n        stars: response.attributes.stars,\n        title: response.attributes.title,\n        richInformation: response.attributes.richInformation,\n      },\n    };\n  }\n\n  if (response.category === ResponseCategory.Separator) {\n    return {\n      id: response.id,\n      createdAt: response.createdAt,\n      type: MessageType.Separator,\n      role: MessageRole.Assistant,\n    };\n  }\n\n  if (response.category === ResponseCategory.Page) {\n    return {\n      id: response.id,\n      createdAt: response.createdAt,\n      role: MessageRole.Assistant,\n      type: MessageType.Page,\n      metadata: {\n        ...response.attributes,\n      },\n    };\n  }\n\n  if (response.category === ResponseCategory.ProductSearch) {\n    return {\n      id: response.id,\n      createdAt: response.createdAt,\n      role: MessageRole.Assistant,\n      type: MessageType.ProductSearch,\n      metadata: {\n        ...response.attributes,\n      },\n    };\n  }\n\n  if (response.category === ResponseCategory.ProductSearchFilter) {\n    return {\n      id: response.id,\n      createdAt: response.createdAt,\n      role: MessageRole.Assistant,\n      type: MessageType.ProductSearchFilter,\n      metadata: {\n        ...response.attributes,\n      },\n    };\n  }\n\n  if (response.category === ResponseCategory.Form) {\n    return {\n      id: response.id,\n      createdAt: response.createdAt,\n      role: MessageRole.Assistant,\n      type: MessageType.Form,\n      metadata: {\n        formType: response.attributes.formCategory?.formType,\n        fields: Object.entries(response.attributes.schema.properties).map(([key, value]) => ({\n          key,\n          title: value.title,\n          type: value.type,\n          format: value.format,\n          required: response.attributes.schema.required.includes(key),\n        })),\n      },\n    };\n  }\n\n  if (response.category === ResponseCategory.Order) {\n    return {\n      id: response.id,\n      createdAt: response.createdAt,\n      role: MessageRole.Assistant,\n      type: MessageType.Order,\n      metadata: {\n        ...response.attributes,\n      },\n    };\n  }\n\n  return undefined;\n};\n","import { UserEventCategory } from '@spiffy-ai/commerce-api-client';\nimport { Message, MessageRole, MessageType, Suggestion, UserEvent } from 'src/application/models';\n\n/**\n * Transforms a UserEvent object into a Message object for presentation.\n *\n * @param event The UserEvent object received from the server\n * @param suggestions A list of generated suggestions to match the event to\n *\n * @returns A Message if the event is a suggestion click event, undefined otherwise\n */\nexport const messageFromSuggestionEvent = (\n  event: UserEvent,\n  suggestions: Suggestion[],\n): Message | undefined => {\n  if (event.category === UserEventCategory.SuggestionClicked) {\n    const { suggestionId } = event.attributes;\n\n    return {\n      id: event.eventId,\n      role: MessageRole.User,\n      type: MessageType.SuggestionClicked,\n      createdAt: event.createdAt,\n      metadata: {\n        suggestionId,\n        suggestionContent: suggestions.find((s) => s.id === suggestionId)?.content ?? '',\n      },\n    };\n  }\n\n  return undefined;\n};\n","import { NextMessageRequest as ApiNextMessageRequest } from '@spiffy-ai/commerce-api-client';\nimport { NextMessageRequest } from '../models';\nimport { coreUserEventToApiUserEvent } from './coreUserEventToApiUserEvent';\n\nexport const messageRequestToCommerceMessageRequest = (\n  data: NextMessageRequest,\n): ApiNextMessageRequest => ({\n  context: {\n    chat_id: data.context.chatId,\n    org_id: data.context.orgId,\n    org_short_name: data.context.orgShortName,\n    user_id: data.context.userId,\n    source: data.context.source,\n    env: data.context.env,\n  },\n  id: data.id,\n  feature_flags: data.featureFlags,\n  user_events: data.userEvents?.map((userEvent) => coreUserEventToApiUserEvent(userEvent)),\n  generation_params: {\n    model: data.generationParams?.model,\n    max_tokens: data.generationParams?.maxTokens,\n    stop: data.generationParams?.stop,\n    stream: data.generationParams?.stream,\n    temperature: data.generationParams?.temperature,\n    top_p: data.generationParams?.topP,\n    num_suggestions: data.generationParams?.numSuggestions,\n    response_system_prompt: data.generationParams?.responseSystemPrompt,\n    suggestion_system_prompt: data.generationParams?.suggestionSystemPrompt,\n    response_caching: data.generationParams?.responseCaching,\n  },\n});\n","export abstract class NodeSelector {\n  private pattern: string;\n  private root: Document;\n\n  constructor(pattern: string) {\n    this.pattern = pattern;\n    this.root = document;\n  }\n\n  getPattern() {\n    return this.pattern;\n  }\n\n  setRoot(root: Document) {\n    this.root = root;\n  }\n\n  getRoot() {\n    return this.root;\n  }\n\n  abstract parse(): Node | null;\n}\n\nclass QuerySelector extends NodeSelector {\n  parse(): Node | null {\n    return this.getRoot().querySelector(this.getPattern());\n  }\n}\n\nclass IDSelector extends NodeSelector {\n  parse(): Node | null {\n    return this.getRoot().getElementById(this.getPattern()) as Node;\n  }\n}\n\nclass XpathSelector extends NodeSelector {\n  parse(): Node | null {\n    return this.getRoot()?.evaluate(\n      this.getPattern(),\n      this.getRoot(),\n      null,\n      XPathResult.FIRST_ORDERED_NODE_TYPE,\n      null,\n    )?.singleNodeValue as Node;\n  }\n}\n\nclass ChainSelector extends NodeSelector {\n  parse(): Node | null {\n    let selectorIndex = 0;\n    const selectors = this.getPattern().split('@');\n    const lastIndex = selectors.length - 1;\n\n    const parseChain = (pattern: string, prevNode?: Node | null): Node | null => {\n      const selector = SelectorFactory.parse(pattern);\n\n      if (prevNode) {\n        selector.setRoot(prevNode as Document);\n      }\n\n      const currentNode = selector.parse();\n      if (selectorIndex === lastIndex) {\n        return currentNode;\n      }\n\n      let node: Node | null | undefined = currentNode || document;\n      if ((currentNode as HTMLElement)?.shadowRoot) {\n        node = (currentNode as HTMLElement).shadowRoot;\n      }\n\n      if ((currentNode as HTMLIFrameElement)?.contentWindow) {\n        node = (currentNode as HTMLIFrameElement).contentWindow?.document;\n      }\n\n      return parseChain(selectors[++selectorIndex].trim(), node);\n    };\n\n    return parseChain(selectors[selectorIndex].trim());\n  }\n}\n\nclass Empty extends NodeSelector {\n  constructor() {\n    super('');\n  }\n  parse(): Node | null {\n    return null;\n  }\n}\n\nexport class SelectorFactory {\n  static parse(composedSelector?: string) {\n    if (!composedSelector) {\n      return new Empty();\n    }\n\n    const split = composedSelector.split('|');\n    const type = split[0];\n    const selector = split[1];\n\n    switch (type) {\n      case 'id':\n        return this.id(selector);\n      case 'query':\n        return this.query(selector);\n      case 'xpath':\n        return this.xpath(selector);\n      default:\n        return new Empty();\n    }\n  }\n\n  static check(selector?: NodeSelector) {\n    return selector ?? new Empty();\n  }\n\n  static chain(pattern?: string) {\n    return pattern ? new ChainSelector(pattern) : new Empty();\n  }\n\n  static id(pattern?: string): NodeSelector {\n    return pattern ? new IDSelector(pattern) : new Empty();\n  }\n\n  static query(pattern?: string): NodeSelector {\n    return pattern ? new QuerySelector(pattern) : new Empty();\n  }\n\n  static xpath(pattern?: string): NodeSelector {\n    return pattern ? new XpathSelector(pattern) : new Empty();\n  }\n}\n","export type ReplaceOp<T> = { $replace: T };\nexport type DeleteOp = { $delete: true };\n\n// Treat these as atomic values (not recursed into)\ntype Builtin = Date | RegExp | ((...args: unknown[]) => unknown);\n\ntype Primitive = string | number | boolean | bigint | symbol | null | undefined;\n\n/**\n * Override<T> is a DeepPartial-like type with special operators:\n * - { $replace: T } to replace an entire subtree/array\n * - { $delete: true } to delete an object key\n *\n * Arrays behavior:\n * - Arrays of objects: merge-by-index by default (unless `arrayStrategy: 'replace'` or `$replace` is used)\n * - Arrays of primitives (string/number/boolean/...): replaced by default when a patch array is provided\n */\nexport type Override<T> =\n  // atomic\n  T extends Primitive | Builtin\n    ? T | ReplaceOp<T> | DeleteOp\n    : // arrays\n      T extends (infer U)[]\n      ? Array<Override<U> | undefined> | ReplaceOp<T>\n      : // maps/sets – keep simple: only allow full replace\n        T extends Map<unknown, unknown> | Set<unknown>\n        ? ReplaceOp<T>\n        : // objects\n          T extends object\n          ? { [K in keyof T]?: Override<T[K]> | DeleteOp | null } | ReplaceOp<T>\n          : T;\n\nexport type MergeOptions = {\n  /**\n   * How to treat arrays when patch provides an array (not $replace):\n   * - 'replace': always use patch array as whole value\n   * - 'mergeByIndex': merge each index recursively (default for arrays of objects)\n   * Note: Arrays of primitives are replaced by default regardless of this option.\n   */\n  arrayStrategy?: 'replace' | 'mergeByIndex';\n  /**\n   * If true, a `null` patch value deletes the key from an object (RFC 7396-ish)\n   */\n  nullDeletes?: boolean;\n};\n\n// Prevents T from being inferred from the 'patch' parameter; it must be inferred from 'base'.\n// See: https://github.com/microsoft/TypeScript/issues/14829#issuecomment-504042546\ntype NoInfer<T> = [T][T extends unknown ? 0 : never];\n\nfunction isPlainObject(x: unknown): x is Record<string, unknown> {\n  return (\n    !!x &&\n    typeof x === 'object' &&\n    !Array.isArray(x) &&\n    !(x instanceof Date) &&\n    !(x instanceof RegExp)\n  );\n}\n\nfunction isReplace(x: unknown): x is ReplaceOp<unknown> {\n  return !!x && typeof x === 'object' && '$replace' in (x as Record<string, unknown>);\n}\nfunction isDelete(x: unknown): x is DeleteOp {\n  return !!x && typeof x === 'object' && (x as Record<string, unknown>).$delete === true;\n}\n\nfunction isPrimitiveValue(x: unknown): boolean {\n  const t = typeof x;\n  return (\n    x === null ||\n    t === 'string' ||\n    t === 'number' ||\n    t === 'boolean' ||\n    t === 'bigint' ||\n    t === 'symbol' ||\n    t === 'undefined'\n  );\n}\n\nfunction isArrayOfPrimitives(arr: unknown[]): boolean {\n  if (arr.length === 0) return false; // ambiguous, default to merge-by-index on empty\n  // If every defined element is primitive, treat as primitives\n  for (let i = 0; i < arr.length; i += 1) {\n    const v = arr[i];\n    if (v !== undefined && !isPrimitiveValue(v)) return false;\n  }\n  return true;\n}\n\nfunction mergeAny(baseAny: unknown, patchAny: unknown, opts: MergeOptions): unknown {\n  if (isReplace(patchAny)) return patchAny.$replace as unknown;\n  if (isDelete(patchAny)) return undefined; // caller deletes the key\n\n  if (Array.isArray(baseAny)) {\n    if (Array.isArray(patchAny)) {\n      const baseArr = baseAny as unknown[];\n      const patchArr = patchAny as unknown[];\n      const shouldReplace =\n        opts.arrayStrategy === 'replace' ||\n        isArrayOfPrimitives(baseArr) ||\n        isArrayOfPrimitives(patchArr);\n      if (shouldReplace) return patchAny as unknown;\n      const out = baseArr.slice();\n      const max = Math.max(out.length, patchArr.length);\n      for (let i = 0; i < max; i += 1) {\n        const pVal = patchArr[i];\n        if (pVal !== undefined) {\n          out[i] = mergeAny(out[i], pVal, opts);\n        }\n      }\n      return out as unknown;\n    }\n    return baseAny as unknown;\n  }\n\n  if (isPlainObject(baseAny) && isPlainObject(patchAny)) {\n    const baseObj = baseAny as Record<string, unknown>;\n    const patchObj = patchAny as Record<string, unknown>;\n    const out: Record<string, unknown> = { ...baseObj };\n    for (const key of Object.keys(patchObj)) {\n      const pVal = patchObj[key];\n      if (pVal === undefined) {\n        // leave as-is\n      } else if (opts.nullDeletes && pVal === null) {\n        delete out[key];\n      } else if (isReplace(pVal)) {\n        out[key] = pVal.$replace;\n      } else if (isDelete(pVal)) {\n        delete out[key];\n      } else {\n        out[key] = mergeAny(baseObj?.[key], pVal, opts);\n      }\n    }\n    return out as unknown;\n  }\n\n  return (patchAny as unknown) ?? baseAny;\n}\n\nexport function applyOverrides<T>(\n  base: T,\n  patch: Override<NoInfer<T>>,\n  opts: MergeOptions = {},\n): T {\n  const { arrayStrategy = 'mergeByIndex', nullDeletes = false } = opts;\n\n  // Handle whole-node control operators on patch itself\n  if (isReplace(patch)) return patch.$replace as T;\n  if (isDelete(patch)) return undefined as unknown as T;\n\n  // Arrays\n  if (Array.isArray(base)) {\n    if (isReplace(patch)) return patch.$replace as T;\n    if (Array.isArray(patch)) {\n      if (arrayStrategy === 'replace') return patch as unknown as T;\n      // merge by index\n      const out = (base as unknown[]).slice();\n      const max = Math.max(out.length, patch.length);\n      for (let i = 0; i < max; i += 1) {\n        const pVal = (patch as unknown[])[i];\n        if (pVal !== undefined) {\n          out[i] = mergeAny(out[i], pVal, opts);\n        }\n      }\n      return out as unknown as T;\n    }\n    // invalid patch type for an array → ignore and return base\n    return base as T;\n  }\n\n  // Plain objects\n  if (isPlainObject(base) && isPlainObject(patch)) {\n    const out: Record<string, unknown> = { ...(base as Record<string, unknown>) };\n    const patchObj = patch as Record<string, unknown>;\n    for (const key of Object.keys(patchObj)) {\n      const pVal = patchObj[key];\n      if (pVal === undefined) {\n        // leave existing value\n      } else if (nullDeletes && pVal === null) {\n        delete out[key];\n      } else if (isReplace(pVal)) {\n        out[key] = pVal.$replace;\n      } else if (isDelete(pVal)) {\n        delete out[key];\n      } else {\n        const bVal = (base as Record<string, unknown>)[key];\n        out[key] = mergeAny(bVal, pVal, opts);\n      }\n    }\n    return out as unknown as T;\n  }\n\n  // For primitives or when patch is primitive, patch wins if defined\n  return ((patch as unknown) ?? base) as T;\n}\n","\nclass StringUtils {\n  static isNullOrEmpty(value: string | undefined): boolean {\n    const valueTrimmed = value?.trim();\n    return value === undefined || valueTrimmed === '';\n  }\n\n  static trimToNull(value: string | undefined): string | undefined {\n    const valueTrimmed = value?.trim();\n    return StringUtils.isNullOrEmpty(valueTrimmed) ? undefined : valueTrimmed;\n  }\n\n  static capitalize(type: string | undefined) {\n    if (type === undefined) {\n      return '';\n    }\n    return type.charAt(0).toUpperCase() + type.substring(1);\n  }\n\n  /**\n   * Finds the first pattern in an array that matches a given URL.\n   * Patterns can include a single wildcard '*' which matches any sequence of characters.\n   *\n   * @param patterns\n   * @param urlToTest\n   * @returns\n   */\n  static findMatchingPattern(patterns: string[], urlToTest: Location): string | undefined {\n    if (!urlToTest) {\n      return undefined;\n    }\n\n    for (const pattern of patterns) {\n      // Test only if a pathname is present.\n      if (urlToTest.pathname !== '/') {\n        // Escape special regex characters in the pattern\n        // This ensures that characters like '.', '+', '?', '(', etc., in the pattern are treated literally.\n        const escapedPattern = pattern.replace(/[.+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\n        // Replace the wildcard '*' with its regex equivalent '.*' (matches any character zero or more times)\n        const regexPattern = escapedPattern.replace(/\\*/g, '.*');\n\n        const regex = new RegExp(`^${regexPattern}$`);\n        if (regex.test(urlToTest.pathname)) {\n          return pattern;\n        }\n\n      } else if (pattern.startsWith(urlToTest.hostname)) {\n        return pattern;\n      }\n    }\n  }\n}\n\nexport { StringUtils };\n","import { SupportedEventRequest as ApiSupportedEventRequest } from '@spiffy-ai/commerce-api-client';\nimport { SupportedEventRequest as CoreSupportedEventRequest } from '../models/api/supportedEventRequest';\nimport { coreUserEventToApiUserEvent } from './coreUserEventToApiUserEvent';\nimport { coreContextToApiContext } from './coreContextToApiContext';\n\nexport const coreSupportedEventRequestToApiRequest = (\n  coreSupportedEventRequest: CoreSupportedEventRequest,\n): ApiSupportedEventRequest => ({\n  id: coreSupportedEventRequest.id,\n  user_event: coreUserEventToApiUserEvent(coreSupportedEventRequest.userEvent),\n  context: coreContextToApiContext(coreSupportedEventRequest.context),\n});\n","// This email validates that there are one or more characters before the `@` symbol,\n// one or more characters between the `@` symbol and the `.` symbol,\n// and one or more characters after the `.` symbol\n// It does NOT validate all possible email formats, but it is a decent place to start.\nexport const validateEmail = (value: string): boolean => /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(value);\n"],"mappings":"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"}