@lookiero/checkout 0.1.1

package/dist/infrastructure/delivery/_mock/checkout.mock.js

@@ -0,0 +1,45 @@
+import { v4 as uuid } from "uuid";
+import { CheckoutStatus, Currency, MediaPerspective, } from "../../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+const checkoutItem = ({ status }) => ({
+    id: uuid(),
+    status,
+    productVariant: {
+        id: uuid(),
+        media: [
+            {
+                id: uuid(),
+                url: "https://cdn-catalog-back-prod.envs.lookiero.tech/d2/65/d2655b80-7745-4537-bb17-eb38f960a8de.jpg",
+                perspective: MediaPerspective.FRONT,
+            },
+        ],
+        brand: "CKS",
+        name: "Sari Tshirt lines",
+        price: {
+            amount: 3999,
+            currency: Currency.EUR,
+        },
+        size: {
+            id: uuid(),
+            lookiero: "M",
+            uk: "M",
+            it: "M",
+            europe: "M",
+            unique: false,
+        },
+        color: {
+            id: uuid(),
+            label: "black_C2",
+        },
+    },
+});
+const checkoutWithItems = ({ items }) => ({
+    id: uuid(),
+    status: CheckoutStatus.STARTED,
+    customerId: uuid(),
+    boxId: uuid(),
+    bookingId: uuid(),
+    expiresOn: new Date("2022-09-20"),
+    items,
+});
+const startedCheckoutWithItems = ({ status }) => checkoutWithItems({ items: status.map((status) => checkoutItem({ status })) });
+export { startedCheckoutWithItems };

package/dist/infrastructure/delivery/bootstrap.d.ts

@@ -0,0 +1,10 @@
+import { BuildBootstrapFunctionReturn } from "@lookiero/messaging-react";
+interface BootstrapFunctionArgs {
+    readonly getAuthToken: () => string;
+    readonly apiUrl: string;
+}
+interface BootstrapFunction {
+    (args: BootstrapFunctionArgs): BuildBootstrapFunctionReturn;
+}
+declare const bootstrap: BootstrapFunction;
+export { bootstrap };

package/dist/infrastructure/delivery/bootstrap.js

@@ -0,0 +1,21 @@
+import { bootstrap as messagingBootstrap } from "@lookiero/messaging-react";
+import { viewFirstAvailableCheckoutByCustomerIdHandler, VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID, } from "../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+import { viewIsCheckoutAccessibleByCustomerIdHandler, VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID, } from "../../projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+import { viewIsCheckoutEnabledByCustomerIdHandler, VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID, } from "../../projection/checkout/viewIsCheckoutEnabledByCustomerId";
+import { httpFirstAvailableCheckoutByCustomerIdView } from "../projection/httpFirstAvailableCheckoutByCustomerIdView";
+import { httpIsCheckoutEnabledByCustomerIdView } from "../projection/httpIsCheckoutEnabledByCustomerIdView";
+import { fetchHttpGet, fetchHttpPost } from "./http/fetchHttpClient";
+const bootstrap = ({ apiUrl, getAuthToken }) => {
+    const httpGet = fetchHttpGet({ apiUrl, getAuthToken });
+    const httpPost = fetchHttpPost({ apiUrl, getAuthToken });
+    return messagingBootstrap({ id: "Checkout" })
+        .query(VIEW_FIRST_AVAILABLE_CHECKOUT_BY_CUSTOMER_ID, viewFirstAvailableCheckoutByCustomerIdHandler, {
+        view: httpFirstAvailableCheckoutByCustomerIdView({ httpPost }),
+    })
+        .query(VIEW_IS_CHECKOUT_ENABLED_BY_CUSTOMER_ID, viewIsCheckoutEnabledByCustomerIdHandler, {
+        view: httpIsCheckoutEnabledByCustomerIdView({ httpGet }),
+    })
+        .query(VIEW_IS_CHECKOUT_ACCESSIBLE_BY_CUSTOMER_ID, viewIsCheckoutAccessibleByCustomerIdHandler, {})
+        .build();
+};
+export { bootstrap };

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

