@zenky/storefront-vue 0.9.35 → 0.9.39

package/dist/esm/index.js

@@ -1,9 +1,10 @@
 import { ref, computed, watch, unref, inject } from 'vue';
-import { debounce, isBoolean } from 'lodash-es';
-import { getStore, getAddressSuggestions, getCategoriesTree, getProductsCollections, getApiErrorMessage, getCategoryFeatures, getCategoryFeaturesGroups, getArticles, getArticleCategories, getArticle, getAuthenticationStatus, setAxiosToken, getCustomerProfile, login, requestPasswordResetCode, resetPassword, register, resendConfirmationCode, confirm, getApiErrorCode, getCustomerAddresses, deleteAddress, updateAddress, getCustomerOrders, getOrder, getCustomerPaymentMethods, deleteCustomerPaymentMethod, ImageType, getOffers, getOffer, getProductsPricesRange, getProducts } from '@zenky/api';
-import { defineStore } from 'pinia';
+import { debounce, isBoolean, cloneDeep } from 'lodash-es';
+import { getStore, getAddressSuggestions, getCategoriesTree, Visibility, getProductsCollections, getApiErrorMessage, getCategoryFeatures, getCategoryFeaturesGroups, getArticle, getArticles, getArticleCategories, getAuthenticationStatus, setAxiosToken, getCustomerProfile, login, requestPasswordResetCode, resetPassword, register, resendConfirmationCode, confirm, getApiErrorCode, getCustomerAddresses, deleteAddress, updateAddress, getOrder, getCustomerOrders, getCustomerPaymentMethods, deleteCustomerPaymentMethod, ImageType, getOffer, getOffers, setOrderCheckoutCustomer, getOrderSettings, createOrder, addOrderProductVariant, removeOrderProductVariant, confirmOrder, resendOrderConfirmationCode, setOrderCheckoutDelivery, setOrderCheckoutPayment, getOrderBonusesPaymentPreview, checkoutOrder, getOrderCheckoutTotal, getProductsPricesRange, getProducts, checkCompletedPromotions } from '@zenky/api';
+import { defineStore, storeToRefs } from 'pinia';
 import { useNotification } from '@zenky/ui';
