@lookiero/checkout 5.2.0-beta.0 → 5.3.0-beta.0

package/dist/infrastructure/testing/asyncKameleoon.d.ts

@@ -1,4 +1,5 @@
-import { Kameleoon, KameleoonAPI } from "./kameleoon";
+import { Logger } from "../../shared/logging/Logger";
+import { Kameleoon, KameleoonAPI } from "./Kameleoon";
 declare global {
     interface Window {
         readonly Kameleoon: KameleoonAPI;
@@ -7,9 +8,11 @@ declare global {
 }
 interface AsyncKameleoonFunctionArgs {
     readonly siteCode: string;
+    readonly logger: Logger;
 }
 interface AsyncKameleoonFunction {
     (args: AsyncKameleoonFunctionArgs): Promise<Kameleoon>;
 }
 declare const asyncKameleoon: AsyncKameleoonFunction;
 export { asyncKameleoon };
+export type { AsyncKameleoonFunction };

package/dist/infrastructure/testing/asyncKameleoon.js

@@ -1,24 +1,23 @@
+import loadjs from "loadjs";
 let instance;
-const asyncKameleoon = async ({ siteCode }) => {
+const asyncKameleoon = async ({ siteCode, logger }) => {
     if (instance) {
         return instance;
     }
     const init = async () => {
+        if (window.Kameleoon) {
+            return;
+        }
         try {
-            await fetch(`//${siteCode}.kameleoon.eu/kameleoon.js`, {
-                mode: "no-cors",
-                headers: {
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    "Content-Type": "application/json",
-                },
-            });
+            await loadjs(`//${siteCode}.kameleoon.eu/kameleoon.js`, { returnPromise: true });
+        }
+        catch (error) {
+            logger.captureException(error);
         }
-        catch (error) { }
     };
     const assignedVariantByExperimentId = ({ experimentId }) => {
         let variation = undefined;
         if (window.Kameleoon && !window.Cypress) {
-            window.Kameleoon.API.Core.load();
             const experiment = window.Kameleoon.API.Experiments.getById(experimentId);
             if (experiment && experiment.associatedVariation) {
                 variation = experiment.associatedVariation;
@@ -26,8 +25,14 @@ const asyncKameleoon = async ({ siteCode }) => {
         }
         return variation;
     };
+    const trackConversion = ({ goalId }) => {
+        if (window.Kameleoon) {
+            window.Kameleoon.API.Goals.processConversion(goalId);
+        }
+    };
     instance = {
         assignedVariantByExperimentId,
+        trackConversion,
     };
     await init();
     return instance;

package/dist/infrastructure/testing/kameleoon.d.ts

@@ -1,14 +1,28 @@
+declare const EXCLUDED_VARIATION_NAME = "Excluded";
+interface ExcludedVariation {
+    readonly id: null;
+    readonly name: typeof EXCLUDED_VARIATION_NAME;
+}
 interface Variation {
-    readonly id: number | null;
+    readonly id: number;
+    readonly name: string;
 }
+declare const isExcludedVariation: (variation: Variation | ExcludedVariation) => variation is ExcludedVariation;
 interface AssignedVariantByExperimentIdFunctionArgs {
     readonly experimentId: string;
 }
 interface AssignedVariantByExperimentIdFunction {
-    (args: AssignedVariantByExperimentIdFunctionArgs): Variation | undefined;
+    (args: AssignedVariantByExperimentIdFunctionArgs): Variation | ExcludedVariation | undefined;
+}
+interface TrackConversionFunctionArgs {
+    readonly goalId: number;
+}
+interface TrackConversionFunction {
+    (args: TrackConversionFunctionArgs): void;
 }
 interface Kameleoon {
     readonly assignedVariantByExperimentId: AssignedVariantByExperimentIdFunction;
+    readonly trackConversion: TrackConversionFunction;
 }
 interface Experiment {
     readonly id: string;
@@ -20,11 +34,16 @@ interface Experiments {
 interface Core {
     readonly load: () => void;
 }
+interface Goals {
+    readonly processConversion: (goalNameOrID: string | number, revenue?: number) => void;
+}
 interface API {
     readonly Core: Core;
     readonly Experiments: Experiments;
+    readonly Goals: Goals;
 }
 interface KameleoonAPI {
     readonly API: API;
 }
-export type { Kameleoon, Variation, KameleoonAPI, AssignedVariantByExperimentIdFunction };
+export { isExcludedVariation };
+export type { Kameleoon, Variation, KameleoonAPI, TrackConversionFunction, AssignedVariantByExperimentIdFunction, ExcludedVariation, };

package/dist/infrastructure/testing/kameleoon.js

@@ -1 +1,3 @@
-export {};
+const EXCLUDED_VARIATION_NAME = "Excluded";
+const isExcludedVariation = (variation) => variation.name === EXCLUDED_VARIATION_NAME && variation.id === null;
+export { isExcludedVariation };

package/dist/infrastructure/testing/kameleoonEnvironment.d.ts

@@ -2,11 +2,10 @@ interface Experiment<T extends string> {
     readonly id: string;
     readonly variations: Record<T, string>;
 }
-interface Experiments {
-    [key: string]: Experiment<string>;
-}
 interface KameleoonEnvironment {
     readonly siteCode: string;
-    readonly experiments: Experiments;
+    readonly experiments: {
+        readonly newFeedback: Experiment<"v1">;
+    };
 }
 export type { KameleoonEnvironment };

package/dist/infrastructure/testing/react/kameleoon.d.ts

@@ -1,8 +1,8 @@
 import { FC, ReactNode } from "react";
 interface KameleoonProps {
     readonly siteCode: string;
-    readonly loader?: ReactNode;
     readonly children: ReactNode;
+    readonly loader?: ReactNode;
 }
 declare const Kameleoon: FC<KameleoonProps>;
 export { Kameleoon };

package/dist/infrastructure/testing/react/kameleoon.js

@@ -1,2 +1,3 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const Kameleoon = ({ children }) => children;
 export { Kameleoon };

package/dist/infrastructure/testing/react/kameleoon.web.d.ts

@@ -1,4 +1,4 @@
 import { FC } from "react";
-import { KameleoonProps } from "./kameleoon";
+import { KameleoonProps } from "./Kameleoon";
 declare const Kameleoon: FC<KameleoonProps>;
 export { Kameleoon };

package/dist/infrastructure/testing/react/kameleoon.web.js

@@ -1,12 +1,14 @@
 import React, { useEffect, useState } from "react";
-import { asyncKameleoon } from "../asyncKameleoon";
+import { useLogger } from "../../../shared/logging/useLogger";
+import { asyncKameleoon } from "../AsyncKameleoon";
 import { KameleoonProvider } from "./useKameleoon";
 const Kameleoon = ({ siteCode, loader = null, children }) => {
+    const logger = useLogger();
     const [kameleoon, setKameleoon] = useState();
     useEffect(() => {
-        const loadKameleoon = async () => setKameleoon(await asyncKameleoon({ siteCode }));
+        const loadKameleoon = async () => setKameleoon(await asyncKameleoon({ siteCode, logger }));
         loadKameleoon();
-    }, [siteCode]);
+    }, [logger, siteCode]);
     return kameleoon ? (React.createElement(KameleoonProvider, { kameleoon: kameleoon }, children)) : 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     loader;

package/dist/infrastructure/testing/react/useAssignedVariationByExperimentId.d.ts

@@ -1,4 +1,4 @@
-import { Variation } from "../kameleoon";
+import { Variation } from "../Kameleoon";
 interface UseAssignedVariationByExperimentIdReturn {
     readonly assignedVariation: Variation | undefined | null;
 }

package/dist/infrastructure/testing/react/useAssignedVariationByExperimentId.js

@@ -1,4 +1,4 @@
 const useAssignedVariationByExperimentId = () => ({
-    assignedVariation: undefined,
+    assignedVariation: null,
 });
 export { useAssignedVariationByExperimentId };

package/dist/infrastructure/testing/react/useAssignedVariationByExperimentId.web.js

@@ -1,4 +1,5 @@
 import { useEffect, useState } from "react";
+import { isExcludedVariation } from "../Kameleoon";
 import { useKameleoon } from "./useKameleoon";
 const useAssignedVariationByExperimentId = ({ experimentId, enabled = true, }) => {
     const kameleoon = useKameleoon();
@@ -8,7 +9,8 @@ const useAssignedVariationByExperimentId = ({ experimentId, enabled = true, }) =
             return;
         }
         const variation = kameleoon.assignedVariantByExperimentId({ experimentId });
-        setAssignedVariation(Boolean(variation) ? variation : null);
+        const isActiveVariation = variation && !isExcludedVariation(variation);
+        setAssignedVariation(isActiveVariation ? variation : null);
     }, [enabled, experimentId, kameleoon]);
     return { assignedVariation };
 };

package/dist/infrastructure/testing/react/useKameleoon.d.ts

@@ -1,5 +1,5 @@
 import { FC, ReactNode } from "react";
-import { Kameleoon } from "../kameleoon";
+import { Kameleoon } from "../Kameleoon";
 interface KameleoonContextProviderProps {
     readonly kameleoon?: Kameleoon;
     readonly children: ReactNode;

package/dist/infrastructure/testing/react/useTrackingConversion.d.ts

@@ -0,0 +1,12 @@
+interface TrackConversionFunctionArgs {
+    readonly goalId: string;
+}
+interface TrackConversionFunction {
+    (args: TrackConversionFunctionArgs): void;
+}
+interface UseTrackingConversionFunction {
+    (): TrackConversionFunction;
+}
+declare const useTrackingConversion: UseTrackingConversionFunction;
+export { useTrackingConversion };
+export type { UseTrackingConversionFunction, TrackConversionFunction };

package/dist/infrastructure/testing/react/useTrackingConversion.js

@@ -0,0 +1,6 @@
+import { useCallback } from "react";
+const useTrackingConversion = () => {
+    const trackConversion = useCallback(() => void 0, []);
+    return trackConversion;
+};
+export { useTrackingConversion };

package/dist/infrastructure/testing/react/useTrackingConversion.web.d.ts

@@ -0,0 +1,3 @@
+import { UseTrackingConversionFunction } from "./useTrackingConversion";
+declare const useTrackingConversion: UseTrackingConversionFunction;
+export { useTrackingConversion };

package/dist/infrastructure/testing/react/useTrackingConversion.web.js

@@ -0,0 +1,13 @@
+import { useCallback } from "react";
+import { useKameleoon } from "./useKameleoon";
+const useTrackingConversion = () => {
+    const kameleoon = useKameleoon();
+    const trackConversion = useCallback(({ goalId }) => {
+        if (!kameleoon) {
+            return;
+        }
+        kameleoon.trackConversion({ goalId: Number(goalId) });
+    }, [kameleoon]);
+    return trackConversion;
+};
+export { useTrackingConversion };

package/dist/infrastructure/ui/components/organisms/returnQuestions/components/hostDefaultReturnQuestionItem/HostDefaultReturnQuestionItem.js

@@ -1,20 +1,15 @@
 import { Text, View } from "@lookiero/aurora";
 import { useI18nMessage } from "@lookiero/i18n-react";
 import React from "react";
-import { useAssignedVariationByExperimentId } from "../../../../../../testing/react/useAssignedVariationByExperimentId";
-import { useStaticInfo } from "../../../../../hooks/useStaticInfo";
+import { NewFeedbackExperimentVariation, useNewFeedbackExperiment, } from "../../../../../hooks/useNewFeedbackExperiment";
 import { I18nMessages } from "../../../../../i18n/i18n";
 import { style } from "./HostDefaultReturnQuestionItem.style";
 const HostDefaultReturnQuestionItem = ({ returnQuestion, children }) => {
     const titleText = useI18nMessage({ id: returnQuestion.name });
     const isAllOptions = returnQuestion.name === I18nMessages.RETURN_QUESTION_MAIN_ALL_OPINION;
     /* Kameleoon experiment */
-    const { kameleoon } = useStaticInfo();
-    const { experiments: { newFeedback: { id: newFeedbackId = "", variations = {} } = {} }, } = kameleoon;
-    const { assignedVariation: newFeedbackVariation } = useAssignedVariationByExperimentId({
-        experimentId: newFeedbackId,
-    });
-    const isReturnPage = newFeedbackVariation?.id === Number(variations.v2);
+    const newFeedbackVariation = useNewFeedbackExperiment();
+    const isReturnPage = newFeedbackVariation === NewFeedbackExperimentVariation.RETURN_PAGE;
     /* Kameleoon experiment */
     return (React.createElement(React.Fragment, null,
         titleText && titleText !== " " ? (React.createElement(View, { style: [

package/dist/infrastructure/ui/components/organisms/returnQuestions/components/textareaReturnQuestionItem/TextareaReturnQuestionItem.js

@@ -2,19 +2,14 @@ import { View } from "@lookiero/aurora";
 import { useIntl } from "@lookiero/i18n-react";
 import React, { useCallback, useMemo } from "react";
 import { InputField } from "../../../../../../../shared/ui/components/molecules/inputField/InputField";
-import { useAssignedVariationByExperimentId } from "../../../../../../testing/react/useAssignedVariationByExperimentId";
-import { useStaticInfo } from "../../../../../hooks/useStaticInfo";
+import { NewFeedbackExperimentVariation, useNewFeedbackExperiment, } from "../../../../../hooks/useNewFeedbackExperiment";
 import { useReturnQuestionFeedbackForReturnQuestion } from "../../behaviors/useReturnQuestionFeedback";
 import { style } from "./TextareaReturnQuestionItem.style";
 const TextareaReturnQuestionItem = ({ returnQuestion, returnQuestionParent, testID, }) => {
     const { formatMessage } = useIntl();
     /* Kameleoon experiment */
-    const { kameleoon } = useStaticInfo();
-    const { experiments: { newFeedback: { id: newFeedbackId = "", variations = {} } = {} }, } = kameleoon;
-    const { assignedVariation: newFeedbackVariation } = useAssignedVariationByExperimentId({
-        experimentId: newFeedbackId,
-    });
-    const isReturnPage = newFeedbackVariation?.id === Number(variations.v2);
+    const newFeedbackVariation = useNewFeedbackExperiment();
+    const isReturnPage = newFeedbackVariation === NewFeedbackExperimentVariation.RETURN_PAGE;
     /* Kameleoon experiment */
     const placeholderText = useMemo(() => (returnQuestion.placeholder ? formatMessage({ id: returnQuestion.placeholder }) : ""), [formatMessage, returnQuestion.placeholder]);
     const { feedback, onChange } = useReturnQuestionFeedbackForReturnQuestion({ returnQuestion: returnQuestionParent });

package/dist/infrastructure/ui/hooks/useNewFeedbackExperiment.d.ts

@@ -0,0 +1,14 @@
+import { FC, ReactNode } from "react";
+import { Country } from "../../../projection/shared/country";
+declare enum NewFeedbackExperimentVariation {
+    CONTROL = "control",
+    RETURN_PAGE = "return_page"
+}
+interface NewFeedbackExperimentProviderProps {
+    readonly country: Country;
+    readonly customerId: string;
+    readonly children: ReactNode;
+}
+declare const NewFeedbackExperimentProvider: FC<NewFeedbackExperimentProviderProps>;
+declare const useNewFeedbackExperiment: () => NewFeedbackExperimentVariation;
+export { useNewFeedbackExperiment, NewFeedbackExperimentProvider, NewFeedbackExperimentVariation };

package/dist/infrastructure/ui/hooks/useNewFeedbackExperiment.js

@@ -0,0 +1,48 @@
+import React, { createContext, useContext, useEffect, useMemo, useRef } from "react";
+import invariant from "tiny-invariant";
+import { useTrackAssignedVariationByExperiment } from "../../../shared/tracking/infrastructure/useTrackAssignedVariationByExperiment";
+import { Spinner } from "../../../shared/ui/components/atoms/spinner/Spinner";
+import { useViewFirstAvailableCheckoutByCustomerId } from "../../projection/checkout/react/useViewFirstAvailableCheckoutByCustomerId";
+import { useAssignedVariationByExperimentId } from "../../testing/react/useAssignedVariationByExperimentId";
+import { useStaticInfo } from "./useStaticInfo";
+var NewFeedbackExperimentVariation;
+(function (NewFeedbackExperimentVariation) {
+    NewFeedbackExperimentVariation["CONTROL"] = "control";
+    NewFeedbackExperimentVariation["RETURN_PAGE"] = "return_page";
+})(NewFeedbackExperimentVariation || (NewFeedbackExperimentVariation = {}));
+const NewFeedbackExperimentContext = createContext(null);
+const NewFeedbackExperimentProvider = ({ customerId, country, children }) => {
+    const { kameleoon: { experiments: { newFeedback: { id: newFeedbackId, variations }, }, }, } = useStaticInfo();
+    const [checkout] = useViewFirstAvailableCheckoutByCustomerId({ customerId });
+    const { assignedVariation: newFeedbackVariation } = useAssignedVariationByExperimentId({
+        experimentId: newFeedbackId,
+    });
+    const trackAssignedVariation = useTrackAssignedVariationByExperiment({
+        checkoutId: checkout?.id,
+        country,
+        experimentId: newFeedbackId,
+    });
+    const value = useMemo(() => ({
+        variation: newFeedbackVariation?.id === Number(variations.v1)
+            ? NewFeedbackExperimentVariation.RETURN_PAGE
+            : NewFeedbackExperimentVariation.CONTROL,
+    }), [newFeedbackVariation?.id, variations.v1]);
+    const assignedVariantTracked = useRef(false);
+    useEffect(() => {
+        if (assignedVariantTracked.current || !newFeedbackVariation || !checkout?.id) {
+            return;
+        }
+        trackAssignedVariation({ assignedVariation: newFeedbackVariation });
+        assignedVariantTracked.current = true;
+    }, [checkout?.id, newFeedbackVariation, trackAssignedVariation]);
+    if (!checkout) {
+        return React.createElement(Spinner, null);
+    }
+    return React.createElement(NewFeedbackExperimentContext.Provider, { value: value }, children);
+};
+const useNewFeedbackExperiment = () => {
+    const newFeedbackExperiment = useContext(NewFeedbackExperimentContext);
+    invariant(newFeedbackExperiment, "Your are trying to use the useNewFeedbackExperiment hook without wrapping your app with the <NewFeedbackExperimentProvider>.");
+    return newFeedbackExperiment.variation;
+};
+export { useNewFeedbackExperiment, NewFeedbackExperimentProvider, NewFeedbackExperimentVariation };

package/dist/infrastructure/ui/routing/Routing.js

@@ -1,7 +1,8 @@
 import React, { lazy, memo, Suspense } from "react";
 import { Navigate, Outlet, useRoutes as reactRouterUseRoutes } from "react-router-native";
 import { Spinner } from "../../../shared/ui/components/atoms/spinner/Spinner";
-import { Kameleoon } from "../../testing/react/kameleoon";
+import { Kameleoon } from "../../testing/react/Kameleoon";
+import { NewFeedbackExperimentProvider } from "../hooks/useNewFeedbackExperiment";
 import { StaticInfoProvider } from "../hooks/useStaticInfo";
 import { App } from "../views/App";
 import { CheckoutPaymentModal } from "../views/checkout/components/checkoutPaymentModal/CheckoutPaymentModal";
@@ -25,8 +26,9 @@ const Routing = ({ basePath = "", customer, order, subscription, locale, I18n, k
                         React.createElement(I18n, { loader: React.createElement(Spinner, null), locale: locale, onError: onI18nError },
                             React.createElement(Kameleoon, { loader: React.createElement(Spinner, null), siteCode: kameleoon.siteCode },
                                 React.createElement(CheckoutMiddleware, { customerId: customer?.customerId, onNotAccessible: onNotAccessible },
-                                    React.createElement(App, null,
-                                        React.createElement(Outlet, null))))))))),
+                                    React.createElement(NewFeedbackExperimentProvider, { country: customer?.country, customerId: customer?.customerId },
+                                        React.createElement(App, null,
+                                            React.createElement(Outlet, null)))))))))),
             children: [
                 {
                     path: Routes.ITEM,

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

@@ -18,13 +18,12 @@ import { useViewFirstAvailableCheckoutByCustomerId } from "../../../projection/c
 import { useViewFiveItemsDiscountByCustomerId } from "../../../projection/checkout/react/useViewFiveItemsDiscountByCustomerId";
 import { useViewIsSizeChangeEnabledByCheckoutId } from "../../../projection/checkout/react/useViewIsSizeChangeEnabledByCheckoutId";
 import { useListReturnQuestionsByCheckoutItemId } from "../../../projection/returnQuestion/react/useListReturnQuestionsByCheckoutItemId";
-import { useAssignedVariationByExperimentId } from "../../../testing/react/useAssignedVariationByExperimentId";
 import { TrackingPage } from "../../../tracking/tracking";
 import { FiveItemsDiscountBanner } from "../../components/atoms/fiveItemsDiscountBanner/FiveItemsDiscountBanner";
 import { ReturnQuestionFeedbackProvider } from "../../components/organisms/returnQuestions/behaviors/useReturnQuestionFeedback";
 import { ItemDetailHeader } from "../../components/templates/header/itemDetailHeader/ItemDetailHeader";
 import { ItemHeader } from "../../components/templates/header/itemHeader/ItemHeader";
-import { useStaticInfo } from "../../hooks/useStaticInfo";
+import { NewFeedbackExperimentVariation, useNewFeedbackExperiment } from "../../hooks/useNewFeedbackExperiment";
 import { Routes } from "../../routing/routes";
 import { useBasePath } from "../../routing/useBasePath";
 import { style } from "./Item.style";
@@ -42,12 +41,8 @@ const Item = ({ customerId, country, layout: Layout }) => {
     const [checkout, checkoutStatus] = useViewFirstAvailableCheckoutByCustomerId({ customerId });
     const checkoutItem = checkout?.items.find((checkoutItem) => checkoutItem.id === id);
     /* Kameleoon experiment */
-    const { kameleoon } = useStaticInfo();
-    const { experiments: { newFeedback: { id: newFeedbackId = "", variations = {} } = {} }, } = kameleoon;
-    const { assignedVariation: newFeedbackVariation } = useAssignedVariationByExperimentId({
-        experimentId: newFeedbackId,
-    });
-    const redirectToReturnPage = newFeedbackVariation?.id === Number(variations.v2);
+    const newFeedbackVariation = useNewFeedbackExperiment();
+    const redirectToReturnPage = newFeedbackVariation === NewFeedbackExperimentVariation.RETURN_PAGE;
     /* Kameleoon experiment */
     /* SizeChange and Booking */
     const [isSizeChangeEnabled, sizeChangeEnabledStatus] = useViewIsSizeChangeEnabledByCheckoutId({

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

@@ -0,0 +1,18 @@
+import { Variation } from "../../../infrastructure/testing/Kameleoon";
+import { Country } from "../../../projection/shared/country";
+interface TrackAssignedVariationFunctionArgs {
+    readonly assignedVariation: Variation;
+}
+interface TrackAssignedVariationFunction {
+    (args: TrackAssignedVariationFunctionArgs): void;
+}
+interface UseTrackAssignedVariationByExperimentFunctionArgs {
+    readonly experimentId: string;
+    readonly country: Country;
+    readonly checkoutId: string | undefined;
+}
+interface UseTrackAssignedVariationByExperimentFunction {
+    (args: UseTrackAssignedVariationByExperimentFunctionArgs): TrackAssignedVariationFunction;
+}
+declare const useTrackAssignedVariationByExperiment: UseTrackAssignedVariationByExperimentFunction;
+export { useTrackAssignedVariationByExperiment };

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

@@ -0,0 +1,24 @@
+import { useCallback } from "react";
+import { PROJECT } from "../../../infrastructure/tracking/tracking";
+import { TrackingEvent, TrackingEventCategory } from "../tracking";
+import { useEmitUserEvent } from "./useEmitUserEvent";
+const useTrackAssignedVariationByExperiment = ({ experimentId, country, checkoutId, }) => {
+    const emitUserEvent = useEmitUserEvent();
+    const trackAssignedVariation = useCallback(({ assignedVariation }) => {
+        if (!checkoutId || !assignedVariation) {
+            return;
+        }
+        const abTestTrackingEvent = {
+            event: TrackingEvent.AB_TEST,
+            eventCategory: TrackingEventCategory.NAVIGATION,
+            section: PROJECT,
+            store: country,
+            checkoutId,
+            experiment: experimentId,
+            variation: String(assignedVariation.id),
+        };
+        emitUserEvent(abTestTrackingEvent);
+    }, [checkoutId, country, emitUserEvent, experimentId]);
+    return trackAssignedVariation;
+};
+export { useTrackAssignedVariationByExperiment };

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

@@ -19,7 +19,8 @@ declare enum TrackingEvent {
     PRESS_BACK = "press_back",
     PRESS_NEXT = "press_next",
     PRESS_PREVIOUS = "press_previous",
-    CHECKOUT = "checkout"
+    CHECKOUT = "checkout",
+    AB_TEST = "abtest"
 }
 declare enum TrackingEventCategory {
     NAVIGATION = "navigation",
@@ -103,5 +104,9 @@ interface CheckoutTrackingEvent extends BaseTrackingEvent {
         };
     };
 }
-export type { BaseTrackingEvent, ChangeFeedbackTrackingEvent, CheckoutTrackingEvent, ImageViewTrackingEvent, ItemPageViewTrackingEvent, KeepItemTrackingEvent, PageViewTrackingEvent, PressContinueTrackingEvent, PressItemTrackingEvent, PressPricingTrackingEvent, ReplaceItemTrackingEvent, ResetItemTrackingEvent, ReturnItemTrackingEvent, TabViewTrackingEvent, PressMenuTrackingEvent, PressBackTrackingEvent, PressNextTrackingEvent, PressPreviousTrackingEvent, };
+interface ABTestTrackingEvent extends BaseTrackingEvent {
+    readonly experiment: string;
+    readonly variation: string;
+}
+export type { BaseTrackingEvent, ChangeFeedbackTrackingEvent, CheckoutTrackingEvent, ImageViewTrackingEvent, ItemPageViewTrackingEvent, KeepItemTrackingEvent, PageViewTrackingEvent, PressContinueTrackingEvent, PressItemTrackingEvent, PressPricingTrackingEvent, ReplaceItemTrackingEvent, ResetItemTrackingEvent, ReturnItemTrackingEvent, TabViewTrackingEvent, PressMenuTrackingEvent, PressBackTrackingEvent, PressNextTrackingEvent, PressPreviousTrackingEvent, ABTestTrackingEvent, };
 export { TrackingEvent, TrackingEventCategory };

package/dist/shared/tracking/tracking.js

@@ -16,6 +16,7 @@ var TrackingEvent;
     TrackingEvent["PRESS_NEXT"] = "press_next";
     TrackingEvent["PRESS_PREVIOUS"] = "press_previous";
     TrackingEvent["CHECKOUT"] = "checkout";
+    TrackingEvent["AB_TEST"] = "abtest";
 })(TrackingEvent || (TrackingEvent = {}));
 var TrackingEventCategory;
 (function (TrackingEventCategory) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lookiero/checkout",
-  "version": "5.2.0-beta.0",
+  "version": "5.3.0-beta.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@gorhom/portal": "^1.0.14",
-    "@lookiero/aurora": "^5.1.0",
-    "@lookiero/aurora-fonts": "^2.0.0",
-    "@lookiero/aurora-iconfont": "^3.0.0",
+    "@lookiero/aurora": ">=5",
+    "@lookiero/aurora-fonts": ">=2",
+    "@lookiero/aurora-iconfont": ">=3",
     "@lookiero/i18n": "^0.9.0",
     "@lookiero/i18n-react": "^0.9.0",
     "@lookiero/messaging": "^8.1.1",
@@ -37,6 +37,7 @@
     "@react-spring/native": "9.6.1",
     "@sentry/react-native": "^4.13.0",
     "inline-style-prefixer": "6.0.1",
+    "loadjs": "^4.2.0",
     "lodash": "^4.17.21",
     "react-native-keyboard-aware-scroll-view": "^0.9.5",
     "react-native-safe-area-context": "^4.5.0",
@@ -82,6 +83,7 @@
     "@testing-library/react-native": "^11.5.0",
     "@trivago/prettier-plugin-sort-imports": "^3.4.0",
     "@types/jest": "^29.2.4",
+    "@types/loadjs": "^4.0.4",
     "@types/pino-pretty": "^5.0.0",
     "@types/react": "~18.0.27",
     "@types/react-dom": "~18.0.10",