@lookiero/checkout 0.8.17 → 0.8.19-beta.0

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/createModalNotification.d.ts

@@ -0,0 +1,18 @@
+import { Command } from "@lookiero/messaging";
+import { NotificationType } from "../model/notification";
+declare const CREATE_MODAL_NOTIFICATION = "create_modal_notification";
+interface CreateModalNotificationPayload {
+    readonly aggregateId: string;
+    readonly bodyI18nKey: string;
+    readonly titleI18nKey: string;
+    readonly acceptI18nKey: string;
+}
+interface CreateModalNotification extends Command<typeof CREATE_MODAL_NOTIFICATION>, CreateModalNotificationPayload {
+    readonly type: NotificationType.MODAL;
+}
+interface CreateModalNotificationFunction {
+    (payload: CreateModalNotificationPayload): CreateModalNotification;
+}
+declare const createModalNotification: CreateModalNotificationFunction;
+export type { CreateModalNotification };
+export { CREATE_MODAL_NOTIFICATION, createModalNotification };

package/dist/shared/notifications/domain/notification/command/createModalNotification.js

@@ -0,0 +1,9 @@
+import { command } from "@lookiero/messaging";
+import { NotificationType } from "../model/notification";
+const CREATE_MODAL_NOTIFICATION = "create_modal_notification";
+const createModalNotification = ({ aggregateId, ...payload }) => ({
+    ...command({ aggregateId, name: CREATE_MODAL_NOTIFICATION }),
+    ...payload,
+    type: NotificationType.MODAL,
+});
+export { CREATE_MODAL_NOTIFICATION, createModalNotification };

package/dist/shared/notifications/domain/notification/command/createToastNotification.d.ts

@@ -0,0 +1,18 @@
+import { Command } from "@lookiero/messaging";
+import { NotificationLevel, NotificationType } from "../model/notification";
+declare const CREATE_TOAST_NOTIFICATION = "create_toast_notification";
+interface CreateToastNotificationPayload {
+    readonly aggregateId: string;
+    readonly level: NotificationLevel;
+    readonly bodyI18nKey: string;
+    readonly titleI18nKey: string | undefined;
+}
+interface CreateToastNotification extends Command<typeof CREATE_TOAST_NOTIFICATION>, CreateToastNotificationPayload {
+    readonly type: NotificationType.TOAST;
+}
+interface CreateToastNotificationFunction {
+    (payload: CreateToastNotificationPayload): CreateToastNotification;
+}
+declare const createToastNotification: CreateToastNotificationFunction;
+export type { CreateToastNotification };
+export { CREATE_TOAST_NOTIFICATION, createToastNotification };

package/dist/shared/notifications/domain/notification/command/createToastNotification.js

@@ -0,0 +1,9 @@
+import { command } from "@lookiero/messaging";
+import { NotificationType } from "../model/notification";
+const CREATE_TOAST_NOTIFICATION = "create_toast_notification";
+const createToastNotification = ({ aggregateId, ...payload }) => ({
+    ...command({ aggregateId, name: CREATE_TOAST_NOTIFICATION }),
+    ...payload,
+    type: NotificationType.TOAST,
+});
+export { CREATE_TOAST_NOTIFICATION, createToastNotification };

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/dist/shared/notifications/domain/notification/model/notification.d.ts

@@ -1,18 +1,25 @@
 import { AggregateRoot, CommandHandlerFunction } from "@lookiero/messaging";
-import { CreateNotification } from "../command/createNotification";
+import { CreateModalNotification } from "../command/createModalNotification";
+import { CreateToastNotification } from "../command/createToastNotification";
 import { RemoveNotification } from "../command/removeNotification";
+declare enum NotificationType {
+    TOAST = "TOAST",
+    MODAL = "MODAL"
+}
 declare enum NotificationLevel {
     INFO = "INFO",
     ERROR = "ERROR",
     SUCCESS = "SUCCESS"
 }
-export { NotificationLevel };
 interface Notification extends AggregateRoot {
+    readonly type: NotificationType;
     readonly level: NotificationLevel;
     readonly bodyI18nKey: string;
     readonly titleI18nKey: string | undefined;
+    readonly acceptI18nKey: string | undefined;
 }
-declare const createNotificationHandler: CommandHandlerFunction<CreateNotification, Notification>;
+declare const createToastNotificationHandler: CommandHandlerFunction<CreateToastNotification, Notification>;
+declare const createModalNotificationHandler: CommandHandlerFunction<CreateModalNotification, Notification>;
 declare const removeNotificationHandler: CommandHandlerFunction<RemoveNotification, Notification>;
 export type { Notification };
