@lookiero/checkout 2.2.0 → 2.2.2-beta.0

package/dist/projection/bookedSizeChangeProductsVariants/viewBookedSizeChangeProductVariantsForCheckoutItem.d.ts

@@ -0,0 +1,25 @@
+import { CancelableQueryViewArgs, Query, QueryHandlerFunction, QueryHandlerFunctionArgs } from "@lookiero/messaging";
+import { BookedSizeChangeProductsVariantsProjection } from "./bookedSizeChangeProductsVariants";
+declare const VIEW_BOOKED_SIZE_CHANGE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM = "view_booked_size_change_product_variants_for_checkout_item";
+interface ViewBookedSizeChangeProductsVariantsForCheckoutItemPayload {
+    readonly checkoutItemId: string;
+}
+interface ViewBookedSizeChangeProductsVariantsForCheckoutItem extends Query<typeof VIEW_BOOKED_SIZE_CHANGE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM>, ViewBookedSizeChangeProductsVariantsForCheckoutItemPayload {
+}
+interface ViewBookedSizeChangeProductsVariantsForCheckoutItemFunction {
+    (payload: ViewBookedSizeChangeProductsVariantsForCheckoutItemPayload): ViewBookedSizeChangeProductsVariantsForCheckoutItem;
+}
+declare const viewBookedSizeChangeProductsVariantsForCheckoutItem: ViewBookedSizeChangeProductsVariantsForCheckoutItemFunction;
+type ViewBookedSizeChangeProductsVariantsForCheckoutItemResult = BookedSizeChangeProductsVariantsProjection | null;
+interface BookedSizeChangeProductsVariantsForCheckoutItemViewArgs extends CancelableQueryViewArgs {
+    readonly checkoutItemId: string;
+}
+interface BookedSizeChangeProductsVariantsForCheckoutItemView {
+    (args: BookedSizeChangeProductsVariantsForCheckoutItemViewArgs): Promise<ViewBookedSizeChangeProductsVariantsForCheckoutItemResult>;
+}
+interface ViewBookedSizeChangeProductsVariantsForCheckoutItemHandlerFunctionArgs extends QueryHandlerFunctionArgs {
+    readonly view: BookedSizeChangeProductsVariantsForCheckoutItemView;
+}
+declare const viewBookedSizeChangeProductsVariantsForCheckoutItemHandler: QueryHandlerFunction<ViewBookedSizeChangeProductsVariantsForCheckoutItem, ViewBookedSizeChangeProductsVariantsForCheckoutItemResult, ViewBookedSizeChangeProductsVariantsForCheckoutItemHandlerFunctionArgs>;
+export type { ViewBookedSizeChangeProductsVariantsForCheckoutItem, BookedSizeChangeProductsVariantsForCheckoutItemView, ViewBookedSizeChangeProductsVariantsForCheckoutItemResult, };
+export { VIEW_BOOKED_SIZE_CHANGE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM, viewBookedSizeChangeProductsVariantsForCheckoutItem, viewBookedSizeChangeProductsVariantsForCheckoutItemHandler, };

package/dist/projection/bookedSizeChangeProductsVariants/viewBookedSizeChangeProductVariantsForCheckoutItem.js

@@ -0,0 +1,8 @@
+import { query, } from "@lookiero/messaging";
+const VIEW_BOOKED_SIZE_CHANGE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM = "view_booked_size_change_product_variants_for_checkout_item";
+const viewBookedSizeChangeProductsVariantsForCheckoutItem = (payload) => ({
+    ...query({ name: VIEW_BOOKED_SIZE_CHANGE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM }),
+    ...payload,
+});
+const viewBookedSizeChangeProductsVariantsForCheckoutItemHandler = ({ view, signal }) => async ({ checkoutItemId }) => view({ checkoutItemId, signal });
+export { VIEW_BOOKED_SIZE_CHANGE_PRODUCT_VARIANTS_FOR_CHECKOUT_ITEM, viewBookedSizeChangeProductsVariantsForCheckoutItem, viewBookedSizeChangeProductsVariantsForCheckoutItemHandler, };

package/dist/projection/checkoutFeedback/viewCheckoutFeedbackByCheckoutId.d.ts