-import { useCustomerLoaded, useCustomerAuthenticated, useCustomerLoggedOut, useOrderPriceRecalculated, useOrderShouldBeReloaded, useOrderPromotionRewardsShouldBeReloaded, useDisplayOrderPromotionRewardSelection, usePromotionsCheckerCompleted, useOrderPromotionsNotFound, useOrderSubmitted } from '@zenky/events';
+import { useCustomerLoaded, useCustomerAuthenticated, useCustomerLoggedOut, useOrderLoaded, useProductQuantityIncreased, useProductQuantityDecreased, usePromotionsCheckerStarted, usePromotionsCheckerCompleted, useDisplayOrderPromotionRewardSelection, useOrderPromotionsNotFound, useOrderPriceRecalculated, useOrderShouldBeReloaded, useOrderPromotionRewardsShouldBeReloaded, useOrderSubmitted } from '@zenky/events';
+import { format } from 'date-fns';
 import Pusher from 'pusher-js';
 
 function useDataDestroyer(destroyer, errorHandler) {
@@ -571,7 +572,7 @@ const useCategoriesStore = defineStore({
             }
             this.loading = true;
             try {
-                this.tree = await getCategoriesTree({ visibility: 'visible', with: 'media' });
+                this.tree = await getCategoriesTree({ visibility: Visibility.Visible, with: 'media' });
                 this.loaded = true;
             }
             catch (e) {
@@ -746,7 +747,7 @@ const useCollectionsStore = defineStore({
             this.loading = true;
             try {
                 this.collections = (await getProductsCollections({
-                    visibility: 'visible',
+                    visibility: Visibility.Visible,
                     order_by: 'name',
                     with: 'media',
                     count: 100,
@@ -1548,6 +1549,970 @@ function useOfferItem(errorHandler) {
     }));
 }
 
+function getUpdatedVariants(currentOrder, order) {
+    var _a, _b;
+    if (!((_a = order === null || order === void 0 ? void 0 : order.variants) === null || _a === void 0 ? void 0 : _a.length)) {
+        return [];
+    }
+    else if (!((_b = currentOrder === null || currentOrder === void 0 ? void 0 : currentOrder.variants) === null || _b === void 0 ? void 0 : _b.length)) {
+        return (order === null || order === void 0 ? void 0 : order.variants) || [];
+    }
+    let current = cloneDeep(currentOrder.variants);
+    let currentVariants = [];
+    const currentlyHasVariants = current && current.length > 0;
+    if (currentlyHasVariants) {
+        currentVariants = current.map((variant) => variant.uuid);
+    }
+    const actualVariantIds = order.variants.map((variant) => variant.uuid);
+    const createdVariantIds = order.variants
+        .filter((variant) => currentVariants.indexOf(variant.uuid) === -1)
+        .map((variant) => variant.uuid);
+    if (currentlyHasVariants) {
+        current = current.filter((variant) => actualVariantIds.indexOf(variant.uuid) !== -1);
+    }
+    if (createdVariantIds.length > 0) {
+        current = current || [];
+        order.variants.filter((variant) => createdVariantIds.indexOf(variant.uuid) !== -1)
+            .forEach((variant) => current.push(variant));
+    }
+    order.variants.forEach((variant) => {
+        const index = current.findIndex((item) => item.uuid === variant.uuid);
+        if (index === -1) {
+            return;
+        }
+        current[index].quantity = variant.quantity;
+        current[index].original_total_price = variant.original_total_price;
+        current[index].total_price = variant.total_price;
+        current[index].discount_difference = variant.discount_difference;
+        current[index].has_discount = variant.has_discount;
+    });
+    return current;
+}
+
+function initializeOrderCustomer(credentialsResolver) {
+    useCustomerAuthenticated().subscribe('order.customer.initialize', async ({ customer }) => {
+        const credentials = credentialsResolver();
+        if (credentials === null) {
+            return;
+        }
+        try {
+            await setOrderCheckoutCustomer(credentials, {
+                phone: {
+                    number: customer.phone.e164,
+                    country: customer.phone.country,
+                },
+            });
+        }
+        catch (e) {
+            console.error('[orders/customer] Unable to attach customer to order.', { e });
+        }
+    });
+}
+
+const useOrderStore = defineStore({
+    id: 'zenky:storefront:order',
+    state: () => ({
+        order: null,
+        token: null,
+        loading: false,
+        inclusions: null,
+        orderSettings: {
+            loaded: false,
+            loading: false,
+            settings: null,
+        },
+    }),
+    getters: {
+        credentials() {
+            if (!this.order || !this.order.id || this.token === null) {
+                return null;
+            }
+            return {
+                id: this.order.id,
+                token: this.token,
+            };
+        },
+        settings() {
+            return this.orderSettings.settings;
+        },
+        settingsLoaded() {
+            return this.orderSettings.loaded;
+        },
+    },
+    actions: {
+        async initialize(storeId, cityId, inclusions) {
+            this.inclusions = inclusions;
+            const storage = getStorage();
+            const orderId = storage.get('order.id');
+            const orderToken = storage.get('order.token');
+            initializeOrderCustomer(() => this.credentials);
+            this.loading = true;
+            if (orderId && orderToken) {
+                return this.load(storeId, cityId, orderId, orderToken);
+            }
+            return this.create(storeId, cityId);
+        },
+        async load(storeId, cityId, orderId, token) {
+            var _a, _b, _c;
+            const { item, load } = useOrderItem();
+            await load({ id: orderId, token }, this.inclusions !== null ? { with: this.inclusions.order } : {});
+            if (((_c = (_b = (_a = item.value) === null || _a === void 0 ? void 0 : _a.current_status) === null || _b === void 0 ? void 0 : _b.status) === null || _c === void 0 ? void 0 : _c.kind.id) === 'pending') {
+                this.order = item.value;
+                this.token = item.value.token;
+                this.loading = false;
+                useOrderLoaded().publish(this.order);
+                await this.loadSettings();
+                return true;
+            }
+            return this.create(storeId, cityId);
+        },
+        async loadSettings() {
+            if (this.orderSettings.loading) {
+                return;
+            }
+            else if (!this.credentials || !this.order || !this.order.city_id) {
+                return;
+            }
+            this.orderSettings.loading = true;
+            try {
+                this.orderSettings.settings = await getOrderSettings(this.credentials, this.order.city_id);
+            }
+            catch (e) {
+                console.error('[storefront/order] Unable to load order settings.', { e });
+            }
+            finally {
+                this.orderSettings.loading = false;
+                this.orderSettings.loaded = true;
+            }
+        },
+        async create(storeId, cityId) {
+            try {
+                const order = await createOrder({ city_id: cityId });
+                const storage = getStorage();
+                storage.set('order.id', order.id);
+                storage.set('order.token', order.token);
+                return await this.load(storeId, cityId, order.id, order.token);
+            }
+            catch (e) {
+                useNotification('error', 'Ошибка инициализации заказа', 'Не удалось инициализировать заказ. Обновите страницу.');
+            }
+            return false;
+        },
+        reset() {
+            const storage = getStorage();
+            storage.delete('order.id');
+            storage.delete('order.token');
+        },
+        async add(productVariantId, quantity, modifiers = [], promotion = null) {
+            if (!this.credentials) {
+                throw new Error('Order is not yet initialized.');
+            }
+            try {
+                const params = {
+                    quantity,
+                    modifiers,
+                    product_variant_id: productVariantId,
+                };
+                if (promotion && promotion.id && promotion.reward_id) {
+                    params.promotion_id = promotion.id;
+                    params.promotion_reward_id = promotion.reward_id;
+                }
+                const order = await addOrderProductVariant(this.credentials, params, this.inclusions !== null ? { with: this.inclusions.product } : {});
+                useProductQuantityIncreased().publish({
+                    order,
+                    productVariantId,
+                    quantity,
+                    modifiers,
+                    promotion,
+                });
+                this.update(order);
+                return true;
+            }
+            catch (e) {
+                useNotification('error', 'Товар не добавлен', getApiErrorMessage(e, 'Не удалось добавить товар в корзину. Повторите попытку'));
+            }
+            return false;
+        },
+        async remove(productVariantId, quantity, modifiers = [], promotion = null) {
+            if (!this.credentials) {
+                throw new Error('Order is not yet initialized.');
+            }
+            try {
+                const params = {
+                    quantity,
+                    modifiers,
+                    product_variant_id: productVariantId,
+                };
+                if (promotion && promotion.id && promotion.reward_id) {
+                    params.promotion_id = promotion.id;
+                    params.promotion_reward_id = promotion.reward_id;
+                }
+                const order = await removeOrderProductVariant(this.credentials, params, this.inclusions !== null ? { with: this.inclusions.product } : {});
+                useProductQuantityDecreased().publish({
+                    order,
+                    productVariantId,
+                    quantity,
+                    modifiers,
+                    promotion,
+                });
+                this.update(order);
+                return true;
+            }
+            catch (e) {
+                useNotification('error', 'Товар не удалён', getApiErrorMessage(e, 'Не удалось удалить товар из корзины. Повторите попытку'));
+            }
+            return false;
+        },
+        update(order) {
+            if (this.order === null) {
+                this.order = order;
+                return;
+            }
+            this.order.total_price = order.total_price;
+            this.order.original_total_price = order.original_total_price;
+            this.order.discount_difference = order.discount_difference;
+            this.order.has_discount = order.has_discount;
+            this.order.variants = getUpdatedVariants(this.order, order);
+        },
+        async recreate(storeId, cityId, inclusions = null) {
+            this.reset();
+            if (!this.inclusions && inclusions) {
+                this.inclusions = inclusions;
+            }
+            this.loading = true;
+            return this.create(storeId, cityId);
+        },
+    },
+});
+
+function useStageDetectors(order) {
+    const hasCustomer = () => !!order.customer && !!order.customer.id;
+    const hasDelivery = () => {
+        var _a;
+        if (['pickup', 'on_premise'].indexOf(order.delivery_method.id) > -1) {
+            return !!order.stock && !!order.stock.id;
+        }
+        return !!(order === null || order === void 0 ? void 0 : order.delivery_address) && !!((_a = order === null || order === void 0 ? void 0 : order.delivery_address) === null || _a === void 0 ? void 0 : _a.id);
+    };
+    return {
+        hasCustomer,
+        hasDelivery,
+    };
+}
+var CheckoutStage;
+(function (CheckoutStage) {
+    CheckoutStage["Customer"] = "customer";
+    CheckoutStage["Delivery"] = "delivery";
+    CheckoutStage["Payments"] = "payments";
+    CheckoutStage["Summary"] = "summary";
+})(CheckoutStage || (CheckoutStage = {}));
+function useOrderCheckout() {
+    const currentStage = ref(CheckoutStage.Customer);
+    const stages = ref({
+        [CheckoutStage.Customer]: {
+            active: false,
+            completed: false,
+        },
+        [CheckoutStage.Delivery]: {
+            active: false,
+            completed: false,
+        },
+        [CheckoutStage.Payments]: {
+            active: false,
+            completed: false,
+        },
+        [CheckoutStage.Summary]: {
+            active: false,
+            completed: false,
+        },
+    });
+    const { order, settingsLoaded } = storeToRefs(useOrderStore());
+    const { loaded: customerLoaded } = storeToRefs(useCustomerStore());
+    const ready = computed(() => {
+        if (!order.value || !order.value.id || !order.value.token) {
+            return false;
+        }
+        else if (!customerLoaded.value) {
+            return false;
+        }
+        else if (!settingsLoaded.value) {
+            return false;
+        }
+        return true;
+    });
+    const setStage = (newStage) => {
+        currentStage.value = newStage;
+        Object.keys(stages.value).forEach((key) => {
+            stages.value[key].active = false;
+            stages.value[key].completed = false;
+        });
+        stages.value[newStage].active = true;
+        switch (newStage) {
+            case CheckoutStage.Customer:
+                break;
+            case CheckoutStage.Delivery:
+                stages.value.customer.completed = true;
+                break;
+            case CheckoutStage.Payments:
+                stages.value.customer.completed = true;
+                stages.value.delivery.completed = true;
+                break;
+            case CheckoutStage.Summary:
+                stages.value.customer.completed = true;
+                stages.value.delivery.completed = true;
+                stages.value.payments.completed = true;
+                break;
+            default:
+                console.error(`[checkout] Unknown stage provided: "${newStage}", resetting to customer stage.`);
+                stages.value.customer.completed = false;
+                stages.value.delivery.completed = false;
+                stages.value.payments.completed = false;
+                break;
+        }
+    };
+    watch(ready, () => {
+        if (!ready.value || order.value === null) {
+            return setStage(CheckoutStage.Customer);
+        }
+        const detectors = useStageDetectors(order.value);
+        if (!detectors.hasCustomer()) {
+            return setStage(CheckoutStage.Customer);
+        }
+        else if (!detectors.hasDelivery()) {
+            return setStage(CheckoutStage.Delivery);
+        }
+        return setStage(CheckoutStage.Payments);
+    }, { immediate: true });
+    return {
+        ready,
+        order,
+        stages,
+        currentStage,
+        setStage,
+    };
+}
+
+function useCheckoutConfirmation(order) {
+    const form = ref({ code: '' });
+    const confirming = ref(false);
+    const resending = ref(false);
+    const credentials = computed(() => ({
+        id: order.value.id,
+        token: order.value.token,
+    }));
+    const confirm = async () => {
+        if (confirming.value) {
+            return null;
+        }
+        else if (!form.value.code) {
+            useNotification('error', 'Ошибка', 'Нужно указать код из SMS.');
+            return null;
+        }
+        confirming.value = true;
+        try {
+            return await confirmOrder(credentials.value, form.value);
+        }
+        catch (e) {
+            useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Не удалось подтвердить заказ.'));
+        }
+        finally {
+            confirming.value = false;
+        }
+        return null;
+    };
+    const resendCode = async () => {
+        if (resending.value) {
+            return;
+        }
+        resending.value = true;
+        try {
+            const result = await resendOrderConfirmationCode(credentials.value);
+            if (result.success) {
+                useNotification('success', 'Код выслан', 'Код был повторно выслан на ваш телефон.');
+            }
+            else {
+                useNotification('error', 'Ошибка', 'Не удалось выслать код подтверждения. Повторите попытку позднее.');
+            }
+        }
+        catch (e) {
+            useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Не удалось выслать код подтверждения.'));
+        }
+        finally {
+            resending.value = false;
+        }
+    };
+    return {
+        form,
+        confirming,
+        confirm,
+        resending,
+        resendCode,
+    };
+}
+
+function useCustomerCheckoutForm(emit) {
+    var _a;
+    const ready = ref(false);
+    const saving = ref(false);
+    const form = ref({
+        phone: {
+            number: '',
+            country: 'RU',
+        },
+        first_name: '',
+        last_name: '',
+    });
+    const { customer } = storeToRefs(useCustomerStore());
+    const { order, credentials } = storeToRefs(useOrderStore());
+    if (((_a = order.value) === null || _a === void 0 ? void 0 : _a.customer) && order.value.customer.id) {
+        form.value.phone.number = order.value.customer.phone.national;
+        form.value.phone.country = order.value.customer.phone.country;
+        form.value.first_name = order.value.customer.first_name || '';
+        form.value.last_name = order.value.customer.last_name || '';
+    }
+    else if (customer.value && customer.value.id) {
+        form.value.phone.number = customer.value.phone.national;
+        form.value.phone.country = customer.value.phone.country;
+        form.value.first_name = customer.value.first_name || '';
+        form.value.last_name = customer.value.last_name || '';
+    }
+    const save = async () => {
+        if (!credentials.value) {
+            return;
+        }
+        else if (saving.value) {
+            return;
+        }
+        else if (!form.value.phone.number || !form.value.phone.country) {
+            useNotification('error', 'Ошибка', 'Нужно указать номер телефона.');
+            return;
+        }
+        else if (!form.value.first_name) {
+            useNotification('error', 'Ошибка', 'Нужно указать имя.');
+            return;
+        }
+        saving.value = true;
+        try {
+            await setOrderCheckoutCustomer(credentials.value, form.value);
+            emit('completed');
+        }
+        catch (e) {
+            useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Не удалось сохранить контактные данные.'));
+        }
+        finally {
+            saving.value = false;
+        }
+    };
+    return {
+        ready,
+        saving,
+        customer,
+        form,
+        save,
+    };
+}
+
+function useTotalPrice() {
+    const { order } = storeToRefs(useOrderStore());
+    return {
+        totalPrice: computed(() => { var _a; return (_a = order.value) === null || _a === void 0 ? void 0 : _a.total_price; }),
+        originalTotalPrice: computed(() => { var _a; return (_a = order.value) === null || _a === void 0 ? void 0 : _a.original_total_price; }),
+        hasDiscount: computed(() => { var _a; return (_a = order.value) === null || _a === void 0 ? void 0 : _a.has_discount; }),
+        discountDifference: computed(() => { var _a; return (_a = order.value) === null || _a === void 0 ? void 0 : _a.discount_difference; }),
+    };
+}
+function useTotalQuantity() {
+    const { order } = storeToRefs(useOrderStore());
+    const quantity = computed(() => {
+        var _a;
+        if (!order.value) {
+            return 0;
+        }
+        return (((_a = order.value) === null || _a === void 0 ? void 0 : _a.variants) || [])
+            .map((variant) => variant.quantity)
+            .reduce((variantQuantity, total) => variantQuantity + total, 0);
+    });
+    return {
+        order,
+        quantity,
+    };
+}
+function useOrderVariants() {
+    const { order } = storeToRefs(useOrderStore());
+    const variants = computed(() => {
+        if (!order.value || !order.value.variants || !order.value.variants.length) {
+            return [];
+        }
+        return order.value.variants;
+    });
+    return {
+        variants,
+    };
+}
+const useVariantControls = (variant, modifiers, modifiersHash, promotion) => {
+    const { order } = storeToRefs(useOrderStore());
+    const { add: addVariant, remove: removeVariant } = useOrderStore();
+    const loading = ref(false);
+    const operation = ref(null);
+    const orderVariant = computed(() => {
+        var _a, _b;
+        if (!((_b = (_a = order.value) === null || _a === void 0 ? void 0 : _a.variants) === null || _b === void 0 ? void 0 : _b.length)) {
+            return null;
+        }
+        return order.value.variants.find((item) => {
+            if (item.product_variant_id !== variant.value.id || item.modifiers_hash !== modifiersHash.value) {
+                return false;
+            }
+            else if (promotion.value === null) {
+                return item.promotion_id === null;
+            }
+            return item.promotion_id === promotion.value.id && item.promotion_reward_id === promotion.value.reward_id;
+        });
+    });
+    const totalQuantity = computed(() => (orderVariant.value ? orderVariant.value.quantity : 0));
+    const quantityModel = ref(totalQuantity.value);
+    const updateVariant = async (type, quantity) => {
+        if (loading.value) {
+            return;
+        }
+        loading.value = true;
+        operation.value = type;
+        let result;
+        if (type === 'add') {
+            result = await addVariant(variant.value.id, quantity, modifiers.value, promotion.value);
+        }
+        else {
+            result = await removeVariant(variant.value.id, quantity, modifiers.value, promotion.value);
+            useNotification('success', 'Товар удалён', `Товар${variant.value.name ? ` «${variant.value.name}»` : ''} удалён из корзины!`);
+        }
+        if (result) {
+            useNotification('success', `Товар ${type === 'add' ? 'добавлен' : 'удалён'}`, `Товар${variant.value.name ? ` «${variant.value.name}»` : ''} ${type === 'add' ? 'добавлен в корзину' : 'удалён из корзины'}!`);
+        }
+        loading.value = false;
+    };
+    const add = async () => updateVariant('add', 1);
+    const remove = async () => updateVariant('remove', totalQuantity.value);
+    const getQuantity = (value) => {
+        if (typeof value === 'string') {
+            return parseInt(value, 10);
+        }
+        return value;
+    };
+    const increase = async (quantity = 1) => {
+        quantityModel.value = getQuantity(quantityModel.value) + quantity;
+    };
+    const decrease = async (quantity = 1) => {
+        quantityModel.value = Math.max(0, getQuantity(quantityModel.value) - quantity);
+    };
+    watch(totalQuantity, () => {
+        quantityModel.value = totalQuantity.value;
+    });
+    watch(quantityModel, debounce(async (val) => {
+        const difference = getQuantity(val) - totalQuantity.value;
+        if (difference < 0) {
+            await updateVariant('remove', Math.abs(difference));
+        }
+        else if (difference > 0) {
+            await updateVariant('add', difference);
+        }
+    }, 1000));
+    return {
+        orderVariant,
+        totalQuantity,
+        quantityModel,
+        add,
+        increase,
+        decrease,
+        remove,
+        loading,
+        operation,
+    };
+};
+
+function getDeliveryMethod(order, settings) {
+    if (!order.value || !settings.value) {
+        return 'delivery';
+    }
+    const methods = settings.value.delivery_methods.map((method) => method.id);
+    if (methods.indexOf(order.value.delivery_method.id) !== -1) {
+        return order.value.delivery_method.id;
+    }
+    return methods[0];
+}
+function getStockId(order, stocks) {
+    const availableStocks = stocks.value.map((stock) => stock.id);
+    if (order.value && order.value.stock_id !== null && availableStocks.indexOf(order.value.stock_id) !== -1) {
+        return order.value.stock_id;
+    }
+    return availableStocks[0];
+}
+function useCustomerAddresses(customer) {
+    const addresses = ref([]);
+    const loaded = ref(false);
+    if (!customer.value || !customer.value.id) {
+        loaded.value = true;
+    }
+    else {
+        getCustomerAddresses({ count: 100 }).then((response) => {
+            addresses.value = response.items;
+            loaded.value = true;
+        });
+    }
+    return {
+        addresses,
+        loaded,
+    };
+}
+function getDeliveryPayload(form, addressesResolver) {
+    const data = { delivery_method: form.method };
+    const errors = [];
+    if (form.method === 'pickup') {
+        if (form.pickup.stock_id) {
+            data.stock_id = form.pickup.stock_id;
+        }
+        else {
+            errors.push('Нужно выбрать точку самовывоза.');
+        }
+    }
+    else if (form.method === 'on_premise') {
+        if (form.on_premise.stock_id) {
+            data.stock_id = form.on_premise.stock_id;
+        }
+        else {
+            errors.push('Нужно выбрать точку самовывоза.');
+        }
+        if (form.on_premise.table) {
+            data.on_premise = { table: form.on_premise.table };
+        }
+        else {
+            errors.push('Нужно указать номер стола.');
+        }
+    }
+    else if (form.method === 'delivery') {
+        if (form.delivery.address.id) {
+            data.delivery_address = { id: form.delivery.address.id };
+        }
+        else {
+            const { errors: addressErrors, data: address } = useAddressFormValue(form.delivery.address, addressesResolver);
+            if (addressErrors.length > 0) {
+                errors.push(addressErrors[0]);
+            }
+            else {
+                data.delivery_address = address;
+            }
+        }
+    }
+    if (form.deliver_at.mode === 'select' && form.deliver_at.date) {
+        data.deliver_at = format(Date.parse(form.deliver_at.date), 'yyyy-MM-dd HH:mm');
+    }
+    return {
+        data,
+        errors,
+    };
+}
+function useDeliveryCheckoutForm(emit) {
+    var _a, _b, _c, _d;
+    const { credentials, order, settings } = storeToRefs(useOrderStore());
+    const { customer } = storeToRefs(useCustomerStore());
+    const { stocks, addressesResolver } = storeToRefs(useStoreStore());
+    const { addresses, loaded } = useCustomerAddresses(customer);
+    const { totalPrice } = useTotalPrice();
+    const ready = computed(() => loaded.value);
+    const currentAddress = computed(() => { var _a; return (_a = order.value) === null || _a === void 0 ? void 0 : _a.delivery_address; });
+    const saving = ref(false);
+    const form = ref({
+        method: getDeliveryMethod(order, settings),
+        delivery: {
+            address: getAddressForm(),
+        },
+        pickup: {
+            stock_id: getStockId(order, stocks),
+        },
+        on_premise: {
+            stock_id: getStockId(order, stocks),
+            table: '',
+        },
+        deliver_at: {
+            mode: 'asap',
+            date: '',
+        },
+    });
+    form.value.delivery.address.id = ((_b = (_a = order.value) === null || _a === void 0 ? void 0 : _a.delivery_address) === null || _b === void 0 ? void 0 : _b.id) || '';
+    if ((_d = (_c = order.value) === null || _c === void 0 ? void 0 : _c.deliver_at_local) === null || _d === void 0 ? void 0 : _d.datetime) {
+        form.value.deliver_at.mode = 'select';
+        form.value.deliver_at.date = format(Date.parse(order.value.deliver_at_local.iso), 'yyyy-MM-dd HH:mm');
+    }
+    const priceIsNotEnough = computed(() => {
+        var _a, _b;
+        const method = (_a = settings.value) === null || _a === void 0 ? void 0 : _a.delivery_methods.find((item) => item.id === form.value.method);
+        if (!method || !method.min_price || !method.min_price.value) {
+            return false;
+        }
+        return method.min_price.value > (((_b = totalPrice.value) === null || _b === void 0 ? void 0 : _b.value) || 0);
+    });
+    const save = async () => {
+        if (!credentials.value || !addressesResolver.value) {
+            return;
+        }
+        else if (saving.value) {
+            return;
+        }
+        const { data, errors } = getDeliveryPayload(form.value, addressesResolver.value);
+        if (errors.length > 0) {
+            useNotification('error', 'Ошибка', errors[0]);
+            return;
+        }
+        saving.value = true;
+        try {
+            await setOrderCheckoutDelivery(credentials.value, data);
+            emit('completed');
+        }
+        catch (e) {
+            useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Не удалось сохранить способ доставки.'));
+        }
+        finally {
+            saving.value = false;
+        }
+    };
+    return {
+        ready,
+        form,
+        addresses,
+        currentAddress,
+        addressesResolver,
+        priceIsNotEnough,
+        saving,
+        save,
+    };
+}
+
+function getPaymentMethod(settings) {
+    if (!settings.value) {
+        return 'cash';
+    }
+    const available = settings.value.payment_methods.map((method) => method.id);
+    return available[0];
+}
+function useBillSuggestions(unpaidAmount, staticAmounts = [10, 50, 200, 5000], availableBills = [100, 500, 1000]) {
+    const { totalPrice } = useTotalPrice();
+    const getClosestMultipleOf = (price, amount) => Math.ceil(price / amount) * amount;
+    const suggestions = computed(() => {
+        const items = new Set([
+            ...staticAmounts,
+            ...availableBills.map((billItem) => getClosestMultipleOf(unpaidAmount.value, billItem)),
+            unpaidAmount.value,
+        ]);
+        const bills = [...items]
+            .filter((suggestion) => suggestion > unpaidAmount.value)
+            .sort((first, second) => (first - second))
+            .map((amount) => {
+            var _a, _b;
+            return ({
+                value: amount,
+                label: `${(_a = totalPrice.value) === null || _a === void 0 ? void 0 : _a.currency.prefix}${amount}${(_b = totalPrice.value) === null || _b === void 0 ? void 0 : _b.currency.suffix}`,
+            });
+        });
+        bills.unshift({
+            label: 'Без сдачи',
+            value: '',
+        });
+        bills.push({
+            label: 'Другая',
+            value: 'custom',
+        });
+        return bills;
+    });
+    return {
+        suggestions,
+    };
+}
+function useBonusesPreviewChecker(order, credentials, bonuses, setBonuses) {
+    var _a;
+    const bonusesAreChecking = ref(false);
+    const unpaidAmount = ref((_a = order.value) === null || _a === void 0 ? void 0 : _a.total_price);
+    const bonusesChecker = async () => {
+        var _a;
+        if (!credentials.value) {
+            return;
+        }
+        else if (bonusesAreChecking.value) {
+            return;
+        }
+        else if (!bonuses.value) {
+            unpaidAmount.value = (_a = order.value) === null || _a === void 0 ? void 0 : _a.total_price;
+            return;
+        }
+        bonusesAreChecking.value = true;
+        try {
+            const preview = await getOrderBonusesPaymentPreview(credentials.value, bonuses.value);
+            unpaidAmount.value = preview.unpaid;
+            if (parseFloat(bonuses.value) > parseFloat(preview.bonuses.trimmed)) {
+                setBonuses(preview.bonuses.trimmed);
+                useNotification('warning', 'Сумма бонусов изменена', 'Вы указали сумму бонусов, превышающую лимит списания. Мы изменили сумму на максимально доступную.');
+            }
+        }
+        catch (e) {
+            //
+        }
+        finally {
+            bonusesAreChecking.value = false;
+        }
+    };
+    watch(bonuses, debounce(async () => bonusesChecker(), 1000));
+    return {
+        unpaidAmount,
+        bonusesAreChecking,
+    };
+}
+function getPaymentsPayload(form) {
+    const payments = [];
+    if (parseFloat(form.bonuses) > 0.0) {
+        payments.push({
+            method: 'bonuses',
+            amount: form.bonuses,
+        });
+    }
+    const payment = { method: form.method };
+    if (form.method === 'cash' && form.bill) {
+        payment.bill = form.bill;
+    }
+    else if (form.method === 'card_token') {
+        payment.card_token_id = form.card_token_id;
+    }
+    else if (form.method === 'cloudpayments') {
+        payment.save_card = form.save_card === true;
+    }
+    payments.push(payment);
+    return payments;
+}
+function useDeliveryPaymentsForm(emit) {
+    const { order, credentials, settings } = storeToRefs(useOrderStore());
+    const form = ref({
+        method: getPaymentMethod(settings),
+        bill: '',
+        save_card: false,
+        bonuses: '',
+        card_token_id: '',
+    });
+    const saving = ref(false);
+    const bonuses = computed(() => form.value.bonuses);
+    const { unpaidAmount, bonusesAreChecking } = useBonusesPreviewChecker(order, credentials, bonuses, (amount) => {
+        form.value.bonuses = amount;
+    });
+    const save = async () => {
+        if (!credentials.value) {
+            return;
+        }
+        else if (saving.value) {
+            return;
+        }
+        const payments = getPaymentsPayload(form.value);
+        try {
+            await setOrderCheckoutPayment(credentials.value, { payments });
+            emit('completed');
+        }
+        catch (e) {
+            useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Не удалось сохранить способ оплаты.'));
+        }
+        finally {
+            saving.value = false;
+        }
+    };
+    return {
+        form,
+        unpaidAmount,
+        bonusesAreChecking,
+        saving,
+        save,
+    };
+}
+
+function useCheckoutSummary(emit) {
+    const orderStore = useOrderStore();
+    const { credentials, settings } = storeToRefs(orderStore);
+    const { store, city } = storeToRefs(useStoreStore());
+    const form = ref({
+        persons_count: '',
+        notes: '',
+    });
+    const hasPersonsCount = computed(() => {
+        if (!settings.value) {
+            return false;
+        }
+        const index = settings.value.options.findIndex((option) => option.kind === 'persons_count');
+        return index !== -1;
+    });
+    const saving = ref(false);
+    const save = async () => {
+        if (!credentials.value) {
+            return;
+        }
+        else if (saving.value) {
+            return;
+        }
+        const payload = {
+            notes: form.value.notes,
+        };
+        if (hasPersonsCount.value && form.value.persons_count) {
+            payload.notes = `Персон: ${form.value.persons_count}\n\n${payload.notes}`.trim();
+        }
+        saving.value = true;
+        try {
+            const response = await checkoutOrder(credentials.value, payload);
+            if (response.confirmation_required) {
+                emit('confirmation', credentials.value);
+            }
+            else {
+                emit('completed', response);
+            }
+            if (store.value && city.value) {
+                await orderStore.recreate(store.value.id, city.value.id);
+            }
+        }
+        catch (e) {
+            useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Не удалось оформить заказ.'));
+        }
+        finally {
+            saving.value = false;
+        }
+    };
+    return {
+        form,
+        hasPersonsCount,
+        saving,
+        save,
+    };
+}
+
+function useCheckoutTotal() {
+    const { credentials } = storeToRefs(useOrderStore());
+    const loading = ref(false);
+    const total = ref(null);
+    const load = async () => {
+        if (loading.value) {
+            return;
+        }
+        else if (!credentials.value) {
+            return;
+        }
+        loading.value = true;
+        try {
+            total.value = await getOrderCheckoutTotal(credentials.value);
+        }
+        catch (e) {
+            //
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    return {
+        loading,
+        load,
+        total,
+    };
+}
+
 function useProductsPricesRange(categoryId, errorHandler) {
     return useDataLoader(async () => getProductsPricesRange(categoryId), getApiErrorHandler(errorHandler, function (e) {
         useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Не удалось загрузить диапазон цен.'));
@@ -1949,6 +2914,123 @@ function getProductsSource(source) {
     }
 }
 
+const usePromotionsStore = defineStore({
+    id: 'zenky:storefront:promotions',
+    state: () => ({
+        checking: false,
+        failed: false,
+        selector: {
+            available: false,
+            closed: false,
+            offer: null,
+            promotion_id: '',
+            reward_id: '',
+            max_quantity: 0,
+            context: null,
+        },
+    }),
+    getters: {
+        hasSelector() {
+            if (this.checking) {
+                return false;
+            }
+            else if (!this.selector.available) {
+                return false;
+            }
+            else if (!this.selector.promotion_id || !this.selector.reward_id) {
+                return false;
+            }
+            return true;
+        },
+        hasSelectorContext() {
+            if (this.selector.context === null) {
+                return false;
+            }
+            return !!this.selector.context.id && !!this.selector.context.type;
+        },
+    },
+    actions: {
+        setCheckerState(value, timedOut = false) {
+            this.checking = value;
+            this.failed = timedOut;
+        },
+        disableRewardsSelector() {
+            this.selector.available = false;
+            this.selector.offer = null;
+            this.selector.promotion_id = '';
+            this.selector.reward_id = '';
+            this.selector.max_quantity = 0;
+            this.selector.context = null;
+        },
+        enableRewardsSelector(selector) {
+            this.selector.available = true;
+            this.selector.offer = selector.offer;
+            this.selector.promotion_id = selector.promotion_id;
+            this.selector.reward_id = selector.reward_id;
+            this.selector.max_quantity = selector.limit;
+            this.selector.context = selector.context;
+        },
+        closeRewardsSelector() {
+            this.selector.closed = true;
+        },
+        openRewardsSelector() {
+            this.selector.closed = false;
+        },
+        initialize() {
+            usePromotionsCheckerStarted().subscribe('storefront.promotions.initialize', () => this.setCheckerState(true));
+            usePromotionsCheckerCompleted().subscribe('storefront.promotions.initialize', (params) => this.setCheckerState(false, params && params.timeout === true));
+            useDisplayOrderPromotionRewardSelection().subscribe('storefront.promotions.initialize', ({ data }) => this.enableRewardsSelector(data));
+            useOrderPromotionsNotFound().subscribe('storefront.promotions.initialize', () => this.disableRewardsSelector());
+        },
+    },
+});
+
+function initializePromotions(order, timeout = 10000) {
+    const promotionsStore = usePromotionsStore();
+    promotionsStore.initialize();
+    const promotionsAreChecking = computed(() => promotionsStore.checking);
+    let manualTimeout = undefined;
+    const checker = async () => {
+        if (promotionsAreChecking.value) {
+            return;
+        }
+        if (manualTimeout) {
+            clearTimeout(manualTimeout);
+        }
+        usePromotionsCheckerStarted().publish();
+        await checkCompletedPromotions({ id: order.id, token: order.token });
+        manualTimeout = setTimeout(() => {
+            if (promotionsAreChecking.value) {
+                usePromotionsCheckerCompleted().publish({ timeout: true });
+            }
+        }, timeout);
+    };
+    useProductQuantityIncreased().subscribe('promotions.init', checker);
+    useProductQuantityDecreased().subscribe('promotions.init', checker);
+    checkCompletedPromotions({ id: order.id, token: order.token }).then(() => {
+        console.log('[storefront/promotions] Promotions checker has been initialized.');
+    });
+}
+function useRewardsSelector() {
+    const promotionsStore = usePromotionsStore();
+    const selector = computed(() => promotionsStore.selector);
+    const checking = computed(() => promotionsStore.checking);
+    const failed = computed(() => promotionsStore.failed);
+    const available = computed(() => selector.value.available);
+    const collapsed = computed(() => selector.value.closed);
+    const close = () => promotionsStore.closeRewardsSelector();
+    const open = () => promotionsStore.openRewardsSelector();
+    return {
+        checking,
+        failed,
+        available,
+        collapsed,
+        selector,
+        open,
+        close,
+    };
+}
+
 var ZenkyWebsocketEvent;
 (function (ZenkyWebsocketEvent) {
     ZenkyWebsocketEvent["OrderPriceRecalculated"] = "orders.price.recalculated";
@@ -2014,4 +3096,4 @@ function subscribeToOrderEvents(order) {
     });
 }
 
-export { AuthenticationEvent, AuthenticationResultType, AuthenticationStage, ZenkyInjection, ZenkyWebsocketEvent, createStorage, createWebsocketsConnection, getAddressForm, getApiErrorHandler, getExistedAddress, getExistedAddressDisplayValue, getFirstMedium, getProductsListParamsFromQuery, getProductsListQueryParams, getProductsPaginationRequest, getProductsSource, getSelectedAddress, getSelectedAddressDisplayValue, getStockAddress, getStockSchedule, getStorage, getWebsocketsConnection, subscribeToOrderEvents, useAddressFormValue, useArticleCategoriesList, useArticleItem, useArticlesList, useAuthenticationForm, useAuthenticationStatusChecker, useCategories, useCategoriesStore, useCategoriesTree, useCategory, useCategoryFeaturesGroupsList, useCategoryFeaturesList, useCollection, useCollections, useCollectionsStore, useCustomer, useCustomerStore, useDadata, useDataDestroyer, useDataLoader, useDeliveryAddressDestroyer, useDeliveryAddressesList, useEditAddressForm, useFeaturesFilters, useFeaturesGroupsFilters, useFlatCategoriesTree, useItemLoader, useListLoader, useLogin, useLogout, useOfferItem, useOffersList, useOrderItem, useOrdersList, usePaginatedLoader, usePasswordReset, usePaymentMethodDestroyer, usePaymentMethodsList, usePhoneConfirmation, useProductsList, useProductsPricesRange, useProductsPricesRangeFilters, useRegistration, useReversedTree, useSplittedCategoriesTree, useStateDataLoader, useStoreStore, useSuggestionsRestrictedToCity };
+export { AuthenticationEvent, AuthenticationResultType, AuthenticationStage, CheckoutStage, ZenkyInjection, ZenkyWebsocketEvent, createStorage, createWebsocketsConnection, getAddressForm, getApiErrorHandler, getExistedAddress, getExistedAddressDisplayValue, getFirstMedium, getProductsListParamsFromQuery, getProductsListQueryParams, getProductsPaginationRequest, getProductsSource, getSelectedAddress, getSelectedAddressDisplayValue, getStockAddress, getStockSchedule, getStorage, getUpdatedVariants, getWebsocketsConnection, initializeOrderCustomer, initializePromotions, subscribeToOrderEvents, useAddressFormValue, useArticleCategoriesList, useArticleItem, useArticlesList, useAuthenticationForm, useAuthenticationStatusChecker, useBillSuggestions, useCategories, useCategoriesStore, useCategoriesTree, useCategory, useCategoryFeaturesGroupsList, useCategoryFeaturesList, useCheckoutConfirmation, useCheckoutSummary, useCheckoutTotal, useCollection, useCollections, useCollectionsStore, useCustomer, useCustomerCheckoutForm, useCustomerStore, useDadata, useDataDestroyer, useDataLoader, useDeliveryAddressDestroyer, useDeliveryAddressesList, useDeliveryCheckoutForm, useDeliveryPaymentsForm, useEditAddressForm, useFeaturesFilters, useFeaturesGroupsFilters, useFlatCategoriesTree, useItemLoader, useListLoader, useLogin, useLogout, useOfferItem, useOffersList, useOrderCheckout, useOrderItem, useOrderStore, useOrderVariants, useOrdersList, usePaginatedLoader, usePasswordReset, usePaymentMethodDestroyer, usePaymentMethodsList, usePhoneConfirmation, useProductsList, useProductsPricesRange, useProductsPricesRangeFilters, usePromotionsStore, useRegistration, useReversedTree, useRewardsSelector, useSplittedCategoriesTree, useStateDataLoader, useStoreStore, useSuggestionsRestrictedToCity, useTotalPrice, useTotalQuantity, useVariantControls };