@@ -0,0 +1,14 @@
+import { HttpGetFunction, HttpPostFunction } from "./httpClient";
+interface FetchHttpFunctionArgs {
+    readonly apiUrl: string;
+    readonly getAuthToken: () => string;
+}
+interface FetchHttpPostFunction {
+    (args: FetchHttpFunctionArgs): HttpPostFunction;
+}
+interface FetchHttpGetFunction {
+    (args: FetchHttpFunctionArgs): HttpGetFunction;
+}
+declare const fetchHttpPost: FetchHttpPostFunction;
+declare const fetchHttpGet: FetchHttpGetFunction;
+export { fetchHttpGet, fetchHttpPost };

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

@@ -0,0 +1,18 @@
+const fetchHttpPost = ({ apiUrl, getAuthToken }) => async ({ endpoint, body }) => fetch(`${apiUrl}${endpoint}`, {
+    method: "POST",
+    headers: {
+        ["Content-Type"]: "application/json",
+        authorization: `Bearer ${getAuthToken()}`,
+    },
+    body: JSON.stringify(body),
+});
+const fetchHttpGet = ({ apiUrl, getAuthToken }) => async ({ endpoint }) => fetch(`${apiUrl}${endpoint}`, {
+    method: "GET",
+    credentials: "include",
+    mode: "no-cors",
+    headers: {
+        authorization: `Bearer ${getAuthToken()}`,
+    },
+    referrer: "",
+});
+export { fetchHttpGet, fetchHttpPost };

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

@@ -0,0 +1,14 @@
+interface HttpGetFunctionArgs {
+    readonly endpoint: string;
+}
+interface HttpGetFunction {
+    (args: HttpGetFunctionArgs): Promise<Response>;
+}
+interface HttpPostFunctionArgs {
+    readonly endpoint: string;
+    readonly body: Record<string, unknown>;
+}
+interface HttpPostFunction {
+    (args: HttpPostFunctionArgs): Promise<Response>;
+}
+export { HttpGetFunction, HttpPostFunction };

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

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

package/dist/infrastructure/domain/checkoutBooking/model/httpCheckoutBookings.d.ts

@@ -0,0 +1,10 @@
+import { CheckoutBookingsSaveFunction } from "../../../../domain/checkoutBooking/model/checkoutBookings";
+import { HttpPostFunction } from "../../../delivery/http/httpClient";
+interface HttpCheckoutBookingsSaveFunctionArgs {
+    readonly httpPost: HttpPostFunction;
+}
+interface HttpCheckoutBookingsSaveFunction {
+    (args: HttpCheckoutBookingsSaveFunctionArgs): CheckoutBookingsSaveFunction;
+}
+export declare const saveCheckoutBooking: HttpCheckoutBookingsSaveFunction;
+export {};

package/dist/infrastructure/domain/checkoutBooking/model/httpCheckoutBookings.js

@@ -0,0 +1,19 @@
+export const saveCheckoutBooking = ({ httpPost }) => async ({ checkoutId, checkoutItemId, checkoutBookingId }) => {
+    try {
+        const response = await httpPost({
+            endpoint: "/book-size-replaceable-product-variants-for-checkout-item",
+            body: {
+                checkout_id: checkoutId,
+                checkout_item_id: checkoutItemId,
+                checkout_booking_id: checkoutBookingId,
+            },
+        });
+        if (!response.ok) {
+            throw new Error("Book size replaceable product variants for checkout item");
+        }
+        return;
+    }
+    catch (ignored) {
+        throw new Error("Could not fetch BookSizeReplaceableProductVariantsForCheckoutItem");
+    }
+};

package/dist/infrastructure/domain/react/useBookSizeReplaceableProductVariantsForCheckoutItem.d.ts

