@lookiero/checkout 0.8.3 → 0.8.4-beta.0

package/dist/shared/logging/SentryLogger.d.ts

@@ -1,19 +1,14 @@
-import { ComponentType } from "react";
 import { Platform } from "react-native";
+import { Logger } from "./Logger";
 interface SentryLoggerFunctionArgs {
     readonly publicKey: string;
     readonly environment: `${typeof Platform.OS}-${"DEV" | "PROD" | "EXPO"}`;
     readonly release: string;
     readonly project: string;
 }
-interface SentryLoggerHOCProps {
-    readonly customer: {
-        readonly customerId: string;
-    } | undefined;
-}
 interface SentryLoggerFunction {
-    (args: SentryLoggerFunctionArgs): <P extends SentryLoggerHOCProps>(Component: ComponentType<P>) => ComponentType<P & JSX.IntrinsicAttributes>;
+    (args: SentryLoggerFunctionArgs): Logger;
 }
 declare const sentryLogger: SentryLoggerFunction;
-export type { SentryLoggerFunctionArgs, SentryLoggerHOCProps };
+export type { SentryLoggerFunctionArgs };
 export { sentryLogger };

package/dist/shared/logging/SentryLogger.js

@@ -1,9 +1,7 @@
 import { defaultStackParser } from "@sentry/browser";
 import { makeMain } from "@sentry/core";
-import React, { useEffect } from "react";
 import { Platform } from "react-native";