-export { createNotificationHandler, removeNotificationHandler };
+export { NotificationLevel, NotificationType, createToastNotificationHandler, createModalNotificationHandler, removeNotificationHandler, };

package/dist/shared/notifications/domain/notification/model/notification.js

@@ -1,22 +1,38 @@
 import { notificationCreated } from "./notificationCreated";
 import { notificationRemoved } from "./notificationRemoved";
+var NotificationType;
+(function (NotificationType) {
+    NotificationType["TOAST"] = "TOAST";
+    NotificationType["MODAL"] = "MODAL";
+})(NotificationType || (NotificationType = {}));
 var NotificationLevel;
 (function (NotificationLevel) {
     NotificationLevel["INFO"] = "INFO";
     NotificationLevel["ERROR"] = "ERROR";
     NotificationLevel["SUCCESS"] = "SUCCESS";
 })(NotificationLevel || (NotificationLevel = {}));
-export { NotificationLevel };
-const createNotificationHandler = () => async ({ aggregateRoot, command }) => {
-    const { aggregateId, level, titleI18nKey, bodyI18nKey } = command;
+const createToastNotificationHandler = () => async ({ aggregateRoot, command }) => {
+    const { aggregateId, type, level, titleI18nKey, bodyI18nKey } = command;
     return {
         ...aggregateRoot,
+        type,
         level,
         titleI18nKey,
         bodyI18nKey,
         domainEvents: [notificationCreated({ aggregateId })],
     };
 };
+const createModalNotificationHandler = () => async ({ aggregateRoot, command }) => {
+    const { aggregateId, type, titleI18nKey, bodyI18nKey, acceptI18nKey } = command;
+    return {
+        ...aggregateRoot,
+        type,
+        titleI18nKey,
+        bodyI18nKey,
+        acceptI18nKey,
+        domainEvents: [notificationCreated({ aggregateId })],
+    };
+};
 const removeNotificationHandler = () => async ({ aggregateRoot, command }) => {
     const { aggregateId } = command;
     return {
@@ -24,4 +40,4 @@ const removeNotificationHandler = () => async ({ aggregateRoot, command }) => {
         domainEvents: [notificationRemoved({ aggregateId })],
     };
 };
-export { createNotificationHandler, removeNotificationHandler };
+export { NotificationLevel, NotificationType, createToastNotificationHandler, createModalNotificationHandler, removeNotificationHandler, };

package/dist/shared/notifications/index.d.ts

@@ -1,8 +1,9 @@
-import { useCreateNotification } from "./infrastructure/domain/notification/react/useCreateNotification";
+import { useCreateModalNotification } from "./infrastructure/domain/notification/react/useCreateModalNotification";
+import { useCreateToastNotification } from "./infrastructure/domain/notification/react/useCreateToastNotification";
 import { useRemoveNotification } from "./infrastructure/domain/notification/react/useRemoveNotification";
 import { NotificationDto } from "./infrastructure/persistence/notificationDto";
 import { Storage } from "./infrastructure/persistence/storage";
 import { notificationsRoot, NotificationsRoot } from "./infrastructure/ui/notificationsRoot";
 import { useListNotifications } from "./projection/notification/react/useListNotifications";
 export type { Storage, NotificationDto, NotificationsRoot };
-export { useListNotifications, useCreateNotification, useRemoveNotification, notificationsRoot };
+export { useListNotifications, useCreateToastNotification, useCreateModalNotification, useRemoveNotification, notificationsRoot, };

package/dist/shared/notifications/index.js

@@ -1,5 +1,6 @@
-import { useCreateNotification } from "./infrastructure/domain/notification/react/useCreateNotification";
+import { useCreateModalNotification } from "./infrastructure/domain/notification/react/useCreateModalNotification";
+import { useCreateToastNotification } from "./infrastructure/domain/notification/react/useCreateToastNotification";
 import { useRemoveNotification } from "./infrastructure/domain/notification/react/useRemoveNotification";
 import { notificationsRoot } from "./infrastructure/ui/notificationsRoot";
 import { useListNotifications } from "./projection/notification/react/useListNotifications";
-export { useListNotifications, useCreateNotification, useRemoveNotification, notificationsRoot };
+export { useListNotifications, useCreateToastNotification, useCreateModalNotification, useRemoveNotification, notificationsRoot, };

package/dist/shared/notifications/infrastructure/delivery/bootstrap.js

@@ -1,18 +1,21 @@
 import { bootstrap as messagingReactBootstrap } from "@lookiero/messaging-react";
-import { CREATE_NOTIFICATION } from "../../domain/notification/command/createNotification";
+import { CREATE_MODAL_NOTIFICATION } from "../../domain/notification/command/createModalNotification";
+import { CREATE_TOAST_NOTIFICATION } from "../../domain/notification/command/createToastNotification";
 import { REMOVE_NOTIFICATION } from "../../domain/notification/command/removeNotification";
-import { createNotificationHandler, removeNotificationHandler } from "../../domain/notification/model/notification";
+import { createModalNotificationHandler, createToastNotificationHandler, removeNotificationHandler, } from "../../domain/notification/model/notification";
 import { listNotificationsHandler, LIST_NOTIFICATIONS } from "../../projection/notification/listNotifications";
 import { getNotification, saveNotification } from "../domain/notification/model/storageNotifications";
 import { storageListNotificationsView } from "../projection/notification/storageListNotificationsView";
 const NOTIFICATIONS_MESSAGING_CONTEXT_ID = "notifications";
 const bootstrap = ({ storage }) => messagingReactBootstrap({ id: NOTIFICATIONS_MESSAGING_CONTEXT_ID })
     .query(LIST_NOTIFICATIONS, listNotificationsHandler, { view: storageListNotificationsView({ storage }) })
-    .command(CREATE_NOTIFICATION, createNotificationHandler)(getNotification, saveNotification, { storage })
+    .command(CREATE_TOAST_NOTIFICATION, createToastNotificationHandler)(getNotification, saveNotification, { storage })
+    .command(CREATE_MODAL_NOTIFICATION, createModalNotificationHandler)(getNotification, saveNotification, { storage })
     .command(REMOVE_NOTIFICATION, removeNotificationHandler)(getNotification, saveNotification, { storage })
     .build();
 const bootstrapWithBuilder = ({ storage, messaging }) => messaging
     .query(LIST_NOTIFICATIONS, listNotificationsHandler, { view: storageListNotificationsView({ storage }) })
-    .command(CREATE_NOTIFICATION, createNotificationHandler)(getNotification, saveNotification, { storage })
+    .command(CREATE_TOAST_NOTIFICATION, createToastNotificationHandler)(getNotification, saveNotification, { storage })
+    .command(CREATE_MODAL_NOTIFICATION, createModalNotificationHandler)(getNotification, saveNotification, { storage })
     .command(REMOVE_NOTIFICATION, removeNotificationHandler)(getNotification, saveNotification, { storage });
 export { NOTIFICATIONS_MESSAGING_CONTEXT_ID, bootstrap, bootstrapWithBuilder };

package/dist/shared/notifications/infrastructure/domain/notification/model/storageNotifications.js

@@ -1,10 +1,12 @@
 import { storageNotificationsCreate } from "./storageNotificationsCreate";
 import { storageNotificationsRemove } from "./storageNotificationsRemove";
-const toDomain = ({ aggregateId, level, titleI18nKey, bodyI18nKey }) => ({
+const toDomain = ({ aggregateId, type, level, titleI18nKey, bodyI18nKey, acceptI18nKey, }) => ({
     aggregateId,
+    type,
     level,
     titleI18nKey,
     bodyI18nKey,
+    acceptI18nKey,
     domainEvents: [],
 });
 const getNotification = ({ storage }) => async (aggregateId) => {

package/dist/shared/notifications/infrastructure/domain/notification/model/storageNotificationsCreate.d.ts

@@ -1,7 +1,7 @@
 import { Notification } from "../../../../domain/notification/model/notification";
 import { NotificationDto } from "../../../persistence/notificationDto";
 import { StorageNotificationsSaveFunction } from "./storageNotifications";
-declare const fromDomain: ({ aggregateId, level, titleI18nKey, bodyI18nKey }: Notification) => NotificationDto;
+declare const fromDomain: ({ aggregateId, type, level, titleI18nKey, bodyI18nKey, acceptI18nKey, }: Notification) => NotificationDto;
 interface StorageNotificationsCreateFunction extends StorageNotificationsSaveFunction {
 }
 declare const storageNotificationsCreate: StorageNotificationsCreateFunction;

package/dist/shared/notifications/infrastructure/domain/notification/model/storageNotificationsCreate.js

@@ -1,9 +1,11 @@
 import { NOTIFICATION_CREATED } from "../../../../domain/notification/model/notificationCreated";
-const fromDomain = ({ aggregateId, level, titleI18nKey, bodyI18nKey }) => ({
+const fromDomain = ({ aggregateId, type, level, titleI18nKey, bodyI18nKey, acceptI18nKey, }) => ({
     aggregateId,
+    type,
     level,
     titleI18nKey,
     bodyI18nKey,
+    acceptI18nKey,
 });
 const isNotificationCreated = (event) => event.name === NOTIFICATION_CREATED;
 const storageNotificationsCreate = ({ storage }) => async (aggregateRoot) => {

package/dist/shared/notifications/infrastructure/domain/notification/react/useCreateModalNotification.d.ts

@@ -0,0 +1,20 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+import { Logger } from "../../../../../logging/Logger";
+interface CreateModalNotificationFunctionArgs {
+    readonly aggregateId?: string;
+    readonly bodyI18nKey: string;
+    readonly titleI18nKey: string;
+    readonly acceptI18nKey: string;
+}
+interface CreateModalNotificationFunction {
+    (args: CreateModalNotificationFunctionArgs): Promise<void>;
+}
+interface UseCreateModalNotificationFunctionArgs {
+    readonly contextId: string;
+    readonly logger: Logger;
+}
+interface UseCreateModalNotificationFunction {
+    (args: UseCreateModalNotificationFunctionArgs): [create: CreateModalNotificationFunction, status: CommandStatus];
+}
+declare const useCreateModalNotification: UseCreateModalNotificationFunction;
+export { useCreateModalNotification };

package/dist/shared/notifications/infrastructure/domain/notification/react/useCreateModalNotification.js

@@ -0,0 +1,22 @@
+import { useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import { v4 as uuid } from "uuid";
+import { createModalNotification } from "../../../../domain/notification/command/createModalNotification";
+const useCreateModalNotification = ({ contextId, logger }) => {
+    const [commandBus, status] = useCommand({ contextId });
+    const create = useCallback(async ({ aggregateId, titleI18nKey, bodyI18nKey, acceptI18nKey }) => {
+        try {
+            await commandBus(createModalNotification({
+                aggregateId: aggregateId || uuid(),
+                titleI18nKey,
+                bodyI18nKey,
+                acceptI18nKey,
+            }));
+        }
+        catch (error) {
+            logger.captureException(error);
+        }
+    }, [commandBus, logger]);
+    return [create, status];
+};
+export { useCreateModalNotification };

package/dist/shared/notifications/infrastructure/domain/notification/react/useCreateToastNotification.d.ts

@@ -0,0 +1,21 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+import { Logger } from "../../../../../logging/Logger";
+import { NotificationLevel } from "../../../../domain/notification/model/notification";
+interface CreateToastNotificationFunctionArgs {
+    readonly aggregateId?: string;
+    readonly level: NotificationLevel;
+    readonly bodyI18nKey: string;
+    readonly titleI18nKey?: string;
+}
+interface CreateToastNotificationFunction {
+    (args: CreateToastNotificationFunctionArgs): Promise<void>;
+}
+interface UseCreateToastNotificationFunctionArgs {
+    readonly contextId: string;
+    readonly logger: Logger;
+}
+interface UseCreateToastNotificationFunction {
+    (args: UseCreateToastNotificationFunctionArgs): [create: CreateToastNotificationFunction, status: CommandStatus];
+}
+declare const useCreateToastNotification: UseCreateToastNotificationFunction;
+export { useCreateToastNotification };

package/dist/shared/notifications/infrastructure/domain/notification/react/useCreateToastNotification.js

@@ -0,0 +1,22 @@
+import { useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import { v4 as uuid } from "uuid";
+import { createToastNotification } from "../../../../domain/notification/command/createToastNotification";
+const useCreateToastNotification = ({ contextId, logger }) => {
+    const [commandBus, status] = useCommand({ contextId });
+    const create = useCallback(async ({ aggregateId, level, titleI18nKey, bodyI18nKey }) => {
+        try {
+            await commandBus(createToastNotification({
+                aggregateId: aggregateId || uuid(),
+                level,
+                titleI18nKey,
+                bodyI18nKey,
+            }));
+        }
+        catch (error) {
+            logger.captureException(error);
+        }
+    }, [commandBus, logger]);
+    return [create, status];
+};
+export { useCreateToastNotification };