@lookiero/checkout 0.8.3 → 0.8.4-beta.0

package/dist/domain/checkout/command/markCheckoutAsPaid.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "@lookiero/messaging";
+declare const MARK_CHECKOUT_AS_PAID = "mark_checkout_as_paid";
+interface MarkCheckoutAsPaidPayload {
+    readonly aggregateId: string;
+}
+interface MarkCheckoutAsPaid extends Command<typeof MARK_CHECKOUT_AS_PAID>, MarkCheckoutAsPaidPayload {
+}
+interface MarkCheckoutAsPaidFunction {
+    (payload: MarkCheckoutAsPaidPayload): MarkCheckoutAsPaid;
+}
+declare const markCheckoutAsPaid: MarkCheckoutAsPaidFunction;
+export type { MarkCheckoutAsPaid };
+export { MARK_CHECKOUT_AS_PAID, markCheckoutAsPaid };

package/dist/domain/checkout/command/markCheckoutAsPaid.js

@@ -0,0 +1,4 @@
+import { command } from "@lookiero/messaging";
+const MARK_CHECKOUT_AS_PAID = "mark_checkout_as_paid";
+const markCheckoutAsPaid = ({ aggregateId }) => command({ aggregateId, name: MARK_CHECKOUT_AS_PAID });
+export { MARK_CHECKOUT_AS_PAID, markCheckoutAsPaid };

package/dist/domain/checkout/model/checkout.js

