@od-oneapp/analytics 2026.1.1301

package/dist/ecommerce-Cgu4wlux.mjs

@@ -0,0 +1,993 @@
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
+import { o as track } from "./emitters-6-nKo8i-.mjs";
+
+//#region src/shared/emitters/ecommerce/types.ts
+const ECOMMERCE_EVENTS = {
+	PRODUCT_CLICKED: "Product Clicked",
+	PRODUCT_COMPARED: "Product Compared",
+	PRODUCT_LIST_FILTERED: "Product List Filtered",
+	PRODUCT_LIST_VIEWED: "Product List Viewed",
+	PRODUCT_RECOMMENDATION_CLICKED: "Product Recommendation Clicked",
+	PRODUCT_RECOMMENDATION_VIEWED: "Product Recommendation Viewed",
+	PRODUCT_SEARCHED: "Product Searched",
+	PRODUCT_VIEWED: "Product Viewed",
+	SEARCH_RESULTS_VIEWED: "Search Results Viewed",
+	CART_ABANDONED: "Cart Abandoned",
+	CART_UPDATED: "Cart Updated",
+	CART_VIEWED: "Cart Viewed",
+	CHECKOUT_PROGRESSED: "Checkout Progressed",
+	ORDER_CANCELLED: "Order Cancelled",
+	ORDER_COMPLETED: "Order Completed",
+	ORDER_FAILED: "Order Failed",
+	ORDER_REFUNDED: "Order Refunded",
+	ORDER_STATUS_UPDATED: "Order Status Updated",
+	COUPON_APPLIED: "Coupon Applied",
+	COUPON_REMOVED: "Coupon Removed",
+	PRODUCT_ADDED_TO_WISHLIST: "Product Added to Wishlist",
+	PRODUCT_REMOVED_FROM_WISHLIST: "Product Removed from Wishlist",
+	WISHLIST_PRODUCT_ADDED_TO_CART: "Wishlist Product Added to Cart",
+	CART_SHARED: "Cart Shared",
+	PRODUCT_SHARED: "Product Shared",
+	PRODUCT_REVIEWED: "Product Reviewed",
+	AFFILIATE_CONVERSION_TRACKED: "Affiliate Conversion Tracked",
+	AFFILIATE_LINK_CLICKED: "Affiliate Link Clicked",
+	MERCHANT_SELECTED: "Merchant Selected",
+	PRICE_COMPARISON_VIEWED: "Price Comparison Viewed",
+	REGISTRY_ITEM_MANAGED: "Registry Item Managed",
+	REGISTRY_MANAGED: "Registry Managed",
+	REGISTRY_SHARED: "Registry Shared",
+	REGISTRY_VIEWED: "Registry Viewed",
+	RETURN_COMPLETED: "Return Completed",
+	RETURN_REQUESTED: "Return Requested",
+	BACK_IN_STOCK_REQUESTED: "Back In Stock Requested",
+	PRICE_ALERT_SET: "Price Alert Set"
+};
+
+//#endregion
+//#region src/shared/emitters/ecommerce/utils.ts
+/**
+* Normalizes product properties to ensure consistent naming
+* Handles common variations like productId vs product_id
+*/
+function normalizeProductProperties(product) {
+	if (!product || typeof product !== "object") throw new Error("Product properties are required");
+	const p = product;
+	const product_id = p.product_id ?? p.productId ?? p.id;
+	if (!product_id) throw new Error("Product must have an id (product_id, productId, or id)");
+	const normalized = {
+		product_id,
+		name: p.name ?? p.title ?? p.productName,
+		image_url: p.image_url ?? p.imageUrl ?? p.image,
+		url: p.url ?? p.link ?? p.product_url,
+		brand: p.brand ?? p.manufacturer,
+		category: p.category,
+		coupon: p.coupon ?? p.couponCode ?? p.coupon_code,
+		position: normalizePosition(p.position),
+		price: normalizePrice(p.price),
+		quantity: normalizeQuantity(p.quantity),
+		variant: p.variant ?? p.variation
+	};
+	const result = { product_id };
+	Object.entries(normalized).forEach(([key, value]) => {
+		if (value !== void 0 && value !== null && Object.hasOwn(normalized, key) && key !== "product_id") result[key] = value;
+	});
+	return result;
+}
+/**
+* Normalizes an array of products
+*/
+function normalizeProducts(products) {
+	if (!Array.isArray(products)) return [];
+	return products.map((product) => normalizeProductProperties(product));
+}
+/**
+* ES2022 enhanced product validation with Error.cause
+*/
+function validateProductWithContext(product, context) {
+	try {
+		normalizeProductProperties(product);
+	} catch (error) {
+		throw new Error(`Product validation failed${context ? ` in ${context}` : ""}`, { cause: error });
+	}
+}
+/**
+* Normalizes price to a number
+*/
+function normalizePrice(price) {
+	if (price === void 0 || price === null) return;
+	const normalized = typeof price === "string" ? Number.parseFloat(price) : Number(price);
+	return Number.isNaN(normalized) ? void 0 : normalized;
+}
+/**
+* Normalizes quantity to a positive integer
+*/
+function normalizeQuantity(quantity) {
+	if (quantity === void 0 || quantity === null) return;
+	const normalized = Number.parseInt(String(quantity), 10);
+	return Number.isNaN(normalized) || normalized < 0 ? void 0 : normalized;
+}
+/**
+* Normalizes position to a positive integer
+*/
+function normalizePosition(position) {
+	if (position === void 0 || position === null) return;
+	const normalized = Number.parseInt(String(position), 10);
+	return Number.isNaN(normalized) || normalized < 0 ? void 0 : normalized;
+}
+/**
+* Validates required properties for an event
+*/
+function validateRequiredProperties(properties, required) {
+	const missing = required.filter((prop) => {
+		const value = properties[prop];
+		return value === void 0 || value === null || value === "";
+	});
+	if (missing.length > 0) throw new Error(`Missing required properties: ${missing.join(", ")}`);
+}
+/**
+* Removes undefined values from an object
+*/
+function cleanProperties(obj) {
+	const cleaned = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0) cleaned[key] = value;
+	return cleaned;
+}
+/**
+* Merges common fields with event-specific properties
+*/
+function mergeEventProperties(specific, common) {
+	return {
+		...common,
+		...specific
+	};
+}
+/**
+* Validates currency code (ISO 4217)
+*/
+function validateCurrency(currency) {
+	if (!currency || typeof currency !== "string") return void 0;
+	const normalized = currency.toUpperCase();
+	if (!/^[A-Z]{3}$/.test(normalized)) return;
+	return normalized;
+}
+/**
+* Creates a consistent context object for ecommerce events
+*/
+function createEcommerceContext(additionalContext) {
+	return {
+		...additionalContext,
+		category: "ecommerce"
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ecommerce/track-ecommerce.ts
+/**
+* @fileoverview Ecommerce tracking wrapper that integrates with the core emitter system
+* Ecommerce tracking wrapper that integrates with the core emitter system
+*/
+/**
+* Convert an ecommerce event specification to a track payload
+*
+* @param eventSpec - The ecommerce event specification
+* @param options - Optional emitter options
+* @returns Track payload ready to be sent to analytics providers
+*/
+function trackEcommerce(eventSpec, options) {
+	const enrichedOptions = {
+		...options,
+		context: {
+			...options?.context,
+			...eventSpec.category && { traits: {
+				...options?.context?.traits,
+				event_category: eventSpec.category
+			} }
+		}
+	};
+	return track(eventSpec.name, eventSpec.properties, enrichedOptions);
+}
+/**
+* Helper to create a tracking function for a specific ecommerce event
+* This allows for cleaner usage in applications
+*/
+function createEcommerceTracker(eventFactory) {
+	return (properties, options) => {
+		return trackEcommerce(eventFactory(properties), options);
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ecommerce/events/cart-checkout.ts
+/**
+* @fileoverview Cart and checkout-related ecommerce events
+* Cart and checkout-related ecommerce events
+*/
+/**
+* Track cart updates (add, remove, update) with a single event
+*/
+function cartUpdated(properties, options) {
+	const { cart_id, action, cart_total, product, quantity_change } = properties;
+	const normalizedProduct = normalizeProductProperties(product);
+	validateRequiredProperties(properties, ["action"]);
+	validateRequiredProperties(normalizedProduct, ["product_id"]);
+	return trackEcommerce({
+		name: ECOMMERCE_EVENTS.CART_UPDATED,
+		category: "ecommerce",
+		properties: cleanProperties({
+			action,
+			...normalizedProduct,
+			cart_id,
+			cart_total,
+			quantity_change
+		}),
+		requiredProperties: ["action", "product_id"]
+	}, options);
+}
+/**
+* Track when a user views their shopping cart
+*/
+function cartViewed(properties) {
+	const normalizedProps = {
+		cart_id: properties.cart_id,
+		products: properties.products ? normalizeProducts(properties.products) : void 0
+	};
+	return {
+		name: ECOMMERCE_EVENTS.CART_VIEWED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: []
+	};
+}
+/**
+* Track when a cart is abandoned
+*/
+function cartAbandoned(properties) {
+	validateRequiredProperties(properties, ["cart_id", "cart_value"]);
+	const normalizedProps = {
+		...properties,
+		products: normalizeProducts(properties.products)
+	};
+	return {
+		name: ECOMMERCE_EVENTS.CART_ABANDONED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["cart_id", "cart_value"]
+	};
+}
+/**
+* Track checkout progression with a single event
+*/
+function checkoutProgressed(properties) {
+	validateRequiredProperties(properties, [
+		"step",
+		"step_name",
+		"action"
+	]);
+	const normalizedProps = {
+		...properties,
+		products: properties.products ? normalizeProducts(properties.products) : void 0
+	};
+	return {
+		name: ECOMMERCE_EVENTS.CHECKOUT_PROGRESSED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: [
+			"step",
+			"step_name",
+			"action"
+		]
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ecommerce/events/coupon.ts
+/**
+* @fileoverview Coupon-related ecommerce events
+* Coupon-related ecommerce events
+*/
+/**
+* Track when a coupon is successfully applied
+*/
+function couponApplied(properties) {
+	const normalizedProps = {
+		cart_id: properties.cart_id,
+		coupon_id: properties.coupon_id,
+		order_id: properties.order_id,
+		coupon_name: properties.coupon_name,
+		discount: properties.discount,
+		reason: properties.reason
+	};
+	return {
+		name: ECOMMERCE_EVENTS.COUPON_APPLIED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: []
+	};
+}
+/**
+* Track when a coupon is removed
+*/
+function couponRemoved(properties) {
+	const normalizedProps = {
+		cart_id: properties.cart_id,
+		coupon_id: properties.coupon_id,
+		order_id: properties.order_id,
+		coupon_name: properties.coupon_name,
+		discount: properties.discount,
+		reason: properties.reason
+	};
+	return {
+		name: ECOMMERCE_EVENTS.COUPON_REMOVED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: []
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ecommerce/events/engagement.ts
+/**
+* @fileoverview Customer engagement events for ecommerce
+* Customer engagement events for ecommerce
+* Track user interactions that indicate interest but aren't direct purchases
+*/
+/**
+* Track when a user sets a price alert for a product
+*/
+function priceAlertSet(properties) {
+	const { currency, notification_method, threshold_price, ...productProps } = properties;
+	const normalizedProduct = normalizeProductProperties(productProps);
+	validateRequiredProperties(normalizedProduct, ["product_id"]);
+	validateRequiredProperties({ threshold_price }, ["threshold_price"]);
+	return {
+		name: ECOMMERCE_EVENTS.PRICE_ALERT_SET,
+		category: "ecommerce",
+		properties: cleanProperties({
+			...normalizedProduct,
+			action_type: "price_alert",
+			currency,
+			notification_method,
+			threshold_price
+		}),
+		requiredProperties: ["product_id", "threshold_price"]
+	};
+}
+/**
+* Track when a user requests notification for out-of-stock items
+*/
+function backInStockRequested(properties) {
+	const { notification_method, ...productProps } = properties;
+	const normalizedProduct = normalizeProductProperties(productProps);
+	validateRequiredProperties(normalizedProduct, ["product_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.BACK_IN_STOCK_REQUESTED,
+		category: "ecommerce",
+		properties: cleanProperties({
+			...normalizedProduct,
+			action_type: "back_in_stock",
+			notification_method
+		}),
+		requiredProperties: ["product_id"]
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ecommerce/events/marketplace.ts
+/**
+* @fileoverview Marketplace and affiliate-specific ecommerce events
+* Marketplace and affiliate-specific ecommerce events
+* These events track user interactions unique to marketplace/affiliate models
+*/
+/**
+* Track when a user views price comparisons across multiple merchants
+*/
+function priceComparisonViewed(properties) {
+	validateRequiredProperties(properties, ["product_id", "merchants"]);
+	return {
+		name: ECOMMERCE_EVENTS.PRICE_COMPARISON_VIEWED,
+		category: "ecommerce",
+		properties: cleanProperties(properties),
+		requiredProperties: ["product_id", "merchants"]
+	};
+}
+/**
+* Track when a user selects a specific merchant from multiple options
+*/
+function merchantSelected(properties) {
+	const normalizedProps = normalizeProductProperties(properties);
+	validateRequiredProperties(properties, ["product_id", "selected_merchant_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.MERCHANT_SELECTED,
+		category: "ecommerce",
+		properties: cleanProperties({
+			...normalizedProps,
+			selected_merchant_id: properties.selected_merchant_id,
+			selected_merchant_name: properties.selected_merchant_name,
+			compared_merchants: properties.compared_merchants,
+			selection_reason: properties.selection_reason
+		}),
+		requiredProperties: ["product_id", "selected_merchant_id"]
+	};
+}
+/**
+* Track when a user clicks an affiliate link to visit merchant site
+*/
+function affiliateLinkClicked(properties) {
+	const normalizedProps = normalizeProductProperties(properties);
+	validateRequiredProperties(properties, ["product_id", "destination_url"]);
+	return {
+		name: ECOMMERCE_EVENTS.AFFILIATE_LINK_CLICKED,
+		category: "ecommerce",
+		properties: cleanProperties({
+			...normalizedProps,
+			destination_url: properties.destination_url,
+			deep_link: properties.deep_link,
+			tracking_code: properties.tracking_code
+		}),
+		requiredProperties: ["product_id", "destination_url"]
+	};
+}
+/**
+* Track when an affiliate conversion is confirmed
+* This is typically fired via webhook or after confirmation from affiliate network
+*/
+function affiliateConversionTracked(properties) {
+	validateRequiredProperties(properties, [
+		"product_id",
+		"order_id",
+		"merchant_id"
+	]);
+	return {
+		name: ECOMMERCE_EVENTS.AFFILIATE_CONVERSION_TRACKED,
+		category: "ecommerce",
+		properties: cleanProperties(properties),
+		requiredProperties: [
+			"product_id",
+			"order_id",
+			"merchant_id"
+		]
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ecommerce/events/order.ts
+/**
+* @fileoverview Order-related ecommerce events
+* Order-related ecommerce events
+*/
+/**
+* Track when a user completes an order
+*/
+function orderCompleted(properties, options) {
+	validateRequiredProperties(properties, ["order_id"]);
+	const normalizedProps = {
+		order_id: properties.order_id,
+		affiliation: properties.affiliation,
+		coupon: properties.coupon,
+		currency: validateCurrency(properties.currency),
+		discount: properties.discount,
+		products: properties.products ? normalizeProducts(properties.products) : void 0,
+		revenue: properties.revenue,
+		shipping: properties.shipping,
+		tax: properties.tax,
+		total: properties.total
+	};
+	return trackEcommerce({
+		name: ECOMMERCE_EVENTS.ORDER_COMPLETED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["order_id"]
+	}, options);
+}
+/**
+* Track when an order fails (payment declined, validation error, etc.)
+*/
+function orderFailed(properties) {
+	validateRequiredProperties(properties, ["order_id"]);
+	const { error_code, failure_reason, ...orderProps } = properties;
+	const normalizedProps = {
+		order_id: orderProps.order_id,
+		affiliation: orderProps.affiliation,
+		coupon: orderProps.coupon,
+		currency: validateCurrency(orderProps.currency),
+		discount: orderProps.discount,
+		error_code,
+		failure_reason,
+		products: orderProps.products ? normalizeProducts(orderProps.products) : void 0,
+		revenue: orderProps.revenue,
+		shipping: orderProps.shipping,
+		tax: orderProps.tax,
+		total: orderProps.total
+	};
+	return {
+		name: ECOMMERCE_EVENTS.ORDER_FAILED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["order_id"]
+	};
+}
+/**
+* Track when an order is refunded
+*/
+function orderRefunded(properties) {
+	validateRequiredProperties(properties, ["order_id"]);
+	const normalizedProps = {
+		order_id: properties.order_id,
+		affiliation: properties.affiliation,
+		coupon: properties.coupon,
+		currency: validateCurrency(properties.currency),
+		discount: properties.discount,
+		products: properties.products ? normalizeProducts(properties.products) : void 0,
+		revenue: properties.revenue,
+		shipping: properties.shipping,
+		tax: properties.tax,
+		total: properties.total
+	};
+	return {
+		name: ECOMMERCE_EVENTS.ORDER_REFUNDED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["order_id"]
+	};
+}
+/**
+* Track when an order is cancelled
+*/
+function orderCancelled(properties) {
+	validateRequiredProperties(properties, ["order_id"]);
+	const normalizedProps = {
+		order_id: properties.order_id,
+		affiliation: properties.affiliation,
+		coupon: properties.coupon,
+		currency: validateCurrency(properties.currency),
+		discount: properties.discount,
+		products: properties.products ? normalizeProducts(properties.products) : void 0,
+		revenue: properties.revenue,
+		shipping: properties.shipping,
+		tax: properties.tax,
+		total: properties.total
+	};
+	return {
+		name: ECOMMERCE_EVENTS.ORDER_CANCELLED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["order_id"]
+	};
+}
+/**
+* Track order status changes (shipping, delivery, etc.)
+*/
+function orderStatusUpdated(properties) {
+	validateRequiredProperties(properties, ["order_id", "status"]);
+	return {
+		name: ECOMMERCE_EVENTS.ORDER_STATUS_UPDATED,
+		category: "ecommerce",
+		properties: cleanProperties(properties),
+		requiredProperties: ["order_id", "status"]
+	};
+}
+/**
+* Track when a return is requested
+*/
+function returnRequested(properties) {
+	validateRequiredProperties(properties, ["order_id", "reason"]);
+	const normalizedProps = {
+		...properties,
+		products: normalizeProducts(properties.products)
+	};
+	return {
+		name: ECOMMERCE_EVENTS.RETURN_REQUESTED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["order_id", "reason"]
+	};
+}
+/**
+* Track when a return is completed
+*/
+function returnCompleted(properties) {
+	validateRequiredProperties(properties, ["order_id", "return_id"]);
+	const normalizedProps = {
+		...properties,
+		products: normalizeProducts(properties.products)
+	};
+	return {
+		name: ECOMMERCE_EVENTS.RETURN_COMPLETED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["order_id", "return_id"]
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ecommerce/events/product.ts
+/**
+* @fileoverview Product-related ecommerce events
+* Product-related ecommerce events
+*/
+/**
+* Track when a user searches for products
+*/
+function productSearched(properties, options) {
+	validateRequiredProperties(properties, ["query"]);
+	return trackEcommerce({
+		name: ECOMMERCE_EVENTS.PRODUCT_SEARCHED,
+		category: "ecommerce",
+		properties: cleanProperties(properties),
+		requiredProperties: ["query"]
+	}, options);
+}
+/**
+* Track when search results are displayed
+*/
+function searchResultsViewed(properties) {
+	validateRequiredProperties(properties, ["query", "results_count"]);
+	const normalizedProps = {
+		...properties,
+		products: properties.products ? normalizeProducts(properties.products) : void 0
+	};
+	return {
+		name: ECOMMERCE_EVENTS.SEARCH_RESULTS_VIEWED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["query", "results_count"]
+	};
+}
+/**
+* Track when a user views a product list or category
+*/
+function productListViewed(properties) {
+	const normalizedProps = {
+		list_id: properties.list_id,
+		category: properties.category,
+		products: properties.products ? normalizeProducts(properties.products) : void 0
+	};
+	return {
+		name: ECOMMERCE_EVENTS.PRODUCT_LIST_VIEWED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: []
+	};
+}
+/**
+* Track when a user filters a product list
+*/
+function productListFiltered(properties) {
+	const normalizedProps = {
+		list_id: properties.list_id,
+		category: properties.category,
+		filters: properties.filters,
+		products: properties.products ? normalizeProducts(properties.products) : void 0
+	};
+	return {
+		name: ECOMMERCE_EVENTS.PRODUCT_LIST_FILTERED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: []
+	};
+}
+/**
+* Track when a user clicks on a product
+*/
+function productClicked(properties) {
+	const normalizedProps = normalizeProductProperties(properties);
+	validateRequiredProperties(normalizedProps, ["product_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.PRODUCT_CLICKED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["product_id"]
+	};
+}
+/**
+* Track when a user views a product detail page
+*/
+function productViewed(properties, options) {
+	const normalizedProps = normalizeProductProperties(properties);
+	validateRequiredProperties(normalizedProps, ["product_id"]);
+	return trackEcommerce({
+		name: ECOMMERCE_EVENTS.PRODUCT_VIEWED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["product_id"]
+	}, options);
+}
+/**
+* Track when a user compares products
+*/
+function productCompared(properties) {
+	const { action, comparison_list, product } = properties;
+	const normalizedProduct = normalizeProductProperties(product);
+	validateRequiredProperties(normalizedProduct, ["product_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.PRODUCT_COMPARED,
+		category: "ecommerce",
+		properties: cleanProperties({
+			action,
+			...normalizedProduct,
+			comparison_list: comparison_list ? normalizeProducts(comparison_list) : void 0
+		}),
+		requiredProperties: ["product_id"]
+	};
+}
+/**
+* Track when product recommendations are viewed
+*/
+function productRecommendationViewed(properties) {
+	validateRequiredProperties(properties, ["recommendation_type", "source"]);
+	const normalizedProps = {
+		...properties,
+		products: normalizeProducts(properties.products)
+	};
+	return {
+		name: ECOMMERCE_EVENTS.PRODUCT_RECOMMENDATION_VIEWED,
+		category: "ecommerce",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["recommendation_type", "source"]
+	};
+}
+/**
+* Track when a recommended product is clicked
+*/
+function productRecommendationClicked(properties) {
+	const { recommendation_type, position, source, ...productProps } = properties;
+	const normalizedProduct = normalizeProductProperties(productProps);
+	validateRequiredProperties(normalizedProduct, ["product_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.PRODUCT_RECOMMENDATION_CLICKED,
+		category: "ecommerce",
+		properties: cleanProperties({
+			...normalizedProduct,
+			recommendation_type,
+			position,
+			source
+		}),
+		requiredProperties: ["product_id"]
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ecommerce/events/registry.ts
+/**
+* @fileoverview Universal registry events for gift registries, wishlists, and similar features
+* Universal registry events for gift registries, wishlists, and similar features
+* Uses action-based patterns for efficient tracking
+*/
+/**
+* Track registry management actions (create, update, delete)
+*/
+function registryManaged(properties) {
+	validateRequiredProperties(properties, ["registry_id", "action"]);
+	return {
+		name: ECOMMERCE_EVENTS.REGISTRY_MANAGED,
+		category: "ecommerce",
+		properties: cleanProperties(properties),
+		requiredProperties: ["registry_id", "action"]
+	};
+}
+/**
+* Track when someone views a registry
+*/
+function registryViewed(properties) {
+	validateRequiredProperties(properties, ["registry_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.REGISTRY_VIEWED,
+		category: "ecommerce",
+		properties: cleanProperties(properties),
+		requiredProperties: ["registry_id"]
+	};
+}
+/**
+* Track when a registry is shared
+*/
+function registryShared(properties) {
+	validateRequiredProperties(properties, ["registry_id", "share_method"]);
+	return {
+		name: ECOMMERCE_EVENTS.REGISTRY_SHARED,
+		category: "ecommerce",
+		properties: cleanProperties(properties),
+		requiredProperties: ["registry_id", "share_method"]
+	};
+}
+/**
+* Track registry item management (add, remove, update, purchase)
+*/
+function registryItemManaged(properties) {
+	const { purchaser_id, registry_id, purchaser_name, action, anonymous_gift, gift_wrap, purchase_message, purchase_quantity, updated_fields, ...productProps } = properties;
+	const normalizedProduct = normalizeProductProperties(productProps);
+	validateRequiredProperties(properties, [
+		"registry_id",
+		"product_id",
+		"action"
+	]);
+	return {
+		name: ECOMMERCE_EVENTS.REGISTRY_ITEM_MANAGED,
+		category: "ecommerce",
+		properties: cleanProperties({
+			purchaser_id,
+			registry_id,
+			purchaser_name,
+			action,
+			anonymous_gift,
+			gift_wrap,
+			purchase_message,
+			purchase_quantity,
+			updated_fields,
+			...normalizedProduct
+		}),
+		requiredProperties: [
+			"registry_id",
+			"product_id",
+			"action"
+		]
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ecommerce/events/wishlist-sharing.ts
+/**
+* @fileoverview Wishlist, sharing, and review-related ecommerce events
+* Wishlist, sharing, and review-related ecommerce events
+*/
+/**
+* Track when a product is added to wishlist
+*/
+function productAddedToWishlist(properties) {
+	const { wishlist_id, wishlist_name, ...productProps } = properties;
+	const normalizedProduct = normalizeProductProperties(productProps);
+	validateRequiredProperties(normalizedProduct, ["product_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.PRODUCT_ADDED_TO_WISHLIST,
+		category: "ecommerce",
+		properties: cleanProperties({
+			wishlist_id,
+			wishlist_name,
+			...normalizedProduct
+		}),
+		requiredProperties: ["product_id"]
+	};
+}
+/**
+* Track when a product is removed from wishlist
+*/
+function productRemovedFromWishlist(properties) {
+	const { wishlist_id, wishlist_name, ...productProps } = properties;
+	const normalizedProduct = normalizeProductProperties(productProps);
+	validateRequiredProperties(normalizedProduct, ["product_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.PRODUCT_REMOVED_FROM_WISHLIST,
+		category: "ecommerce",
+		properties: cleanProperties({
+			wishlist_id,
+			wishlist_name,
+			...normalizedProduct
+		}),
+		requiredProperties: ["product_id"]
+	};
+}
+/**
+* Track when a wishlist product is added to cart
+*/
+function wishlistProductAddedToCart(properties) {
+	const { cart_id, wishlist_id, wishlist_name, ...productProps } = properties;
+	const normalizedProduct = normalizeProductProperties(productProps);
+	validateRequiredProperties(normalizedProduct, ["product_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.WISHLIST_PRODUCT_ADDED_TO_CART,
+		category: "ecommerce",
+		properties: cleanProperties({
+			cart_id,
+			wishlist_id,
+			wishlist_name,
+			...normalizedProduct
+		}),
+		requiredProperties: ["product_id"]
+	};
+}
+/**
+* Track when a product is shared
+*/
+function productShared(properties) {
+	const { recipient, share_message, share_via, ...productProps } = properties;
+	const normalizedProduct = normalizeProductProperties(productProps);
+	validateRequiredProperties(normalizedProduct, ["product_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.PRODUCT_SHARED,
+		category: "ecommerce",
+		properties: cleanProperties({
+			recipient,
+			share_message,
+			share_via,
+			...normalizedProduct
+		}),
+		requiredProperties: ["product_id"]
+	};
+}
+/**
+* Track when a cart is shared
+*/
+function cartShared(properties) {
+	const { cart_id, products, recipient, share_message, share_via } = properties;
+	return {
+		name: ECOMMERCE_EVENTS.CART_SHARED,
+		category: "ecommerce",
+		properties: cleanProperties({
+			cart_id,
+			products: products ? normalizeProducts(products) : void 0,
+			recipient,
+			share_message,
+			share_via
+		}),
+		requiredProperties: []
+	};
+}
+/**
+* Track when a product is reviewed
+*/
+function productReviewed(properties) {
+	validateRequiredProperties(properties, ["product_id"]);
+	return {
+		name: ECOMMERCE_EVENTS.PRODUCT_REVIEWED,
+		category: "ecommerce",
+		properties: cleanProperties(properties),
+		requiredProperties: ["product_id"]
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ecommerce/index.ts
+var ecommerce_exports = /* @__PURE__ */ __exportAll({
+	ECOMMERCE_EVENTS: () => ECOMMERCE_EVENTS,
+	affiliateConversionTracked: () => affiliateConversionTracked,
+	affiliateLinkClicked: () => affiliateLinkClicked,
+	backInStockRequested: () => backInStockRequested,
+	cartAbandoned: () => cartAbandoned,
+	cartShared: () => cartShared,
+	cartUpdated: () => cartUpdated,
+	cartViewed: () => cartViewed,
+	checkoutProgressed: () => checkoutProgressed,
+	cleanProperties: () => cleanProperties,
+	couponApplied: () => couponApplied,
+	couponRemoved: () => couponRemoved,
+	createEcommerceContext: () => createEcommerceContext,
+	createEcommerceTracker: () => createEcommerceTracker,
+	merchantSelected: () => merchantSelected,
+	mergeEventProperties: () => mergeEventProperties,
+	normalizeProductProperties: () => normalizeProductProperties,
+	normalizeProducts: () => normalizeProducts,
+	orderCancelled: () => orderCancelled,
+	orderCompleted: () => orderCompleted,
+	orderFailed: () => orderFailed,
+	orderRefunded: () => orderRefunded,
+	orderStatusUpdated: () => orderStatusUpdated,
+	priceAlertSet: () => priceAlertSet,
+	priceComparisonViewed: () => priceComparisonViewed,
+	productAddedToWishlist: () => productAddedToWishlist,
+	productClicked: () => productClicked,
+	productCompared: () => productCompared,
+	productListFiltered: () => productListFiltered,
+	productListViewed: () => productListViewed,
+	productRecommendationClicked: () => productRecommendationClicked,
+	productRecommendationViewed: () => productRecommendationViewed,
+	productRemovedFromWishlist: () => productRemovedFromWishlist,
+	productReviewed: () => productReviewed,
+	productSearched: () => productSearched,
+	productShared: () => productShared,
+	productViewed: () => productViewed,
+	registryItemManaged: () => registryItemManaged,
+	registryManaged: () => registryManaged,
+	registryShared: () => registryShared,
+	registryViewed: () => registryViewed,
+	returnCompleted: () => returnCompleted,
+	returnRequested: () => returnRequested,
+	searchResultsViewed: () => searchResultsViewed,
+	trackEcommerce: () => trackEcommerce,
+	validateCurrency: () => validateCurrency,
+	validateProductWithContext: () => validateProductWithContext,
+	validateRequiredProperties: () => validateRequiredProperties,
+	wishlistProductAddedToCart: () => wishlistProductAddedToCart
+});
+
+//#endregion
+export { ecommerce_exports as t };
+//# sourceMappingURL=ecommerce-Cgu4wlux.mjs.map