@@ -0,0 +1,15 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+interface UseBookSizeReplaceableProductVariantsForCheckoutItem {
+    readonly book: () => Promise<void>;
+    readonly status: CommandStatus;
+}
+interface UseBookSizeReplaceableProductVariantsForCheckoutItemFunctionArgs {
+    readonly checkoutId: string;
+    readonly checkoutItemId: string;
+    readonly checkoutBookingId: string;
+}
+interface UseBookSizeReplaceableProductVariantsForCheckoutItemFunction {
+    (args: UseBookSizeReplaceableProductVariantsForCheckoutItemFunctionArgs): UseBookSizeReplaceableProductVariantsForCheckoutItem;
+}
+export declare const useBookSizeReplaceableProductVariantsForCheckoutItem: UseBookSizeReplaceableProductVariantsForCheckoutItemFunction;
+export {};

package/dist/infrastructure/domain/react/useBookSizeReplaceableProductVariantsForCheckoutItem.js

@@ -0,0 +1,17 @@
+import { useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import { v4 as uuid } from "uuid";
+import { bookSizeReplaceableProductVariantsForCheckoutItem } from "../../../domain/checkoutBooking/command/bookSizeReplaceableProductVariantsForCheckoutItem";
+export const useBookSizeReplaceableProductVariantsForCheckoutItem = ({ checkoutId, checkoutItemId, checkoutBookingId }) => {
+    const [commandBus, status] = useCommand();
+    const book = useCallback(async () => await commandBus(bookSizeReplaceableProductVariantsForCheckoutItem({
+        aggregateId: uuid(),
+        checkoutId,
+        checkoutItemId,
+        checkoutBookingId,
+    })), [checkoutBookingId, checkoutId, checkoutItemId, commandBus]);
+    return {
+        book,
+        status,
+    };
+};

package/dist/infrastructure/domain/react/useUpdateUiSetting.d.ts

@@ -0,0 +1,17 @@
+import { CommandStatus } from "@lookiero/messaging-react";
+interface UpdateFunctionArgs {
+    readonly key: string;
+    readonly value: unknown;
+}
+interface UpdateFunction {
+    (args: UpdateFunctionArgs): Promise<void>;
+}
+interface UseUpdateUiSetting {
+    readonly update: UpdateFunction;
+    readonly status: CommandStatus;
+}
+interface UseUpdateUiSettingFunction {
+    (): UseUpdateUiSetting;
+}
+export declare const useUpdateUiSetting: UseUpdateUiSettingFunction;
+export {};

package/dist/infrastructure/domain/react/useUpdateUiSetting.js

@@ -0,0 +1,16 @@
+import { useCommand } from "@lookiero/messaging-react";
+import { useCallback } from "react";
+import { v4 as uuid } from "uuid";
+import { updateUiSetting } from "../../../domain/uiSetting/command/updateUiSetting";
+export const useUpdateUiSetting = () => {
+    const [commandBus, status] = useCommand();
+    const update = useCallback(async ({ key, value }) => await commandBus(updateUiSetting({
+        aggregateId: uuid(),
+        key,
+        value,
+    })), [commandBus]);
+    return {
+        update,
+        status,
+    };
+};

package/dist/infrastructure/domain/uiSetting/model/storageUiSettings.d.ts

@@ -0,0 +1,18 @@
+import { UiSettingGetFunction, UiSettingSaveFunction } from "../../../../domain/uiSetting/model/uiSettings";
+import { ReadFunction, WriteFunction } from "../../../persistence/storage";
+import { UiSettingDto } from "../../../persistence/uiSettingData";
+interface StorageUiSettingsGetFunctionArgs {
+    readonly read: ReadFunction<UiSettingDto>;
+}
+interface StorageUiSettingsGetFunction {
+    (args: StorageUiSettingsGetFunctionArgs): UiSettingGetFunction;
+}
+export declare const getUiSetting: StorageUiSettingsGetFunction;
+interface StorageUiSettingsSaveFunctionArgs {
+    readonly write: WriteFunction<UiSettingDto>;
+}
+interface StorageUiSettingsSaveFunction {
+    (args: StorageUiSettingsSaveFunctionArgs): UiSettingSaveFunction;
+}
+export declare const saveUiSetting: StorageUiSettingsSaveFunction;
+export {};

package/dist/infrastructure/domain/uiSetting/model/storageUiSettings.js

@@ -0,0 +1,19 @@
+const toDomain = (uiSettingDto) => ({
+    aggregateId: uiSettingDto.id,
+    key: uiSettingDto.key,
+    value: uiSettingDto.value,
+    domainEvents: [],
+});
+const fromDomain = (uiSetting) => ({
+    id: uiSetting.aggregateId,
+    key: uiSetting.key,
+    value: uiSetting.value,
+});
+export const getUiSetting = ({ read }) => async (uiSettingKey) => {
+    const uiSettingDto = await read(uiSettingKey);
+    if (!uiSettingDto) {
+        throw new Error(`UiSetting not found: ${uiSettingKey}`);
+    }
+    return toDomain(uiSettingDto);
+};
+export const saveUiSetting = ({ write }) => async (aggregateRoot) => await write(aggregateRoot.key, fromDomain(aggregateRoot));

package/dist/infrastructure/persistence/asyncStorageStorage.d.ts

@@ -0,0 +1,4 @@
+import { ReadFunction, WriteFunction } from "./storage";
+import { UiSettingDto } from "./uiSettingData";
+export declare const read: ReadFunction<UiSettingDto>;
+export declare const write: WriteFunction<UiSettingDto>;

package/dist/infrastructure/persistence/asyncStorageStorage.js

@@ -0,0 +1,6 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+export const read = async (key) => {
+    const value = await AsyncStorage.getItem(key);
+    return value ? JSON.parse(value) : undefined;
+};
+export const write = async (key, value) => AsyncStorage.setItem(key, JSON.stringify(value));

package/dist/infrastructure/persistence/storage.d.ts

@@ -0,0 +1,6 @@
+export interface ReadFunction<T> {
+    (key: string): Promise<T | undefined>;
+}
+export interface WriteFunction<T> {
+    (key: string, value: T): Promise<void>;
+}

package/dist/infrastructure/persistence/storage.js

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

package/dist/infrastructure/persistence/uiSettingData.d.ts

@@ -0,0 +1,5 @@
+export interface UiSettingDto {
+    readonly id: string;
+    readonly key: string;
+    readonly value: unknown;
+}

package/dist/infrastructure/persistence/uiSettingData.js

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

package/dist/infrastructure/projection/httpBookedSizeReplaceableProductVariantsForCheckoutItemView.d.ts

@@ -0,0 +1,36 @@
+import { BookedSizeReplaceableProductVariantsProjection, BookedSizeReplaceableProductVariantsForCheckoutItemView } from "../../projection/bookedSizeReplaceableProductVariants/viewBookedSizeReplaceableProductVariantsForCheckoutItem";
+import { HttpPostFunction } from "../delivery/http/httpClient";
+interface SizeFormatDto {
+    readonly size: string;
+    readonly format: string;
+    readonly length?: string;
+}
+interface SizeDto {
+    readonly id: string;
+    readonly europe: SizeFormatDto;
+    readonly it: SizeFormatDto;
+    readonly lookiero: SizeFormatDto;
+    readonly uk: SizeFormatDto;
+}
+interface ProductVariantDto {
+    readonly id: string;
+    readonly size: SizeDto;
+}
+interface BookedSizeReplaceableProductVariantsDto {
+    readonly booking: string | null;
+    readonly product_variants: ProductVariantDto[];
+}
+interface ToBookedSizeReplaceableProductVariantsFunction {
+    (bookedSizeReplaceableProductVariants: BookedSizeReplaceableProductVariantsDto): BookedSizeReplaceableProductVariantsProjection;
+}
+declare const toBookedSizeReplaceableProductVariants: ToBookedSizeReplaceableProductVariantsFunction;
+interface HttpBookedSizeReplaceableProductVariantsForCheckoutItemView extends BookedSizeReplaceableProductVariantsForCheckoutItemView {
+}
+interface HttpBookedSizeReplaceableProductVariantsForCheckoutItemViewFunctionArgs {
+    readonly httpPost: HttpPostFunction;
+}
+interface HttpBookedSizeReplaceableProductVariantsForCheckoutItemViewFunction {
+    (args: HttpBookedSizeReplaceableProductVariantsForCheckoutItemViewFunctionArgs): HttpBookedSizeReplaceableProductVariantsForCheckoutItemView;
+}
+declare const httpBookedSizeReplaceableProductVariantsForCheckoutItemView: HttpBookedSizeReplaceableProductVariantsForCheckoutItemViewFunction;
+export { BookedSizeReplaceableProductVariantsDto, toBookedSizeReplaceableProductVariants, httpBookedSizeReplaceableProductVariantsForCheckoutItemView, };

package/dist/infrastructure/projection/httpBookedSizeReplaceableProductVariantsForCheckoutItemView.js

@@ -0,0 +1,30 @@
+const toSize = (size) => ({
+    id: size.id,
+    europe: size.europe,
+    it: size.it,
+    lookiero: size.lookiero,
+    uk: size.uk,
+});
+const toProductVariant = (productVariant) => ({
+    id: productVariant.id,
+    size: toSize(productVariant.size),
+});
+const toBookedSizeReplaceableProductVariants = (bookedSizeReplaceableProductVariants) => ({
+    booking: bookedSizeReplaceableProductVariants.booking,
+    productVariants: bookedSizeReplaceableProductVariants.product_variants.map(toProductVariant),
+});
+const httpBookedSizeReplaceableProductVariantsForCheckoutItemView = ({ httpPost }) => async ({ checkoutItemId }) => {
+    try {
+        const response = await httpPost({
+            endpoint: "/view-booked-size-replaceable-product-variants-for-checkout-item",
+            body: { checkout_item_id: checkoutItemId },
+        });
+        return response.status === 404
+            ? undefined
+            : toBookedSizeReplaceableProductVariants((await response.json()).result);
+    }
+    catch (ignored) {
+        throw new Error("Could not fetch BookedSizeReplaceableProductVariantsForCheckoutItem");
+    }
+};
+export { toBookedSizeReplaceableProductVariants, httpBookedSizeReplaceableProductVariantsForCheckoutItemView, };

package/dist/infrastructure/projection/httpFirstAvailableCheckoutByCustomerIdView.d.ts

@@ -0,0 +1,60 @@
+import { CheckoutItemStatus, CheckoutProjection, CheckoutStatus, Currency, FirstAvailableCheckoutByCustomerIdView, MediaPerspective } from "../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+import { HttpPostFunction } from "../delivery/http/httpClient";
+interface CheckoutDto {
+    readonly id: string;
+    readonly customer_id: string;
+    readonly box_id: string;
+    readonly booking_id: string;
+    readonly status: CheckoutStatus;
+    readonly expires_on: string;
+    readonly items: {
+        readonly id: string;
+        readonly status: CheckoutItemStatus;
+        readonly product_variant: {
+            readonly id: string;
+            readonly media: {
+                readonly id: string;
+                readonly url: string;
+                readonly perspective: MediaPerspective;
+            }[];
+            readonly brand: string;
+            readonly name: string;
+            readonly price: {
+                readonly amount: number;
+                readonly currency: Currency;
+                readonly discounted_price?: {
+                    readonly amount: number;
+                    readonly percentage: number;
+                };
+            };
+            readonly size: {
+                readonly id: string;
+                readonly lookiero: string;
+                readonly uk: string;
+                readonly it: string;
+                readonly europe: string;
+                readonly unique: boolean;
+                readonly visual_order?: number;
+            };
+            readonly color: {
+                readonly id: string;
+                readonly label: string;
+            };
+        };
+        readonly replaced_for?: string;
+    }[];
+}
+interface ToCheckoutProjectionFunction {
+    (checkoutDto: CheckoutDto): CheckoutProjection;
+}
+declare const toCheckoutProjection: ToCheckoutProjectionFunction;
+interface HttpFirstAvailableCheckoutByCustomerIdView extends FirstAvailableCheckoutByCustomerIdView {
+}
+interface HttpFirstAvailableCheckoutByCustomerIdViewFunctionArgs {
+    readonly httpPost: HttpPostFunction;
+}
+interface HttpFirstAvailableCheckoutByCustomerIdViewFunction {
+    (args: HttpFirstAvailableCheckoutByCustomerIdViewFunctionArgs): HttpFirstAvailableCheckoutByCustomerIdView;
+}
+declare const httpFirstAvailableCheckoutByCustomerIdView: HttpFirstAvailableCheckoutByCustomerIdViewFunction;
+export { CheckoutDto, toCheckoutProjection, httpFirstAvailableCheckoutByCustomerIdView };

package/dist/infrastructure/projection/httpFirstAvailableCheckoutByCustomerIdView.js

@@ -0,0 +1,54 @@
+const toCheckoutProjection = (checkoutDto) => ({
+    id: checkoutDto.id,
+    customerId: checkoutDto.customer_id,
+    boxId: checkoutDto.box_id,
+    bookingId: checkoutDto.booking_id,
+    status: checkoutDto.status,
+    expiresOn: new Date(checkoutDto.expires_on),
+    items: checkoutDto.items.map((item) => ({
+        id: item.id,
+        status: item.status,
+        replacedFor: item.replaced_for,
+        productVariant: {
+            id: item.product_variant.id,
+            media: item.product_variant.media.map((media) => ({
+                id: media.id,
+                url: media.url,
+                perspective: media.perspective,
+            })),
+            brand: item.product_variant.brand,
+            name: item.product_variant.name,
+            price: {
+                amount: item.product_variant.price.amount,
+                currency: item.product_variant.price.currency,
+                discountedPrice: item.product_variant.price.discounted_price
+                    ? {
+                        amount: item.product_variant.price.discounted_price.amount,
+                        percentage: item.product_variant.price.discounted_price.percentage,
+                    }
+                    : undefined,
+            },
+            size: {
+                id: item.product_variant.size.id,
+                lookiero: item.product_variant.size.lookiero,
+                uk: item.product_variant.size.uk,
+                it: item.product_variant.size.it,
+                europe: item.product_variant.size.europe,
+                unique: item.product_variant.size.unique,
+                visualOrder: item.product_variant.size.visual_order,
+            },
+            color: {
+                id: item.product_variant.color.id,
+                label: item.product_variant.color.label,
+            },
+        },
+    })),
+});
+const httpFirstAvailableCheckoutByCustomerIdView = ({ httpPost }) => async ({ customerId }) => {
+    const response = await httpPost({
+        endpoint: "/view-first-available-checkout-by-customer-id",
+        body: { customer_id: customerId },
+    });
+    return !response.ok || response.status === 404 ? undefined : toCheckoutProjection((await response.json()).result);
+};
+export { toCheckoutProjection, httpFirstAvailableCheckoutByCustomerIdView };

package/dist/infrastructure/projection/httpIsCheckoutEnabledByCustomerIdView.d.ts

@@ -0,0 +1,12 @@
+import { IsCheckoutEnabledByCustomerIdView } from "../../projection/checkout/viewIsCheckoutEnabledByCustomerId";
+import { HttpGetFunction } from "../delivery/http/httpClient";
+interface HttpIsCheckoutEnabledByCustomerIdView extends IsCheckoutEnabledByCustomerIdView {
+}
+interface HttpIsCheckoutEnabledByCustomerIdViewFunctionArgs {
+    readonly httpGet: HttpGetFunction;
+}
+interface HttpIsCheckoutEnabledByCustomerIdViewFunction {
+    (args: HttpIsCheckoutEnabledByCustomerIdViewFunctionArgs): HttpIsCheckoutEnabledByCustomerIdView;
+}
+declare const httpIsCheckoutEnabledByCustomerIdView: HttpIsCheckoutEnabledByCustomerIdViewFunction;
+export { httpIsCheckoutEnabledByCustomerIdView };

package/dist/infrastructure/projection/httpIsCheckoutEnabledByCustomerIdView.js

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

package/dist/infrastructure/projection/react/useViewBookedSizeReplaceableProductVariantsForCheckoutItem.d.ts

@@ -0,0 +1,10 @@
+import { UseQueryFunctionResult } from "@lookiero/messaging-react";
+import { BookedSizeReplaceableProductVariantsProjection } from "../../../projection/bookedSizeReplaceableProductVariants/viewBookedSizeReplaceableProductVariantsForCheckoutItem";
+interface UseViewBookedSizeReplaceableProductVariantsForCheckoutItemFunctionArgs {
+    readonly checkoutItemId: string;
+}
+interface UseViewBookedSizeReplaceableProductVariantsForCheckoutItemFunction {
+    (args: UseViewBookedSizeReplaceableProductVariantsForCheckoutItemFunctionArgs): UseQueryFunctionResult<BookedSizeReplaceableProductVariantsProjection>;
+}
+declare const useViewBookedSizeReplaceableProductVariantsForCheckoutItem: UseViewBookedSizeReplaceableProductVariantsForCheckoutItemFunction;
+export { useViewBookedSizeReplaceableProductVariantsForCheckoutItem };

package/dist/infrastructure/projection/react/useViewBookedSizeReplaceableProductVariantsForCheckoutItem.js

@@ -0,0 +1,8 @@
+import { useQuery } from "@lookiero/messaging-react";
+import { viewBookedSizeReplaceableProductVariantsForCheckoutItem, } from "../../../projection/bookedSizeReplaceableProductVariants/viewBookedSizeReplaceableProductVariantsForCheckoutItem";
+const useViewBookedSizeReplaceableProductVariantsForCheckoutItem = ({ checkoutItemId }) => useQuery({
+    query: viewBookedSizeReplaceableProductVariantsForCheckoutItem({ checkoutItemId }),
+    contextId: "Checkout",
+    options: { staleTime: Infinity },
+});
+export { useViewBookedSizeReplaceableProductVariantsForCheckoutItem };

package/dist/infrastructure/projection/react/useViewFirstAvailableCheckoutByCustomerId.d.ts

@@ -0,0 +1,10 @@
+import { UseQueryFunctionResult } from "@lookiero/messaging-react";
+import { CheckoutProjection } from "../../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+interface UseViewFirstAvailableCheckoutByCustomerIdFunctionArgs {
+    readonly customerId: string;
+}
+interface UseViewFirstAvailableCheckoutByCustomerIdFunction {
+    (args: UseViewFirstAvailableCheckoutByCustomerIdFunctionArgs): UseQueryFunctionResult<CheckoutProjection>;
+}
+declare const useViewFirstAvailableCheckoutByCustomerId: UseViewFirstAvailableCheckoutByCustomerIdFunction;
+export { useViewFirstAvailableCheckoutByCustomerId };

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

