@zenky/storefront-vue 0.9.37 → 0.9.40

package/dist/cjs/index.js

@@ -8,6 +8,7 @@ var api = require('@zenky/api');
 var pinia = require('pinia');
 var ui = require('@zenky/ui');
 var events = require('@zenky/events');
+var dateFns = require('date-fns');
 var Pusher = require('pusher-js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -1556,6 +1557,1352 @@ 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 = lodashEs.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) {
+    events.useCustomerAuthenticated().subscribe('order.customer.initialize', async ({ customer }) => {
+        const credentials = credentialsResolver();
+        if (credentials === null) {
+            return;
+        }
+        try {
+            await api.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 = pinia.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;
+                events.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 api.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 api.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) {
+                ui.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 api.addOrderProductVariant(this.credentials, params, this.inclusions !== null ? { with: this.inclusions.product } : {});
+                events.useProductQuantityIncreased().publish({
+                    order,
+                    productVariantId,
+                    quantity,
+                    modifiers,
+                    promotion,
+                });
+                this.update(order);
+                return true;
+            }
+            catch (e) {
+                ui.useNotification('error', 'Товар не добавлен', api.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 api.removeOrderProductVariant(this.credentials, params, this.inclusions !== null ? { with: this.inclusions.product } : {});
+                events.useProductQuantityDecreased().publish({
+                    order,
+                    productVariantId,
+                    quantity,
+                    modifiers,
+                    promotion,
+                });
+                this.update(order);
+                return true;
+            }
+            catch (e) {
+                ui.useNotification('error', 'Товар не удалён', api.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,
+    };
+}
+exports.CheckoutStage = void 0;
+(function (CheckoutStage) {
+    CheckoutStage["Customer"] = "customer";
+    CheckoutStage["Delivery"] = "delivery";
+    CheckoutStage["Payments"] = "payments";
+    CheckoutStage["Summary"] = "summary";
+})(exports.CheckoutStage || (exports.CheckoutStage = {}));
+function useOrderCheckout() {
+    const currentStage = vue.ref(exports.CheckoutStage.Customer);
+    const stages = vue.ref({
+        [exports.CheckoutStage.Customer]: {
+            active: false,
+            completed: false,
+        },
+        [exports.CheckoutStage.Delivery]: {
+            active: false,
+            completed: false,
+        },
+        [exports.CheckoutStage.Payments]: {
+            active: false,
+            completed: false,
+        },
+        [exports.CheckoutStage.Summary]: {
+            active: false,
+            completed: false,
+        },
+    });
+    const { order, settingsLoaded } = pinia.storeToRefs(useOrderStore());
+    const { loaded: customerLoaded } = pinia.storeToRefs(useCustomerStore());
+    const ready = vue.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 exports.CheckoutStage.Customer:
+                break;
+            case exports.CheckoutStage.Delivery:
+                stages.value.customer.completed = true;
+                break;
+            case exports.CheckoutStage.Payments:
+                stages.value.customer.completed = true;
+                stages.value.delivery.completed = true;
+                break;
+            case exports.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;
+        }
+    };
+    vue.watch(ready, () => {
+        if (!ready.value || order.value === null) {
+            return setStage(exports.CheckoutStage.Customer);
+        }
+        const detectors = useStageDetectors(order.value);
+        if (!detectors.hasCustomer()) {
+            return setStage(exports.CheckoutStage.Customer);
+        }
+        else if (!detectors.hasDelivery()) {
+            return setStage(exports.CheckoutStage.Delivery);
+        }
+        return setStage(exports.CheckoutStage.Payments);
+    }, { immediate: true });
+    return {
+        ready,
+        order,
+        stages,
+        currentStage,
+        setStage,
+    };
+}
+
+function useCheckoutConfirmation(order) {
+    const form = vue.ref({ code: '' });
+    const confirming = vue.ref(false);
+    const resending = vue.ref(false);
+    const credentials = vue.computed(() => ({
+        id: order.value.id,
+        token: order.value.token,
+    }));
+    const confirm = async () => {
+        if (confirming.value) {
+            return null;
+        }
+        else if (!form.value.code) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать код из SMS.');
+            return null;
+        }
+        confirming.value = true;
+        try {
+            return await api.confirmOrder(credentials.value, form.value);
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось подтвердить заказ.'));
+        }
+        finally {
+            confirming.value = false;
+        }
+        return null;
+    };
+    const resendCode = async () => {
+        if (resending.value) {
+            return;
+        }
+        resending.value = true;
+        try {
+            const result = await api.resendOrderConfirmationCode(credentials.value);
+            if (result.success) {
+                ui.useNotification('success', 'Код выслан', 'Код был повторно выслан на ваш телефон.');
+            }
+            else {
+                ui.useNotification('error', 'Ошибка', 'Не удалось выслать код подтверждения. Повторите попытку позднее.');
+            }
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось выслать код подтверждения.'));
+        }
+        finally {
+            resending.value = false;
+        }
+    };
+    return {
+        form,
+        confirming,
+        confirm,
+        resending,
+        resendCode,
+    };
+}
+
+function useCustomerCheckoutForm(emit) {
+    var _a;
+    const ready = vue.ref(false);
+    const saving = vue.ref(false);
+    const form = vue.ref({
+        phone: {
+            number: '',
+            country: 'RU',
+        },
+        first_name: '',
+        last_name: '',
+    });
+    const { customer } = pinia.storeToRefs(useCustomerStore());
+    const { order, credentials } = pinia.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) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать номер телефона.');
+            return;
+        }
+        else if (!form.value.first_name) {
+            ui.useNotification('error', 'Ошибка', 'Нужно указать имя.');
+            return;
+        }
+        saving.value = true;
+        try {
+            await api.setOrderCheckoutCustomer(credentials.value, form.value);
+            emit('completed');
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось сохранить контактные данные.'));
+        }
+        finally {
+            saving.value = false;
+        }
+    };
+    return {
+        ready,
+        saving,
+        customer,
+        form,
+        save,
+    };
+}
+
+function useTotalPrice() {
+    const { order } = pinia.storeToRefs(useOrderStore());
+    return {
+        totalPrice: vue.computed(() => { var _a; return (_a = order.value) === null || _a === void 0 ? void 0 : _a.total_price; }),
+        originalTotalPrice: vue.computed(() => { var _a; return (_a = order.value) === null || _a === void 0 ? void 0 : _a.original_total_price; }),
+        hasDiscount: vue.computed(() => { var _a; return (_a = order.value) === null || _a === void 0 ? void 0 : _a.has_discount; }),
+        discountDifference: vue.computed(() => { var _a; return (_a = order.value) === null || _a === void 0 ? void 0 : _a.discount_difference; }),
+    };
+}
+function useTotalQuantity() {
+    const { order } = pinia.storeToRefs(useOrderStore());
+    const quantity = vue.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 } = pinia.storeToRefs(useOrderStore());
+    const variants = vue.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 } = pinia.storeToRefs(useOrderStore());
+    const { add: addVariant, remove: removeVariant } = useOrderStore();
+    const loading = vue.ref(false);
+    const operation = vue.ref(null);
+    const orderVariant = vue.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 = vue.computed(() => (orderVariant.value ? orderVariant.value.quantity : 0));
+    const quantityModel = vue.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);
+            ui.useNotification('success', 'Товар удалён', `Товар${variant.value.name ? ` «${variant.value.name}»` : ''} удалён из корзины!`);
+        }
+        if (result) {
+            ui.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);
+    };
+    vue.watch(totalQuantity, () => {
+        quantityModel.value = totalQuantity.value;
+    });
+    vue.watch(quantityModel, lodashEs.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 = vue.ref([]);
+    const loaded = vue.ref(false);
+    if (!customer.value || !customer.value.id) {
+        loaded.value = true;
+    }
+    else {
+        api.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 = dateFns.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 } = pinia.storeToRefs(useOrderStore());
+    const { customer } = pinia.storeToRefs(useCustomerStore());
+    const { stocks, addressesResolver } = pinia.storeToRefs(useStoreStore());
+    const { addresses, loaded } = useCustomerAddresses(customer);
+    const { totalPrice } = useTotalPrice();
+    const ready = vue.computed(() => loaded.value);
+    const currentAddress = vue.computed(() => { var _a; return (_a = order.value) === null || _a === void 0 ? void 0 : _a.delivery_address; });
+    const saving = vue.ref(false);
+    const form = vue.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 = dateFns.format(Date.parse(order.value.deliver_at_local.iso), 'yyyy-MM-dd HH:mm');
+    }
+    const priceIsNotEnough = vue.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) {
+            ui.useNotification('error', 'Ошибка', errors[0]);
+            return;
+        }
+        saving.value = true;
+        try {
+            await api.setOrderCheckoutDelivery(credentials.value, data);
+            emit('completed');
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.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 = vue.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 = vue.ref(false);
+    const unpaidAmount = vue.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 api.getOrderBonusesPaymentPreview(credentials.value, bonuses.value);
+            unpaidAmount.value = preview.unpaid;
+            if (parseFloat(bonuses.value) > parseFloat(preview.bonuses.trimmed)) {
+                setBonuses(preview.bonuses.trimmed);
+                ui.useNotification('warning', 'Сумма бонусов изменена', 'Вы указали сумму бонусов, превышающую лимит списания. Мы изменили сумму на максимально доступную.');
+            }
+        }
+        catch (e) {
+            //
+        }
+        finally {
+            bonusesAreChecking.value = false;
+        }
+    };
+    vue.watch(bonuses, lodashEs.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 } = pinia.storeToRefs(useOrderStore());
+    const form = vue.ref({
+        method: getPaymentMethod(settings),
+        bill: '',
+        save_card: false,
+        bonuses: '',
+        card_token_id: '',
+    });
+    const saving = vue.ref(false);
+    const bonuses = vue.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 api.setOrderCheckoutPayment(credentials.value, { payments });
+            emit('completed');
+        }
+        catch (e) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось сохранить способ оплаты.'));
+        }
+        finally {
+            saving.value = false;
+        }
+    };
+    return {
+        form,
+        unpaidAmount,
+        bonusesAreChecking,
+        saving,
+        save,
+    };
+}
+
+function useCheckoutSummary(emit) {
+    const orderStore = useOrderStore();
+    const { credentials, settings } = pinia.storeToRefs(orderStore);
+    const { store, city } = pinia.storeToRefs(useStoreStore());
+    const form = vue.ref({
+        persons_count: '',
+        notes: '',
+    });
+    const hasPersonsCount = vue.computed(() => {
+        if (!settings.value) {
+            return false;
+        }
+        const index = settings.value.options.findIndex((option) => option.kind === 'persons_count');
+        return index !== -1;
+    });
+    const saving = vue.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 api.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) {
+            ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось оформить заказ.'));
+        }
+        finally {
+            saving.value = false;
+        }
+    };
+    return {
+        form,
+        hasPersonsCount,
+        saving,
+        save,
+    };
+}
+
+function useCheckoutTotal() {
+    const { credentials } = pinia.storeToRefs(useOrderStore());
+    const loading = vue.ref(false);
+    const total = vue.ref(null);
+    const load = async () => {
+        if (loading.value) {
+            return;
+        }
+        else if (!credentials.value) {
+            return;
+        }
+        loading.value = true;
+        try {
+            total.value = await api.getOrderCheckoutTotal(credentials.value);
+        }
+        catch (e) {
+            //
+        }
+        finally {
+            loading.value = false;
+        }
+    };
+    return {
+        loading,
+        load,
+        total,
+    };
+}
+
+function useSingleModifier(props, emit) {
+    const value = vue.computed({
+        get: () => props.modelValue,
+        set: (val) => emit('update:modelValue', val),
+    });
+    const checked = vue.computed({
+        get: () => value.value.quantity > 0,
+        set: (val) => {
+            value.value.quantity = val ? 1 : 0;
+        },
+    });
+    const shouldUseQuantityControls = vue.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 = vue.computed({
+        get: () => props.modelValue,
+        set: (val) => emit('update:modelValue', val),
+    });
+    const selectedModifier = vue.ref('');
+    const modifiers = vue.ref(getDefaultModifiersGroupModifiers(props.group, value));
+    const shouldUseQuantityControls = vue.computed(() => props.group.max_quantity > 1);
+    const totalSelectedCount = vue.computed(() => {
+        return value.value
+            .map((modifier) => modifier.quantity)
+            .reduce((current, total) => current + total, 0);
+    });
+    const limitReached = vue.computed(() => {
+        if (!shouldUseQuantityControls.value) {
+            return selectedModifier.value !== '';
+        }
+        return totalSelectedCount.value >= props.group.max_quantity;
+    });
+    const requiredModifierIsMissing = vue.computed(() => {
+        if (!props.group.is_required) {
+            return false;
+        }
+        else if (props.group.min_quantity === 0) {
+            return false;
+        }
+        return totalSelectedCount.value < props.group.min_quantity;
+    });
+    vue.watch(selectedModifier, (val) => {
+        if (!val) {
+            value.value = [];
+            return;
+        }
+        value.value = [{
+                modifiers_group_id: props.group.group.id,
+                modifier_id: val,
+                quantity: 1,
+            }];
+    });
+    vue.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 = vue.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 = vue.ref(getModifiers(product, variant));
+    const selectedModifiers = vue.computed(() => getSelectedModifiers(modifiers));
+    vue.watch(variant, () => {
+        modifiers.value = getModifiers(product, variant);
+    });
+    vue.watch(selectedModifiers, async () => {
+        const hash = await recalculate(selectedModifiers);
+        if (hash === null) {
+            return;
+        }
+        modifiersHash.value = hash;
+    });
+    return {
+        modifiers,
+        selectedModifiers,
+        modifiersHash,
+    };
+}
+
+async function recalculatePrice(variant, modifiers) {
+    if (!variant.value) {
+        return null;
+    }
+    else if (!modifiers.value.length) {
+        return null;
+    }
+    const { cityId } = pinia.storeToRefs(useStoreStore());
+    try {
+        return await api.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 = vue.ref(null);
+    const recalculating = vue.ref(false);
+    const totalPrice = vue.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 = vue.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 = vue.ref(getOptionsList(variants));
+    const selectedOptions = vue.ref({});
+    options.value.forEach((option) => {
+        selectedOptions.value[option.id] = option.values.length > 0 ? option.values[0].id : null;
+    });
+    const variant = vue.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(api.getProduct, getApiErrorHandler(errorHandler, function (e) {
+        ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Товар не найден.'));
+    }));
+}
+function useProductCard(item) {
+    var _a;
+    const product = vue.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 () => api.getProductsPricesRange(categoryId), getApiErrorHandler(errorHandler, function (e) {
         ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить диапазон цен.'));
@@ -1607,7 +2954,7 @@ function useProductsPricesRangeFilters(categoryId, values) {
     };
 }
 
-var ProductsSourceType;
+exports.ProductsSourceType = void 0;
 (function (ProductsSourceType) {
     ProductsSourceType["Category"] = "category";
     ProductsSourceType["Collection"] = "collection";
@@ -1615,20 +2962,20 @@ var ProductsSourceType;
     ProductsSourceType["GroupContext"] = "group_context";
     ProductsSourceType["VariantOptionContext"] = "variant_option_context";
     ProductsSourceType["VariantOptionValueContext"] = "variant_option_value_context";
-})(ProductsSourceType || (ProductsSourceType = {}));
-var ProductsSorting;
+})(exports.ProductsSourceType || (exports.ProductsSourceType = {}));
+exports.ProductsSorting = void 0;
 (function (ProductsSorting) {
     ProductsSorting["Manual"] = "manual";
     ProductsSorting["NameAsc"] = "name";
     ProductsSorting["NameDesc"] = "-name";
     ProductsSorting["PriceAsc"] = "price";
     ProductsSorting["PriceDesc"] = "-price";
-})(ProductsSorting || (ProductsSorting = {}));
-var ProductsFiltersType;
+})(exports.ProductsSorting || (exports.ProductsSorting = {}));
+exports.ProductsFiltersType = void 0;
 (function (ProductsFiltersType) {
     ProductsFiltersType["Features"] = "features";
     ProductsFiltersType["FeaturesGroups"] = "featuresGroups";
-})(ProductsFiltersType || (ProductsFiltersType = {}));
+})(exports.ProductsFiltersType || (exports.ProductsFiltersType = {}));
 
 function getSourceParams(source, promotion) {
     if (source === null || !source.id || !source.type) {
@@ -1638,26 +2985,26 @@ function getSourceParams(source, promotion) {
         return {};
     }
     switch (source.type) {
-        case ProductsSourceType.Category:
+        case exports.ProductsSourceType.Category:
             return { category_id: source.id };
-        case ProductsSourceType.Collection:
+        case exports.ProductsSourceType.Collection:
             return { collection_id: source.id };
-        case ProductsSourceType.CategoryContext:
+        case exports.ProductsSourceType.CategoryContext:
             return {
                 context_type: 'category',
                 context_id: source.id,
             };
-        case ProductsSourceType.GroupContext:
+        case exports.ProductsSourceType.GroupContext:
             return {
                 context_type: 'group',
                 context_id: source.id,
             };
-        case ProductsSourceType.VariantOptionContext:
+        case exports.ProductsSourceType.VariantOptionContext:
             return {
                 context_type: 'variant_option',
                 context_id: source.id,
             };
-        case ProductsSourceType.VariantOptionValueContext:
+        case exports.ProductsSourceType.VariantOptionValueContext:
             return {
                 context_type: 'variant_option_value',
                 context_id: source.id,
@@ -1671,11 +3018,11 @@ function getSortingParams(sorting) {
         return {};
     }
     switch (sorting) {
-        case ProductsSorting.Manual:
-        case ProductsSorting.NameAsc:
-        case ProductsSorting.NameDesc:
-        case ProductsSorting.PriceAsc:
-        case ProductsSorting.PriceDesc:
+        case exports.ProductsSorting.Manual:
+        case exports.ProductsSorting.NameAsc:
+        case exports.ProductsSorting.NameDesc:
+        case exports.ProductsSorting.PriceAsc:
+        case exports.ProductsSorting.PriceDesc:
             return { order_by: sorting };
         default:
             return {};
@@ -1751,7 +3098,7 @@ function getCategoryIdFromSource(source) {
     if (!source || !source.type || !source.id || source.error) {
         return null;
     }
-    else if (source.type !== ProductsSourceType.Category) {
+    else if (source.type !== exports.ProductsSourceType.Category) {
         return null;
     }
     return source.id;
@@ -1762,9 +3109,9 @@ function useProductsList(config, errorHandler) {
     }));
     const store = useStoreStore();
     const cityId = vue.computed(() => store.cityId);
-    const sorting = vue.ref(config.value.sorting || ProductsSorting.Manual);
+    const sorting = vue.ref(config.value.sorting || exports.ProductsSorting.Manual);
     const search = vue.ref(config.value.search || '');
-    const { filters, load: loadFilters, items: features, } = config.value.filtersType === ProductsFiltersType.Features
+    const { filters, load: loadFilters, items: features, } = config.value.filtersType === exports.ProductsFiltersType.Features
         ? useFeaturesFilters(getCategoryIdFromSource(config.value.source), config.value.filters)
         : useFeaturesGroupsFilters(getCategoryIdFromSource(config.value.source), config.value.filters);
     const { filters: pricesFilters, load: loadPricesRange, range, } = useProductsPricesRangeFilters(getCategoryIdFromSource(config.value.source), config.value.pricesFilters);
@@ -1940,23 +3287,140 @@ function getProductsSource(source) {
         return null;
     }
     switch (injected) {
-        case ProductsSourceType.Category:
+        case exports.ProductsSourceType.Category:
             return getInjectedSource(exports.ZenkyInjection.Category, exports.ZenkyInjection.CategoryNotFound, injected);
-        case ProductsSourceType.Collection:
+        case exports.ProductsSourceType.Collection:
             return getInjectedSource(exports.ZenkyInjection.Collection, exports.ZenkyInjection.CollectionNotFound, injected);
-        case ProductsSourceType.CategoryContext:
+        case exports.ProductsSourceType.CategoryContext:
             return getInjectedSource(exports.ZenkyInjection.CategoryContext, exports.ZenkyInjection.CategoryContextNotFound, injected);
-        case ProductsSourceType.GroupContext:
+        case exports.ProductsSourceType.GroupContext:
             return getInjectedSource(exports.ZenkyInjection.GroupContext, exports.ZenkyInjection.GroupContextNotFound, injected);
-        case ProductsSourceType.VariantOptionContext:
+        case exports.ProductsSourceType.VariantOptionContext:
             return getInjectedSource(exports.ZenkyInjection.VariantOptionContext, exports.ZenkyInjection.VariantOptionContextNotFound, injected);
-        case ProductsSourceType.VariantOptionValueContext:
+        case exports.ProductsSourceType.VariantOptionValueContext:
             return getInjectedSource(exports.ZenkyInjection.VariantOptionValueContext, exports.ZenkyInjection.VariantOptionValueContextNotFound, injected);
         default:
             return null;
     }
 }
 
+const usePromotionsStore = pinia.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() {
+            events.usePromotionsCheckerStarted().subscribe('storefront.promotions.initialize', () => this.setCheckerState(true));
+            events.usePromotionsCheckerCompleted().subscribe('storefront.promotions.initialize', (params) => this.setCheckerState(false, params && params.timeout === true));
+            events.useDisplayOrderPromotionRewardSelection().subscribe('storefront.promotions.initialize', ({ data }) => this.enableRewardsSelector(data));
+            events.useOrderPromotionsNotFound().subscribe('storefront.promotions.initialize', () => this.disableRewardsSelector());
+        },
+    },
+});
+
+function initializePromotions(order, timeout = 10000) {
+    const promotionsStore = usePromotionsStore();
+    promotionsStore.initialize();
+    const promotionsAreChecking = vue.computed(() => promotionsStore.checking);
+    let manualTimeout = undefined;
+    const checker = async () => {
+        if (promotionsAreChecking.value) {
+            return;
+        }
+        if (manualTimeout) {
+            clearTimeout(manualTimeout);
+        }
+        events.usePromotionsCheckerStarted().publish();
+        await api.checkCompletedPromotions({ id: order.id, token: order.token });
+        manualTimeout = setTimeout(() => {
+            if (promotionsAreChecking.value) {
+                events.usePromotionsCheckerCompleted().publish({ timeout: true });
+            }
+        }, timeout);
+    };
+    events.useProductQuantityIncreased().subscribe('promotions.init', checker);
+    events.useProductQuantityDecreased().subscribe('promotions.init', checker);
+    api.checkCompletedPromotions({ id: order.id, token: order.token }).then(() => {
+        console.log('[storefront/promotions] Promotions checker has been initialized.');
+    });
+}
+function useRewardsSelector() {
+    const promotionsStore = usePromotionsStore();
+    const selector = vue.computed(() => promotionsStore.selector);
+    const checking = vue.computed(() => promotionsStore.checking);
+    const failed = vue.computed(() => promotionsStore.failed);
+    const available = vue.computed(() => selector.value.available);
+    const collapsed = vue.computed(() => selector.value.closed);
+    const close = () => promotionsStore.closeRewardsSelector();
+    const open = () => promotionsStore.openRewardsSelector();
+    return {
+        checking,
+        failed,
+        available,
+        collapsed,
+        selector,
+        open,
+        close,
+    };
+}
+
 exports.ZenkyWebsocketEvent = void 0;
 (function (ZenkyWebsocketEvent) {
     ZenkyWebsocketEvent["OrderPriceRecalculated"] = "orders.price.recalculated";
@@ -2029,6 +3493,7 @@ exports.getApiErrorHandler = getApiErrorHandler;
 exports.getExistedAddress = getExistedAddress;
 exports.getExistedAddressDisplayValue = getExistedAddressDisplayValue;
 exports.getFirstMedium = getFirstMedium;
+exports.getProductVariantsPricesRange = getProductVariantsPricesRange;
 exports.getProductsListParamsFromQuery = getProductsListParamsFromQuery;
 exports.getProductsListQueryParams = getProductsListQueryParams;
 exports.getProductsPaginationRequest = getProductsPaginationRequest;
@@ -2038,7 +3503,10 @@ exports.getSelectedAddressDisplayValue = getSelectedAddressDisplayValue;
 exports.getStockAddress = getStockAddress;
 exports.getStockSchedule = getStockSchedule;
 exports.getStorage = getStorage;
+exports.getUpdatedVariants = getUpdatedVariants;
 exports.getWebsocketsConnection = getWebsocketsConnection;
+exports.initializeOrderCustomer = initializeOrderCustomer;
+exports.initializePromotions = initializePromotions;
 exports.subscribeToOrderEvents = subscribeToOrderEvents;
 exports.useAddressFormValue = useAddressFormValue;
 exports.useArticleCategoriesList = useArticleCategoriesList;
@@ -2046,22 +3514,29 @@ exports.useArticleItem = useArticleItem;
 exports.useArticlesList = useArticlesList;
 exports.useAuthenticationForm = useAuthenticationForm;
 exports.useAuthenticationStatusChecker = useAuthenticationStatusChecker;
+exports.useBillSuggestions = useBillSuggestions;
 exports.useCategories = useCategories;
 exports.useCategoriesStore = useCategoriesStore;
 exports.useCategoriesTree = useCategoriesTree;
 exports.useCategory = useCategory;
 exports.useCategoryFeaturesGroupsList = useCategoryFeaturesGroupsList;
 exports.useCategoryFeaturesList = useCategoryFeaturesList;
+exports.useCheckoutConfirmation = useCheckoutConfirmation;
+exports.useCheckoutSummary = useCheckoutSummary;
+exports.useCheckoutTotal = useCheckoutTotal;
 exports.useCollection = useCollection;
 exports.useCollections = useCollections;
 exports.useCollectionsStore = useCollectionsStore;
 exports.useCustomer = useCustomer;
+exports.useCustomerCheckoutForm = useCustomerCheckoutForm;
 exports.useCustomerStore = useCustomerStore;
 exports.useDadata = useDadata;
 exports.useDataDestroyer = useDataDestroyer;
 exports.useDataLoader = useDataLoader;
 exports.useDeliveryAddressDestroyer = useDeliveryAddressDestroyer;
 exports.useDeliveryAddressesList = useDeliveryAddressesList;
+exports.useDeliveryCheckoutForm = useDeliveryCheckoutForm;
+exports.useDeliveryPaymentsForm = useDeliveryPaymentsForm;
 exports.useEditAddressForm = useEditAddressForm;
 exports.useFeaturesFilters = useFeaturesFilters;
 exports.useFeaturesGroupsFilters = useFeaturesGroupsFilters;
@@ -2070,21 +3545,36 @@ exports.useItemLoader = useItemLoader;
 exports.useListLoader = useListLoader;
 exports.useLogin = useLogin;
 exports.useLogout = useLogout;
+exports.useModifiers = useModifiers;
+exports.useModifiersGroup = useModifiersGroup;
 exports.useOfferItem = useOfferItem;
 exports.useOffersList = useOffersList;
+exports.useOrderCheckout = useOrderCheckout;
 exports.useOrderItem = useOrderItem;
+exports.useOrderStore = useOrderStore;
+exports.useOrderVariants = useOrderVariants;
 exports.useOrdersList = useOrdersList;
 exports.usePaginatedLoader = usePaginatedLoader;
 exports.usePasswordReset = usePasswordReset;
 exports.usePaymentMethodDestroyer = usePaymentMethodDestroyer;
 exports.usePaymentMethodsList = usePaymentMethodsList;
 exports.usePhoneConfirmation = usePhoneConfirmation;
+exports.useProductCard = useProductCard;
+exports.useProductItem = useProductItem;
 exports.useProductsList = useProductsList;
 exports.useProductsPricesRange = useProductsPricesRange;
 exports.useProductsPricesRangeFilters = useProductsPricesRangeFilters;
+exports.usePromotionsStore = usePromotionsStore;
 exports.useRegistration = useRegistration;
 exports.useReversedTree = useReversedTree;
+exports.useRewardsSelector = useRewardsSelector;
+exports.useSingleModifier = useSingleModifier;
 exports.useSplittedCategoriesTree = useSplittedCategoriesTree;
 exports.useStateDataLoader = useStateDataLoader;
 exports.useStoreStore = useStoreStore;
 exports.useSuggestionsRestrictedToCity = useSuggestionsRestrictedToCity;
+exports.useTotalPrice = useTotalPrice;
+exports.useTotalQuantity = useTotalQuantity;
+exports.useVariant = useVariant;
+exports.useVariantControls = useVariantControls;
+exports.useVariantPrice = useVariantPrice;