@lookiero/checkout 0.8.23 → 0.8.25

package/dist/infrastructure/ui/components/layouts/tabs/Tabs.js

@@ -1,6 +1,6 @@
 import { Text } from "@lookiero/aurora-next/build/components/primitives/Text/Text";
 import { animated, useSpring } from "@react-spring/native";
-import React, { Children, useCallback, useState } from "react";
+import React, { Children, useCallback, useEffect, useState } from "react";
 import { Pressable, View } from "react-native";
 import invariant from "tiny-invariant";
 import { Slider } from "../../../../../shared/ui/components/layouts/slider/Slider";
@@ -35,10 +35,10 @@ const TabList = ({ labels = [], tabIndex = 0, style: customStyle, onSelect }) =>
 const Tabs = ({ children, defaultIndex = 0, tabLabels, style: customStyle, onChanged, tabLabelsWrapper = (children) => children, }) => {
     invariant(Children.count(children) === tabLabels.length, "Children and tab labels must be the same length");
     const [active, setActive] = useState(defaultIndex);
-    const handleOnActiveChanged = useCallback((activeIndex) => {
-        setActive(activeIndex);
-        onChanged?.(activeIndex);
-    }, [onChanged]);
+    const handleOnActiveChanged = useCallback((activeIndex) => setActive(activeIndex), []);
+    useEffect(() => {
+        onChanged?.(active);
+    }, [active, onChanged]);
     return (React.createElement(View, { style: [style.container, customStyle?.tabContainer], testID: "tabs" },
         tabLabelsWrapper(React.createElement(TabList, { labels: tabLabels, style: customStyle?.tabList, tabIndex: active, onSelect: handleOnActiveChanged })),
         React.createElement(View, { style: customStyle?.sliderContainer },

package/dist/infrastructure/ui/views/checkout/Checkout.js

@@ -5,7 +5,7 @@ import React, { useCallback, useMemo } from "react";
 import { Platform, View } from "react-native";
 import { useNavigate } from "react-router-native";
 import { CheckoutItemStatus } from "../../../../domain/checkoutItem/model/checkoutItem";
-import { usePageView } from "../../../../shared/tracking/infrastructure/usePageView";
+import { useTrackPageView } from "../../../../shared/tracking/infrastructure/useTrackPageView";
 import { Spinner } from "../../../../shared/ui/components/atoms/spinner/Spinner";
 import { useViewFirstAvailableCheckoutByCustomerId } from "../../../projection/checkout/react/useViewFirstAvailableCheckoutByCustomerId";
 import { useViewPricingByCheckoutId } from "../../../projection/pricing/react/useViewPricingByCheckoutId";
@@ -25,7 +25,7 @@ const Checkout = ({ children, customerId, country, useRedirect }) => {
     const titleText = useI18nMessage({ id: I18nMessages.CHECKOUT_TITLE });
     const [checkout, checkoutStatus] = useViewFirstAvailableCheckoutByCustomerId({ customerId });
     const [pricing, pricingStatus] = useViewPricingByCheckoutId({ checkoutId: checkout?.id });
-    usePageView({
+    useTrackPageView({
         page: TrackingPage.CHECKOUT,
         country,
         checkoutId: checkout?.id,

package/dist/infrastructure/ui/views/feedback/Feedback.js

@@ -2,7 +2,7 @@ import { CommandStatus, QueryStatus } from "@lookiero/messaging-react";
 import React, { useCallback, useEffect, useRef } from "react";
 import { Platform } from "react-native";
 import { useLogger } from "../../../../shared/logging/useLogger";
-import { usePageView } from "../../../../shared/tracking/infrastructure/usePageView";
+import { useTrackPageView } from "../../../../shared/tracking/infrastructure/useTrackPageView";
 import { Spinner } from "../../../../shared/ui/components/atoms/spinner/Spinner";
 import { useGiveCheckoutFeedback } from "../../../domain/checkoutFeedback/react/useGiveCheckoutFeedback";
 import { useViewFirstAvailableCheckoutByCustomerId } from "../../../projection/checkout/react/useViewFirstAvailableCheckoutByCustomerId";
@@ -32,7 +32,7 @@ const Feedback = ({ customerId, country }) => {
         }
         catch (e) { }
     }, [giveCheckoutFeedback]);
-    usePageView({
+    useTrackPageView({
         page: TrackingPage.FEEDBACK,
         country,
         checkoutId: checkout?.id,

package/dist/infrastructure/ui/views/item/Item.js

@@ -5,7 +5,12 @@ import { useParams } from "react-router-native";
 import { CheckoutItemStatus } from "../../../../domain/checkoutItem/model/checkoutItem";
 import "../../../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
 import { useLogger } from "../../../../shared/logging/useLogger";
-import { usePageView } from "../../../../shared/tracking/infrastructure/usePageView";
+import { useTrackImageView } from "../../../../shared/tracking/infrastructure/useTrackImageView";
+import { useTrackItemPageView } from "../../../../shared/tracking/infrastructure/useTrackItemPageView";
+import { useTrackKeepItem } from "../../../../shared/tracking/infrastructure/useTrackKeepItem";
+import { useTrackReplaceItem } from "../../../../shared/tracking/infrastructure/useTrackReplaceItem";
+import { useTrackResetItem } from "../../../../shared/tracking/infrastructure/useTrackResetItem";
+import { useTrackReturnItem } from "../../../../shared/tracking/infrastructure/useTrackReturnItem";
 import { Spinner } from "../../../../shared/ui/components/atoms/spinner/Spinner";
 import { useBookCheckoutBookingForCheckoutItem } from "../../../domain/checkoutBooking/react/useBookCheckoutBookingForCheckoutItem";
 import { useKeepCheckoutItem } from "../../../domain/checkoutItem/react/useKeepCheckoutItem";
@@ -39,12 +44,69 @@ const Item = ({ customerId, country }) => {
         checkoutId: checkout?.id,
     });
     const checkoutItem = checkout?.items.find((checkoutItem) => checkoutItem.id === id);
-    usePageView({
+    const [bookedProductsVariants] = useViewBookedProductsVariantsForCheckoutItem({
+        checkoutItemId: checkoutItem.id,
+    });
+    const [bookCheckoutBooking] = useBookCheckoutBookingForCheckoutItem({
+        checkoutItemId: checkoutItem.id,
+        checkoutBookingId: checkout?.checkoutBookingId,
+        logger,
+    });
+    const isBookingRequired = bookedProductsVariants === null && isSizeChangeEnabled;
+    useEffect(() => {
+        isBookingRequired && bookCheckoutBooking();
+    }, [bookCheckoutBooking, isBookingRequired]);
+    const replaceableFor = useMemo(() => sizeChangeEnabledStatus === QueryStatus.SUCCESS
+        ? isSizeChangeEnabled
+            ? bookedProductsVariants
+                ? bookedProductsVariants?.productVariants.map(({ id }) => id)
+                : undefined
+            : []
+        : undefined, [bookedProductsVariants, isSizeChangeEnabled, sizeChangeEnabledStatus]);
+    useTrackItemPageView({
         page: TrackingPage.ITEM,
         country,
         checkoutId: checkout?.id,
         checkoutItemId: checkoutItem.id,
+        productVariantId: checkoutItem.productVariant.id,
+        replaceableFor,
+        unique: checkoutItem.productVariant.size.unique,
     });
+    const trackKeepItem = useTrackKeepItem({
+        page: TrackingPage.ITEM,
+        country,
+        checkoutId: checkout?.id,
+        checkoutItemId: checkoutItem.id,
+    });
+    const trackReturnItem = useTrackReturnItem({
+        page: TrackingPage.ITEM,
+        country,
+        checkoutId: checkout?.id,
+        checkoutItemId: checkoutItem.id,
+    });
+    const trackReplaceItem = useTrackReplaceItem({
+        page: TrackingPage.ITEM,
+        country,
+        checkoutId: checkout?.id,
+        checkoutItemId: checkoutItem.id,
+        productVariantId: checkoutItem.productVariant.id,
+    });
+    const trackResetItem = useTrackResetItem({
+        page: TrackingPage.ITEM,
+        country,
+        checkoutId: checkout?.id,
+        checkoutItemId: checkoutItem.id,
+    });
+    const trackImageView = useTrackImageView({
+        page: TrackingPage.ITEM,
+        country,
+        checkoutId: checkout?.id,
+        checkoutItemId: checkoutItem.id,
+        productVariantId: checkoutItem.productVariant.id,
+    });
+    useEffect(() => trackImageView({
+        perspective: checkoutItem.productVariant.media[0]?.perspective,
+    }), [checkoutItem.productVariant.media, trackImageView]);
     const customerDecissionMade = checkoutItem.status !== CheckoutItemStatus.INITIAL;
     const [resetCheckoutItem, resetCheckoutItemStatus] = useResetCheckoutItem({
         checkoutItemId: checkoutItem.id,
@@ -62,18 +124,6 @@ const Item = ({ customerId, country }) => {
     const [sizeWithoutStockModalVisible, setSizeWithoutStockModalVisible] = useState(false);
     const handleOnShowSizeWithoutStockModal = useCallback(() => setSizeWithoutStockModalVisible(true), []);
     const handleOnHideSizeWithoutStockModal = useCallback(() => setSizeWithoutStockModalVisible(false), []);
-    const [bookedProductsVariants] = useViewBookedProductsVariantsForCheckoutItem({
-        checkoutItemId: checkoutItem.id,
-    });
-    const [bookCheckoutBooking] = useBookCheckoutBookingForCheckoutItem({
-        checkoutItemId: checkoutItem.id,
-        checkoutBookingId: checkout?.checkoutBookingId,
-        logger,
-    });
-    const isBookingRequired = bookedProductsVariants === null && isSizeChangeEnabled;
-    useEffect(() => {
-        isBookingRequired && bookCheckoutBooking();
-    }, [bookCheckoutBooking, isBookingRequired]);
     const [returnQuestions, returnQuestionsStatus] = useListReturnQuestionsByCheckoutItemId({
         checkoutItemId: checkoutItem.id,
     });
@@ -86,9 +136,22 @@ const Item = ({ customerId, country }) => {
     const handleOnSubmit = useCallback((feedbacks) => {
         handleOnHideReturnQuestions();
         returnCheckoutItem({ feedbacks });
-    }, [handleOnHideReturnQuestions, returnCheckoutItem]);
-    const handleOnReplace = useCallback((replacedForId) => replaceCheckoutItem({ replacedForId }), [replaceCheckoutItem]);
+        trackReturnItem();
+    }, [handleOnHideReturnQuestions, returnCheckoutItem, trackReturnItem]);
+    const handleOnReplace = useCallback((replacedForId) => {
+        replaceCheckoutItem({ replacedForId });
+        trackReplaceItem({ replaceFor: replacedForId });
+    }, [replaceCheckoutItem, trackReplaceItem]);
     const handleOnReturn = useCallback(() => handleOnShowReturnQuestions(), [handleOnShowReturnQuestions]);
+    const handleOnKeep = useCallback(() => {
+        keepCheckoutItem();
+        trackKeepItem();
+    }, [keepCheckoutItem, trackKeepItem]);
+    const handleOnPressCustomerDecissionBanner = useCallback(() => {
+        resetCheckoutItem();
+        trackResetItem();
+    }, [resetCheckoutItem, trackResetItem]);
+    const handleOnChangedProductVariantSlider = useCallback((active) => trackImageView({ perspective: checkoutItem.productVariant.media[active]?.perspective }), [checkoutItem.productVariant.media, trackImageView]);
     const productVariantSelected = useMemo(() => checkoutItem.status === CheckoutItemStatus.REPLACED && checkoutItem.replacedFor
         ? { id: checkoutItem.replacedFor.id, size: checkoutItem.replacedFor.size }
         : { id: checkoutItem.productVariant.id, size: checkoutItem.productVariant.size }, [checkoutItem.productVariant.id, checkoutItem.productVariant.size, checkoutItem.replacedFor, checkoutItem.status]);
@@ -104,12 +167,12 @@ const Item = ({ customerId, country }) => {
     const { media, brand, name, color } = checkoutItem.productVariant;
     return (React.createElement(ReturnQuestionFeedbackProvider, { feedback: checkoutItem.feedbacks || {} },
         React.createElement(SizeWithoutStockModal, { visible: sizeWithoutStockModalVisible, onDismiss: handleOnHideSizeWithoutStockModal }),
-        React.createElement(SafeAreaScrollView, { scrollerPaddingTop: Platform.OS === "web" || Platform.OS === "android" ? HEADER_HEIGHT : 0, footer: !customerDecissionMade && (React.createElement(ItemActions, { country: country, keepButtonLoading: keepCheckoutItemStatus === CommandStatus.LOADING, productVariantSelected: productVariantSelected, productVariants: bookedProductsVariants?.productVariants, returnButtonLoading: returnCheckoutItemStatus === CommandStatus.LOADING, sizeSelectorDisabled: replaceCheckoutItemStatus === CommandStatus.LOADING, onKeep: keepCheckoutItem, onLayout: handleOnStickyLayout, onReplace: handleOnReplace, onReturn: handleOnReturn, onSizeSelectorPress: handleOnShowSizeWithoutStockModal })) },
+        React.createElement(SafeAreaScrollView, { scrollerPaddingTop: Platform.OS === "web" || Platform.OS === "android" ? HEADER_HEIGHT : 0, footer: !customerDecissionMade && (React.createElement(ItemActions, { country: country, keepButtonLoading: keepCheckoutItemStatus === CommandStatus.LOADING, productVariantSelected: productVariantSelected, productVariants: bookedProductsVariants?.productVariants, returnButtonLoading: returnCheckoutItemStatus === CommandStatus.LOADING, sizeSelectorDisabled: replaceCheckoutItemStatus === CommandStatus.LOADING, onKeep: handleOnKeep, onLayout: handleOnStickyLayout, onReplace: handleOnReplace, onReturn: handleOnReturn, onSizeSelectorPress: handleOnShowSizeWithoutStockModal })) },
             React.createElement(Body, null,
-                customerDecissionMade && (React.createElement(CustomerDecissionBanner, { changingDecission: resetCheckoutItemStatus === CommandStatus.LOADING, checkoutItemStatus: checkoutItem.status, onPress: resetCheckoutItem })),
+                customerDecissionMade && (React.createElement(CustomerDecissionBanner, { changingDecission: resetCheckoutItemStatus === CommandStatus.LOADING, checkoutItemStatus: checkoutItem.status, onPress: handleOnPressCustomerDecissionBanner })),
                 React.createElement(View, { style: [style.content, { paddingBottom: Platform.OS === "web" ? spaceXL : stickyHeight }] },
                     React.createElement(View, { style: style.sliderContainer },
-                        React.createElement(ProductVariantSlider, { producVariantMedia: media })),
+                        React.createElement(ProductVariantSlider, { producVariantMedia: media, onChanged: handleOnChangedProductVariantSlider })),
                     React.createElement(ProductVariantDescription, { brand: brand, color: color, country: country, name: name, price: price, size: productVariantSelected.size }),
                     checkoutItem.status === CheckoutItemStatus.RETURNED && (React.createElement(View, { style: style.feedbackContainer },
                         React.createElement(ReturnQuestionsFeedback, { returnQuestions: returnQuestions || [], onEditFeedback: handleOnEditFeedback })))))),

package/dist/infrastructure/ui/views/item/components/productVariantSlider/ProductVariantSlider.d.ts

@@ -2,6 +2,7 @@ import { FC } from "react";
 import { MediaProjection } from "../../../../../../projection/checkoutItem/checkoutItem";
 interface ProductVariantSlider {
     readonly producVariantMedia: MediaProjection[];
+    readonly onChanged?: (active: number) => void;
 }
 declare const ProductVariantSlider: FC<ProductVariantSlider>;
 export { ProductVariantSlider };

package/dist/infrastructure/ui/views/item/components/productVariantSlider/ProductVariantSlider.js

@@ -3,10 +3,13 @@ import { Image } from "react-native";
 import { Slider } from "../../../../../../shared/ui/components/layouts/slider/Slider";
 import { useMediaImage } from "../../../../hooks/useMediaImage";
 import { style } from "./ProductVariantSlider.style";
-const ProductVariantSlider = ({ producVariantMedia }) => {
+const ProductVariantSlider = ({ producVariantMedia, onChanged }) => {
     const cdnImageUrl = useMediaImage();
     const [active, setActive] = useState(0);
-    const handleOnActiveChanged = useCallback((activeIndex) => setActive(activeIndex), []);
+    const handleOnActiveChanged = useCallback((activeIndex) => {
+        setActive(activeIndex);
+        onChanged?.(activeIndex);
+    }, [onChanged]);
     return (React.createElement(Slider, { active: active, paginationActiveItemStyle: style.paginationActiveItemStyle, paginationItemStyle: style.paginationItemStyle, paginationStyle: style.paginationStyle, paginationRenderItem: (index) => (React.createElement(Image, { key: producVariantMedia[index]?.perspective, resizeMode: "contain", style: style.paginationImage, testID: "product-variant-pagination-image", source: {
                 uri: cdnImageUrl({
                     url: producVariantMedia[index]?.url,

package/dist/infrastructure/ui/views/notFound/NotFound.js

@@ -5,7 +5,7 @@ import { QueryStatus } from "@lookiero/messaging-react";
 import React, { useCallback } from "react";
 import { Image, Platform } from "react-native";
 import { useNavigate } from "react-router-native";
-import { usePageView } from "../../../../shared/tracking/infrastructure/usePageView";
+import { useTrackPageView } from "../../../../shared/tracking/infrastructure/useTrackPageView";
 import { AspectRatioView } from "../../../../shared/ui/components/atoms/aspectRatioView/AspectRatioView";
 import { Spinner } from "../../../../shared/ui/components/atoms/spinner/Spinner";
 import { useViewFirstAvailableCheckoutByCustomerId } from "../../../projection/checkout/react/useViewFirstAvailableCheckoutByCustomerId";
@@ -21,7 +21,7 @@ const NotFound = ({ customerId, country }) => {
     const descriptionText = useI18nMessage({ id: I18nMessages.NOT_FOUND_DESCRIPTION });
     const buttonText = useI18nMessage({ id: I18nMessages.NOT_FOUND_BUTTON });
     const [checkout, checkoutStatus] = useViewFirstAvailableCheckoutByCustomerId({ customerId });
-    usePageView({
+    useTrackPageView({
         page: TrackingPage.NOT_FOUND,
         country,
         checkoutId: checkout?.id,

package/dist/infrastructure/ui/views/summary/Summary.js

@@ -5,7 +5,11 @@ import React, { useCallback, useMemo, useState } from "react";
 import { Platform, View } from "react-native";
 import { generatePath, useNavigate } from "react-router-native";
 import { CheckoutItemStatus } from "../../../../domain/checkoutItem/model/checkoutItem";
-import { usePageView } from "../../../../shared/tracking/infrastructure/usePageView";
+import { useTrackPageView } from "../../../../shared/tracking/infrastructure/useTrackPageView";
+import { useTrackPressContinue } from "../../../../shared/tracking/infrastructure/useTrackPressContinue";
+import { useTrackPressItem } from "../../../../shared/tracking/infrastructure/useTrackPressItem";
+import { useTrackPressPricing } from "../../../../shared/tracking/infrastructure/useTrackPressPricing";
+import { useTrackTabView } from "../../../../shared/tracking/infrastructure/useTrackTabView";
 import { Spinner } from "../../../../shared/ui/components/atoms/spinner/Spinner";
 import { useViewFirstAvailableCheckoutByCustomerId } from "../../../projection/checkout/react/useViewFirstAvailableCheckoutByCustomerId";
 import { useViewFiveItemsDiscountByCustomerId } from "../../../projection/checkout/react/useViewFiveItemsDiscountByCustomerId";
@@ -31,17 +35,48 @@ const Summary = ({ customerId, country }) => {
     const [checkout, checkoutStatus] = useViewFirstAvailableCheckoutByCustomerId({ customerId });
     const [pricing, pricingStatus] = useViewPricingByCheckoutId({ checkoutId: checkout?.id });
     const [fiveItemsDiscount = 0, fiveItemsDiscountStatus] = useViewFiveItemsDiscountByCustomerId({ customerId });
-    usePageView({
+    useTrackPageView({
         page: TrackingPage.SUMMARY,
         country,
         checkoutId: checkout?.id,
     });
     const navigate = useNavigate();
     const basePath = useBasePath();
+    const trackPressPricing = useTrackPressPricing({
+        page: TrackingPage.SUMMARY,
+        country,
+        checkoutId: checkout?.id,
+    });
     const [pricingCollapsed, setPricingCollapsed] = useState(true);
-    const handleOnPressPricing = useCallback(() => setPricingCollapsed(!pricingCollapsed), [pricingCollapsed]);
-    const handleOnSubmit = useCallback(() => navigate(`${basePath}/${Routes.CHECKOUT}`), [basePath, navigate]);
-    const handleOnPressItem = useCallback((checkoutItemId) => navigate(`${basePath}/${generatePath(Routes.ITEM_DETAIL, { id: checkoutItemId })}`), [basePath, navigate]);
+    const handleOnPressPricing = useCallback(() => {
+        const collapsed = !pricingCollapsed;
+        setPricingCollapsed(collapsed);
+        trackPressPricing({ collapse: collapsed });
+    }, [pricingCollapsed, trackPressPricing]);
+    const trackPressContinue = useTrackPressContinue({
+        page: TrackingPage.SUMMARY,
+        country,
+        checkoutId: checkout?.id,
+    });
+    const handleOnSubmit = useCallback(() => {
+        trackPressContinue();
+        navigate(`${basePath}/${Routes.CHECKOUT}`);
+    }, [basePath, navigate, trackPressContinue]);
+    const trackPressItem = useTrackPressItem({
+        page: TrackingPage.SUMMARY,
+        country,
+        checkoutId: checkout?.id,
+    });
+    const handleOnPressItem = useCallback((checkoutItemId) => {
+        trackPressItem({ checkoutItemId });
+        navigate(`${basePath}/${generatePath(Routes.ITEM_DETAIL, { id: checkoutItemId })}`);
+    }, [basePath, navigate, trackPressItem]);
+    const trackTabView = useTrackTabView({
+        page: TrackingPage.SUMMARY,
+        country,
+        checkoutId: checkout?.id,
+    });
+    const handleOnChangedTab = useCallback((active) => trackTabView({ tab: active === 0 ? "keep" : "return" }), [trackTabView]);
     const checkoutItemsKept = useMemo(() => checkout?.items.filter((checkoutItem) => checkoutItem.status === CheckoutItemStatus.KEPT || checkoutItem.status === CheckoutItemStatus.REPLACED), [checkout?.items]);
     const checkoutItemsReturned = useMemo(() => checkout?.items.filter((checkoutItem) => checkoutItem.status === CheckoutItemStatus.RETURNED || checkoutItem.status === CheckoutItemStatus.REPLACED), [checkout?.items]);
     const dependenciesLoadedStatuses = [QueryStatus.ERROR, QueryStatus.SUCCESS];
@@ -56,6 +91,6 @@ const Summary = ({ customerId, country }) => {
             React.createElement(View, { style: style.content },
                 React.createElement(Text, { level: 3, style: style.title, heading: true }, titleText),
                 React.createElement(Text, { level: 3, style: style.description, body: true }, descriptionText)),
-            React.createElement(CheckoutItemsTabs, { checkoutItemsKept: checkoutItemsKept || [], checkoutItemsReturned: checkoutItemsReturned || [], country: country, onPressItem: handleOnPressItem }))));
+            React.createElement(CheckoutItemsTabs, { checkoutItemsKept: checkoutItemsKept || [], checkoutItemsReturned: checkoutItemsReturned || [], country: country, onChanged: handleOnChangedTab, onPressItem: handleOnPressItem }))));
 };
 export { Summary };

package/dist/infrastructure/ui/views/summary/components/checkoutItemsTabs/CheckoutItemsTabs.d.ts

@@ -6,6 +6,7 @@ interface CheckoutItemsTabsProps {
     readonly checkoutItemsReturned: CheckoutItemProjection[];
     readonly country: Country;
     readonly onPressItem: (checkoutItemId: string) => void;
+    readonly onChanged?: (index: number) => void;
 }
 declare const CheckoutItemsTabs: FC<CheckoutItemsTabsProps>;
 export { CheckoutItemsTabs };

package/dist/infrastructure/ui/views/summary/components/checkoutItemsTabs/CheckoutItemsTabs.js

@@ -9,13 +9,13 @@ import { ProductVariant } from "../../../item/components/productVariant/ProductV
 import { style } from "./CheckoutItemsTabs.style";
 const CheckoutItem = ({ checkoutItemStatus, checkoutItemProductVariant, checkoutItemPrice, country, discarded = false, testID, style: customStyle, onPress, }) => (React.createElement(View, { style: style.checkoutItem, testID: testID },
     React.createElement(ProductVariant, { brand: checkoutItemProductVariant.brand, color: checkoutItemProductVariant.color, country: country, discarded: discarded, media: checkoutItemProductVariant.media, name: checkoutItemProductVariant.name, price: checkoutItemPrice, size: checkoutItemProductVariant.size, status: checkoutItemStatus, style: customStyle, onPress: onPress })));
-const CheckoutItemsTabs = ({ checkoutItemsKept, checkoutItemsReturned, country, onPressItem, }) => {
+const CheckoutItemsTabs = ({ checkoutItemsKept, checkoutItemsReturned, country, onPressItem, onChanged, }) => {
     const keepTabText = useI18nMessage({ id: I18nMessages.SUMMARY_KEEP_TAB });
     const returnTabText = useI18nMessage({ id: I18nMessages.SUMMARY_RETURN_TAB });
     const keepEmptyText = useI18nMessage({ id: I18nMessages.SUMMARY_KEEP_EMPTY });
     const returnEmptyText = useI18nMessage({ id: I18nMessages.SUMMARY_RETURN_EMPTY });
     const handleOnPressItem = useCallback((checkoutItemId) => onPressItem(checkoutItemId), [onPressItem]);
-    return (React.createElement(Tabs, { style: { sliderContainer: style.sliderContainer }, tabLabels: [`${keepTabText} (${checkoutItemsKept.length})`, `${returnTabText} (${checkoutItemsReturned.length})`] },
+    return (React.createElement(Tabs, { style: { sliderContainer: style.sliderContainer }, tabLabels: [`${keepTabText} (${checkoutItemsKept.length})`, `${returnTabText} (${checkoutItemsReturned.length})`], onChanged: onChanged },
         React.createElement(React.Fragment, null, checkoutItemsKept.length === 0 ? (React.createElement(Text, { style: style.emptyText }, keepEmptyText)) : (checkoutItemsKept.map((checkoutItem) => (React.createElement(CheckoutItem, { key: checkoutItem.id, checkoutItemPrice: checkoutItem.price, checkoutItemStatus: checkoutItem.status, country: country, testID: "keep-checkout-item", checkoutItemProductVariant: checkoutItem.status === CheckoutItemStatus.REPLACED && checkoutItem.replacedFor
                 ? checkoutItem.replacedFor
                 : checkoutItem.productVariant, onPress: () => handleOnPressItem(checkoutItem.id) }))))),

package/dist/shared/tracking/infrastructure/useTrackImageView.d.ts

@@ -0,0 +1,21 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { MediaPerspective } from "../../../projection/checkoutItem/checkoutItem";
+import { Country } from "../../../projection/shared/country";
+interface ImageViewFunctionArgs {
+    readonly perspective: MediaPerspective;
+}
+interface ImageViewFunction {
+    (args: ImageViewFunctionArgs): void;
+}
+interface UseTrackImageViewFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+    readonly checkoutItemId: string;
+    readonly productVariantId: string;
+}
+interface UseTrackImageViewFunction {
+    (agrs: UseTrackImageViewFunctionArgs): ImageViewFunction;
+}
+declare const useTrackImageView: UseTrackImageViewFunction;
+export { useTrackImageView };

package/dist/shared/tracking/infrastructure/useTrackImageView.js

@@ -0,0 +1,25 @@
+import { useCallback } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackImageView = ({ page, country, checkoutId, checkoutItemId, productVariantId, }) => {
+    const emitUserEvent = useEmitUserEvent();
+    const imageView = useCallback(({ perspective }) => {
+        if (!checkoutId) {
+            return;
+        }
+        const imageViewTrackingEvent = {
+            event: TrackingEvent.IMAGE_VIEW,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: `${PROJECT}_${page}`,
+            store: country,
+            checkoutId,
+            checkoutItemId,
+            productVariantId,
+            perspective,
+        };
+        emitUserEvent(imageViewTrackingEvent);
+    }, [checkoutId, checkoutItemId, country, emitUserEvent, page, productVariantId]);
+    return imageView;
+};
+export { useTrackImageView };

package/dist/shared/tracking/infrastructure/useTrackItemPageView.d.ts

@@ -0,0 +1,16 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { Country } from "../../../projection/shared/country";
+interface UseTrackItemPageViewFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId?: string;
+    readonly checkoutItemId: string;
+    readonly productVariantId: string;
+    readonly replaceableFor: string[] | undefined;
+    readonly unique: boolean;
+}
+interface UseTrackItemPageViewFunction {
+    (agrs: UseTrackItemPageViewFunctionArgs): void;
+}
+declare const useTrackItemPageView: UseTrackItemPageViewFunction;
+export { useTrackItemPageView };

package/dist/shared/tracking/infrastructure/useTrackItemPageView.js

@@ -0,0 +1,25 @@
+import { useLayoutEffect } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackItemPageView = ({ page, country, checkoutId, checkoutItemId, productVariantId, replaceableFor, unique, }) => {
+    const emitUserEvent = useEmitUserEvent();
+    useLayoutEffect(() => {
+        if (!(checkoutId && replaceableFor)) {
+            return;
+        }
+        const itemPageViewTrackingEvent = {
+            event: TrackingEvent.PAGEVIEW,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: `${PROJECT}_${page}`,
+            store: country,
+            checkoutId,
+            checkoutItemId,
+            productVariantId,
+            replaceableFor,
+            unique,
+        };
+        emitUserEvent(itemPageViewTrackingEvent);
+    }, [checkoutId, checkoutItemId, country, emitUserEvent, page, productVariantId, replaceableFor, unique]);
+};
+export { useTrackItemPageView };

package/dist/shared/tracking/infrastructure/useTrackKeepItem.d.ts

@@ -0,0 +1,16 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { Country } from "../../../projection/shared/country";
+interface KeepItemFunction {
+    (): void;
+}
+interface UseTrackKeepItemFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+    readonly checkoutItemId: string;
+}
+interface UseTrackKeepItemFunction {
+    (agrs: UseTrackKeepItemFunctionArgs): KeepItemFunction;
+}
+declare const useTrackKeepItem: UseTrackKeepItemFunction;
+export { useTrackKeepItem };

package/dist/shared/tracking/infrastructure/useTrackKeepItem.js

@@ -0,0 +1,23 @@
+import { useCallback } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackKeepItem = ({ page, country, checkoutId, checkoutItemId }) => {
+    const emitUserEvent = useEmitUserEvent();
+    const keepItem = useCallback(() => {
+        if (!checkoutId) {
+            return;
+        }
+        const keepItemTrackingEvent = {
+            event: TrackingEvent.KEEP_ITEM,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: `${PROJECT}_${page}`,
+            store: country,
+            checkoutId,
+            checkoutItemId,
+        };
+        emitUserEvent(keepItemTrackingEvent);
+    }, [checkoutId, checkoutItemId, country, emitUserEvent, page]);
+    return keepItem;
+};
+export { useTrackKeepItem };

package/dist/shared/tracking/infrastructure/useTrackPageView.d.ts

@@ -0,0 +1,12 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { Country } from "../../../projection/shared/country";
+interface UseTrackPageViewFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+}
+interface UseTrackPageViewFunction {
+    (agrs: UseTrackPageViewFunctionArgs): void;
+}
+declare const useTrackPageView: UseTrackPageViewFunction;
+export { useTrackPageView };

package/dist/shared/tracking/infrastructure/{usePageView.js → useTrackPageView.js}

@@ -2,26 +2,20 @@ import { useLayoutEffect } from "react";
 import { PROJECT } from "../../../infrastructure/tracking/tracking";
 import { TrackingEvent, TrackingEventCategory } from "../tracking";
 import { useEmitUserEvent } from "./useEmitUserEvent";
-const usePageView = ({ page, country, checkoutId, checkoutItemId }) => {
+const useTrackPageView = ({ page, country, checkoutId }) => {
     const emitUserEvent = useEmitUserEvent();
     useLayoutEffect(() => {
         if (!checkoutId) {
             return;
         }
-        const baseTrackingEvent = {
+        const pageViewTrackingEvent = {
             event: TrackingEvent.PAGEVIEW,
             eventCategory: TrackingEventCategory.NAVIGATION,
             section: `${PROJECT}_${page}`,
             store: country,
             checkoutId,
         };
-        const pageViewTrackingEvent = checkoutItemId
-            ? {
-                ...baseTrackingEvent,
-                checkoutItemId,
-            }
-            : baseTrackingEvent;
         emitUserEvent(pageViewTrackingEvent);
-    }, [checkoutId, checkoutItemId, country, emitUserEvent, page]);
+    }, [checkoutId, country, emitUserEvent, page]);
 };
-export { usePageView };
+export { useTrackPageView };

package/dist/shared/tracking/infrastructure/useTrackPressContinue.d.ts

@@ -0,0 +1,15 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { Country } from "../../../projection/shared/country";
+interface PressContinueFunction {
+    (): void;
+}
+interface UseTrackPressContinueFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+}
+interface UseTrackPressContinueFunction {
+    (agrs: UseTrackPressContinueFunctionArgs): PressContinueFunction;
+}
+declare const useTrackPressContinue: UseTrackPressContinueFunction;
+export { useTrackPressContinue };

package/dist/shared/tracking/infrastructure/useTrackPressContinue.js

@@ -0,0 +1,22 @@
+import { useCallback } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackPressContinue = ({ page, country, checkoutId }) => {
+    const emitUserEvent = useEmitUserEvent();
+    const pressContinue = useCallback(() => {
+        if (!checkoutId) {
+            return;
+        }
+        const pressContinueTrackingEvent = {
+            event: TrackingEvent.PRESS_CONTINUE,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: `${PROJECT}_${page}`,
+            store: country,
+            checkoutId,
+        };
+        emitUserEvent(pressContinueTrackingEvent);
+    }, [checkoutId, country, emitUserEvent, page]);
+    return pressContinue;
+};
+export { useTrackPressContinue };

package/dist/shared/tracking/infrastructure/useTrackPressItem.d.ts

@@ -0,0 +1,18 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { Country } from "../../../projection/shared/country";
+interface PressItemFunctionArgs {
+    readonly checkoutItemId: string;
+}
+interface PressItemFunction {
+    (args: PressItemFunctionArgs): void;
+}
+interface UseTrackPressItemFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+}
+interface UseTrackPressItemFunction {
+    (agrs: UseTrackPressItemFunctionArgs): PressItemFunction;
+}
+declare const useTrackPressItem: UseTrackPressItemFunction;
+export { useTrackPressItem };

package/dist/shared/tracking/infrastructure/useTrackPressItem.js

@@ -0,0 +1,23 @@
+import { useCallback } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackPressItem = ({ page, country, checkoutId }) => {
+    const emitUserEvent = useEmitUserEvent();
+    const pressItem = useCallback(({ checkoutItemId }) => {
+        if (!checkoutId) {
+            return;
+        }
+        const pressItemTrackingEvent = {
+            event: TrackingEvent.PRESS_ITEM,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: `${PROJECT}_${page}`,
+            store: country,
+            checkoutId,
+            checkoutItemId,
+        };
+        emitUserEvent(pressItemTrackingEvent);
+    }, [checkoutId, country, emitUserEvent, page]);
+    return pressItem;
+};
+export { useTrackPressItem };

package/dist/shared/tracking/infrastructure/useTrackPressPricing.d.ts

@@ -0,0 +1,18 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { Country } from "../../../projection/shared/country";
+interface PressPricingFunctionArgs {
+    readonly collapse: boolean;
+}
+interface PressPricingFunction {
+    (args: PressPricingFunctionArgs): void;
+}
+interface UseTrackPressPricingFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+}
+interface UseTrackPressPricingFunction {
+    (agrs: UseTrackPressPricingFunctionArgs): PressPricingFunction;
+}
+declare const useTrackPressPricing: UseTrackPressPricingFunction;
+export { useTrackPressPricing };

package/dist/shared/tracking/infrastructure/useTrackPressPricing.js

@@ -0,0 +1,23 @@
+import { useCallback } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackPressPricing = ({ page, country, checkoutId }) => {
+    const emitUserEvent = useEmitUserEvent();
+    const pressPricing = useCallback(({ collapse }) => {
+        if (!checkoutId) {
+            return;
+        }
+        const pressPricingTrackingEvent = {
+            event: TrackingEvent.PRESS_PRICING,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: `${PROJECT}_${page}`,
+            store: country,
+            checkoutId,
+            collapse,
+        };
+        emitUserEvent(pressPricingTrackingEvent);
+    }, [checkoutId, country, emitUserEvent, page]);
+    return pressPricing;
+};
+export { useTrackPressPricing };

package/dist/shared/tracking/infrastructure/useTrackReplaceItem.d.ts

@@ -0,0 +1,20 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { Country } from "../../../projection/shared/country";
+interface ReplaceItemFunctionArgs {
+    readonly replaceFor: string;
+}
+interface ReplaceItemFunction {
+    (args: ReplaceItemFunctionArgs): void;
+}
+interface UseTrackReplaceItemFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+    readonly checkoutItemId: string;
+    readonly productVariantId: string;
+}
+interface UseTrackReplaceItemFunction {
+    (agrs: UseTrackReplaceItemFunctionArgs): ReplaceItemFunction;
+}
+declare const useTrackReplaceItem: UseTrackReplaceItemFunction;
+export { useTrackReplaceItem };

package/dist/shared/tracking/infrastructure/useTrackReplaceItem.js

@@ -0,0 +1,25 @@
+import { useCallback } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackReplaceItem = ({ page, country, checkoutId, checkoutItemId, productVariantId, }) => {
+    const emitUserEvent = useEmitUserEvent();
+    const replaceItem = useCallback(({ replaceFor }) => {
+        if (!checkoutId) {
+            return;
+        }
+        const replaceItemTrackingEvent = {
+            event: TrackingEvent.REPLACE_ITEM,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: `${PROJECT}_${page}`,
+            store: country,
+            checkoutId,
+            checkoutItemId,
+            productVariantId,
+            replaceFor,
+        };
+        emitUserEvent(replaceItemTrackingEvent);
+    }, [checkoutId, checkoutItemId, country, emitUserEvent, page, productVariantId]);
+    return replaceItem;
+};
+export { useTrackReplaceItem };

package/dist/shared/tracking/infrastructure/useTrackResetItem.d.ts

@@ -0,0 +1,16 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { Country } from "../../../projection/shared/country";
+interface ResetItemFunction {
+    (): void;
+}
+interface UseTrackResetItemFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+    readonly checkoutItemId: string;
+}
+interface UseTrackResetItemFunction {
+    (agrs: UseTrackResetItemFunctionArgs): ResetItemFunction;
+}
+declare const useTrackResetItem: UseTrackResetItemFunction;
+export { useTrackResetItem };

package/dist/shared/tracking/infrastructure/useTrackResetItem.js

@@ -0,0 +1,23 @@
+import { useCallback } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackResetItem = ({ page, country, checkoutId, checkoutItemId }) => {
+    const emitUserEvent = useEmitUserEvent();
+    const resetItem = useCallback(() => {
+        if (!checkoutId) {
+            return;
+        }
+        const resetItemTrackingEvent = {
+            event: TrackingEvent.RESET_ITEM,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: `${PROJECT}_${page}`,
+            store: country,
+            checkoutId,
+            checkoutItemId,
+        };
+        emitUserEvent(resetItemTrackingEvent);
+    }, [checkoutId, checkoutItemId, country, emitUserEvent, page]);
+    return resetItem;
+};
+export { useTrackResetItem };

package/dist/shared/tracking/infrastructure/useTrackReturnItem.d.ts

@@ -0,0 +1,16 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { Country } from "../../../projection/shared/country";
+interface ReturnItemFunction {
+    (): void;
+}
+interface UseTrackReturnItemFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+    readonly checkoutItemId: string;
+}
+interface UseTrackReturnItemFunction {
+    (agrs: UseTrackReturnItemFunctionArgs): ReturnItemFunction;
+}
+declare const useTrackReturnItem: UseTrackReturnItemFunction;
+export { useTrackReturnItem };

package/dist/shared/tracking/infrastructure/useTrackReturnItem.js

@@ -0,0 +1,23 @@
+import { useCallback } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackReturnItem = ({ page, country, checkoutId, checkoutItemId }) => {
+    const emitUserEvent = useEmitUserEvent();
+    const returnItem = useCallback(() => {
+        if (!checkoutId) {
+            return;
+        }
+        const returnItemTrackingEvent = {
+            event: TrackingEvent.RETURN_ITEM,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: `${PROJECT}_${page}`,
+            store: country,
+            checkoutId,
+            checkoutItemId,
+        };
+        emitUserEvent(returnItemTrackingEvent);
+    }, [checkoutId, checkoutItemId, country, emitUserEvent, page]);
+    return returnItem;
+};
+export { useTrackReturnItem };

package/dist/shared/tracking/infrastructure/useTrackTabView.d.ts

@@ -0,0 +1,15 @@
+import { TrackingPage } from "../../../infrastructure/tracking/tracking";
+import { Country } from "../../../projection/shared/country";
+interface TabViewFunctionArgs<T> {
+    readonly tab: T;
+}
+interface TabViewFunction<T> {
+    (args: TabViewFunctionArgs<T>): void;
+}
+interface UseTrackTabViewFunctionArgs {
+    readonly page: TrackingPage;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+}
+declare const useTrackTabView: <T>({ page, country, checkoutId }: UseTrackTabViewFunctionArgs) => TabViewFunction<T>;
+export { useTrackTabView };

package/dist/shared/tracking/infrastructure/useTrackTabView.js

@@ -0,0 +1,23 @@
+import { useCallback } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackTabView = ({ page, country, checkoutId }) => {
+    const emitUserEvent = useEmitUserEvent();
+    const tabView = useCallback(({ tab }) => {
+        if (!checkoutId) {
+            return;
+        }
+        const tabViewTrackingEvent = {
+            event: TrackingEvent.TAB_VIEW,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: `${PROJECT}_${page}`,
+            store: country,
+            checkoutId,
+            tab,
+        };
+        emitUserEvent(tabViewTrackingEvent);
+    }, [checkoutId, country, emitUserEvent, page]);
+    return tabView;
+};
+export { useTrackTabView };

package/dist/shared/tracking/tracking.d.ts

@@ -1,6 +1,16 @@
+import { MediaPerspective } from "../../projection/checkoutItem/checkoutItem";
 import { Country } from "../../projection/shared/country";
 declare enum TrackingEvent {
-    PAGEVIEW = "pageview"
+    PAGEVIEW = "pageview",
+    KEEP_ITEM = "keep-item",
+    RETURN_ITEM = "return-item",
+    REPLACE_ITEM = "replace-item",
+    RESET_ITEM = "reset-item",
+    IMAGE_VIEW = "image-view",
+    PRESS_PRICING = "press-pricing",
+    PRESS_ITEM = "press-item",
+    PRESS_CONTINUE = "press-continue",
+    TAB_VIEW = "tab-view"
 }
 declare enum TrackingEventCategory {
     NAVIGATION = "navigation"
@@ -12,8 +22,41 @@ interface BaseTrackingEvent {
     readonly store: Country;
     readonly checkoutId: string;
 }
-interface PageViewTrackingEvent extends BaseTrackingEvent {
-    readonly checkoutItemId?: string;
+type PageViewTrackingEvent = BaseTrackingEvent;
+interface ItemPageViewTrackingEvent extends BaseTrackingEvent {
+    readonly checkoutItemId: string;
+    readonly productVariantId: string;
+    readonly replaceableFor: string[] | undefined;
+    readonly unique: boolean;
 }
-export type { BaseTrackingEvent, PageViewTrackingEvent };
+interface KeepItemTrackingEvent extends BaseTrackingEvent {
+    readonly checkoutItemId: string;
+}
+interface ReturnItemTrackingEvent extends BaseTrackingEvent {
+    readonly checkoutItemId: string;
+}
+interface ReplaceItemTrackingEvent extends BaseTrackingEvent {
+    readonly checkoutItemId: string;
+    readonly productVariantId: string;
+    readonly replaceFor: string;
+}
+interface ResetItemTrackingEvent extends BaseTrackingEvent {
+    readonly checkoutItemId: string;
+}
+interface ImageViewTrackingEvent extends BaseTrackingEvent {
+    readonly checkoutItemId: string;
+    readonly productVariantId: string;
+    readonly perspective: MediaPerspective;
+}
+interface PressPricingTrackingEvent extends BaseTrackingEvent {
+    readonly collapse: boolean;
+}
+interface PressItemTrackingEvent extends BaseTrackingEvent {
+    readonly checkoutItemId: string;
+}
+type PressContinueTrackingEvent = BaseTrackingEvent;
+interface TabViewTrackingEvent<T> extends BaseTrackingEvent {
+    readonly tab: T;
+}
+export type { BaseTrackingEvent, ImageViewTrackingEvent, ItemPageViewTrackingEvent, KeepItemTrackingEvent, PageViewTrackingEvent, PressContinueTrackingEvent, PressItemTrackingEvent, PressPricingTrackingEvent, ReplaceItemTrackingEvent, ResetItemTrackingEvent, ReturnItemTrackingEvent, TabViewTrackingEvent, };
 export { TrackingEvent, TrackingEventCategory };

package/dist/shared/tracking/tracking.js

@@ -1,6 +1,15 @@
 var TrackingEvent;
 (function (TrackingEvent) {
     TrackingEvent["PAGEVIEW"] = "pageview";
+    TrackingEvent["KEEP_ITEM"] = "keep-item";
+    TrackingEvent["RETURN_ITEM"] = "return-item";
+    TrackingEvent["REPLACE_ITEM"] = "replace-item";
+    TrackingEvent["RESET_ITEM"] = "reset-item";
+    TrackingEvent["IMAGE_VIEW"] = "image-view";
+    TrackingEvent["PRESS_PRICING"] = "press-pricing";
+    TrackingEvent["PRESS_ITEM"] = "press-item";
+    TrackingEvent["PRESS_CONTINUE"] = "press-continue";
+    TrackingEvent["TAB_VIEW"] = "tab-view";
 })(TrackingEvent || (TrackingEvent = {}));
 var TrackingEventCategory;
 (function (TrackingEventCategory) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lookiero/checkout",
-  "version": "0.8.23",
+  "version": "0.8.25",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [

package/dist/shared/tracking/infrastructure/usePageView.d.ts

@@ -1,13 +0,0 @@
-import { TrackingPage } from "../../../infrastructure/tracking/tracking";
-import { Country } from "../../../projection/shared/country";
-interface UsePageViewFunctionArgs {
-    readonly page: TrackingPage;
-    readonly country: Country;
-    readonly checkoutId?: string;
-    readonly checkoutItemId?: string;
-}
-interface UsePageViewFunction {
-    (agrs: UsePageViewFunctionArgs): void;
-}
-declare const usePageView: UsePageViewFunction;
-export { usePageView };