-import { useRoutes as reactRouterUseRoutes } from "react-router-native";
-import { Client, Hub, transport, integrations, wrapUseRoutes, wrapComponent, ErrorBoundary, } from "./SentryDependencies";
+import { Client, Hub, integrations, transport } from "./SentryDependencies";
 // This configuration is obtained from
 // https://docs.sentry.io/clients/javascript/tips/#decluttering-sentry
 const IGNORED_ERRORS = [
@@ -51,10 +49,10 @@ const DENIED_URLS = [
     /webappstoolbarba\.texthelp\.com\//i,
     /metrics\.itunes\.apple\.com\.edgesuite\.net\//i,
 ];
-const sentryLogger = ({ publicKey, environment, release, project }) => {
+const sentryLogger = ({ environment, release, publicKey, project }) => {
     let globalHub;
     let currentHub;
-    const initHub = () => {
+    const createHub = () => {
         const client = new Client({
             environment,
             release,
@@ -72,28 +70,30 @@ const sentryLogger = ({ publicKey, environment, release, project }) => {
         });
         return new Hub(client);
     };
-    /**
-     * BrowserClient must be initialized before wrapUseRoutes is used.
-     *
-     * ReactNativeClient cannot be initialized until actual component is rendered.
-     * Its initialization will trigger the native sdk setup with the provided settings,
-     * but by the time an event will be sent to Sentry, the host project (UAF)
-     * will have overridden its configuration (dsn, etc) after initializing it
-     * so we have to initialize it after the component mount.
-     */
-    if (Platform.OS === "web") {
-        currentHub = initHub();
-    }
+    const init = () => {
+        /**
+         * BrowserClient must be initialized before wrapUseRoutes is used.
+         *
+         * ReactNativeClient cannot be initialized until actual component is rendered.
+         * Its initialization will trigger the native sdk setup with the provided settings,
+         * but by the time an event will be sent to Sentry, the host project (UAF)
+         * will have overridden its configuration (dsn, etc) after initializing it
+         * so we have to initialize it after the component mount.
+         */
+        if (Platform.OS === "web") {
+            currentHub = createHub();
+        }
+    };
     const onMount = (customerId) => {
         // currentHub won't be initialized in native until this time
-        currentHub = currentHub ?? initHub();
+        currentHub = currentHub ?? createHub();
         currentHub.setUser({ id: customerId });
         currentHub.startSession();
         if (!globalHub) {
             globalHub = makeMain(currentHub);
         }
     };
-    const onUnMount = () => {
+    const onUnmount = () => {
         if (currentHub) {
             currentHub.endSession();
             currentHub.setUser(null);
@@ -104,20 +104,14 @@ const sentryLogger = ({ publicKey, environment, release, project }) => {
             globalHub = null;
         }
     };
-    const useRoutes = wrapUseRoutes(reactRouterUseRoutes);
-    return (Component) => {
-        const WrappedComponent = wrapComponent(Component);
-        const SentryLogger = (props) => {
-            const { customer } = props;
-            useEffect(() => {
-                onMount(customer?.customerId);
-                return onUnMount;
-                // eslint-disable-next-line react-hooks/exhaustive-deps
-            }, []);
-            return (React.createElement(ErrorBoundary, null,
-                React.createElement(WrappedComponent, { ...props, useRoutes: useRoutes })));
-        };
-        return SentryLogger;
+    const captureException = (error) => {
+        currentHub?.captureException(error);
+    };
+    return {
+        init,
+        onMount,
+        onUnmount,
+        captureException,
     };
 };
 export { sentryLogger };

package/dist/shared/logging/SentryLoggerHOC.d.ts

@@ -0,0 +1,15 @@
+import { ComponentType } from "react";
+import { Logger } from "./Logger";
+interface SentryLoggerHOCFunctionArgs {
+    readonly logger: Logger;
+}
+interface SentryLoggerHOCProps {
+    readonly customer: {
+        readonly customerId: string;
+    } | undefined;
+}
+interface SentryLoggerHOCFunction {
+    (args: SentryLoggerHOCFunctionArgs): <P extends SentryLoggerHOCProps>(Component: ComponentType<P>) => ComponentType<P & JSX.IntrinsicAttributes>;
+}
+declare const sentryLoggerHOC: SentryLoggerHOCFunction;
+export { sentryLoggerHOC };

package/dist/shared/logging/SentryLoggerHOC.js

@@ -0,0 +1,22 @@
+import React, { useEffect } from "react";
+import { useRoutes as reactRouterUseRoutes } from "react-router-native";
+import { wrapUseRoutes, wrapComponent, ErrorBoundary } from "./SentryDependencies";
+const sentryLoggerHOC = ({ logger }) => {
+    logger.init();
+    const useRoutes = wrapUseRoutes(reactRouterUseRoutes);
+    return (Component) => {
+        const WrappedComponent = wrapComponent(Component);
+        const SentryLogger = (props) => {
+            const { customer } = props;
+            useEffect(() => {
+                logger.onMount(customer?.customerId);
+                return logger.onUnmount;
+                // eslint-disable-next-line react-hooks/exhaustive-deps
+            }, []);
+            return (React.createElement(ErrorBoundary, null,
+                React.createElement(WrappedComponent, { ...props, useRoutes: useRoutes })));
+        };
+        return SentryLogger;
+    };
+};
+export { sentryLoggerHOC };

package/dist/shared/logging/location.d.ts

@@ -0,0 +1,3 @@
+import { Location } from "./types";
+declare const stripFirstSlugFromLocation: (locationArg: string | Location) => Location;
+export { stripFirstSlugFromLocation };

package/dist/shared/logging/location.js

@@ -0,0 +1,5 @@
+// Remove the location's first path ("/checkout"). Otherwise it won't match the proper route.
+const stripFirstSlugFromLocation = (locationArg) => ({
+    pathname: (typeof locationArg === "string" ? locationArg : locationArg?.pathname || "").replace(/^\/\w+/, ""),
+});
+export { stripFirstSlugFromLocation };

package/dist/shared/logging/matchRoutes.d.ts

@@ -0,0 +1,3 @@
+import { matchRoutes as reactRouterMatchRoutes } from "@remix-run/router";
+declare const matchRoutes: typeof reactRouterMatchRoutes;
+export { matchRoutes };

package/dist/shared/logging/matchRoutes.js

@@ -0,0 +1,7 @@
+import { matchRoutes as reactRouterMatchRoutes } from "@remix-run/router";
+const matchRoutes = (routes, locationArg) => {
+    // Remove the location's first path ("/checkout"). Otherwise it won't match the proper route.
+    const location = (typeof locationArg === "string" ? locationArg : locationArg?.pathname || "").replace(/^\/\w+/, "");
+    return reactRouterMatchRoutes(routes, location);
+};
+export { matchRoutes };

package/dist/shared/logging/reactRouterV6Instrumentation/reactRouterV6Instrumentation.native.d.ts

@@ -0,0 +1,29 @@
+import { RoutingInstrumentation } from "@sentry/react-native";
+import { OnConfirmRoute, TransactionCreator } from "@sentry/react-native/dist/js/tracing/routingInstrumentation";
+import { BeforeNavigate } from "@sentry/react-native/dist/js/tracing/types";
+import { MatchRoutes, UseEffect, UseLocation, WrapUseRoutes } from "../types";
+/**
+ * This instrumentation has been built taking as an example the actual
+ * ReactNavigationV4Instrumentation implementation as suggested in the documentation.
+ *
+ * (https://docs.sentry.io/platforms/react-native/performance/instrumentation/automatic-instrumentation/#custom-instrumentation)
+ * (https://github.com/getsentry/sentry-react-native/blob/211ec081b6bf8d7d29541afe9d800040f61e3c4e/src/js/tracing/reactnavigationv4.ts)
+ */
+declare class ReactRouterV6Instrumentation extends RoutingInstrumentation {
+    static instrumentationName: string;
+    private useEffect;
+    private useLocation;
+    private matchRoutes;
+    private prevRoute?;
+    private recentRouteKeys;
+    private latestTransaction?;
+    private readonly maxRecentRouteLen;
+    constructor(useEffect: UseEffect, useLocation: UseLocation, matchRoutes: MatchRoutes);
+    registerRoutingInstrumentation(listener: TransactionCreator, beforeNavigate: BeforeNavigate, onConfirmRoute: OnConfirmRoute): void;
+    private onRouteChange;
+    private currentRouteFromLocation;
+    private pushRecentRouteKey;
+    private onBeforeNavigateNotSampled;
+    wrapUseRoutes: WrapUseRoutes;
+}
+export { ReactRouterV6Instrumentation };

package/dist/shared/logging/reactRouterV6Instrumentation/reactRouterV6Instrumentation.native.js

@@ -0,0 +1,134 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { RoutingInstrumentation } from "@sentry/react-native";
+import { logger } from "@sentry/utils";
+import React from "react";
+import { stripFirstSlugFromLocation } from "../location";
+import { normalizedNameAndMatchForLocation } from "./normalizedNameAndMatchForLocation";
+import { transactionContext } from "./transactionContext";
+/**
+ * This instrumentation has been built taking as an example the actual
+ * ReactNavigationV4Instrumentation implementation as suggested in the documentation.
+ *
+ * (https://docs.sentry.io/platforms/react-native/performance/instrumentation/automatic-instrumentation/#custom-instrumentation)
+ * (https://github.com/getsentry/sentry-react-native/blob/211ec081b6bf8d7d29541afe9d800040f61e3c4e/src/js/tracing/reactnavigationv4.ts)
+ */
+class ReactRouterV6Instrumentation extends RoutingInstrumentation {
+    static instrumentationName = "react-router-v6";
+    useEffect;
+    useLocation;
+    matchRoutes;
+    prevRoute;
+    recentRouteKeys = [];
+    latestTransaction;
+    maxRecentRouteLen = 200;
+    constructor(useEffect, useLocation, matchRoutes) {
+        super();
+        this.useEffect = useEffect;
+        this.useLocation = useLocation;
+        this.matchRoutes = matchRoutes;
+    }
+    registerRoutingInstrumentation(listener, beforeNavigate, onConfirmRoute) {
+        super.registerRoutingInstrumentation(listener, beforeNavigate, onConfirmRoute);
+        this.latestTransaction = this.onRouteWillChange(INITIAL_TRANSACTION_CONTEXT);
+    }
+    onRouteChange(location, routes, updateLatestTransaction = false) {
+        const currentRoute = this.currentRouteFromLocation(location, routes);
+        if (!currentRoute || (this.prevRoute && currentRoute.key === this.prevRoute.key)) {
+            return;
+        }
+        const originalContext = transactionContext({
+            instrumentationName: ReactRouterV6Instrumentation.instrumentationName,
+            route: currentRoute,
+            previousRoute: this.prevRoute,
+        });
+        let finalContext = this._beforeNavigate?.(originalContext);
+        if (!finalContext) {
+            logger.error(`[ReactRouterV6Instrumentation] beforeNavigate returned ${finalContext}, return context.sampled = false to not send transaction.`);
+            finalContext = { ...originalContext, sampled: false };
+        }
+        if (finalContext.sampled === false) {
+            this.onBeforeNavigateNotSampled(finalContext.name);
+        }
+        if (updateLatestTransaction && this.latestTransaction) {
+            this.latestTransaction.updateWithContext(finalContext);
+        }
+        else {
+            this.latestTransaction = this.onRouteWillChange(finalContext);
+        }
+        this.pushRecentRouteKey(currentRoute.key);
+        this.prevRoute = currentRoute;
+    }
+    currentRouteFromLocation(location, routes) {
+        const normalizedLocation = stripFirstSlugFromLocation(location);
+        const branches = this.matchRoutes(routes, normalizedLocation);
+        if (!branches) {
+            return null;
+        }
+        const [normalizedName, match] = normalizedNameAndMatchForLocation({
+            location: normalizedLocation,
+            routes,
+            branches,
+        });
+        if (!match) {
+            return {
+                name: normalizedName,
+                key: normalizedName,
+                params: {},
+                hasBeenSeen: this.recentRouteKeys.includes(normalizedName),
+            };
+        }
+        return {
+            name: match.route.path,
+            key: normalizedName,
+            params: match.params,
+            hasBeenSeen: this.recentRouteKeys.includes(normalizedName),
+        };
+    }
+    pushRecentRouteKey(key) {
+        this.recentRouteKeys.push(key);
+        if (this.recentRouteKeys.length > this.maxRecentRouteLen) {
+            this.recentRouteKeys = this.recentRouteKeys.slice(this.recentRouteKeys.length - this.maxRecentRouteLen);
+        }
+    }
+    onBeforeNavigateNotSampled(transactionName) {
+        logger.log(`[ReactRouterV6Instrumentation] Will not send transaction "${transactionName}" due to beforeNavigate.`);
+    }
+    wrapUseRoutes = (origUseRoutes) => {
+        if (!this.useEffect || !this.useLocation || !this.matchRoutes) {
+            __DEBUG_BUILD__ &&
+                logger.warn("ReactRouterV6Instrumentation was unable to wrap `useRoutes` because of one or more missing parameters.");
+            return origUseRoutes;
+        }
+        let isMountRenderPass = true;
+        const useRoutes = (routes, locationArg) => {
+            const SentryRoutes = () => {
+                const Routes = origUseRoutes(routes, locationArg);
+                const location = this.useLocation();
+                const stableLocationParam = typeof locationArg === "string" || (locationArg && locationArg.pathname)
+                    ? locationArg
+                    : location;
+                this.useEffect(() => {
+                    const normalizedLocation = typeof stableLocationParam === "string" ? { pathname: stableLocationParam } : stableLocationParam;
+                    if (isMountRenderPass) {
+                        this.onRouteChange(normalizedLocation, routes, true);
+                        isMountRenderPass = false;
+                    }
+                    else {
+                        this.onRouteChange(normalizedLocation, routes);
+                    }
+                }, [stableLocationParam]);
+                return Routes;
+            };
+            return React.createElement(SentryRoutes, null);
+        };
+        return useRoutes;
+    };
+}
+const INITIAL_TRANSACTION_CONTEXT = {
+    name: "App Launch",
+    op: "navigation",
+    tags: {
+        ["routing.instrumentation"]: ReactRouterV6Instrumentation.instrumentationName,
+    },
+};
+export { ReactRouterV6Instrumentation };

package/dist/shared/logging/reactRouterV6Instrumentation/transactionContext.d.ts

@@ -0,0 +1,22 @@
+import { TransactionContext } from "@sentry/types";
+import { NavigationCurrentRoute, NavigationRoute } from "./types";
+interface NavigationTransactionContext extends TransactionContext {
+    readonly tags: {
+        readonly ["routing.instrumentation"]: string;
+        readonly ["routing.route.name"]: string;
+    };
+    readonly data: {
+        readonly route: NavigationCurrentRoute;
+        readonly previousRoute: NavigationRoute | null;
+    };
+}
+interface TransactionContextFunctionArgs {
+    readonly instrumentationName: string;
+    readonly route: NavigationCurrentRoute;
+    readonly previousRoute?: NavigationRoute;
+}
+interface TransactionContextFunction {
+    (args: TransactionContextFunctionArgs): NavigationTransactionContext;
+}
+declare const transactionContext: TransactionContextFunction;
+export { transactionContext };

package/dist/shared/logging/reactRouterV6Instrumentation/transactionContext.js

@@ -0,0 +1,15 @@
+const transactionContext = ({ instrumentationName, route, previousRoute = null, }) => {
+    return {
+        name: route.name,
+        op: "navigation",
+        tags: {
+            ["routing.instrumentation"]: instrumentationName,
+            ["routing.route.name"]: route.name,
+        },
+        data: {
+            route,
+            previousRoute,
+        },
+    };
+};
+export { transactionContext };

package/dist/shared/logging/reactRouterV6Instrumentation.native.d.ts

@@ -0,0 +1,27 @@
+import { RoutingInstrumentation } from "@sentry/react-native";
+import { OnConfirmRoute, TransactionCreator } from "@sentry/react-native/dist/js/tracing/routingInstrumentation";
+import { BeforeNavigate } from "@sentry/react-native/dist/js/tracing/types";
+import { MatchRoutes, UseEffect, UseLocation, UseNavigationType, WrapUseRoutes } from "./types";
+declare class ReactRouterV6Instrumentation extends RoutingInstrumentation {
+    static instrumentationName: string;
+    private useEffect;
+    private useLocation;
+    private useNavigationType;
+    private matchRoutes;
+    private prevRoute?;
+    private recentRouteKeys;
+    private latestTransaction?;
+    private shouldUpdateLatestTransaction;
+    constructor(useEffect: UseEffect, useLocation: UseLocation, useNavigationType: UseNavigationType, matchRoutes: MatchRoutes);
+    /**
+     * Extends by calling _handleInitialState at the end.
+     */
+    registerRoutingInstrumentation(listener: TransactionCreator, beforeNavigate: BeforeNavigate, onConfirmRoute: OnConfirmRoute): void;
+    /**
+     * Starts an idle transaction for the initial state which won't get called by the router listener.
+     */
+    private handleInitialState;
+    private getTransactionContext;
+    wrapUseRoutes: WrapUseRoutes;
+}
+export { ReactRouterV6Instrumentation };

package/dist/shared/logging/reactRouterV6Instrumentation.native.js

@@ -0,0 +1,115 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { RoutingInstrumentation } from "@sentry/react-native";
+import { logger } from "@sentry/utils";
+import React from "react";
+class ReactRouterV6Instrumentation extends RoutingInstrumentation {
+    static instrumentationName = "react-router-v6";
+    useEffect;
+    useLocation;
+    useNavigationType;
+    matchRoutes;
+    // @ts-ignore
+    prevRoute;
+    recentRouteKeys = [];
+    // @ts-ignore
+    latestTransaction;
+    // @ts-ignore
+    shouldUpdateLatestTransaction = false;
+    constructor(useEffect, useLocation, useNavigationType, matchRoutes) {
+        super();
+        this.useEffect = useEffect;
+        this.useLocation = useLocation;
+        this.useNavigationType = useNavigationType;
+        this.matchRoutes = matchRoutes;
+    }
+    /**
+     * Extends by calling _handleInitialState at the end.
+     */
+    registerRoutingInstrumentation(listener, beforeNavigate, onConfirmRoute) {
+        super.registerRoutingInstrumentation(listener, beforeNavigate, onConfirmRoute);
+        // Need to handle the initial state as the router patch will only attach transactions on subsequent route changes.
+        this.handleInitialState();
+    }
+    /**
+     * Starts an idle transaction for the initial state which won't get called by the router listener.
+     */
+    handleInitialState() {
+        this.latestTransaction = this.onRouteWillChange(INITIAL_TRANSACTION_CONTEXT);
+        // We set this to true so when registerAppContainer is called, the transaction gets updated with the actual route data
+        this.shouldUpdateLatestTransaction = true;
+    }
+    // @ts-ignore
+    getTransactionContext(route, previousRoute) {
+        return {
+            name: route.name,
+            op: "navigation",
+            tags: {
+                ["routing.instrumentation"]: ReactRouterV6Instrumentation.instrumentationName,
+                ["routing.route.name"]: route.name,
+            },
+            data: {
+                route: {
+                    name: route.name,
+                    key: route.key,
+                    params: route.params ?? {},
+                    hasBeenSeen: this.recentRouteKeys.includes(route.key),
+                },
+                previousRoute: previousRoute
+                    ? {
+                        name: previousRoute.name,
+                        key: previousRoute.key,
+                        params: previousRoute.params ?? {},
+                    }
+                    : null,
+            },
+        };
+    }
+    wrapUseRoutes = (origUseRoutes) => {
+        if (!this.useEffect ||
+            !this.useLocation ||
+            !this.useNavigationType ||
+            !this.matchRoutes
+        // !this._customStartTransaction
+        ) {
+            __DEBUG_BUILD__ &&
+                logger.warn("reactRouterV6Instrumentation was unable to wrap `useRoutes` because of one or more missing parameters.");
+            return origUseRoutes;
+        }
+        let isMountRenderPass = true;
+        // eslint-disable-next-line react/display-name
+        return (routes, locationArg) => {
+            const SentryRoutes = () => {
+                const Routes = origUseRoutes(routes, locationArg);
+                const location = this.useLocation();
+                const navigationType = this.useNavigationType();
+                // A value with stable identity to either pick `locationArg` if available or `location` if not
+                const stableLocationParam = typeof locationArg === "string" || (locationArg && locationArg.pathname)
+                    ? locationArg
+                    : location;
+                this.useEffect(() => {
+                    const normalizedLocation = typeof stableLocationParam === "string" ? { pathname: stableLocationParam } : stableLocationParam;
+                    if (isMountRenderPass) {
+                        console.log("updatePageloadTransaction", normalizedLocation, routes);
+                        // updatePageloadTransaction(normalizedLocation, routes);
+                        isMountRenderPass = false;
+                    }
+                    else {
+                        console.log("normalizedLocation", normalizedLocation, routes, navigationType);
+                        // handleNavigation(normalizedLocation, routes, navigationType);
+                    }
+                }, [navigationType, stableLocationParam]);
+                return Routes;
+            };
+            return React.createElement(SentryRoutes, null);
+        };
+    };
+}
+const INITIAL_TRANSACTION_CONTEXT = {
+    name: "App Launch",
+    op: "navigation",
+    tags: {
+        ["routing.instrumentation"]: ReactRouterV6Instrumentation.instrumentationName,
+    },
+    data: {},
+};
+export { ReactRouterV6Instrumentation };

package/dist/shared/notifications/domain/notification/command/removeNotification.tes.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/notifications/domain/notification/command/removeNotification.tes.js

@@ -0,0 +1,9 @@
+import { removeNotification as sut, REMOVE_NOTIFICATION } from "./removeNotification";
+describe("removeNotification", () => {
+    it("returns a RemoveNotification command", () => {
+        const aggregateId = "67ac1d5c-6d24-4b19-bc01-8f61c266670c";
+        const command = sut({ aggregateId });
+        expect(command.aggregateId).toBe(aggregateId);
+        expect(command.name).toBe(REMOVE_NOTIFICATION);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lookiero/checkout",
-  "version": "0.8.3",
+  "version": "0.8.4-beta.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
@@ -110,6 +110,7 @@
     "prettier": "^2.7.1",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
+    "react-error-overlay": "^6.0.9",
     "react-native": "^0.70.6",
     "react-native-adjust": "^4.33.0",
     "react-native-get-random-values": "^1.8.0",

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

@@ -1,2 +0,0 @@
-declare const usePaymentInstrumentEvents: () => void;
-export { usePaymentInstrumentEvents };

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

@@ -1,28 +0,0 @@
-import { useEvent } from "@lookiero/event";
-import { useCallback, useEffect } from "react";
-import { useCreateNotification } from "../../../shared/notifications";
-import { MESSAGING_CONTEXT_ID } from "../../delivery/baseBootstrap";
-import { I18nMessages } from "../i18n/i18n";
-import { useToast } from "./useToast";
-const PAYMENT_ERROR = "ERROR";
-const PAYMENT_SUCCESS = "PAYMENT_INSTRUMENT_UPDATED";
-const usePaymentInstrumentEvents = () => {
-    const { subscribe, unsubscribe } = useEvent();
-    const { showError, showSuccess } = useToast();
-    const [createNotification] = useCreateNotification({ contextId: MESSAGING_CONTEXT_ID });
-    const onSuccess = useCallback(({ message }) => showSuccess({ message: message.id }), [showSuccess]);
-    const onError = useCallback(({ error }) => {
-        if (error.toaster) {
-            showError({ message: error.toaster.id || I18nMessages.CHECKOUT_TOAST_PAYMENT_ERROR });
-        }
-    }, [showError]);
-    useEffect(() => {
-        subscribe({ event: PAYMENT_ERROR }, onError);
-        subscribe({ event: PAYMENT_SUCCESS }, onSuccess);
-        return () => {
-            unsubscribe({ event: PAYMENT_ERROR }, onError);
-            unsubscribe({ event: PAYMENT_SUCCESS }, onSuccess);
-        };
-    }, [subscribe, unsubscribe, createNotification, onError, onSuccess]);
-};
-export { usePaymentInstrumentEvents };

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

@@ -1,11 +0,0 @@
-interface ShowErrorFunctionArgs {
-    readonly message: string;
-}
-interface ShowErrorFunction {
-    (args: ShowErrorFunctionArgs): void;
-}
-declare const useToast: () => {
-    showError: ShowErrorFunction;
-    showSuccess: ShowErrorFunction;
-};
-export { useToast };

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

@@ -1,44 +0,0 @@
-import { Notification } from "@lookiero/aurora-next/build/components/molecules/Notification/Notification";
-import { useStack } from "@lookiero/aurora-next/build/contexts/Stack/Stack";
-import { useIntl } from "@lookiero/i18n-react";
-import { useCallback } from "react";
-import { StyleSheet } from "react-native";
-import { v4 as uuid } from "uuid";
-import { theme } from "../theme/theme";
-const { layoutXXS, elevationColor, elevationOffset, elevationOpacityM, elevationRadius } = theme();
-const style = StyleSheet.create({
-    container: {
-        marginHorizontal: layoutXXS,
-        marginTop: layoutXXS,
-        shadowColor: elevationColor,
-        shadowOffset: elevationOffset,
-        shadowOpacity: elevationOpacityM,
-        shadowRadius: elevationRadius,
-    },
-    inAppContainer: {
-        top: 75,
-    },
-});
-const NOTIFICATION_DEFAULTS = {
-    motion: "top",
-    timeoutClose: 10000,
-    style: style.container,
-};
-const IN_APP_NOTIFICATION_DEFAULTS = {
-    ...NOTIFICATION_DEFAULTS,
-    style: [style.container, style.inAppContainer],
-};
-const iOSInAppBrowser = window.screen?.height > 667 && /FBIOS/.test(navigator.userAgent);
-const getNotificationDefaults = () => (iOSInAppBrowser ? IN_APP_NOTIFICATION_DEFAULTS : NOTIFICATION_DEFAULTS);
-const useToast = () => {
-    const Stack = useStack();
-    const intl = useIntl();
-    const translate = useCallback((message) => intl.formatMessage({ id: message, defaultMessage: message }), [intl]);
-    const showError = useCallback(({ message }) => Stack.alert(uuid(), Notification, { ...getNotificationDefaults(), text: translate(message) }), [Stack, translate]);
-    const showSuccess = useCallback(({ message }) => Stack.success(uuid(), Notification, { ...getNotificationDefaults(), text: translate(message) }), [Stack, translate]);
-    return {
-        showError,
-        showSuccess,
-    };
-};
-export { useToast };