@@ -0,0 +1,8 @@
+import { useQuery } from "@lookiero/messaging-react";
+import { viewFirstAvailableCheckoutByCustomerId, } from "../../../projection/checkout/viewFirstAvailableCheckoutByCustomerId";
+const useViewFirstAvailableCheckoutByCustomerId = ({ customerId }) => useQuery({
+    query: viewFirstAvailableCheckoutByCustomerId({ customerId }),
+    contextId: "Checkout",
+    options: { staleTime: Infinity, retry: false },
+});
+export { useViewFirstAvailableCheckoutByCustomerId };

package/dist/infrastructure/projection/react/useViewIsCheckoutAccessibleByCustomerId.d.ts

@@ -0,0 +1,10 @@
+import { UseQueryFunctionResult } from "@lookiero/messaging-react";
+import { IsCheckoutAccessibleByCustomerIdProjection } from "../../../projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+interface UseViewIsCheckoutAccessibleByCustomerIdFunctionArgs {
+    readonly customerId: string | undefined;
+}
+interface UseViewIsCheckoutAccessibleByCustomerIdFunction {
+    (args: UseViewIsCheckoutAccessibleByCustomerIdFunctionArgs): UseQueryFunctionResult<IsCheckoutAccessibleByCustomerIdProjection>;
+}
+declare const useViewIsCheckoutAccessibleByCustomerId: UseViewIsCheckoutAccessibleByCustomerIdFunction;
+export { useViewIsCheckoutAccessibleByCustomerId };

