@zenky/storefront-vue 0.9.35 → 0.9.39

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 }; }
@@ -579,7 +580,7 @@ const useCategoriesStore = pinia.defineStore({
             }
             this.loading = true;
             try {
-                this.tree = await api.getCategoriesTree({ visibility: 'visible', with: 'media' });
+                this.tree = await api.getCategoriesTree({ visibility: api.Visibility.Visible, with: 'media' });
                 this.loaded = true;
             }
             catch (e) {
@@ -754,7 +755,7 @@ const useCollectionsStore = pinia.defineStore({
             this.loading = true;
             try {
                 this.collections = (await api.getProductsCollections({
-                    visibility: 'visible',
+                    visibility: api.Visibility.Visible,
                     order_by: 'name',
                     with: 'media',
                     count: 100,
@@ -1556,6 +1557,970 @@ function useOfferItem(errorHandler) {
     }));
 }
 
+function getUpdatedVariants(currentOrder, order) {
+    var _a, _b;
+    if (!((_a = order === null || order === void 0 ? void 0 : order.variants) === null || _a === void 0 ? void 0 : _a.length)) {
+        return [];
+    }
+    else if (!((_b = currentOrder === null || currentOrder === void 0 ? void 0 : currentOrder.variants) === null || _b === void 0 ? void 0 : _b.length)) {
+        return (order === null || order === void 0 ? void 0 : order.variants) || [];
+    }
+    let current = 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 useProductsPricesRange(categoryId, errorHandler) {
     return useDataLoader(async () => api.getProductsPricesRange(categoryId), getApiErrorHandler(errorHandler, function (e) {
         ui.useNotification('error', 'Ошибка', api.getApiErrorMessage(e, 'Не удалось загрузить диапазон цен.'));
@@ -1957,6 +2922,123 @@ function getProductsSource(source) {
     }
 }
 
+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";
@@ -2038,7 +3120,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 +3131,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;
@@ -2072,7 +3164,10 @@ exports.useLogin = useLogin;
 exports.useLogout = useLogout;
 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;
@@ -2082,9 +3177,14 @@ exports.usePhoneConfirmation = usePhoneConfirmation;
 exports.useProductsList = useProductsList;
 exports.useProductsPricesRange = useProductsPricesRange;
 exports.useProductsPricesRangeFilters = useProductsPricesRangeFilters;
+exports.usePromotionsStore = usePromotionsStore;
 exports.useRegistration = useRegistration;
 exports.useReversedTree = useReversedTree;
+exports.useRewardsSelector = useRewardsSelector;
 exports.useSplittedCategoriesTree = useSplittedCategoriesTree;
 exports.useStateDataLoader = useStateDataLoader;
 exports.useStoreStore = useStoreStore;
 exports.useSuggestionsRestrictedToCity = useSuggestionsRestrictedToCity;
+exports.useTotalPrice = useTotalPrice;
+exports.useTotalQuantity = useTotalQuantity;
+exports.useVariantControls = useVariantControls;