@zenky/storefront-vue 0.9.38 → 0.9.41

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, Visibility, 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, checkCompletedPromotions } 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, getProductVariantPrice, getProduct, getProductsPricesRange, getProducts, checkCompletedPromotions } from '@zenky/api';
+import { defineStore, storeToRefs } from 'pinia';
 import { useNotification } from '@zenky/ui';
-import { useCustomerLoaded, useCustomerAuthenticated, useCustomerLoggedOut, usePromotionsCheckerStarted, usePromotionsCheckerCompleted, useDisplayOrderPromotionRewardSelection, useOrderPromotionsNotFound, useProductQuantityIncreased, useProductQuantityDecreased, useOrderPriceRecalculated, useOrderShouldBeReloaded, useOrderPromotionRewardsShouldBeReloaded, 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) {
@@ -1548,6 +1549,1348 @@ 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 useSingleModifier(props, emit) {
+    const value = computed({
+        get: () => props.modelValue,
+        set: (val) => emit('update:modelValue', val),
+    });
+    const checked = computed({
+        get: () => value.value.quantity > 0,
+        set: (val) => {
+            value.value.quantity = val ? 1 : 0;
+        },
+    });
+    const shouldUseQuantityControls = computed(() => props.modifier.max_quantity > 1);
+    const increase = () => {
+        if (props.limitReached) {
+            return;
+        }
+        value.value.quantity = Math.min(value.value.quantity + 1, props.modifier.max_quantity);
+    };
+    const decrease = () => {
+        value.value.quantity = Math.max(value.value.quantity - 1, props.modifier.min_quantity);
+    };
+    return {
+        value,
+        checked,
+        shouldUseQuantityControls,
+        increase,
+        decrease,
+    };
+}
+
+function getModifierQuantity(modifier, value) {
+    const index = value.value.findIndex((item) => item.modifier_id === modifier.modifier.id);
+    if (index === -1) {
+        return 0;
+    }
+    return value.value[index].quantity;
+}
+function getDefaultModifiersGroupModifiers(group, value) {
+    const modifiers = {};
+    group.modifiers.forEach((modifier) => {
+        const quantity = Array.isArray(value.value) ? getModifierQuantity(modifier, value) : 0;
+        modifiers[modifier.modifier.id] = {
+            quantity,
+            modifier_id: modifier.modifier.id,
+        };
+    });
+    return modifiers;
+}
+function getSelectedModifiers$1(group, modifiers) {
+    const selected = [];
+    Object.keys(modifiers).forEach((modifierId) => {
+        if (!modifiers[modifierId].quantity) {
+            return;
+        }
+        selected.push({
+            modifiers_group_id: group.group.id,
+            modifier_id: modifierId,
+            quantity: modifiers[modifierId].quantity,
+        });
+    });
+    return selected;
+}
+function useModifiersGroup(props, emit) {
+    const value = computed({
+        get: () => props.modelValue,
+        set: (val) => emit('update:modelValue', val),
+    });
+    const selectedModifier = ref('');
+    const modifiers = ref(getDefaultModifiersGroupModifiers(props.group, value));
+    const shouldUseQuantityControls = computed(() => props.group.max_quantity > 1);
+    const totalSelectedCount = computed(() => {
+        return value.value
+            .map((modifier) => modifier.quantity)
+            .reduce((current, total) => current + total, 0);
+    });
+    const limitReached = computed(() => {
+        if (!shouldUseQuantityControls.value) {
+            return selectedModifier.value !== '';
+        }
+        return totalSelectedCount.value >= props.group.max_quantity;
+    });
+    const requiredModifierIsMissing = computed(() => {
+        if (!props.group.is_required) {
+            return false;
+        }
+        else if (props.group.min_quantity === 0) {
+            return false;
+        }
+        return totalSelectedCount.value < props.group.min_quantity;
+    });
+    watch(selectedModifier, (val) => {
+        if (!val) {
+            value.value = [];
+            return;
+        }
+        value.value = [{
+                modifiers_group_id: props.group.group.id,
+                modifier_id: val,
+                quantity: 1,
+            }];
+    });
+    watch(modifiers, (val) => {
+        value.value = getSelectedModifiers$1(props.group, val);
+    }, { deep: true });
+    return {
+        selectedModifier,
+        modifiers,
+        shouldUseQuantityControls,
+        requiredModifierIsMissing,
+        limitReached,
+    };
+}
+
+function getModifiers(product, variant) {
+    const modifiers = {};
+    ((product === null || product === void 0 ? void 0 : product.modifiers) || []).forEach((modifier) => {
+        modifiers[modifier.modifier.id] = {
+            modifier_id: modifier.modifier.id,
+            quantity: 0,
+        };
+    });
+    ((product === null || product === void 0 ? void 0 : product.modifiers_groups) || []).forEach((group) => {
+        modifiers[group.group.id] = [];
+    });
+    if (!variant.value || !variant.value.selected_modifiers || !variant.value.selected_modifiers.modifiers) {
+        return modifiers;
+    }
+    else if (!variant.value.selected_modifiers.modifiers.length) {
+        return modifiers;
+    }
+    variant.value.selected_modifiers.modifiers.forEach((modifier) => {
+        if (typeof modifier.modifiers_group_id !== 'undefined' && modifier.modifiers_group_id) {
+            modifiers[modifier.modifiers_group_id].push(modifier);
+        }
+        else if (typeof modifier.modifier_id !== 'undefined' && modifier.modifier_id) {
+            modifiers[modifier.modifier_id] = {
+                modifier_id: modifier.modifier_id,
+                quantity: modifier.quantity,
+            };
+        }
+    });
+    return modifiers;
+}
+function getSelectedModifiers(modifiers) {
+    const selected = [];
+    Object.keys(modifiers.value).forEach((modifierId) => {
+        const isGroup = Array.isArray(modifiers.value[modifierId]);
+        if (!isGroup && !modifiers.value[modifierId].quantity) {
+            return;
+        }
+        else if (!isGroup) {
+            selected.push({
+                modifier_id: modifierId,
+                quantity: modifiers.value[modifierId].quantity,
+            });
+            return;
+        }
+        modifiers.value[modifierId].forEach((modifier) => {
+            if (!modifier.modifier_id || !modifier.quantity || !modifier.modifiers_group_id) {
+                return;
+            }
+            selected.push({
+                modifiers_group_id: modifier.modifiers_group_id,
+                modifier_id: modifier.modifier_id,
+                quantity: modifier.quantity,
+            });
+        });
+    });
+    return selected;
+}
+function useModifiers(product, variant, recalculate) {
+    var _a, _b;
+    const modifiersHash = ref(((_b = (_a = variant.value) === null || _a === void 0 ? void 0 : _a.selected_modifiers) === null || _b === void 0 ? void 0 : _b.hash) || null);
+    const modifiers = ref(getModifiers(product, variant));
+    const selectedModifiers = computed(() => getSelectedModifiers(modifiers));
+    watch(variant, () => {
+        modifiers.value = getModifiers(product, variant);
+    });
+    watch(selectedModifiers, async () => {
+        modifiersHash.value = await recalculate(selectedModifiers);
+    });
+    return {
+        modifiers,
+        selectedModifiers,
+        modifiersHash,
+    };
+}
+
+async function recalculatePrice(variant, modifiers) {
+    if (!variant.value) {
+        return null;
+    }
+    else if (!modifiers.value.length) {
+        return null;
+    }
+    const { cityId } = storeToRefs(useStoreStore());
+    try {
+        return await getProductVariantPrice(variant.value.product_id, variant.value.id, modifiers.value, {
+            city_id: cityId.value || undefined,
+        });
+    }
+    catch (e) {
+        //
+    }
+    return null;
+}
+function getProductVariantsPricesRange(variants) {
+    if (!variants.length) {
+        return null;
+    }
+    const sorted = [...variants].sort((first, second) => Math.sign(first.price.value - second.price.value));
+    return {
+        min: sorted[0].price,
+        max: sorted[sorted.length - 1].price,
+    };
+}
+function useVariantPrice(variants, variant) {
+    const result = ref(null);
+    const recalculating = ref(false);
+    const totalPrice = computed(() => {
+        if (result.value !== null) {
+            return {
+                recalculated: true,
+                recalculating: recalculating.value,
+                price: result.value.price,
+                original_price: result.value.original_price,
+                has_discount: result.value.has_discount,
+                discount_id: result.value.discount_id,
+                discount_difference: result.value.discount_difference,
+                discount_percentage: result.value.discount_percentage,
+            };
+        }
+        else if (!variant.value) {
+            return null;
+        }
+        return {
+            recalculated: false,
+            recalculating: recalculating.value,
+            price: variant.value.price,
+            original_price: variant.value.original_price,
+            has_discount: variant.value.has_discount,
+            discount_id: variant.value.discount_id,
+            discount_difference: variant.value.discount_difference,
+            discount_percentage: variant.value.discount_percentage,
+        };
+    });
+    const pricesRange = computed(() => getProductVariantsPricesRange(variants));
+    const recalculate = async (modifiers) => {
+        if (recalculating.value) {
+            return null;
+        }
+        recalculating.value = true;
+        result.value = await recalculatePrice(variant, modifiers);
+        recalculating.value = false;
+        return result.value !== null ? result.value.modifiers_hash : null;
+    };
+    return {
+        totalPrice,
+        pricesRange,
+        recalculating,
+        recalculate,
+    };
+}
+
+function getOptionsList(variants) {
+    const options = [];
+    if (variants.length <= 1) {
+        return options;
+    }
+    variants.forEach((variant) => {
+        if (!variant.option_values || !variant.option_values.length) {
+            return;
+        }
+        variant.option_values.forEach((optionValue) => {
+            if (!optionValue.option || !optionValue.option.id) {
+                return;
+            }
+            const optionIndex = options.findIndex((option) => { var _a; return option.id === ((_a = optionValue.option) === null || _a === void 0 ? void 0 : _a.id); });
+            if (optionIndex === -1) {
+                options.push({
+                    id: optionValue.option.id,
+                    name: optionValue.option.name,
+                    type: optionValue.option.type,
+                    values: [optionValue],
+                });
+                return;
+            }
+            const valueIndex = options[optionIndex].values.findIndex((item) => item.id === optionValue.id);
+            if (valueIndex !== -1) {
+                return;
+            }
+            options[optionIndex].values.push(optionValue);
+        });
+    });
+    return options;
+}
+function useVariant(variants) {
+    const options = ref(getOptionsList(variants));
+    const selectedOptions = ref({});
+    options.value.forEach((option) => {
+        selectedOptions.value[option.id] = option.values.length > 0 ? option.values[0].id : null;
+    });
+    const variant = computed(() => {
+        if (!Array.isArray(variants) || !variants.length) {
+            return null;
+        }
+        else if (variants.length === 1) {
+            return variants[0];
+        }
+        else if (!Object.keys(selectedOptions.value).length) {
+            return variants[0];
+        }
+        const variantIndex = variants.findIndex((item) => {
+            if (!item.option_values || !item.option_values.length) {
+                return false;
+            }
+            return item.option_values.every((optionValue) => {
+                if (!optionValue.option || !optionValue.option.id) {
+                    return false;
+                }
+                else if (typeof selectedOptions.value[optionValue.option.id] === 'undefined') {
+                    return false;
+                }
+                else if (selectedOptions.value[optionValue.option.id] !== optionValue.id) {
+                    return false;
+                }
+                return true;
+            });
+        });
+        if (variantIndex === -1) {
+            return null;
+        }
+        return variants[variantIndex];
+    });
+    return {
+        variant,
+        options,
+        selectedOptions,
+    };
+}
+
+function useProductItem(errorHandler) {
+    return useItemLoader(getProduct, getApiErrorHandler(errorHandler, function (e) {
+        useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Товар не найден.'));
+    }));
+}
+function useProductCard(item) {
+    var _a;
+    const product = ref({
+        id: item.id,
+        short_id: item.short_id,
+        category_id: Array.isArray(item.categories) && item.categories.length > 0 ? item.categories[0].id : null,
+        slug: item.slug,
+        name: item.name,
+        description: item.description,
+        images: item.media || [],
+        modifiers: item.modifiers || [],
+        modifiers_groups: item.modifiers_groups || [],
+        variants_count: ((_a = item.variants) === null || _a === void 0 ? void 0 : _a.length) || 0,
+        has_images: (item.media || []).length > 0,
+        has_modifiers: (item.modifiers || []).length > 0 || (item.modifiers_groups || []).length > 0,
+    });
+    const { variant, options, selectedOptions, } = useVariant(item.variants || []);
+    const { totalPrice, pricesRange, recalculate, } = useVariantPrice(item.variants || [], variant);
+    const { modifiers, selectedModifiers, modifiersHash, } = useModifiers(item, variant, recalculate);
+    return {
+        product,
+        variant,
+        options,
+        selectedOptions,
+        pricesRange,
+        totalPrice,
+        modifiers,
+        modifiersHash,
+        selectedModifiers,
+    };
+}
+
 function useProductsPricesRange(categoryId, errorHandler) {
     return useDataLoader(async () => getProductsPricesRange(categoryId), getApiErrorHandler(errorHandler, function (e) {
         useNotification('error', 'Ошибка', getApiErrorMessage(e, 'Не удалось загрузить диапазон цен.'));
@@ -2131,4 +3474,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, initializePromotions, 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, usePromotionsStore, useRegistration, useReversedTree, useRewardsSelector, useSplittedCategoriesTree, useStateDataLoader, useStoreStore, useSuggestionsRestrictedToCity };
+export { AuthenticationEvent, AuthenticationResultType, AuthenticationStage, CheckoutStage, ProductsFiltersType, ProductsSorting, ProductsSourceType, ZenkyInjection, ZenkyWebsocketEvent, createStorage, createWebsocketsConnection, getAddressForm, getApiErrorHandler, getExistedAddress, getExistedAddressDisplayValue, getFirstMedium, getProductVariantsPricesRange, 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, useModifiers, useModifiersGroup, useOfferItem, useOffersList, useOrderCheckout, useOrderItem, useOrderStore, useOrderVariants, useOrdersList, usePaginatedLoader, usePasswordReset, usePaymentMethodDestroyer, usePaymentMethodsList, usePhoneConfirmation, useProductCard, useProductItem, useProductsList, useProductsPricesRange, useProductsPricesRangeFilters, usePromotionsStore, useRegistration, useReversedTree, useRewardsSelector, useSingleModifier, useSplittedCategoriesTree, useStateDataLoader, useStoreStore, useSuggestionsRestrictedToCity, useTotalPrice, useTotalQuantity, useVariant, useVariantControls, useVariantPrice };