@@ -0,0 +1,25 @@
+import { CancelableQueryViewArgs, Query, QueryHandlerFunction, QueryHandlerFunctionArgs } from "@lookiero/messaging";
+import { CheckoutFeedbackProjection } from "./checkoutFeedback";
+declare const VIEW_CHECKOUT_FEEDBACK_BY_CHECKOUT_ID = "view_checkout_feedback_by_checkout_id";
+interface ViewCheckoutFeedbackByCheckoutIdPayload {
+    readonly checkoutId: string;
+}
+interface ViewCheckoutFeedbackByCheckoutId extends Query<typeof VIEW_CHECKOUT_FEEDBACK_BY_CHECKOUT_ID>, ViewCheckoutFeedbackByCheckoutIdPayload {
+}
+interface ViewCheckoutFeedbackByCheckoutIdFunction {
+    (payload: ViewCheckoutFeedbackByCheckoutIdPayload): ViewCheckoutFeedbackByCheckoutId;
+}
+declare const viewCheckoutFeedbackByCheckoutId: ViewCheckoutFeedbackByCheckoutIdFunction;
+type ViewCheckoutFeedbackByCheckoutIdResult = CheckoutFeedbackProjection | null;
+interface CheckoutFeedbackByCheckoutIdViewArgs extends CancelableQueryViewArgs {
+    readonly checkoutId: string;
+}
+interface CheckoutFeedbackByCheckoutIdView {
+    (args: CheckoutFeedbackByCheckoutIdViewArgs): Promise<ViewCheckoutFeedbackByCheckoutIdResult>;
+}
+interface ViewCheckoutFeedbackByCheckoutIdHandlerFunctionArgs extends QueryHandlerFunctionArgs {
+    readonly view: CheckoutFeedbackByCheckoutIdView;
+}
+declare const viewCheckoutFeedbackByCheckoutIdHandler: QueryHandlerFunction<ViewCheckoutFeedbackByCheckoutId, ViewCheckoutFeedbackByCheckoutIdResult, ViewCheckoutFeedbackByCheckoutIdHandlerFunctionArgs>;
+export type { ViewCheckoutFeedbackByCheckoutId, CheckoutFeedbackByCheckoutIdView, ViewCheckoutFeedbackByCheckoutIdResult, };
+export { VIEW_CHECKOUT_FEEDBACK_BY_CHECKOUT_ID, viewCheckoutFeedbackByCheckoutId, viewCheckoutFeedbackByCheckoutIdHandler, };

package/dist/projection/checkoutFeedback/viewCheckoutFeedbackByCheckoutId.js

@@ -0,0 +1,8 @@
+import { query, } from "@lookiero/messaging";
+const VIEW_CHECKOUT_FEEDBACK_BY_CHECKOUT_ID = "view_checkout_feedback_by_checkout_id";
+const viewCheckoutFeedbackByCheckoutId = (payload) => ({
+    ...query({ name: VIEW_CHECKOUT_FEEDBACK_BY_CHECKOUT_ID }),
+    ...payload,
+});
+const viewCheckoutFeedbackByCheckoutIdHandler = ({ view, signal }) => async ({ checkoutId }) => view({ checkoutId, signal });
+export { VIEW_CHECKOUT_FEEDBACK_BY_CHECKOUT_ID, viewCheckoutFeedbackByCheckoutId, viewCheckoutFeedbackByCheckoutIdHandler, };

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

@@ -0,0 +1,17 @@
+import { Command } from "@lookiero/messaging";
+import { NotificationLevel } from "../model/notification";
+declare const CREATE_NOTIFICATION = "create_notification";
+interface CreateNotificationPayload {
+    readonly aggregateId: string;
+    readonly level: NotificationLevel;
+    readonly bodyI18nKey: string;
+    readonly titleI18nKey: string | undefined;
+}
+interface CreateNotification extends Command<typeof CREATE_NOTIFICATION>, CreateNotificationPayload {
+}
+interface CreateNotificationFunction {
+    (payload: CreateNotificationPayload): CreateNotification;
+}
+declare const createNotification: CreateNotificationFunction;
+export type { CreateNotification };
+export { CREATE_NOTIFICATION, createNotification };

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

@@ -0,0 +1,7 @@
+import { command } from "@lookiero/messaging";
+const CREATE_NOTIFICATION = "create_notification";
+const createNotification = ({ aggregateId, ...payload }) => ({
+    ...command({ aggregateId, name: CREATE_NOTIFICATION }),
+    ...payload,
+});
+export { CREATE_NOTIFICATION, createNotification };

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/infrastructure/domain/notification/react/useCreateNotification.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 CreateNotificationFunctionArgs {
+    readonly aggregateId?: string;
+    readonly level: NotificationLevel;
+    readonly bodyI18nKey: string;
+    readonly titleI18nKey?: string;
+}
+interface CreateNotificationFunction {
+    (args: CreateNotificationFunctionArgs): Promise<void>;
+}
+interface UseCreateNotificationFunctionArgs {
+    readonly contextId: string;
+    readonly logger: Logger;
+}
+interface UseCreateNotificationFunction {
+    (args: UseCreateNotificationFunctionArgs): [create: CreateNotificationFunction, status: CommandStatus];
+}
+declare const useCreateNotification: UseCreateNotificationFunction;
+export { useCreateNotification };

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

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

package/dist/shared/notifications/infrastructure/ui/components/NotificationItem.d.ts