package/dist/infrastructure/projection/react/useViewIsCheckoutAccessibleByCustomerId.js

@@ -0,0 +1,8 @@
+import { useQuery } from "@lookiero/messaging-react";
+import { viewIsCheckoutAccessibleByCustomerId, } from "../../../projection/checkout/viewIsCheckoutAccessibleByCustomerId";
+const useViewIsCheckoutAccessibleByCustomerId = ({ customerId }) => useQuery({
+    query: viewIsCheckoutAccessibleByCustomerId({ customerId }),
+    contextId: "Checkout",
+    options: { staleTime: Infinity },
+});
+export { useViewIsCheckoutAccessibleByCustomerId };

package/dist/infrastructure/projection/react/useViewIsCheckoutIntroVisible.d.ts

@@ -0,0 +1,3 @@
+import { QueryStatus } from "@lookiero/messaging-react";
+declare const useViewIsCheckoutIntroVisible: () => (boolean | QueryStatus)[];
+export { useViewIsCheckoutIntroVisible };

package/dist/infrastructure/projection/react/useViewIsCheckoutIntroVisible.js

@@ -0,0 +1,3 @@
+import { QueryStatus } from "@lookiero/messaging-react";
+const useViewIsCheckoutIntroVisible = () => [false, QueryStatus.SUCCESS];
+export { useViewIsCheckoutIntroVisible };

