@zenky/storefront-vue 0.9.44 → 0.9.46

package/dist/cjs/index.js

@@ -1,3725 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var vue = require('vue');
-var api = require('@zenky/api');
-var lodashEs = require('lodash-es');
-var pinia = require('pinia');
-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 }; }
-
-var Pusher__default = /*#__PURE__*/_interopDefaultLegacy(Pusher);
-
-function useDataDestroyer(destroyer, errorHandler) {
-    const destroying = vue.ref(false);
-    const destroy = async (id) => {
-        if (destroying.value) {
-            return false;
-        }
-        destroying.value = true;
-        try {
-            await destroyer(id);
-            return true;
-        }
-        catch (e) {
-            errorHandler({
-                e,
-                error: api.getApiError(e),
-                message: api.getApiErrorMessage(e),
-            });
-        }
-        finally {
-            destroying.value = false;
-        }
-        return false;
-    };
-    return {
-        destroying,
-        destroy,
-    };
-}
-
-function getApiErrorHandler(providedHandler, composableName, defaultMessage) {
-    if (typeof providedHandler === 'function') {
-        return providedHandler;
-    }
-    return function ({ e, error, message }) {
-        console.error(`[${composableName}] ${defaultMessage}`, {
-            message,
-            error,
-            e,
-        });
-        console.info(`[@zenky/storefront] Pass errorHandler argument to the ${composableName}() composable to properly handle this error.`);
-    };
-}
-
-exports.ZenkyInjection = void 0;
-(function (ZenkyInjection) {
-    ZenkyInjection["ProductsSource"] = "zenky:products:source";
-    ZenkyInjection["Category"] = "zenky:category";
-    ZenkyInjection["CategoryNotFound"] = "zenky:category:notFound";
-    ZenkyInjection["Collection"] = "zenky:collection";
-    ZenkyInjection["CollectionNotFound"] = "zenky:collection:notFound";
-    ZenkyInjection["Offer"] = "zenky:offer";
-    ZenkyInjection["OfferNotFound"] = "zenky:offer:notFound";
-    ZenkyInjection["CategoryContext"] = "zenky:context:category";
-    ZenkyInjection["CategoryContextNotFound"] = "zenky:context:category:notFound";
-    ZenkyInjection["GroupContext"] = "zenky:context:category";
-    ZenkyInjection["GroupContextNotFound"] = "zenky:context:category:notFound";
-    ZenkyInjection["VariantOptionContext"] = "zenky:context:variant_option";
-    ZenkyInjection["VariantOptionContextNotFound"] = "zenky:context:variant_option:notFound";
-    ZenkyInjection["VariantOptionValueContext"] = "zenky:context:variant_option_value";
-    ZenkyInjection["VariantOptionValueContextNotFound"] = "zenky:context:variant_option_value:notFound";
-})(exports.ZenkyInjection || (exports.ZenkyInjection = {}));
-
-async function useStateDataLoader(state, loader) {
-    if (state.value.loaded) {
-        // Data was already loaded, return it.
-        return state.value.data;
-    }
-    else if (state.value.loading) {
-        // If data is in loading state, return promise that will be resolved after data loaded.
-        return new Promise(function (resolve) {
-            const loaded = vue.computed(() => state.value.loaded);
-            const stop = vue.watch(loaded, function (val) {
-                if (val) {
-                    resolve(state.value.data);
-                    stop();
-                }
-            }, { immediate: true });
-        });
-    }
-    // Data is not loading nor was loaded, dispatch loader now.
-    await loader();
-    return state.value.data;
-}
-function usePaginatedLoader(provider, errorHandler) {
-    const state = vue.ref({
-        waiting: false,
-        loading: false,
-        loaded: false,
-    });
-    const pagination = vue.ref(null);
-    const items = vue.ref([]);
-    const load = async (request, reset = false) => {
-        if (state.value.loading) {
-            return;
-        }
-        if (reset) {
-            state.value.loaded = false;
-        }
-        state.value.loading = true;
-        if (!state.value.loaded) {
-            state.value.waiting = true;
-        }
-        try {
-            const { pagination: currentPagination, items: currentItems, } = await provider(request);
-            pagination.value = currentPagination;
-            if (reset) {
-                items.value = currentItems;
-            }
-            else {
-                currentItems.forEach((item) => items.value.push(item));
-            }
-        }
-        catch (e) {
-            errorHandler({
-                e,
-                error: api.getApiError(e),
-                message: api.getApiErrorMessage(e),
-            });
-        }
-        finally {
-            state.value.loading = false;
-            state.value.waiting = false;
-            state.value.loaded = true;
-        }
-    };
-    return {
-        state,
-        pagination,
-        items,
-        load,
-    };
-}
-function useListLoader(provider, errorHandler) {
-    const state = vue.ref({
-        loading: false,
-        loaded: false,
-    });
-    const items = vue.ref([]);
-    const load = async (request) => {
-        if (state.value.loading || state.value.loaded) {
-            return;
-        }
-        state.value.loading = true;
-        try {
-            items.value = await provider(request);
-        }
-        catch (e) {
-            errorHandler({
-                e,
-                error: api.getApiError(e),
-                message: api.getApiErrorMessage(e),
-            });
-        }
-        finally {
-            state.value.loading = false;
-            state.value.loaded = true;
-        }
-    };
-    return {
-        state,
-        items,
-        load,
-    };
-}
-function useItemLoader(provider, errorHandler) {
-    const state = vue.ref({
-        loading: false,
-        loaded: false,
-    });
-    const item = vue.ref(null);
-    const load = async (id, request) => {
-        if (state.value.loading || state.value.loaded) {
-            return;
-        }
-        state.value.loading = true;
-        try {
-            item.value = await provider(id, request);
-        }
-        catch (e) {
-            errorHandler({
-                e,
-                error: api.getApiError(e),
-                message: api.getApiErrorMessage(e),
-            });
-        }
-        finally {
-            state.value.loading = false;
-            state.value.loaded = true;
-        }
-    };
-    return {
-        state,
-        item,
-        load,
-    };
-}
-function useDataLoader(provider, errorHandler) {
-    const state = vue.ref({
-        loading: false,
-        loaded: false,
-    });
-    const data = vue.ref(null);
-    const load = async () => {
-        if (state.value.loading || state.value.loaded) {
-            return;
-        }
-        state.value.loading = true;
-        try {
-            data.value = await provider();
-        }
-        catch (e) {
-            errorHandler({
-                e,
-                error: api.getApiError(e),
-                message: api.getApiErrorMessage(e),
-            });
-        }
-        finally {
-            state.value.loading = false;
-            state.value.loaded = true;
-        }
-    };
-    return {
-        state,
-        data,
-        load,
-    };
-}
-
-let prefix = null;
-const getPrefixedKey = (key) => (prefix ? `${prefix}:${key}` : key);
-const storage = {
-    get(key, defaultValue) {
-        const item = localStorage.getItem(getPrefixedKey(key));
-        if (item === undefined || item === null) {
-            return defaultValue;
-        }
-        return JSON.parse(item).value;
-    },
-    set(key, value) {
-        localStorage.setItem(getPrefixedKey(key), JSON.stringify({ value }));
-    },
-    delete(key) {
-        this.set(key, null);
-    },
-};
-const createStorage = (storeId) => {
-    prefix = `zenky:storefront:${storeId}`;
-    return storage;
-};
-const getStorage = () => storage;
-
-function getDaDataEntityName(data, types) {
-    return types.find((type) => data[type] !== 'undefined' && data[type]);
-}
-function getHousePart(house) {
-    if (Number.isNaN(parseInt(house, 10))) {
-        return `${house}`;
-    }
-    return `д ${house}`;
-}
-function getSettlementPart(suggestion) {
-    const city = suggestion.city_with_type;
-    const area = suggestion.area_with_type;
-    const region = suggestion.region_with_type;
-    if (city) {
-        return city === suggestion.settlement_with_type
-            ? suggestion.settlement_with_type
-            : `${city}, ${suggestion.settlement_with_type}`;
-    }
-    else if (region && area) {
-        return `${region}, ${area}, ${suggestion.settlement_with_type}`;
-    }
-    else if (region) {
-        return `${region}, ${suggestion.settlement_with_type}`;
-    }
-    else if (area) {
-        return `${area}, ${suggestion.settlement_with_type}`;
-    }
-    return suggestion.settlement_with_type;
-}
-function getCityPart(suggestion) {
-    if (suggestion.settlement_with_type) {
-        return getSettlementPart(suggestion);
-    }
-    else if (suggestion.city_with_type) {
-        return suggestion.city_with_type;
-    }
-    return null;
-}
-
-function getStockSchedule(schedule) {
-    if (!schedule) {
-        return 'Закрыто';
-    }
-    else if (!schedule.today.open && schedule.today.next_open_at) {
-        return `Откроется ${schedule.today.next_open_at.short}`;
-    }
-    else if (!schedule.today.open) {
-        return 'Закрыто';
-    }
-    else if (!schedule.today.closing_at) {
-        return `Сегодня: ${schedule.today.hours[0]}`;
-    }
-    const diff = schedule.today.closing_at.timestamp - (new Date().getTime() / 1000);
-    const min = 60 * 60;
-    if (diff < min) {
-        return `Закроется ${schedule.today.closing_at.diff.toLowerCase()}`;
-    }
-    return `Сегодня: ${schedule.today.hours[0]}`;
-}
-function getStockAddress(stock) {
-    if (!stock || !stock.address) {
-        return null;
-    }
-    return stock.address.address;
-}
-
-const useStoreStore = pinia.defineStore({
-    id: 'zenky:storefront:store',
-    state: () => {
-        const storage = getStorage();
-        return {
-            loading: false,
-            loaded: false,
-            store: null,
-            storeId: window.zenky.storeId,
-            cityId: storage.get('cityId'),
-        };
-    },
-    getters: {
-        cities() {
-            if (!this.loaded || !this.store || !this.store.cities) {
-                return [];
-            }
-            return this.store.cities;
-        },
-        city() {
-            if (!this.cityId) {
-                return null;
-            }
-            return this.cities.find((city) => city.id === this.cityId) || null;
-        },
-        stocks() {
-            if (!this.city || !this.city.stocks) {
-                return [];
-            }
-            return this.city.stocks.filter((stock) => stock.visible);
-        },
-        settings() {
-            if (!this.store || !this.store.settings) {
-                return null;
-            }
-            return this.store.settings;
-        },
-        addressesResolver() {
-            if (!this.settings) {
-                return null;
-            }
-            return this.settings.addresses.resolver.id;
-        },
-        loyalty() {
-            if (!this.settings) {
-                return null;
-            }
-            return this.settings.loyalty;
-        },
-    },
-    actions: {
-        async loadStore(inclusions) {
-            if (this.loading || this.loaded) {
-                return;
-            }
-            try {
-                this.store = await api.getStore(inclusions);
-                this.loaded = true;
-            }
-            catch (e) {
-                //
-            }
-            finally {
-                this.loading = false;
-            }
-        },
-        selectDefaultCity() {
-            if (this.city) {
-                return this.city;
-            }
-            else if (!this.cities.length) {
-                return null;
-            }
-            return this.selectCity(this.cities[0].id);
-        },
-        selectCity(cityId) {
-            const city = this.cities.find((item) => item.id === cityId);
-            if (!city) {
-                return null;
-            }
-            const storage = getStorage();
-            storage.set('cityId', city.id);
-            this.cityId = city.id;
-            return city;
-        },
-    },
-});
-
-function useDadata() {
-    const { cityId } = pinia.storeToRefs(useStoreStore());
-    const query = vue.ref(null);
-    const loading = vue.ref(false);
-    const results = vue.ref([]);
-    vue.watch(query, lodashEs.debounce(async () => {
-        if (loading.value || !query.value || !cityId.value) {
-            return;
-        }
-        try {
-            loading.value = true;
-            const { suggestions } = await api.getAddressSuggestions({
-                query: query.value,
-                city_id: cityId.value,
-            });
-            results.value = suggestions;
-        }
-        catch (e) {
-            //
-        }
-        finally {
-            loading.value = false;
-        }
-    }, 500));
-    return {
-        query,
-        loading,
-        results,
-    };
-}
-function useSuggestionsRestrictedToCity(city) {
-    const restricted = vue.computed(() => {
-        if (!city) {
-            return false;
-        }
-        else if (!city.settings) {
-            return false;
-        }
-        return city.settings.addresses.restrict_suggestions
-            && city.settings.addresses.search_radius === null;
-    });
-    return {
-        restricted,
-    };
-}
-function getSelectedAddress(suggestion, house, block) {
-    const city = getCityPart(suggestion);
-    const street = suggestion[`${getDaDataEntityName(suggestion, ['street', 'settlement', 'city_district'])}_with_type`];
-    if (!city || !street) {
-        return null;
-    }
-    let address;
-    if (city !== street) {
-        address = `${city}, ${street}, ${getHousePart(house)}`;
-    }
-    else {
-        address = `${city}, ${getHousePart(house)}`;
-    }
-    if (block) {
-        address += ` ${block}`;
-    }
-    return address;
-}
-function getSelectedAddressDisplayValue(suggestion) {
-    const entityName = getDaDataEntityName(suggestion, ['street', 'settlement', 'city_district']);
-    if (entityName === null) {
-        throw new Error('Selected address does not have a single field that we qualify as "street"');
-    }
-    const entityWithType = suggestion[`${entityName}_with_type`];
-    const cityEntityName = getDaDataEntityName(suggestion, ['city', 'settlement']);
-    const cityEntityWithType = suggestion[`${cityEntityName}_with_type`];
-    return {
-        short: entityWithType,
-        full: cityEntityWithType === entityWithType ? cityEntityWithType : `${cityEntityWithType}, ${entityWithType}`,
-    };
-}
-function getExistedAddressDisplayValue(address, restrictedToCity) {
-    const query = [];
-    if (address.city && !restrictedToCity) {
-        query.push(address.city.full);
-    }
-    if (address.settlement && query.indexOf(address.settlement) === -1) {
-        query.push(address.settlement);
-    }
-    if (address.street && query.indexOf(address.street.full) === -1) {
-        query.push(address.street.full);
-    }
-    return query.join(', ');
-}
-function getExistedAddress(address, house, block) {
-    const pieces = getExistedAddressDisplayValue(address, false).split(',');
-    if (house) {
-        pieces.push(`д ${house}`);
-    }
-    if (block) {
-        pieces.push(Number.isNaN(parseInt(block, 10)) ? block : `к ${block}`);
-    }
-    return pieces.join(', ');
-}
-
-const getAddressForm = () => ({
-    suggestion: null,
-    id: '',
-    city: '',
-    street: '',
-    house: '',
-    block: '',
-    address: '',
-    apartment: '',
-    entrance: '',
-    floor: '',
-    has_intercom: true,
-});
-exports.AddressFormValueError = void 0;
-(function (AddressFormValueError) {
-    AddressFormValueError["DaDataSuggestionRequired"] = "dadata.suggestion_required";
-    AddressFormValueError["CityRequired"] = "plain.city_required";
-    AddressFormValueError["StreetRequired"] = "plain.street_required";
-    AddressFormValueError["HouseRequired"] = "plain.house_required";
-    AddressFormValueError["StockRequired"] = "stock_required";
-    AddressFormValueError["TableRequired"] = "table_required";
-})(exports.AddressFormValueError || (exports.AddressFormValueError = {}));
-function useAddressFormValue(form, resolver, address) {
-    const errors = [];
-    let data = {};
-    if (resolver === 'dadata') {
-        if (form.suggestion) {
-            data = {
-                address: getSelectedAddress(form.suggestion, form.house, form.block),
-                apartment: form.apartment,
-                entrance: form.entrance,
-                floor: form.floor,
-                has_intercom: lodashEs.isBoolean(form.has_intercom)
-                    ? form.has_intercom
-                    : form.has_intercom === 'true',
-            };
-        }
-        else if (address) {
-            data = {
-                address: getExistedAddress(address, form.house, form.block),
-                apartment: form.apartment,
-                entrance: form.entrance,
-                floor: form.floor,
-                has_intercom: lodashEs.isBoolean(form.has_intercom)
-                    ? form.has_intercom
-                    : form.has_intercom === 'true',
-            };
-        }
-        else {
-            errors.push(exports.AddressFormValueError.DaDataSuggestionRequired);
-        }
-    }
-    else if (resolver === 'plain') {
-        if (!form.city) {
-            errors.push(exports.AddressFormValueError.CityRequired);
-        }
-        else if (!form.street) {
-            errors.push(exports.AddressFormValueError.StreetRequired);
-        }
-        else if (!form.house) {
-            errors.push(exports.AddressFormValueError.HouseRequired);
-        }
-        else {
-            data = {
-                city: form.city,
-                street: form.street,
-                house: form.house,
-                block: form.block,
-                apartment: form.apartment,
-                entrance: form.entrance,
-                floor: form.floor,
-                has_intercom: lodashEs.isBoolean(form.has_intercom)
-                    ? form.has_intercom
-                    : form.has_intercom === 'true',
-            };
-        }
-    }
-    return {
-        data,
-        errors,
-    };
-}
-
-const useCategoriesStore = pinia.defineStore({
-    id: 'zenky:storefront:categories',
-    state: () => ({
-        loading: false,
-        loaded: false,
-        tree: [],
-        flatTree: null,
-    }),
-    actions: {
-        async load() {
-            if (this.loading || this.loaded) {
-                return;
-            }
-            this.loading = true;
-            try {
-                this.tree = await api.getCategoriesTree({ visibility: api.Visibility.Visible, with: 'media' });
-                this.loaded = true;
-            }
-            catch (e) {
-                //
-            }
-            finally {
-                this.loading = false;
-            }
-        },
-        setFlatTree(flatTree) {
-            this.flatTree = flatTree;
-        },
-    },
-});
-
-async function getTree() {
-    const store = useCategoriesStore();
-    const state = vue.computed(() => ({
-        loaded: store.loaded,
-        loading: store.loading,
-        data: store.tree,
-    }));
-    return useStateDataLoader(state, async () => store.load());
-}
-
-const findCategory = (items, id) => {
-    for (let i = 0; i < items.length; ++i) {
-        if (items[i].id === id || items[i].short_id === id) {
-            return items[i];
-        }
-        const children = findCategory(items[i].children, id);
-        if (children !== null) {
-            return children;
-        }
-    }
-    return null;
-};
-function useCategories() {
-    const categories = vue.ref([]);
-    const load = async (ids) => {
-        const tree = await getTree();
-        ids.forEach((id) => {
-            const category = findCategory(tree, id);
-            if (category !== null) {
-                categories.value.push(category);
-            }
-        });
-    };
-    return {
-        categories,
-        load,
-    };
-}
-function useCategory() {
-    const category = vue.ref(null);
-    const load = async (id) => {
-        const tree = await getTree();
-        category.value = findCategory(tree, id);
-    };
-    return {
-        category,
-        load,
-    };
-}
-
-const generateFlatTree = (flat, categories, append = '') => {
-    categories.forEach((category) => {
-        flat.push({
-            ...category,
-            children: [],
-            name: `${append}${category.name}`,
-            original_name: category.name,
-        });
-        if (category.children.length > 0) {
-            generateFlatTree(flat, category.children, `${append}${category.name} / `);
-        }
-    });
-};
-function useFlatCategoriesTree() {
-    const tree = vue.ref([]);
-    const load = async () => {
-        const store = useCategoriesStore();
-        if (store.flatTree !== null) {
-            tree.value = store.flatTree;
-            return;
-        }
-        const flat = [];
-        generateFlatTree(flat, await getTree());
-        store.setFlatTree(flat);
-        tree.value = flat;
-    };
-    return {
-        tree,
-        load,
-    };
-}
-
-const findReversedCategories = (id, stack, categories) => {
-    for (let i = 0; i < categories.length; ++i) {
-        if (categories[i].id === id || categories[i].short_id === id) {
-            return {
-                category: categories[i],
-                stack,
-            };
-        }
-        stack.push(categories[i]);
-        const children = findReversedCategories(id, stack, categories[i].children);
-        if (children !== null) {
-            return children;
-        }
-        else {
-            stack.pop();
-        }
-    }
-    return null;
-};
-function useReversedTree() {
-    const tree = vue.ref([]);
-    const load = async (id) => {
-        const stack = [];
-        const result = findReversedCategories(id, stack, await getTree());
-        if (result === null) {
-            return;
-        }
-        tree.value = [...result.stack, result.category];
-    };
-    return {
-        tree,
-        load,
-    };
-}
-
-function useSplittedCategoriesTree() {
-    const visible = vue.ref([]);
-    const hidden = vue.ref([]);
-    const load = async (split) => {
-        const tree = await getTree();
-        const unrefSplit = vue.unref(split);
-        visible.value = tree.slice(0, unrefSplit);
-        hidden.value = tree.slice(unrefSplit);
-    };
-    return {
-        visible,
-        hidden,
-        load,
-    };
-}
-
-function useCategoriesTree() {
-    const tree = vue.ref([]);
-    const load = async () => {
-        tree.value = await getTree();
-    };
-    return {
-        tree,
-        load,
-    };
-}
-
-const useCollectionsStore = pinia.defineStore({
-    id: 'zenky:storefront:collections',
-    state: () => ({
-        loading: false,
-        loaded: false,
-        collections: [],
-    }),
-    actions: {
-        async load() {
-            if (this.loading || this.loaded) {
-                return;
-            }
-            this.loading = true;
-            try {
-                this.collections = (await api.getProductsCollections({
-                    visibility: api.Visibility.Visible,
-                    order_by: 'name',
-                    with: 'media',
-                    count: 100,
-                })).items;
-                this.loaded = true;
-            }
-            catch (e) {
-                //
-            }
-            finally {
-                this.loading = false;
-            }
-        },
-    },
-});
-
-async function getCollections() {
-    const store = useCollectionsStore();
-    const state = vue.computed(() => ({
-        loaded: store.loaded,
-        loading: store.loading,
-        data: store.collections,
-    }));
-    return useStateDataLoader(state, async () => store.load());
-}
-function useCollections() {
-    const collections = vue.ref([]);
-    const load = async (ids = null) => {
-        collections.value = [];
-        const items = await getCollections();
-        if (ids === null) {
-            collections.value = items;
-        }
-        else if (Array.isArray(ids)) {
-            collections.value = items.filter((collection) => ids.indexOf(collection.id) !== -1);
-        }
-    };
-    return {
-        collections,
-        load,
-    };
-}
-function useCollection() {
-    const collection = vue.ref(null);
-    const load = async (id) => {
-        collection.value = null;
-        const items = await getCollections();
-        const index = items.findIndex((item) => item.id === id);
-        if (index !== -1) {
-            collection.value = items[index];
-        }
-    };
-    return {
-        collection,
-        load,
-    };
-}
-
-function useCategoryFeaturesList(categoryId, errorHandler) {
-    return useListLoader(async function () {
-        if (!categoryId) {
-            return [];
-        }
-        return api.getCategoryFeatures(categoryId);
-    }, getApiErrorHandler(errorHandler, 'useCategoryFeaturesList', 'Unable to load category features list.'));
-}
-function useCategoryFeaturesGroupsList(categoryId, errorHandler) {
-    return useListLoader(async function () {
-        if (!categoryId) {
-            return [];
-        }
-        return api.getCategoryFeaturesGroups(categoryId);
-    }, getApiErrorHandler(errorHandler, 'useCategoryFeaturesGroupsList', 'Unable to load category features groups list.'));
-}
-
-function useArticlesList(errorHandler) {
-    return usePaginatedLoader(api.getArticles, getApiErrorHandler(errorHandler, 'useArticlesList', 'Unable to load articles list.'));
-}
-function useArticleCategoriesList(errorHandler) {
-    return usePaginatedLoader(api.getArticleCategories, getApiErrorHandler(errorHandler, 'useArticleCategoriesList', 'Unable to load article categories list.'));
-}
-function useArticleItem(errorHandler) {
-    return useItemLoader(api.getArticle, getApiErrorHandler(errorHandler, 'useArticleItem', 'Unable to load article.'));
-}
-
-exports.AuthenticationStage = void 0;
-(function (AuthenticationStage) {
-    AuthenticationStage["Check"] = "check";
-    AuthenticationStage["Login"] = "login";
-    AuthenticationStage["Register"] = "register";
-    AuthenticationStage["Confirmation"] = "confirmation";
-})(exports.AuthenticationStage || (exports.AuthenticationStage = {}));
-exports.AuthenticationEvent = void 0;
-(function (AuthenticationEvent) {
-    AuthenticationEvent["Stage"] = "stage";
-    AuthenticationEvent["Completed"] = "completed";
-})(exports.AuthenticationEvent || (exports.AuthenticationEvent = {}));
-exports.AuthenticationResultType = void 0;
-(function (AuthenticationResultType) {
-    AuthenticationResultType["Validation"] = "validation";
-    AuthenticationResultType["Failed"] = "failed";
-    AuthenticationResultType["Completed"] = "completed";
-    AuthenticationResultType["Stage"] = "stage";
-})(exports.AuthenticationResultType || (exports.AuthenticationResultType = {}));
-exports.AuthenticationFailureReason = void 0;
-(function (AuthenticationFailureReason) {
-    AuthenticationFailureReason["ApiError"] = "api_error";
-    AuthenticationFailureReason["InProgress"] = "in_progress";
-    AuthenticationFailureReason["Cooldown"] = "cooldown";
-    AuthenticationFailureReason["PhoneRequired"] = "phone_required";
-    AuthenticationFailureReason["PasswordRequired"] = "password_required";
-    AuthenticationFailureReason["CodeRequired"] = "code_required";
-})(exports.AuthenticationFailureReason || (exports.AuthenticationFailureReason = {}));
-exports.AddressResultType = void 0;
-(function (AddressResultType) {
-    AddressResultType["Failed"] = "failed";
-    AddressResultType["Completed"] = "completed";
-})(exports.AddressResultType || (exports.AddressResultType = {}));
-exports.AddressResultReason = void 0;
-(function (AddressResultReason) {
-    AddressResultReason["InProgress"] = "in_progress";
-    AddressResultReason["Validation"] = "validation";
-    AddressResultReason["ApiError"] = "api_error";
-})(exports.AddressResultReason || (exports.AddressResultReason = {}));
-
-function useAuthenticationStatusChecker(form, emit) {
-    const active = vue.ref(false);
-    const check = async () => {
-        if (active.value) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.InProgress,
-            };
-        }
-        else if (!form.value.phone.number || !form.value.phone.country) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PhoneRequired,
-            };
-        }
-        active.value = true;
-        try {
-            const status = await api.getAuthenticationStatus(form.value.phone);
-            if (!status.registered) {
-                emit(exports.AuthenticationEvent.Stage, exports.AuthenticationStage.Register);
-                return {
-                    type: exports.AuthenticationResultType.Stage,
-                    data: exports.AuthenticationStage.Register,
-                };
-            }
-            else if (!status.confirmed) {
-                emit(exports.AuthenticationEvent.Stage, exports.AuthenticationStage.Confirmation);
-                return {
-                    type: exports.AuthenticationResultType.Stage,
-                    data: exports.AuthenticationStage.Confirmation,
-                };
-            }
-            emit(exports.AuthenticationEvent.Stage, exports.AuthenticationStage.Login);
-            return {
-                type: exports.AuthenticationResultType.Stage,
-                data: exports.AuthenticationStage.Login,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.ApiError,
-                error: api.getApiError(e),
-            };
-        }
-        finally {
-            active.value = false;
-        }
-    };
-    return {
-        active,
-        check,
-    };
-}
-
-function useAuthenticationForm() {
-    const stage = vue.ref(exports.AuthenticationStage.Check);
-    const form = vue.ref({
-        phone: {
-            number: '',
-            country: '',
-        },
-        password: '',
-        confirmation_code: '',
-    });
-    const reset = () => {
-        form.value.phone.country = 'RU';
-        form.value.phone.number = '';
-        form.value.password = '';
-        form.value.confirmation_code = '';
-        stage.value = exports.AuthenticationStage.Check;
-    };
-    return {
-        stage,
-        form,
-        reset,
-    };
-}
-
-const useCustomerStore = pinia.defineStore({
-    id: 'zenky:storefront:customer',
-    state: () => ({
-        inclusions: '',
-        loading: false,
-        loaded: false,
-        token: null,
-        customer: null,
-    }),
-    actions: {
-        async initialize(inclusions) {
-            this.inclusions = inclusions;
-            const storage = getStorage();
-            this.token = storage.get('customer.token', null);
-            this.loaded = false;
-            if (!this.token) {
-                this.loaded = true;
-                return;
-            }
-            return this.load();
-        },
-        async load() {
-            if (this.loading || !this.token) {
-                return null;
-            }
-            this.loading = true;
-            try {
-                api.setAxiosToken(this.token);
-                this.customer = await api.getCustomerProfile(this.inclusions);
-                events.useCustomerLoaded().publish({ customer: this.customer });
-                return this.customer;
-            }
-            catch (e) {
-                api.setAxiosToken();
-            }
-            finally {
-                this.loading = false;
-                this.loaded = true;
-            }
-            return null;
-        },
-        async setToken(token) {
-            this.token = token;
-            const storage = getStorage();
-            storage.set('customer.token', token);
-            const customer = await this.load();
-            events.useCustomerAuthenticated().publish({ customer });
-            return customer;
-        },
-        logout() {
-            this.token = null;
-            this.customer = null;
-            const storage = getStorage();
-            storage.delete('customer.token');
-            api.setAxiosToken();
-            events.useCustomerLoggedOut().publish();
-        },
-    },
-});
-
-function useLogin(form, emit) {
-    const active = vue.ref(false);
-    const login = async () => {
-        if (active.value) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.InProgress,
-            };
-        }
-        else if (!form.value.phone.number || !form.value.phone.country) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PhoneRequired,
-            };
-        }
-        else if (!form.value.password) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PasswordRequired,
-            };
-        }
-        active.value = true;
-        try {
-            const { token } = await api.login({ number: form.value.phone.number, country: form.value.phone.country }, form.value.password);
-            const { setToken } = useCustomerStore();
-            const customer = await setToken(token);
-            emit(exports.AuthenticationEvent.Completed);
-            return {
-                type: exports.AuthenticationResultType.Completed,
-                data: customer,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.ApiError,
-                error: api.getApiError(e),
-            };
-        }
-        finally {
-            active.value = false;
-        }
-    };
-    return {
-        active,
-        login,
-    };
-}
-
-function useLogout() {
-    const logout = () => {
-        const store = useCustomerStore();
-        store.logout();
-    };
-    return {
-        logout,
-    };
-}
-
-function pluralize(value, choices, prependWithValue = true) {
-    const word1 = choices[0];
-    const word2 = choices[1];
-    const word5 = choices[2];
-    if (!Number.isInteger(value)) {
-        return prependWithValue ? `${value} ${word2}` : word2;
-    }
-    let n = value % 100;
-    if (n >= 5 && n <= 20) {
-        return prependWithValue ? `${value} ${word5}` : word5;
-    }
-    if (n > 19) {
-        n %= 10;
-    }
-    if (n > 4 || n === 0) {
-        return prependWithValue ? `${value} ${word5}` : word5;
-    }
-    if (n === 1) {
-        return prependWithValue ? `${value} ${word1}` : word1;
-    }
-    return prependWithValue ? `${value} ${word2}` : word2;
-}
-
-const useTimer = (cooldown) => {
-    const seconds = vue.ref(0);
-    const label = vue.computed(() => pluralize(seconds.value, ['секунду', 'секунды', 'секунд']));
-    let timerInterval;
-    const start = () => {
-        clearInterval(timerInterval);
-        seconds.value = cooldown;
-        timerInterval = setInterval(() => {
-            seconds.value -= 1;
-            if (seconds.value === 0) {
-                clearInterval(timerInterval);
-            }
-        }, 1000);
-    };
-    const stop = () => {
-        clearInterval(timerInterval);
-    };
-    return {
-        seconds,
-        label,
-        start,
-        stop,
-    };
-};
-
-function useRequest(form, active) {
-    const { seconds, label, start } = useTimer(60);
-    const sent = vue.ref(false);
-    const request = async () => {
-        if (active.value) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.InProgress,
-            };
-        }
-        else if (seconds.value > 0) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.Cooldown,
-            };
-        }
-        else if (!form.value.phone.number || !form.value.phone.country) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PhoneRequired,
-            };
-        }
-        active.value = true;
-        try {
-            await api.requestPasswordResetCode(form.value.phone);
-            sent.value = true;
-            start();
-            return {
-                type: exports.AuthenticationResultType.Completed,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.ApiError,
-                error: api.getApiError(e),
-            };
-        }
-        finally {
-            active.value = false;
-        }
-    };
-    return {
-        seconds,
-        label,
-        request,
-        sent,
-    };
-}
-function useReset(form, active, emit) {
-    const reset = async () => {
-        if (active.value) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.InProgress,
-            };
-        }
-        else if (!form.value.phone.number || !form.value.phone.country) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PhoneRequired,
-            };
-        }
-        else if (!form.value.password) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PasswordRequired,
-            };
-        }
-        else if (!form.value.confirmation_code) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.CodeRequired,
-            };
-        }
-        active.value = true;
-        try {
-            const result = await api.resetPassword(form.value.phone, form.value.confirmation_code, form.value.password);
-            const store = useCustomerStore();
-            await store.setToken(result.token);
-            emit(exports.AuthenticationEvent.Completed);
-            return {
-                type: exports.AuthenticationResultType.Completed,
-                data: result.customer,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.ApiError,
-                error: api.getApiError(e),
-            };
-        }
-        finally {
-            active.value = false;
-        }
-    };
-    return {
-        reset,
-    };
-}
-function usePasswordReset(form, emit) {
-    const active = vue.ref(false);
-    const { request, sent, seconds, label } = useRequest(form, active);
-    const { reset } = useReset(form, active, emit);
-    return {
-        active,
-        sent,
-        seconds,
-        label,
-        request,
-        reset,
-    };
-}
-
-function useRegistration(form, emit) {
-    const active = vue.ref(false);
-    const register = async () => {
-        if (active.value) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.InProgress,
-            };
-        }
-        else if (!form.value.phone.number || !form.value.phone.country) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PhoneRequired,
-            };
-        }
-        else if (!form.value.password) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PasswordRequired,
-            };
-        }
-        active.value = true;
-        try {
-            const result = await api.register(form.value.phone, form.value.password);
-            if (!result.confirmation_required) {
-                emit(exports.AuthenticationEvent.Completed);
-                return {
-                    type: exports.AuthenticationResultType.Completed,
-                };
-            }
-            emit(exports.AuthenticationEvent.Stage, exports.AuthenticationStage.Confirmation);
-            return {
-                type: exports.AuthenticationResultType.Stage,
-                data: exports.AuthenticationStage.Confirmation,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.ApiError,
-                error: api.getApiError(e),
-            };
-        }
-        finally {
-            active.value = false;
-        }
-    };
-    return {
-        active,
-        register,
-    };
-}
-
-function useResend(form, active) {
-    const { seconds, label, start } = useTimer(60);
-    const resend = async () => {
-        if (active.value) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.InProgress,
-            };
-        }
-        else if (seconds.value > 0) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.Cooldown,
-            };
-        }
-        else if (!form.value.phone.number || !form.value.phone.country) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PhoneRequired,
-            };
-        }
-        active.value = true;
-        try {
-            await api.resendConfirmationCode(form.value.phone);
-            start();
-            return {
-                type: exports.AuthenticationResultType.Completed,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.ApiError,
-                error: api.getApiError(e),
-            };
-        }
-        finally {
-            active.value = false;
-        }
-    };
-    return {
-        seconds,
-        label,
-        start,
-        resend,
-    };
-}
-function useConfirm(form, active, emit) {
-    const confirm = async (withPassword = false) => {
-        if (active.value) {
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.InProgress,
-            };
-        }
-        else if (!form.value.phone.number || !form.value.phone.country) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PhoneRequired,
-            };
-        }
-        else if (!form.value.confirmation_code) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.CodeRequired,
-            };
-        }
-        else if (withPassword && !form.value.password) {
-            return {
-                type: exports.AuthenticationResultType.Validation,
-                reason: exports.AuthenticationFailureReason.PasswordRequired,
-            };
-        }
-        active.value = true;
-        try {
-            const result = await api.confirm(form.value.phone, form.value.confirmation_code, withPassword ? form.value.password : null);
-            const store = useCustomerStore();
-            await store.setToken(result.token);
-            emit(exports.AuthenticationEvent.Completed);
-            return {
-                type: exports.AuthenticationResultType.Completed,
-                data: result.customer,
-            };
-        }
-        catch (e) {
-            if (api.getApiErrorCode(e) === 'auth.registration.password_required') {
-                return {
-                    type: exports.AuthenticationResultType.Validation,
-                    reason: exports.AuthenticationFailureReason.PasswordRequired,
-                };
-            }
-            return {
-                type: exports.AuthenticationResultType.Failed,
-                reason: exports.AuthenticationFailureReason.ApiError,
-                error: api.getApiError(e),
-            };
-        }
-        finally {
-            active.value = false;
-        }
-    };
-    return {
-        confirm,
-    };
-}
-const usePhoneConfirmation = (form, emit) => {
-    const active = vue.ref(false);
-    const { seconds, label, start, resend } = useResend(form, active);
-    const { confirm } = useConfirm(form, active, emit);
-    return {
-        active,
-        seconds,
-        label,
-        start,
-        resend,
-        confirm,
-    };
-};
-
-function useDeliveryAddressesList(errorHandler) {
-    return usePaginatedLoader(api.getCustomerAddresses, getApiErrorHandler(errorHandler, 'useDeliveryAddressesList', 'Unable to load delivery addresses list.'));
-}
-function useDeliveryAddressDestroyer(errorHandler) {
-    return useDataDestroyer(api.deleteAddress, getApiErrorHandler(errorHandler, 'useDeliveryAddressDestroyer', 'Unable to delete delivery address.'));
-}
-function useEditAddressForm(address) {
-    var _a, _b;
-    const addressFields = address.resolver === 'plain' ? {
-        id: address.id,
-        name: address.name,
-        city: (_a = address === null || address === void 0 ? void 0 : address.city) === null || _a === void 0 ? void 0 : _a.short,
-        street: (_b = address === null || address === void 0 ? void 0 : address.street) === null || _b === void 0 ? void 0 : _b.short,
-        house: address.house,
-        block: address.block || '',
-        apartment: address.apartment,
-        entrance: address.entrance,
-        floor: address.floor,
-        has_intercom: address.has_intercom,
-    } : {
-        id: address.id,
-        name: address.name,
-        address: getExistedAddressDisplayValue(address, false),
-        house: address.house,
-        block: address.block || '',
-        apartment: address.apartment,
-        entrance: address.entrance,
-        floor: address.floor,
-        has_intercom: address.has_intercom,
-    };
-    const saving = vue.ref(false);
-    const form = vue.ref(addressFields);
-    const save = async () => {
-        if (saving.value) {
-            return {
-                type: exports.AddressResultType.Failed,
-                reason: exports.AddressResultReason.InProgress,
-            };
-        }
-        const { errors, data } = useAddressFormValue(form.value, address.resolver, address);
-        if (errors.length > 0) {
-            return {
-                type: exports.AddressResultType.Failed,
-                reason: exports.AddressResultReason.Validation,
-                data: errors,
-            };
-        }
-        saving.value = true;
-        try {
-            await api.updateAddress(address.id, {
-                delivery_address: {
-                    ...data,
-                    name: form.value.name,
-                },
-            });
-            return {
-                type: exports.AddressResultType.Completed,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.AddressResultType.Failed,
-                reason: exports.AddressResultReason.ApiError,
-                error: api.getApiError(e),
-            };
-        }
-        finally {
-            saving.value = false;
-        }
-    };
-    return {
-        form,
-        saving,
-        save,
-    };
-}
-
-function useCustomer() {
-    const store = useCustomerStore();
-    const customer = vue.computed(() => store.customer);
-    const loaded = vue.computed(() => store.loaded);
-    return {
-        customer,
-        loaded,
-    };
-}
-
-function useOrdersList(errorHandler) {
-    return usePaginatedLoader(api.getCustomerOrders, getApiErrorHandler(errorHandler, 'useOrdersList', 'Unable to load orders list.'));
-}
-function useOrderItem(errorHandler) {
-    return useItemLoader(api.getOrder, getApiErrorHandler(errorHandler, 'useOrderItem', 'Unable to load order.'));
-}
-
-function usePaymentMethodsList(errorHandler) {
-    return usePaginatedLoader(api.getCustomerPaymentMethods, getApiErrorHandler(errorHandler, 'usePaymentMethodsList', 'Unable to load payment methods.'));
-}
-function usePaymentMethodDestroyer(errorHandler) {
-    return useDataDestroyer(api.deleteCustomerPaymentMethod, getApiErrorHandler(errorHandler, 'usePaymentMethodDestroyer', 'Unable to delete payment method.'));
-}
-
-function getFirstMedium(media, sizes = ['large', 'medium'], preferWebp = true) {
-    const medium = Array.isArray(media) ? media[0] : media;
-    if (!medium || !medium.images) {
-        return null;
-    }
-    const sizesMap = {
-        'placeholder': api.ImageType.Placeholder,
-        'placeholder_webp': api.ImageType.PlaceholderWebp,
-        'thumb': api.ImageType.Thumb,
-        'thumb_webp': api.ImageType.ThumbWebp,
-        'medium': api.ImageType.Medium,
-        'medium_webp': api.ImageType.MediumWebp,
-        'large': api.ImageType.Large,
-        'large_webp': api.ImageType.LargeWebp,
-        'xlarge': api.ImageType.XLarge,
-        'xlarge_webp': api.ImageType.XLargeWebp,
-        'hd': api.ImageType.HD,
-        'hd_webp': api.ImageType.HDWebp,
-    };
-    const images = [];
-    sizes.forEach((size) => {
-        const webpImage = medium.images[sizesMap[`${size}_webp`]];
-        if (preferWebp && webpImage) {
-            images.push(webpImage);
-            return;
-        }
-        const jpegImage = medium.images[sizesMap[size]];
-        if (jpegImage) {
-            images.push(jpegImage);
-        }
-    });
-    return images.length > 0 ? images[0] : null;
-}
-
-function useOffersList(errorHandler) {
-    return usePaginatedLoader(api.getOffers, getApiErrorHandler(errorHandler, 'useOffersList', 'Unable to load offers list.'));
-}
-function useOfferItem(errorHandler) {
-    return useItemLoader(api.getOffer, getApiErrorHandler(errorHandler, 'useOfferItem', 'Unable to load offer.'));
-}
-
-exports.OrderCheckoutResultType = void 0;
-(function (OrderCheckoutResultType) {
-    OrderCheckoutResultType["Validation"] = "validation";
-    OrderCheckoutResultType["Completed"] = "completed";
-    OrderCheckoutResultType["Failed"] = "failed";
-})(exports.OrderCheckoutResultType || (exports.OrderCheckoutResultType = {}));
-exports.OrderCheckoutResultReason = void 0;
-(function (OrderCheckoutResultReason) {
-    OrderCheckoutResultReason["InProgress"] = "in_progress";
-    OrderCheckoutResultReason["Cooldown"] = "cooldown";
-    OrderCheckoutResultReason["ApiError"] = "api_error";
-    OrderCheckoutResultReason["OrderNotReady"] = "order_not_ready";
-    OrderCheckoutResultReason["PhoneRequired"] = "phone_required";
-    OrderCheckoutResultReason["FirstNameRequired"] = "first_name_required";
-    OrderCheckoutResultReason["CodeRequired"] = "code_required";
-    OrderCheckoutResultReason["AddressError"] = "address_error";
-})(exports.OrderCheckoutResultReason || (exports.OrderCheckoutResultReason = {}));
-exports.BillSuggestionType = void 0;
-(function (BillSuggestionType) {
-    BillSuggestionType["Bill"] = "bill";
-    BillSuggestionType["NoChange"] = "no_change";
-    BillSuggestionType["Custom"] = "custom";
-})(exports.BillSuggestionType || (exports.BillSuggestionType = {}));
-
-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) {
-                events.useOrderInitializationFailed().publish({
-                    error: api.getApiError(e),
-                });
-            }
-            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) {
-                events.useProductQuantityIncreaseFailed().publish({
-                    error: api.getApiError(e),
-                    order: this.order,
-                    productVariantId,
-                    quantity,
-                    modifiers,
-                    promotion,
-                });
-            }
-            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) {
-                events.useProductQuantityDecreaseFailed().publish({
-                    error: api.getApiError(e),
-                    order: this.order,
-                    productVariantId,
-                    quantity,
-                    modifiers,
-                    promotion,
-                });
-            }
-            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 {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.InProgress,
-            };
-        }
-        else if (!form.value.code) {
-            return {
-                type: exports.OrderCheckoutResultType.Validation,
-                reason: exports.OrderCheckoutResultReason.CodeRequired,
-            };
-        }
-        confirming.value = true;
-        try {
-            const response = await api.confirmOrder(credentials.value, form.value);
-            return {
-                type: exports.OrderCheckoutResultType.Completed,
-                data: response,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.ApiError,
-                error: api.getApiError(e),
-            };
-        }
-        finally {
-            confirming.value = false;
-        }
-    };
-    const resendCode = async () => {
-        if (resending.value) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.InProgress,
-            };
-        }
-        resending.value = true;
-        try {
-            const result = await api.resendOrderConfirmationCode(credentials.value);
-            if (result.success) {
-                return {
-                    type: exports.OrderCheckoutResultType.Completed,
-                };
-            }
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.Cooldown,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.ApiError,
-                error: api.getApiError(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 {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.OrderNotReady,
-            };
-        }
-        else if (saving.value) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.InProgress,
-            };
-        }
-        else if (!form.value.phone.number || !form.value.phone.country) {
-            return {
-                type: exports.OrderCheckoutResultType.Validation,
-                reason: exports.OrderCheckoutResultReason.PhoneRequired,
-            };
-        }
-        else if (!form.value.first_name) {
-            return {
-                type: exports.OrderCheckoutResultType.Validation,
-                reason: exports.OrderCheckoutResultReason.FirstNameRequired,
-            };
-        }
-        saving.value = true;
-        try {
-            await api.setOrderCheckoutCustomer(credentials.value, form.value);
-            emit('completed');
-            return {
-                type: exports.OrderCheckoutResultType.Completed,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.ApiError,
-                error: api.getApiError(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, callback) => {
-    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);
-        }
-        if (typeof callback === 'function') {
-            callback(type, result);
-        }
-        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(exports.AddressFormValueError.StockRequired);
-        }
-    }
-    else if (form.method === 'on_premise') {
-        if (form.on_premise.stock_id) {
-            data.stock_id = form.on_premise.stock_id;
-        }
-        else {
-            errors.push(exports.AddressFormValueError.StockRequired);
-        }
-        if (form.on_premise.table) {
-            data.on_premise = { table: form.on_premise.table };
-        }
-        else {
-            errors.push(exports.AddressFormValueError.TableRequired);
-        }
-    }
-    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 {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.OrderNotReady,
-            };
-        }
-        else if (saving.value) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.InProgress,
-            };
-        }
-        const { data, errors } = getDeliveryPayload(form.value, addressesResolver.value);
-        if (errors.length > 0) {
-            return {
-                type: exports.OrderCheckoutResultType.Validation,
-                reason: exports.OrderCheckoutResultReason.AddressError,
-                data: errors,
-            };
-        }
-        saving.value = true;
-        try {
-            await api.setOrderCheckoutDelivery(credentials.value, data);
-            emit('completed');
-            return {
-                type: exports.OrderCheckoutResultType.Completed,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.ApiError,
-                error: api.getApiError(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 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) => ({
-            value: amount,
-            type: exports.BillSuggestionType.Bill,
-        }));
-        bills.unshift({
-            type: exports.BillSuggestionType.NoChange,
-            value: '',
-        });
-        bills.push({
-            type: exports.BillSuggestionType.Custom,
-            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);
-            }
-        }
-        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 {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.OrderNotReady,
-            };
-        }
-        else if (saving.value) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.InProgress,
-            };
-        }
-        const payments = getPaymentsPayload(form.value);
-        try {
-            await api.setOrderCheckoutPayment(credentials.value, { payments });
-            emit('completed');
-            return {
-                type: exports.OrderCheckoutResultType.Completed,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.ApiError,
-                error: api.getApiError(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 {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.OrderNotReady,
-            };
-        }
-        else if (saving.value) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.InProgress,
-            };
-        }
-        const payload = {
-            notes: form.value.notes,
-        };
-        if (hasPersonsCount.value && form.value.persons_count) {
-            payload.persons_count = form.value.persons_count;
-        }
-        saving.value = true;
-        try {
-            const response = await api.checkoutOrder(credentials.value, payload);
-            if (response.confirmation.required) {
-                emit('confirmation', {
-                    credentials: credentials.value,
-                    method: response.confirmation.method,
-                });
-            }
-            else {
-                emit('completed', response);
-            }
-            if (store.value && city.value) {
-                await orderStore.recreate(store.value.id, city.value.id);
-            }
-            return {
-                type: exports.OrderCheckoutResultType.Completed,
-            };
-        }
-        catch (e) {
-            return {
-                type: exports.OrderCheckoutResultType.Failed,
-                reason: exports.OrderCheckoutResultReason.ApiError,
-                error: api.getApiError(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 () => {
-        modifiersHash.value = await recalculate(selectedModifiers);
-    });
-    return {
-        modifiers,
-        selectedModifiers,
-        modifiersHash,
-    };
-}
-
-async function recalculatePrice(variant, modifiers) {
-    if (!variant.value) {
-        return null;
-    }
-    else if (!modifiers.value.length) {
-        return null;
-    }
-    const { cityId } = 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, 'useProductItem', 'Unable to load product.'));
-}
-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, 'useProductsPricesRange', 'Unable to load product prices range.'));
-}
-
-function useFeaturesFilters(categoryId, values) {
-    const loader = useCategoryFeaturesList(categoryId);
-    const filters = vue.ref({});
-    const load = async () => {
-        await loader.load();
-        loader.items.value.forEach((feature) => {
-            filters.value[feature.alias] = values && values[feature.alias] ? values[feature.alias] : [];
-        });
-    };
-    return {
-        filters,
-        load,
-        items: loader.items,
-    };
-}
-function useFeaturesGroupsFilters(categoryId, values) {
-    const loader = useCategoryFeaturesGroupsList(categoryId);
-    const filters = vue.ref({});
-    const load = async () => {
-        await loader.load();
-        loader.items.value.forEach((container) => {
-            container.features.forEach((item) => {
-                filters.value[item.feature.alias] = values && values[item.feature.alias] ? values[item.feature.alias] : [];
-            });
-        });
-    };
-    return {
-        filters,
-        load,
-        items: loader.items,
-    };
-}
-function useProductsPricesRangeFilters(categoryId, values) {
-    const loader = useProductsPricesRange(categoryId);
-    const filters = vue.ref({
-        min: (values === null || values === void 0 ? void 0 : values.min) || '',
-        max: (values === null || values === void 0 ? void 0 : values.max) || '',
-    });
-    return {
-        filters,
-        load: async () => loader.load(),
-        range: loader.data,
-    };
-}
-
-exports.ProductsSourceType = void 0;
-(function (ProductsSourceType) {
-    ProductsSourceType["Category"] = "category";
-    ProductsSourceType["Collection"] = "collection";
-    ProductsSourceType["CategoryContext"] = "category_context";
-    ProductsSourceType["GroupContext"] = "group_context";
-    ProductsSourceType["VariantOptionContext"] = "variant_option_context";
-    ProductsSourceType["VariantOptionValueContext"] = "variant_option_value_context";
-})(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";
-})(exports.ProductsSorting || (exports.ProductsSorting = {}));
-exports.ProductsFiltersType = void 0;
-(function (ProductsFiltersType) {
-    ProductsFiltersType["Features"] = "features";
-    ProductsFiltersType["FeaturesGroups"] = "featuresGroups";
-})(exports.ProductsFiltersType || (exports.ProductsFiltersType = {}));
-
-function getSourceParams(source, promotion) {
-    if (source === null || !source.id || !source.type) {
-        return {};
-    }
-    else if (promotion !== null) {
-        return {};
-    }
-    switch (source.type) {
-        case exports.ProductsSourceType.Category:
-            return { category_id: source.id };
-        case exports.ProductsSourceType.Collection:
-            return { collection_id: source.id };
-        case exports.ProductsSourceType.CategoryContext:
-            return {
-                context_type: 'category',
-                context_id: source.id,
-            };
-        case exports.ProductsSourceType.GroupContext:
-            return {
-                context_type: 'group',
-                context_id: source.id,
-            };
-        case exports.ProductsSourceType.VariantOptionContext:
-            return {
-                context_type: 'variant_option',
-                context_id: source.id,
-            };
-        case exports.ProductsSourceType.VariantOptionValueContext:
-            return {
-                context_type: 'variant_option_value',
-                context_id: source.id,
-            };
-        default:
-            return {};
-    }
-}
-function getSortingParams(sorting) {
-    if (!sorting) {
-        return {};
-    }
-    switch (sorting) {
-        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 {};
-    }
-}
-function getFiltersParams(filters) {
-    if (typeof filters !== 'object' || !Object.keys(filters).length) {
-        return {};
-    }
-    const features = {};
-    Object.keys(filters).forEach((key) => {
-        if (Array.isArray(filters[key]) && filters[key].length > 0) {
-            features[key] = filters[key].join(',');
-        }
-    });
-    if (!Object.keys(features).length) {
-        return {};
-    }
-    return { f: features };
-}
-function getPricesFiltersParams(filters) {
-    const params = {};
-    if (filters.min) {
-        params.min_price = filters.min;
-    }
-    if (filters.max) {
-        params.max_price = filters.max;
-    }
-    return params;
-}
-function getLoaderParams(page, loader) {
-    const params = {
-        page,
-        count: loader.pagination.count,
-    };
-    if (loader.cityId) {
-        params.city_id = loader.cityId;
-    }
-    if (loader.visibility) {
-        params.visibility = loader.visibility;
-    }
-    if (loader.with) {
-        params.with = loader.with;
-    }
-    if (loader.search) {
-        params.search = loader.search;
-    }
-    if (typeof loader.promotion === 'undefined' || loader.promotion === null) {
-        return params;
-    }
-    params.promotion_reward = 'all';
-    if (!loader.promotion.context_type || !loader.promotion.context_id) {
-        return params;
-    }
-    params.context_type = loader.promotion.context_type;
-    params.context_id = loader.promotion.context_id;
-    return params;
-}
-function getProductsPaginationRequest(page, loader) {
-    if (loader.source && typeof loader.source.error !== 'undefined' && loader.source.error) {
-        return null;
-    }
-    return {
-        ...getSourceParams(loader.source, loader.promotion),
-        ...getSortingParams(loader.sorting),
-        ...getFiltersParams(loader.filters),
-        ...getPricesFiltersParams(loader.pricesFilters),
-        ...getLoaderParams(page, loader),
-    };
-}
-
-function getCategoryIdFromSource(source) {
-    if (!source || !source.type || !source.id || source.error) {
-        return null;
-    }
-    else if (source.type !== exports.ProductsSourceType.Category) {
-        return null;
-    }
-    return source.id;
-}
-function useProductsList(config, errorHandler) {
-    const productsLoader = usePaginatedLoader(api.getProducts, getApiErrorHandler(errorHandler, 'useProductsList', 'Unable to load products list.'));
-    const store = useStoreStore();
-    const cityId = vue.computed(() => store.cityId);
-    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 === 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);
-    const allowed = vue.ref(false);
-    const loader = vue.computed(() => ({
-        source: config.value.source,
-        cityId: cityId.value,
-        sorting: sorting.value,
-        search: search.value,
-        filters: filters.value,
-        pricesFilters: pricesFilters.value,
-        pagination: {
-            count: config.value.count,
-        },
-        with: config.value.with || '',
-        promotion: config.value.promotion || null,
-    }));
-    const load = async (page, reset = false, callback) => {
-        const request = getProductsPaginationRequest(page, loader.value);
-        if (request === null) {
-            allowed.value = false;
-            if (typeof callback === 'function') {
-                callback(null);
-            }
-            return;
-        }
-        allowed.value = true;
-        await productsLoader.load(request, reset);
-        if (typeof callback === 'function') {
-            callback(request);
-        }
-    };
-    const init = async (callback) => {
-        if (config.value.filtersType !== null) {
-            await loadFilters();
-        }
-        await loadPricesRange();
-        vue.watch(loader, lodashEs.debounce(async () => load(1, true, callback), 1000), {
-            deep: true,
-        });
-        await load(1, true, callback);
-    };
-    return {
-        state: productsLoader.state,
-        pagination: productsLoader.pagination,
-        items: productsLoader.items,
-        allowed,
-        filters,
-        pricesFilters,
-        sorting,
-        features,
-        search,
-        pricesRange: range,
-        init,
-        load,
-    };
-}
-function getFiltersForUrl(filters) {
-    const params = [];
-    Object.keys(filters).forEach((key) => {
-        params.push(`${key}:${filters[key]}`);
-    });
-    return params.join(';');
-}
-function getFiltersFromUrl(param) {
-    const items = param.split(';');
-    const filters = {};
-    items.forEach((item) => {
-        const [filter, value] = item.split(':');
-        if (!filter || !value) {
-            return;
-        }
-        filters[filter] = value.split(',');
-    });
-    return filters;
-}
-function getProductsListQueryParamsWithPromotion(params, promotion) {
-    if (!promotion) {
-        return params;
-    }
-    const clone = {
-        ...params,
-        promotion_id: promotion.id,
-        reward_id: promotion.reward_id,
-    };
-    if (promotion.context_type) {
-        clone.context_type = promotion.context_type;
-    }
-    if (promotion.context_id) {
-        clone.context_id = promotion.context_id;
-    }
-    return clone;
-}
-function getProductsListQueryParams(config, request) {
-    if (request === null) {
-        return getProductsListQueryParamsWithPromotion({}, config.promotion);
-    }
-    const query = {};
-    if (request.order_by && request.order_by !== config.sorting) {
-        query.order_by = request.order_by;
-    }
-    if (typeof request.f !== 'undefined' && Object.keys(request.f).length > 0) {
-        query.f = getFiltersForUrl(request.f);
-    }
-    if (request.min_price) {
-        query.min_price = request.min_price;
-    }
-    if (request.max_price) {
-        query.max_price = request.max_price;
-    }
-    if (request.search) {
-        query.search = request.search;
-    }
-    return getProductsListQueryParamsWithPromotion(query, config.promotion);
-}
-function getQueryParam(query, param) {
-    return typeof query[param] !== 'undefined' && query[param] ? query[param] : null;
-}
-function getPromotionFromQuery(query) {
-    const promotionId = getQueryParam(query, 'promotion_id');
-    const rewardId = getQueryParam(query, 'reward_id');
-    if (!promotionId || !rewardId) {
-        return null;
-    }
-    const contextType = getQueryParam(query, 'context_type');
-    const contextId = getQueryParam(query, 'context_id');
-    return {
-        id: promotionId,
-        reward_id: rewardId,
-        context_type: contextType,
-        context_id: contextId,
-    };
-}
-function getProductsListParamsFromQuery(query) {
-    if (!query) {
-        return null;
-    }
-    return {
-        sorting: typeof query.order_by !== 'undefined' ? query.order_by : null,
-        f: typeof query.f === 'string' ? getFiltersFromUrl(query.f) : null,
-        min_price: getQueryParam(query, 'min_price'),
-        max_price: getQueryParam(query, 'max_price'),
-        search: getQueryParam(query, 'search'),
-        promotion: getPromotionFromQuery(query),
-    };
-}
-
-function getInjectedSource(sourceInjection, notFoundInjection, type) {
-    const source = vue.inject(sourceInjection);
-    const notFound = vue.inject(notFoundInjection);
-    if (!source) {
-        return null;
-    }
-    else if (notFound && notFound.value) {
-        return {
-            error: true,
-        };
-    }
-    return {
-        type: type,
-        id: source.value.id,
-    };
-}
-function getProductsSource(source) {
-    if (source && source.type && source.id) {
-        return source;
-    }
-    else if (source && source.error) {
-        return null;
-    }
-    const injected = vue.inject(exports.ZenkyInjection.ProductsSource, null);
-    if (!injected) {
-        return null;
-    }
-    switch (injected) {
-        case exports.ProductsSourceType.Category:
-            return getInjectedSource(exports.ZenkyInjection.Category, exports.ZenkyInjection.CategoryNotFound, injected);
-        case exports.ProductsSourceType.Collection:
-            return getInjectedSource(exports.ZenkyInjection.Collection, exports.ZenkyInjection.CollectionNotFound, injected);
-        case exports.ProductsSourceType.CategoryContext:
-            return getInjectedSource(exports.ZenkyInjection.CategoryContext, exports.ZenkyInjection.CategoryContextNotFound, injected);
-        case exports.ProductsSourceType.GroupContext:
-            return getInjectedSource(exports.ZenkyInjection.GroupContext, exports.ZenkyInjection.GroupContextNotFound, injected);
-        case exports.ProductsSourceType.VariantOptionContext:
-            return getInjectedSource(exports.ZenkyInjection.VariantOptionContext, exports.ZenkyInjection.VariantOptionContextNotFound, injected);
-        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";
-    ZenkyWebsocketEvent["OrderMustBeReloaded"] = "orders.reload";
-    ZenkyWebsocketEvent["OrderRewardsMustBeReloaded"] = "orders.rewards.reload";
-    ZenkyWebsocketEvent["DisplayOrderRewardsSelection"] = "orders.rewards.display_selection";
-    ZenkyWebsocketEvent["PromotionsNotFound"] = "orders.promotions.not_found";
-})(exports.ZenkyWebsocketEvent || (exports.ZenkyWebsocketEvent = {}));
-
-let instance = null;
-function createWebsocketsConnection(store) {
-    if (instance !== null) {
-        return instance;
-    }
-    else if (typeof store.settings === 'undefined' || store.settings === null) {
-        throw new Error('You must provide store with settings.');
-    }
-    else if (typeof store.settings.websockets === 'undefined' || store.settings.websockets === null) {
-        throw new Error('You must provide store with websockets settings.');
-    }
-    instance = new Pusher__default["default"](store.settings.websockets.app_key, {
-        wsHost: store.settings.websockets.options.host,
-        wsPort: store.settings.websockets.options.port,
-        forceTLS: false,
-        enableStats: false,
-        enabledTransports: ['ws', 'wss'],
-    });
-    return instance;
-}
-function getWebsocketsConnection() {
-    if (instance === null) {
-        throw new Error('You must create websockets connection using [createWebsocketsConnection] function.');
-    }
-    return instance;
-}
-function subscribeToOrderEvents(order) {
-    if (instance === null) {
-        throw new Error('You must create websocket connection using `createWebsocketConnection` function!');
-    }
-    const channel = instance.subscribe(`orders.${order.id}.${order.token}`);
-    channel.bind(exports.ZenkyWebsocketEvent.OrderPriceRecalculated, (data) => {
-        events.useOrderPriceRecalculated().publish({ order, data });
-    });
-    channel.bind(exports.ZenkyWebsocketEvent.OrderMustBeReloaded, () => {
-        events.useOrderShouldBeReloaded().publish({ order });
-    });
-    channel.bind(exports.ZenkyWebsocketEvent.OrderRewardsMustBeReloaded, () => {
-        events.useOrderPromotionRewardsShouldBeReloaded().publish({ order });
-    });
-    channel.bind(exports.ZenkyWebsocketEvent.DisplayOrderRewardsSelection, (data) => {
-        events.useDisplayOrderPromotionRewardSelection().publish({ order, data });
-        events.usePromotionsCheckerCompleted().publish();
-    });
-    channel.bind(exports.ZenkyWebsocketEvent.PromotionsNotFound, () => {
-        events.useOrderPromotionsNotFound().publish({ order });
-        events.usePromotionsCheckerCompleted().publish();
-    });
-    events.useOrderSubmitted().subscribe('websockets.subscribe', ({ order: submittedOrder }) => {
-        if (instance === null) {
-            throw new Error('You must create websocket connection using `createWebsocketConnection` function!');
-        }
-        instance.unsubscribe(`orders.${submittedOrder.id}.${submittedOrder.token}`);
-    });
-}
-
-exports.createStorage = createStorage;
-exports.createWebsocketsConnection = createWebsocketsConnection;
-exports.getAddressForm = getAddressForm;
-exports.getApiErrorHandler = getApiErrorHandler;
-exports.getExistedAddress = getExistedAddress;
-exports.getExistedAddressDisplayValue = getExistedAddressDisplayValue;
-exports.getFirstMedium = getFirstMedium;
-exports.getProductVariantsPricesRange = getProductVariantsPricesRange;
-exports.getProductsListParamsFromQuery = getProductsListParamsFromQuery;
-exports.getProductsListQueryParams = getProductsListQueryParams;
-exports.getProductsPaginationRequest = getProductsPaginationRequest;
-exports.getProductsSource = getProductsSource;
-exports.getSelectedAddress = getSelectedAddress;
-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;
-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;
-exports.useFlatCategoriesTree = useFlatCategoriesTree;
-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;