@@ -0,0 +1,12 @@
+import { FC } from "react";
+import { ToastStyle } from "../../../../ui/components/molecules/toast/Toast";
+import { NotificationProjection } from "../../../projection/notification/notification";
+interface NotificationItemProps {
+    readonly notification: NotificationProjection;
+    readonly onRemove: (notificationId: string) => void;
+    readonly autoHideTimeout?: number;
+    readonly testID?: string;
+    readonly style?: ToastStyle;
+}
+declare const NotificationItem: FC<NotificationItemProps>;
+export { NotificationItem };

package/dist/shared/notifications/infrastructure/ui/components/NotificationItem.js

@@ -0,0 +1,24 @@
+import { useI18nMessage } from "@lookiero/i18n-react";
+import React from "react";
+import { useCallback, useEffect } from "react";
+import { Toast, ToastVariant } from "../../../../ui/components/molecules/toast/Toast";
+import { NotificationLevel } from "../../../domain/notification/model/notification";
+const toastVariantForNotificationLevel = {
+    [NotificationLevel.INFO]: ToastVariant.INFO,
+    [NotificationLevel.ERROR]: ToastVariant.ERROR,
+    [NotificationLevel.SUCCESS]: ToastVariant.SUCCESS,
+};
+const NotificationItem = ({ notification, onRemove, autoHideTimeout, testID = "notification-item", style: customStyle, }) => {
+    const title = useI18nMessage({ id: notification.titleI18nKey }) || undefined;
+    const body = useI18nMessage({ id: notification.bodyI18nKey || "" });
+    const handleOnClose = useCallback(() => onRemove(notification.id), [notification.id, onRemove]);
+    useEffect(() => {
+        if (!autoHideTimeout) {
+            return;
+        }
+        const hideTimeout = setTimeout(handleOnClose, autoHideTimeout);
+        return () => clearTimeout(hideTimeout);
+    }, [autoHideTimeout, handleOnClose]);
+    return (React.createElement(Toast, { body: body, style: customStyle, testID: testID, title: title, variant: toastVariantForNotificationLevel[notification.level], onClose: handleOnClose }));
+};
+export { NotificationItem };

package/dist/shared/notifications/infrastructure/ui/components/Notifications.d.ts

@@ -0,0 +1,9 @@
+import { FC } from "react";
+import { NotificationProjection } from "../../../projection/notification/notification";
+interface NotificationsProps {
+    readonly notifications?: NotificationProjection[];
+    readonly onRemove: (notificationId: string) => void;
+    readonly autoHideTimeout?: number;
+}
+declare const Notifications: FC<NotificationsProps>;
+export { Notifications };

package/dist/shared/notifications/infrastructure/ui/components/Notifications.js

@@ -0,0 +1,20 @@
+import React from "react";
+import { View } from "react-native";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { Column } from "../../../../ui/components/layouts/column/Column";
+import { Row } from "../../../../ui/components/layouts/row/Row";
+import { Stack } from "../../../../ui/components/layouts/stack/Stack";
+import { useScreenSize } from "../../../../ui/hooks/useScreenSize";
+import { NotificationItem } from "./NotificationItem";
+import { style } from "./Notifications.style";
+const NOTIFICATIONS_AUTOHIDE_TIMEOUT = 10000;
+const Notifications = ({ notifications = [], onRemove, autoHideTimeout = NOTIFICATIONS_AUTOHIDE_TIMEOUT, }) => {
+    const { top: safeAreaInsetTop } = useSafeAreaInsets();
+    const screenSize = useScreenSize();
+    const isSmallDevice = screenSize === "S";
+    return (React.createElement(View, { pointerEvents: "box-none", style: style.notifications, testID: "notifications" },
+        React.createElement(Row, { style: [style.row, isSmallDevice && style.rowSmall, { paddingTop: safeAreaInsetTop }] },
+            React.createElement(Column, null,
+                React.createElement(Stack, null, notifications.map((notification) => (React.createElement(NotificationItem, { key: notification.id, autoHideTimeout: autoHideTimeout, notification: notification, style: { toast: style.toast }, testID: notification.id, onRemove: onRemove }))))))));
+};
+export { Notifications };

package/dist/shared/notifications/infrastructure/ui/components/Notifications.style.d.ts

@@ -0,0 +1,36 @@
+import { StyleSheet } from "react-native";
+declare const style: StyleSheet.NamedStyles<any> | StyleSheet.NamedStyles<{
+    notifications: {
+        flexDirection: "column";
+        top: number;
+        width: string;
+        zIndex: number;
+        left: number;
+    } | {
+        flexDirection: "column";
+        top: number;
+        width: string;
+        zIndex: number;
+        position: "fixed";
+        left: number;
+    } | {
+        flexDirection: "column";
+        top: number;
+        width: string;
+        zIndex: number;
+        position: "absolute";
+        left: number;
+    };
+    row: {
+        flex: number;
+        justifyContent: "center";
+    };
+    rowSmall: {
+        paddingLeft: number;
+        paddingRight: number;
+    };
+    toast: {
+        marginTop: number;
+    };
+}>;
+export { style };