package/dist/infrastructure/projection/react/useViewUiSettingByKey.d.ts

@@ -0,0 +1,10 @@
+import { UseQueryFunctionResult } from "@lookiero/messaging-react";
+import { UiSettingProjection } from "../../../projection/uiSetting/viewUiSettingByKey";
+interface UseViewUiSettingByKeyFunctionArgs {
+    readonly uiSettingKey: string;
+}
+interface UseViewUiSettingByKeyFunction {
+    (args: UseViewUiSettingByKeyFunctionArgs): UseQueryFunctionResult<UiSettingProjection>;
+}
+export declare const useViewUiSettingByKey: UseViewUiSettingByKeyFunction;
+export {};

package/dist/infrastructure/projection/react/useViewUiSettingByKey.js

@@ -0,0 +1,8 @@
+import { useQuery } from "@lookiero/messaging-react";
+import { uiSettingUpdated } from "../../../domain/uiSetting/model/uiSettingUpdated";
+import { viewUiSettingByKey } from "../../../projection/uiSetting/viewUiSettingByKey";
+export const useViewUiSettingByKey = ({ uiSettingKey }) => useQuery({
+    query: viewUiSettingByKey({ key: uiSettingKey }),
+    invalidation: (event) => event instanceof uiSettingUpdated,
+    options: { staleTime: Infinity },
+});

package/dist/infrastructure/projection/storageUiSettingByKeyView.d.ts

@@ -0,0 +1,13 @@
+import { UiSettingByKeyView } from "../../projection/uiSetting/viewUiSettingByKey";
+import { ReadFunction } from "../persistence/storage";
+import { UiSettingDto } from "../persistence/uiSettingData";
+interface StorageUiSettingByKeyView extends UiSettingByKeyView {
+}
+interface StorageUiSettingByKeyViewFunctionArgs {
+    readonly read: ReadFunction<UiSettingDto>;
+}
+interface StorageUiSettingByKeyViewFunction {
+    (args: StorageUiSettingByKeyViewFunctionArgs): StorageUiSettingByKeyView;
+}
+export declare const storageUiSettingByKeyView: StorageUiSettingByKeyViewFunction;
+export {};