@@ -11,6 +11,7 @@ var CheckoutStatus;
 })(CheckoutStatus || (CheckoutStatus = {}));
 const startCheckoutHandler = () => async ({ aggregateRoot, command }) => {
     const { aggregateId } = command;
+    invariant(aggregateRoot.status !== CheckoutStatus.STARTED, "Checkout is already started");
     invariant(aggregateRoot.status !== CheckoutStatus.SUBMITTED, "Checkout is already submitted");
     invariant(aggregateRoot.status !== CheckoutStatus.COMPLETED, "Checkout is already completed");
     return {

package/dist/domain/checkout/model/checkoutPaid.d.ts

@@ -0,0 +1,13 @@
+import { DomainEvent } from "@lookiero/messaging";
+declare const CHECKOUT_PAID = "checkout_paid";
+interface CheckoutPaidPayload {
+    readonly aggregateId: string;
+}
+interface CheckoutPaid extends DomainEvent<typeof CHECKOUT_PAID>, CheckoutPaidPayload {
+}
+interface CheckoutPaidFunction {
+    (payload: CheckoutPaidPayload): CheckoutPaid;
+}
+declare const checkoutPaid: CheckoutPaidFunction;
+export type { CheckoutPaid };
+export { CHECKOUT_PAID, checkoutPaid };

package/dist/domain/checkout/model/checkoutPaid.js

@@ -0,0 +1,4 @@
+import { domainEvent } from "@lookiero/messaging";
+const CHECKOUT_PAID = "checkout_paid";
+const checkoutPaid = ({ aggregateId }) => domainEvent({ aggregateId, name: CHECKOUT_PAID });
+export { CHECKOUT_PAID, checkoutPaid };

package/dist/infrastructure/delivery/http/fetchHttpClient.js

@@ -1,20 +1,37 @@
-const fetchHttpPost = ({ apiUrl, getAuthToken }) => async ({ endpoint, body, signal }) => fetch(`${apiUrl}${endpoint}`, {
-    method: "POST",
-    headers: {
-        ["Content-Type"]: "application/json",
-        authorization: `Bearer ${await getAuthToken()}`,
-    },
-    body: JSON.stringify(body),
-    signal,
-});
-const fetchHttpGet = ({ apiUrl, getAuthToken }) => async ({ endpoint, signal }) => fetch(`${apiUrl}${endpoint}`, {
-    method: "GET",
-    credentials: "include",
-    headers: {
-        Authorization: `Bearer ${await getAuthToken()}`,
-        ["Content-Type"]: "application/json",
-    },
-    referrer: "",
-    signal,
-});
+const fetchHttpPost = ({ apiUrl, getAuthToken }) => async ({ endpoint, body, signal, result }) => {
+    const response = await fetch(`${apiUrl}${endpoint}`, {
+        method: "POST",
+        headers: {
+            ["Content-Type"]: "application/json",
+            authorization: `Bearer ${await getAuthToken()}`,
+        },
+        body: JSON.stringify(body),
+        signal,
+    });
+    return await processResponse({ response, result });
+};
+const fetchHttpGet = ({ apiUrl, getAuthToken }) => async ({ endpoint, signal, result }) => {
+    const response = await fetch(`${apiUrl}${endpoint}`, {
+        method: "GET",
+        credentials: "include",
+        headers: {
+            Authorization: `Bearer ${await getAuthToken()}`,
+            ["Content-Type"]: "application/json",
+        },
+        referrer: "",
+        signal,
+    });
+    return await processResponse({ response, result });
+};
+const processResponse = async ({ response, result }) => {
+    if (response.ok) {
+        const responseText = await response.text();
+        const responseResult = responseText ? JSON.parse(responseText) : responseText;
+        return result?.success(responseResult) ?? responseResult;
+    }
+    if (result?.error !== undefined) {
+        return result.error;
+    }
+    throw new Error(response.statusText);
+};
 export { fetchHttpGet, fetchHttpPost };

package/dist/infrastructure/delivery/http/httpClient.d.ts

@@ -1,16 +1,22 @@
+interface HttpFunctionResult {
+    readonly error: any;
+    readonly success: (response: any) => any;
+}
 interface HttpGetFunctionArgs {
     readonly endpoint: string;
     readonly signal?: AbortSignal;
+    readonly result?: HttpFunctionResult;
 }
 interface HttpGetFunction {
-    (args: HttpGetFunctionArgs): Promise<Response>;
+    (args: HttpGetFunctionArgs): Promise<any>;
 }
 interface HttpPostFunctionArgs {
     readonly endpoint: string;
     readonly body: Record<string, unknown>;
     readonly signal?: AbortSignal;
+    readonly result?: HttpFunctionResult;
 }
 interface HttpPostFunction {
-    (args: HttpPostFunctionArgs): Promise<Response>;
+    (args: HttpPostFunctionArgs): Promise<any>;
 }
-export type { HttpGetFunction, HttpPostFunction };
+export type { HttpGetFunction, HttpPostFunction, HttpFunctionResult };

package/dist/infrastructure/domain/checkout/model/httpCheckoutsMarkAsPaid.d.ts

@@ -0,0 +1,5 @@
+import { HttpCheckoutsSaveFunction } from "./httpCheckouts";
+interface HttpCheckoutsMarkAsPaidFunction extends HttpCheckoutsSaveFunction {
+}
+declare const httpCheckoutsMarkAsPaid: HttpCheckoutsMarkAsPaidFunction;
+export { httpCheckoutsMarkAsPaid };

package/dist/infrastructure/domain/checkout/model/httpCheckoutsMarkAsPaid.js

@@ -0,0 +1,13 @@
+import { CHECKOUT_PAID } from "../../../../domain/checkout/model/checkoutPaid";
+const isCheckoutPaid = (event) => event.name === CHECKOUT_PAID;
+const httpCheckoutsMarkAsPaid = ({ httpPost }) => async ({ aggregateId, domainEvents }) => {
+    const checkoutPaid = domainEvents.find(isCheckoutPaid);
+    if (!checkoutPaid) {
+        return;
+    }
+    await httpPost({
+        endpoint: "/mark-checkout-as-paid",
+        body: { checkoutId: aggregateId },
+    });
+};
+export { httpCheckoutsMarkAsPaid };

package/dist/infrastructure/domain/checkout/react/useMarkCheckoutAsPaid.d.ts

@@ -0,0 +1,13 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+interface MarkAsPaidFunction {
+    (): Promise<void>;
+}
+type UseMarkCheckoutAsPaid = [markAsPaid: MarkAsPaidFunction, status: CommandStatus];
+interface UseMarkCheckoutAsPaidFunctionArgs {
+    readonly checkoutId?: string;
+}
+interface UseMarkCheckoutAsPaidFunction {
+    (args: UseMarkCheckoutAsPaidFunctionArgs): UseMarkCheckoutAsPaid;
+}
+declare const useMarkCheckoutAsPaid: UseMarkCheckoutAsPaidFunction;
+export { useMarkCheckoutAsPaid };

package/dist/infrastructure/domain/checkout/react/useMarkCheckoutAsPaid.js

@@ -0,0 +1,16 @@
+import { useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import invariant from "tiny-invariant";
+import { markCheckoutAsPaid } from "../../../../domain/checkout/command/markCheckoutAsPaid";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+const useMarkCheckoutAsPaid = ({ checkoutId }) => {
+    const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
+    const markAsPaid = useCallback(() => {
+        invariant(checkoutId, "CheckoutId must be defined in order to mark the checkout as paid");
+        return commandBus(markCheckoutAsPaid({
+            aggregateId: checkoutId,
+        }));
+    }, [checkoutId, commandBus]);
+    return [markAsPaid, status];
+};
+export { useMarkCheckoutAsPaid };

package/dist/infrastructure/domain/checkout/react/useStartCheckout.d.ts

@@ -1,6 +1,6 @@
 import { CommandStatus } from "@lookiero/messaging-react";
 interface StartCheckoutFunction {
-    (): Promise<void>;
+    (): Promise<void> | undefined;
 }
 interface UseStartCheckoutArgs {
     readonly checkoutId?: string;

package/dist/infrastructure/domain/checkout/react/useStartCheckout.js

@@ -5,9 +5,16 @@ import { startCheckout } from "../../../../domain/checkout/command/startCheckout
 import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
 const useStartCheckout = ({ checkoutId }) => {
     const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
-    const start = useCallback(() => {
+    const start = useCallback(async () => {
         invariant(checkoutId, "CheckoutId must be defined in order to start checkout");
-        return commandBus(startCheckout({ aggregateId: checkoutId }));
+        try {
+            return await commandBus(startCheckout({ aggregateId: checkoutId }));
+        }
+        catch (error) {
+            if (!error?.message?.includes("Checkout is already started")) {
+                // logger?.captureException(error as Error);
+            }
+        }
     }, [checkoutId, commandBus]);
     return [start, status];
 };

package/dist/infrastructure/domain/checkoutBooking/react/useBookCheckouBookingForCheckoutItem.d.ts

@@ -0,0 +1,13 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+interface BookFunction {
+    (): Promise<void>;
+}
+type UseBookCheckouBookingForCheckoutItem = [book: BookFunction, status: CommandStatus];
+interface UseBookCheckouBookingForCheckoutItemFunctionArgs {
+    readonly checkoutItemId: string;
+}
+interface UseBookCheckouBookingForCheckoutItemFunction {
+    (args: UseBookCheckouBookingForCheckoutItemFunctionArgs): UseBookCheckouBookingForCheckoutItem;
+}
+declare const useBookCheckouBookingForCheckoutItem: UseBookCheckouBookingForCheckoutItemFunction;
+export { useBookCheckouBookingForCheckoutItem };

package/dist/infrastructure/domain/checkoutBooking/react/useBookCheckouBookingForCheckoutItem.js

@@ -0,0 +1,14 @@
+import { useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import { v4 as uuid } from "uuid";
+import { bookCheckoutBookingForCheckoutItem } from "../../../../domain/checkoutBooking/command/bookCheckoutBookingForCheckoutItem";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+const useBookCheckouBookingForCheckoutItem = ({ checkoutItemId }) => {
+    const [commandBus, status] = useCommand({ contextId: MESSAGING_CONTEXT_ID });
+    const book = useCallback(() => commandBus(bookCheckoutBookingForCheckoutItem({
+        aggregateId: uuid(),
+        checkoutItemId,
+    })), [checkoutItemId, commandBus]);
+    return [book, status];
+};
+export { useBookCheckouBookingForCheckoutItem };

package/dist/infrastructure/domain/uiSetting/react/useIncrementIntroShownCount.d.ts

@@ -0,0 +1,10 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+interface IncrementIntroShownCountFunction {
+    (): Promise<void>;
+}
+type UseIncrementIntroShownCount = [incrementIntroShownCount: IncrementIntroShownCountFunction, status: CommandStatus];
+interface UseIncrementIntroShownCountFunction {
+    (): UseIncrementIntroShownCount;
+}
+declare const useIncrementIntroShownCount: UseIncrementIntroShownCountFunction;
+export { useIncrementIntroShownCount };

package/dist/infrastructure/domain/uiSetting/react/useIncrementIntroShownCount.js

@@ -0,0 +1,11 @@
+import { useCallback } from "react";
+import { useViewIntroShownCount } from "../../../projection/uiSetting/react/useViewIntroShownCount";
+import { UISettings } from "../../../ui/settings/UISettings";
+import { useUpdateUiSetting } from "./useUpdateUiSetting";
+const useIncrementIntroShownCount = () => {
+    const [update, status] = useUpdateUiSetting();
+    const [introShownCount] = useViewIntroShownCount();
+    const incrementIntroShownCount = useCallback(() => update({ key: UISettings.INTRO_SHOWN_COUNT, value: introShownCount + 1 }), [introShownCount, update]);
+    return [incrementIntroShownCount, status];
+};
+export { useIncrementIntroShownCount };

package/dist/infrastructure/projection/bookedProductsVariants/httpBookedProductsVariantsForCheckoutItemView.js

@@ -1,9 +1,10 @@
-const httpBookedProductsVariantsForCheckoutItemView = ({ httpPost }) => async ({ checkoutItemId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/view-booked-product-variants-for-checkout-item",
-        body: { checkoutItemId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : (await response.json()).result;
-};
+const httpBookedProductsVariantsForCheckoutItemView = ({ httpPost }) => async ({ checkoutItemId, signal }) => await httpPost({
+    endpoint: "/view-booked-product-variants-for-checkout-item",
+    body: { checkoutItemId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => response.result,
+    },
+});
 export { httpBookedProductsVariantsForCheckoutItemView };

package/dist/infrastructure/projection/bookedSizeChangeProductsVariants/httpBookedSizeChangeProductsVariantsForCheckoutItemView.d.ts

@@ -0,0 +1,12 @@
+import { BookedSizeChangeProductsVariantsForCheckoutItemView } from "../../../projection/bookedSizeChangeProductsVariants/viewBookedSizeChangeProductVariantsForCheckoutItem";
+import { HttpPostFunction } from "../../delivery/http/httpClient";
+interface HttpBookedSizeChangeProductsVariantsForCheckoutItemView extends BookedSizeChangeProductsVariantsForCheckoutItemView {
+}
+interface HttpBookedSizeChangeProductsVariantsForCheckoutItemViewFunctionArgs {
+    readonly httpPost: HttpPostFunction;
+}
+interface HttpBookedSizeChangeProductsVariantsForCheckoutItemViewFunction {
+    (args: HttpBookedSizeChangeProductsVariantsForCheckoutItemViewFunctionArgs): HttpBookedSizeChangeProductsVariantsForCheckoutItemView;
+}
+declare const httpBookedSizeChangeProductsVariantsForCheckoutItemView: HttpBookedSizeChangeProductsVariantsForCheckoutItemViewFunction;
+export { httpBookedSizeChangeProductsVariantsForCheckoutItemView };

package/dist/infrastructure/projection/bookedSizeChangeProductsVariants/httpBookedSizeChangeProductsVariantsForCheckoutItemView.js

@@ -0,0 +1,9 @@
+const httpBookedSizeChangeProductsVariantsForCheckoutItemView = ({ httpPost }) => async ({ checkoutItemId, signal }) => {
+    const response = await httpPost({
+        endpoint: "/view-booked-size-change-product-variants-for-checkout-item",
+        body: { checkoutItemId },
+        signal,
+    });
+    return !response.ok || response.status === 404 ? null : (await response.json()).result;
+};
+export { httpBookedSizeChangeProductsVariantsForCheckoutItemView };

package/dist/infrastructure/projection/bookedSizeChangeProductsVariants/react/useViewBookedSizeChangeProductsVariantsForCheckoutItem.d.ts

@@ -0,0 +1,10 @@
+import { UseQueryFunctionResult } from "@lookiero/messaging-react";
+import { BookedSizeChangeProductsVariantsProjection } from "../../../../projection/bookedSizeChangeProductsVariants/bookedSizeChangeProductsVariants";
+interface UseViewBookedSizeChangeProductsVariantsForCheckoutItemFunctionArgs {
+    readonly checkoutItemId: string;
+}
+interface UseViewBookedSizeChangeProductsVariantsForCheckoutItemFunction {
+    (args: UseViewBookedSizeChangeProductsVariantsForCheckoutItemFunctionArgs): UseQueryFunctionResult<BookedSizeChangeProductsVariantsProjection>;
+}
+declare const useViewBookedSizeChangeProductsVariantsForCheckoutItem: UseViewBookedSizeChangeProductsVariantsForCheckoutItemFunction;
+export { useViewBookedSizeChangeProductsVariantsForCheckoutItem };

package/dist/infrastructure/projection/bookedSizeChangeProductsVariants/react/useViewBookedSizeChangeProductsVariantsForCheckoutItem.js

@@ -0,0 +1,12 @@
+import { useQuery } from "@lookiero/messaging-react";
+import { CHECKOUT_BOOKING_BOOKED, } from "../../../../domain/checkoutBooking/model/checkoutBookingBooked";
+import { viewBookedSizeChangeProductsVariantsForCheckoutItem } from "../../../../projection/bookedSizeChangeProductsVariants/viewBookedSizeChangeProductVariantsForCheckoutItem";
+import { MESSAGING_CONTEXT_ID } from "../../../delivery/baseBootstrap";
+const isCheckoutBookingBooked = (event) => event.name === CHECKOUT_BOOKING_BOOKED;
+const useViewBookedSizeChangeProductsVariantsForCheckoutItem = ({ checkoutItemId }) => useQuery({
+    query: viewBookedSizeChangeProductsVariantsForCheckoutItem({ checkoutItemId }),
+    contextId: MESSAGING_CONTEXT_ID,
+    invalidation: isCheckoutBookingBooked,
+    options: { staleTime: Infinity, retry: false, refetchOnWindowFocus: false },
+});
+export { useViewBookedSizeChangeProductsVariantsForCheckoutItem };

package/dist/infrastructure/projection/checkout/httpCheckoutByIdView.js

@@ -1,10 +1,11 @@
 import { toCheckoutProjection } from "./checkout";
-const httpCheckoutByIdView = ({ httpPost }) => async ({ checkoutId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/view-checkout-by-id",
-        body: { checkoutId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : toCheckoutProjection((await response.json()).result);
-};
+const httpCheckoutByIdView = ({ httpPost }) => async ({ checkoutId, signal }) => await httpPost({
+    endpoint: "/view-checkout-by-id",
+    body: { checkoutId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => toCheckoutProjection(response.result),
+    },
+});
 export { httpCheckoutByIdView };

package/dist/infrastructure/projection/checkout/httpFirstAvailableCheckoutByCustomerIdView.js

@@ -1,10 +1,11 @@
 import { toCheckoutProjection } from "./checkout";
-const httpFirstAvailableCheckoutByCustomerIdView = ({ httpPost }) => async ({ customerId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/view-first-available-checkout-by-customer-id",
-        body: { customerId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : toCheckoutProjection((await response.json()).result);
-};
+const httpFirstAvailableCheckoutByCustomerIdView = ({ httpPost }) => async ({ customerId, signal }) => await httpPost({
+    endpoint: "/view-first-available-checkout-by-customer-id",
+    body: { customerId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => toCheckoutProjection(response.result),
+    },
+});
 export { httpFirstAvailableCheckoutByCustomerIdView };

package/dist/infrastructure/projection/checkout/httpFiveItemsDiscountByCustomerIdView.js

@@ -1,8 +1,9 @@
-const httpFiveItemsDiscountByCustomerIdView = ({ httpGet }) => async ({ customerId, signal }) => {
-    const response = await httpGet({
-        endpoint: `/view-five-items-discount-by-customer-id/${customerId}`,
-        signal,
-    });
-    return !response.ok ? 0 : await response.json();
-};
+const httpFiveItemsDiscountByCustomerIdView = ({ httpGet }) => async ({ customerId, signal }) => await httpGet({
+    endpoint: `/view-five-items-discount-by-customer-id/${customerId}`,
+    signal,
+    result: {
+        error: 0,
+        success: (response) => response,
+    },
+});
 export { httpFiveItemsDiscountByCustomerIdView };

package/dist/infrastructure/projection/checkout/httpIsCheckoutEnabledByCustomerIdView.js

@@ -1,8 +1,9 @@
-const httpIsCheckoutEnabledByCustomerIdView = ({ httpGet }) => async ({ customerId, signal }) => {
-    const response = await httpGet({
-        endpoint: `/is-new-checkout-enabled/${customerId}`,
-        signal,
-    });
-    return !response.ok ? false : await response.json();
-};
+const httpIsCheckoutEnabledByCustomerIdView = ({ httpGet }) => async ({ customerId, signal }) => await httpGet({
+    endpoint: `/is-new-checkout-enabled/${customerId}`,
+    signal,
+    result: {
+        error: false,
+        success: (response) => response,
+    },
+});
 export { httpIsCheckoutEnabledByCustomerIdView };

package/dist/infrastructure/projection/checkout/react/useViewFirstAvailableCheckoutByCustomerId.js

@@ -1,7 +1,6 @@
 import { useQuery } from "@lookiero/messaging-react";
 import { CHECKOUT_STARTED } from "../../../../domain/checkout/model/checkoutStarted";
 import { CHECKOUT_SUBMITTED } from "../../../../domain/checkout/model/checkoutSubmitted";
-import { CHECKOUT_BOOKING_BOOKED, } from "../../../../domain/checkoutBooking/model/checkoutBookingBooked";
 import { CHECKOUT_BOOKING_EXPIRED, } from "../../../../domain/checkoutBooking/model/checkoutBookingExpired";
 import { CHECKOUT_FEEDBACK_GIVEN, } from "../../../../domain/checkoutFeedback/model/checkoutFeedbackGiven";
 import { CHECKOUT_ITEM_KEPT } from "../../../../domain/checkoutItem/model/checkoutItemKept";
@@ -16,15 +15,13 @@ const isCheckoutStarted = (event) => event.name === CHECKOUT_STARTED;
 const isCheckoutSubmitted = (event) => event.name === CHECKOUT_SUBMITTED;
 const isCheckoutFeedbackGiven = (event) => event.name === CHECKOUT_FEEDBACK_GIVEN;
 const isCheckoutBookingExpired = (event) => event.name === CHECKOUT_BOOKING_EXPIRED;
-const isCheckoutBookingBooked = (event) => event.name === CHECKOUT_BOOKING_BOOKED;
 const shouldInvalidate = (event) => isCheckoutItemKept(event) ||
     isCheckoutItemReplaced(event) ||
     isCheckoutItemReturned(event) ||
     isCheckoutStarted(event) ||
     isCheckoutSubmitted(event) ||
     isCheckoutFeedbackGiven(event) ||
-    isCheckoutBookingExpired(event) ||
-    isCheckoutBookingBooked(event);
+    isCheckoutBookingExpired(event);
 const useViewFirstAvailableCheckoutByCustomerId = ({ customerId }) => useQuery({
     query: viewFirstAvailableCheckoutByCustomerId({ customerId }),
     contextId: MESSAGING_CONTEXT_ID,

package/dist/infrastructure/projection/checkoutBooking/httpCheckoutBookingByIdView.js

@@ -1,9 +1,10 @@
-const httpCheckoutBookingByIdView = ({ httpPost }) => async ({ checkoutBookingId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/view-checkout-booking-by-id",
-        body: { checkoutBookingId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : (await response.json()).result;
-};
+const httpCheckoutBookingByIdView = ({ httpPost }) => async ({ checkoutBookingId, signal }) => await httpPost({
+    endpoint: "/view-checkout-booking-by-id",
+    body: { checkoutBookingId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => response.result,
+    },
+});
 export { httpCheckoutBookingByIdView };

package/dist/infrastructure/projection/checkoutFeedback/httpCheckoutFeedbackByCheckoutIdView.d.ts

@@ -0,0 +1,12 @@
+import { CheckoutFeedbackByCheckoutIdView } from "../../../projection/checkoutFeedback/viewCheckoutFeedbackByCheckoutId";
+import { HttpPostFunction } from "../../delivery/http/httpClient";
+interface HttpCheckoutFeebackByCheckoutIdView extends CheckoutFeedbackByCheckoutIdView {
+}
+interface HttpCheckoutFeebackByCheckoutIdViewFunctionArgs {
+    readonly httpPost: HttpPostFunction;
+}
+interface HttpCheckoutFeebackByCheckoutIdViewFunction {
+    (args: HttpCheckoutFeebackByCheckoutIdViewFunctionArgs): HttpCheckoutFeebackByCheckoutIdView;
+}
+declare const httpCheckoutFeebackByCheckoutIdView: HttpCheckoutFeebackByCheckoutIdViewFunction;
+export { httpCheckoutFeebackByCheckoutIdView };

package/dist/infrastructure/projection/checkoutFeedback/httpCheckoutFeedbackByCheckoutIdView.js

@@ -0,0 +1,9 @@
+const httpCheckoutFeebackByCheckoutIdView = ({ httpPost }) => async ({ checkoutId, signal }) => {
+    const response = await httpPost({
+        endpoint: "/view-checkout-feedback-by-checkout-id",
+        body: { checkoutId },
+        signal,
+    });
+    return !response.ok || response.status === 404 ? null : (await response.json()).result;
+};
+export { httpCheckoutFeebackByCheckoutIdView };

package/dist/infrastructure/projection/checkoutItem/httpCheckoutItemByIdView.js

@@ -1,9 +1,10 @@
-const httpCheckoutItemByIdView = ({ httpPost }) => async ({ checkoutItemId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/view-checkout-item-by-id",
-        body: { checkoutItemId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : (await response.json()).result;
-};
+const httpCheckoutItemByIdView = ({ httpPost }) => async ({ checkoutItemId, signal }) => await httpPost({
+    endpoint: "/view-checkout-item-by-id",
+    body: { checkoutItemId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => response.result,
+    },
+});
 export { httpCheckoutItemByIdView };

package/dist/infrastructure/projection/checkoutQuestion/httpCheckoutQuestionsByCheckoutIdView.js

@@ -1,9 +1,10 @@
-const httpCheckoutQuestionsByCheckoutIdView = ({ httpPost }) => async ({ checkoutId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/list-checkout-questions-by-checkout-id",
-        body: { checkoutId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : (await response.json()).result;
-};
+const httpCheckoutQuestionsByCheckoutIdView = ({ httpPost }) => async ({ checkoutId, signal }) => await httpPost({
+    endpoint: "/list-checkout-questions-by-checkout-id",
+    body: { checkoutId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => response.result,
+    },
+});
 export { httpCheckoutQuestionsByCheckoutIdView };

package/dist/infrastructure/projection/payment/httpPaymentFlowPayloadByCheckoutIdView.js

@@ -1,9 +1,10 @@
-const httpPaymentFlowPayloadByCheckoutIdView = ({ httpPost }) => async ({ checkoutId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/view-payment-flow-payload-by-checkout-id",
-        body: { checkoutId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : (await response.json()).result;
-};
+const httpPaymentFlowPayloadByCheckoutIdView = ({ httpPost }) => async ({ checkoutId, signal }) => await httpPost({
+    endpoint: "/view-payment-flow-payload-by-checkout-id",
+    body: { checkoutId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => response.result,
+    },
+});
 export { httpPaymentFlowPayloadByCheckoutIdView };

package/dist/infrastructure/projection/pricing/httpPricingByCheckoutIdView.js

@@ -1,9 +1,10 @@
-const httpPricingByCheckoutIdView = ({ httpPost }) => async ({ checkoutId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/view-pricing-by-checkout-id",
-        body: { checkoutId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : (await response.json()).result;
-};
+const httpPricingByCheckoutIdView = ({ httpPost }) => async ({ checkoutId, signal }) => await httpPost({
+    endpoint: "/view-pricing-by-checkout-id",
+    body: { checkoutId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => response.result,
+    },
+});
 export { httpPricingByCheckoutIdView };

package/dist/infrastructure/projection/returnQuestion/httpReturnQuestionsByCheckoutItemIdView.js

@@ -1,9 +1,10 @@
-const httpReturnQuestionsByCheckoutItemIdView = ({ httpPost }) => async ({ checkoutItemId, signal }) => {
-    const response = await httpPost({
-        endpoint: "/list-return-questions-by-checkout-item-id",
-        body: { checkoutItemId },
-        signal,
-    });
-    return !response.ok || response.status === 404 ? null : (await response.json()).result;
-};
+const httpReturnQuestionsByCheckoutItemIdView = ({ httpPost }) => async ({ checkoutItemId, signal }) => await httpPost({
+    endpoint: "/list-return-questions-by-checkout-item-id",
+    body: { checkoutItemId },
+    signal,
+    result: {
+        error: null,
+        success: (response) => response.result,
+    },
+});
 export { httpReturnQuestionsByCheckoutItemIdView };

package/dist/infrastructure/projection/uiSetting/react/useShouldIntroBeShown.d.ts

@@ -0,0 +1,6 @@
+import { QueryStatus } from "@lookiero/messaging-react";
+interface UseShouldIntroBeShownFunction {
+    (): [boolean, QueryStatus];
+}
+declare const useShouldIntroBeShown: UseShouldIntroBeShownFunction;
+export { useShouldIntroBeShown };

package/dist/infrastructure/projection/uiSetting/react/useShouldIntroBeShown.js

@@ -0,0 +1,7 @@
+import { useViewIntroShownCount } from "./useViewIntroShownCount";
+const MAX_INTRO_SHOWN_COUNT = 2;
+const useShouldIntroBeShown = () => {
+    const [introShownCount, introShownCountStatus] = useViewIntroShownCount();
+    return [introShownCount < MAX_INTRO_SHOWN_COUNT, introShownCountStatus];
+};
+export { useShouldIntroBeShown };

package/dist/infrastructure/projection/uiSetting/react/useViewIntroShownCount.d.ts

@@ -0,0 +1,6 @@
+import { QueryStatus } from "@lookiero/messaging-react";
+interface UseViewIntroShownCountFunction {
+    (): [number, QueryStatus];
+}
+declare const useViewIntroShownCount: UseViewIntroShownCountFunction;
+export { useViewIntroShownCount };